aboutsummaryrefslogtreecommitdiffstats
path: root/src/k8splugin/api
diff options
context:
space:
mode:
Diffstat (limited to 'src/k8splugin/api')
-rw-r--r--src/k8splugin/api/api.go120
-rw-r--r--src/k8splugin/api/handler.go377
-rw-r--r--src/k8splugin/api/handler_test.go316
-rw-r--r--src/k8splugin/api/model.go76
4 files changed, 889 insertions, 0 deletions
diff --git a/src/k8splugin/api/api.go b/src/k8splugin/api/api.go
new file mode 100644
index 00000000..651d9311
--- /dev/null
+++ b/src/k8splugin/api/api.go
@@ -0,0 +1,120 @@
+/*
+Copyright 2018 Intel Corporation.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+import (
+ "os"
+ "path/filepath"
+ "plugin"
+ "strings"
+
+ "github.com/gorilla/mux"
+ pkgerrors "github.com/pkg/errors"
+
+ "k8splugin/db"
+ "k8splugin/krd"
+)
+
+// CheckEnvVariables checks for required Environment variables
+func CheckEnvVariables() error {
+ envList := []string{"CSAR_DIR", "KUBE_CONFIG_DIR", "DATABASE_TYPE", "DATABASE_IP"}
+ for _, env := range envList {
+ if _, ok := os.LookupEnv(env); !ok {
+ return pkgerrors.New("environment variable " + env + " not set")
+ }
+ }
+
+ return nil
+}
+
+// CheckDatabaseConnection checks if the database is up and running and
+// plugin can talk to it
+func CheckDatabaseConnection() error {
+ err := db.CreateDBClient(os.Getenv("DATABASE_TYPE"))
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+
+ err = db.DBconn.InitializeDatabase()
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+
+ err = db.DBconn.CheckDatabase()
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+ return nil
+}
+
+// LoadPlugins loads all the compiled .so plugins
+func LoadPlugins() error {
+ pluginsDir, ok := os.LookupEnv("PLUGINS_DIR")
+ if !ok {
+ pluginsDir, _ = filepath.Abs(filepath.Dir(os.Args[0]))
+ }
+ err := filepath.Walk(pluginsDir,
+ func(path string, info os.FileInfo, err error) error {
+ if strings.Contains(path, ".so") {
+ p, err := plugin.Open(path)
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+
+ krd.LoadedPlugins[info.Name()[:len(info.Name())-3]] = p
+ }
+ return err
+ })
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// CheckInitialSettings is used to check initial settings required to start api
+func CheckInitialSettings() error {
+ err := CheckEnvVariables()
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+
+ err = CheckDatabaseConnection()
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+
+ err = LoadPlugins()
+ if err != nil {
+ return pkgerrors.Cause(err)
+ }
+
+ return nil
+}
+
+// NewRouter creates a router instance that serves the VNFInstance web methods
+func NewRouter(kubeconfig string) *mux.Router {
+ router := mux.NewRouter()
+
+ vnfInstanceHandler := router.PathPrefix("/v1/vnf_instances").Subrouter()
+ vnfInstanceHandler.HandleFunc("/", CreateHandler).Methods("POST").Name("VNFCreation")
+ vnfInstanceHandler.HandleFunc("/{cloudRegionID}/{namespace}", ListHandler).Methods("GET")
+ vnfInstanceHandler.HandleFunc("/{cloudRegionID}/{namespace}/{externalVNFID}", DeleteHandler).Methods("DELETE")
+ vnfInstanceHandler.HandleFunc("/{cloudRegionID}/{namespace}/{externalVNFID}", GetHandler).Methods("GET")
+
+ // (TODO): Fix update method
+ // vnfInstanceHandler.HandleFunc("/{vnfInstanceId}", UpdateHandler).Methods("PUT")
+
+ return router
+}
diff --git a/src/k8splugin/api/handler.go b/src/k8splugin/api/handler.go
new file mode 100644
index 00000000..27d060aa
--- /dev/null
+++ b/src/k8splugin/api/handler.go
@@ -0,0 +1,377 @@
+/*
+Copyright 2018 Intel Corporation.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+import (
+ "encoding/json"
+ "errors"
+ "log"
+ "net/http"
+ "os"
+ "strings"
+
+ "github.com/gorilla/mux"
+ pkgerrors "github.com/pkg/errors"
+ "k8s.io/client-go/kubernetes"
+
+ "k8splugin/csar"
+ "k8splugin/db"
+ "k8splugin/krd"
+)
+
+// GetVNFClient retrieves the client used to communicate with a Kubernetes Cluster
+var GetVNFClient = func(kubeConfigPath string) (kubernetes.Clientset, error) {
+ client, err := krd.GetKubeClient(kubeConfigPath)
+ if err != nil {
+ return client, err
+ }
+ return client, nil
+}
+
+func validateBody(body interface{}) error {
+ switch b := body.(type) {
+ case CreateVnfRequest:
+ if b.CloudRegionID == "" {
+ werr := pkgerrors.Wrap(errors.New("Invalid/Missing CloudRegionID in POST request"), "CreateVnfRequest bad request")
+ return werr
+ }
+ if b.CsarID == "" {
+ werr := pkgerrors.Wrap(errors.New("Invalid/Missing CsarID in POST request"), "CreateVnfRequest bad request")
+ return werr
+ }
+ if strings.Contains(b.CloudRegionID, "|") || strings.Contains(b.Namespace, "|") {
+ werr := pkgerrors.Wrap(errors.New("Character \"|\" not allowed in CSAR ID"), "CreateVnfRequest bad request")
+ return werr
+ }
+ case UpdateVnfRequest:
+ if b.CloudRegionID == "" || b.CsarID == "" {
+ werr := pkgerrors.Wrap(errors.New("Invalid/Missing Data in PUT request"), "UpdateVnfRequest bad request")
+ return werr
+ }
+ }
+ return nil
+}
+
+// CreateHandler is the POST method creates a new VNF instance resource.
+func CreateHandler(w http.ResponseWriter, r *http.Request) {
+ var resource CreateVnfRequest
+
+ if r.Body == nil {
+ http.Error(w, "Body empty", http.StatusBadRequest)
+ return
+ }
+
+ err := json.NewDecoder(r.Body).Decode(&resource)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+ return
+ }
+
+ err = validateBody(resource)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+ return
+ }
+
+ // (TODO): Read kubeconfig for specific Cloud Region from local file system
+ // if present or download it from AAI
+ // err := DownloadKubeConfigFromAAI(resource.CloudRegionID, os.Getenv("KUBE_CONFIG_DIR")
+ kubeclient, err := GetVNFClient(os.Getenv("KUBE_CONFIG_DIR") + "/" + resource.CloudRegionID)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ /*
+ uuid,
+ {
+ "deployment": ["cloud1-default-uuid-sisedeploy1", "cloud1-default-uuid-sisedeploy2", ... ]
+ "service": ["cloud1-default-uuid-sisesvc1", "cloud1-default-uuid-sisesvc2", ... ]
+ },
+ nil
+ */
+ externalVNFID, resourceNameMap, err := csar.CreateVNF(resource.CsarID, resource.CloudRegionID, resource.Namespace, &kubeclient)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Read Kubernetes Data information error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ // cloud1-default-uuid
+ internalVNFID := resource.CloudRegionID + "-" + resource.Namespace + "-" + externalVNFID
+
+ // Persist in AAI database.
+ log.Printf("Cloud Region ID: %s, Namespace: %s, VNF ID: %s ", resource.CloudRegionID, resource.Namespace, externalVNFID)
+
+ // TODO: Uncomment when annotations are done
+ // krd.AddNetworkAnnotationsToPod(kubeData, resource.Networks)
+
+ // "{"deployment":<>,"service":<>}"
+ out, err := json.Marshal(resourceNameMap)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Create VNF deployment error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+ serializedResourceNameMap := string(out)
+
+ // key: cloud1-default-uuid
+ // value: "{"deployment":<>,"service":<>}"
+ err = db.DBconn.CreateEntry(internalVNFID, serializedResourceNameMap)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Create VNF deployment error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ resp := CreateVnfResponse{
+ VNFID: externalVNFID,
+ CloudRegionID: resource.CloudRegionID,
+ Namespace: resource.Namespace,
+ VNFComponents: resourceNameMap,
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusCreated)
+ json.NewEncoder(w).Encode(resp)
+}
+
+// ListHandler the existing VNF instances created in a given Kubernetes cluster
+func ListHandler(w http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+
+ cloudRegionID := vars["cloudRegionID"]
+ namespace := vars["namespace"]
+ prefix := cloudRegionID + "-" + namespace
+
+ internalVNFIDs, err := db.DBconn.ReadAll(prefix)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Get VNF list error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ if len(internalVNFIDs) == 0 {
+ w.WriteHeader(http.StatusNotFound)
+ return
+ }
+
+ // TODO: There is an edge case where if namespace is passed but is missing some characters
+ // trailing, it will print the result with those excluding characters. This is because of
+ // the way I am trimming the Prefix. This fix is needed.
+
+ var editedList []string
+
+ for _, id := range internalVNFIDs {
+ if len(id) > 0 {
+ editedList = append(editedList, strings.TrimPrefix(id, prefix)[1:])
+ }
+ }
+
+ if len(editedList) == 0 {
+ editedList = append(editedList, "")
+ }
+
+ resp := ListVnfsResponse{
+ VNFs: editedList,
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(resp)
+}
+
+// DeleteHandler method terminates an individual VNF instance.
+func DeleteHandler(w http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+
+ cloudRegionID := vars["cloudRegionID"] // cloud1
+ namespace := vars["namespace"] // default
+ externalVNFID := vars["externalVNFID"] // uuid
+
+ // cloud1-default-uuid
+ internalVNFID := cloudRegionID + "-" + namespace + "-" + externalVNFID
+
+ // (TODO): Read kubeconfig for specific Cloud Region from local file system
+ // if present or download it from AAI
+ // err := DownloadKubeConfigFromAAI(resource.CloudRegionID, os.Getenv("KUBE_CONFIG_DIR")
+ kubeclient, err := GetVNFClient(os.Getenv("KUBE_CONFIG_DIR") + "/" + cloudRegionID)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ // key: cloud1-default-uuid
+ // value: "{"deployment":<>,"service":<>}"
+ serializedResourceNameMap, found, err := db.DBconn.ReadEntry(internalVNFID)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ if found == false {
+ w.WriteHeader(http.StatusNotFound)
+ return
+ }
+
+ /*
+ {
+ "deployment": ["cloud1-default-uuid-sisedeploy1", "cloud1-default-uuid-sisedeploy2", ... ]
+ "service": ["cloud1-default-uuid-sisesvc1", "cloud1-default-uuid-sisesvc2", ... ]
+ },
+ */
+ deserializedResourceNameMap := make(map[string][]string)
+ err = json.Unmarshal([]byte(serializedResourceNameMap), &deserializedResourceNameMap)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Delete VNF error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ err = csar.DestroyVNF(deserializedResourceNameMap, namespace, &kubeclient)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Delete VNF error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ err = db.DBconn.DeleteEntry(internalVNFID)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Delete VNF error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusAccepted)
+}
+
+// // UpdateHandler method to update a VNF instance.
+// func UpdateHandler(w http.ResponseWriter, r *http.Request) {
+// vars := mux.Vars(r)
+// id := vars["vnfInstanceId"]
+
+// var resource UpdateVnfRequest
+
+// if r.Body == nil {
+// http.Error(w, "Body empty", http.StatusBadRequest)
+// return
+// }
+
+// err := json.NewDecoder(r.Body).Decode(&resource)
+// if err != nil {
+// http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+// return
+// }
+
+// err = validateBody(resource)
+// if err != nil {
+// http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+// return
+// }
+
+// kubeData, err := utils.ReadCSARFromFileSystem(resource.CsarID)
+
+// if kubeData.Deployment == nil {
+// werr := pkgerrors.Wrap(err, "Update VNF deployment error")
+// http.Error(w, werr.Error(), http.StatusInternalServerError)
+// return
+// }
+// kubeData.Deployment.SetUID(types.UID(id))
+
+// if err != nil {
+// werr := pkgerrors.Wrap(err, "Update VNF deployment information error")
+// http.Error(w, werr.Error(), http.StatusInternalServerError)
+// return
+// }
+
+// // (TODO): Read kubeconfig for specific Cloud Region from local file system
+// // if present or download it from AAI
+// s, err := NewVNFInstanceService("../kubeconfig/config")
+// if err != nil {
+// http.Error(w, err.Error(), http.StatusInternalServerError)
+// return
+// }
+
+// err = s.Client.UpdateDeployment(kubeData.Deployment, resource.Namespace)
+// if err != nil {
+// werr := pkgerrors.Wrap(err, "Update VNF error")
+
+// http.Error(w, werr.Error(), http.StatusInternalServerError)
+// return
+// }
+
+// resp := UpdateVnfResponse{
+// DeploymentID: id,
+// }
+
+// w.Header().Set("Content-Type", "application/json")
+// w.WriteHeader(http.StatusCreated)
+
+// err = json.NewEncoder(w).Encode(resp)
+// if err != nil {
+// werr := pkgerrors.Wrap(err, "Parsing output of new VNF error")
+// http.Error(w, werr.Error(), http.StatusInternalServerError)
+// }
+// }
+
+// GetHandler retrieves information about a VNF instance by reading an individual VNF instance resource.
+func GetHandler(w http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+
+ cloudRegionID := vars["cloudRegionID"] // cloud1
+ namespace := vars["namespace"] // default
+ externalVNFID := vars["externalVNFID"] // uuid
+
+ // cloud1-default-uuid
+ internalVNFID := cloudRegionID + "-" + namespace + "-" + externalVNFID
+
+ // key: cloud1-default-uuid
+ // value: "{"deployment":<>,"service":<>}"
+ serializedResourceNameMap, found, err := db.DBconn.ReadEntry(internalVNFID)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ if found == false {
+ w.WriteHeader(http.StatusNotFound)
+ return
+ }
+
+ /*
+ {
+ "deployment": ["cloud1-default-uuid-sisedeploy1", "cloud1-default-uuid-sisedeploy2", ... ]
+ "service": ["cloud1-default-uuid-sisesvc1", "cloud1-default-uuid-sisesvc2", ... ]
+ },
+ */
+ deserializedResourceNameMap := make(map[string][]string)
+ err = json.Unmarshal([]byte(serializedResourceNameMap), &deserializedResourceNameMap)
+ if err != nil {
+ werr := pkgerrors.Wrap(err, "Get VNF error")
+ http.Error(w, werr.Error(), http.StatusInternalServerError)
+ return
+ }
+
+ resp := GetVnfResponse{
+ VNFID: externalVNFID,
+ CloudRegionID: cloudRegionID,
+ Namespace: namespace,
+ VNFComponents: deserializedResourceNameMap,
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ json.NewEncoder(w).Encode(resp)
+}
diff --git a/src/k8splugin/api/handler_test.go b/src/k8splugin/api/handler_test.go
new file mode 100644
index 00000000..df573d94
--- /dev/null
+++ b/src/k8splugin/api/handler_test.go
@@ -0,0 +1,316 @@
+/*
+Copyright 2018 Intel Corporation.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+import (
+ "bytes"
+ "encoding/json"
+ "k8s.io/client-go/kubernetes"
+ "net/http"
+ "net/http/httptest"
+ "reflect"
+ "testing"
+
+ "k8splugin/csar"
+ "k8splugin/db"
+)
+
+type mockDB struct {
+ db.DatabaseConnection
+}
+
+func (c *mockDB) InitializeDatabase() error {
+ return nil
+}
+
+func (c *mockDB) CheckDatabase() error {
+ return nil
+}
+
+func (c *mockDB) CreateEntry(key string, value string) error {
+ return nil
+}
+
+func (c *mockDB) ReadEntry(key string) (string, bool, error) {
+ str := "{\"deployment\":[\"cloud1-default-uuid-sisedeploy\"],\"service\":[\"cloud1-default-uuid-sisesvc\"]}"
+ return str, true, nil
+}
+
+func (c *mockDB) DeleteEntry(key string) error {
+ return nil
+}
+
+func (c *mockDB) ReadAll(key string) ([]string, error) {
+ returnVal := []string{"cloud1-default-uuid1", "cloud1-default-uuid2"}
+ return returnVal, nil
+}
+
+func executeRequest(req *http.Request) *httptest.ResponseRecorder {
+ router := NewRouter("")
+ recorder := httptest.NewRecorder()
+ router.ServeHTTP(recorder, req)
+
+ return recorder
+}
+
+func checkResponseCode(t *testing.T, expected, actual int) {
+ if expected != actual {
+ t.Errorf("Expected response code %d. Got %d\n", expected, actual)
+ }
+}
+
+func TestVNFInstanceCreation(t *testing.T) {
+ t.Run("Succesful create a VNF", func(t *testing.T) {
+ payload := []byte(`{
+ "cloud_region_id": "region1",
+ "namespace": "test",
+ "csar_id": "UUID-1",
+ "oof_parameters": [{
+ "key1": "value1",
+ "key2": "value2",
+ "key3": {}
+ }],
+ "network_parameters": {
+ "oam_ip_address": {
+ "connection_point": "string",
+ "ip_address": "string",
+ "workload_name": "string"
+ }
+ }
+ }`)
+
+ data := map[string][]string{
+ "deployment": []string{"cloud1-default-uuid-sisedeploy"},
+ "service": []string{"cloud1-default-uuid-sisesvc"},
+ }
+
+ expected := &CreateVnfResponse{
+ VNFID: "test_UUID",
+ CloudRegionID: "region1",
+ Namespace: "test",
+ VNFComponents: data,
+ }
+
+ var result CreateVnfResponse
+
+ req, _ := http.NewRequest("POST", "/v1/vnf_instances/", bytes.NewBuffer(payload))
+
+ GetVNFClient = func(configPath string) (kubernetes.Clientset, error) {
+ return kubernetes.Clientset{}, nil
+ }
+
+ csar.CreateVNF = func(id string, r string, n string, kubeclient *kubernetes.Clientset) (string, map[string][]string, error) {
+ return "externaluuid", data, nil
+ }
+
+ db.DBconn = &mockDB{}
+
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusCreated, response.Code)
+
+ err := json.NewDecoder(response.Body).Decode(&result)
+ if err != nil {
+ t.Fatalf("TestVNFInstanceCreation returned:\n result=%v\n expected=%v", err, expected.VNFComponents)
+ }
+ })
+ t.Run("Missing body failure", func(t *testing.T) {
+ req, _ := http.NewRequest("POST", "/v1/vnf_instances/", nil)
+ response := executeRequest(req)
+
+ checkResponseCode(t, http.StatusBadRequest, response.Code)
+ })
+ t.Run("Invalid JSON request format", func(t *testing.T) {
+ payload := []byte("invalid")
+ req, _ := http.NewRequest("POST", "/v1/vnf_instances/", bytes.NewBuffer(payload))
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusUnprocessableEntity, response.Code)
+ })
+ t.Run("Missing parameter failure", func(t *testing.T) {
+ payload := []byte(`{
+ "csar_id": "testID",
+ "oof_parameters": {
+ "key_values": {
+ "key1": "value1",
+ "key2": "value2"
+ }
+ },
+ "vnf_instance_name": "test",
+ "vnf_instance_description": "vRouter_test_description"
+ }`)
+ req, _ := http.NewRequest("POST", "/v1/vnf_instances/", bytes.NewBuffer(payload))
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusUnprocessableEntity, response.Code)
+ })
+}
+
+func TestVNFInstancesRetrieval(t *testing.T) {
+ t.Run("Succesful get a list of VNF", func(t *testing.T) {
+ expected := &ListVnfsResponse{
+ VNFs: []string{"uuid1", "uuid2"},
+ }
+ var result ListVnfsResponse
+
+ req, _ := http.NewRequest("GET", "/v1/vnf_instances/cloud1/default", nil)
+
+ db.DBconn = &mockDB{}
+
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusOK, response.Code)
+
+ err := json.NewDecoder(response.Body).Decode(&result)
+ if err != nil {
+ t.Fatalf("TestVNFInstancesRetrieval returned:\n result=%v\n expected=list", err)
+ }
+ if !reflect.DeepEqual(*expected, result) {
+ t.Fatalf("TestVNFInstancesRetrieval returned:\n result=%v\n expected=%v", result, *expected)
+ }
+ })
+ t.Run("Get empty list", func(t *testing.T) {
+ req, _ := http.NewRequest("GET", "/v1/vnf_instances/cloudregion1/testnamespace", nil)
+ db.DBconn = &mockDB{}
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusOK, response.Code)
+ })
+}
+
+func TestVNFInstanceDeletion(t *testing.T) {
+ t.Run("Succesful delete a VNF", func(t *testing.T) {
+ req, _ := http.NewRequest("DELETE", "/v1/vnf_instances/cloudregion1/testnamespace/1", nil)
+
+ GetVNFClient = func(configPath string) (kubernetes.Clientset, error) {
+ return kubernetes.Clientset{}, nil
+ }
+
+ csar.DestroyVNF = func(d map[string][]string, n string, kubeclient *kubernetes.Clientset) error {
+ return nil
+ }
+
+ db.DBconn = &mockDB{}
+
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusAccepted, response.Code)
+
+ if result := response.Body.String(); result != "" {
+ t.Fatalf("TestVNFInstanceDeletion returned:\n result=%v\n expected=%v", result, "")
+ }
+ })
+ // t.Run("Malformed delete request", func(t *testing.T) {
+ // req, _ := http.NewRequest("DELETE", "/v1/vnf_instances/foo", nil)
+ // response := executeRqequest(req)
+ // checkResponseCode(t, http.StatusBadRequest, response.Code)
+ // })
+}
+
+// TODO: Update this test when the UpdateVNF endpoint is fixed.
+/*
+func TestVNFInstanceUpdate(t *testing.T) {
+ t.Run("Succesful update a VNF", func(t *testing.T) {
+ payload := []byte(`{
+ "cloud_region_id": "region1",
+ "csar_id": "UUID-1",
+ "oof_parameters": [{
+ "key1": "value1",
+ "key2": "value2",
+ "key3": {}
+ }],
+ "network_parameters": {
+ "oam_ip_address": {
+ "connection_point": "string",
+ "ip_address": "string",
+ "workload_name": "string"
+ }
+ }
+ }`)
+ expected := &UpdateVnfResponse{
+ DeploymentID: "1",
+ }
+
+ var result UpdateVnfResponse
+
+ req, _ := http.NewRequest("PUT", "/v1/vnf_instances/1", bytes.NewBuffer(payload))
+
+ GetVNFClient = func(configPath string) (krd.VNFInstanceClientInterface, error) {
+ return &mockClient{
+ update: func() error {
+ return nil
+ },
+ }, nil
+ }
+ utils.ReadCSARFromFileSystem = func(csarID string) (*krd.KubernetesData, error) {
+ kubeData := &krd.KubernetesData{
+ Deployment: &appsV1.Deployment{},
+ Service: &coreV1.Service{},
+ }
+ return kubeData, nil
+ }
+
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusCreated, response.Code)
+
+ err := json.NewDecoder(response.Body).Decode(&result)
+ if err != nil {
+ t.Fatalf("TestVNFInstanceUpdate returned:\n result=%v\n expected=%v", err, expected.DeploymentID)
+ }
+
+ if result.DeploymentID != expected.DeploymentID {
+ t.Fatalf("TestVNFInstanceUpdate returned:\n result=%v\n expected=%v", result.DeploymentID, expected.DeploymentID)
+ }
+ })
+}
+*/
+
+func TestVNFInstanceRetrieval(t *testing.T) {
+ t.Run("Succesful get a VNF", func(t *testing.T) {
+
+ data := map[string][]string{
+ "deployment": []string{"cloud1-default-uuid-sisedeploy"},
+ "service": []string{"cloud1-default-uuid-sisesvc"},
+ }
+
+ expected := GetVnfResponse{
+ VNFID: "1",
+ CloudRegionID: "cloud1",
+ Namespace: "default",
+ VNFComponents: data,
+ }
+
+ req, _ := http.NewRequest("GET", "/v1/vnf_instances/cloud1/default/1", nil)
+
+ GetVNFClient = func(configPath string) (kubernetes.Clientset, error) {
+ return kubernetes.Clientset{}, nil
+ }
+
+ db.DBconn = &mockDB{}
+
+ response := executeRequest(req)
+ checkResponseCode(t, http.StatusOK, response.Code)
+
+ var result GetVnfResponse
+
+ err := json.NewDecoder(response.Body).Decode(&result)
+ if err != nil {
+ t.Fatalf("TestVNFInstanceRetrieval returned:\n result=%v\n expected=%v", err, expected)
+ }
+
+ if !reflect.DeepEqual(expected, result) {
+ t.Fatalf("TestVNFInstanceRetrieval returned:\n result=%v\n expected=%v", result, expected)
+ }
+ })
+ t.Run("VNF not found", func(t *testing.T) {
+ req, _ := http.NewRequest("GET", "/v1/vnf_instances/cloudregion1/testnamespace/1", nil)
+ response := executeRequest(req)
+
+ checkResponseCode(t, http.StatusOK, response.Code)
+ })
+}
diff --git a/src/k8splugin/api/model.go b/src/k8splugin/api/model.go
new file mode 100644
index 00000000..0e4863c4
--- /dev/null
+++ b/src/k8splugin/api/model.go
@@ -0,0 +1,76 @@
+/*
+Copyright 2018 Intel Corporation.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+// CreateVnfRequest contains the VNF creation request parameters
+type CreateVnfRequest struct {
+ CloudRegionID string `json:"cloud_region_id"`
+ CsarID string `json:"csar_id"`
+ OOFParams []map[string]interface{} `json:"oof_parameters"`
+ NetworkParams NetworkParameters `json:"network_parameters"`
+ Namespace string `json:"namespace"`
+ Name string `json:"vnf_instance_name"`
+ Description string `json:"vnf_instance_description"`
+}
+
+// CreateVnfResponse contains the VNF creation response parameters
+type CreateVnfResponse struct {
+ VNFID string `json:"vnf_id"`
+ CloudRegionID string `json:"cloud_region_id"`
+ Namespace string `json:"namespace"`
+ VNFComponents map[string][]string `json:"vnf_components"`
+}
+
+// ListVnfsResponse contains the list of VNFs response parameters
+type ListVnfsResponse struct {
+ VNFs []string `json:"vnf_id_list"`
+}
+
+// NetworkParameters contains the networking info required by the VNF instance
+type NetworkParameters struct {
+ OAMI OAMIPParams `json:"oam_ip_address"`
+ // Add other network parameters if necessary.
+}
+
+// OAMIPParams contains the management networking info required by the VNF instance
+type OAMIPParams struct {
+ ConnectionPoint string `json:"connection_point"`
+ IPAddress string `json:"ip_address"`
+ WorkLoadName string `json:"workload_name"`
+}
+
+// UpdateVnfRequest contains the VNF creation parameters
+type UpdateVnfRequest struct {
+ CloudRegionID string `json:"cloud_region_id"`
+ CsarID string `json:"csar_id"`
+ OOFParams []map[string]interface{} `json:"oof_parameters"`
+ NetworkParams NetworkParameters `json:"network_parameters"`
+ Namespace string `json:"namespace"`
+ Name string `json:"vnf_instance_name"`
+ Description string `json:"vnf_instance_description"`
+}
+
+// UpdateVnfResponse contains the VNF update response parameters
+type UpdateVnfResponse struct {
+ DeploymentID string `json:"vnf_id"`
+ Name string `json:"name"`
+}
+
+// GetVnfResponse returns information about a specific VNF instance
+type GetVnfResponse struct {
+ VNFID string `json:"vnf_id"`
+ CloudRegionID string `json:"cloud_region_id"`
+ Namespace string `json:"namespace"`
+ VNFComponents map[string][]string `json:"vnf_components"`
+}