// NewChecker creates a new Checker with the given isolated client.
// maxConcurrent controls maximum number of check requests to be in-flight at once.
// The provided context is used to make all requests to the isolate server.
496714
func NewChecker(ctx context.Context, client *isolatedclient.Client, maxConcurrent int) *BundlingChecker {
	return newChecker(ctx, client, maxConcurrent)
}
501256
func (s *UpdateMaintenanceWindowTaskInput) SetMaxConcurrency(v string) *UpdateMaintenanceWindowTaskInput {
	s.MaxConcurrency = &v
	return s
}
1174669
func (s *CreateAssociationInput) SetMaxConcurrency(v string) *CreateAssociationInput {
	s.MaxConcurrency = &v
	return s
}
829397
func NewHealthChecker(trans string) HealthChecker {
	switch trans {
	case transport.DNS, transport.TLS:
		c := new(dns.Client)
		c.Net = "udp"
		c.ReadTimeout = 1 * time.Second
		c.WriteTimeout = 1 * time.Second

		return &dnsHc{c: c}
	}

	log.Warningf("No healthchecker for transport %q", trans)
	return nil
}
1159416
func (m *MockContext) LeadershipChecker() (leadership.Checker, error) {
	ret := m.ctrl.Call(m, "LeadershipChecker")
	ret0, _ := ret[0].(leadership.Checker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
172106
func NewUpdateChecker(updater *Updater, ctx Context, tickDuration time.Duration, log Log) UpdateChecker {
	return UpdateChecker{
		updater:      updater,
		ctx:          ctx,
		log:          log,
		tickDuration: tickDuration,
	}
}
956188
func NewPingChecker(ip net.IP) *PingChecker {
	proto := seesaw.IPProtoICMP
	if ip.To4() == nil {
		proto = seesaw.IPProtoICMPv6
	}
	id := nextPingCheckerID
	nextPingCheckerID++
	return &PingChecker{
		Target: Target{
			IP:    ip,
			Proto: proto,
		},
		ID: id,
	}
}
493845
func NewConstraintChecker(ctx Context, constraints []*structs.Constraint) *ConstraintChecker {
	return &ConstraintChecker{
		ctx:         ctx,
		constraints: constraints,
	}
}
453488
func NewRefCounter(c Checker) *RefCounter {
	return &RefCounter{
		checker: c,
		counts:  make(map[string]*minfo),
	}
}
673390
func NewChecksummedReader(delegate io.ReadSeeker, interval int, newHash func() hash.Hash32) ChecksummedReader {
	return newChecksummedReaderImpl(delegate, interval, newHash)
}
270401
func mapConcurrent(fn func(Observer), requestNotifiers []Observer) {
	var wg sync.WaitGroup
	wg.Add(len(requestNotifiers))
	defer wg.Wait()

	for _, n := range requestNotifiers {
		go func(notifier Observer) {
			defer wg.Done()
			fn(notifier)
		}(n)
	}
}
710153
func (s *GetMaintenanceWindowTaskOutput) SetMaxConcurrency(v string) *GetMaintenanceWindowTaskOutput {
	s.MaxConcurrency = &v
	return s
}
1098552
func HasConcurrency(ctx context.Context) bool {
	iv, ok := ctx.Value(ctxKeyConcurrency).(int)
	if iv <= 1 {
		return false
	}
	return ok
}
429550
func NewGrantCheck(check GrantChecker, handler GrantHandler, errorHandler GrantErrorHandler) osinserver.AuthorizeHandler {
	return &GrantCheck{check, handler, errorHandler}
}
197276
func (s *AssociationVersionInfo) SetMaxConcurrency(v string) *AssociationVersionInfo {
	s.MaxConcurrency = &v
	return s
}
472623
func NewUploader(ctx context.Context, client *isolatedclient.Client, maxConcurrent int) *ConcurrentUploader {
	return newUploader(ctx, client, maxConcurrent)
}
1235796
func (s *SendCommandInput) SetMaxConcurrency(v string) *SendCommandInput {
	s.MaxConcurrency = &v
	return s
}