Skip to content

Modern Docker Management, Designed for Everyone

9.9 KB
Raw Blame
package backups

import (
	"errors"
	"fmt"
	"net/http"
	"slices"
	"strconv"

	"github.com/getarcaneapp/arcane/types/v2/backup"
	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/spf13/cobra"
	"go.getarcane.app/kit/pkg"

	"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 newS3Cmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "s3",
		Short: "Manage S3 backup destinations",
	}
	cmd.AddCommand(newS3ListCmd())
	cmd.AddCommand(newS3GetCmd())
	cmd.AddCommand(newS3CreateCmd())
	cmd.AddCommand(newS3UpdateCmd())
	cmd.AddCommand(newS3DeleteCmd())
	cmd.AddCommand(newS3TestCmd())
	return cmd
}

func newS3ListCmd() *cobra.Command {
	var opts struct {
		limit int
		start int
		all   bool
	}
	cmd := &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List S3 backup destinations",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		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[backup.S3Destination]{
				Resource: "S3 destinations",
				Endpoint: types.BackupsS3(),
				Params:   cmdutil.ListParams{Resource: "s3 destinations", Limit: opts.limit, FallbackDefault: 20, Start: opts.start, All: opts.all},
				Headers:  []string{"ID", "NAME", "BUCKET", "REGION", "ENDPOINT", "SSL", "SECRET"},
				Row: func(dest backup.S3Destination) []string {
					return []string{
						dest.ID,
						dest.Name,
						dest.Bucket,
						dest.Region,
						dest.Endpoint,
						strconv.FormatBool(dest.UseSSL),
						kit.Ternary(dest.SecretConfigured, "Set", "Not set"),
					}
				},
			})
		},
	}
	cmd.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of destinations to show")
	cmd.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
	cmd.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
	return cmd
}

func newS3GetCmd() *cobra.Command {
	var opts struct {
		inUse bool
	}
	cmd := &cobra.Command{
		Use:          "get <destination>",
		Short:        "Get S3 destination details by name or ID",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			resolved, _, err := s3DestinationRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}
			dest := *resolved

			if !opts.inUse {
				if cmdutil.JSONOutputEnabled(cmd) {
					return cmdutil.PrintJSON(dest)
				}
				printS3Destination(dest)
				return nil
			}

			usage, err := c.DoJSON[backup.S3DestinationUsage](cmd.Context(), http.MethodGet, types.BackupsS3DestinationInUse(resolved.ID), nil)
			if err != nil {
				return fmt.Errorf("failed to check S3 destination usage: %w", err)
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(struct {
					Destination backup.S3Destination `json:"destination"`
					InUse       bool                 `json:"inUse"`
				}{Destination: dest, InUse: usage.InUse})
			}

			printS3Destination(dest)
			if usage.InUse {
				output.KeyValue("In Use", "Yes (referenced by backups, policies, or settings)")
			} else {
				output.KeyValue("In Use", "No")
			}
			return nil
		},
	}
	cmd.Flags().BoolVar(&opts.inUse, "in-use", false, "Also report whether the destination is still referenced")
	return cmd
}

func printS3Destination(dest backup.S3Destination) {
	output.Header("S3 Destination Details")
	output.KeyValue("ID", dest.ID)
	output.KeyValue("Name", dest.Name)
	output.KeyValue("Bucket", dest.Bucket)
	output.KeyValue("Region", dest.Region)
	if dest.Endpoint != "" {
		output.KeyValue("Endpoint", dest.Endpoint)
	}
	if dest.Prefix != "" {
		output.KeyValue("Prefix", dest.Prefix)
	}
	output.KeyValue("Access Key ID", dest.AccessKeyID)
	output.KeyValue("Secret Configured", dest.SecretConfigured)
	output.KeyValue("Use SSL", dest.UseSSL)
	output.KeyValue("Force Path Style", dest.ForcePathStyle)
	output.KeyValue("Created", dest.CreatedAt.Format("2006-01-02 15:04"))
}

func newS3CreateCmd() *cobra.Command {
	var opts backup.CreateS3Destination
	cmd := &cobra.Command{
		Use:          "create",
		Short:        "Create an S3 backup destination",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			dest, err := c.DoJSON[backup.S3Destination](cmd.Context(), http.MethodPost, types.BackupsS3(), opts)
			if err != nil {
				return fmt.Errorf("failed to create S3 destination: %w", err)
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(dest)
			}

			output.Success("S3 destination %s created successfully", dest.Name)
			printS3Destination(dest)
			return nil
		},
	}
	addS3ConnectionFlags(cmd, &opts)
	_ = cmd.MarkFlagRequired("name")
	_ = cmd.MarkFlagRequired("bucket")
	_ = cmd.MarkFlagRequired("region")
	_ = cmd.MarkFlagRequired("access-key-id")
	_ = cmd.MarkFlagRequired("secret-access-key")
	return cmd
}

