Merge pull request #116 from UpCloudLtd/feat/storage-autoresize

Feat/storage autoresize

Author: ka-myl

docs/upctl_storage_modify.md

@@ -16,13 +16,14 @@ upctl storage modify "My Storage" --size 25
 ### Options
 
 ```
-      --title string             A short, informational description.
-      --size int                 Size of the storage (GiB).
-      --backup-time string       The time when to create a backup in HH:MM. Empty value means no backups.
-      --backup-interval string   The interval of the backup.
-                                 Available: daily,mon,tue,wed,thu,fri,sat,sun
-      --backup-retention int     How long to store the backups in days. The accepted range is 1-1095.
-  -h, --help                     help for modify
+      --title string                          A short, informational description.
+      --size int                              Size of the storage (GiB).
+      --backup-time string                    The time when to create a backup in HH:MM. Empty value means no backups.
+      --backup-interval string                The interval of the backup.
+                                              Available: daily,mon,tue,wed,thu,fri,sat,sun
+      --backup-retention int                  How long to store the backups in days. The accepted range is 1-1095.
+      --enable-filesystem-autoresize[=true]   Enable automatic resize of partition and filesystem when modifying storage size. Note that before the resize attempt is made, backup of the storage will be taken. If the resize attempt fails, the backup will be used to restore the storage and then deleted. If the resize attempt succeeds, backup will be kept. Taking and keeping backups incure costs..
+  -h, --help                                  help for modify
 ```
 
 ### Options inherited from parent commands

internal/commands/storage/modify.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/UpCloudLtd/upcloud-cli/internal/commands"
 	"github.com/UpCloudLtd/upcloud-cli/internal/completion"
+	"github.com/UpCloudLtd/upcloud-cli/internal/config"
 	"github.com/UpCloudLtd/upcloud-cli/internal/output"
 	"github.com/UpCloudLtd/upcloud-cli/internal/resolver"
 	"github.com/UpCloudLtd/upcloud-cli/internal/ui"
@@ -20,7 +21,8 @@ type modifyCommand struct {
 	*commands.BaseCommand
 	completion.Storage
 	resolver.CachingStorage
-	params modifyParams
+	params                        modifyParams
+	autoresizePartitionFilesystem config.OptionalBoolean
 }
 
 type modifyParams struct {
@@ -66,6 +68,7 @@ func (s *modifyCommand) InitCommand() {
 	flagSet.StringVar(&s.params.backupTime, "backup-time", s.params.backupTime, "The time when to create a backup in HH:MM. Empty value means no backups.")
 	flagSet.StringVar(&s.params.backupInterval, "backup-interval", "", "The interval of the backup.\nAvailable: daily,mon,tue,wed,thu,fri,sat,sun")
 	flagSet.IntVar(&s.params.backupRetention, "backup-retention", 0, "How long to store the backups in days. The accepted range is 1-1095.")
+	config.AddEnableOrDisableFlag(flagSet, &s.autoresizePartitionFilesystem, false, "filesystem-autoresize", "automatic resize of partition and filesystem when modifying storage size. Note that before the resize attempt is made, backup of the storage will be taken. If the resize attempt fails, the backup will be used to restore the storage and then deleted. If the resize attempt succeeds, backup will be kept. Taking and keeping backups incure costs.")
 
 	s.AddFlags(flagSet)
 }
@@ -129,6 +132,10 @@ func setBackupFields(storageUUID string, p modifyParams, service service.Storage
 
 // Execute implements commands.MultipleArgumentCommand
 func (s *modifyCommand) Execute(exec commands.Executor, uuid string) (output.Output, error) {
+	if s.autoresizePartitionFilesystem.Value() && s.params.Size == 0 {
+		return nil, fmt.Errorf("filesystem autoresize is enabled, but new size is not specified")
+	}
+
 	svc := exec.Storage()
 	msg := fmt.Sprintf("modifing storage %v", uuid)
 	logline := exec.NewLogEntry(msg)
@@ -149,8 +156,35 @@ func (s *modifyCommand) Execute(exec commands.Executor, uuid string) (output.Out
 		return nil, err
 	}
 
+	// If autoresize is not enabled, then just consider the whole operation done and output the modify API call response
+	if !s.autoresizePartitionFilesystem.Value() {
+		logline.SetMessage(fmt.Sprintf("%s: done", msg))
+		logline.MarkDone()
+
+		return output.OnlyMarshaled{Value: res}, nil
+	}
+
+	logline.SetMessage(fmt.Sprintf("%s: resizing partition and filesystem", msg))
+	backup, err := svc.ResizeStorageFilesystem(&request.ResizeStorageFilesystemRequest{UUID: uuid})
+
+	// If there was an error during resize attempt, we consider the overall modify operation successful and just log warning about failed resize
+	if err != nil {
+		logline.SetMessage(ui.LiveLogEntryWarningColours.Sprintf("%s: done, but partition and filesystem resize failed; storage was restored using backed taken right before resize attempt", msg))
+		logline.SetDetails(err.Error(), "error: ")
+		logline.MarkDone()
+		return output.OnlyMarshaled{Value: res}, nil
+	}
+
 	logline.SetMessage(fmt.Sprintf("%s: done", msg))
 	logline.MarkDone()
 
-	return output.OnlyMarshaled{Value: res}, nil
+	out := struct {
+		upcloud.StorageDetails
+		LatestResizeBackup string `json:"latest_resize_backup,omitempty"`
+	}{
+		StorageDetails:     *res,
+		LatestResizeBackup: backup.UUID,
+	}
+
+	return output.OnlyMarshaled{Value: out}, nil
 }

internal/commands/storage/modify_test.go

@@ -230,3 +230,46 @@ func TestModifyCommandExistingBackupRule(t *testing.T) {
 		})
 	}
 }
