[droplets]: add support for droplet backup policy

args.go

@@ -150,6 +150,8 @@ const (
 	ArgResourceType = "resource"
 	// ArgBackups is an enable backups argument.
 	ArgBackups = "enable-backups"
+	// ArgDropletBackupPolicy is a path to a droplet backup policy.
+	ArgDropletBackupPolicy = "backup-policy"
 	// ArgIPv6 is an enable IPv6 argument.
 	ArgIPv6 = "enable-ipv6"
 	// ArgPrivateNetworking is an enable private networking argument.

commands/commands_test.go

@@ -16,6 +16,7 @@ package commands
 import (
 	"io"
 	"testing"
+	"time"
 
 	"github.com/digitalocean/doctl"
 	"github.com/digitalocean/doctl/do"
@@ -123,6 +124,63 @@ var (
 	}
 
 	testSnapshotList = do.Snapshots{testSnapshot, testSnapshotSecondary}
+
+	testDropletBackupPolicy = do.DropletBackupPolicy{
+		DropletBackupPolicy: &godo.DropletBackupPolicy{
+			DropletID: 123,
+			BackupPolicy: &godo.DropletBackupPolicyConfig{
+				Plan:                "weekly",
+				Weekday:             "MON",
+				Hour:                0,
+				WindowLengthHours:   4,
+				RetentionPeriodDays: 28,
+			},
+			NextBackupWindow: &godo.BackupWindow{
+				Start: &godo.Timestamp{Time: time.Date(2024, time.January, 1, 12, 0, 0, 0, time.UTC)},
+				End:   &godo.Timestamp{Time: time.Date(2024, time.February, 1, 12, 0, 0, 0, time.UTC)},
+			},
+		},
+	}
+
+	anotherTestDropletBackupPolicy = do.DropletBackupPolicy{
+		DropletBackupPolicy: &godo.DropletBackupPolicy{
+			DropletID: 123,
+			BackupPolicy: &godo.DropletBackupPolicyConfig{
+				Plan:                "daily",
+				Hour:                12,
+				WindowLengthHours:   4,
+				RetentionPeriodDays: 7,
+			},
+			NextBackupWindow: &godo.BackupWindow{
+				Start: &godo.Timestamp{Time: time.Date(2024, time.January, 1, 12, 0, 0, 0, time.UTC)},
+				End:   &godo.Timestamp{Time: time.Date(2024, time.February, 1, 12, 0, 0, 0, time.UTC)},
+			},
+		},
+	}
+
+	testDropletBackupPolicies = do.DropletBackupPolicies{testDropletBackupPolicy, anotherTestDropletBackupPolicy}
+
+	testDropletSupportedBackupPolicy = do.DropletSupportedBackupPolicy{
+		SupportedBackupPolicy: &godo.SupportedBackupPolicy{
+			Name:                 "daily",
+			PossibleWindowStarts: []int{0, 4, 8, 12, 16, 20},
+			WindowLengthHours:    4,
+			RetentionPeriodDays:  7,
+			PossibleDays:         []string{},
+		},
+	}
+
+	anotherTestDropletSupportedBackupPolicy = do.DropletSupportedBackupPolicy{
+		SupportedBackupPolicy: &godo.SupportedBackupPolicy{
+			Name:                 "weekly",
+			PossibleWindowStarts: []int{0, 4, 8, 12, 16, 20},
+			WindowLengthHours:    4,
+			RetentionPeriodDays:  28,
+			PossibleDays:         []string{"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"},
+		},
+	}
+
+	testDropletSupportedBackupPolicies = do.DropletSupportedBackupPolicies{testDropletSupportedBackupPolicy, anotherTestDropletSupportedBackupPolicy}
 )
 
 func assertCommandNames(t *testing.T, cmd *Command, expected ...string) {

commands/displayers/droplet_backup_policies.go

@@ -0,0 +1,50 @@
+package displayers
+
+import (
+	"io"
+
+	"github.com/digitalocean/doctl/do"
+)
+
+type DropletBackupPolicy struct {
+	DropletBackupPolicies []do.DropletBackupPolicy
+}
+
+var _ Displayable = &DropletBackupPolicy{}
+
+func (d *DropletBackupPolicy) JSON(out io.Writer) error {
+	return writeJSON(d.DropletBackupPolicies, out)
+}
+
+func (d *DropletBackupPolicy) Cols() []string {
+	cols := []string{
+		"DropletID", "BackupEnabled", "BackupPolicyPlan", "BackupPolicyWeekday", "BackupPolicyHour",
+		"BackupPolicyWindowLengthHours", "BackupPolicyRetentionPeriodDays",
+		"NextBackupWindowStart", "NextBackupWindowEnd",
+	}
+	return cols
+}
+
+func (d *DropletBackupPolicy) ColMap() map[string]string {
+	return map[string]string{
+		"DropletID": "Droplet ID", "BackupEnabled": "Backup Enabled",
+		"BackupPolicyPlan": "Backup Policy Plan", "BackupPolicyWeekday": "Backup Policy Weekday", "BackupPolicyHour": "Backup Policy Hour",
+		"BackupPolicyWindowLengthHours": "Backup Policy Window Length Hours", "BackupPolicyRetentionPeriodDays": "Backup Policy Retention Period Days",
+		"NextBackupWindowStart": "Next Backup Window Start", "NextBackupWindowEnd": "Next Backup Window End",
+	}
+}
+
+func (d *DropletBackupPolicy) KV() []map[string]any {
+	out := make([]map[string]any, 0)
+	for _, d := range d.DropletBackupPolicies {
+		m := map[string]any{
+			"DropletID": d.DropletID, "BackupEnabled": d.BackupEnabled, "BackupPolicyPlan": d.BackupPolicy.Plan,
+			"BackupPolicyWeekday": d.BackupPolicy.Weekday, "BackupPolicyHour": d.BackupPolicy.Hour,
+			"BackupPolicyWindowLengthHours": d.BackupPolicy.WindowLengthHours, "BackupPolicyRetentionPeriodDays": d.BackupPolicy.RetentionPeriodDays,
+			"NextBackupWindowStart": d.NextBackupWindow.Start, "NextBackupWindowEnd": d.NextBackupWindow.End,
+		}
+		out = append(out, m)
+	}
+
+	return out
+}

commands/displayers/droplet_supported_backup_policies.go

@@ -0,0 +1,44 @@
+package displayers
+
+import (
+	"io"
+
+	"github.com/digitalocean/doctl/do"
+)
+
+type DropletSupportedBackupPolicy struct {
+	DropletSupportedBackupPolicies []do.DropletSupportedBackupPolicy
+}
+
+var _ Displayable = &DropletSupportedBackupPolicy{}
+
+func (d *DropletSupportedBackupPolicy) JSON(out io.Writer) error {
+	return writeJSON(d.DropletSupportedBackupPolicies, out)
+}
+
+func (d *DropletSupportedBackupPolicy) Cols() []string {
+	cols := []string{
+		"Name", "PossibleWindowStarts", "WindowLengthHours", "RetentionPeriodDays", "PossibleDays",
+	}
+	return cols
+}
+
+func (d *DropletSupportedBackupPolicy) ColMap() map[string]string {
+	return map[string]string{
+		"Name": "Name", "PossibleWindowStarts": "Possible Window Starts",
+		"WindowLengthHours": "Window Length Hours", "RetentionPeriodDays": "Retention Period Days", "PossibleDays": "Possible Days",
+	}
+}
+
+func (d *DropletSupportedBackupPolicy) KV() []map[string]any {
+	out := make([]map[string]any, 0)
+	for _, d := range d.DropletSupportedBackupPolicies {
+		m := map[string]any{
+			"Name": d.Name, "PossibleWindowStarts": d.PossibleWindowStarts, "WindowLengthHours": d.WindowLengthHours,
+			"RetentionPeriodDays": d.RetentionPeriodDays, "PossibleDays": d.PossibleDays,
+		}
+		out = append(out, m)
+	}
+
+	return out
+}

commands/droplet_actions.go

@@ -14,9 +14,12 @@ limitations under the License.
 package commands
 
 import (
+	"os"
+
 	"github.com/digitalocean/doctl"
 	"github.com/digitalocean/doctl/commands/displayers"
 	"github.com/digitalocean/doctl/do"
+	"github.com/digitalocean/doctl/internal/droplets"
 	"github.com/spf13/cobra"
 )
 
@@ -72,15 +75,23 @@ You can use Droplet actions to perform tasks on a Droplet, such as rebooting, re
 	cmdDropletActionEnableBackups := CmdBuilder(cmd, RunDropletActionEnableBackups,
 		"enable-backups <droplet-id>", "Enable backups on a Droplet", `Enables backups on a Droplet. This automatically creates and stores a disk image of the Droplet. By default, backups happen daily.`, Writer,
 		displayerType(&displayers.Action{}))
+	AddStringFlag(cmdDropletActionEnableBackups, doctl.ArgDropletBackupPolicy, "", "", `Path to a new backup policy in JSON or YAML format. Set to "-" to read from stdin.`, requiredOpt())
 	AddBoolFlag(cmdDropletActionEnableBackups, doctl.ArgCommandWait, "", false, "Wait for action to complete")
-	cmdDropletActionEnableBackups.Example = `The following example enables backups on a Droplet with the ID ` + "`" + `386734086` + "`" + `: doctl compute droplet-action enable-backups 386734086`
+	cmdDropletActionEnableBackups.Example = `The following example enables backups on a Droplet with the ID ` + "`" + `386734086` + "` with a backup policy flag" + `: doctl compute droplet-action enable-backups 386734086 --backup-policy src/your-backup-policy.yaml`
 
 	cmdDropletActionDisableBackups := CmdBuilder(cmd, RunDropletActionDisableBackups,
 		"disable-backups <droplet-id>", "Disable backups on a Droplet", `Disables backups on a Droplet. This does not delete existing backups.`, Writer,
 		displayerType(&displayers.Action{}))
 	AddBoolFlag(cmdDropletActionDisableBackups, doctl.ArgCommandWait, "", false, "Instruct the terminal to wait for the action to complete before returning access to the user")
 	cmdDropletActionDisableBackups.Example = `The following example disables backups on a Droplet with the ID ` + "`" + `386734086` + "`" + `: doctl compute droplet-action disable-backups 386734086`
 
+	cmdDropletActionChangeBackupPolicy := CmdBuilder(cmd, RunDropletActionChangeBackupPolicy,
+		"change-backup-policy <droplet-id>", "Change backup policy on a Droplet", `Changes backup policy for a Droplet with enabled backups.`, Writer,
+		displayerType(&displayers.Action{}))
+	AddStringFlag(cmdDropletActionChangeBackupPolicy, doctl.ArgDropletBackupPolicy, "", "", `Path to a new backup policy in JSON or YAML format. Set to "-" to read from stdin.`, requiredOpt())
+	AddBoolFlag(cmdDropletActionChangeBackupPolicy, doctl.ArgCommandWait, "", false, "Wait for action to complete")
+	cmdDropletActionChangeBackupPolicy.Example = `The following example changes backup policy on a Droplet with the ID ` + "`" + `386734086` + "`" + `: doctl compute droplet-action change-backup-policy 386734086 --backup-policy src/your-backup-policy.yaml`
+
 	cmdDropletActionReboot := CmdBuilder(cmd, RunDropletActionReboot,
 		"reboot <droplet-id>", "Reboot a Droplet", `Reboots a Droplet. A reboot action is an attempt to reboot the Droplet in a graceful way, similar to using the reboot command from the Droplet's console.`, Writer,
 		displayerType(&displayers.Action{}))
@@ -230,6 +241,31 @@ func RunDropletActionGet(c *CmdConfig) error {
 	return performAction(c, fn)
 }
 
+// RunDropletActionEnableBackupsWithPolicy enables backups with a policy for a droplet.
+func RunDropletActionEnableBackupsWithPolicy(c *CmdConfig) error {
+	fn := func(das do.DropletActionsService) (*do.Action, error) {
+		id, err := ContextualAtoi(c.Args[0], dropletIDResource)
+		if err != nil {
+			return nil, err
+		}
+
+		policyPath, err := c.Doit.GetString(c.NS, doctl.ArgDropletBackupPolicy)
+		if err != nil {
+			return nil, err
+		}
+
+		policy, err := droplets.ReadDropletBackupPolicy(os.Stdin, policyPath)
+		if err != nil {
+			return nil, err
+		}
+
+		a, err := das.EnableBackupsWithPolicy(id, policy)
+		return a, err
+	}
+
+	return performAction(c, fn)
+}
+
 // RunDropletActionEnableBackups disables backups for a droplet.
 func RunDropletActionEnableBackups(c *CmdConfig) error {
 	fn := func(das do.DropletActionsService) (*do.Action, error) {
@@ -242,8 +278,19 @@ func RunDropletActionEnableBackups(c *CmdConfig) error {
 			return nil, err
 		}
 
-		a, err := das.EnableBackups(id)
-		return a, err
+		policyPath, err := c.Doit.GetString(c.NS, doctl.ArgDropletBackupPolicy)
+		if err != nil {
+			return nil, err
+		}
+		if policyPath != "" {
+			policy, err := droplets.ReadDropletBackupPolicy(os.Stdin, policyPath)
+			if err != nil {
+				return nil, err
+			}
+			return das.EnableBackupsWithPolicy(id, policy)
+		} else {
+			return das.EnableBackups(id)
+		}
 	}
 
 	return performAction(c, fn)
@@ -268,6 +315,36 @@ func RunDropletActionDisableBackups(c *CmdConfig) error {
 	return performAction(c, fn)
 }
 
+// RunDropletActionChangeBackupPolicy changes backup policy for a droplet.
+func RunDropletActionChangeBackupPolicy(c *CmdConfig) error {
+	fn := func(das do.DropletActionsService) (*do.Action, error) {
+		err := ensureOneArg(c)
+		if err != nil {
+			return nil, err
+		}
+
+		id, err := ContextualAtoi(c.Args[0], dropletIDResource)
+		if err != nil {
+			return nil, err
+		}
+
+		policyPath, err := c.Doit.GetString(c.NS, doctl.ArgDropletBackupPolicy)
+		if err != nil {
+			return nil, err
+		}
+
+		policy, err := droplets.ReadDropletBackupPolicy(os.Stdin, policyPath)
+		if err != nil {
+			return nil, err
+		}
+
+		a, err := das.ChangeBackupPolicy(id, policy)
+		return a, err
+	}
+
+	return performAction(c, fn)
+}
+
 // RunDropletActionReboot reboots a droplet.
 func RunDropletActionReboot(c *CmdConfig) error {
 	fn := func(das do.DropletActionsService) (*do.Action, error) {