snapshotgroup: support for creat/delete snapshot group

Signed-off-by: Raunak Kumar <[email protected]>

Author: Raunak Kumar

model/types.go

@@ -252,6 +252,16 @@ type VolumeGroup struct {
 	Config       map[string]interface{} `json:"config,omitempty"`
 }
 
+type SnapshotGroup struct {
+	ID                    string                 `json:"id,omitempty"`
+	Name                  string                 `json:"name,omitempty"`
+	SourceVolumeGroupID   string                 `json:"volume_group_id,omitempty"`
+	SourceVolumeGroupName string                 `json:"volume_group_name,omitempty"`
+	Snapshots             []*Snapshot            `json:"snapshots,omitempty"`
+	CreationTime          int64                  `json:"creation_time,omitempty"`
+	Config                map[string]interface{} `json:"config,omitempty"`
+}
+
 // PublishOptions are the options needed to publish a volume
 type PublishOptions struct {
 	HostUUID       string `json:"host_uuid,omitempty"`

storageprovider/csp/container_storage_provider.go

@@ -263,6 +263,64 @@ func (provider *ContainerStorageProvider) CreateVolume(name, description string,
 	return response, err
 }
 
+// CreateSnapshotGroup creates a snapshot group on the CSP
+func (provider *ContainerStorageProvider) CreateSnapshotGroup(name, sourceVolumeGroupID string, opts map[string]interface{}) (*model.SnapshotGroup, error) {
+	log.Tracef(">>>>> CreateSnapshotGroup, name: %s, sourceVolumeGroupID: %s", name, sourceVolumeGroupID)
+	defer log.Trace("<<<<< CreateSnapshotGroup")
+
+	response := &model.SnapshotGroup{}
+	var errorResponse *ErrorsPayload
+
+	snapshot_group := &model.SnapshotGroup{
+		Name:                name,
+		SourceVolumeGroupID: sourceVolumeGroupID,
+		Config:              opts,
+	}
+
+	// Create the snapshot group on the array
+	status, err := provider.invoke(
+		&connectivity.Request{
+			Action:        "POST",
+			Path:          "/containers/v1/snapshot_groups",
+			Payload:       &snapshot_group,
+			Response:      &response,
+			ResponseError: &errorResponse,
+		},
+	)
+	if errorResponse != nil {
+		return nil, handleError(status, errorResponse)
+	}
+
+	return response, err
+}
+
+// DeleteSnapshotGroup deletes a snapshot group on the CSP
+func (provider *ContainerStorageProvider) DeleteSnapshotGroup(id string) error {
+	log.Tracef(">>>>> DeleteSnapshotGroup, id: %s", id)
+	defer log.Trace("<<<<< DeleteSnapshotGroup")
+
+	var errorResponse *ErrorsPayload
+
+	// Delete the snapshot group on the array
+	status, err := provider.invoke(
+		&connectivity.Request{
+			Action:        "DELETE",
+			Path:          fmt.Sprintf("/containers/v1/snapshot_groups/%s", id),
+			Payload:       nil,
+			Response:      nil,
+			ResponseError: &errorResponse,
+		},
+	)
+	if errorResponse != nil {
+		return handleError(status, errorResponse)
+	}
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // CreateVolumeGroup creates a volume group on the CSP
 func (provider *ContainerStorageProvider) CreateVolumeGroup(name, description string, opts map[string]interface{}) (*model.VolumeGroup, error) {
 	log.Tracef(">>>>> CreateVolumeGroup, name: %s, opts: %+v", name, opts)

storageprovider/fake/fake_storage_provider.go

@@ -11,17 +11,19 @@ import (
 
 // StorageProvider is an implementor of the StorageProvider interface
 type StorageProvider struct {
-	volumes      map[string]model.Volume
-	snapshots    map[string]model.Snapshot
-	volumeGroups map[string]model.VolumeGroup
+	volumes        map[string]model.Volume
+	snapshots      map[string]model.Snapshot
+	volumeGroups   map[string]model.VolumeGroup
+	snapshotGroups map[string]model.SnapshotGroup
 }
 
 // NewFakeStorageProvider returns a fake storage provider
 func NewFakeStorageProvider() *StorageProvider {
 	return &StorageProvider{
-		volumes:      make(map[string]model.Volume),
-		snapshots:    make(map[string]model.Snapshot),
-		volumeGroups: make(map[string]model.VolumeGroup),
+		volumes:        make(map[string]model.Volume),
+		snapshots:      make(map[string]model.Snapshot),
+		volumeGroups:   make(map[string]model.VolumeGroup),
+		snapshotGroups: make(map[string]model.SnapshotGroup),
 	}
 }
 
@@ -55,7 +57,7 @@ func (provider *StorageProvider) CreateVolume(name, description string, size int
 	return &fakeVolume, nil
 }
 
-// CreateVolume returns a fake volume group
+// CreateVolumeGroup returns a fake volume group
 func (provider *StorageProvider) CreateVolumeGroup(name, description string, opts map[string]interface{}) (*model.VolumeGroup, error) {
 	if _, ok := provider.volumeGroups[name]; ok {
 		return nil, fmt.Errorf("Volume Group named %s already exists", name)
@@ -69,6 +71,20 @@ func (provider *StorageProvider) CreateVolumeGroup(name, description string, opt
 	return &fakeVolumeGroup, nil
 }
 
+// CreateSnapshotGroup returns a fake volume group
+func (provider *StorageProvider) CreateSnapshotGroup(name, sourceVolumeGroupID string) (*model.SnapshotGroup, error) {
+	if _, ok := provider.snapshotGroups[name]; ok {
+		return nil, fmt.Errorf("Snapshot Group named %s already exists", name)
+	}
+	fakeSnapshotGroup := model.SnapshotGroup{
+		ID:                  name,
+		Name:                name,
+		SourceVolumeGroupID: sourceVolumeGroupID,
+	}
+	provider.snapshotGroups[name] = fakeSnapshotGroup
+	return &fakeSnapshotGroup, nil
+}
+
 // CloneVolume returns a fake volume
 func (provider *StorageProvider) CloneVolume(name, description, sourceID, snapshotID string, size int64, opts map[string]interface{}) (*model.Volume, error) {
 	if _, ok := provider.volumes[name]; ok {
@@ -125,6 +141,15 @@ func (provider *StorageProvider) DeleteVolumeGroup(id string) error {
 	return fmt.Errorf("Could not find volume group with id %s", id)
 }
 
+// DeleteSnapshotGroup removes a fake snapshotGroup
+func (provider *StorageProvider) DeleteSnapshotGroup(id string) error {
+	if _, ok := provider.snapshotGroups[id]; ok {
+		delete(provider.snapshotGroups, id)
+		return nil
+	}
+	return fmt.Errorf("Could not find snapshot group with id %s", id)
+}
+
 // PublishVolume returns fake publish data
 func (provider *StorageProvider) PublishVolume(id, hostUUID, accessProtocol string) (*model.PublishInfo, error) {
 	return &model.PublishInfo{

storageprovider/fake/fake_storage_provider_test.go

@@ -10,12 +10,13 @@ import (
 )
 
 const (
-	volumeName      = "testCspVol"
-	volumeSize      = 1024 * 1024 * 1024
-	snapshotName    = "testCspSnapshot"
-	cloneName       = "testCspVolClone"
-	cloneSize       = 2 * 1024 * 1024 * 1024
-	volumeGroupName = "testCspVolumeGroup"
+	volumeName        = "testCspVol"
+	volumeSize        = 1024 * 1024 * 1024
+	snapshotName      = "testCspSnapshot"
+	cloneName         = "testCspVolClone"
+	cloneSize         = 2 * 1024 * 1024 * 1024
+	volumeGroupName   = "testCspVolumeGroup"
+	snapshotGroupName = "testCspSnapshotGroup"
 )
 
 // nolint: gocyclo
@@ -109,6 +110,18 @@ func TestPluginSuite(t *testing.T) {
 	if err != nil {
 		t.Fatal("Failed to create volume group" + volumeGroupName)
 	}
+
+	// Create Snapshot Group
+	config["test"] = "test"
+
+	snapshotGroup, err := provider.CreateSnapshotGroup(snapshotGroupName, volumeGroup.ID)
+	if err != nil {
+		t.Fatal("Failed to create snapshot group" + snapshotGroupName)
+	}
+
+	// Delete the Snapshot Group
+	deleteSnapshotGroup(t, provider, snapshotGroup)
+
 	// Delete the Volume Group
 	deleteVolumeGroup(t, provider, volumeGroup)
 
@@ -151,6 +164,14 @@ func deleteVolume(t *testing.T, provider *StorageProvider, volume *model.Volume)
 	assert.Nil(t, volume)
 }
 
+// nolint: dupl
+func deleteSnapshotGroup(t *testing.T, provider *StorageProvider, snapshotGroup *model.SnapshotGroup) {
+	err := provider.DeleteSnapshotGroup(snapshotGroup.ID)
+	if err != nil {
+		t.Fatal("Could not delete snapshot group" + snapshotGroup.Name + ".  Error: " + err.Error())
+	}
+}
+
 // nolint: dupl
 func deleteVolumeGroup(t *testing.T, provider *StorageProvider, volumeGroup *model.VolumeGroup) {
 	err := provider.DeleteVolumeGroup(volumeGroup.ID)

storageprovider/storage_provider.go

@@ -44,6 +44,8 @@ type StorageProvider interface {
 	EditVolume(id string, opts map[string]interface{}) (*model.Volume, error)
 	CreateVolumeGroup(name, description string, opts map[string]interface{}) (*model.VolumeGroup, error)
 	DeleteVolumeGroup(id string) error
+	CreateSnapshotGroup(name, sourceVolumeGroupID string, opts map[string]interface{}) (*model.SnapshotGroup, error)
+	DeleteSnapshotGroup(id string) error
 }
 
 // Credentials defines how a StorageProvider is accessed