Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

feat(rexctl): add launch check runner and .env checks

Hampusbe08fbbf5883
diff --git a/fluxer_rexctl/internal/checks/checks.go b/fluxer_rexctl/internal/checks/checks.go
new file mode 100644
index 000000000..91b93ff74
--- /dev/null
+++ b/fluxer_rexctl/internal/checks/checks.go
@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package checks
+
+import (
+ "context"
+ "sort"
+ "strings"
+
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/adminapi"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"
+)
+
+type Status string
+
+const (
+ Pass Status = "pass"
+ Warn Status = "warn"
+ Fail Status = "fail"
+ Skip Status = "skip"
+)
+
+type Phase int
+
+const (
+ Preinstall Phase = 1 << iota
+ Installed
+)
+
+type Result struct {
+ ID string `json:"id"`
+ Status Status `json:"status"`
+ Message string `json:"message"`
+ Fix string `json:"fix,omitempty"`
+ Fixable bool `json:"fixable"`
+ Fixed bool `json:"fixed"`
+ Manual string `json:"-"`
+ Details []string `json:"-"`
+}
+
+type Env struct {
+ Dir string
+ Domain string
+ Instance *instance.Instance
+ Engine *engine.Engine
+ Project *engine.Project
+ Host *host.Info
+ Behind bool
+ Bind string
+ Admin *adminapi.Client
+ Settings map[string]string
+
+ phase Phase
+ prepared bool
+ engineErr error
+ loadErr error
+ env map[string]string
+ staged map[string]*string
+ stagedSecrets map[string]string
+ stagedAdmin map[string]string
+ importEnv bool
+ stagedBy []string
+ keptEdits [][2]string
+ publicIP string
+ publicErr error
+ publicDone bool
+ ps []engine.Container
+ psErr error
+ psDone bool
+}
+
+type Check struct {
+ ID string
+ Phases Phase
+ Run func(ctx context.Context, env *Env) Result
+ Fix func(ctx context.Context, env *Env) error
+ SafeFix bool
+}
+
+var order = []string{
+ "engine",
+ "podman-subids",
+ "podman-setup",
+ "windows-linux-containers",
+ "memory",
+ "disk",
+ "ports",
+ "low-ports",
+ "dns",
+ "env-file",
+ "stack-files",
+ "stack-edits",
+ "pending-change",
+ "upgrade-unfinished",
+ "boot-unit",
+ "origin",
+ "vapid",
+ "services",
+ "stale-containers",
+ "health",
+ "certificate",
+ "discovery",
+ "app-proxy-discovery",
+ "postgres-password",
+ "postgres-scram",
+ "livekit-ip",
+ "client-ip",
+ "backup-age",
+}
+
+var registry = map[string]Check{}
+
+func Register(c Check) {
+ if _, dup := registry[c.ID]; dup {
+ panic("checks: duplicate id " + c.ID)
+ }
+ registry[c.ID] = c
+}
+
+func rank(id string) int {
+ for i, o := range order {
+ if o == id {
+ return i
+ }
+ }
+ return len(order)
+}
+
+func All() []Check {
+ out := make([]Check, 0, len(registry))
+ for _, c := range registry {
+ out = append(out, c)
+ }
+ sort.Slice(out, func(i, j int) bool {
+ ri, rj := rank(out[i].ID), rank(out[j].ID)
+ if ri != rj {
+ return ri < rj
+ }
+ return out[i].ID < out[j].ID
+ })
+ return out
+}
+
+func Get(id string) (Check, bool) {
+ c, ok := registry[id]
+ return c, ok
+}
+
+func Run(ctx context.Context, env *Env, phase Phase) []Result {
+ env.phase = phase
+ env.prepare(ctx)
+ env.reset()
+ out := []Result{}
+ for _, c := range All() {
+ if c.Phases&phase == 0 {
+ continue
+ }
+ out = append(out, RunOne(ctx, env, c))
+ }
+ return out
+}
+
+func RunOne(ctx context.Context, env *Env, c Check) Result {
+ if env.phase == 0 {
+ env.phase = c.Phases
+ }
+ env.prepare(ctx)
+ r := c.Run(ctx, env)
+ r.ID = c.ID
+ if env.phase&Installed == 0 {
+ r.Fix = strings.Replace(r.Fix, "then run rexctl doctor.", "then run rexctl install.", 1)
+ }
+ r.Fixable = r.Fixable && c.Fix != nil && (r.Status == Warn || r.Status == Fail)
+ return r
+}
+
+func Recheck(ctx context.Context, env *Env, c Check) Result {
+ env.reset()
+ return RunOne(ctx, env, c)
+}
+
+func RunIn(ctx context.Context, env *Env, phase Phase, c Check) Result {
+ env.phase = phase
+ return RunOne(ctx, env, c)
+}
+
+func ApplyFix(ctx context.Context, env *Env, id string) (Result, error) {
+ c, ok := registry[id]
+ if !ok || c.Fix == nil {
+ return Result{}, ErrNoFix
+ }
+ before := env.stagedCount()
+ if err := c.Fix(ctx, env); err != nil {
+ return Result{}, err
+ }
+ if env.stagedCount() != before {
+ env.stagedBy = append(env.stagedBy, id)
+ }
+ env.reset()
+ r := RunOne(ctx, env, c)
+ r.Fixable = true
+ r.Fixed = r.Status == Pass || r.Status == Skip
+ return r, nil
+}
+
+func Failed(results []Result) bool {
+ for _, r := range results {
+ if r.Status == Fail {
+ return true
+ }
+ }
+ return false
+}
+
+func AllGood(results []Result) bool {
+ for _, r := range results {
+ if r.Status == Fail || r.Status == Warn {
+ return false
+ }
+ }
+ return true
+}
diff --git a/fluxer_rexctl/internal/checks/env.go b/fluxer_rexctl/internal/checks/env.go
new file mode 100644
index 000000000..627a7487d
--- /dev/null
+++ b/fluxer_rexctl/internal/checks/env.go
@@ -0,0 +1,424 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package checks
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "fmt"
+ "maps"
+ "math"
+ "net"
+ "os"
+ "os/exec"
+ "runtime"
+ "strings"
+ "time"
+
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/deploy"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/settings"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
+)
+
+var ErrNoFix = errors.New("checks: this check has no fix")
+
+const defaultBind = "127.0.0.1:8080"
+
+type edgeMode int
+
+const (
+ modeBundled edgeMode = iota
+ modeProxy
+ modeTunnel
+)
+
+func (e *Env) prepare(ctx context.Context) {
+ if e.prepared {
+ return
+ }
+ e.prepared = true
+ if e.Instance != nil {
+ if e.Dir == "" {
+ e.Dir = e.Instance.Dir
+ }
+ if e.Domain == "" {
+ e.Domain = e.value("FLUXER_DOMAIN")
+ }
+ if e.Bind == "" {
+ e.Bind = e.value("FLUXER_EDGE_BIND")
+ }
+ }
+ if e.Bind == "" {
+ e.Bind = defaultBind
+ }
+ if e.Engine == nil && e.engineErr == nil {
+ opts := engine.ConnectOptions{AllowOld: true}
+ if st := e.state(); st != nil {
+ opts.Host, opts.ID, opts.Prefer = st.Engine.Host, st.Engine.ID, engine.Kind(st.Engine.Kind)
+ }
+ e.Engine, e.engineErr = engine.Connect(ctx, opts)
+ }
+ if e.Project == nil && e.Engine != nil && e.Instance != nil && e.Instance.Project() != "" {
+ p, err := deploy.Load(ctx, e.Instance, e.Engine)
+ if err != nil {
+ e.loadErr = err
+ p = e.Engine.Named(e.Instance.Project(), e.Instance.Dir)
+ }
+ e.Project = p
+ }
+ if e.Host == nil {
+ if info, err := host.Detect(ctx, e.Dir); err == nil {
+ e.Host = info
+ }
+ }
+}
+
+func (e *Env) SetEngine(en *engine.Engine, err error) {
+ e.Engine, e.engineErr = en, err
+}
+
+func (e *Env) reset() {
+ e.ps, e.psErr, e.psDone = nil, nil, false
+}
+
+func (e *Env) state() *instance.State {
+ if e.Instance == nil {
+ return nil
+ }
+ return e.Instance.State
+}
+
+func (e *Env) effective() map[string]string {
+ if e.env != nil {
+ return e.env
+ }
+ e.env = map[string]string{}
+ st := e.state()
+ if st == nil {
+ return e.env
+ }
+ set, err := e.Instance.Set()
+ if err != nil {
+ return e.env
+ }
+ chosen := maps.Clone(st.Settings)
+ for k, v := range e.staged {
+ if v == nil {
+ delete(chosen, k)
+ } else {
+ chosen[k] = *v
+ }
+ }
+ secrets := maps.Clone(st.Secrets)
+ maps.Copy(secrets, e.stagedSecrets)
+ admin := map[string]string{}
+ if st.AdminImport != nil {
+ maps.Copy(admin, st.AdminImport.Values)
+ }
+ maps.Copy(admin, e.stagedAdmin)
+ if env, err := settings.Effective(set, chosen, secrets, admin); err == nil {
+ e.env = env
+ }
+ return e.env
+}
+
+func (e *Env) setting(key string) string {
+ if v, ok := e.staged[key]; ok {
+ if v == nil {
+ return ""
+ }
+ return *v
+ }
+ if st := e.state(); st != nil {
+ return st.Settings[key]
+ }
+ return ""
+}
+
+func (e *Env) value(key string) string {
+ v, _ := e.lookup(key)
+ return strings.TrimSpace(v)
+}
+
+func (e *Env) lookup(key string) (string, bool) {
+ if v, ok := e.Settings[key]; ok {
+ return v, true
+ }
+ v, ok := e.effective()[key]
+ return v, ok
+}
+
+func (e *Env) stage(key string, value *string) {
+ if e.staged == nil {
+ e.staged = map[string]*string{}
+ }
+ e.staged[key] = value
+ e.env = nil
+}
+
+func (e *Env) stageSecret(key, value string) {
+ if e.stagedSecrets == nil {
+ e.stagedSecrets = map[string]string{}
+ }
+ e.stagedSecrets[key] = value
+ e.env = nil
+}
+
+func (e *Env) stageAdmin(key, value string) {
+ if e.stagedAdmin == nil {
+ e.stagedAdmin = map[string]string{}
+ }
+ e.stagedAdmin[key] = value
+ e.env = nil
+}
+
+func (e *Env) stagedCount() int {
+ n := len(e.staged) + len(e.stagedSecrets) + len(e.stagedAdmin)
+ if e.importEnv {
+ n++
+ }
+ return n
+}
+
+func (e *Env) Staged() bool { return e.stagedCount() > 0 }
+
+func (e *Env) StagedBy() []string { return e.stagedBy }
+
+func Commit(ctx context.Context, e *Env, o deploy.ApplyOptions) error {
+ if !e.Staged() {
+ return nil
+ }
+ if e.Instance == nil || e.Instance.State == nil || e.Engine == nil {
+ return errNoProject
+ }
+ st := e.Instance.State
+ staged, secrets, admin, importEnv := e.staged, e.stagedSecrets, e.stagedAdmin, e.importEnv
+ e.staged, e.stagedSecrets, e.stagedAdmin, e.importEnv, e.stagedBy = nil, nil, nil, false, nil
+ e.env = nil
+ envPath := e.Instance.Path(instance.EnvFileName)
+ aside := e.Instance.Path(instance.StateDirName, "env.import")
+ if importEnv {
+ if err := os.Rename(envPath, aside); err != nil && !errors.Is(err, os.ErrNotExist) {
+ return err
+ }
+ }
+ done := false
+ defer func() {
+ if !importEnv {
+ return
+ }
+ if done {
+ _ = os.Remove(aside)
+ } else {
+ _ = os.Rename(aside, envPath)
+ }
+ }()
+ if len(secrets) > 0 || len(admin) > 0 {
+ maps.Copy(st.Secrets, secrets)
+ if len(admin) > 0 {
+ if st.AdminImport == nil {
+ st.AdminImport = &instance.AdminImport{}
+ }
+ if st.AdminImport.Values == nil {
+ st.AdminImport.Values = map[string]string{}
+ }
+ maps.Copy(st.AdminImport.Values, admin)
+ st.AdminImport.SentAt = ""
+ }
+ if err := e.Instance.Save(); err != nil {
+ return err
+ }
+ }
+ var err error
+ if len(staged) > 0 {
+ _, err = deploy.Set(ctx, e.Instance, e.Engine, staged, o)
+ } else {
+ _, err = deploy.Apply(ctx, e.Instance, e.Engine, o)
+ }
+ if err != nil {
+ return err
+ }
+ done = true
+ e.Project = nil
+ e.prepared = false
+ e.prepare(ctx)
+ e.reset()
+ return nil
+}
+
+func (e *Env) ports() []stack.Port {
+ return stack.Ports(map[string]string{
+ stack.VoiceTCPPortKey: e.value(stack.VoiceTCPPortKey),
+ stack.VoiceUDPPortKey: e.value(stack.VoiceUDPPortKey),
+ })
+}
+
+func (e *Env) mode() edgeMode {
+ if e.state() != nil {
+ switch e.setting(settings.EdgeMode) {
+ case settings.EdgeTunnel:
+ return modeTunnel
+ case settings.EdgeProxy:
+ return modeProxy
+ }
+ }
+ if e.Behind {
+ return modeProxy
+ }
+ return modeBundled
+}
+
+func (e *Env) installed() bool { return e.phase&Installed != 0 }
+
+func (e *Env) podmanSocketOff() bool {
+ if runtime.GOOS != "linux" || e.Engine != nil || engine.ClassOf(e.engineErr) != engine.ClassUnreachable {
+ return false
+ }
+ if _, err := exec.LookPath("podman"); err != nil {
+ return false
+ }
+ if st := e.state(); st != nil && st.Engine.Kind != "" {
+ return st.Engine.Kind == string(engine.Podman)
+ }
+ _, err := exec.LookPath("docker")
+ return err != nil
+}
+
+func (e *Env) rootless() bool {
+ if e.Engine != nil {
+ return e.Engine.Rootless
+ }
+ return e.podmanSocketOff() && os.Geteuid() != 0
+}
+
+func (e *Env) podman() bool {
+ return (e.Engine != nil && e.Engine.Kind == engine.Podman) || e.podmanSocketOff()
+}
+
+func (e *Env) reconnect(ctx context.Context) {
+ e.Engine, e.engineErr, e.Project, e.loadErr = nil, nil, nil, nil
+ e.prepared = false
+ e.prepare(ctx)
+}
+
+func (e *Env) engineName() string {
+ if e.podman() {
+ return "Podman"
+ }
+ if e.Engine == nil && e.state() != nil && e.state().Engine.Kind == string(engine.Podman) {
+ return "Podman"
+ }
+ return "Docker"
+}
+
+func (e *Env) containers(ctx context.Context) ([]engine.Container, error) {
+ if e.psDone {
+ return e.ps, e.psErr
+ }
+ e.psDone = true
+ if e.Project == nil {
+ e.psErr = errNoProject
+ return nil, e.psErr
+ }
+ e.ps, e.psErr = e.Project.PS(ctx)
+ return e.ps, e.psErr
+}
+
+var errNoProject = errors.New("checks: no instance or container engine")
+
+func (e *Env) running(ctx context.Context, service string) bool {
+ cs, err := e.containers(ctx)
+ if err != nil {
+ return false
+ }
+ for _, c := range cs {
+ if c.Service == service && c.State == "running" {
+ return true
+ }
+ }
+ return false
+}
+
+func (e *Env) exec(ctx context.Context, service, stdin string, command ...string) (string, error) {
+ if e.Project == nil {
+ return "", errNoProject
+ }
+ ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+ defer cancel()
+ var out, errOut bytes.Buffer
+ opts := engine.ExecOptions{Stdout: &out, Stderr: &errOut}
+ if stdin != "" {
+ opts.Stdin = strings.NewReader(stdin)
+ }
+ err := e.Project.Exec(ctx, service, opts, command...)
+ combined := strings.TrimSpace(out.String() + "\n" + errOut.String())
+ return combined, err
+}
+
+func (e *Env) publicAddress(ctx context.Context) (string, error) {
+ if !e.publicDone {
+ e.publicDone = true
+ e.publicIP, e.publicErr = host.PublicIP(ctx)
+ }
+ return e.publicIP, e.publicErr
+}
+
+func privateDomain(domain string) bool {
+ d := strings.ToLower(strings.TrimSuffix(domain, "."))
+ if d == "" || d == "localhost" || !strings.Contains(d, ".") {
+ return true
+ }
+ if net.ParseIP(d) != nil {
+ return true
+ }
+ for _, suffix := range []string{".localhost", ".local", ".test", ".internal", ".lan", ".home.arpa", ".example", ".invalid"} {
+ if strings.HasSuffix(d, suffix) {
+ return true
+ }
+ }
+ return false
+}
+
+func gb(bytes uint64) string {
+ return fmt.Sprintf("%d GB", int(math.Round(float64(bytes)/(1<<30))))
+}
+
+func day(t time.Time) string { return t.Local().Format("2 January") }
+
+func Services(names []string, one, many string) string {
+ switch {
+ case len(names) == 1:
+ return names[0] + " " + one
+ case len(names) <= 3:
+ return strings.Join(names[:len(names)-1], ", ") + " and " + names[len(names)-1] + " " + many
+ }
+ return fmt.Sprintf("%d services %s", len(names), many)
+}
+
+func pass(msg string) Result { return Result{Status: Pass, Message: msg} }
+
+func skip(msg string) Result { return Result{Status: Skip, Message: msg} }
+
+func warn(msg, fix string) Result { return Result{Status: Warn, Message: msg, Fix: fix} }
+
+func fail(msg, fix string) Result { return Result{Status: Fail, Message: msg, Fix: fix} }
+
+func fixable(r Result) Result {
+ r.Fixable = true
+ return r
+}
+
+func (e *Env) up(ctx context.Context) error {
+ if e.Instance == nil || e.Engine == nil {
+ return errNoProject
+ }
+ if e.loadErr != nil {
+ return e.loadErr
+ }
+ _, err := deploy.Apply(ctx, e.Instance, e.Engine, deploy.ApplyOptions{})
+ return err
+}