Refactor the storage to support multiple type.

src/entity/network_fake.go

@@ -1,6 +1,6 @@
 package entity
 
 type FakeNetwork struct {
-	FakeParameter string `bson:"bridgeName" json:"bridgeName"`
-	IWantFail     bool   `bson:"iWantFail" json:"iWantFail"`
+	FakeParameter string
+	IWantFail     bool
 }

src/entity/storage.go

@@ -0,0 +1,32 @@
+package entity
+
+import (
+	"time"
+
+	"gopkg.in/mgo.v2/bson"
+)
+
+type StorageType string
+
+const (
+	NFSStorageType  = "nfs"
+	FakeStorageType = "fake"
+)
+
+const (
+	StorageCollectionName string = "storage"
+)
+
+type Storage struct {
+	ID        bson.ObjectId `bson:"_id,omitempty" json:"id"`
+	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.
+}
+
+//GetCollection - get model mongo collection name.
+func (m Storage) GetCollection() string {
+	return StorageCollectionName
+}

src/entity/storage_fake.go

@@ -0,0 +1,6 @@
+package entity
+
+type FakeStorage struct {
+	FakeParameter string
+	IWantFail     bool
+}

src/entity/storage_nfs.go

@@ -0,0 +1,6 @@
+package entity
+
+type NFSStorage struct {
+	IP   string `bson:"ip" json:"ip"`
+	PATH string `bson:"path" json:"path"`
+}

src/kubernetes/deployment.go

@@ -0,0 +1,15 @@
+package kubernetes
+
+import (
+	appsv1 "k8s.io/api/apps/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+//Get the external IP address of node
+func (kc *KubeCtl) CreateDeployment(deployment *appsv1.Deployment) (*appsv1.Deployment, error) {
+	return kc.Clientset.AppsV1().Deployments(kc.Namespace).Create(deployment)
+}
+
+func (kc *KubeCtl) GetDeployment(name string) (*appsv1.Deployment, error) {
+	return kc.Clientset.AppsV1().Deployments(kc.Namespace).Get(name, metav1.GetOptions{})
+}

src/kubernetes/deployment_test.go

@@ -0,0 +1,59 @@
+package kubernetes
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/moby/moby/pkg/namesgenerator"
+	"github.com/stretchr/testify/suite"
+	appsv1 "k8s.io/api/apps/v1"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	fakeclientset "k8s.io/client-go/kubernetes/fake"
+)
+
+type KubeCtlDeploymentTestSuite struct {
+	suite.Suite
+	kubectl    *KubeCtl
+	fakeclient *fakeclientset.Clientset
+}
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+func (suite *KubeCtlDeploymentTestSuite) SetupSuite() {
+	suite.fakeclient = fakeclientset.NewSimpleClientset()
+	namespace := "default"
+	suite.kubectl = New(suite.fakeclient, namespace)
+}
+
+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 TestDeploymentTestSuite(t *testing.T) {
+	suite.Run(t, new(KubeCtlDeploymentTestSuite))
+}

src/server/handler_storage_provider.go → src/server/handler_storage.go

@@ -10,6 +10,7 @@ import (
 	"github.com/linkernetworks/vortex/src/entity"
 	response "github.com/linkernetworks/vortex/src/net/http"
 	"github.com/linkernetworks/vortex/src/net/http/query"
+	"github.com/linkernetworks/vortex/src/storageprovider"
 	"github.com/linkernetworks/vortex/src/web"
 	mgo "gopkg.in/mgo.v2"
 	"gopkg.in/mgo.v2/bson"
@@ -18,25 +19,42 @@ import (
 func createStorage(ctx *web.Context) {
 	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
 
-	storageProvider := entity.Storage{}
-	if err := req.ReadEntity(&storageProvider); err != nil {
+	storage := entity.Storage{}
+	if err := req.ReadEntity(&storage); err != nil {
 		logger.Error(err)
 		response.BadRequest(req.Request, resp.ResponseWriter, err)
 		return
 	}
 
 	session := sp.Mongo.NewSession()
 	session.C(entity.StorageCollectionName).EnsureIndex(mgo.Index{
-		Key:    []string{"displayName"},
+		Key:    []string{"name"},
 		Unique: true,
 	})
 	defer session.Close()
 	// Check whether this displayname has been used
-	storageProvider.ID = bson.NewObjectId()
-	storageProvider.CreatedAt = timeutils.Now()
-	if err := session.Insert(entity.StorageCollectionName, &storageProvider); err != nil {
+
+	storageProvider, err := storageprovider.GetStorageProvider(&storage)
+	if err != nil {
+		response.BadRequest(req.Request, resp.ResponseWriter, err)
+		return
+	}
+
+	if err := storageProvider.ValidateBeforeCreating(sp, storage); err != nil {
+		response.BadRequest(req.Request, resp.ResponseWriter, err)
+		return
+	}
+
+	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", storageProvider.DisplayName))
+			response.Conflict(req.Request, resp.ResponseWriter, fmt.Errorf("Storage Provider Name: %s already existed", storage.Name))
 		} else {
 			response.InternalServerError(req.Request, resp.ResponseWriter, err)
 		}
@@ -98,12 +116,34 @@ func listStorage(ctx *web.Context) {
 }
 
 func deleteStorage(ctx *web.Context) {
-	as, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
 
 	id := req.PathParameter("id")
 
-	session := as.Mongo.NewSession()
+	session := sp.Mongo.NewSession()
 	defer session.Close()
+	c := session.C(entity.StorageCollectionName)
+
+	var storage entity.Storage
+	if err := c.FindId(bson.ObjectIdHex(id)).One(&storage); err != nil {
+		if err == mgo.ErrNotFound {
+			response.NotFound(req.Request, resp.ResponseWriter, err)
+		} else {
+			response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		}
+		return
+	}
+
+	storageProvider, err := storageprovider.GetStorageProvider(&storage)
+	if err != nil {
+		response.BadRequest(req.Request, resp.ResponseWriter, err)
+		return
+	}
+
+	if err := storageProvider.DeleteStorage(sp, storage); err != nil {
+		response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		return
+	}
 
 	if err := session.Remove(entity.StorageCollectionName, "_id", bson.ObjectIdHex(id)); err != nil {
 		if mgo.ErrNotFound == err {