A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(rexctl): load empty custom services and always log upgrades (#3707)
Hampus9fb347f364ca
diff --git a/fluxer_rexctl/cmd/upgrade.go b/fluxer_rexctl/cmd/upgrade.goindex c97be1aa7..9f33a4f9e 100644--- a/fluxer_rexctl/cmd/upgrade.go+++ b/fluxer_rexctl/cmd/upgrade.go@@ -11,6 +11,7 @@ import ("os""path/filepath""runtime"+ "runtime/debug""slices""strings""time"@@ -208,7 +209,7 @@ func runUpgrade(ctx context.Context, app *App, f *upgradeFlags) error {if err := setPhase(inst, cur, rel.Version, release.PhaseResolved); err != nil {return err}- return upgradeStack(ctx, app, inst, e, f)+ return guardedUpgradeStack(ctx, app, inst, e, f)})}asset, err := rel.AssetFor(runtime.GOOS, runtime.GOARCH)@@ -438,7 +439,7 @@ func runUpgradeCheck(ctx context.Context, app *App, f *upgradeFlags) error {}if inst != nil && inst.State.FailedRelease == rel.Version {fix := "Run rexctl logs api to see why before you try again."- if log := inst.Path(instance.StateDirName, "upgrade-"+release.DirName(rel.Version)+".log"); fileExists(log) {+ if log := inst.Path(instance.StateDirName, upgradeLog(rel.Version)); fileExists(log) {fix = fmt.Sprintf("Read %s to see why before you try again.", log)}app.UI.Warn(fmt.Sprintf("The last upgrade to Fluxer %s didn't start.", to), fix)@@ -501,10 +502,47 @@ func resumeUpgrade(ctx context.Context, app *App, f *upgradeFlags) error {if err := refreshBootUnit(ctx, inst, e, nil); err != nil {app.UI.Detail("%v", err)}- return upgradeStack(ctx, app, inst, e, f)+ return guardedUpgradeStack(ctx, app, inst, e, f)})}+func guardedUpgradeStack(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, f *upgradeFlags) (err error) {+ defer guardUpgrade(inst, inst.State.Upgrade.To, &err)+ return upgradeStack(ctx, app, inst, e, f)+}++func guardUpgrade(inst *instance.Instance, to string, err *error) {+ r := recover()+ if r == nil {+ return+ }+ fix := "Run rexctl upgrade --verbose to see why."+ if inst.State.Upgrade != nil {+ fix = release.UnfinishedFix(inst.State.Upgrade)+ }+ if logPath := writeUpgradeText(inst, to, fmt.Sprintf("rexctl: %v\n\n%s", r, debug.Stack())); logPath != "" {+ fix = fmt.Sprintf("Read %s to see why. %s", logPath, fix)+ }+ *err = ui.Wrap(fmt.Errorf("%v", r), fmt.Sprintf("The upgrade to Fluxer %s stopped because rexctl hit a bug.", release.Short(to)), fix)+}++func writeUpgradeText(inst *instance.Instance, to, text string) string {+ path := inst.Path(instance.StateDirName, upgradeLog(to))+ flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC+ if loggedThisAttempt(inst, to) {+ flag = os.O_CREATE | os.O_WRONLY | os.O_APPEND+ }+ f, err := os.OpenFile(path, flag, 0o600)+ if err != nil {+ return ""+ }+ defer f.Close()+ if _, err := f.WriteString(text); err != nil {+ return ""+ }+ return path+}+func printUpgradePlan(ctx context.Context, app *App, inst *instance.Instance, f *upgradeFlags, needSelf bool, from, version string) {_, to := versionPair(from, version)if needSelf {@@ -704,7 +742,7 @@ func upgradeStack(ctx context.Context, app *App, inst *instance.Instance, e *engerr := backUpForUpgrade(ctx, app, inst, old, upgradeScope(f))if err != nil {fix := "Run rexctl backup to see why, then run rexctl upgrade again."- if logPath := writeBackupLog(inst, "upgrade-"+release.DirName(to)+".log", err); logPath != "" {+ if logPath := writeBackupLog(inst, upgradeLog(to), err); logPath != "" {fix = fmt.Sprintf("Read %s to see why, then run rexctl upgrade again.", logPath)}report := ui.Wrap(err, fmt.Sprintf("Couldn't back up your instance. %s is still running.", capitalise(fluxerName(fromShort))), fix)@@ -713,7 +751,7 @@ func upgradeStack(ctx context.Context, app *App, inst *instance.Instance, e *engreport.Msg = be.Msg + " " + capitalise(fluxerName(fromShort)) + " is still running."report.Fix = be.Fix}- return abortUpgrade(ctx, app, inst, e, err, report)+ return abandonUpgrade(ctx, app, inst, e, err, report)}if err := setPhase(inst, from, to, release.PhaseBackedUp); err != nil {return err@@ -879,7 +917,7 @@ func retryUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *engreturn ctx.Err()}fix := release.UnfinishedFix(pend)- if logPath := writeFailureLog(ctx, inst, p, "upgrade-"+release.DirName(pend.To)+".log", err, waiting); logPath != "" {+ if logPath := writeFailureLog(ctx, inst, p, upgradeLog(pend.To), err, waiting); logPath != "" {fix = fmt.Sprintf("Read %s to see why. %s", logPath, fix)}return ui.Wrap(err, fmt.Sprintf("Fluxer %s didn't start either.", toShort), fix)@@ -1093,7 +1131,7 @@ func failedStart(ctx context.Context, app *App, inst *instance.Instance, e *engi}app.UI.Fail(msg, "")app.UI.Detail("%v", cause)- logPath := writeFailureLog(ctx, inst, p, "upgrade-"+release.DirName(pend.To)+".log", cause, waiting)+ logPath := writeFailureLog(ctx, inst, p, upgradeLog(pend.To), cause, waiting)if err := goBack(ctx, app, inst, e, pend.From); err != nil {return err}@@ -1162,7 +1200,25 @@ func notRunning(ctx context.Context, p *engine.Project) []string {return out}+func upgradeLog(to string) string {+ return "upgrade-" + release.DirName(to) + ".log"+}++func loggedThisAttempt(inst *instance.Instance, to string) bool {+ pend := inst.State.Upgrade+ if pend == nil || pend.To != to || pend.StartedAt.IsZero() {+ return false+ }+ info, err := os.Stat(inst.Path(instance.StateDirName, upgradeLog(to)))+ return err == nil && !info.ModTime().Before(pend.StartedAt)+}+func abortUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, cause, report error) error {+ writeFailureLog(ctx, inst, e.Named(inst.Project(), inst.Dir), upgradeLog(inst.State.Upgrade.To), cause, nil)+ return abandonUpgrade(ctx, app, inst, e, cause, report)+}++func abandonUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, cause, report error) error {pend := inst.State.Upgradeapp.UI.Detail("%v", cause)if err := goBack(ctx, app, inst, e, pend.From); err != nil {@@ -1309,12 +1365,21 @@ func finishUpgrade(ctx context.Context, app *App, inst *instance.Instance, e *enreturn nil}-func recoverUpgrade(ctx context.Context, app *App, inst *instance.Instance, forward bool) error {+func recoverUpgrade(ctx context.Context, app *App, inst *instance.Instance, forward bool) (err error) {pend := inst.State.Upgradeif pend == nil {return nil}+ defer guardUpgrade(inst, pend.To, &err)phase := phaseIndex(pend.Phase)+ if phase >= phaseIndex(release.PhasePulled) && phase < phaseIndex(release.PhaseVerified) && !loggedThisAttempt(inst, pend.To) {+ cause := fmt.Errorf("the upgrade stopped after the %s step and didn't finish", pend.Phase)+ if e, err := app.Engine(ctx, inst); err == nil {+ writeFailureLog(ctx, inst, e.Named(inst.Project(), inst.Dir), upgradeLog(pend.To), cause, nil)+ } else {+ writeUpgradeText(inst, pend.To, fmt.Sprintf("rexctl: %v\n", cause))+ }+ }switch {case phase >= phaseIndex(release.PhaseVerified):e, err := app.Engine(ctx, inst)diff --git a/fluxer_rexctl/cmd/upgrade_log_test.go b/fluxer_rexctl/cmd/upgrade_log_test.gonew file mode 100644index 000000000..973947944--- /dev/null+++ b/fluxer_rexctl/cmd/upgrade_log_test.go@@ -0,0 +1,95 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package cmd++import (+ "bytes"+ "context"+ "errors"+ "os"+ "strings"+ "testing"+ "time"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/release"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"+)++func pendingUpgrade(t *testing.T, phase string) (*App, *instance.Instance) {+ t.Helper()+ inst, err := instance.Create(t.TempDir(), "fluxer")+ if err != nil {+ t.Fatal(err)+ }+ inst.State.Release = recoveryFrom+ inst.State.Upgrade = &instance.Upgrade{From: recoveryFrom, To: recoveryLatest, Phase: phase, StartedAt: time.Now().UTC().Add(-time.Minute)}+ if err := inst.Save(); err != nil {+ t.Fatal(err)+ }+ out := &bytes.Buffer{}+ app := &App{+ Version: recoveryLatest,+ Flags: GlobalFlags{Dir: inst.Dir},+ UI: ui.New(ui.Options{Stdin: strings.NewReader(""), Stdout: out, Stderr: out}),+ engine: &engine.Engine{Kind: engine.Docker},+ }+ return app, inst+}++func upgradeLogText(t *testing.T, inst *instance.Instance) string {+ t.Helper()+ data, err := os.ReadFile(inst.Path(instance.StateDirName, upgradeLog(recoveryLatest)))+ if err != nil {+ t.Fatalf("no upgrade log: %v", err)+ }+ return string(data)+}++func TestAbortedUpgradeWritesItsLogWhenGoingBackFails(t *testing.T) {+ app, inst := pendingUpgrade(t, release.PhaseMigrated)+ cause := errors.New("couldn't write docker-compose.yml")+ err := abortUpgrade(context.Background(), app, inst, app.engine, cause, ui.Wrap(cause, "Couldn't write the files.", ""))+ if err == nil {+ t.Fatal("going back worked without an engine")+ }+ if got := upgradeLogText(t, inst); !strings.Contains(got, cause.Error()) {+ t.Fatalf("upgrade log = %q, want the cause", got)+ }+}++func TestRecoveringAnInterruptedUpgradeWritesItsLog(t *testing.T) {+ app, inst := pendingUpgrade(t, release.PhaseRecreated)+ _ = recoverUpgrade(context.Background(), app, inst, true)+ if got := upgradeLogText(t, inst); !strings.Contains(got, "didn't finish") {+ t.Fatalf("upgrade log = %q", got)+ }+}++func TestRecoveringKeepsTheLogOfTheFailedAttempt(t *testing.T) {+ app, inst := pendingUpgrade(t, release.PhaseRecreated)+ path := inst.Path(instance.StateDirName, upgradeLog(recoveryLatest))+ if err := os.WriteFile(path, []byte("rexctl: api isn't ready\n"), 0o600); err != nil {+ t.Fatal(err)+ }+ _ = recoverUpgrade(context.Background(), app, inst, true)+ if got := upgradeLogText(t, inst); !strings.HasPrefix(got, "rexctl: api isn't ready\n") {+ t.Fatalf("upgrade log = %q", got)+ }+}++func TestAPanicDuringAnUpgradeWritesItsLog(t *testing.T) {+ _, inst := pendingUpgrade(t, release.PhaseRecreated)+ err := func() (err error) {+ defer guardUpgrade(inst, recoveryLatest, &err)+ panic("interface conversion: interface {} is nil")+ }()+ var ee *ui.ExitError+ if !errors.As(err, &ee) || !strings.Contains(ee.Fix, upgradeLog(recoveryLatest)) {+ t.Fatalf("err = %#v, want a fix that points at the log", err)+ }+ if got := upgradeLogText(t, inst); !strings.Contains(got, "interface conversion") || !strings.Contains(got, "goroutine") {+ t.Fatalf("upgrade log = %q", got)+ }+}diff --git a/fluxer_rexctl/internal/checks/overcommit.go b/fluxer_rexctl/internal/checks/overcommit.goindex a4c63ee53..e4851dccd 100644--- a/fluxer_rexctl/internal/checks/overcommit.go+++ b/fluxer_rexctl/internal/checks/overcommit.go@@ -4,27 +4,35 @@ package checksimport ("context"- "runtime""github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host")+var (+ overcommit = host.Overcommit+ enableOvercommit = host.EnableOvercommit+)++const overcommitOff = "Memory overcommit is off, so Fluxer's cache can fail to save data when memory runs low."+func init() {Register(Check{ID: "memory-overcommit", Phases: Preinstall | Installed, Run: runOvercommit, Fix: fixOvercommit, SafeFix: true})}func runOvercommit(_ context.Context, _ *Env) Result {- if runtime.GOOS != "linux" {+ switch overcommit() {+ case host.OvercommitUnknown:return skip("")+ case host.OvercommitLocked:+ return warn(overcommitOff, "This machine is a container and can't change it. Run this on the container host: "+host.OvercommitCommand)+ case host.OvercommitOff:+ r := fixable(warn(overcommitOff, "Run rexctl doctor --fix to turn it on."))+ r.Manual = "Run this as an administrator, or on the container host if this machine is a container: " + host.OvercommitCommand+ return r}- if !host.OvercommitDisabled() {- return pass("Memory overcommit is on.")- }- r := fixable(warn("Memory overcommit is off, so Fluxer's cache can fail to save data when memory runs low.", "Run rexctl doctor --fix to turn it on."))- r.Manual = "Ask an administrator to add " + host.OvercommitSetting + " to " + host.OvercommitFile + " and run sudo sysctl --system."- return r+ return pass("Memory overcommit is on.")}func fixOvercommit(ctx context.Context, _ *Env) error {- return host.EnableOvercommit(ctx)+ return enableOvercommit(ctx)}diff --git a/fluxer_rexctl/internal/checks/overcommit_test.go b/fluxer_rexctl/internal/checks/overcommit_test.gonew file mode 100644index 000000000..d5ecb5595--- /dev/null+++ b/fluxer_rexctl/internal/checks/overcommit_test.go@@ -0,0 +1,49 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "errors"+ "strings"+ "testing"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+)++func stubOvercommit(t *testing.T, state host.OvercommitState, enable func(context.Context) error) {+ t.Helper()+ prevState, prevEnable := overcommit, enableOvercommit+ t.Cleanup(func() { overcommit, enableOvercommit = prevState, prevEnable })+ overcommit = func() host.OvercommitState { return state }+ enableOvercommit = enable+}++func TestOvercommitInAContainerGivesTheHostCommand(t *testing.T) {+ stubOvercommit(t, host.OvercommitLocked, func(context.Context) error {+ t.Fatal("offered a fix that can't work")+ return nil+ })+ c, _ := Get("memory-overcommit")+ r := RunOne(context.Background(), &Env{prepared: true}, c)+ if r.Status != Warn || r.Fixable {+ t.Fatalf("result = %+v, want a warning without a fix", r)+ }+ if want := "This machine is a container and can't change it. Run this on the container host: " + host.OvercommitCommand; r.Fix != want {+ t.Fatalf("fix = %q, want %q", r.Fix, want)+ }+}++func TestOvercommitFixThatChangesNothingFails(t *testing.T) {+ stubOvercommit(t, host.OvercommitOff, func(context.Context) error {+ return host.ErrOvercommitUnchanged+ })+ c, _ := Get("memory-overcommit")+ r := RunOne(context.Background(), &Env{prepared: true}, c)+ if !r.Fixable || !strings.Contains(r.Manual, host.OvercommitCommand) {+ t.Fatalf("result = %+v", r)+ }+ if _, err := ApplyFix(context.Background(), &Env{prepared: true}, "memory-overcommit"); !errors.Is(err, host.ErrOvercommitUnchanged) {+ t.Fatalf("ApplyFix error = %v, want %v", err, host.ErrOvercommitUnchanged)+ }+}diff --git a/fluxer_rexctl/internal/engine/binds.go b/fluxer_rexctl/internal/engine/binds.goindex b98a6dde8..2e421cab7 100644--- a/fluxer_rexctl/internal/engine/binds.go+++ b/fluxer_rexctl/internal/engine/binds.go@@ -5,34 +5,13 @@ package engineimport ("context""path/filepath"- "sort""github.com/compose-spec/compose-go/v2/cli"- "github.com/compose-spec/compose-go/v2/loader""github.com/compose-spec/compose-go/v2/types")-func BindSources(ctx context.Context, dir, name string, files []string, env map[string]string) ([]string, error) {- vars := make([]string, 0, len(env))- for k, v := range env {- vars = append(vars, k+"="+v)- }- sort.Strings(vars)- opts, err := cli.NewProjectOptions(files,- cli.WithWorkingDirectory(dir),- cli.WithEnv(vars),- cli.WithName(name),- cli.WithDefaultProfiles(),- cli.WithResolvedPaths(true),- cli.WithLoadOptions(func(o *loader.Options) {- o.SkipValidation = true- o.SkipConsistencyCheck = true- }),- )- if err != nil {- return nil, err- }- model, err := opts.LoadProject(ctx)+func BindSources(ctx context.Context, s Spec) ([]string, error) {+ model, err := loadModel(ctx, s, cli.WithResolvedPaths(true))if err != nil {return nil, err}@@ -42,7 +21,7 @@ func BindSources(ctx context.Context, dir, name string, files []string, env map[if v.Type == types.VolumeTypeBind && v.Source != "" {src := v.Sourceif !filepath.IsAbs(src) {- src = filepath.Join(dir, src)+ src = filepath.Join(s.Dir, src)}out = append(out, filepath.Clean(src))}diff --git a/fluxer_rexctl/internal/engine/binds_test.go b/fluxer_rexctl/internal/engine/binds_test.gonew file mode 100644index 000000000..04ca033f9--- /dev/null+++ b/fluxer_rexctl/internal/engine/binds_test.go@@ -0,0 +1,47 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package engine++import (+ "context"+ "os"+ "path/filepath"+ "slices"+ "testing"+)++func writeCompose(t *testing.T, dir, name, data string) {+ t.Helper()+ if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0o600); err != nil {+ t.Fatal(err)+ }+}++func TestBindSourcesMergesAServiceWithNoBodyLikeLoad(t *testing.T) {+ dir := t.TempDir()+ writeCompose(t, dir, "compose.yml", "services:\n livekit:\n image: livekit\n edge:\n image: caddy\n")+ writeCompose(t, dir, "custom.compose.yml", "services:\n livekit:\n edge:\n volumes:\n - ${PWD}/Caddyfile:/etc/caddy/Caddyfile\n")+ s := Spec{Name: "fluxer", Dir: dir, Files: []string{"compose.yml", "custom.compose.yml"}}+ if _, err := (&Engine{}).Load(context.Background(), s); err != nil {+ t.Fatalf("Load: %v", err)+ }+ got, err := BindSources(context.Background(), s)+ if err != nil {+ t.Fatal(err)+ }+ if want := filepath.Join(dir, "Caddyfile"); !slices.Equal(got, []string{want}) {+ t.Fatalf("BindSources = %q, want %q", got, want)+ }+}++func TestBindSourcesReturnsAnErrorForAServiceWithNoBodyOnItsOwn(t *testing.T) {+ dir := t.TempDir()+ writeCompose(t, dir, "custom.compose.yml", "services:\n livekit:\n")+ s := Spec{Name: "fluxer", Dir: dir, Files: []string{"custom.compose.yml"}}+ if _, err := BindSources(context.Background(), s); err == nil {+ t.Fatal("BindSources read a service with no body and nothing to merge it with")+ }+ if _, err := (&Engine{}).Load(context.Background(), s); err == nil {+ t.Fatal("Load read a service with no body and nothing to merge it with")+ }+}diff --git a/fluxer_rexctl/internal/engine/load.go b/fluxer_rexctl/internal/engine/load.goindex 7e1c8d2a0..344ca5091 100644--- a/fluxer_rexctl/internal/engine/load.go+++ b/fluxer_rexctl/internal/engine/load.go@@ -26,38 +26,15 @@ func (e *Engine) Named(name, dir string) *Project {}func (e *Engine) Load(ctx context.Context, s Spec) (*Project, error) {- files := make([]string, 0, len(s.Files))- for _, f := range s.Files {- if !filepath.IsAbs(f) {- f = filepath.Join(s.Dir, f)- }- files = append(files, f)- }+ files := absFiles(s)for _, f := range files {if err := refuseUnsupported(f); err != nil {return nil, err}}- env := make([]string, 0, len(s.Env)+1)- for k, v := range s.Env {- env = append(env, k+"="+v)- }- if _, ok := s.Env["PWD"]; !ok {- env = append(env, "PWD="+s.Dir)- }- sort.Strings(env)- opts, err := cli.NewProjectOptions(files,- cli.WithWorkingDirectory(s.Dir),- cli.WithEnv(env),- cli.WithName(s.Name),- cli.WithDefaultProfiles(),- )+ model, err := loadModel(ctx, s)if err != nil {- return nil, &Error{Op: "load", Class: ClassInvalidConfig, Err: err}- }- model, err := opts.LoadProject(ctx)- if err != nil {- return nil, loadError(err)+ return nil, err}for name, svc := range model.Services {if svc.Build != nil {@@ -80,6 +57,48 @@ func (e *Engine) Load(ctx context.Context, s Spec) (*Project, error) {return &Project{Engine: e, Name: model.Name, Dir: s.Dir, Model: model}, nil}+func absFiles(s Spec) []string {+ files := make([]string, 0, len(s.Files))+ for _, f := range s.Files {+ if !filepath.IsAbs(f) {+ f = filepath.Join(s.Dir, f)+ }+ files = append(files, f)+ }+ return files+}++func loadModel(ctx context.Context, s Spec, extra ...cli.ProjectOptionsFn) (model *types.Project, err error) {+ defer func() {+ if r := recover(); r != nil {+ model, err = nil, &Error{Op: "load", Class: ClassInvalidConfig, Err: fmt.Errorf("the compose files couldn't be read: %v", r)}+ }+ }()+ env := make([]string, 0, len(s.Env)+1)+ for k, v := range s.Env {+ env = append(env, k+"="+v)+ }+ if _, ok := s.Env["PWD"]; !ok {+ env = append(env, "PWD="+s.Dir)+ }+ sort.Strings(env)+ fns := append([]cli.ProjectOptionsFn{+ cli.WithWorkingDirectory(s.Dir),+ cli.WithEnv(env),+ cli.WithName(s.Name),+ cli.WithDefaultProfiles(),+ }, extra...)+ opts, err := cli.NewProjectOptions(absFiles(s), fns...)+ if err != nil {+ return nil, &Error{Op: "load", Class: ClassInvalidConfig, Err: err}+ }+ model, err = opts.LoadProject(ctx)+ if err != nil {+ return nil, loadError(err)+ }+ return model, nil+}+func loadError(err error) error {var missing *template.MissingRequiredErrorif errors.As(err, &missing) {diff --git a/fluxer_rexctl/internal/host/overcommit.go b/fluxer_rexctl/internal/host/overcommit.goindex b73c3bfad..d7c40e351 100644--- a/fluxer_rexctl/internal/host/overcommit.go+++ b/fluxer_rexctl/internal/host/overcommit.go@@ -4,33 +4,71 @@ package hostimport ("context"+ "errors"+ "fmt"+ "io/fs""os""runtime""strconv""strings"+ "syscall")const (OvercommitSetting = "vm.overcommit_memory = 1"OvercommitFile = "/etc/sysctl.d/61-fluxer-overcommit.conf"+ OvercommitCommand = "echo '" + OvercommitSetting + "' | sudo tee " + OvercommitFile + " && sudo sysctl --system")-func OvercommitDisabled() bool {+type OvercommitState int++const (+ OvercommitUnknown OvercommitState = iota+ OvercommitOn+ OvercommitOff+ OvercommitLocked+)++var ErrOvercommitUnchanged = errors.New("vm.overcommit_memory didn't change")++var overcommitPath = "/proc/sys/vm/overcommit_memory"++func Overcommit() OvercommitState {if runtime.GOOS != "linux" {- return false+ return OvercommitUnknown}- data, err := os.ReadFile("/proc/sys/vm/overcommit_memory")+ return overcommitAt(overcommitPath, os.Geteuid() == 0)+}++func overcommitAt(path string, root bool) OvercommitState {+ data, err := os.ReadFile(path)if err != nil {- return false+ return OvercommitOn}n, err := strconv.Atoi(strings.TrimSpace(string(data)))- return err == nil && n != 1+ if err != nil || n == 1 {+ return OvercommitOn+ }+ f, err := os.OpenFile(path, os.O_WRONLY, 0)+ if err == nil {+ _ = f.Close()+ return OvercommitOff+ }+ if errors.Is(err, syscall.EROFS) || root && errors.Is(err, fs.ErrPermission) {+ return OvercommitLocked+ }+ return OvercommitOff}func EnableOvercommit(ctx context.Context) error {if _, err := output(ctx, false, "sh", "-c", "printf '"+OvercommitSetting+"\\n' > "+OvercommitFile); err != nil {return err}- _, err := output(ctx, false, "sysctl", "-p", OvercommitFile)- return err+ if _, err := output(ctx, false, "sysctl", "-p", OvercommitFile); err != nil {+ return err+ }+ if s := Overcommit(); s == OvercommitOff || s == OvercommitLocked {+ return fmt.Errorf("%w after sysctl -p %s", ErrOvercommitUnchanged, OvercommitFile)+ }+ return nil}diff --git a/fluxer_rexctl/internal/host/overcommit_test.go b/fluxer_rexctl/internal/host/overcommit_test.gonew file mode 100644index 000000000..d7cc37aa0--- /dev/null+++ b/fluxer_rexctl/internal/host/overcommit_test.go@@ -0,0 +1,41 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package host++import (+ "os"+ "path/filepath"+ "testing"+)++func TestOvercommitAtReadsTheSetting(t *testing.T) {+ dir := t.TempDir()+ path := filepath.Join(dir, "overcommit_memory")+ for value, want := range map[string]OvercommitState{"1\n": OvercommitOn, "0\n": OvercommitOff, "2\n": OvercommitOff} {+ if err := os.WriteFile(path, []byte(value), 0o644); err != nil {+ t.Fatal(err)+ }+ if got := overcommitAt(path, false); got != want {+ t.Errorf("overcommitAt(%q) = %v, want %v", value, got, want)+ }+ }+ if got := overcommitAt(filepath.Join(dir, "missing"), false); got != OvercommitOn {+ t.Errorf("a missing file = %v, want %v", got, OvercommitOn)+ }+}++func TestOvercommitAtSeesASettingRootCantWrite(t *testing.T) {+ if os.Geteuid() == 0 {+ t.Skip("root can write a read-only file")+ }+ path := filepath.Join(t.TempDir(), "overcommit_memory")+ if err := os.WriteFile(path, []byte("0\n"), 0o444); err != nil {+ t.Fatal(err)+ }+ if got := overcommitAt(path, true); got != OvercommitLocked {+ t.Errorf("as root = %v, want %v", got, OvercommitLocked)+ }+ if got := overcommitAt(path, false); got != OvercommitOff {+ t.Errorf("as a user who can use sudo = %v, want %v", got, OvercommitOff)+ }+}diff --git a/fluxer_rexctl/internal/instance/layout.go b/fluxer_rexctl/internal/instance/layout.goindex 8485202a3..6ef3c83f5 100644--- a/fluxer_rexctl/internal/instance/layout.go+++ b/fluxer_rexctl/internal/instance/layout.go@@ -176,7 +176,11 @@ func (i *Instance) rootMounted(ctx context.Context, name string) bool {if _, err := os.Stat(custom); errors.Is(err, fs.ErrNotExist) {return false}- sources, err := engine.BindSources(ctx, i.Dir, i.Project(), []string{custom}, map[string]string{"PWD": i.Dir})+ env, err := i.Environment()+ if err != nil {+ return true+ }+ sources, err := engine.BindSources(ctx, engine.Spec{Name: i.Project(), Dir: i.Dir, Files: i.ComposeFiles(), Env: env})if err != nil {return true}diff --git a/fluxer_rexctl/internal/instance/layout_test.go b/fluxer_rexctl/internal/instance/layout_test.goindex e1d01099b..573aaaf55 100644--- a/fluxer_rexctl/internal/instance/layout_test.go+++ b/fluxer_rexctl/internal/instance/layout_test.go@@ -602,3 +602,18 @@ func TestEjectOnTheOldLayoutKeepsTheFiles(t *testing.T) {}checkOldLayout(t, dir, old)}++func TestDropRootCopiesReadsACustomComposeServiceWithNoBody(t *testing.T) {+ dir, old := oldLayout(t)+ inst := migrated(t, dir, old)+ writeTestFile(t, inst.Path(CustomCompose), []byte("services:\n livekit:\n"))+ startedWithGenerated(t, inst)+ if _, err := os.Stat(inst.Path(stack.Caddyfile)); !errors.Is(err, os.ErrNotExist) {+ t.Fatal("kept the Caddyfile though custom.compose.yml mounts nothing")+ }+ writeTestFile(t, inst.Path(stack.Caddyfile), []byte(":443 {\n}\n"))+ writeTestFile(t, inst.Path(CustomCompose), []byte("services:\n livekit:\n edge:\n volumes:\n - ./Caddyfile:/etc/caddy/Caddyfile:ro\n"))+ if !inst.rootMounted(context.Background(), stack.Caddyfile) {+ t.Fatal("missed the Caddyfile that custom.compose.yml mounts next to a service with no body")+ }+}