+
+func TestModifyCommandAutoresize(t *testing.T) {
+	t.Run("modifying storage size with filesystem autoresize enabled", func(t *testing.T) {
+		conf := config.New()
+		testCmd := ModifyCommand()
+		mService := new(smock.Service)
+		UUID := "some_storage_id"
+
+		mGetDetailsResponse := upcloud.StorageDetails{
+			Storage:    upcloud.Storage{Size: 45},
+			BackupRule: &upcloud.BackupRule{},
+		}
+
+		mModifyResponse := upcloud.StorageDetails{
+			Storage: upcloud.Storage{
+				Size: 50,
+			},
+		}
+
+		mResizeResponse := upcloud.ResizeStorageFilesystemBackup{
+			UUID: "resize_backup",
+		}
+
+		conf.Service = internal.Wrapper{Service: mService}
+		mService.On("ModifyStorage", &request.ModifyStorageRequest{UUID: UUID, Size: 50}).Return(&mModifyResponse, nil)
+		mService.On("ResizeStorageFilesystem", &request.ResizeStorageFilesystemRequest{UUID: UUID}).Return(&mResizeResponse, nil)
+		mService.On("GetStorageDetails", &request.GetStorageDetailsRequest{UUID: UUID}).Return(&mGetDetailsResponse, nil)
+
+		c := commands.BuildCommand(testCmd, nil, conf)
+		err := c.Cobra().Flags().Parse([]string{"--size", "50", "--enable-filesystem-autoresize"})
+		assert.NoError(t, err)
+
+		output, err := c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, mService, flume.New("test")), UUID)
+		assert.NoError(t, err)
+		mService.AssertNumberOfCalls(t, "ModifyStorage", 1)
+		mService.AssertNumberOfCalls(t, "ResizeStorageFilesystem", 1)
+
+		json, err := output.MarshalJSON()
+		assert.NoError(t, err)
+		assert.Contains(t, string(json), "latest_resize_backup")
+		assert.Contains(t, string(json), "resize_backup")
+	})
+}

internal/ui/log.go

@@ -27,8 +27,10 @@ var (
 		DisableLiveRendering: !terminal.IsStdoutTerminal(),
 		Colours:              liveLogDefaultColours,
 	}
+	// LiveLogEntryWarningColours specifies the colour used for warnings in LiveLog
+	// TODO: remove cross-package dependency and make those private
+	LiveLogEntryWarningColours = text.FgHiYellow
 	// LiveLogEntryErrorColours specifies the colour used for errors in LiveLog
-	// TODO: remove cross-package dependency and make this private
 	LiveLogEntryErrorColours = text.FgHiRed
 )