From b73a4925c45260c61f243fe78cd87baaf3680bad Mon Sep 17 00:00:00 2001 From: hwchiu Date: Thu, 5 Jul 2018 02:54:43 +0000 Subject: [PATCH 1/5] Add the validata function --- src/storageprovider/nfs.go | 18 ++++++++++-- src/storageprovider/nfs_test.go | 49 +++++++++++++++++++++++++++++---- 2 files changed, 58 insertions(+), 9 deletions(-) diff --git a/src/storageprovider/nfs.go b/src/storageprovider/nfs.go index 1517deee..11f5e807 100644 --- a/src/storageprovider/nfs.go +++ b/src/storageprovider/nfs.go @@ -1,8 +1,10 @@ package storageprovider import ( + "fmt" "github.com/linkernetworks/vortex/src/entity" "github.com/linkernetworks/vortex/src/serviceprovider" + "net" // "gopkg.in/mgo.v2/bson" ) @@ -10,14 +12,24 @@ type NFSStorageProvider struct { entity.NFSStorage } -func (nfs NFSStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Container, network entity.Storage) error { +func (nfs NFSStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Container, storage entity.Storage) error { + ip := net.ParseIP(storage.NFS.IP) + if len(ip) == 0 { + return fmt.Errorf("Invalid IP address %s\n", storage.NFS.IP) + } + + path := storage.NFS.PATH + if path == "" || path[0] != '/' { + return fmt.Errorf("Invalid NFS export path %s\n", path) + } + return nil } -func (nfs NFSStorageProvider) CreateStorage(sp *serviceprovider.Container, network entity.Storage) error { +func (nfs NFSStorageProvider) CreateStorage(sp *serviceprovider.Container, storage entity.Storage) error { return nil } -func (nfs NFSStorageProvider) DeleteStorage(sp *serviceprovider.Container, network entity.Storage) error { +func (nfs NFSStorageProvider) DeleteStorage(sp *serviceprovider.Container, storage entity.Storage) error { return nil } diff --git a/src/storageprovider/nfs_test.go b/src/storageprovider/nfs_test.go index 2e5b117d..d0fd6d8c 100644 --- a/src/storageprovider/nfs_test.go +++ b/src/storageprovider/nfs_test.go @@ -5,7 +5,6 @@ import ( "fmt" "math/rand" "os/exec" - "runtime" "testing" "time" @@ -14,6 +13,7 @@ import ( "github.com/linkernetworks/vortex/src/entity" kc "github.com/linkernetworks/vortex/src/kubernetes" "github.com/linkernetworks/vortex/src/serviceprovider" + //"github.com/moby/moby/pkg/namesgenerator" "github.com/stretchr/testify/suite" //mgo "gopkg.in/mgo.v2" @@ -57,13 +57,50 @@ func (suite *StorageTestSuite) TearDownSuite() { } func TestStorageSuite(t *testing.T) { - if runtime.GOOS != "linux" { - fmt.Println("We only testing the ovs function on Linux Host") - t.Skip() - return - } suite.Run(t, new(StorageTestSuite)) } func (suite *StorageTestSuite) TestCreateStorage() { + +} + +func (suite *StorageTestSuite) TestValidateBeforeCreatingFail() { + testCases := []struct { + caseName string + storage *entity.Storage + }{ + {"invalidIP", &entity.Storage{ + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "a.b.c.d", + }, + }}, + {"invalidExports-1", &entity.Storage{ + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "1.2.3.4", + PATH: "tmp", + }, + }}, + {"invalidExports-2", &entity.Storage{ + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "1.2.3.4", + PATH: "", + }, + }}, + } + + for _, tc := range testCases { + suite.T().Run(tc.caseName, func(t *testing.T) { + //Parameters + np, err := GetStorageProvider(tc.storage) + suite.NoError(err) + np = np.(NFSStorageProvider) + + err = np.ValidateBeforeCreating(suite.sp, *tc.storage) + suite.Error(err) + }) + } + } From 3605506cc2ed5c011ee116b3f8c5d2c9aeb104d7 Mon Sep 17 00:00:00 2001 From: hwchiu Date: Thu, 5 Jul 2018 06:20:46 +0000 Subject: [PATCH 2/5] Add create function --- src/storageprovider/nfs.go | 70 ++++++++++++++++++++++++++++++++- src/storageprovider/nfs_test.go | 58 +++++++++++++++++++++++---- 2 files changed, 119 insertions(+), 9 deletions(-) diff --git a/src/storageprovider/nfs.go b/src/storageprovider/nfs.go index 11f5e807..cfe32978 100644 --- a/src/storageprovider/nfs.go +++ b/src/storageprovider/nfs.go @@ -2,12 +2,19 @@ package storageprovider import ( "fmt" + "net" + "github.com/linkernetworks/vortex/src/entity" "github.com/linkernetworks/vortex/src/serviceprovider" - "net" + appsv1 "k8s.io/api/apps/v1" + "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" // "gopkg.in/mgo.v2/bson" ) +const NFS_PROVISIONER_PREFIX = "nfs-provisioner" +const NFS_STORAGECLASS_PREFIX = "nfs-storageclass" + type NFSStorageProvider struct { entity.NFSStorage } @@ -26,8 +33,67 @@ func (nfs NFSStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Contain return nil } +func getDeployment(name string, storage *entity.Storage) *appsv1.Deployment { + var replicas int32 + replicas = 1 + volumeName := "nfs-client-root" + return &appsv1.Deployment{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + }, + Spec: appsv1.DeploymentSpec{ + Replicas: &replicas, + Strategy: appsv1.DeploymentStrategy{ + Type: appsv1.RecreateDeploymentStrategyType, + }, + Template: v1.PodTemplateSpec{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "app": name, + }, + }, + Spec: v1.PodSpec{ + Containers: []v1.Container{ + { + Name: name, + Image: "quay.io/kubernetes_incubator/nfs-provisioner:latest", + ImagePullPolicy: v1.PullIfNotPresent, + Env: []v1.EnvVar{ + {Name: "PROVISIONER_NAME", Value: name}, + {Name: "NFS_SERVER", Value: storage.NFS.IP}, + {Name: "NFS_PATH", Value: storage.NFS.PATH}, + }, + VolumeMounts: []v1.VolumeMount{ + {Name: volumeName, MountPath: "/persistentvolumes"}, + }, + }, + }, + Volumes: []v1.Volume{ + { + Name: volumeName, + VolumeSource: v1.VolumeSource{ + NFS: &v1.NFSVolumeSource{ + Server: storage.NFS.IP, + Path: storage.NFS.PATH, + }, + }, + }, + }, + }, + }, + }, + } + +} + func (nfs NFSStorageProvider) CreateStorage(sp *serviceprovider.Container, storage entity.Storage) error { - return nil + name := NFS_PROVISIONER_PREFIX + storage.ID.Hex() + + //Create deployment + deployment := getDeployment(name, &storage) + //Create storageClass + _, err := sp.KubeCtl.CreateDeployment(deployment) + return err } func (nfs NFSStorageProvider) DeleteStorage(sp *serviceprovider.Container, storage entity.Storage) error { diff --git a/src/storageprovider/nfs_test.go b/src/storageprovider/nfs_test.go index d0fd6d8c..58b05094 100644 --- a/src/storageprovider/nfs_test.go +++ b/src/storageprovider/nfs_test.go @@ -15,9 +15,7 @@ import ( "github.com/linkernetworks/vortex/src/serviceprovider" //"github.com/moby/moby/pkg/namesgenerator" "github.com/stretchr/testify/suite" - - //mgo "gopkg.in/mgo.v2" - + "gopkg.in/mgo.v2/bson" fakeclientset "k8s.io/client-go/kubernetes/fake" ) @@ -35,10 +33,7 @@ func execute(suite *suite.Suite, cmd *exec.Cmd) { type StorageTestSuite struct { suite.Suite - sp *serviceprovider.Container - fakeName string //Use for non-connectivity node - np NFSStorageProvider - network entity.Storage + sp *serviceprovider.Container } func (suite *StorageTestSuite) SetupSuite() { @@ -60,8 +55,57 @@ func TestStorageSuite(t *testing.T) { suite.Run(t, new(StorageTestSuite)) } +func (suite *StorageTestSuite) TestGetDeployment() { + storage := &entity.Storage{ + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "1.2.3.4", + PATH: "/exports", + }, + } + + deployment := getDeployment(bson.NewObjectId().Hex(), storage) + suite.NotNil(deployment) +} + +func (suite *StorageTestSuite) TestValidateBeforeCreating() { + storage := &entity.Storage{ + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "1.2.3.4", + PATH: "/exports", + }, + } + + //Parameters + sp, err := GetStorageProvider(storage) + suite.NoError(err) + sp = sp.(NFSStorageProvider) + + err = sp.ValidateBeforeCreating(suite.sp, *storage) + suite.NoError(err) +} + func (suite *StorageTestSuite) TestCreateStorage() { + storage := entity.Storage{ + ID: bson.NewObjectId(), + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "1.2.3.4", + PATH: "/exports", + }, + } + sp, err := GetStorageProvider(&storage) + suite.NoError(err) + sp = sp.(NFSStorageProvider) + + err = sp.CreateStorage(suite.sp, storage) + suite.NoError(err) + + deploy, err := suite.sp.KubeCtl.GetDeployment(NFS_PROVISIONER_PREFIX + storage.ID.Hex()) + suite.NotNil(deploy) + suite.NoError(err) } func (suite *StorageTestSuite) TestValidateBeforeCreatingFail() { From e9c2f9b0429d97d6f348a0d02d92b59cd15ddcb1 Mon Sep 17 00:00:00 2001 From: hwchiu Date: Thu, 5 Jul 2018 06:47:59 +0000 Subject: [PATCH 3/5] Delete the deployment --- src/kubernetes/deployment.go | 4 ++++ src/kubernetes/deployment_test.go | 28 ++++++++++++++++++++++++++++ src/storageprovider/nfs.go | 6 +++++- src/storageprovider/nfs_test.go | 30 +++++++++++++++++++++++++++++- 4 files changed, 66 insertions(+), 2 deletions(-) diff --git a/src/kubernetes/deployment.go b/src/kubernetes/deployment.go index d93fdda1..0165d1a1 100644 --- a/src/kubernetes/deployment.go +++ b/src/kubernetes/deployment.go @@ -13,3 +13,7 @@ func (kc *KubeCtl) CreateDeployment(deployment *appsv1.Deployment) (*appsv1.Depl func (kc *KubeCtl) GetDeployment(name string) (*appsv1.Deployment, error) { return kc.Clientset.AppsV1().Deployments(kc.Namespace).Get(name, metav1.GetOptions{}) } + +func (kc *KubeCtl) DeleteDeployment(name string) error { + return kc.Clientset.AppsV1().Deployments(kc.Namespace).Delete(name, &metav1.DeleteOptions{}) +} diff --git a/src/kubernetes/deployment_test.go b/src/kubernetes/deployment_test.go index 8f4f6bb5..a54d80a4 100644 --- a/src/kubernetes/deployment_test.go +++ b/src/kubernetes/deployment_test.go @@ -31,7 +31,29 @@ func (suite *KubeCtlDeploymentTestSuite) SetupSuite() { func (suite *KubeCtlDeploymentTestSuite) TearDownSuite() {} func (suite *KubeCtlDeploymentTestSuite) TestCreateDeployment() { + var replicas int32 + replicas = 3 + name := namesgenerator.GetRandomName(0) + deployment := appsv1.Deployment{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + }, + Spec: appsv1.DeploymentSpec{ + Replicas: &replicas, + }, + Status: appsv1.DeploymentStatus{}, + } + ret, err := suite.kubectl.CreateDeployment(&deployment) + suite.NoError(err) + suite.NotNil(ret) + deploy, err := suite.kubectl.GetDeployment(name) + suite.NoError(err) + suite.NotNil(deploy) + suite.Equal(replicas, *deploy.Spec.Replicas) +} + +func (suite *KubeCtlDeploymentTestSuite) TestDeleteDeployment() { var replicas int32 replicas = 3 name := namesgenerator.GetRandomName(0) @@ -52,6 +74,12 @@ func (suite *KubeCtlDeploymentTestSuite) TestCreateDeployment() { suite.NoError(err) suite.NotNil(deploy) suite.Equal(replicas, *deploy.Spec.Replicas) + + err = suite.kubectl.DeleteDeployment(name) + suite.NoError(err) + deploy, err = suite.kubectl.GetDeployment(name) + suite.Error(err) + suite.Nil(deploy) } func TestDeploymentTestSuite(t *testing.T) { diff --git a/src/storageprovider/nfs.go b/src/storageprovider/nfs.go index cfe32978..0fa8f878 100644 --- a/src/storageprovider/nfs.go +++ b/src/storageprovider/nfs.go @@ -97,5 +97,9 @@ func (nfs NFSStorageProvider) CreateStorage(sp *serviceprovider.Container, stora } func (nfs NFSStorageProvider) DeleteStorage(sp *serviceprovider.Container, storage entity.Storage) error { - return nil + name := NFS_PROVISIONER_PREFIX + storage.ID.Hex() + //Delete StorageClass + + //Delete Deployment + return sp.KubeCtl.DeleteDeployment(name) } diff --git a/src/storageprovider/nfs_test.go b/src/storageprovider/nfs_test.go index 58b05094..80f1c6a6 100644 --- a/src/storageprovider/nfs_test.go +++ b/src/storageprovider/nfs_test.go @@ -108,6 +108,35 @@ func (suite *StorageTestSuite) TestCreateStorage() { suite.NoError(err) } +func (suite *StorageTestSuite) TestDeleteStorage() { + storage := entity.Storage{ + ID: bson.NewObjectId(), + Type: entity.NFSStorageType, + NFS: entity.NFSStorage{ + IP: "1.2.3.4", + PATH: "/exports", + }, + } + + sp, err := GetStorageProvider(&storage) + suite.NoError(err) + sp = sp.(NFSStorageProvider) + + err = sp.CreateStorage(suite.sp, storage) + suite.NoError(err) + + deploy, err := suite.sp.KubeCtl.GetDeployment(NFS_PROVISIONER_PREFIX + storage.ID.Hex()) + suite.NotNil(deploy) + suite.NoError(err) + + err = sp.DeleteStorage(suite.sp, storage) + suite.NoError(err) + + deploy, err = suite.sp.KubeCtl.GetDeployment(NFS_PROVISIONER_PREFIX + storage.ID.Hex()) + suite.Nil(deploy) + suite.Error(err) +} + func (suite *StorageTestSuite) TestValidateBeforeCreatingFail() { testCases := []struct { caseName string @@ -146,5 +175,4 @@ func (suite *StorageTestSuite) TestValidateBeforeCreatingFail() { suite.Error(err) }) } - } From 4a6473d43a679f6d3a63c9db30da07f295b376bd Mon Sep 17 00:00:00 2001 From: hwchiu Date: Thu, 5 Jul 2018 07:02:52 +0000 Subject: [PATCH 4/5] Change the function type, from instance to pointer --- src/server/handler_storage.go | 14 +++++++------- src/storageprovider/fake.go | 6 +++--- src/storageprovider/fake_test.go | 12 ++++++------ src/storageprovider/nfs.go | 12 ++++++------ src/storageprovider/nfs_test.go | 10 +++++----- src/storageprovider/storage.go | 6 +++--- 6 files changed, 30 insertions(+), 30 deletions(-) diff --git a/src/server/handler_storage.go b/src/server/handler_storage.go index 96e41da1..2e9d5c2f 100644 --- a/src/server/handler_storage.go +++ b/src/server/handler_storage.go @@ -26,32 +26,32 @@ func createStorage(ctx *web.Context) { return } + storage.ID = bson.NewObjectId() + storage.CreatedAt = timeutils.Now() + session := sp.Mongo.NewSession() session.C(entity.StorageCollectionName).EnsureIndex(mgo.Index{ Key: []string{"name"}, Unique: true, }) defer session.Close() - // Check whether this displayname has been used - + // Check whether this name has been used storageProvider, err := storageprovider.GetStorageProvider(&storage) if err != nil { response.BadRequest(req.Request, resp.ResponseWriter, err) return } - if err := storageProvider.ValidateBeforeCreating(sp, storage); err != nil { + if err := storageProvider.ValidateBeforeCreating(sp, &storage); err != nil { response.BadRequest(req.Request, resp.ResponseWriter, err) return } - if err := storageProvider.CreateStorage(sp, storage); err != nil { + if err := storageProvider.CreateStorage(sp, &storage); err != nil { response.InternalServerError(req.Request, resp.ResponseWriter, err) return } - storage.ID = bson.NewObjectId() - storage.CreatedAt = timeutils.Now() if err := session.Insert(entity.StorageCollectionName, &storage); err != nil { if mgo.IsDup(err) { response.Conflict(req.Request, resp.ResponseWriter, fmt.Errorf("Storage Provider Name: %s already existed", storage.Name)) @@ -140,7 +140,7 @@ func deleteStorage(ctx *web.Context) { return } - if err := storageProvider.DeleteStorage(sp, storage); err != nil { + if err := storageProvider.DeleteStorage(sp, &storage); err != nil { response.InternalServerError(req.Request, resp.ResponseWriter, err) return } diff --git a/src/storageprovider/fake.go b/src/storageprovider/fake.go index 5d61f1e2..da00130e 100644 --- a/src/storageprovider/fake.go +++ b/src/storageprovider/fake.go @@ -10,21 +10,21 @@ type FakeStorageProvider struct { entity.FakeStorage } -func (fake FakeStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Container, net entity.Storage) error { +func (fake FakeStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Container, net *entity.Storage) error { if fake.FakeParameter == "" { return fmt.Errorf("Fail to validate but don't worry, I'm fake storage provider") } return nil } -func (fake FakeStorageProvider) CreateStorage(sp *serviceprovider.Container, net entity.Storage) error { +func (fake FakeStorageProvider) CreateStorage(sp *serviceprovider.Container, net *entity.Storage) error { if fake.IWantFail { return fmt.Errorf("Fail to create storage but don't worry, I'm fake storage provider") } return nil } -func (fake FakeStorageProvider) DeleteStorage(sp *serviceprovider.Container, net entity.Storage) error { +func (fake FakeStorageProvider) DeleteStorage(sp *serviceprovider.Container, net *entity.Storage) error { if fake.IWantFail { return fmt.Errorf("Fail to delete storage but don't worry, I'm fake storage provider") } diff --git a/src/storageprovider/fake_test.go b/src/storageprovider/fake_test.go index ae7dc571..2ab6f860 100644 --- a/src/storageprovider/fake_test.go +++ b/src/storageprovider/fake_test.go @@ -16,7 +16,7 @@ func TestStorageValidateBeforeCreating(t *testing.T) { }, }) assert.NoError(t, err) - err = fake.ValidateBeforeCreating(nil, entity.Storage{}) + err = fake.ValidateBeforeCreating(nil, &entity.Storage{}) assert.NoError(t, err) } @@ -29,7 +29,7 @@ func TestFakeStorageCreating(t *testing.T) { }, }) assert.NoError(t, err) - err = fake.CreateStorage(nil, entity.Storage{}) + err = fake.CreateStorage(nil, &entity.Storage{}) assert.NoError(t, err) } @@ -41,7 +41,7 @@ func TestFakeStorageValidateBeforeCreatingFail(t *testing.T) { }, }) assert.NoError(t, err) - err = fake.ValidateBeforeCreating(nil, entity.Storage{}) + err = fake.ValidateBeforeCreating(nil, &entity.Storage{}) assert.Error(t, err) } @@ -53,7 +53,7 @@ func TestFakeStorageCreatingFail(t *testing.T) { }, }) assert.NoError(t, err) - err = fake.CreateStorage(nil, entity.Storage{}) + err = fake.CreateStorage(nil, &entity.Storage{}) assert.Error(t, err) } @@ -63,7 +63,7 @@ func TestFakeStorageDelete(t *testing.T) { Fake: entity.FakeStorage{}, }) assert.NoError(t, err) - err = fake.DeleteStorage(nil, entity.Storage{}) + err = fake.DeleteStorage(nil, &entity.Storage{}) assert.NoError(t, err) } @@ -75,6 +75,6 @@ func TestFakeStorageDeleteFail(t *testing.T) { }, }) assert.NoError(t, err) - err = fake.DeleteStorage(nil, entity.Storage{}) + err = fake.DeleteStorage(nil, &entity.Storage{}) assert.Error(t, err) } diff --git a/src/storageprovider/nfs.go b/src/storageprovider/nfs.go index 0fa8f878..80221103 100644 --- a/src/storageprovider/nfs.go +++ b/src/storageprovider/nfs.go @@ -12,14 +12,14 @@ import ( // "gopkg.in/mgo.v2/bson" ) -const NFS_PROVISIONER_PREFIX = "nfs-provisioner" -const NFS_STORAGECLASS_PREFIX = "nfs-storageclass" +const NFS_PROVISIONER_PREFIX = "nfs-provisioner-" +const NFS_STORAGECLASS_PREFIX = "nfs-storageclass-" type NFSStorageProvider struct { entity.NFSStorage } -func (nfs NFSStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Container, storage entity.Storage) error { +func (nfs NFSStorageProvider) ValidateBeforeCreating(sp *serviceprovider.Container, storage *entity.Storage) error { ip := net.ParseIP(storage.NFS.IP) if len(ip) == 0 { return fmt.Errorf("Invalid IP address %s\n", storage.NFS.IP) @@ -86,17 +86,17 @@ func getDeployment(name string, storage *entity.Storage) *appsv1.Deployment { } -func (nfs NFSStorageProvider) CreateStorage(sp *serviceprovider.Container, storage entity.Storage) error { +func (nfs NFSStorageProvider) CreateStorage(sp *serviceprovider.Container, storage *entity.Storage) error { name := NFS_PROVISIONER_PREFIX + storage.ID.Hex() //Create deployment - deployment := getDeployment(name, &storage) + deployment := getDeployment(name, storage) //Create storageClass _, err := sp.KubeCtl.CreateDeployment(deployment) return err } -func (nfs NFSStorageProvider) DeleteStorage(sp *serviceprovider.Container, storage entity.Storage) error { +func (nfs NFSStorageProvider) DeleteStorage(sp *serviceprovider.Container, storage *entity.Storage) error { name := NFS_PROVISIONER_PREFIX + storage.ID.Hex() //Delete StorageClass diff --git a/src/storageprovider/nfs_test.go b/src/storageprovider/nfs_test.go index 80f1c6a6..ca1dcc5e 100644 --- a/src/storageprovider/nfs_test.go +++ b/src/storageprovider/nfs_test.go @@ -82,7 +82,7 @@ func (suite *StorageTestSuite) TestValidateBeforeCreating() { suite.NoError(err) sp = sp.(NFSStorageProvider) - err = sp.ValidateBeforeCreating(suite.sp, *storage) + err = sp.ValidateBeforeCreating(suite.sp, storage) suite.NoError(err) } @@ -100,7 +100,7 @@ func (suite *StorageTestSuite) TestCreateStorage() { suite.NoError(err) sp = sp.(NFSStorageProvider) - err = sp.CreateStorage(suite.sp, storage) + err = sp.CreateStorage(suite.sp, &storage) suite.NoError(err) deploy, err := suite.sp.KubeCtl.GetDeployment(NFS_PROVISIONER_PREFIX + storage.ID.Hex()) @@ -109,7 +109,7 @@ func (suite *StorageTestSuite) TestCreateStorage() { } func (suite *StorageTestSuite) TestDeleteStorage() { - storage := entity.Storage{ + storage := &entity.Storage{ ID: bson.NewObjectId(), Type: entity.NFSStorageType, NFS: entity.NFSStorage{ @@ -118,7 +118,7 @@ func (suite *StorageTestSuite) TestDeleteStorage() { }, } - sp, err := GetStorageProvider(&storage) + sp, err := GetStorageProvider(storage) suite.NoError(err) sp = sp.(NFSStorageProvider) @@ -171,7 +171,7 @@ func (suite *StorageTestSuite) TestValidateBeforeCreatingFail() { suite.NoError(err) np = np.(NFSStorageProvider) - err = np.ValidateBeforeCreating(suite.sp, *tc.storage) + err = np.ValidateBeforeCreating(suite.sp, tc.storage) suite.Error(err) }) } diff --git a/src/storageprovider/storage.go b/src/storageprovider/storage.go index 8d3b1734..b1b7bf7d 100644 --- a/src/storageprovider/storage.go +++ b/src/storageprovider/storage.go @@ -7,9 +7,9 @@ import ( ) type StorageProvider interface { - ValidateBeforeCreating(sp *serviceprovider.Container, net entity.Storage) error - CreateStorage(sp *serviceprovider.Container, net entity.Storage) error - DeleteStorage(sp *serviceprovider.Container, net entity.Storage) error + ValidateBeforeCreating(sp *serviceprovider.Container, net *entity.Storage) error + CreateStorage(sp *serviceprovider.Container, net *entity.Storage) error + DeleteStorage(sp *serviceprovider.Container, net *entity.Storage) error } func GetStorageProvider(storage *entity.Storage) (StorageProvider, error) { From 2fded36f98e9100e7765a34a7a2fbf91d22d7f77 Mon Sep 17 00:00:00 2001 From: hwchiu Date: Thu, 5 Jul 2018 09:19:33 +0000 Subject: [PATCH 5/5] Fix the type, don't save to the mongodb --- src/entity/storage.go | 4 ++-- src/server/handler_storage_test.go | 16 ++++++++-------- src/storageprovider/fake_test.go | 12 ++++++------ src/storageprovider/nfs.go | 5 +++++ src/storageprovider/nfs_test.go | 14 +++++++------- src/storageprovider/storage.go | 4 ++-- src/storageprovider/storage_test.go | 2 ++ 7 files changed, 32 insertions(+), 25 deletions(-) diff --git a/src/entity/storage.go b/src/entity/storage.go index a2f22447..6667240d 100644 --- a/src/entity/storage.go +++ b/src/entity/storage.go @@ -22,8 +22,8 @@ type Storage struct { Type StorageType `bson:"type" json:"type"` Name string `bson:"name" json:"name"` CreatedAt *time.Time `bson:"createdAt,omitempty" json:"createdAt,omitempty"` - NFS NFSStorage `bson:"nfs" json:"nfs"` - Fake FakeStorage `json:"fake"` //FakeNetwork, for restful testing. + NFS *NFSStorage `bson:"nfs,omitempty" json:"nfs,omitempty"` + Fake *FakeStorage `bson:"fake,omitempty" json:"fake,omitempty"` //FakeStorage, for restful testing. } //GetCollection - get model mongo collection name. diff --git a/src/server/handler_storage_test.go b/src/server/handler_storage_test.go index f46052e9..5cef4788 100644 --- a/src/server/handler_storage_test.go +++ b/src/server/handler_storage_test.go @@ -62,7 +62,7 @@ func (suite *StorageTestSuite) TestCreateStorage() { storage := entity.Storage{ Type: entity.FakeStorageType, Name: tName, - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "fake~", }, } @@ -103,14 +103,14 @@ func (suite *StorageTestSuite) TestCreateStorageFail() { {"InvalidParameter", entity.Storage{ Name: namesgenerator.GetRandomName(0), Type: entity.FakeStorageType, - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "", }}, http.StatusBadRequest}, {"CreateFail", entity.Storage{ Name: namesgenerator.GetRandomName(0), Type: entity.FakeStorageType, - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "Yo", IWantFail: true, }}, @@ -118,7 +118,7 @@ func (suite *StorageTestSuite) TestCreateStorageFail() { {"StorageTypeError", entity.Storage{ Name: namesgenerator.GetRandomName(0), Type: "non-exist", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "Yo", IWantFail: true, }}, @@ -150,7 +150,7 @@ func (suite *StorageTestSuite) TestDeleteStorage() { ID: bson.NewObjectId(), Type: entity.FakeStorageType, Name: tName, - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "fake~", }, } @@ -198,7 +198,7 @@ func (suite *StorageTestSuite) TestDeleteStorageFail() { ID: bson.NewObjectId(), Name: namesgenerator.GetRandomName(0), Type: entity.FakeStorageType, - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "Yo-Delete-Fail", IWantFail: true, }}, @@ -207,7 +207,7 @@ func (suite *StorageTestSuite) TestDeleteStorageFail() { ID: bson.NewObjectId(), Name: namesgenerator.GetRandomName(0), Type: "non-exist", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "Yo-Delete-Fail", IWantFail: true, }}, @@ -238,7 +238,7 @@ func (suite *StorageTestSuite) TestListStorage() { storages = append(storages, entity.Storage{ Name: namesgenerator.GetRandomName(0), Type: entity.FakeStorageType, - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "Yo", IWantFail: false, }, diff --git a/src/storageprovider/fake_test.go b/src/storageprovider/fake_test.go index 2ab6f860..d648b5d0 100644 --- a/src/storageprovider/fake_test.go +++ b/src/storageprovider/fake_test.go @@ -11,7 +11,7 @@ import ( func TestStorageValidateBeforeCreating(t *testing.T) { fake, err := GetStorageProvider(&entity.Storage{ Type: "fake", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "yes", }, }) @@ -23,7 +23,7 @@ func TestStorageValidateBeforeCreating(t *testing.T) { func TestFakeStorageCreating(t *testing.T) { fake, err := GetStorageProvider(&entity.Storage{ Type: "fake", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "yes", IWantFail: false, }, @@ -36,7 +36,7 @@ func TestFakeStorageCreating(t *testing.T) { func TestFakeStorageValidateBeforeCreatingFail(t *testing.T) { fake, err := GetStorageProvider(&entity.Storage{ Type: "fake", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ FakeParameter: "", }, }) @@ -48,7 +48,7 @@ func TestFakeStorageValidateBeforeCreatingFail(t *testing.T) { func TestFakeStorageCreatingFail(t *testing.T) { fake, err := GetStorageProvider(&entity.Storage{ Type: "fake", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ IWantFail: true, }, }) @@ -60,7 +60,7 @@ func TestFakeStorageCreatingFail(t *testing.T) { func TestFakeStorageDelete(t *testing.T) { fake, err := GetStorageProvider(&entity.Storage{ Type: "fake", - Fake: entity.FakeStorage{}, + Fake: &entity.FakeStorage{}, }) assert.NoError(t, err) err = fake.DeleteStorage(nil, &entity.Storage{}) @@ -70,7 +70,7 @@ func TestFakeStorageDelete(t *testing.T) { func TestFakeStorageDeleteFail(t *testing.T) { fake, err := GetStorageProvider(&entity.Storage{ Type: "fake", - Fake: entity.FakeStorage{ + Fake: &entity.FakeStorage{ IWantFail: true, }, }) diff --git a/src/storageprovider/nfs.go b/src/storageprovider/nfs.go index 80221103..9dc6cfe2 100644 --- a/src/storageprovider/nfs.go +++ b/src/storageprovider/nfs.go @@ -42,6 +42,11 @@ func getDeployment(name string, storage *entity.Storage) *appsv1.Deployment { Name: name, }, Spec: appsv1.DeploymentSpec{ + Selector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "app": name, + }, + }, Replicas: &replicas, Strategy: appsv1.DeploymentStrategy{ Type: appsv1.RecreateDeploymentStrategyType, diff --git a/src/storageprovider/nfs_test.go b/src/storageprovider/nfs_test.go index ca1dcc5e..87a4df2d 100644 --- a/src/storageprovider/nfs_test.go +++ b/src/storageprovider/nfs_test.go @@ -58,7 +58,7 @@ func TestStorageSuite(t *testing.T) { func (suite *StorageTestSuite) TestGetDeployment() { storage := &entity.Storage{ Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "1.2.3.4", PATH: "/exports", }, @@ -71,7 +71,7 @@ func (suite *StorageTestSuite) TestGetDeployment() { func (suite *StorageTestSuite) TestValidateBeforeCreating() { storage := &entity.Storage{ Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "1.2.3.4", PATH: "/exports", }, @@ -90,7 +90,7 @@ func (suite *StorageTestSuite) TestCreateStorage() { storage := entity.Storage{ ID: bson.NewObjectId(), Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "1.2.3.4", PATH: "/exports", }, @@ -112,7 +112,7 @@ func (suite *StorageTestSuite) TestDeleteStorage() { storage := &entity.Storage{ ID: bson.NewObjectId(), Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "1.2.3.4", PATH: "/exports", }, @@ -144,20 +144,20 @@ func (suite *StorageTestSuite) TestValidateBeforeCreatingFail() { }{ {"invalidIP", &entity.Storage{ Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "a.b.c.d", }, }}, {"invalidExports-1", &entity.Storage{ Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "1.2.3.4", PATH: "tmp", }, }}, {"invalidExports-2", &entity.Storage{ Type: entity.NFSStorageType, - NFS: entity.NFSStorage{ + NFS: &entity.NFSStorage{ IP: "1.2.3.4", PATH: "", }, diff --git a/src/storageprovider/storage.go b/src/storageprovider/storage.go index b1b7bf7d..176a6a21 100644 --- a/src/storageprovider/storage.go +++ b/src/storageprovider/storage.go @@ -15,9 +15,9 @@ type StorageProvider interface { func GetStorageProvider(storage *entity.Storage) (StorageProvider, error) { switch storage.Type { case "nfs": - return NFSStorageProvider{storage.NFS}, nil + return NFSStorageProvider{*storage.NFS}, nil case "fake": - return FakeStorageProvider{storage.Fake}, nil + return FakeStorageProvider{*storage.Fake}, nil default: return nil, fmt.Errorf("Unsupported Storage Type %s", storage.Type) } diff --git a/src/storageprovider/storage_test.go b/src/storageprovider/storage_test.go index 01e309fd..157a5191 100644 --- a/src/storageprovider/storage_test.go +++ b/src/storageprovider/storage_test.go @@ -24,6 +24,8 @@ func TestGetStorageProvider(t *testing.T) { provider, err := GetStorageProvider( &entity.Storage{ Type: tc.storageType, + Fake: &entity.FakeStorage{}, + NFS: &entity.NFSStorage{}, }) assert.NoError(t, err) a := reflect.TypeOf(provider)