A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(rexctl): add takeover of old installer deployments
Hampus92a326bf33e0
diff --git a/fluxer_rexctl/cmd/takeover.go b/fluxer_rexctl/cmd/takeover.gonew file mode 100644index 000000000..e5e4cbc44--- /dev/null+++ b/fluxer_rexctl/cmd/takeover.go@@ -0,0 +1,317 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package cmd++import (+ "context"+ "errors"+ "fmt"+ "os"+ "path/filepath"+ "regexp"+ "strings"++ "github.com/spf13/cobra"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/setup"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"+)++type takeoverOptions struct {+ DryRun bool+ Then string+}++func newTakeoverCmd(app *App) *cobra.Command {+ var dryRun bool+ c := &cobra.Command{+ Use: "takeover",+ Short: "Let rexctl manage an instance it doesn't manage yet",+ Long: "Hands an instance made by the old installer, by hand with docker compose, or released with rexctl eject over to rexctl. Fluxer keeps running as it is.",+ Args: noArgs,+ RunE: func(c *cobra.Command, args []string) error {+ dir, err := app.Dir()+ if err != nil {+ return err+ }+ inst, _, err := takeoverDir(c.Context(), app, dir, takeoverOptions{DryRun: dryRun})+ if err != nil || inst == nil {+ return err+ }+ app.UI.OK("rexctl manages your instance in %s.", inst.Dir)+ return nil+ },+ }+ c.Flags().BoolVar(&dryRun, "dry-run", false, "Show what would change without changing anything")+ return c+}++func isBootstrap(path string) bool {+ data, err := os.ReadFile(path)+ return err == nil && strings.Contains(string(data), "REXCTL_RELEASE_URL")+}++func takeoverDir(ctx context.Context, app *App, dir string, opts takeoverOptions) (*instance.Instance, []string, error) {+ u := app.UI+ dir, err := filepath.Abs(dir)+ if err != nil {+ return nil, nil, err+ }+ var current *instance.Instance+ switch found, err := instance.Find(dir); {+ case err == nil:+ current = found+ case errors.Is(err, instance.ErrNotFound):+ return nil, nil, ui.Refused(fmt.Sprintf("There's no Fluxer instance in %s.", dir), "Run rexctl install, or pass --dir.")+ case !errors.Is(err, instance.ErrLegacy):+ return nil, nil, ui.Wrap(err, fmt.Sprintf("rexctl can't read the instance in %s.", dir), "Run rexctl as the account that installed Fluxer.")+ }+ e, err := app.Engine(ctx, current)+ if err != nil && !opts.DryRun {+ return nil, nil, err+ }+ report, err := instance.PreviewImport(dir, e)+ if err != nil {+ return nil, nil, takeoverError(err)+ }+ if report.Source == instance.SourceManaged {+ u.Info("rexctl already manages the instance in %s.", dir)+ return current, nil, nil+ }+ describeTakeover(u, report)+ if opts.DryRun {+ if opts.Then != "" && len(report.KeepAsMine) == 0 {+ u.Info("%s", opts.Then)+ }+ u.Info("Dry run. Nothing changed.")+ return nil, nil, nil+ }+ ok, err := u.Confirm("Take over this instance?", true)+ if err != nil {+ return nil, nil, err+ }+ if !ok {+ return nil, nil, ui.Refused("Your instance was left as it was.", "Run rexctl takeover when you're ready.")+ }+ lock, err := (&instance.Instance{Dir: dir}).Lock(ctx)+ if errors.Is(err, instance.ErrLocked) {+ return nil, nil, ui.Refused("Another rexctl command is changing this instance.", "Wait for it to finish, then try again.")+ }+ if err != nil {+ return nil, nil, err+ }+ defer lock.Release()+ var inst *instance.Instance+ err = u.Step(ctx, "Taking over your instance", func(ctx context.Context, s *ui.Step) error {+ state, done, err := instance.Import(dir, e)+ if err != nil {+ return takeoverError(err)+ }+ report = done+ inst = &instance.Instance{Dir: dir, State: state}+ s.Done("Took over your instance.")+ return nil+ })+ if err != nil {+ return nil, nil, err+ }+ installTakeoverBootUnit(ctx, app, inst, e)+ if e != nil {+ sendAdminImport(ctx, app, inst, e)+ }+ if refreshSetupDone(ctx, app, inst, e) {+ if err := inst.Save(); err != nil {+ return nil, nil, err+ }+ }+ for _, name := range report.KeepAsMine {+ warnKeptCopy(u, name, report.Mine[name], inst.State.Release == instance.LegacyRelease)+ }+ if line := report.DroppedLine(); line != "" && report.Source != instance.SourceEjected {+ u.Info("%s", line)+ }+ return inst, report.KeepAsMine, nil+}++func describeTakeover(u *ui.UI, r *instance.ImportReport) {+ switch r.Source {+ case instance.SourceEjected:+ u.Info("You manage the instance in %s yourself. rexctl takes it back with the settings in its .env file.", r.Dir)+ case instance.SourceRexctl:+ u.Info("An earlier rexctl manages the instance in %s. rexctl moves its settings out of .env.", r.Dir)+ default:+ u.Info("Found a Fluxer instance in %s.", r.Dir)+ }+ 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 {+ u.Info("Your own compose changes in %s will move to %s.", f, instance.CustomCompose)+ }+ }+ for _, name := range r.KeepAsMine {+ u.Info("Your copy of %s has changes. It keeps running, and a copy is saved as %s.", name, keptName(r, name))+ }+ if n := len(r.Minted); n == 1 {+ u.Info("One setting your instance is missing will be added.")+ } else if n > 1 {+ u.Info("%d settings your instance is missing will be added.", n)+ }+ if r.DedupedEnv {+ u.Info("Settings that appear twice in .env keep their last value.")+ }+ if len(r.Placeholders) > 0 {+ u.Info("These settings still have the example value from the old installer: %s. rexctl keeps them. Run rexctl config list to check them.", joinAnd(r.Placeholders))+ }+ if n := len(r.AdminKeys); n > 0 {+ u.Info("%s move into Fluxer's own settings, where rexctl config set changes them.", countWord(n, "One email, branding or billing setting", "email, branding and billing settings"))+ }+ if len(r.Changed) > 0 {+ u.Info("rexctl keeps the changes you made: %s.", joinAnd(r.Changed))+ }+ if r.PodmanCompose {+ u.Info("The first time rexctl starts or changes Fluxer, it replaces the containers podman-compose made. Fluxer restarts once and your data stays.")+ }+ for _, name := range r.DeleteFiles {+ if (name == "install.sh" || name == "install.ps1") && !isBootstrap(filepath.Join(r.Dir, name)) {+ u.Info("The old installer will be removed.")+ break+ }+ }+ if r.EngineProxies {+ u.Detail("proxy settings from the engine's config.json")+ }+ for _, f := range r.CustomFiles {+ u.Detail("custom file %s", f)+ }+ for _, f := range r.DeleteFiles {+ u.Detail("delete %s", f)+ }+ for _, k := range r.Minted {+ u.Detail("mint %s", k)+ }+ for _, k := range r.Defaults {+ u.Detail("default %s", k)+ }+ for _, k := range r.AdminKeys {+ u.Detail("admin %s", k)+ }+}++func keptName(r *instance.ImportReport, name string) string {+ if kept := r.Mine[name]; kept != "" {+ return kept+ }+ return name + ".mine"+}++func countWord(n int, one, many string) string {+ if n == 1 {+ return one+ }+ return fmt.Sprintf("%d %s", n, many)+}++func warnKeptCopy(u *ui.UI, name, kept string, legacy bool) {+ when := "before you run rexctl upgrade. The upgrade replaces"+ if !legacy {+ when = "now. The next time rexctl restarts or changes Fluxer, it replaces"+ }+ switch {+ case name == stack.Caddyfile:+ u.Warn(fmt.Sprintf("Your Caddyfile changes are also saved in %s.", kept), fmt.Sprintf("Move them into a file in %s %s the Caddyfile.", instance.CaddyDropInDir, when))+ case isComposeName(name):+ u.Warn(fmt.Sprintf("Your changes to %s are also saved in %s.", name, kept), fmt.Sprintf("Move them into %s %s %s.", instance.CustomCompose, when, name))+ }+}++type keptCopy struct {+ Name string+ Copy string+}++func keptCopies(inst *instance.Instance) []keptCopy {+ if inst == nil || inst.State == nil || inst.State.Release != instance.LegacyRelease {+ return nil+ }+ entries, err := os.ReadDir(inst.Dir)+ if err != nil {+ return nil+ }+ var out []keptCopy+ for _, ent := range entries {+ if ent.IsDir() {+ continue+ }+ m := keptPattern.FindStringSubmatch(ent.Name())+ if m == nil || (m[1] != stack.Caddyfile && !isComposeName(m[1])) {+ continue+ }+ out = append(out, keptCopy{Name: m[1], Copy: ent.Name()})+ }+ return out+}++var keptPattern = regexp.MustCompile(`^(.+)\.mine(?:\.[0-9]+)?$`)++func confirmKeptCopies(app *App, inst *instance.Instance) (bool, error) {+ kept := keptCopies(inst)+ if len(kept) == 0 {+ return true, nil+ }+ names := make([]string, 0, len(kept))+ for _, k := range kept {+ warnKeptCopy(app.UI, k.Name, k.Copy, true)+ names = append(names, k.Copy)+ }+ msg := fmt.Sprintf("Your changes in %s stop working after the upgrade.", joinAnd(names))+ if !app.UI.Interactive() || app.UI.Yes() {+ return false, ui.Refused(msg, "Move them, then delete the copies and run rexctl upgrade again.")+ }+ app.UI.Info("%s", msg)+ return app.UI.Confirm("Upgrade anyway?", false)+}++func isComposeName(name string) bool {+ ext := filepath.Ext(name)+ return name != instance.CustomCompose && (ext == ".yml" || ext == ".yaml")+}++func takeoverError(err error) error {+ var ae *instance.AdoptError+ if errors.As(err, &ae) {+ return ui.Refused(ae.Msg, ae.Fix)+ }+ var ej *instance.EjectedError+ if errors.As(err, &ej) {+ return ui.Refused(ej.Error(), ej.Fix())+ }+ return err+}++func installTakeoverBootUnit(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine) {+ if e == nil || !host.BootUnitSupported() {+ return+ }+ if err := installBootUnit(ctx, inst, e, nil); err != nil {+ app.UI.Detail("%v", err)+ app.UI.Warn("Fluxer won't start by itself when this machine restarts.", "Run rexctl doctor --fix to set that up.")+ }+}++func refreshSetupDone(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine) bool {+ if e == nil {+ return false+ }+ client := app.adminClient(inst, e.Named(inst.Project(), inst.Dir))+ client.OnSkew = nil+ done, err := setup.Done(ctx, client)+ if err != nil || done == inst.State.SetupDone {+ return false+ }+ inst.State.SetupDone = done+ return true+}