func runAgent()

in google_guest_agent/main.go [155:264]
78 lines of code
16 McCabe index (conditional complexity)

func runAgent(ctx context.Context) {
	opts := logger.LogOpts{LoggerName: programName}

	if !cfg.Get().Core.CloudLoggingEnabled {
		opts.DisableCloudLogging = true
	}

	if runtime.GOOS == "windows" {
		opts.FormatFunction = logFormatWindows
		opts.Writers = []io.Writer{&utils.SerialPort{Port: "COM1"}}
	} else {
		opts.FormatFunction = logFormat
		opts.Writers = []io.Writer{os.Stdout}
		// Local logging is syslog; we will just use stdout in Linux.
		opts.DisableLocalLogging = true
	}

	if os.Getenv("GUEST_AGENT_DEBUG") != "" {
		opts.Debug = true
	}

	if err := logger.Init(ctx, opts); err != nil {
		fmt.Printf("Error initializing logger: %v", err)
		os.Exit(1)
	}

	// Try flushing logs before exiting, if not flushed logs could go missing.
	defer logger.Close()

	logger.Infof("GCE Agent Started (version %s)", version)

	osInfo = osinfo.Get()
	mdsClient = metadata.New()

	agentInit(ctx)

	if cfg.Get().Unstable.CommandMonitorEnabled {
		command.Init(ctx)
		defer command.Close()
	}

	// Previous request to metadata *may* not have worked becasue routes don't get added until agentInit.
	var err error
	if newMetadata == nil {
		// Error here doesn't matter, if we cant get metadata, we cant record telemetry.
		newMetadata, err = mdsClient.Get(ctx)
		if err != nil {
			logger.Debugf("Error getting metdata: %v", err)
		}
	}

	// Try to re-initialize logger now, we know after agentInit() is more likely to have metadata available.
	// TODO: move all this metadata dependent code to its own metadata event handler.
	if newMetadata != nil {
		opts.ProjectName = newMetadata.Project.ProjectID
		opts.MIG = newMetadata.Instance.Attributes.CreatedBy
		if err := logger.Init(ctx, opts); err != nil {
			logger.Errorf("Error initializing logger: %v", err)
		}
	}

	// knownJobs is list of default jobs that run on a pre-defined schedule.
	knownJobs := []scheduler.Job{telemetry.New(mdsClient, programName, version)}
	scheduler.ScheduleJobs(ctx, knownJobs, false)

	eventManager := events.Get()
	if err := eventManager.AddDefaultWatchers(ctx); err != nil {
		logger.Errorf("Error initializing event manager: %v", err)
		return
	}

	if err := enableDisableOSLoginCertAuth(ctx); err != nil {
		logger.Errorf("Failed to enable sshtrustedca watcher: %+v", err)
		return
	}

	oldMetadata = &metadata.Descriptor{}
	eventManager.Subscribe(mdsEvent.LongpollEvent, nil, func(ctx context.Context, evType string, data interface{}, evData *events.EventData) bool {
		logger.Debugf("Handling metadata %q event.", evType)

		// If metadata watcher failed there isn't much we can do, just ignore the event and
		// allow the watcher to get it corrected.
		if evData.Error != nil {
			logger.Infof("Metadata event watcher failed, ignoring: %+v", evData.Error)
			return true
		}

		if evData.Data == nil {
			logger.Infof("Metadata event watcher didn't pass in the metadata, ignoring.")
			return true
		}

		newMetadata = evData.Data.(*metadata.Descriptor)

		if err := enableDisableOSLoginCertAuth(ctx); err != nil {
			logger.Errorf("Failed to enable/disable sshtrustedca watcher: %+v", err)
		}

		runUpdate(ctx)
		oldMetadata = newMetadata

		return true
	})

	if err := eventManager.Run(ctx); err != nil {
		logger.Fatalf("Failed to run event manager: %+v", err)
	}

	logger.Infof("GCE Agent Stopped")
}