refactor: Set up env config

README.md

@@ -116,9 +116,11 @@ pnpm start
 
 ```sh
 export N8N_LAUNCHER_LOG_LEVEL=debug
-export N8N_RUNNERS_N8N_URI=...        # e.g. http://127.0.0.1:5679
 export N8N_MAIN_URI=...               # e.g. http://127.0.0.1:5678
+export N8N_RUNNERS_N8N_URI=...        # e.g. http://127.0.0.1:5679
+export N8N_RUNNER_URI=...             # e.g. http://127.0.0.1:5680
 export N8N_RUNNERS_AUTH_TOKEN=...     # i.e. same string as in step 4
+export N8N_RUNNERS_SERVER_ENABLED=true
 
 make run
 ```

internal/commands/launch.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"strconv"
 	"task-runner-launcher/internal/auth"
 	"task-runner-launcher/internal/config"
 	"task-runner-launcher/internal/env"
@@ -16,45 +15,27 @@ type LaunchCommand struct {
 	RunnerType string
 }
 
-const idleTimeoutEnvVar = "N8N_RUNNERS_AUTO_SHUTDOWN_TIMEOUT"
-const defaultIdleTimeoutValue = "15" // seconds
-
 func (l *LaunchCommand) Execute() error {
 	logs.Info("Starting to execute `launch` command")
 
-	authToken := os.Getenv("N8N_RUNNERS_AUTH_TOKEN")
-	n8nRunnerServerURI := os.Getenv("N8N_RUNNERS_N8N_URI")
-	n8nMainServerURI := os.Getenv("N8N_MAIN_URI")
-	idleTimeout := os.Getenv(idleTimeoutEnvVar)
-
-	if authToken == "" || n8nRunnerServerURI == "" {
-		return fmt.Errorf("both N8N_RUNNERS_AUTH_TOKEN and N8N_RUNNERS_N8N_URI are required")
-	}
-
-	if n8nMainServerURI == "" {
-		return fmt.Errorf("N8N_MAIN_URI is required")
-	}
+	// 0. validate env vars
 
-	if idleTimeout == "" {
-		os.Setenv(idleTimeoutEnvVar, defaultIdleTimeoutValue)
-	} else {
-		idleTimeoutInt, err := strconv.Atoi(idleTimeout)
-		if err != nil || idleTimeoutInt < 0 {
-			return fmt.Errorf("%s must be a non-negative integer", idleTimeoutEnvVar)
-		}
+	envCfg, err := env.FromEnv()
+	if err != nil {
+		return fmt.Errorf("env vars failed validation: %w", err)
 	}
 
 	// 1. read configuration
 
-	cfg, err := config.ReadConfig()
+	fileCfg, err := config.ReadConfig()
 	if err != nil {
-		logs.Errorf("Error reading config: %v", err)
+		logs.Errorf("Error reading config file: %v", err)
 		return err
 	}
 
 	var runnerConfig config.TaskRunnerConfig
 	found := false
-	for _, r := range cfg.TaskRunners {
+	for _, r := range fileCfg.TaskRunners {
 		if r.RunnerType == l.RunnerType {
 			runnerConfig = r
 			found = true
@@ -66,12 +47,12 @@ func (l *LaunchCommand) Execute() error {
 		return fmt.Errorf("config file does not contain requested runner type: %s", l.RunnerType)
 	}
 
-	cfgNum := len(cfg.TaskRunners)
+	taskRunnersNum := len(fileCfg.TaskRunners)
 
-	if cfgNum == 1 {
+	if taskRunnersNum == 1 {
 		logs.Debug("Loaded config file loaded with a single runner config")
 	} else {
-		logs.Debugf("Loaded config file with %d runner configs", cfgNum)
+		logs.Debugf("Loaded config file with %d runner configs", taskRunnersNum)
 	}
 
 	// 2. change into working directory
@@ -84,22 +65,22 @@ func (l *LaunchCommand) Execute() error {
 
 	// 3. filter environment variables
 
-	defaultEnvs := []string{"LANG", "PATH", "TZ", "TERM", idleTimeoutEnvVar}
+	defaultEnvs := []string{"LANG", "PATH", "TZ", "TERM", env.EnvVarIdleTimeout, env.EnvVarRunnerServerEnabled}
 	allowedEnvs := append(defaultEnvs, runnerConfig.AllowedEnv...)
 	runnerEnv := env.AllowedOnly(allowedEnvs)
 
 	logs.Debugf("Filtered environment variables")
 
 	// 4. wait for n8n instance to be ready
 
-	if err := http.WaitForN8nReady(n8nMainServerURI); err != nil {
+	if err := http.WaitForN8nReady(envCfg.MainServerURI); err != nil {
 		return fmt.Errorf("encountered error while waiting for n8n to be ready: %w", err)
 	}
 
 	for {
 		// 5. fetch grant token for launcher
 
-		launcherGrantToken, err := auth.FetchGrantToken(n8nRunnerServerURI, authToken)
+		launcherGrantToken, err := auth.FetchGrantToken(envCfg.MainRunnerServerURI, envCfg.AuthToken)
 		if err != nil {
 			return fmt.Errorf("failed to fetch grant token for launcher: %w", err)
 		}
@@ -110,7 +91,7 @@ func (l *LaunchCommand) Execute() error {
 
 		handshakeCfg := auth.HandshakeConfig{
 			TaskType:   l.RunnerType,
-			N8nURI:     n8nRunnerServerURI,
+			N8nURI:     envCfg.MainRunnerServerURI,
 			GrantToken: launcherGrantToken,
 		}
 
@@ -120,7 +101,7 @@ func (l *LaunchCommand) Execute() error {
 
 		// 7. fetch grant token for runner
 
-		runnerGrantToken, err := auth.FetchGrantToken(n8nRunnerServerURI, authToken)
+		runnerGrantToken, err := auth.FetchGrantToken(envCfg.MainRunnerServerURI, envCfg.AuthToken)
 		if err != nil {
 			return fmt.Errorf("failed to fetch grant token for runner: %w", err)
 		}
@@ -149,6 +130,6 @@ func (l *LaunchCommand) Execute() error {
 		}
 
 		// next runner will need to fetch a new grant token
-		runnerEnv = env.Clear(runnerEnv, "N8N_RUNNERS_GRANT_TOKEN")
+		runnerEnv = env.Clear(runnerEnv, env.EnvVarGrantToken)
 	}
 }

internal/env/env.go

@@ -1,10 +1,61 @@
 package env
 
 import (
+	"errors"
+	"fmt"
 	"os"
+	"strconv"
 	"strings"
 )
 
+const (
+	// ------------------------
+	//          auth
+	// ------------------------
+
+	// EnvVarAuthToken is the env var for the auth token sent by the launcher to
+	// the main instance in exchange for a single-use grant token.
+	// nolint:gosec // G101: False positive
+	EnvVarAuthToken = "N8N_RUNNERS_AUTH_TOKEN"
+
+	// EnvVarGrantToken is the env var for the single-use grant token returned by
+	// the main instance to the launcher in exchange for the auth token.
+	// nolint:gosec // G101: False positive
+	EnvVarGrantToken = "N8N_RUNNERS_GRANT_TOKEN"
+
+	// ------------------------
+	//        n8n main
+	// ------------------------
+
+	// EnvVarMainServerURI is the env var for the URI of the n8n main instance's
+	// main server.
+	EnvVarMainServerURI = "N8N_MAIN_URI"
+
+	// EnvVarMainRunnerServerURI is the env var for the URI of the n8n main
+	// instance's runner server. Do not confuse with `N8N_RUNNER_URI`.
+	EnvVarMainRunnerServerURI = "N8N_RUNNERS_N8N_URI"
+
+	// ------------------------
+	//         runner
+	// ------------------------
+
+	// EnvVarRunnerServerURI is the env var for the URI of the runner's server. Do not
+	// confuse with `N8N_RUNNERS_N8N_URI`.
+	EnvVarRunnerServerURI = "N8N_RUNNER_URI"
+
+	// EnvVarRunnerServerEnabled is the env var for whether the runner's health
+	// check server should be started.
+	EnvVarRunnerServerEnabled = "N8N_RUNNERS_SERVER_ENABLED"
+
+	// EnvVarIdleTimeout is the env var for how long (in seconds) a runner may be
+	// idle for before exit.
+	EnvVarIdleTimeout = "N8N_RUNNERS_AUTO_SHUTDOWN_TIMEOUT"
+)
+
+const (
+	defaultIdleTimeoutValue = "15" // seconds
+)
+
 // AllowedOnly filters the current environment down to only those
 // environment variables in the allow list.
 func AllowedOnly(allowed []string) []string {
@@ -50,3 +101,60 @@ func Clear(envVars []string, envVarName string) []string {
 
 	return result
 }
+
+// Config holds validated environment variable values.
+type Config struct {
+	AuthToken           string
+	MainServerURI       string
+	MainRunnerServerURI string
+	RunnerServerURI     string
+	RunnerServerEnabled bool
+	IdleTimeout         int
+}
+
+// FromEnv retrieves vars from the environment, validates their values, and
+// returns a Config holding the validated values, or a slice of errors.
+func FromEnv() (*Config, error) {
+	var errs []error
+
+	authToken := os.Getenv(EnvVarAuthToken)
+	mainServerURI := os.Getenv(EnvVarMainServerURI)
+	mainRunnerServerURI := os.Getenv(EnvVarMainRunnerServerURI)
+	runnerServerURI := os.Getenv(EnvVarRunnerServerURI)
+	runnerServerEnabled := os.Getenv(EnvVarRunnerServerEnabled)
+	idleTimeout := os.Getenv(EnvVarIdleTimeout)
+
+	if authToken == "" {
+		errs = append(errs, fmt.Errorf("%s is required", EnvVarAuthToken))
+	}
+	if mainRunnerServerURI == "" {
+		errs = append(errs, fmt.Errorf("%s is required", EnvVarMainRunnerServerURI))
+	}
+	if mainServerURI == "" {
+		errs = append(errs, fmt.Errorf("%s is required", EnvVarMainServerURI))
+	}
+	if runnerServerEnabled != "true" {
+		errs = append(errs, fmt.Errorf("%s is required to be 'true'", EnvVarRunnerServerEnabled))
+	}
+
+	if idleTimeout == "" {
+		os.Setenv(EnvVarIdleTimeout, defaultIdleTimeoutValue)
+	} else {
+		idleTimeoutInt, err := strconv.Atoi(idleTimeout)
+		if err != nil || idleTimeoutInt < 0 {
+			errs = append(errs, fmt.Errorf("%s must be a non-negative integer", EnvVarIdleTimeout))
+		}
+	}
+
+	if len(errs) > 0 {
+		return nil, errors.Join(errs...)
+	}
+
+	return &Config{
+		AuthToken:           authToken,
+		MainServerURI:       mainServerURI,
+		MainRunnerServerURI: mainRunnerServerURI,
+		RunnerServerURI:     runnerServerURI,
+		RunnerServerEnabled: true,
+	}, nil
+}