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 a hand-upgraded release on takeover (#3631)

Hampus5907e7547caf
diff --git a/fluxer_docs/src/content/docs/operator/running.mdx b/fluxer_docs/src/content/docs/operator/running.mdx
index 54f34fb2e..5de0b7336 100644
--- a/fluxer_docs/src/content/docs/operator/running.mdx
+++ b/fluxer_docs/src/content/docs/operator/running.mdx
@@ -134,3 +134,5 @@ This checks your instance and the machine, and tells you how to fix each problem
## Manage it without rexctl
To run your instance yourself with docker compose, run `rexctl eject`. Fluxer keeps running, and `rexctl takeover` hands it back to rexctl.
+
+To upgrade Fluxer while you manage it yourself, run `rexctl takeover`, `rexctl upgrade` and `rexctl eject` one after the other. You can also [upgrade with the compose bundle](/operator/docker-compose/#upgrade) of the new version, the same way as an instance that never used rexctl.
diff --git a/fluxer_rexctl/cmd/eject.go b/fluxer_rexctl/cmd/eject.go
index b56b485aa..ee9462779 100644
--- a/fluxer_rexctl/cmd/eject.go
+++ b/fluxer_rexctl/cmd/eject.go
@@ -76,6 +76,7 @@ func runEject(ctx context.Context, app *App) error {
u.Info("Your containers come back after a restart of this machine only once Podman's own podman-restart.service starts them.")
}
u.Info("If %s recreates Fluxer's containers the first time, that's expected. Your data stays.", tool)
+ u.Info("To upgrade Fluxer later, run rexctl takeover, rexctl upgrade and rexctl eject one after the other.")
u.OK("You manage this instance with %s in %s from here on. Run rexctl takeover to hand it back to rexctl.", tool, inst.Dir)
return nil
})
diff --git a/fluxer_rexctl/cmd/takeover.go b/fluxer_rexctl/cmd/takeover.go
index 0a1eab081..cb6509b8f 100644
--- a/fluxer_rexctl/cmd/takeover.go
+++ b/fluxer_rexctl/cmd/takeover.go
@@ -148,6 +148,9 @@ func describeTakeover(u *ui.UI, r *instance.ImportReport) {
} else {
u.Info("Found a Fluxer instance in %s.", r.Dir)
}
+ if r.Release != "" {
+ u.Info("Your instance now runs Fluxer %s. rexctl takes it over on that release.", release.Short(r.Release))
+ }
u.Info("After this, rexctl manages it. Fluxer keeps running as it is, and your data and secrets stay.")
for _, f := range r.CustomFiles {
if f != instance.CustomCompose {
diff --git a/fluxer_rexctl/internal/instance/eject.go b/fluxer_rexctl/internal/instance/eject.go
index 665b5c3b9..d758b8635 100644
--- a/fluxer_rexctl/internal/instance/eject.go
+++ b/fluxer_rexctl/internal/instance/eject.go
@@ -95,6 +95,10 @@ func importEjected(ctx context.Context, dir string, e *engine.Engine, s *State,
if err != nil {
return nil, nil, err
}
+ updated, err := handUpdate(ctx, dir, e, s, custom)
+ if err != nil {
+ return nil, nil, err
+ }
envPath := filepath.Join(dir, EnvFileName)
data, err := os.ReadFile(envPath)
haveEnv := err == nil
@@ -125,6 +129,18 @@ func importEjected(ctx context.Context, dir string, e *engine.Engine, s *State,
r.AdminKeys = slices.Sorted(maps.Keys(s.AdminImport.Values))
}
}
+ if updated != nil {
+ minted, err := mint(s.Secrets, true)
+ if err != nil {
+ return nil, nil, err
+ }
+ r.Minted, r.Release = minted, updated.Release
+ s.PreviousRelease, s.Release = s.Release, updated.Release
+ s.Images = Images{Release: updated.Release, Refs: maps.Clone(updated.Images)}
+ if s.Rendered, err = stack.Hashes(stack.Embedded(), stack.OverlaysFor(s.Settings), s.Images.Refs, s.Project); err != nil {
+ return nil, nil, err
+ }
+ }
for _, name := range slices.Sorted(maps.Keys(s.Rendered)) {
data, err := os.ReadFile(filepath.Join(dir, name))
if err != nil || stack.Hash(data) == s.Rendered[name] {
@@ -156,6 +172,57 @@ func importEjected(ctx context.Context, dir string, e *engine.Engine, s *State,
return s, r, nil
}
+func handUpdate(ctx context.Context, dir string, e *engine.Engine, s *State, custom []byte) (*stack.ImageSet, error) {
+ shipped, err := stack.EmbeddedImages()
+ if err != nil || len(shipped.Images) == 0 {
+ return nil, err
+ }
+ newer := shipped.Release == stack.Embedded().Release && VersionBelow(s.Release, shipped.Release)
+ live, err := inspect(ctx, e, s.Project, dir)
+ if err != nil {
+ return nil, err
+ }
+ compose, err := os.ReadFile(filepath.Join(dir, stack.ComposeFile))
+ if err != nil && !errors.Is(err, fs.ErrNotExist) {
+ return nil, err
+ }
+ own := stack.ComposeImages(custom)
+ var updated *stack.ImageSet
+ for _, seen := range []map[string]string{stack.ComposeImages(compose), live.images} {
+ maps.DeleteFunc(seen, func(svc, ref string) bool {
+ _, fluxer := shipped.Images[svc]
+ _, mine := own[svc]
+ return !fluxer || mine || strings.Contains(ref, "${")
+ })
+ switch {
+ case sameImages(seen, s.Images.Refs):
+ case newer && sameImages(seen, shipped.Images):
+ updated = &shipped
+ default:
+ return nil, &AdoptError{
+ Msg: "rexctl doesn't know the Fluxer images your instance runs.",
+ Fix: "Download the latest rexctl, then run rexctl takeover again.",
+ }
+ }
+ }
+ return updated, nil
+}
+
+func sameImages(seen, refs map[string]string) bool {
+ for svc, ref := range seen {
+ _, got, _ := strings.Cut(ref, "@")
+ _, want, _ := strings.Cut(refs[svc], "@")
+ if got != "" && want != "" {
+ if got != want {
+ return false
+ }
+ } else if !sameImage(ref, refs[svc]) {
+ return false
+ }
+ }
+ return true
+}
+
func removedFromEnv(key string, env map[string]string) bool {
if isRawVar(key) {
_, ok := env[key]
diff --git a/fluxer_rexctl/internal/instance/eject_test.go b/fluxer_rexctl/internal/instance/eject_test.go
new file mode 100644
index 000000000..85e6cdd00
--- /dev/null
+++ b/fluxer_rexctl/internal/instance/eject_test.go
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package instance
+
+import (
+ "encoding/json"
+ "errors"
+ "maps"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/secrets"
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
+)
+
+const (
+ ejectedAt = "2026.10.0"
+ shippedAt = "2026.11.0"
+)
+
+func fluxerRefs(digit string) map[string]string {
+ refs := map[string]string{}
+ for _, svc := range []string{"api", "worker", "gateway", "media-proxy", "push", "static-proxy", "app-proxy", "admin", "snowflakes", "users", "gifs", "messages", "unfurl"} {
+ refs[svc] = "ghcr.io/fluxerapp/fluxer-" + svc + "@sha256:" + strings.Repeat(digit, 64)
+ }
+ return refs
+}
+
+func TestMain(m *testing.M) {
+ dir, err := os.MkdirTemp("", "rexctl-imageset")
+ if err != nil {
+ panic(err)
+ }
+ data, err := json.Marshal(stack.ImageSet{Release: shippedAt, Images: fluxerRefs("b")})
+ if err != nil {
+ panic(err)
+ }
+ path := filepath.Join(dir, "imageset.json")
+ if err := os.WriteFile(path, data, 0o644); err != nil {
+ panic(err)
+ }
+ os.Setenv(stack.ImageSetEnv, path)
+ code := m.Run()
+ os.RemoveAll(dir)
+ os.Exit(code)
+}
+
+func ejectedInstance(t *testing.T, declared *stack.Set, refs map[string]string) string {
+ t.Helper()
+ dir := t.TempDir()
+ shipped := stack.Embedded()
+ old := &stack.Set{Release: ejectedAt, Files: shipped.Files, Profiles: shipped.Profiles, Vars: shipped.Vars}
+ if err := stack.WriteSet(filepath.Join(dir, StateDirName, ReleasesDir, ejectedAt, StackDir), old); err != nil {
+ t.Fatal(err)
+ }
+ r, err := stack.Render(old, nil, fluxerRefs("a"), "fluxer", dir)
+ if err != nil {
+ t.Fatal(err)
+ }
+ compose, err := stack.RenderCompose(declared, refs, "fluxer")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(dir, stack.ComposeFile), compose, 0o644); err != nil {
+ t.Fatal(err)
+ }
+ s := &State{
+ Project: "fluxer",
+ Release: ejectedAt,
+ Images: Images{Release: ejectedAt, Refs: fluxerRefs("a")},
+ Settings: map[string]string{},
+ Secrets: map[string]string{},
+ Rendered: r.Hashes,
+ SetupDone: true,
+ Ejected: &Ejected{At: time.Now().UTC().Truncate(time.Second)},
+ }
+ if _, err := secrets.Mint(s.Secrets, false); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.Save(filepath.Join(dir, StateDirName, StateFileName)); err != nil {
+ t.Fatal(err)
+ }
+ return dir
+}
+
+func TestTakeoverOfEjectedInstanceNeverGoesBack(t *testing.T) {
+ shipped := stack.Embedded()
+ old := &stack.Set{Release: ejectedAt, Files: shipped.Files, Profiles: shipped.Profiles, Vars: shipped.Vars}
+
+ t.Run("same release", func(t *testing.T) {
+ s, r, err := Import(ejectedInstance(t, old, fluxerRefs("a")), nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if s.Release != ejectedAt || len(r.KeepAsMine) != 0 {
+ t.Fatalf("release %s, kept %v", s.Release, r.KeepAsMine)
+ }
+ })
+
+ t.Run("updated to the release rexctl ships", func(t *testing.T) {
+ s, r, err := Import(ejectedInstance(t, shipped, fluxerRefs("b")), nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if s.Release != shippedAt || s.Images.Release != shippedAt || !maps.Equal(s.Images.Refs, fluxerRefs("b")) {
+ t.Fatalf("took over on %s with %v", s.Release, s.Images)
+ }
+ if s.PreviousRelease != ejectedAt || len(r.KeepAsMine) != 0 {
+ t.Fatalf("previous %s, kept %v", s.PreviousRelease, r.KeepAsMine)
+ }
+ })
+
+ t.Run("updated to a release rexctl doesn't know", func(t *testing.T) {
+ dir := ejectedInstance(t, shipped, fluxerRefs("c"))
+ _, _, err := Import(dir, nil)
+ var ae *AdoptError
+ if !errors.As(err, &ae) {
+ t.Fatalf("took over an instance on unknown images: %v", err)
+ }
+ data, err := os.ReadFile(filepath.Join(dir, StateDirName, StateFileName))
+ if err != nil {
+ t.Fatal(err)
+ }
+ s, err := ParseState(data, dir)
+ if err != nil || s.Ejected == nil || s.Release != ejectedAt {
+ t.Fatalf("state changed after the refusal: %v", err)
+ }
+ })
+}
diff --git a/fluxer_rexctl/internal/instance/import.go b/fluxer_rexctl/internal/instance/import.go
index c4d0c68e8..717ef0f69 100644
--- a/fluxer_rexctl/internal/instance/import.go
+++ b/fluxer_rexctl/internal/instance/import.go
@@ -55,6 +55,7 @@ type ImportReport struct {
EngineProxies bool
RemovedEnv bool
Images map[string]string
+ Release string
}
func (r *ImportReport) DroppedLine() string {
diff --git a/fluxer_rexctl/internal/stack/images.go b/fluxer_rexctl/internal/stack/images.go
index a25603806..f391cad98 100644
--- a/fluxer_rexctl/internal/stack/images.go
+++ b/fluxer_rexctl/internal/stack/images.go
@@ -79,6 +79,18 @@ func imageLines(compose []byte) ([]imageLine, error) {
return out, nil
}
+func ComposeImages(compose []byte) map[string]string {
+ found, err := imageLines(compose)
+ if err != nil {
+ return nil
+ }
+ out := make(map[string]string, len(found))
+ for _, img := range found {
+ out[img.service] = img.value
+ }
+ return out
+}
+
func mappingValue(n *yaml.Node, key string) *yaml.Node {
if n == nil || n.Kind != yaml.MappingNode {
return nil
diff --git a/fluxer_rexctl/internal/stack/stack.go b/fluxer_rexctl/internal/stack/stack.go
index fe751f2f9..0e0dbc606 100644
--- a/fluxer_rexctl/internal/stack/stack.go
+++ b/fluxer_rexctl/internal/stack/stack.go
@@ -156,6 +156,18 @@ func RenderCompose(set *Set, images map[string]string, project string) ([]byte,
return nameProject(compose, project), nil
}
+func Hashes(set *Set, selected []Overlay, images map[string]string, project string) (map[string]string, error) {
+ files, _, err := renderFiles(set, selected, images, project)
+ if err != nil {
+ return nil, err
+ }
+ out := make(map[string]string, len(files))
+ for _, f := range files {
+ out[f.name] = Hash(f.data)
+ }
+ return out, nil
+}
+
func ReadFile(set *Set, name string) ([]byte, error) {
if set == nil || set.Files == nil {
return nil, fmt.Errorf("%w: %s", ErrMissingFile, name)