Skip to content

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

TypeScript fluxerfluxerapp

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.go
index 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 *eng
err := 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 *eng
report.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 *eng
return 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.Upgrade
app.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 *en
return 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.Upgrade
if 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.go
new file mode 100644
index 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.go
index a4c63ee53..e4851dccd 100644
--- a/fluxer_rexctl/internal/checks/overcommit.go
+++ b/fluxer_rexctl/internal/checks/overcommit.go
@@ -4,27 +4,35 @@ package checks
import (
"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.go
new file mode 100644
index 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.go
index b98a6dde8..2e421cab7 100644
--- a/fluxer_rexctl/internal/engine/binds.go
+++ b/fluxer_rexctl/internal/engine/binds.go
@@ -5,34 +5,13 @@ package engine
import (
"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.Source
if !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.go
new file mode 100644
index 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.go
index 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.MissingRequiredError
if errors.As(err, &missing) {
diff --git a/fluxer_rexctl/internal/host/overcommit.go b/fluxer_rexctl/internal/host/overcommit.go
index b73c3bfad..d7c40e351 100644
--- a/fluxer_rexctl/internal/host/overcommit.go
+++ b/fluxer_rexctl/internal/host/overcommit.go
@@ -4,33 +4,71 @@ package host
import (
"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.go
new file mode 100644
index 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.go
index 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.go
index 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")
+ }
+}