A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(rexctl): apply setting changes and revert on failure
Hampusc3a0357883d0
diff --git a/fluxer_rexctl/internal/deploy/apply.go b/fluxer_rexctl/internal/deploy/apply.gonew file mode 100644index 000000000..6aacea9fa--- /dev/null+++ b/fluxer_rexctl/internal/deploy/apply.go@@ -0,0 +1,104 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package deploy++import (+ "context"+ "maps"+ "slices"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+)++const edgeService = "edge"++func apply(ctx context.Context, inst *instance.Instance, e *engine.Engine, o ApplyOptions) (*Change, error) {+ if err := refuseEjected(inst); err != nil {+ return nil, err+ }+ if err := checkDrift(inst, true); err != nil {+ return nil, err+ }+ set, err := ReleaseSet(inst)+ if err != nil {+ return nil, err+ }+ r, err := render(inst, set, inst.State.Settings)+ if err != nil {+ return nil, err+ }+ mounted, err := mountedHashes(inst)+ if err != nil {+ return nil, err+ }+ restartEdge := len(r.RestartNeeded) > 0 || !maps.Equal(mounted, inst.State.Mounted)+ if err := save(inst); err != nil {+ return nil, err+ }+ s, err := specFor(inst, set, inst.State.Settings)+ if err != nil {+ return nil, err+ }+ p, err := e.Load(ctx, s)+ if err != nil {+ return nil, err+ }+ if o.Pull {+ if err := p.Pull(ctx, o.OnEvent); err != nil {+ return nil, err+ }+ }+ plan, err := p.Plan(ctx)+ if err != nil {+ return nil, err+ }+ if err := up(ctx, p, o.Wait, o.OnEvent); err != nil {+ return nil, err+ }+ change := &Change{Restarted: restarted(plan), Removed: slices.Clone(plan.Remove), Applied: true}+ if restartEdge && slices.Contains(p.Services(), edgeService) && !slices.Contains(change.Restarted, edgeService) {+ if err := p.Restart(context.WithoutCancel(ctx), edgeService); err != nil {+ return change, err+ }+ change.Restarted = append(change.Restarted, edgeService)+ }+ inst.State.Mounted = mounted+ if err := save(inst); err != nil {+ return change, err+ }+ return change, nil+}++func up(ctx context.Context, p *engine.Project, wait bool, onEvent func(engine.Event)) error {+ return p.Up(context.WithoutCancel(ctx), engine.UpOptions{+ Recreate: engine.RecreateChanged,+ RemoveOrphans: true,+ Wait: wait,+ WaitTimeout: engine.DefaultReadyTimeout,+ OnEvent: onEvent,+ })+}++func restarted(plan *engine.Plan) []string {+ out := append(slices.Clone(plan.Recreate), plan.Create...)+ slices.Sort(out)+ return slices.Compact(out)+}++func running(ctx context.Context, inst *instance.Instance, e *engine.Engine) (bool, error) {+ if inst.State.Stopped {+ return false, nil+ }+ containers, err := e.Named(inst.Project(), inst.Dir).PS(ctx)+ if err != nil {+ return false, err+ }+ for _, c := range containers {+ if c.State == "running" && !stack.OneShot[c.Service] {+ return true, nil+ }+ }+ return false, nil+}diff --git a/fluxer_rexctl/internal/deploy/set.go b/fluxer_rexctl/internal/deploy/set.gonew file mode 100644index 000000000..00a2e4dfc--- /dev/null+++ b/fluxer_rexctl/internal/deploy/set.go@@ -0,0 +1,417 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package deploy++import (+ "context"+ "errors"+ "fmt"+ "maps"+ "os"+ "slices"+ "strconv"+ "strings"+ "unicode"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/settings"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"+)++var ErrDeclined = errors.New("deploy: the change was declined")++var errIPv6NotApplied = errors.New("deploy: the network kept its old IPv6 setting")++var derivedVars = map[string][]string{+ settings.Domain: {"FLUXER_PUBLIC_ORIGIN", "FLUXER_EDGE_SITE_ADDRESS"},+ settings.EdgeHTTPSPort: {"FLUXER_PUBLIC_PORT", "FLUXER_PUBLIC_ORIGIN"},+ settings.EdgePublicPort: {"FLUXER_PUBLIC_ORIGIN"},+}++func Promised(set *stack.Set, custom []byte, k settings.Key) []string {+ switch k.Name {+ case settings.EngineHost:+ return nil+ case settings.EdgeMode, settings.IPv6, settings.ImagesRegistry, settings.StorageEndpoint:+ return slices.Clone(stack.Services)+ case settings.MemoryProfile:+ return settings.Services(set, custom, stack.ProfileKeys(set))+ }+ return settings.Services(set, custom, append(slices.Clone(k.Vars), derivedVars[k.Name]...))+}++func Lookup(set *stack.Set, custom []byte, name string) (settings.Key, error) {+ vars, err := settings.Vars(set, custom)+ if err != nil {+ return settings.Key{}, ui.Wrap(err, fmt.Sprintf("rexctl can't read %s.", instance.CustomCompose), "Fix the file, then try again.")+ }+ k, err := settings.Lookup(set, vars, name, nil)+ if err != nil {+ return settings.Key{}, keyError(err)+ }+ return k, nil+}++func keyError(err error) error {+ var se *settings.Error+ if errors.As(err, &se) {+ return &ui.ExitError{Code: ui.ExitRefused, Msg: se.Problem, Fix: se.Fix, Err: err}+ }+ return err+}++func set(ctx context.Context, inst *instance.Instance, e *engine.Engine, changes map[string]*string, o ApplyOptions) (*Change, error) {+ keys := slices.Sorted(maps.Keys(changes))+ if err := refuseEjected(inst); err != nil {+ return nil, err+ }+ if err := refuseUpgrade(inst); err != nil {+ return nil, err+ }+ if inst.State.Pending != nil {+ return nil, ui.Refused("An earlier settings change didn't finish.", "Run rexctl doctor --fix to put the old values back, then try again.")+ }+ if _, ok := changes[settings.EngineHost]; ok {+ if len(changes) > 1 {+ return nil, ui.Usage("Change engine.host on its own, without other settings.")+ }+ return setEngineHost(ctx, inst, e, changes[settings.EngineHost])+ }+ if err := checkDrift(inst, false); err != nil {+ return nil, err+ }+ rs, err := ReleaseSet(inst)+ if err != nil {+ return nil, err+ }+ custom, err := CustomFile(inst)+ if err != nil {+ return nil, err+ }+ st := inst.State+ next := maps.Clone(st.Settings)+ var promised, changed []string+ for _, name := range keys {+ k, err := Lookup(rs, custom, name)+ if err != nil {+ return nil, err+ }+ if k.Kind == settings.Instance {+ return nil, fmt.Errorf("deploy: %s is an instance setting", name)+ }+ v := changes[name]+ current, had := st.Settings[name]+ if v == nil {+ delete(next, name)+ } else {+ if err := validate(k, *v); err != nil {+ return nil, err+ }+ next[name] = *v+ if k.Kind == settings.Deployment {+ for _, raw := range k.Vars {+ delete(next, raw)+ }+ }+ }+ if differs := (v == nil && had) || (v != nil && (!had || current != *v)); differs {+ if k.Stateful {+ return nil, ui.Refused(+ fmt.Sprintf("rexctl doesn't change %s once Fluxer has stored data with it.", name),+ "Restore a backup made with the value you want with rexctl restore.")+ }+ changed = append(changed, name)+ promised = append(promised, Promised(rs, custom, k)...)+ }+ }+ if maps.Equal(next, st.Settings) {+ return &Change{Keys: keys, Unchanged: true}, nil+ }+ if next[settings.StorageSecret] != st.Settings[settings.StorageSecret] && next[settings.StorageEndpoint] == "" && next[settings.StorageSecret] != "" {+ return nil, ui.Refused("storage.secret_key only applies to your own object store.", "Set storage.endpoint in the same command, for example rexctl config set storage.endpoint=https://s3.example.com storage.secret_key=-.")+ }+ oldEnv, err := Environment(rs, st, st.Settings)+ if err != nil {+ return nil, err+ }+ newEnv, err := Environment(rs, st, next)+ if err != nil {+ return nil, err+ }+ staged, err := stageOverlays(inst, rs, next)+ if err != nil {+ return nil, err+ }+ rendered := false+ defer func() {+ if !rendered {+ for _, p := range staged {+ os.Remove(p)+ }+ }+ }()+ newP, err := e.Load(ctx, engine.Spec{Name: inst.Project(), Dir: inst.Dir, Files: composeFiles(inst, next), Env: newEnv})+ if err != nil {+ return nil, &ui.ExitError{Code: ui.ExitRefused, Err: err,+ Msg: "Fluxer can't start with that value.",+ Fix: fmt.Sprintf("Run rexctl config get %s to see what it takes, then try again.", keys[0])}+ }+ oldP, err := e.Load(ctx, engine.Spec{Name: inst.Project(), Dir: inst.Dir, Files: composeFiles(inst, st.Settings), Env: oldEnv})+ if err != nil {+ return nil, err+ }+ if err := checkPostgres(oldP, newP); err != nil {+ return nil, err+ }+ live, err := running(ctx, inst, e)+ if err != nil {+ return nil, err+ }+ ipv6 := parseBool(st.Settings[settings.IPv6]) != parseBool(next[settings.IPv6])+ slices.Sort(promised)+ preview := Preview{Keys: changed, Promised: slices.Compact(promised)}+ if live {+ if err := oldP.Pull(ctx, o.OnEvent); err != nil {+ return nil, err+ }+ plan, err := newP.Plan(ctx)+ if err != nil {+ return nil, err+ }+ preview.Restarts, preview.Removes, preview.Networks = restarted(plan), slices.Clone(plan.Remove), slices.Clone(plan.Networks)+ if ipv6 {+ preview.Restarts = newP.Services()+ }+ }+ added, _ := portDiff(oldEnv, newEnv)+ if err := checkPortsFree(added); err != nil {+ return nil, err+ }+ if o.Confirm != nil && !o.Confirm(preview) {+ return nil, ErrDeclined+ }++ if !live {+ if ipv6 {+ if err := e.Named(inst.Project(), inst.Dir).Down(context.WithoutCancel(ctx), false); err != nil {+ return nil, err+ }+ }+ st.Settings = next+ if _, err := render(inst, rs, next); err != nil {+ return nil, err+ }+ rendered = true+ if err := save(inst); err != nil {+ return nil, err+ }+ return &Change{Keys: changed}, nil+ }++ if err := newP.Pull(ctx, o.OnEvent); err != nil {+ return nil, err+ }+ st.Pending = &instance.Pending{Settings: next, Keys: changed, StartedAt: now()}+ if err := save(inst); err != nil {+ st.Pending = nil+ return nil, err+ }+ _, err = render(inst, rs, next)+ rendered = err == nil+ if err == nil {+ err = save(inst)+ }+ if err == nil {+ err = bringUp(ctx, oldP, newP, ipv6, o.OnEvent)+ }+ if err != nil {+ if o.Failed != nil {+ o.Failed(newP, err)+ }+ rerr := revert(ctx, inst, rs, oldP, ipv6, o.OnEvent)+ return &Change{Keys: changed, Reverted: rerr == nil}, errors.Join(err, rerr)+ }+ st.Settings = next+ st.Pending = nil+ if err := save(inst); err != nil {+ return nil, err+ }+ return &Change{Keys: changed, Restarted: preview.Restarts, Removed: preview.Removes, Applied: true}, nil+}++func bringUp(ctx context.Context, oldP, newP *engine.Project, ipv6 bool, onEvent func(engine.Event)) error {+ bg := context.WithoutCancel(ctx)+ if ipv6 {+ if err := oldP.Down(bg, false); err != nil {+ return err+ }+ }+ if err := up(ctx, newP, true, onEvent); err != nil {+ return err+ }+ if !ipv6 {+ return nil+ }+ plan, err := newP.Plan(bg)+ if err != nil {+ return err+ }+ if len(plan.Networks) > 0 {+ return errIPv6NotApplied+ }+ return nil+}++func revert(ctx context.Context, inst *instance.Instance, rs *stack.Set, oldP *engine.Project, ipv6 bool, onEvent func(engine.Event)) error {+ bg := context.WithoutCancel(ctx)+ inst.State.Pending = nil+ if _, err := render(inst, rs, inst.State.Settings); err != nil {+ return err+ }+ if err := save(inst); err != nil {+ return err+ }+ if ipv6 {+ if err := oldP.Down(bg, false); err != nil {+ return err+ }+ }+ return up(bg, oldP, true, onEvent)+}++func stageOverlays(inst *instance.Instance, rs *stack.Set, chosen map[string]string) ([]string, error) {+ var created []string+ for _, o := range stack.OverlaysFor(chosen) {+ name := stack.OverlayFiles[o]+ target := inst.Path(name)+ if _, err := os.Stat(target); err == nil {+ continue+ }+ data, err := stack.ReadFile(rs, name)+ if err == nil {+ err = os.WriteFile(target, data, 0o644)+ }+ if err != nil {+ for _, p := range created {+ os.Remove(p)+ }+ return nil, ui.Wrap(err, "Couldn't write Fluxer's files.", "Check that you can write to "+inst.Dir+", then try again.")+ }+ created = append(created, target)+ }+ return created, nil+}++func checkPostgres(oldP, newP *engine.Project) error {+ const svc = "postgres"+ before, after := oldP.Image(svc), newP.Image(svc)+ if before == "" || after == "" || before == after {+ return nil+ }+ was, err1 := stack.PostgresMajor(before)+ will, err2 := stack.PostgresMajor(after)+ if err1 != nil || err2 != nil || was == will {+ return nil+ }+ return ui.Refused(+ fmt.Sprintf("Your database runs Postgres %d and that image has Postgres %d.", was, will),+ fmt.Sprintf("Use a Postgres %d image. rexctl upgrade moves the database to a new major version when a release needs it.", was))+}++func setEngineHost(ctx context.Context, inst *instance.Instance, e *engine.Engine, v *string) (*Change, error) {+ keys := []string{settings.EngineHost}+ st := inst.State+ if v == nil {+ if st.Engine.Host == "" {+ return &Change{Keys: keys, Unchanged: true}, nil+ }+ st.Engine.Host = ""+ if err := save(inst); err != nil {+ return nil, err+ }+ return &Change{Keys: keys, Applied: true}, nil+ }+ for _, k := range settings.Named() {+ if k.Name == settings.EngineHost {+ if err := validate(k, *v); err != nil {+ return nil, err+ }+ }+ }+ if *v == st.Engine.Host {+ return &Change{Keys: keys, Unchanged: true}, nil+ }+ target, err := engine.Connect(ctx, engine.ConnectOptions{Host: *v, AllowOld: true})+ if err != nil {+ return nil, ui.Wrap(err, fmt.Sprintf("rexctl can't connect to an engine at %s.", *v), "Check the address and that the engine is running, then try again.")+ }+ defer target.Close()+ if target.ID != e.ID {+ there, err := target.Volumes(ctx, inst.Project())+ if err != nil {+ return nil, err+ }+ here, err := e.Volumes(ctx, inst.Project())+ if err != nil {+ return nil, err+ }+ if len(there) == 0 && len(here) > 0 {+ return nil, ui.Refused("That engine has none of this instance's data.", "Move the instance with rexctl backup, then rexctl restore on the other engine.")+ }+ }+ st.Engine = instance.EngineRef{Kind: string(target.Kind), Host: *v, ID: target.ID}+ if err := save(inst); err != nil {+ return nil, err+ }+ return &Change{Keys: keys, Applied: true}, nil+}++func validate(k settings.Key, v string) error {+ if k.Validate == nil {+ return nil+ }+ err := k.Validate(v)+ switch {+ case err == nil:+ return nil+ case k.Secret:+ return ui.Usage(fmt.Sprintf("That value doesn't work for %s. %s", k.Name, err.Error()))+ }+ shown := strconv.Quote(v)+ if strings.IndexFunc(v, unicode.IsControl) < 0 {+ shown = `"` + v + `"`+ }+ return ui.Usage(fmt.Sprintf("%s can't be %s. %s", k.Name, shown, err.Error()))+}++func (p Preview) Larger() bool {+ return len(p.Networks) > 0 || !subset(p.Restarts, p.Promised) || !subset(p.Removes, p.Promised)+}++func (p Preview) Notes() []string {+ var out []string+ for _, k := range settings.Named() {+ if k.Confirm != "" && slices.Contains(p.Keys, k.Name) && !slices.Contains(out, k.Confirm) {+ out = append(out, k.Confirm)+ }+ }+ return out+}++func (p Preview) NeedsConfirm() bool { return p.Larger() || len(p.Notes()) > 0 }++func subset(items, of []string) bool {+ for _, s := range items {+ if !slices.Contains(of, s) {+ return false+ }+ }+ return true+}++func parseBool(v string) bool {+ b, _ := strconv.ParseBool(v)+ return b+}