Add Connectivity Info API

API to add connectivity information for
Cloud Regions to K8s Plugin
https://wiki.onap.org/display/DW/MultiCloud+K8s-Plugin-service+API%27s

Change-Id: I0a9166df9b076a7fdacf0b2f9e51a9cdebe4b621
Signed-off-by: rsood <ritu.sood@intel.com>
Issue-ID: MULTICLOUD-292
Signed-off-by: Kiran Kamineni <kiran.k.kamineni@intel.com>

3 files changed, 256 insertions, 0 deletions

diff --git a/src/k8splugin/api/api.go b/src/k8splugin/api/api.go
index 4bf8d6a6..282835a4 100644
--- a/src/k8splugin/api/api.go
+++ b/src/k8splugin/api/api.go
@@ -15,6 +15,7 @@ package api
 
 import (
 	"k8splugin/internal/app"
+	"k8splugin/internal/connection"
 	"k8splugin/internal/rb"
 
 	"github.com/gorilla/mux"
@@ -39,6 +40,7 @@ func NewRouter(defClient rb.DefinitionManager,
 	// (TODO): Fix update method
 	// instRouter.HandleFunc("/{vnfInstanceId}", UpdateHandler).Methods("PUT")
 
+	//Setup the broker handler here
 	brokerHandler := brokerInstanceHandler{client: instClient}
 	instRouter.HandleFunc("/{cloud-owner}/{cloud-region}/infra_workload", brokerHandler.createHandler).Methods("POST")
 	instRouter.HandleFunc("/{cloud-owner}/{cloud-region}/infra_workload/{instID}",
@@ -46,6 +48,13 @@ func NewRouter(defClient rb.DefinitionManager,
 	instRouter.HandleFunc("/{cloud-owner}/{cloud-region}/infra_workload/{instID}",
 		brokerHandler.deleteHandler).Methods("DELETE")
 
+	//Setup the connectivity api handler here
+	connectionClient := connection.NewConnectionClient()
+	connectionHandler := connection.ConnectionHandler{Client: connectionClient}
+	instRouter.HandleFunc("/connectivity-info", connectionHandler.CreateHandler).Methods("POST")
+	instRouter.HandleFunc("/connectivity-info/{connname}", connectionHandler.GetHandler).Methods("GET")
+	instRouter.HandleFunc("/connectivity-info/{connname}", connectionHandler.DeleteHandler).Methods("DELETE")
+
 	//Setup resource bundle definition routes
 	if defClient == nil {
 		defClient = rb.NewDefinitionClient()
diff --git a/src/k8splugin/internal/connection/connection.go b/src/k8splugin/internal/connection/connection.go
new file mode 100644
index 00000000..3faa74bd
--- /dev/null
+++ b/src/k8splugin/internal/connection/connection.go
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2018 Intel Corporation, Inc
+ *
+ * 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 connection
+
+import (
+	"encoding/json"
+	"k8splugin/internal/db"
+
+	pkgerrors "github.com/pkg/errors"
+)
+
+// Connection contains the parameters needed for Connection information for a Cloud region
+type Connection struct {
+	ConnectionName        string                 `json:"name"`
+	CloudOwner            string                 `json:"cloud-owner"`
+	CloudRegionID         string                 `json:"cloud-region-id"`
+	Kubeconfig            map[string]interface{} `json:"kubeconfig"`
+	OtherConnectivityList map[string]interface{} `json:"other-connectivity-list"`
+}
+
+// ConnectionKey is the key structure that is used in the database
+type ConnectionKey struct {
+	ConnectionName string `json:"connection-name"`
+}
+
+// We will use json marshalling to convert to string to
+// preserve the underlying structure.
+func (dk ConnectionKey) String() string {
+	out, err := json.Marshal(dk)
+	if err != nil {
+		return ""
+	}
+
+	return string(out)
+}
+
+//  ConnectionManager is an interface exposes the Connection functionality
+type ConnectionManager interface {
+	Create(c Connection) (Connection, error)
+	Get(name string) (Connection, error)
+	Delete(name string) error
+}
+
+//  ConnectionClient implements the  ConnectionManager
+// It will also be used to maintain some localized state
+type ConnectionClient struct {
+	storeName string
+	tagMeta   string
+}
+
+// New ConnectionClient returns an instance of the  ConnectionClient
+// which implements the  ConnectionManager
+func NewConnectionClient() *ConnectionClient {
+	return &ConnectionClient{
+		storeName: "connection",
+		tagMeta:   "metadata",
+	}
+}
+
+// Create an entry for the Connection resource in the database`
+func (v *ConnectionClient) Create(c Connection) (Connection, error) {
+
+	//Construct composite key consisting of name
+	key := ConnectionKey{ConnectionName: c.ConnectionName}
+
+	//Check if this Connection already exists
+	_, err := v.Get(c.ConnectionName)
+	if err == nil {
+		return Connection{}, pkgerrors.New("Connection already exists")
+	}
+
+	err = db.DBconn.Create(v.storeName, key, v.tagMeta, c)
+	if err != nil {
+		return Connection{}, pkgerrors.Wrap(err, "Creating DB Entry")
+	}
+
+	return c, nil
+}
+
+// Get returns Connection for corresponding to name
+func (v *ConnectionClient) Get(name string) (Connection, error) {
+
+	//Construct the composite key to select the entry
+	key := ConnectionKey{ConnectionName: name}
+	value, err := db.DBconn.Read(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return Connection{}, pkgerrors.Wrap(err, "Get Connection")
+	}
+
+	//value is a byte array
+	if value != nil {
+		c := Connection{}
+		err = db.DBconn.Unmarshal(value, &c)
+		if err != nil {
+			return Connection{}, pkgerrors.Wrap(err, "Unmarshaling Value")
+		}
+		return c, nil
+	}
+
+	return Connection{}, pkgerrors.New("Error getting Connection")
+}
+
+// Delete the  Connection from database
+func (v *ConnectionClient) Delete(name string) error {
+
+	//Construct the composite key to select the entry
+	key := ConnectionKey{ConnectionName: name}
+	err := db.DBconn.Delete(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete Connection")
+	}
+	return nil
+}
diff --git a/src/k8splugin/internal/connection/connectionhandler.go b/src/k8splugin/internal/connection/connectionhandler.go
new file mode 100644
index 00000000..ddb43f57
--- /dev/null
+++ b/src/k8splugin/internal/connection/connectionhandler.go
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2018 Intel Corporation, Inc
+ *
+ * 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 connection
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+// ConnectionHandler is used to store backend implementations objects
+// Also simplifies mocking for unit testing purposes
+type ConnectionHandler struct {
+	// Interface that implements Connectivity operations
+	// We will set this variable with a mock interface for testing
+	Client ConnectionManager
+}
+
+// createHandler handles creation of the connectivity entry in the database
+func (h ConnectionHandler) CreateHandler(w http.ResponseWriter, r *http.Request) {
+	var v Connection
+
+	err := json.NewDecoder(r.Body).Decode(&v)
+	switch {
+	case err == io.EOF:
+		http.Error(w, "Empty body", http.StatusBadRequest)
+		return
+	case err != nil:
+		http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+		return
+	}
+
+	// Name is required.
+	if v.ConnectionName == "" {
+		http.Error(w, "Missing name in POST request", http.StatusBadRequest)
+		return
+	}
+
+	// Cloudowner is required.
+	if v.CloudOwner == "" {
+		http.Error(w, "Missing cloudowner in POST request", http.StatusBadRequest)
+		return
+	}
+
+	// CloudRegionID is required.
+	if v.CloudRegionID == "" {
+		http.Error(w, "Missing CloudRegionID in POST request", http.StatusBadRequest)
+		return
+	}
+
+	// CloudRegionID is required.
+	if v.Kubeconfig == nil {
+		http.Error(w, "Missing Kubeconfig in POST request", http.StatusBadRequest)
+		return
+	}
+	ret, err := h.Client.Create(v)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	err = json.NewEncoder(w).Encode(ret)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// getHandler handles GET operations on a particular name
+// Returns a  Connectivity instance
+func (h ConnectionHandler) GetHandler(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["connname"]
+
+	ret, err := h.Client.Get(name)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	err = json.NewEncoder(w).Encode(ret)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// deleteHandler handles DELETE operations on a particular record
+func (h ConnectionHandler) DeleteHandler(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	name := vars["connname"]
+
+	err := h.Client.Delete(name)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}