func Run()

in agent/cmd/cmd.go [103:243]
120 lines of code
24 McCabe index (conditional complexity)

func Run(flags *Flags, opts ...Option) {
	if flags.PeerPort == 0 {
		panic("must specify non-zero peer port")
	}
	if flags.AgentServerPort == 0 {
		panic("must specify non-zero agent server port")
	}
	if flags.AgentRegistryPort == 0 {
		panic("must specify non-zero agent registry port")
	}

	var overrides options
	for _, o := range opts {
		o(&overrides)
	}

	var config Config
	if overrides.config != nil {
		config = *overrides.config
	} else {
		if err := configutil.Load(flags.ConfigFile, &config); err != nil {
			panic(err)
		}
		if flags.SecretsFile != "" {
			if err := configutil.Load(flags.SecretsFile, &config); err != nil {
				panic(err)
			}
		}
	}

	if overrides.logger != nil {
		log.SetGlobalLogger(overrides.logger.Sugar())
	} else {
		zlog := log.ConfigureLogger(config.ZapLogging)
		defer zlog.Sync()
	}

	stats := overrides.metrics
	if stats == nil {
		s, closer, err := metrics.New(config.Metrics, flags.KrakenCluster)
		if err != nil {
			log.Fatalf("Failed to init metrics: %s", err)
		}
		stats = s
		defer closer.Close()
	}

	go metrics.EmitVersion(stats)

	if flags.PeerIP == "" {
		localIP, err := netutil.GetLocalIP()
		if err != nil {
			log.Fatalf("Error getting local ip: %s", err)
		}
		flags.PeerIP = localIP
	}

	pctx, err := core.NewPeerContext(
		config.PeerIDFactory, flags.Zone, flags.KrakenCluster, flags.PeerIP, flags.PeerPort, false)
	if err != nil {
		log.Fatalf("Failed to create peer context: %s", err)
	}

	cads, err := store.NewCADownloadStore(config.CADownloadStore, stats)
	if err != nil {
		log.Fatalf("Failed to create local store: %s", err)
	}

	netevents, err := networkevent.NewProducer(config.NetworkEvent)
	if err != nil {
		log.Fatalf("Failed to create network event producer: %s", err)
	}

	trackers, err := config.Tracker.Build()
	if err != nil {
		log.Fatalf("Error building tracker upstream: %s", err)
	}
	go trackers.Monitor(nil)

	tls, err := config.TLS.BuildClient()
	if err != nil {
		log.Fatalf("Error building client tls config: %s", err)
	}

	announceClient := announceclient.New(pctx, trackers, tls)
	sched, err := scheduler.NewAgentScheduler(
		config.Scheduler, stats, pctx, cads, netevents, trackers, announceClient, tls)
	if err != nil {
		log.Fatalf("Error creating scheduler: %s", err)
	}

	buildIndexes, err := config.BuildIndex.Build()
	if err != nil {
		log.Fatalf("Error building build-index upstream: %s", err)
	}

	tagClient := tagclient.NewClusterClient(buildIndexes, tls)

	transferer := transfer.NewReadOnlyTransferer(stats, cads, tagClient, sched)

	registry, err := config.Registry.Build(config.Registry.ReadOnlyParameters(transferer, cads, stats))
	if err != nil {
		log.Fatalf("Failed to init registry: %s", err)
	}

	registryAddr := fmt.Sprintf("127.0.0.1:%d", flags.AgentRegistryPort)
	containerRuntimeCfg := config.ContainerRuntime
	dockerdaemonCfg := dockerdaemon.Config{}
	if config.DockerDaemon != dockerdaemonCfg {
		log.Warn("please move docker config under \"container_runtime\"")
		containerRuntimeCfg.Docker = config.DockerDaemon
	}
	containerRuntimeFactory, err := containerruntime.NewFactory(containerRuntimeCfg, registryAddr)
	if err != nil {
		log.Fatalf("Failed to create container runtime factory: %s", err)
	}

	agentServer := agentserver.New(
		config.AgentServer, stats, cads, sched, tagClient, announceClient, containerRuntimeFactory)
	addr := fmt.Sprintf(":%d", flags.AgentServerPort)
	log.Infof("Starting agent server on %s", addr)
	go func() {
		log.Fatal(http.ListenAndServe(addr, agentServer.Handler()))
	}()

	log.Info("Starting registry...")
	go func() {
		log.Fatal(registry.ListenAndServe())
	}()

	go heartbeat(stats)

	log.Fatal(nginx.Run(config.Nginx, map[string]interface{}{
		"allowed_cidrs": config.AllowedCidrs,
		"port":          flags.AgentRegistryPort,
		"registry_server": nginx.GetServer(
			config.Registry.Docker.HTTP.Net, config.Registry.Docker.HTTP.Addr),
		"agent_server":    fmt.Sprintf("127.0.0.1:%d", flags.AgentServerPort),
		"registry_backup": config.RegistryBackup},
		nginx.WithTLS(config.TLS)))
}