add CRUD operations for Volume Snapshots

cloudscale.go

@@ -37,6 +37,7 @@ type Client struct {
 	Regions                    RegionService
 	Servers                    ServerService
 	Volumes                    VolumeService
+	VolumeSnapshots            VolumeSnapshotService
 	Networks                   NetworkService
 	Subnets                    SubnetService
 	FloatingIPs                FloatingIPsService
@@ -88,10 +89,14 @@ func NewClient(httpClient *http.Client) *Client {
 		client: c,
 		path:   floatingIPsBasePath,
 	}
-	c.Volumes = GenericServiceOperations[Volume, VolumeRequest, VolumeRequest]{
+	c.Volumes = GenericServiceOperations[Volume, VolumeCreateRequest, VolumeUpdateRequest]{
 		client: c,
 		path:   volumeBasePath,
 	}
+	c.VolumeSnapshots = GenericServiceOperations[VolumeSnapshot, VolumeSnapshotCreateRequest, VolumeSnapshotUpdateRequest]{
+		client: c,
+		path:   volumeSnapshotsBasePath,
+	}
 	c.ServerGroups = GenericServiceOperations[ServerGroup, ServerGroupRequest, ServerGroupRequest]{
 		client: c,
 		path:   serverGroupsBasePath,

test/integration/cloudscale_test.go

@@ -49,6 +49,7 @@ func TestMain(m *testing.M) {
 	foundResource := false
 	foundResource = foundResource || DeleteRemainingServer()
 	foundResource = foundResource || DeleteRemainingServerGroups()
+	foundResource = foundResource || DeleteRemainingVolumeSnapshots()
 	foundResource = foundResource || DeleteRemainingVolumes()
 	foundResource = foundResource || DeleteRemainingSubnets()
 	foundResource = foundResource || DeleteRemainingNetworks()
@@ -106,6 +107,28 @@ func DeleteRemainingServerGroups() bool {
 	return foundResource
 }
 
+func DeleteRemainingVolumeSnapshots() bool {
+	foundResource := false
+
+	snapshots, err := client.VolumeSnapshots.List(context.Background())
+	if err != nil {
+		log.Fatalf("VolumeSnapshots.List returned error %s\n", err)
+	}
+
+	for _, snapshot := range snapshots {
+		if strings.HasPrefix(snapshot.Name, testRunPrefix) {
+			foundResource = true
+			log.Printf("Found not deleted snapshot: %s (%s)\n", snapshot.Name, snapshot.UUID)
+			err = client.VolumeSnapshots.Delete(context.Background(), snapshot.UUID)
+			if err != nil {
+				log.Fatalf("VolumeSnapshots.Delete returned error %s\n", err)
+			}
+		}
+	}
+
+	return foundResource
+}
+
 func DeleteRemainingVolumes() bool {
 	foundResource := false
 

test/integration/tags_integration_test.go

@@ -109,7 +109,7 @@ func TestIntegrationTags_Server(t *testing.T) {
 func TestIntegrationTags_Volume(t *testing.T) {
 	integrationTest(t)
 
-	createRequest := cloudscale.VolumeRequest{
+	createRequest := cloudscale.VolumeCreateRequest{
 		Name:   testRunPrefix,
 		SizeGB: 3,
 	}
@@ -129,7 +129,7 @@ func TestIntegrationTags_Volume(t *testing.T) {
 		t.Errorf("Tagging failed, could not tag, is at %s\n", getResult.Tags)
 	}
 
-	updateRequest := cloudscale.VolumeRequest{}
+	updateRequest := cloudscale.VolumeUpdateRequest{}
 	newTags := getNewTags()
 	updateRequest.Tags = &newTags
 
@@ -174,6 +174,197 @@ func TestIntegrationTags_Volume(t *testing.T) {
 	}
 }
 
+func TestIntegrationTags_VolumeFromSnapshot(t *testing.T) {
+	integrationTest(t)
+	ctx := context.Background()
+
+	// first create a volume and a snapshot
+	createVolumeRequest := &cloudscale.VolumeCreateRequest{
+		Name:   testRunPrefix,
+		SizeGB: 3,
+	}
+	sourceVolume, err := client.Volumes.Create(ctx, createVolumeRequest)
+	if err != nil {
+		t.Fatalf("Volumes.Create returned error %s\n", err)
+	}
+	snapshotCreateRequest := &cloudscale.VolumeSnapshotCreateRequest{
+		Name:         testRunPrefix,
+		SourceVolume: sourceVolume.UUID,
+	}
+	snapshot, err := client.VolumeSnapshots.Create(ctx, snapshotCreateRequest)
+	if err != nil {
+		t.Fatalf("VolumeSnapshots.Create: %v", err)
+	}
+
+	createVolumeFromSnapshotRequest := &cloudscale.VolumeCreateRequest{
+		Name:               fmt.Sprintf("%s-from-snapshot", testRunPrefix),
+		VolumeSnapshotUUID: snapshot.UUID,
+	}
+
+	initialTags := getInitialTags()
+	createVolumeFromSnapshotRequest.Tags = &initialTags
+
+	volume, err := client.Volumes.Create(ctx, createVolumeFromSnapshotRequest)
+	if err != nil {
+		t.Fatalf("Volumes.Create returned error %s\n", err)
+	}
+
+	getResult, err := client.Volumes.Get(ctx, volume.UUID)
+	if err != nil {
+		t.Errorf("Volumes.Get returned error %s\n", err)
+	}
+	if !reflect.DeepEqual(getResult.Tags, initialTags) {
+		t.Errorf("Tagging failed, could not tag, is at %s\n", getResult.Tags)
+	}
+
+	updateRequest := cloudscale.VolumeUpdateRequest{}
+	newTags := getNewTags()
+	updateRequest.Tags = &newTags
+
+	err = client.Volumes.Update(ctx, volume.UUID, &updateRequest)
+	if err != nil {
+		t.Errorf("Volumes.Update returned error: %v", err)
+	}
+	getResult2, err := client.Volumes.Get(ctx, volume.UUID)
+	if err != nil {
+		t.Errorf("Volumes.Get returned error %s\n", err)
+	}
+	if !reflect.DeepEqual(getResult2.Tags, newTags) {
+		t.Errorf("Tagging failed, could not tag, is at %s\n", getResult.Tags)
+	}
+
+	// test querying with tags
+	initialTagsKeyOnly := getInitialTagsKeyOnly()
+	for _, tags := range []cloudscale.TagMap{initialTags, initialTagsKeyOnly} {
+		res, err := client.Volumes.List(ctx, cloudscale.WithTagFilter(tags))
+		if err != nil {
+			t.Errorf("Volumes.List returned error %s\n", err)
+		}
+		if len(res) > 0 {
+			t.Errorf("Expected no result when filter with %#v, got: %#v", tags, res)
+		}
+	}
+
+	newTagsKeyOnly := getNewTagsKeyOnly()
+	for _, tags := range []cloudscale.TagMap{newTags, newTagsKeyOnly} {
+		res, err := client.Volumes.List(ctx, cloudscale.WithTagFilter(tags))
+		if err != nil {
+			t.Errorf("Volumes.List returned error %s\n", err)
+		}
+		if len(res) != 1 {
+			t.Errorf("Expected exactly one result when filter with %#v, got: %#v", tags, len(res))
+		}
+	}
+
+	if err := client.VolumeSnapshots.Delete(ctx, snapshot.UUID); err != nil {
+		t.Fatalf("Warning: failed to delete snapshot %s: %v", snapshot.UUID, err)
+	}
+
+	// Wait for snapshot to be fully deleted before deleting volume
+	// As a volume has been created, deletion can take a few seconds longer
+	err = waitForSnapshotDeletion(ctx, snapshot.UUID, 30)
+	if err != nil {
+		t.Fatalf("Snapshot deletion timeout: %v", err)
+	}
+
+	if err := client.Volumes.Delete(ctx, sourceVolume.UUID); err != nil {
+		t.Fatalf("Volumes.Delete returned error %s: %v", sourceVolume.UUID, err)
+	}
+
+	err = client.Volumes.Delete(ctx, volume.UUID)
+	if err != nil {
+		t.Fatalf("Volumes.Delete returned error %s\n", err)
+	}
+}
+
+func TestIntegrationTags_Snapshot(t *testing.T) {
+	integrationTest(t)
+
+	createVolumeRequest := cloudscale.VolumeCreateRequest{
+		Name:   testRunPrefix,
+		SizeGB: 3,
+	}
+
+	volume, err := client.Volumes.Create(context.Background(), &createVolumeRequest)
+	if err != nil {
+		t.Fatalf("Volumes.Create returned error %s\n", err)
+	}
+
+	snapshotCreateRequest := &cloudscale.VolumeSnapshotCreateRequest{
+		Name:         testRunPrefix,
+		SourceVolume: volume.UUID,
+	}
+	initialTags := getInitialTags()
+	snapshotCreateRequest.Tags = &initialTags
+
+	snapshot, err := client.VolumeSnapshots.Create(context.Background(), snapshotCreateRequest)
+	if err != nil {
+		t.Fatalf("VolumeSnapshots.Create: %v", err)
+	}
+
+	getResult, err := client.VolumeSnapshots.Get(context.Background(), snapshot.UUID)
+	if err != nil {
+		t.Errorf("VolumeSnapshots.Get returned error %s\n", err)
+	}
+	if !reflect.DeepEqual(getResult.Tags, initialTags) {
+		t.Errorf("Tagging failed, could not tag, is at %s\n", getResult.Tags)
+	}
+
+	updateRequest := cloudscale.VolumeSnapshotUpdateRequest{}
+	newTags := getNewTags()
+	updateRequest.Tags = &newTags
+
+	err = client.VolumeSnapshots.Update(context.Background(), snapshot.UUID, &updateRequest)
+	if err != nil {
+		t.Errorf("VolumeSnapshots.Update returned error: %v", err)
+	}
+	getResult2, err := client.VolumeSnapshots.Get(context.Background(), snapshot.UUID)
+	if err != nil {
+		t.Errorf("VolumeSnapshots.Get returned error %s\n", err)
+	}
+	if !reflect.DeepEqual(getResult2.Tags, newTags) {
+		t.Errorf("Tagging failed, could not tag, is at %s\n", getResult.Tags)
+	}
+
+	// test querying with tags
+	initialTagsKeyOnly := getInitialTagsKeyOnly()
+	for _, tags := range []cloudscale.TagMap{initialTags, initialTagsKeyOnly} {
+		res, err := client.VolumeSnapshots.List(context.Background(), cloudscale.WithTagFilter(tags))
+		if err != nil {
+			t.Errorf("VolumeSnapshots.List returned error %s\n", err)
+		}
+		if len(res) > 0 {
+			t.Errorf("Expected no result when filter with %#v, got: %#v", tags, res)
+		}
+	}
+
+	newTagsKeyOnly := getNewTagsKeyOnly()
+	for _, tags := range []cloudscale.TagMap{newTags, newTagsKeyOnly} {
+		res, err := client.VolumeSnapshots.List(context.Background(), cloudscale.WithTagFilter(tags))
+		if err != nil {
+			t.Errorf("VolumeSnapshots.List returned error %s\n", err)
+		}
+		if len(res) != 1 {
+			t.Errorf("Expected exactly one result when filter with %#v, got: %#v", tags, len(res))
+		}
+	}
+
+	err = client.VolumeSnapshots.Delete(context.Background(), snapshot.UUID)
+	if err != nil {
+		t.Fatalf("VolumeSnapshots.Delete returned error %s\n", err)
+	}
+
+	// Wait for snapshot to be fully deleted before deleting volume
+	err = waitForSnapshotDeletion(context.Background(), snapshot.UUID, 10)
+	if err != nil {
+		t.Fatalf("Snapshot deletion timeout: %v", err)
+	}
+
+	if err := client.Volumes.Delete(context.Background(), volume.UUID); err != nil {
+		t.Fatalf("Warning: failed to delete volume %s: %v", volume.UUID, err)
+	}
+}
+
 func TestIntegrationTags_FloatingIP(t *testing.T) {
 	integrationTest(t)