From 8c3bfebaf6792bbf5fb9042532c918107633a957 Mon Sep 17 00:00:00 2001 From: rsood Date: Thu, 11 Apr 2019 13:09:00 +0000 Subject: 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 Issue-ID: MULTICLOUD-292 Signed-off-by: Kiran Kamineni --- src/k8splugin/api/api.go | 9 ++ src/k8splugin/internal/connection/connection.go | 127 +++++++++++++++++++++ .../internal/connection/connectionhandler.go | 120 +++++++++++++++++++ 3 files changed, 256 insertions(+) create mode 100644 src/k8splugin/internal/connection/connection.go create mode 100644 src/k8splugin/internal/connection/connectionhandler.go 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) +} -- cgit 1.2.3-korg