func main()

in src/main.go [38:123]
54 lines of code
11 McCabe index (conditional complexity)

func main() {
	cfg := config{}
	cfg.configure()

	// Initialize empty resource manager cache with maxTTL
	// Note that the cache is unlikely to live this long when executed in some environments.
	// e.g. Cloud Run (with --min-instances 0) is likely to regularly dispose the serving
	// instances. The maxTTL setting helps with executing this service on long-lived
	// infrastructure, where it is required to eventually refreshed the cache entries.
	cache := &statequery.Cache{}
	cache.Initialize(time.Hour)

	ctx := context.Background()

	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		// Always respond with JSON
		w.Header().Set("Content-Type", "application/json")

		log.Println("starting analysis")

		// Start from a clean slate and track state
		state := statequery.State{}

		// Retrieve all BQ reservations from current (admin) project
		err := state.RetrieveReservations(ctx, cfg.project, cfg.locations)
		if err != nil {
			log.Fatalf("failed to retrieve reservations: %v\n", err)
		}

		// Abort if no reservations have been found
		if len(state.Reservations) == 0 {
			json.NewEncoder(w).Encode(state)
			return
		}

		// Retrieve all assignments for each reservation
		err = state.RetrieveAssignments(ctx, cfg.project, cache)
		if err != nil {
			log.Fatalf("failed to retrieve assignments: %v\n", err)
		}

		// Retrieve info for all running jobs from projects with reservations
		err = state.RetrieveJobs(ctx)
		if err != nil {
			log.Fatalf("failed to retrieve jobs: %v\n", err)
		}

		// Compute utilization totals
		state.ComputeUtilization(cfg.threshold)

		err = state.DumpState(ctx, cfg.bucket)
		if err != nil {
			log.Fatalf("failed to dump state: %v\n", err)
		}

		// Abort if no reservation is breaching its threshold
		alert := false
		for _, reservation := range state.Reservations {
			if reservation.ThresholdBreached {
				alert = true
			}
		}
		if !alert {
			json.NewEncoder(w).Encode(state)
			return
		}

		// Render message from template
		message, err := state.RenderMessage()
		if err != nil {
			log.Fatalf("failed to render message: %v\n", err)
		}

		// Push rendered message to all defined chat webhooks
		err = statequery.SendMessage(cfg.hooks(), message)
		if err != nil {
			log.Fatalf("failed to send message: %v\n", err)
		}

		// Encode state to HTTP response
		json.NewEncoder(w).Encode(state)
	})

	log.Println("listening for connections")
	http.ListenAndServe(fmt.Sprintf(":%s", cfg.port), nil)
}