func main()

in go/cmd/aggregate-known/aggregate-known.go [124:245]
96 lines of code
17 McCabe index (conditional complexity)

func main() {
	ctconfig.Init()

	ctx := context.Background()
	ctx, cancelMain := context.WithCancel(ctx)

	// Try to handle SIGINT and SIGTERM gracefully
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	defer close(sigChan)
	go func() {
		sig := <-sigChan
		glog.Infof("Signal caught: %s..", sig)
		cancelMain()
		signal.Stop(sigChan) // Restore default behavior
	}()

	certDB, cache := engine.GetConfiguredStorage(ctx, ctconfig, false)
	defer glog.Flush()

	checkPathArg(*enrolledpath, "enrolledpath", ctconfig)
	checkPathArg(*knownpath, "knownpath", ctconfig)
	checkPathArg(*ctlogspath, "ctlogspath", ctconfig)

	if err := os.MkdirAll(*knownpath, permModeDir); err != nil {
		glog.Fatalf("Unable to make the output directory: %s", err)
	}

	engine.PrepareTelemetry("aggregate-known", ctconfig)

	mozIssuers := rootprogram.NewMozillaIssuers()
	if err := mozIssuers.LoadEnrolledIssuers(*enrolledpath); err != nil {
		glog.Fatalf("Failed to load enrolled issuers from disk: %s", err)
	}

	glog.Infof("%d issuers loaded", len(mozIssuers.GetIssuers()))

	glog.Infof("Committing DB changes since last run")
	commitToken, err := cache.AcquireCommitLock()
	if err != nil || commitToken == nil {
		glog.Fatalf("Failed to acquire commit lock: %s", err)
	}
	defer cache.ReleaseCommitLock(*commitToken)

	err = certDB.Commit(*commitToken)
	if err != nil {
		glog.Fatalf("Error in commit: %s", err)
	}

	logList, err := certDB.GetCTLogsFromStorage()
	if err != nil {
		glog.Fatalf("Error reading coverage metadata: %s", err)
	}

	ctLogFD, err := os.OpenFile(*ctlogspath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		glog.Fatalf("Error opening %s: %s", *ctlogspath, err)
	}

	enc := json.NewEncoder(ctLogFD)
	if err := enc.Encode(logList); err != nil {
		glog.Fatalf("Error marshaling ct-logs list %s: %s", *ctlogspath, err)
	}
	ctLogFD.Close()

	glog.Infof("Listing issuers and their expiration dates...")
	issuerList, err := certDB.GetIssuerAndDatesFromStorage()
	if err != nil {
		glog.Fatal(err)
	}

	var count int64
	for _, iObj := range issuerList {
		if mozIssuers.IsIssuerInProgram(iObj.Issuer) {
			count = count + int64(len(iObj.ExpDates))
		}
	}

	workChan := make(chan knownWorkUnit, count)
	for _, iObj := range issuerList {
		if !mozIssuers.IsIssuerInProgram(iObj.Issuer) {
			continue
		}

		issuerSubj, err := mozIssuers.GetSubjectForIssuer(iObj.Issuer)
		if err != nil {
			glog.Warningf("Couldn't get subject for issuer=%s that is in the root program: %s",
				iObj.Issuer.ID(), err)
			issuerSubj = "<unknown>"
		}

		wu := knownWorkUnit{
			issuer:   iObj.Issuer,
			issuerDN: issuerSubj,
			expDates: iObj.ExpDates,
		}

		select {
		case workChan <- wu:
		default:
			glog.Fatalf("Channel overflow. Aborting at %+v", wu)
		}
	}
	// Signal that was the last work
	close(workChan)

	glog.Infof("Starting worker processes to handle %d work units", count)

	var wg sync.WaitGroup

	// Start the workers
	for t := 0; t < *ctconfig.NumThreads; t++ {
		wg.Add(1)
		worker := knownWorker{
			savePath: *knownpath,
			certDB:   certDB,
		}
		go worker.run(ctx, &wg, workChan)
	}

	wg.Wait()
}