func newS3UpdateCmd() *cobra.Command {
	var opts backup.CreateS3Destination
	cmd := &cobra.Command{
		Use:          "update <destination>",
		Short:        "Update an S3 backup destination by name or ID",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			resolved, _, err := s3DestinationRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
			if err != nil {
				return err
			}

			dest, err := c.DoJSON[backup.S3Destination](cmd.Context(), http.MethodPut, types.BackupsS3Destination(resolved.ID), opts)
			if err != nil {
				return fmt.Errorf("failed to update S3 destination: %w", err)
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(dest)
			}

			output.Success("S3 destination %s updated successfully", dest.Name)
			printS3Destination(dest)
			return nil
		},
	}
	addS3ConnectionFlags(cmd, &opts)
	_ = cmd.MarkFlagRequired("name")
	_ = cmd.MarkFlagRequired("bucket")
	_ = cmd.MarkFlagRequired("region")
	_ = cmd.MarkFlagRequired("access-key-id")
	return cmd
}

func newS3DeleteCmd() *cobra.Command {
	var opts struct {
		force bool
	}
	cmd := &cobra.Command{
		Use:          "delete <destination>",
		Aliases:      []string{"rm", "remove"},
		Short:        "Delete an S3 backup destination by name or ID",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			resolved, _, err := s3DestinationRef.Resolve(cmd.Context(), c, args[0], !opts.force && cmdutil.AllowPrompt(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 S3 destination %s?", resolved.Name),
				Path:           types.BackupsS3Destination(resolved.ID),
				Body:           nil,
				FailureMessage: "failed to delete S3 destination",
				SuccessMessage: fmt.Sprintf("S3 destination %s deleted successfully", resolved.Name),
			})
		},
	}
	cmd.Flags().BoolVarP(&opts.force, "force", "f", false, "Delete without confirmation")
	return cmd
}

func newS3TestCmd() *cobra.Command {
	var opts backup.CreateS3Destination
	cmd := &cobra.Command{
		Use:   "test [destination]",
		Short: "Test an S3 destination connection",
		Long: `Test a saved S3 destination by name or ID, or an unsaved configuration by
passing the connection flags (--name, --bucket, --region, ...) with no argument.`,
		Args:         cobra.MaximumNArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			flagNames := []string{"name", "endpoint", "bucket", "region", "access-key-id", "secret-access-key", "prefix", "use-ssl", "force-path-style"}
			connectionFlagsSet := slices.ContainsFunc(flagNames, cmd.Flags().Changed)

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

			testPath := types.BackupsS3Test()
			var testBody any = opts
			if len(args) == 1 {
				if connectionFlagsSet {
					return errors.New("pass either a saved destination name or ID, or the connection flags, not both")
				}
				resolved, _, resolveErr := s3DestinationRef.Resolve(cmd.Context(), c, args[0], cmdutil.AllowPrompt(cmd))
				if resolveErr != nil {
					return resolveErr
				}
				testPath, testBody = types.BackupsS3DestinationTest(resolved.ID), nil
			} else if opts.Bucket == "" {
				return errors.New("either a destination name or ID, or connection flags (--name, --bucket, --region, ...) are required")
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[base.MessageResponse]{
				Method:         http.MethodPost,
				Path:           testPath,
				Body:           testBody,
				FailureMessage: "failed to test S3 destination",
				Render:         func(base.MessageResponse) error { output.Success("%s", "S3 connection test succeeded"); return nil },
			})
		},
	}
	addS3ConnectionFlags(cmd, &opts)
	return cmd
}

func addS3ConnectionFlags(cmd *cobra.Command, opts *backup.CreateS3Destination) {
	cmd.Flags().StringVar(&opts.Name, "name", "", "Destination name")
	cmd.Flags().StringVar(&opts.Endpoint, "endpoint", "", "S3 endpoint (empty for AWS S3)")
	cmd.Flags().StringVar(&opts.Bucket, "bucket", "", "Bucket name")
	cmd.Flags().StringVar(&opts.Region, "region", "", "Region")
	cmd.Flags().StringVar(&opts.AccessKeyID, "access-key-id", "", "Access key ID")
	cmd.Flags().StringVar(&opts.SecretAccessKey, "secret-access-key", "", "Secret access key")
	cmd.Flags().StringVar(&opts.Prefix, "prefix", "", "Object key prefix")
	cmd.Flags().BoolVar(&opts.UseSSL, "use-ssl", true, "Use SSL for the connection")
	cmd.Flags().BoolVar(&opts.ForcePathStyle, "force-path-style", false, "Use path-style bucket addressing")
}