Add Distributed Cloud Manager

This handles RESTful API CRUD operations for logical clouds, CLuster,
User Permissions, Quota, and Key Value pairs.
See: https://wiki.onap.org/x/tAiVB

Issue-ID: MULTICLOUD-996
Signed-off-by: Enyinna Ochulor <enyinna.ochulor@intel.com>
Change-Id: I654a304cd682f762c02cfd92b4483d1edea63fca

6 files changed, 965 insertions, 0 deletions

diff --git a/src/dcm/api/api.go b/src/dcm/api/api.go
new file mode 100644
index 00000000..d050a5ba
--- /dev/null
+++ b/src/dcm/api/api.go
@@ -0,0 +1,148 @@
+/*
+Copyright 2020 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 (
+
+    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+
+    "github.com/gorilla/mux"
+)
+
+// NewRouter creates a router that registers the various urls that are
+// supported
+
+func NewRouter(
+    logicalCloudClient module.LogicalCloudManager,
+    clusterClient module.ClusterManager,
+    userPermissionClient module.UserPermissionManager,
+    quotaClient module.QuotaManager,
+    keyValueClient module.KeyValueManager) *mux.Router {
+
+    router := mux.NewRouter()
+
+    // Set up Logical Cloud handler routes
+    if logicalCloudClient == nil {
+        logicalCloudClient = module.NewLogicalCloudClient()
+    }
+    logicalCloudHandler := logicalCloudHandler{client: logicalCloudClient}
+    lcRouter := router.PathPrefix("/v2/projects/{project-name}").Subrouter()
+    lcRouter.HandleFunc(
+        "/logical-clouds",
+        logicalCloudHandler.createHandler).Methods("POST")
+    lcRouter.HandleFunc(
+        "/logical-clouds",
+        logicalCloudHandler.getHandler).Methods("GET")
+    lcRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}",
+        logicalCloudHandler.getHandler).Methods("GET")
+    lcRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}",
+        logicalCloudHandler.deleteHandler).Methods("DELETE")
+    lcRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}",
+        logicalCloudHandler.updateHandler).Methods("PUT")
+    lcRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/apply",
+        logicalCloudHandler.applyHandler).Methods("POST")
+    // To Do
+    // get kubeconfig
+    /*lcRouter.HandleFunc(
+         "/logical-clouds/{name}/kubeconfig?cluster-reference={cluster}",
+         logicalCloudHandler.getConfigHandler).Methods("GET")
+    //get status
+    lcRouter.HandleFunc(
+        "/logical-clouds/{name}/cluster-references/",
+        logicalCloudHandler.associateHandler).Methods("GET")*/
+
+    // Set up Cluster API
+    if clusterClient == nil {
+        clusterClient = module.NewClusterClient()
+    }
+    clusterHandler := clusterHandler{client: clusterClient}
+    clusterRouter := router.PathPrefix("/v2/projects/{project-name}").Subrouter()
+    clusterRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-references",
+        clusterHandler.createHandler).Methods("POST")
+    clusterRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-references",
+        clusterHandler.getHandler).Methods("GET")
+    clusterRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-references/{cluster-reference}",
+        clusterHandler.getHandler).Methods("GET")
+    clusterRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-references/{cluster-reference}",
+        clusterHandler.updateHandler).Methods("PUT")
+    clusterRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-references/{cluster-reference}",
+        clusterHandler.deleteHandler).Methods("DELETE")
+
+    // Set up User Permission API
+    if userPermissionClient == nil {
+        userPermissionClient = module.NewUserPermissionClient()
+    }
+    userPermissionHandler := userPermissionHandler{client: userPermissionClient}
+    upRouter := router.PathPrefix("/v2/projects/{project-name}").Subrouter()
+    upRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/user-permissions",
+        userPermissionHandler.createHandler).Methods("POST")
+    upRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/user-permissions/{permission-name}",
+        userPermissionHandler.getHandler).Methods("GET")
+    upRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/user-permissions/{permission-name}",
+        userPermissionHandler.updateHandler).Methods("PUT")
+    upRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/user-permissions/{permission-name}",
+        userPermissionHandler.deleteHandler).Methods("DELETE")
+
+    // Set up Quota API
+    if quotaClient == nil {
+        quotaClient = module.NewQuotaClient()
+    }
+    quotaHandler := quotaHandler{client: quotaClient}
+    quotaRouter := router.PathPrefix("/v2/projects/{project-name}").Subrouter()
+    quotaRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-quotas",
+        quotaHandler.createHandler).Methods("POST")
+    quotaRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-quotas/{quota-name}",
+        quotaHandler.getHandler).Methods("GET")
+    quotaRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-quotas/{quota-name}",
+        quotaHandler.updateHandler).Methods("PUT")
+    quotaRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/cluster-quotas/{quota-name}",
+        quotaHandler.deleteHandler).Methods("DELETE")
+
+    // Set up Key Value API
+    if keyValueClient == nil {
+        keyValueClient = module.NewKeyValueClient()
+    }
+    keyValueHandler := keyValueHandler{client: keyValueClient}
+    kvRouter := router.PathPrefix("/v2/projects/{project-name}").Subrouter()
+    kvRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/kv-pairs",
+        keyValueHandler.createHandler).Methods("POST")
+    kvRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/kv-pairs/{kv-pair-name}",
+        keyValueHandler.getHandler).Methods("GET")
+    kvRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/kv-pairs/{kv-pair-name}",
+        keyValueHandler.updateHandler).Methods("PUT")
+    kvRouter.HandleFunc(
+        "/logical-clouds/{logical-cloud-name}/kv-pairs/{kv-pair-name}",
+        keyValueHandler.deleteHandler).Methods("DELETE")
+        return router
+}
diff --git a/src/dcm/api/clusterHandler.go b/src/dcm/api/clusterHandler.go
new file mode 100644
index 00000000..3e483f06
--- /dev/null
+++ b/src/dcm/api/clusterHandler.go
@@ -0,0 +1,162 @@
+/*
+* Copyright 2020 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 api
+
+import (
+    "encoding/json"
+    "net/http"
+    "io"
+    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+
+    "github.com/gorilla/mux"
+)
+
+
+// clusterHandler is used to store backend implementations objects
+type clusterHandler struct {
+    client module.ClusterManager
+}
+
+// CreateHandler handles creation of the cluster reference entry in the database
+
+func (h clusterHandler) createHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    var v module.Cluster
+
+    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
+    }
+
+    // Cluster Reference Name is required.
+    if v.MetaData.ClusterReference == "" {
+        http.Error(w, "Missing name in POST request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.CreateCluster(project, logicalCloud, 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 handle GET operations on a particular name
+// Returns a Cluster Reference
+func (h clusterHandler) getHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["cluster-reference"]
+    var ret interface{}
+    var err error
+
+    if len(name) == 0 {
+        ret, err = h.client.GetAllClusters(project, logicalCloud)
+        if err != nil {
+            http.Error(w, err.Error(), http.StatusInternalServerError)
+            return
+        }
+    } else {
+        ret, err = h.client.GetCluster(project, logicalCloud, 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
+    }
+}
+
+// UpdateHandler handles Update operations on a particular cluster reference
+func (h clusterHandler) updateHandler(w http.ResponseWriter, r *http.Request) {
+    var v module.Cluster
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["cluster-reference"]
+
+    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.MetaData.ClusterReference == "" {
+        http.Error(w, "Missing name in PUT request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.UpdateCluster(project, logicalCloud, name, 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
+    }
+}
+
+//deleteHandler handles DELETE operations on a particular record
+func (h clusterHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["cluster-reference"]
+
+    err := h.client.DeleteCluster(project, logicalCloud, name)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    w.WriteHeader(http.StatusNoContent)
+}
diff --git a/src/dcm/api/keyValueHandler.go b/src/dcm/api/keyValueHandler.go
new file mode 100644
index 00000000..57df6556
--- /dev/null
+++ b/src/dcm/api/keyValueHandler.go
@@ -0,0 +1,161 @@
+/*
+* Copyright 2020 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 api
+
+import (
+    "encoding/json"
+    "net/http"
+    "io"
+    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+    "github.com/gorilla/mux"
+)
+
+
+// keyValueHandler is used to store backend implementations objects
+type keyValueHandler struct {
+    client module.KeyValueManager
+}
+
+// CreateHandler handles creation of the key value entry in the database
+
+func (h keyValueHandler) createHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    var v module.KeyValue
+
+    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
+    }
+
+    // Key Value Name is required.
+    if v.MetaData.KeyValueName == "" {
+        http.Error(w, "Missing name in POST request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.CreateKVPair(project, logicalCloud, 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 handle GET operations on a particular name
+// Returns a Key Value
+func (h keyValueHandler) getHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["kv-pair-name"]
+    var ret interface{}
+    var err error
+
+    if len(name) == 0 {
+        ret, err = h.client.GetAllKVPairs(project, logicalCloud)
+        if err != nil {
+            http.Error(w, err.Error(), http.StatusInternalServerError)
+            return
+        }
+    } else {
+        ret, err = h.client.GetKVPair(project, logicalCloud, 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
+    }
+}
+
+// UpdateHandler handles Update operations on a particular Key Value
+func (h keyValueHandler) updateHandler(w http.ResponseWriter, r *http.Request) {
+    var v module.KeyValue
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["kv-pair-name"]
+
+    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.MetaData.KeyValueName == "" {
+        http.Error(w, "Missing name in PUT request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.UpdateKVPair(project, logicalCloud, name, 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
+    }
+}
+
+//deleteHandler handles DELETE operations on a particular record
+func (h keyValueHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["kv-pair-name"]
+
+        err := h.client.DeleteKVPair(project, logicalCloud, name)
+        if err != nil {
+                http.Error(w, err.Error(), http.StatusInternalServerError)
+                return
+        }
+
+        w.WriteHeader(http.StatusNoContent)
+}
diff --git a/src/dcm/api/logicalCloudHandler.go b/src/dcm/api/logicalCloudHandler.go
new file mode 100644
index 00000000..7df0ae2e
--- /dev/null
+++ b/src/dcm/api/logicalCloudHandler.go
@@ -0,0 +1,170 @@
+/*
+* Copyright 2020 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 api
+
+import (
+    "encoding/json"
+    "net/http"
+    "io"
+    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+    "github.com/gorilla/mux"
+)
+
+
+// logicalCloudHandler is used to store backend implementations objects
+type logicalCloudHandler struct {
+    client module.LogicalCloudManager
+}
+
+// CreateHandler handles creation of the logical cloud entry in the database
+
+func (h logicalCloudHandler) createHandler(w http.ResponseWriter, r *http.Request) {
+
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    var v module.LogicalCloud
+
+    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
+    }
+
+    // Logical Cloud Name is required.
+    if v.MetaData.LogicalCloudName == "" {
+        http.Error(w, "Missing name in POST request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.Create(project, 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 handle GET operations on a particular name
+// Returns a Logical Cloud
+func (h logicalCloudHandler) getHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    name := vars["logical-cloud-name"]
+    var ret interface{}
+    var err error
+
+    if len(name) == 0 {
+        ret, err = h.client.GetAll(project)
+        if err != nil {
+            http.Error(w, err.Error(), http.StatusInternalServerError)
+            return
+        }
+    } else {
+        ret, err = h.client.Get(project, 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
+    }
+}
+
+// UpdateHandler handles Update operations on a particular logical cloud
+func (h logicalCloudHandler) updateHandler(w http.ResponseWriter, r *http.Request) {
+    var v module.LogicalCloud
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    name := vars["logical-cloud-name"]
+
+    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
+    }
+
+    if v.MetaData.LogicalCloudName == "" {
+        http.Error(w, "Missing name in PUT request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.Update(project, name, 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
+    }
+}
+
+func (h logicalCloudHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    name := vars["logical-cloud-name"]
+
+    err := h.client.Delete(project, name)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    w.WriteHeader(http.StatusNoContent)
+}
+
+func (h logicalCloudHandler) applyHandler(w http.ResponseWriter, r *http.Request) {
+    /*vars := mux.Vars(r)
+    project := vars["project-name"]
+    name := vars["logical-cloud-name"]*/
+    /*ret, err := h.client.Get(project, name)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }*/
+
+    // Do Some Work
+    // someApplyFunction(project, name, ret)
+}
diff --git a/src/dcm/api/quotaHandler.go b/src/dcm/api/quotaHandler.go
new file mode 100644
index 00000000..bca5206a
--- /dev/null
+++ b/src/dcm/api/quotaHandler.go
@@ -0,0 +1,162 @@
+/*
+* Copyright 2020 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 api
+
+import (
+    "encoding/json"
+    "net/http"
+    "io"
+    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+
+    "github.com/gorilla/mux"
+)
+
+
+// quotaHandler is used to store backend implementations objects
+type quotaHandler struct {
+    client module.QuotaManager
+}
+
+// CreateHandler handles creation of the quota entry in the database
+
+func (h quotaHandler) createHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    var v module.Quota
+
+    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
+    }
+
+    // Quota Name is required.
+    if v.MetaData.QuotaName == "" {
+        http.Error(w, "Missing name in POST request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.CreateQuota(project, logicalCloud, 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 handle GET operations on a particular name
+// Returns a quota
+func (h quotaHandler) getHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["quota-name"]
+    var ret interface{}
+    var err error
+
+    if len(name) == 0 {
+        ret, err = h.client.GetAllQuotas(project, logicalCloud)
+        if err != nil {
+            http.Error(w, err.Error(), http.StatusInternalServerError)
+            return
+        }
+    } else {
+        ret, err = h.client.GetQuota(project, logicalCloud, 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
+    }
+}
+
+// UpdateHandler handles Update operations on a particular quota
+func (h quotaHandler) updateHandler(w http.ResponseWriter, r *http.Request) {
+    var v module.Quota
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["quota-name"]
+
+    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.MetaData.QuotaName == "" {
+        http.Error(w, "Missing name in PUT request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.UpdateQuota(project, logicalCloud, name, 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
+    }
+}
+
+//deleteHandler handles DELETE operations on a particular record
+func (h quotaHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["quota-name"]
+
+    err := h.client.DeleteQuota(project, logicalCloud, name)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    w.WriteHeader(http.StatusNoContent)
+}
diff --git a/src/dcm/api/userPermissionsHandler.go b/src/dcm/api/userPermissionsHandler.go
new file mode 100644
index 00000000..48ab3d8e
--- /dev/null
+++ b/src/dcm/api/userPermissionsHandler.go
@@ -0,0 +1,162 @@
+/*
+* Copyright 2020 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 api
+
+import (
+    "encoding/json"
+    "net/http"
+    "io"
+    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+    "github.com/gorilla/mux"
+)
+
+
+// userPermissionHandler is used to store backend implementations objects
+type userPermissionHandler struct {
+    client module.UserPermissionManager
+}
+
+// CreateHandler handles creation of the user permission entry in the database
+
+func (h userPermissionHandler) createHandler(w http.ResponseWriter, r *http.Request) {
+
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    var v module.UserPermission
+
+    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
+    }
+
+    // User-Permission Name is required.
+    if v.UserPermissionName == "" {
+        http.Error(w, "Missing name in POST request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.CreateUserPerm(project, logicalCloud, 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 handle GET operations on a particular name
+// Returns a User Permission
+func (h userPermissionHandler) getHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["permission-name"]
+    var ret interface{}
+    var err error
+
+    if len(name) == 0 {
+        ret, err = h.client.GetAllUserPerms(project, logicalCloud)
+        if err != nil {
+            http.Error(w, err.Error(), http.StatusInternalServerError)
+            return
+        }
+    } else {
+        ret, err = h.client.GetAllUserPerms(project, logicalCloud)
+        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
+    }
+}
+
+// UpdateHandler handles Update operations on a particular user permission
+func (h userPermissionHandler) updateHandler(w http.ResponseWriter, r *http.Request) {
+    var v module.UserPermission
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["permission-name"]
+
+    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.UserPermissionName == "" {
+        http.Error(w, "Missing name in PUT request", http.StatusBadRequest)
+        return
+    }
+
+    ret, err := h.client.UpdateUserPerm(project, logicalCloud, name, 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
+    }
+}
+
+//deleteHandler handles DELETE operations on a particular record
+func (h userPermissionHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
+    vars := mux.Vars(r)
+    project := vars["project-name"]
+    logicalCloud := vars["logical-cloud-name"]
+    name := vars["permission-name"]
+
+    err := h.client.DeleteUserPerm(project, logicalCloud, name)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    w.WriteHeader(http.StatusNoContent)
+}