func Main()

in lib/notifiers/notifiers.go [184:295]
84 lines of code
18 McCabe index (conditional complexity)

func Main(notifier Notifier) error {
	// TODO(ljr): Refactor/separate this flagged logic from the main logic via a Main/doMain refactor.
	ctx := context.Background()

	if !flag.Parsed() {
		flag.Parse()
	}
	if *smoketest {
		log.V(0).Infof("notifier smoketest: %T", notifier)
		return nil
	}

	if *setupCheck {
		log.V(2).Info("starting setup check")
		cfg, err := decodeConfig(os.Stdin)
		if err != nil {
			return fmt.Errorf("failed to decode YAML config from stdin: %w", err)
		}

		if out, err := yaml.Marshal(cfg); err != nil {
			log.Warningf("failed to re-encode config YAML: %v", err)
		} else {
			log.V(2).Infof("got re-encoded YAML from stdin:\n%s", string(out))
		}

		if err := validateConfig(cfg); err != nil {
			return fmt.Errorf("failed to validate config during setup check: %w", err)
		}

		br, err := newResolver(cfg)
		if err != nil {
			return fmt.Errorf("failed to create BindingResolver during setup check: %w", err)
		}

		if err := notifier.SetUp(ctx, cfg, "", new(setupCheckSecretGetter), br); err != nil {
			return fmt.Errorf("failed to run notifier.SetUp during setup check: %w", err)
		}

		log.V(2).Infof("setup check successful")
		return nil
	}

	cfgPath, ok := GetEnv("CONFIG_PATH")
	if !ok {
		return errors.New("expected CONFIG_PATH to be non-empty")
	}

	sc, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create new GCS client: %w", err)
	}
	defer sc.Close()

	smc, err := secretmanager.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create new SecretManager client: %w", err)
	}
	defer smc.Close()

	cfg, err := getGCSConfig(ctx, &actualGCSReaderFactory{sc}, cfgPath)
	if err != nil {
		return fmt.Errorf("failed to get config from GCS: %w", err)
	}

	if err := validateConfig(cfg); err != nil {
		return fmt.Errorf("got invalid config from path %q: %w", cfgPath, err)
	}
	log.V(2).Infof("got config from GCS (%q): %+v\n", cfgPath, cfg)

	tmpl, err := parseTemplate(ctx, cfg.Spec.Notification.Template, &actualGCSReaderFactory{sc})
	if err != nil {
		return fmt.Errorf("failed to parse template from notiifer spec %q: %w", cfg.Spec.Notification.Template, err)
	}

	sm := &actualSecretManager{client: smc}

	br, err := newResolver(cfg)
	if err != nil {
		return fmt.Errorf("failed to construct a binding resolver: %v", err)
	}

	if err := notifier.SetUp(ctx, cfg, tmpl, sm, br); err != nil {
		return fmt.Errorf("failed to call SetUp on notifier: %w", err)
	}

	_, ignoreBadMessages := GetEnv("IGNORE_BAD_MESSAGES")

	log.V(2).Infoln("starting HTTP server...")

	// Our Pub/Sub push receiver.
	http.HandleFunc("/", newReceiver(notifier, &receiverParams{ignoreBadMessages}))

	// An auxilliary, healthz-style receiver.
	// You can call this endpoint using the curl command here:
	// https://cloud.google.com/run/docs/triggering/https-request#creating_private_services.
	startTime := time.Now()
	http.HandleFunc("/helloz", func(w http.ResponseWriter, _ *http.Request) {
		fmt.Fprintf(w, "Greetings from a Google Cloud Build notifier: %T!\nStart Time: %s\nCurrent Time: %s\n",
			notifier, startTime.Format(time.RFC1123), time.Now().Format(time.RFC1123))
	})

	var port string
	if p, ok := GetEnv("PORT"); ok {
		port = p
	} else {
		log.Warningf("PORT environment variable was not present, using %s instead", defaultHTTPPort)
		port = defaultHTTPPort
	}

	// Block on the HTTP's health.
	return http.ListenAndServe(":"+port, nil)
}