A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(rexctl): add config command
Hampus81e7902e7863
diff --git a/fluxer_rexctl/cmd/config.go b/fluxer_rexctl/cmd/config.gonew file mode 100644index 000000000..12690962a--- /dev/null+++ b/fluxer_rexctl/cmd/config.go@@ -0,0 +1,859 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package cmd++import (+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "io"+ "maps"+ "reflect"+ "slices"+ "strings"++ "github.com/spf13/cobra"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/adminapi"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/deploy"+ "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/settings"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"+)++const maxValueWidth = 60++func clip(s string) string {+ s = strings.Join(strings.Fields(s), " ")+ if n := len([]rune(s)); n > maxValueWidth {+ return fmt.Sprintf("%d characters", n)+ }+ return s+}++func describeType(k adminapi.ConfigKey) string {+ switch k.Type {+ case "list":+ return "a comma-separated list"+ case "json":+ return "JSON"+ case "secret":+ return "a secret. Pass - to read it from stdin"+ case "integer":+ return "a whole number"+ case "boolean":+ return "true or false"+ }+ if len(k.Options) > 0 {+ return adminapi.JoinOr(k.Options)+ }+ switch k.Type {+ case "number":+ return "a number"+ }+ return "text"+}++var deploymentTypes = map[string]string{+ "hostname": "a domain name, like chat.example.com",+ "address": "an address and port, like 127.0.0.1:8080",+ "port": "a port number",+ "list": "a comma-separated list",+ "ip": "an IP address, or nothing to let Fluxer find it",+ "url": "a full address that starts with https://",+ "bool": "true or false",+ "secret": "a secret. Pass - to read it from stdin",+ "image": "an image reference, like postgres:16-alpine",+ "registry": "a registry host, like registry.example.com",+ "endpoint": "an engine address, like " + settings.EngineExample(),+}++func describeDeployType(k settings.Key) string {+ if len(k.Options) > 0 {+ return adminapi.JoinOr(k.Options)+ }+ if k.Secret {+ return deploymentTypes["secret"]+ }+ if t, ok := deploymentTypes[k.Type]; ok {+ return t+ }+ return "text"+}++type configView struct {+ inst *instance.Instance+ set *stack.Set+ custom []byte+ vars []string+ schema []adminapi.ConfigKey+}++func loadConfigView(app *App) (*configView, error) {+ inst, err := app.Instance()+ if err != nil {+ return nil, err+ }+ set, err := deploy.ReleaseSet(inst)+ if err != nil {+ return nil, err+ }+ custom, err := deploy.CustomFile(inst)+ if err != nil {+ return nil, err+ }+ vars, err := settings.Vars(set, custom)+ if err != nil {+ return nil, ui.Wrap(err, fmt.Sprintf("rexctl can't read %s.", instance.CustomCompose), "Fix the file, then try again.")+ }+ schema, err := adminapi.ConfigSchema()+ if err != nil {+ return nil, err+ }+ return &configView{inst: inst, set: set, custom: custom, vars: vars, schema: schema}, nil+}++func (v *configView) lookup(name string) (settings.Key, error) {+ k, err := settings.Lookup(v.set, v.vars, strings.TrimSpace(name), v.schema)+ var se *settings.Error+ if errors.As(err, &se) {+ return settings.Key{}, &ui.ExitError{Code: ui.ExitUsage, Msg: se.Problem, Fix: se.Fix, Err: err}+ }+ return k, err+}++func (v *configView) value(k settings.Key) string {+ st := v.inst.State+ if k.Name == settings.EngineHost {+ return st.Engine.Host+ }+ if value, ok := st.Settings[k.Name]; ok {+ return value+ }+ if k.Kind == settings.Raw {+ if value, ok := st.Secrets[k.Name]; ok {+ return value+ }+ }+ return v.fallback(k, v.inst)+}++func (v *configView) fallback(k settings.Key, inst *instance.Instance) string {+ switch k.Name {+ case settings.EdgeMode:+ return settings.EdgeBundled+ case settings.IPv6:+ return "false"+ }+ if len(k.Vars) == 0 {+ return ""+ }+ return inst.Setting(k.Vars[0])+}++func (v *configView) defaultOf(k settings.Key) string {+ st := *v.inst.State+ st.Settings = maps.Clone(st.Settings)+ delete(st.Settings, k.Name)+ tmp := *v.inst+ tmp.State = &st+ return v.fallback(k, &tmp)+}++func (v *configView) applies(k settings.Key) string {+ if k.Kind == settings.Instance {+ return "Right away"+ }+ if k.Name == settings.EngineHost {+ return "Next command"+ }+ return restartText(deploy.Promised(v.set, v.custom, k))+}++func partsOf(services []string) []string {+ var parts []string+ for _, p := range logParts {+ for _, svc := range p.services {+ if slices.Contains(services, svc) && !slices.Contains(parts, p.name) {+ parts = append(parts, p.name)+ }+ }+ }+ return parts+}++func extraRestartText(p deploy.Preview) string {+ promised := partsOf(p.Promised)+ if len(promised) > 2 {+ return ""+ }+ all := partsOf(append(slices.Clone(p.Restarts), p.Removes...))+ var extra []string+ for _, part := range all {+ if !slices.Contains(promised, part) {+ extra = append(extra, part)+ }+ }+ switch {+ case len(all) > 2:+ return "This restarts all of Fluxer."+ case len(extra) == 0:+ return "This also restarts other Fluxer services."+ }+ return "This also restarts " + joinAnd(extra) + "."+}++func restartText(services []string) string {+ parts := partsOf(services)+ switch {+ case len(parts) == 0:+ return "Right away"+ case len(parts) > 2:+ return "Restarts Fluxer"+ }+ return "Restarts " + joinAnd(parts)+}++type configRow struct {+ Key string `json:"key"`+ Kind string `json:"kind"`+ Type string `json:"type"`+ Value any `json:"value"`+ Default any `json:"default,omitempty"`+ Secret bool `json:"secret"`+ Restarts []string `json:"restarts"`+ Help string `json:"help,omitempty"`+}++func (v *configView) row(k settings.Key, reveal bool) configRow {+ value := v.value(k)+ shown := settings.Mask(k, value)+ if reveal {+ shown = value+ }+ r := configRow{Key: k.Name, Kind: "deployment", Type: k.Type, Value: shown, Secret: k.Secret, Help: k.Help, Restarts: []string{}}+ if k.Name != settings.EngineHost {+ r.Restarts = deploy.Promised(v.set, v.custom, k)+ }+ if def := v.defaultOf(k); def != "" {+ r.Default = settings.Mask(k, def)+ }+ return r+}++func (v *configView) deploymentKeys(all bool) []settings.Key {+ var out []settings.Key+ for _, k := range settings.Named() {+ if _, err := settings.Lookup(v.set, v.vars, k.Name, nil); err == nil {+ out = append(out, k)+ }+ }+ st := v.inst.State+ var raw []string+ for name := range st.Settings {+ raw = append(raw, name)+ }+ if all {+ raw = append(raw, v.vars...)+ for name := range st.Secrets {+ raw = append(raw, name)+ }+ }+ slices.Sort(raw)+ for _, name := range slices.Compact(raw) {+ k, err := settings.Lookup(v.set, v.vars, name, nil)+ if err == nil && k.Kind == settings.Raw {+ out = append(out, k)+ }+ }+ return out+}++func newConfigCmd(app *App) *cobra.Command {+ c := &cobra.Command{Use: "config", Short: "Read and change Fluxer's settings", Args: noArgs}+ c.AddCommand(newConfigListCmd(app), newConfigGetCmd(app), newConfigSetCmd(app), newConfigUnsetCmd(app), newConfigRenderCmd(app))+ return c+}++func newConfigListCmd(app *App) *cobra.Command {+ var all bool+ list := &cobra.Command{Use: "list", Short: "List every setting with its value and help", Args: noArgs}+ app.jsonFlag(list)+ list.Flags().BoolVar(&all, "all", false, "also list every raw setting and the secrets rexctl generated")+ list.RunE = func(c *cobra.Command, _ []string) error {+ ctx := c.Context()+ v, err := loadConfigView(app)+ if err != nil {+ return err+ }+ var rows []configRow+ var table [][]string+ for _, k := range v.deploymentKeys(all) {+ r := v.row(k, false)+ if _, generated := v.inst.State.Secrets[k.Name]; generated && k.Kind == settings.Raw {+ if _, chosen := v.inst.State.Settings[k.Name]; !chosen {+ r.Value = "generated"+ }+ }+ rows = append(rows, r)+ table = append(table, []string{r.Key, clip(fmt.Sprint(r.Value)), v.applies(k), r.Help})+ }+ instanceKeys, apiErr := instanceValues(ctx, app)+ for _, k := range instanceKeys {+ rows = append(rows, configRow{Key: k.Key, Kind: "instance", Type: k.Type, Value: k.Value, Default: k.Default,+ Secret: k.Type == "secret", Restarts: []string{}, Help: k.Help})+ table = append(table, []string{k.Key, clip(adminapi.FormatValue(k)), "Right away", k.Help})+ }+ if app.Flags.JSON {+ return app.UI.JSON(rows)+ }+ app.UI.Table([]string{"Setting", "Value", "Applies", "Help"}, table)+ if errors.Is(apiErr, adminapi.ErrNoRelay) {+ app.UI.Info("The other settings need a newer Fluxer release. Run rexctl upgrade to see them.")+ } else if apiErr != nil {+ app.UI.Info("The other settings need Fluxer running. Run rexctl start to see them.")+ app.UI.Detail("%v", apiErr)+ }+ return nil+ }+ return list+}++func instanceValues(ctx context.Context, app *App) ([]adminapi.ConfigKey, error) {+ api, _, err := app.Admin(ctx)+ if err != nil {+ return nil, err+ }+ return api.ConfigValues(ctx)+}++func newConfigGetCmd(app *App) *cobra.Command {+ var reveal bool+ get := &cobra.Command{Use: "get <key>", Short: "Show one setting", Args: exactArgs("a setting name")}+ app.jsonFlag(get)+ get.Flags().BoolVar(&reveal, "reveal", false, "print a secret rexctl keeps")+ get.RunE = func(c *cobra.Command, args []string) error {+ v, err := loadConfigView(app)+ if err != nil {+ return err+ }+ k, err := v.lookup(args[0])+ if err != nil {+ return err+ }+ if k.Kind == settings.Instance {+ if reveal {+ return ui.Usage(fmt.Sprintf("Fluxer doesn't show %s once it's saved.", k.Name))+ }+ return getInstanceKey(c, app, k.Name)+ }+ r := v.row(k, reveal)+ if app.Flags.JSON {+ return app.UI.JSON(r)+ }+ value := v.value(k)+ if reveal {+ app.UI.Result(value)+ return nil+ }+ shown := settings.Mask(k, value)+ if k.Secret && value == "" {+ shown = "not set"+ }+ rows := [][]string{{"Value", shown}, {"Takes", describeDeployType(k)}}+ if r.Default != nil {+ rows = append(rows, []string{"Default", fmt.Sprint(r.Default)})+ }+ rows = append(rows, []string{"Applies", v.applies(k)})+ if k.Help != "" {+ rows = append(rows, []string{"Help", k.Help})+ }+ app.UI.Table([]string{"Setting", k.Name}, rows)+ return nil+ }+ return get+}++func getInstanceKey(c *cobra.Command, app *App, name string) error {+ return adminRead(c, app, func(ctx context.Context, api *adminapi.Client, _ *instance.Instance) error {+ values, err := api.ConfigValues(ctx)+ if err != nil {+ return err+ }+ k, err := adminapi.FindConfigKey(values, name)+ if err != nil {+ return err+ }+ if app.Flags.JSON {+ return app.UI.JSON(configRow{Key: k.Key, Kind: "instance", Type: k.Type, Value: k.Value, Default: k.Default,+ Secret: k.Type == "secret", Restarts: []string{}, Help: k.Help})+ }+ rows := [][]string{{"Value", adminapi.FormatValue(k)}, {"Takes", describeType(k)}}+ if k.Default != nil {+ rows = append(rows, []string{"Default", fmt.Sprint(k.Default)})+ }+ rows = append(rows, []string{"Applies", "Right away"}, []string{"Help", k.Help})+ app.UI.Table([]string{"Setting", k.Key}, rows)+ return nil+ })+}++type configChange struct {+ name string+ value *string+}++func parseSetArgs(app *App, args []string) ([]configChange, error) {+ var out []configChange+ if len(args) == 2 && !strings.Contains(args[0], "=") {+ out = []configChange{{name: args[0], value: &args[1]}}+ } else {+ for _, a := range args {+ name, value, ok := strings.Cut(a, "=")+ if !ok || strings.TrimSpace(name) == "" {+ return nil, ui.Usage(fmt.Sprintf("%q isn't a setting=value pair.", a))+ }+ out = append(out, configChange{name: name, value: &value})+ }+ }+ stdin := false+ seen := map[string]bool{}+ for i, ch := range out {+ out[i].name = strings.TrimSpace(ch.name)+ if seen[out[i].name] {+ return nil, ui.Usage(fmt.Sprintf("%s is in the command twice.", out[i].name))+ }+ seen[out[i].name] = true+ if *ch.value != "-" {+ continue+ }+ if stdin {+ return nil, ui.Usage("Only one setting can read its value from stdin.")+ }+ stdin = true+ data, err := io.ReadAll(app.UI.Stdin())+ if err != nil {+ return nil, ui.Failed("Couldn't read the value from stdin.", "Pass the value again.")+ }+ value := strings.TrimRight(string(data), "\r\n")+ if value == "" {+ return nil, ui.Usage(fmt.Sprintf("The value for %s on stdin is empty.", out[i].name))+ }+ out[i].value = &value+ }+ return out, nil+}++func newConfigSetCmd(app *App) *cobra.Command {+ set := &cobra.Command{+ Use: "set <key> <value> | <key>=<value>...",+ Short: "Change one or more settings",+ Args: func(c *cobra.Command, args []string) error {+ if len(args) == 0 {+ return ui.Usage("Pass a setting and its value.")+ }+ return nil+ },+ }+ set.RunE = func(c *cobra.Command, args []string) error {+ changes, err := parseSetArgs(app, args)+ if err != nil {+ return err+ }+ return runConfigChange(c.Context(), app, changes)+ }+ return set+}++func newConfigUnsetCmd(app *App) *cobra.Command {+ unset := &cobra.Command{+ Use: "unset <key>...",+ Short: "Go back to the default for one or more settings",+ Args: func(c *cobra.Command, args []string) error {+ if len(args) == 0 {+ return ui.Usage("Pass a setting name.")+ }+ return nil+ },+ }+ unset.RunE = func(c *cobra.Command, args []string) error {+ var changes []configChange+ for _, a := range args {+ changes = append(changes, configChange{name: strings.TrimSpace(a)})+ }+ return runConfigChange(c.Context(), app, changes)+ }+ return unset+}++func runConfigChange(ctx context.Context, app *App, changes []configChange) error {+ v, err := loadConfigView(app)+ if err != nil {+ return err+ }+ deployment := map[string]*string{}+ var admin []adminChange+ for _, ch := range changes {+ k, err := v.lookup(ch.name)+ if err != nil {+ return err+ }+ if k.Kind != settings.Instance {+ deployment[k.Name] = ch.value+ continue+ }+ ac, err := parseAdminChange(v.schema, k.Name, ch.value)+ if err != nil {+ return err+ }+ admin = append(admin, ac)+ }+ finish := func(change *deploy.Change) error {+ sent, err := applyAdminChanges(ctx, app, v.inst, admin)+ if err != nil {+ return err+ }+ reportConfigChange(app, change, deployment, sent)+ names := slices.Collect(maps.Keys(deployment))+ for _, ac := range admin {+ names = append(names, ac.key.Key)+ }+ removed, err := instance.SettleEnv(v.inst, names)+ if err != nil {+ return ui.Wrap(err, "Couldn't remove the .env file rexctl doesn't read.", "Delete "+v.inst.Path(instance.EnvFileName)+" yourself.")+ }+ if removed != "" {+ app.UI.Info("Removed %s. You changed every setting in it with rexctl.", removed)+ }+ return nil+ }+ if len(deployment) == 0 {+ return app.Locked(ctx, v.inst, func() error { return finish(nil) })+ }+ return app.ChangeSettings(ctx, v.inst, func(e *engine.Engine) error {+ change, err := applySettings(ctx, app, v.inst, e, deployment, "Applying the new settings")+ if err != nil {+ return err+ }+ return finish(change)+ })+}++func reportConfigChange(app *App, change *deploy.Change, values map[string]*string, admin []adminChange) {+ var keys []string+ if change != nil && !change.Unchanged {+ keys = change.Keys+ }+ switch {+ case len(keys) == 0 && len(admin) == 0:+ app.UI.OK("Nothing to change.")+ return+ case len(keys)+len(admin) > 1:+ app.UI.OK("Saved %d settings.", len(keys)+len(admin))+ case len(admin) == 1:+ app.UI.OK("%s", admin[0].done())+ default:+ app.UI.OK("%s", deploymentDone(keys[0], values[keys[0]]))+ }+ if len(keys) > 0 && !change.Applied {+ app.UI.Info("Fluxer uses the new settings the next time it starts.")+ }+}++func deploymentDone(name string, value *string) string {+ switch {+ case value == nil:+ return fmt.Sprintf("%s is back to its default.", name)+ case settings.SecretName(name) || name == settings.StorageSecret:+ return fmt.Sprintf("Saved %s.", name)+ }+ return fmt.Sprintf("Set %s to %s.", name, clip(settings.Mask(settings.Key{}, *value)))+}++type adminChange struct {+ key adminapi.ConfigKey+ value any+ patch map[string]any+ mode string+}++func (a adminChange) done() string {+ switch {+ case a.mode != "":+ return registrationDone[a.mode]+ case a.patch != nil && a.value == nil:+ return fmt.Sprintf("Cleared %s.", a.key.Key)+ case a.key.Type == "secret":+ return fmt.Sprintf("Saved %s.", a.key.Key)+ }+ k := a.key+ k.Value = a.value+ return fmt.Sprintf("Set %s to %s.", k.Key, clip(adminapi.FormatValue(k)))+}++func parseAdminChange(schema []adminapi.ConfigKey, name string, raw *string) (adminChange, error) {+ k, err := adminapi.FindConfigKey(schema, name)+ if err != nil {+ return adminChange{}, adminapi.Explain(err)+ }+ if raw == nil {+ if !k.Nullable {+ return adminChange{}, ui.Refused(fmt.Sprintf("Fluxer can't clear %s.", k.Key), fmt.Sprintf("Set another value with rexctl config set %s <value>.", k.Key))+ }+ return adminChange{key: k, patch: adminapi.ConfigPatch(k.Key, nil)}, nil+ }+ if k.Key == adminapi.RegistrationModeKey {+ mode := strings.ToLower(strings.TrimSpace(*raw))+ patch, err := adminapi.RegistrationPatch(mode)+ if err != nil {+ return adminChange{}, ui.Usage(fmt.Sprintf("%s needs one of %s.", k.Key, adminapi.JoinOr(adminapi.RegistrationModes)))+ }+ return adminChange{key: k, value: mode, patch: patch, mode: mode}, nil+ }+ value, err := adminapi.ParseConfigValue(k, *raw)+ if err != nil {+ return adminChange{}, adminapi.Explain(err)+ }+ return adminChange{key: k, value: value, patch: adminapi.ConfigPatch(k.Key, value)}, nil+}++func applyAdminChanges(ctx context.Context, app *App, inst *instance.Instance, changes []adminChange) ([]adminChange, error) {+ pendingImport := inst.State.AdminImport != nil && inst.State.AdminImport.SentAt == ""+ if len(changes) == 0 && !pendingImport {+ return nil, nil+ }+ api, _, err := app.Admin(ctx)+ if err != nil {+ if len(changes) == 0 {+ return nil, nil+ }+ return nil, err+ }+ if pendingImport {+ if err := deploy.SendAdminImport(ctx, inst, api); err != nil {+ app.UI.Detail("%v", err)+ }+ }+ if len(changes) == 0 {+ return nil, nil+ }+ current, err := api.ConfigValues(ctx)+ if err != nil {+ return nil, adminapi.Explain(err)+ }+ patch := map[string]any{}+ var sent []adminChange+ for _, ch := range changes {+ if ch.mode == "" && ch.key.Type != "secret" {+ if k, err := adminapi.FindConfigKey(current, ch.key.Key); err == nil && sameValue(k.Value, ch.value) {+ continue+ }+ }+ adminapi.MergePatch(patch, ch.patch)+ sent = append(sent, ch)+ }+ if len(sent) == 0 {+ return nil, nil+ }+ if err := api.PatchConfig(ctx, patch); err != nil {+ return nil, adminapi.Explain(err)+ }+ return sent, nil+}++func sameValue(a, b any) bool {+ ja, err1 := json.Marshal(a)+ jb, err2 := json.Marshal(b)+ if err1 != nil || err2 != nil {+ return reflect.DeepEqual(a, b)+ }+ var na, nb any+ if json.Unmarshal(ja, &na) != nil || json.Unmarshal(jb, &nb) != nil {+ return false+ }+ return reflect.DeepEqual(na, nb)+}++type setResult struct {+ change *deploy.Change+ err error+}++func applySettings(ctx context.Context, app *App, inst *instance.Instance, e *engine.Engine, changes map[string]*string, title string) (*deploy.Change, error) {+ closePorts, err := openPorts(ctx, app, inst, changes)+ if err != nil {+ return nil, err+ }+ ask := make(chan deploy.Preview)+ answer := make(chan bool)+ done := make(chan setResult, 1)+ var logPath string+ opts := deploy.ApplyOptions{+ Failed: func(p *engine.Project, err error) {+ logPath = writeFailureLog(ctx, inst, p, "start.log", err, nil)+ },+ Wait: true,+ Confirm: func(p deploy.Preview) bool {+ ask <- p+ return <-answer+ },+ OnEvent: func(ev engine.Event) {+ if ev.Text != "" {+ app.UI.Detail("%s %s", ev.ID, ev.Text)+ }+ },+ }+ go func() {+ change, err := deploy.Set(ctx, inst, e, changes, opts)+ done <- setResult{change, err}+ }()+ var r setResult+ select {+ case r = <-done:+ case p := <-ask:+ ok, err := confirmPreview(app, p)+ answer <- ok && err == nil+ if err != nil {+ <-done+ return nil, err+ }+ if ok {+ _ = app.UI.Step(ctx, title, func(context.Context, *ui.Step) error {+ r = <-done+ return nil+ })+ } else {+ r = <-done+ }+ }+ if errors.Is(r.err, deploy.ErrDeclined) {+ return nil, &ui.ExitError{Code: ui.ExitRefused, Msg: "rexctl left your settings as they were.", Err: r.err}+ }+ if r.err != nil {+ return nil, settingsFailure(r.change, r.err, logPath)+ }+ if r.change.Applied && !r.change.Unchanged {+ closePorts()+ }+ return r.change, nil+}++func settingsFailure(change *deploy.Change, err error, logPath string) error {+ var ee *ui.ExitError+ if errors.As(err, &ee) {+ return err+ }+ switch {+ case change != nil && change.Reverted:+ fix := "Run rexctl logs to see why."+ if logPath != "" {+ fix = "Read " + logPath + " to see why."+ }+ return ui.Wrap(err, "Fluxer didn't start with the new settings. rexctl put the old ones back.", fix)+ case change != nil:+ return ui.Wrap(err, "Fluxer didn't start with the new settings, and rexctl couldn't put the old ones back.", "Run rexctl doctor to see what's wrong.")+ }+ return engineFailure(err)+}++func confirmPreview(app *App, p deploy.Preview) (bool, error) {+ if !p.NeedsConfirm() {+ return true, nil+ }+ for _, note := range p.Notes() {+ app.UI.Info("%s", note)+ }+ if p.Larger() {+ if len(p.Networks) > 0 {+ app.UI.Info("Fluxer restarts completely to change its network.")+ } else {+ if text := extraRestartText(p); text != "" {+ app.UI.Info("%s", text)+ }+ }+ if app.UI.Verbose() {+ app.UI.Detail("restarts: %s", strings.Join(p.Restarts, ", "))+ app.UI.Detail("removes: %s", strings.Join(p.Removes, ", "))+ app.UI.Detail("networks: %s", strings.Join(p.Networks, ", "))+ }+ }+ return app.UI.Confirm("Go ahead?", true)+}++func openPorts(ctx context.Context, app *App, inst *instance.Instance, changes map[string]*string) (func(), error) {+ nothing := func() {}+ opened, closed, err := deploy.PortChanges(inst, changes)+ if err != nil || len(opened) == 0 {+ return nothing, err+ }+ fw, err := host.DetectFirewall(ctx)+ if err != nil || fw == host.FirewallNone {+ return nothing, nil+ }+ blocked, err := host.ClosedPorts(ctx, fw, opened)+ if err != nil {+ return nothing, nil+ }+ if len(blocked) > 0 {+ ok, err := app.UI.Confirm(fmt.Sprintf("Open port %s in the firewall on this machine?", deploy.PortList(blocked)), true)+ if err != nil {+ return nothing, err+ }+ if !ok {+ app.UI.Warn(fmt.Sprintf("Port %s stays closed in the firewall on this machine.", deploy.PortList(blocked)), "Open it before people connect.")+ } else if err := host.OpenPorts(ctx, fw, blocked); err != nil {+ return nothing, ui.Wrap(err, "Couldn't open the port.", fmt.Sprintf("Open port %s in the firewall yourself, then try again.", deploy.PortList(blocked)))+ }+ }+ return func() {+ ok, err := app.UI.Confirm(fmt.Sprintf("Close port %s in the firewall? Fluxer doesn't use it any more.", deploy.PortList(closed)), true)+ if err != nil || !ok {+ return+ }+ if err := host.ClosePorts(ctx, fw, closed); err != nil {+ app.UI.Warn(fmt.Sprintf("Couldn't close port %s.", deploy.PortList(closed)), "Close it in the firewall yourself.")+ }+ }, nil+}++func newConfigRenderCmd(app *App) *cobra.Command {+ return &cobra.Command{+ Use: "render",+ Short: "Print the Compose project rexctl runs, with secrets hidden",+ Hidden: true,+ Args: noArgs,+ RunE: func(c *cobra.Command, _ []string) error {+ inst, err := app.Instance()+ if err != nil {+ return err+ }+ s, err := deploy.Spec(inst)+ if err != nil {+ return err+ }+ for name, value := range s.Env {+ _, generated := inst.State.Secrets[name]+ if generated || settings.SecretName(name) {+ s.Env[name] = settings.Masked+ } else {+ s.Env[name] = settings.Mask(settings.Key{}, value)+ }+ }+ var e engine.Engine+ p, err := e.Load(c.Context(), s)+ if err != nil {+ return ui.Wrap(err, "rexctl can't read Fluxer's files.", "Run rexctl doctor to see what's wrong.")+ }+ out, err := p.Model.MarshalYAML()+ if err != nil {+ return err+ }+ app.UI.Result(string(out))+ return nil+ },+ }+}