Skip to content

Modern Docker Management, Designed for Everyone

7.6 KB
Raw Blame
package podman

import (
	"cmp"
	"fmt"
	"maps"
	"net/http"
	"os"
	"slices"

	"github.com/getarcaneapp/arcane/types/v2/podman"
	"github.com/spf13/cobra"

	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

func newSecretsCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "secrets",
		Aliases: []string{"secret"},
		Short:   "Manage Podman secrets",
	}
	cmd.AddCommand(
		newSecretListCmd(),
		newSecretInspectCmd(),
		newSecretCreateCmd(),
		newSecretUpdateCmd(),
		newSecretDeleteCmd(),
	)
	return cmd
}

func newSecretListCmd() *cobra.Command {
	var opts struct {
		limit int
		start int
		all   bool
	}
	cmd := &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List Podman secrets",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.RunList(cmd, c, cmdutil.ListSpec[podman.Secret]{
				Resource: "secrets",
				Endpoint: types.PodmanSecrets(c.EnvID()),
				Params: cmdutil.ListParams{
					Resource:        "secrets",
					Limit:           opts.limit,
					FallbackDefault: 20,
					Start:           opts.start,
					All:             opts.all,
				},
				Headers: []string{"ID", "NAME", "DRIVER", "CREATED"},
				Row: func(secret podman.Secret) []string {
					return []string{
						secret.ID[:min(len(secret.ID), 12)],
						secret.Spec.Name,
						secret.Spec.Driver.Name,
						secret.CreatedAt.Format("2006-01-02 15:04"),
					}
				},
			})
		},
	}
	cmd.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of secrets to show")
	cmd.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
	cmd.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
	cmdutil.SetScope(cmdutil.ScopeRead, cmd)
	return cmd
}

func newSecretInspectCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:          "inspect <secret>",
		Aliases:      []string{"get"},
		Short:        "Show Podman secret metadata",
		Long:         "Show a Podman secret's metadata. The secret value is never returned.",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[podman.Secret]{
				Method:         http.MethodGet,
				Path:           types.PodmanSecret(c.EnvID(), args[0]),
				FailureMessage: "failed to inspect Podman secret",
				Render: func(data podman.Secret) error {
					output.Header("Secret Details")
					output.KeyValue("ID", data.ID)
					output.KeyValue("Name", data.Spec.Name)
					output.KeyValue("Driver", cmp.Or(data.Spec.Driver.Name, "-"))
					output.KeyValue("Created", data.CreatedAt.Format("2006-01-02 15:04"))
					output.KeyValue("Updated", data.UpdatedAt.Format("2006-01-02 15:04"))
					for _, key := range slices.Sorted(maps.Keys(data.Spec.Labels)) {
						output.KeyValue("Label "+key, data.Spec.Labels[key])
					}
					return nil
				},
			})
		},
	}
	cmdutil.SetScope(cmdutil.ScopeRead, cmd)
	return cmd
}

func newSecretCreateCmd() *cobra.Command {
	var opts struct {
		file   string
		driver string
		labels map[string]string
	}
	cmd := &cobra.Command{
		Use:          "create <name>",
		Short:        "Create a Podman secret",
		Long:         "Create a Podman secret from --file, or from a hidden prompt (or one line of stdin) when --file is omitted.",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			data, err := func() (string, error) {
				if opts.file == "" {
					return output.Secret(cmd.Context(), cmd.InOrStdin(), cmd.ErrOrStderr(), "Secret value", "file")
				}
				content, readErr := os.ReadFile(opts.file)
				return string(content), readErr
			}()
			if err != nil {
				return fmt.Errorf("failed to read secret value: %w", err)
			}

			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[podman.SecretCreateResponse]{
				Method: http.MethodPost,
				Path:   types.PodmanSecrets(c.EnvID()),
				Body: podman.SecretCreateRequest{
					Name:   args[0],
					Data:   data,
					Driver: opts.driver,
					Labels: opts.labels,
				},
				FailureMessage: "failed to create Podman secret",
				Render: func(created podman.SecretCreateResponse) error {
					output.Success("Secret %s created successfully", args[0])
					output.KeyValue("ID", cmp.Or(created.ID, "-"))
					return nil
				},
			})
		},
	}
	cmd.Flags().StringVar(&opts.file, "file", "", "Read the secret value from this file")
	cmd.Flags().StringVar(&opts.driver, "driver", "", "Secret driver (default file)")
	cmd.Flags().StringToStringVar(&opts.labels, "label", nil, "Label (KEY=VALUE)")
	cmdutil.SetScope(cmdutil.ScopeDestination, cmd)
	return cmd
}

func newSecretUpdateCmd() *cobra.Command {
	var opts struct {
		file   string
		driver string
		labels map[string]string
	}
	cmd := &cobra.Command{
		Use:     "update <name>",
		Aliases: []string{"replace"},
		Short:   "Replace a Podman secret's value",
		Long: "Replace a Podman secret's value from --file, or from a hidden prompt (or one line of stdin) when --file is omitted. " +
			"Podman replaces the whole secret, so pass --driver and --label again to keep them.",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			data, err := func() (string, error) {
				if opts.file == "" {
					return output.Secret(cmd.Context(), cmd.InOrStdin(), cmd.ErrOrStderr(), "New secret value", "file")
				}
				content, readErr := os.ReadFile(opts.file)
				return string(content), readErr
			}()
			if err != nil {
				return fmt.Errorf("failed to read secret value: %w", err)
			}

			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[podman.Secret]{
				Method: http.MethodPut,
				Path:   types.PodmanSecret(c.EnvID(), args[0]),
				Body: podman.SecretUpdateRequest{
					Data:   data,
					Driver: opts.driver,
					Labels: opts.labels,
				},
				FailureMessage: "failed to update Podman secret",
				Render: func(updated podman.Secret) error {
					output.Success("Secret %s updated successfully", args[0])
					output.KeyValue("ID", cmp.Or(updated.ID, "-"))
					return nil
				},
			})
		},
	}
	cmd.Flags().StringVar(&opts.file, "file", "", "Read the new secret value from this file")
	cmd.Flags().StringVar(&opts.driver, "driver", "", "Secret driver (default file)")
	cmd.Flags().StringToStringVar(&opts.labels, "label", nil, "Label (KEY=VALUE)")
	cmdutil.SetScope(cmdutil.ScopeDestination, cmd)
	return cmd
}

func newSecretDeleteCmd() *cobra.Command {
	var opts struct {
		force bool
	}
	cmd := &cobra.Command{
		Use:          "delete <secret>",
		Aliases:      []string{"rm", "remove"},
		Short:        "Delete a Podman secret",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
				Force:          opts.force,
				Prompt:         fmt.Sprintf("Are you sure you want to delete secret %s?", args[0]),
				Path:           types.PodmanSecret(c.EnvID(), args[0]),
				FailureMessage: "failed to delete Podman secret",
				SuccessMessage: fmt.Sprintf("Secret %s deleted successfully", args[0]),
			})
		},
	}
	cmd.Flags().BoolVarP(&opts.force, "force", "f", false, "Force deletion without confirmation")
	return cmd
}