func newScheduler()

in lib/torrent/scheduler/scheduler.go [115:190]
64 lines of code
8 McCabe index (conditional complexity)

func newScheduler(
	config Config,
	ta storage.TorrentArchive,
	stats tally.Scope,
	pctx core.PeerContext,
	announceClient announceclient.Client,
	netevents networkevent.Producer,
	options ...option) (*scheduler, error) {

	config = config.applyDefaults()

	logger, err := log.New(config.Log, nil)
	if err != nil {
		return nil, fmt.Errorf("log: %s", err)
	}
	slogger := logger.Sugar()

	done := make(chan struct{})

	stats = stats.Tagged(map[string]string{
		"module": "scheduler",
	})

	overrides := schedOverrides{
		clock:     clock.New(),
		eventLoop: newEventLoop(),
	}
	for _, opt := range options {
		opt(&overrides)
	}

	eventLoop := liftEventLoop(overrides.eventLoop)

	var preemptionTick <-chan time.Time
	if !config.DisablePreemption {
		preemptionTick = overrides.clock.Tick(config.PreemptionInterval)
	}

	handshaker, err := conn.NewHandshaker(
		config.Conn, stats, overrides.clock, netevents, pctx.PeerID, eventLoop, slogger)
	if err != nil {
		return nil, fmt.Errorf("conn: %s", err)
	}

	tlog, err := torrentlog.New(config.TorrentLog, pctx)
	if err != nil {
		return nil, fmt.Errorf("torrentlog: %s", err)
	}

	s := &scheduler{
		pctx:           pctx,
		config:         config,
		clock:          overrides.clock,
		torrentArchive: ta,
		stats:          stats,
		handshaker:     handshaker,
		eventLoop:      eventLoop,
		preemptionTick: preemptionTick,
		emitStatsTick:  overrides.clock.Tick(config.EmitStatsInterval),
		announceClient: announceClient,
		announcer:      announcer.Default(announceClient, eventLoop, overrides.clock, slogger),
		netevents:      netevents,
		torrentlog:     tlog,
		logger:         slogger,
		done:           done,
	}

	if config.DisablePreemption {
		s.log().Warn("Preemption disabled")
	}
	if config.ConnState.DisableBlacklist {
		s.log().Warn("Blacklisting disabled")
	}

	return s, nil
}