Skip to content

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

TypeScript fluxerfluxerapp

fix(rexctl): keep only the previous release's images (#3619)

Hampus52ef26078082
diff --git a/fluxer_rexctl/internal/instance/instance.go b/fluxer_rexctl/internal/instance/instance.go
index 021c0cc4f..93c7bf857 100644
--- a/fluxer_rexctl/internal/instance/instance.go
+++ b/fluxer_rexctl/internal/instance/instance.go
@@ -41,7 +41,6 @@ const (
BackupsDir = "backups"
CertsDir = "certs"
CaddyDropInDir = "caddy.d"
- KeepReleases = 3
DefaultKeepBackups = 3
KeepAllBackups = -1
diff --git a/fluxer_rexctl/internal/release/files.go b/fluxer_rexctl/internal/release/files.go
index 2d05789e3..73ca52f0a 100644
--- a/fluxer_rexctl/internal/release/files.go
+++ b/fluxer_rexctl/internal/release/files.go
@@ -374,16 +374,23 @@ func CheckPostgres(fromRef, toRef string) error {
}
func Prune(ctx context.Context, inst *instance.Instance, e *engine.Engine) error {
+ remove, err := pruneReleases(inst)
+ if err != nil || len(remove) == 0 || e == nil {
+ return err
+ }
+ return e.RemoveImages(ctx, remove)
+}
+
+func pruneReleases(inst *instance.Instance) ([]string, error) {
root := inst.Path(instance.StateDirName, instance.ReleasesDir)
entries, err := os.ReadDir(root)
if errors.Is(err, fs.ErrNotExist) {
- return nil
+ return nil, nil
}
if err != nil {
- return err
+ return nil, err
}
keep := map[string]bool{
- stack.LegacyRelease: true,
DirName(inst.State.Release): true,
DirName(inst.State.PreviousRelease): true,
}
@@ -391,24 +398,16 @@ func Prune(ctx context.Context, inst *instance.Instance, e *engine.Engine) error
keep[DirName(u.From)] = true
keep[DirName(u.To)] = true
}
- var versions []string
- for _, d := range entries {
- if d.IsDir() && d.Name() != stack.LegacyRelease {
- versions = append(versions, d.Name())
- }
- }
- sort.Slice(versions, func(i, j int) bool { return Compare(versions[i], versions[j]) > 0 })
- for i, v := range versions {
- if i < instance.KeepReleases {
- keep[v] = true
- }
- }
kept := map[string]bool{}
for _, r := range inst.State.Images.Refs {
kept[r] = true
}
var drop []string
- for _, v := range append(versions, stack.LegacyRelease) {
+ for _, d := range entries {
+ if !d.IsDir() {
+ continue
+ }
+ v := d.Name()
refs, _ := Images(inst, v)
if keep[v] {
for _, r := range refs {
@@ -417,8 +416,16 @@ func Prune(ctx context.Context, inst *instance.Instance, e *engine.Engine) error
continue
}
drop = append(drop, refs...)
- if err := removeAll(filepath.Join(root, v)); err != nil {
- return err
+ if v == stack.LegacyRelease {
+ err = os.Remove(filepath.Join(root, v, imagesFile))
+ if errors.Is(err, fs.ErrNotExist) {
+ err = nil
+ }
+ } else {
+ err = removeAll(filepath.Join(root, v))
+ }
+ if err != nil {
+ return nil, err
}
}
var remove []string
@@ -429,10 +436,7 @@ func Prune(ctx context.Context, inst *instance.Instance, e *engine.Engine) error
remove = append(remove, r)
}
}
- if len(remove) == 0 || e == nil {
- return nil
- }
- return e.RemoveImages(ctx, remove)
+ return remove, nil
}
func removeAll(dir string) error {
diff --git a/fluxer_rexctl/internal/release/files_test.go b/fluxer_rexctl/internal/release/files_test.go
new file mode 100644
index 000000000..1d294ec3d
--- /dev/null
+++ b/fluxer_rexctl/internal/release/files_test.go
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package release
+
+import (
+ "os"
+ "path/filepath"
+ "slices"
+ "testing"
+
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
+)
+
+func TestPruneReleases(t *testing.T) {
+ images := map[string][]string{
+ stack.LegacyRelease: {"fluxer:legacy", "postgres:16"},
+ "2026.1.0": {"fluxer:1", "postgres:17"},
+ "2026.2.0": {"fluxer:2", "postgres:17"},
+ "2026.3.0": {"fluxer:3", "postgres:17"},
+ "2026.4.0": {"fluxer:4", "postgres:17"},
+ }
+ cases := []struct {
+ name string
+ state instance.State
+ remove []string
+ kept []string
+ legacyOn bool
+ }{
+ {
+ name: "current and previous",
+ state: instance.State{Release: "2026.4.0", PreviousRelease: "2026.3.0"},
+ remove: []string{"fluxer:1", "fluxer:2", "fluxer:legacy", "postgres:16"},
+ kept: []string{"2026.3.0", "2026.4.0"},
+ },
+ {
+ name: "legacy is the rollback target",
+ state: instance.State{Release: "2026.1.0", PreviousRelease: stack.LegacyRelease},
+ remove: []string{"fluxer:2", "fluxer:3", "fluxer:4"},
+ kept: []string{"2026.1.0"},
+ legacyOn: true,
+ },
+ {
+ name: "unfinished upgrade",
+ state: instance.State{Release: "2026.2.0", PreviousRelease: "2026.1.0",
+ Upgrade: &instance.Upgrade{From: "2026.2.0", To: "2026.4.0"}},
+ remove: []string{"fluxer:3", "fluxer:legacy", "postgres:16"},
+ kept: []string{"2026.1.0", "2026.2.0", "2026.4.0"},
+ },
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ inst := &instance.Instance{Dir: t.TempDir(), State: &tc.state}
+ for v, refs := range images {
+ if err := writeImages(Dir(inst, v), v, refs); err != nil {
+ t.Fatal(err)
+ }
+ }
+ remove, err := pruneReleases(inst)
+ if err != nil {
+ t.Fatal(err)
+ }
+ slices.Sort(remove)
+ if !slices.Equal(remove, tc.remove) {
+ t.Errorf("removed images %v, want %v", remove, tc.remove)
+ }
+ entries, err := os.ReadDir(filepath.Dir(Dir(inst, stack.LegacyRelease)))
+ if err != nil {
+ t.Fatal(err)
+ }
+ var dirs []string
+ for _, d := range entries {
+ if d.Name() != stack.LegacyRelease {
+ dirs = append(dirs, d.Name())
+ }
+ }
+ if !slices.Equal(dirs, tc.kept) {
+ t.Errorf("release folders %v, want %v", dirs, tc.kept)
+ }
+ refs, err := Images(inst, stack.LegacyRelease)
+ if tc.legacyOn != (err == nil && len(refs) > 0) {
+ t.Errorf("legacy images %v (%v), want kept %v", refs, err, tc.legacyOn)
+ }
+ if !exists(Dir(inst, stack.LegacyRelease)) {
+ t.Error("the legacy folder was removed")
+ }
+ })
+ }
+}