A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
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.mdxindex 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 rexctlTo 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.goindex 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.goindex 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.goindex 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.gonew file mode 100644index 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.goindex 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 boolRemovedEnv boolImages 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.goindex 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 nildiff --git a/fluxer_rexctl/internal/stack/stack.go b/fluxer_rexctl/internal/stack/stack.goindex 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)