A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
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.gonew file mode 100644index 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.gonew file mode 100644index 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+}