package crypticnet import ( "context" "cryptic-net/tarutil" "cryptic-net/yamlutil" "errors" "fmt" "io/fs" "os" "os/signal" "path/filepath" "sync" "syscall" "github.com/adrg/xdg" ) // Names of various environment variables which get set by the entrypoint. const ( DaemonYmlPathEnvVar = "_DAEMON_YML_PATH" BootstrapPathEnvVar = "_BOOTSTRAP_PATH" RuntimeDirPathEnvVar = "_RUNTIME_DIR_PATH" DataDirPathEnvVar = "_DATA_DIR_PATH" ) // Env contains the values of environment variables, as well as other entities // which are useful across all processes. type Env struct { Context context.Context AppDirPath string DaemonYmlPath string RuntimeDirPath string DataDirPath string // If NewEnv is called with bootstrapOptional, and a bootstrap file is not // found, then these fields will not be set. BootstrapPath string BootstrapFS fs.FS Hosts map[string]Host HostName string thisDaemon DaemonYml thisDaemonOnce sync.Once } func getAppDirPath() string { appDirPath := os.Getenv("APPDIR") if appDirPath == "" { appDirPath = "." } return appDirPath } // NewEnv calculates an Env instance based on the APPDIR and XDG envvars. // // If bootstrapOptional is true then NewEnv will first check if a bootstrap file // can be found in the expected places, and if not then it will not populate // BootstrapFS or any other fields based on it. func NewEnv(bootstrapOptional bool) (*Env, error) { runtimeDirPath := filepath.Join(xdg.RuntimeDir, "cryptic-net") appDirPath := getAppDirPath() env := &Env{ AppDirPath: appDirPath, DaemonYmlPath: filepath.Join(runtimeDirPath, "daemon.yml"), RuntimeDirPath: runtimeDirPath, DataDirPath: filepath.Join(xdg.DataHome, "cryptic-net"), } return env, env.init(bootstrapOptional) } // ReadEnv reads an Env from the process's environment variables, rather than // calculating like NewEnv does. func ReadEnv() (*Env, error) { var err error readEnv := func(key string) string { if err != nil { return "" } val := os.Getenv(key) if val == "" { err = fmt.Errorf("envvar %q not set", key) } return val } env := &Env{ AppDirPath: getAppDirPath(), DaemonYmlPath: readEnv(DaemonYmlPathEnvVar), RuntimeDirPath: readEnv(RuntimeDirPathEnvVar), DataDirPath: readEnv(DataDirPathEnvVar), } if err != nil { return nil, err } return env, env.init(false) } // DataDirBootstrapPath returns the path to the bootstrap file within the user's // data dir. If the file does not exist there it will be found in the AppDirPath // by ReloadBootstrap. func (e *Env) DataDirBootstrapPath() string { return filepath.Join(e.DataDirPath, "bootstrap.tgz") } // LoadBootstrap sets BootstrapPath to the given value, and loads BootstrapFS // and all derived fields based on that. func (e *Env) LoadBootstrap(path string) error { var ( err error // load all values into temp variables before setting the fields on Env, // so we don't leave it in an inconsistent state. bootstrapFS fs.FS hosts map[string]Host hostNameB []byte ) if bootstrapFS, err = tarutil.FSFromTGZFile(path); err != nil { return fmt.Errorf("reading bootstrap file at %q: %w", e.BootstrapPath, err) } if hosts, err = LoadHosts(bootstrapFS); err != nil { return fmt.Errorf("loading hosts info from bootstrap fs: %w", err) } if hostNameB, err = fs.ReadFile(bootstrapFS, "hostname"); err != nil { return fmt.Errorf("loading hostname from bootstrap fs: %w", err) } e.BootstrapPath = path e.BootstrapFS = bootstrapFS e.Hosts = hosts e.HostName = string(hostNameB) return nil } func (e *Env) initBootstrap(bootstrapOptional bool) error { exists := func(path string) (bool, error) { if _, err := os.Stat(path); errors.Is(err, fs.ErrNotExist) { return false, nil } else if err != nil { return false, fmt.Errorf("stat'ing %q: %w", path, err) } return true, nil } // start by checking if a bootstrap can be found in the user's data // directory. This will only not be the case if daemon has never been // successfully started. { bootstrapPath := e.DataDirBootstrapPath() if exists, err := exists(bootstrapPath); err != nil { return fmt.Errorf("determining if %q exists: %w", bootstrapPath, err) } else if exists { return e.LoadBootstrap(bootstrapPath) } } // fallback to checking within the AppDir for a bootstrap which has been // embedded into the binary. { bootstrapPath := filepath.Join(e.AppDirPath, "share/bootstrap.tgz") if exists, err := exists(bootstrapPath); err != nil { return fmt.Errorf("determining if %q exists: %w", bootstrapPath, err) } else if !exists && !bootstrapOptional { return fmt.Errorf("boostrap file not found at %q", bootstrapPath) } else if exists { return e.LoadBootstrap(bootstrapPath) } } return nil } func (e *Env) init(bootstrapOptional bool) error { var cancel context.CancelFunc e.Context, cancel = context.WithCancel(context.Background()) signalCh := make(chan os.Signal, 2) signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM) go func() { sig := <-signalCh cancel() fmt.Fprintf(os.Stderr, "got signal %v, will exit gracefully\n", sig) sig = <-signalCh fmt.Fprintf(os.Stderr, "second interrupt signal %v received, force quitting, there may be zombie children left behind, good luck!\n", sig) os.Stderr.Sync() os.Exit(1) }() if err := e.initBootstrap(bootstrapOptional); err != nil { return fmt.Errorf("initializing bootstrap data: %w", err) } return nil } // ThisHost is a shortcut for returning env.Hosts[env.HostName]. func (e *Env) ThisHost() Host { return e.Hosts[e.HostName] } // ToMap returns the Env as a map of key/value strings. If this map is set into // a process's environment, then that process can read it back using ReadEnv. func (e *Env) ToMap() map[string]string { return map[string]string{ DaemonYmlPathEnvVar: e.DaemonYmlPath, BootstrapPathEnvVar: e.BootstrapPath, RuntimeDirPathEnvVar: e.RuntimeDirPath, DataDirPathEnvVar: e.DataDirPath, } } // ThisDaemon returns the DaemonYml (loaded from DaemonYmlPath) for the // currently running process. func (e *Env) ThisDaemon() DaemonYml { e.thisDaemonOnce.Do(func() { if err := yamlutil.LoadYamlFile(&e.thisDaemon, e.DaemonYmlPath); err != nil { panic(err) } }) return e.thisDaemon } // BinPath returns the absolute path to a binary in the AppDir. func (e *Env) BinPath(name string) string { return filepath.Join(e.AppDirPath, "bin", name) }