20 files changed, 2619 insertions, 2613 deletions

diff --git a/src/dcm/api/api.go b/src/dcm/api/api.go
index 87ad77b5..de1d5c97 100644
--- a/src/dcm/api/api.go
+++ b/src/dcm/api/api.go
@@ -14,143 +14,142 @@ limitations under the License.
 package api
 
 import (
+	"github.com/onap/multicloud-k8s/src/dcm/pkg/module"
 
-    "github.com/onap/multicloud-k8s/src/dcm/pkg/module"
-
-    "github.com/gorilla/mux"
+	"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()
-    }
-
-    if clusterClient == nil {
-        clusterClient = module.NewClusterClient()
-    }
-
-    if quotaClient == nil {
-        quotaClient = module.NewQuotaClient()
-    }
-
-    logicalCloudHandler := logicalCloudHandler{client: logicalCloudClient,
-        clusterClient: clusterClient,
-        quotaClient: quotaClient,
-    }
-    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
-    
-    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
-    
-    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
+	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()
+	}
+
+	if clusterClient == nil {
+		clusterClient = module.NewClusterClient()
+	}
+
+	if quotaClient == nil {
+		quotaClient = module.NewQuotaClient()
+	}
+
+	logicalCloudHandler := logicalCloudHandler{client: logicalCloudClient,
+		clusterClient: clusterClient,
+		quotaClient:   quotaClient,
+	}
+	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
+
+	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
+
+	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
index 3e483f06..f4a3abdc 100644
--- a/src/dcm/api/clusterHandler.go
+++ b/src/dcm/api/clusterHandler.go
@@ -14,149 +14,149 @@
 * 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"
+	"encoding/json"
+	"io"
+	"net/http"
 
-    "github.com/gorilla/mux"
-)
+	"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
+	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
-    }
+	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
-    }
+	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
-    }
+	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)
+	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
index 57df6556..c67504f2 100644
--- a/src/dcm/api/keyValueHandler.go
+++ b/src/dcm/api/keyValueHandler.go
@@ -14,148 +14,148 @@
 * 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"
-)
+	"encoding/json"
+	"io"
+	"net/http"
 
+	"github.com/gorilla/mux"
+	"github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+)
 
 // keyValueHandler is used to store backend implementations objects
 type keyValueHandler struct {
-    client module.KeyValueManager
+	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
-    }
+	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
-    }
+	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
-    }
+	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)
+	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
index d8fcf268..d9a3e5f5 100644
--- a/src/dcm/api/logicalCloudHandler.go
+++ b/src/dcm/api/logicalCloudHandler.go
@@ -14,182 +14,181 @@
 * 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"
-)
+	"encoding/json"
+	"io"
+	"net/http"
 
+	"github.com/gorilla/mux"
+	"github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+)
 
 // logicalCloudHandler is used to store backend implementations objects
 type logicalCloudHandler struct {
-    client module.LogicalCloudManager
-    clusterClient module.ClusterManager
-    quotaClient module.QuotaManager
+	client        module.LogicalCloudManager
+	clusterClient module.ClusterManager
+	quotaClient   module.QuotaManager
 }
 
 // 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
-    }
+	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
-    }
+	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
-    }
+	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"]
+	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
-    }
+	err := h.client.Delete(project, name)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 
-    w.WriteHeader(http.StatusNoContent)
+	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"]
-
-    // Get logical cloud
-    lc, err := h.client.Get(project, name)
-    if err != nil {
-        http.Error(w, err.Error(), http.StatusInternalServerError)
-        return
-    }
-
-    // Get Clusters
-    clusters, err := h.clusterClient.GetAllClusters(project, name)
-
-    if err != nil {
-        http.Error(w, err.Error(), http.StatusInternalServerError)
-        return
-    }
-
-
-    //Get Quotas
-    quotas, err := h.quotaClient.GetAllQuotas(project, name)
-    if err != nil {
-        http.Error(w, err.Error(), http.StatusInternalServerError)
-        return
-    }
-
-    err = module.CreateEtcdContext(lc, clusters, quotas)
-    if err != nil {
-        http.Error(w, err.Error(), http.StatusInternalServerError)
-        return
-    }
-
-    return
+	vars := mux.Vars(r)
+	project := vars["project-name"]
+	name := vars["logical-cloud-name"]
+
+	// Get logical cloud
+	lc, err := h.client.Get(project, name)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Get Clusters
+	clusters, err := h.clusterClient.GetAllClusters(project, name)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	//Get Quotas
+	quotas, err := h.quotaClient.GetAllQuotas(project, name)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	err = module.CreateEtcdContext(lc, clusters, quotas)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	return
 }
diff --git a/src/dcm/api/quotaHandler.go b/src/dcm/api/quotaHandler.go
index bca5206a..deb18e18 100644
--- a/src/dcm/api/quotaHandler.go
+++ b/src/dcm/api/quotaHandler.go
@@ -14,149 +14,149 @@
 * 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"
+	"encoding/json"
+	"io"
+	"net/http"
 
-    "github.com/gorilla/mux"
-)
+	"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
+	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
-    }
+	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
-    }
+	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
-    }
+	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)
+	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
index 48ab3d8e..156c390f 100644
--- a/src/dcm/api/userPermissionsHandler.go
+++ b/src/dcm/api/userPermissionsHandler.go
@@ -14,149 +14,149 @@
 * 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"
-)
+	"encoding/json"
+	"io"
+	"net/http"
 
+	"github.com/gorilla/mux"
+	"github.com/onap/multicloud-k8s/src/dcm/pkg/module"
+)
 
 // userPermissionHandler is used to store backend implementations objects
 type userPermissionHandler struct {
-    client module.UserPermissionManager
+	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
-    }
+	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
-    }
+	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
-    }
+	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)
+	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)
 }
diff --git a/src/dcm/cmd/main.go b/src/dcm/cmd/main.go
index 77d5348b..c08330fa 100644
--- a/src/dcm/cmd/main.go
+++ b/src/dcm/cmd/main.go
@@ -14,65 +14,65 @@ limitations under the License.
 package main
 
 import (
-        "context"
-        "log"
-        "math/rand"
-        "net/http"
-        "os"
-        "os/signal"
-        "time"
+	"context"
+	"log"
+	"math/rand"
+	"net/http"
+	"os"
+	"os/signal"
+	"time"
 
-        "github.com/onap/multicloud-k8s/src/dcm/api"
-        "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/auth"
-        "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/config"
-        "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"
-        contextDb "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/contextdb"
-        "github.com/gorilla/handlers"
+	"github.com/gorilla/handlers"
+	"github.com/onap/multicloud-k8s/src/dcm/api"
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/auth"
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/config"
+	contextDb "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/contextdb"
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"
 )
 
 func main() {
 
-        rand.Seed(time.Now().UnixNano())
+	rand.Seed(time.Now().UnixNano())
 
-        err := db.InitializeDatabaseConnection("mco")
-        if err != nil {
-                log.Println("Unable to initialize database connection...")
-                log.Println(err)
-                log.Fatalln("Exiting...")
-        }
+	err := db.InitializeDatabaseConnection("mco")
+	if err != nil {
+		log.Println("Unable to initialize database connection...")
+		log.Println(err)
+		log.Fatalln("Exiting...")
+	}
 
-        err = contextDb.InitializeContextDatabase()
-        if err != nil {
-                log.Println("Unable to initialize database connection...")
-                log.Println(err)
-                log.Fatalln("Exiting...")
-        }
+	err = contextDb.InitializeContextDatabase()
+	if err != nil {
+		log.Println("Unable to initialize database connection...")
+		log.Println(err)
+		log.Fatalln("Exiting...")
+	}
 
-        httpRouter := api.NewRouter(nil, nil, nil, nil, nil)
-        loggedRouter := handlers.LoggingHandler(os.Stdout, httpRouter)
-        log.Println("Starting Distributed Cloud Manager API")
+	httpRouter := api.NewRouter(nil, nil, nil, nil, nil)
+	loggedRouter := handlers.LoggingHandler(os.Stdout, httpRouter)
+	log.Println("Starting Distributed Cloud Manager API")
 
-        httpServer := &http.Server{
-                Handler:    loggedRouter,
-                Addr:       ":" + config.GetConfiguration().ServicePort,
-        }
+	httpServer := &http.Server{
+		Handler: loggedRouter,
+		Addr:    ":" + config.GetConfiguration().ServicePort,
+	}
 
-        connectionsClose := make(chan struct{})
-        go func() {
-                c := make(chan os.Signal, 1)
-                signal.Notify(c, os.Interrupt)
-                <-c
-                httpServer.Shutdown(context.Background())
-                close(connectionsClose)
-        }()
+	connectionsClose := make(chan struct{})
+	go func() {
+		c := make(chan os.Signal, 1)
+		signal.Notify(c, os.Interrupt)
+		<-c
+		httpServer.Shutdown(context.Background())
+		close(connectionsClose)
+	}()
 
-        tlsConfig, err := auth.GetTLSConfig("ca.cert", "server.cert", "server.key")
-        if err != nil {
-            log.Println("Error Getting TLS Configuration. Starting without TLS...")
-            log.Fatal(httpServer.ListenAndServe())
-        } else {
-                httpServer.TLSConfig = tlsConfig
+	tlsConfig, err := auth.GetTLSConfig("ca.cert", "server.cert", "server.key")
+	if err != nil {
+		log.Println("Error Getting TLS Configuration. Starting without TLS...")
+		log.Fatal(httpServer.ListenAndServe())
+	} else {
+		httpServer.TLSConfig = tlsConfig
 
-                err = httpServer.ListenAndServeTLS("", "")
-          }
+		err = httpServer.ListenAndServeTLS("", "")
+	}
 }
diff --git a/src/dcm/pkg/module/apply.go b/src/dcm/pkg/module/apply.go
index c918f749..dbcbf8ac 100644
--- a/src/dcm/pkg/module/apply.go
+++ b/src/dcm/pkg/module/apply.go
@@ -1,451 +1,424 @@
-/*

-* 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 module

-

-import (

-    "strings"

-    "fmt"

-    "crypto/rsa"

-    "crypto/rand"

-    "crypto/x509"

-    "crypto/x509/pkix"

-    "encoding/json"

-    "encoding/pem"

-    "encoding/base64"

-    "github.com/onap/multicloud-k8s/src/orchestrator/pkg/appcontext"

-    log "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/logutils"

-    "gopkg.in/yaml.v2"

-    pkgerrors "github.com/pkg/errors"

-

-)

-

-type Resource struct {

-    ApiVersion      string               `yaml:"apiVersion"`

-    Kind            string               `yaml:"kind"`

-    MetaData        MetaDatas            `yaml:"metadata"`

-    Specification   Specs                 `yaml:"spec,omitempty"`

-    Rules           []RoleRules          `yaml:"rules,omitempty"`

-    Subjects        []RoleSubjects       `yaml:"subjects,omitempty"`

-    RoleRefs        RoleRef              `yaml:"roleRef,omitempty"`

-}

-

-type MetaDatas struct {

-    Name           string                `yaml:"name"`

-    Namespace      string                `yaml:"namespace,omitempty"`

-}

-

-type Specs struct {

-    Request        string                `yaml:"request,omitempty"`

-    Usages         []string              `yaml:"usages,omitempty"`

-    //Hard           logicalcloud.QSpec    `yaml:"hard,omitempty"`

-    Hard           QSpec    `yaml:"hard,omitempty"`

-}

-

-type RoleRules struct {

-    ApiGroups      []string              `yaml:"apiGroups"`

-    Resources      []string              `yaml:"resources"`

-    Verbs          []string              `yaml:"verbs"`

-}

-

-type RoleSubjects struct {

-    Kind           string                `yaml:"kind"`

-    Name           string                `yaml:"name"`

-    ApiGroup       string                `yaml:"apiGroup"`

-}

-

-type RoleRef struct {

-    Kind           string                `yaml:"kind"`

-    Name           string                `yaml:"name"`

-    ApiGroup       string                `yaml:"apiGroup"`

-}

-

-

-func createNamespace(logicalcloud LogicalCloud) (string, error) {

-

-    namespace := Resource{

-        ApiVersion: "v1",

-        Kind:       "Namespace",

-        MetaData:  MetaDatas{

-            Name:  logicalcloud.Specification.NameSpace,

-        },

-    }

-

-    nsData, err := yaml.Marshal(&namespace)

-    if err != nil {

-        return "", err

-    }

-

-

-    return string(nsData), nil

-}

-

-func createRole(logicalcloud LogicalCloud) (string, error) {

-

-    userPermissions := logicalcloud.Specification.User.UserPermissions[0]

-    

-    role := Resource{

-        ApiVersion: "rbac.authorization.k8s.io/v1beta1",

-        Kind: "Role",

-        MetaData: MetaDatas{

-            Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-role"}, ""),

-            Namespace:  logicalcloud.Specification.NameSpace,

-        },

-        Rules: []RoleRules{ RoleRules{

-            ApiGroups: userPermissions.APIGroups,

-            Resources: userPermissions.Resources,

-            Verbs: userPermissions.Verbs,

-            },

-        },

-

-    }

-

-    roleData, err := yaml.Marshal(&role)

-    if err != nil {

-        return "", err

-    }

-

-    return string(roleData), nil

-}

-

-func createRoleBinding(logicalcloud LogicalCloud) (string, error) {

-

-    roleBinding := Resource{

-        ApiVersion: "rbac.authorization.k8s.io/v1beta1",

-        Kind: "RoleBinding",

-        MetaData: MetaDatas{

-            Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-roleBinding"}, ""),

-            Namespace:  logicalcloud.Specification.NameSpace,

-        },

-        Subjects: []RoleSubjects{ RoleSubjects{

-            Kind: "User",

-            Name: logicalcloud.Specification.User.UserName,

-            ApiGroup: "",

-          },

-        },

-

-        RoleRefs: RoleRef{

-            Kind: "Role",

-            Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-role"}, ""),

-            ApiGroup: "",

-        },

-    }

-

-    rBData, err := yaml.Marshal(&roleBinding)

-    if err != nil {

-        return "", err

-    }

-

-

-    return string(rBData), nil

-

-}

-

-func createQuota(quota []Quota, namespace string) (string, error) {

-    lcQuota := quota[0]

-

-    q := Resource{

-        ApiVersion: "v1",

-        Kind:       "ResourceQuota",

-        MetaData:  MetaDatas{

-            Name:  lcQuota.MetaData.QuotaName,

-            Namespace: namespace,

-        },

-        Specification:  Specs{

-            Hard:  lcQuota.Specification,

-        },

-    }

-

-    qData, err := yaml.Marshal(&q)

-    if err != nil {

-        return "", err

-    }

-

-

-

-    return string(qData), nil

-

-}

-

-func createUserCSR(logicalcloud LogicalCloud) (string, error) {

-    KEYSIZE := 4096

-    userName := logicalcloud.Specification.User.UserName

-

-    key, err := rsa.GenerateKey(rand.Reader, KEYSIZE)

-    if err != nil {

-        return "", err

-    }

-

-    csrTemplate := x509.CertificateRequest{Subject: pkix.Name{CommonName: userName,},

-    }

-

-    csrCert, err := x509.CreateCertificateRequest(rand.Reader, &csrTemplate, key)

-    if err != nil {

-        return "", err

-    }

-

-    //Encode csr

-    csr := pem.EncodeToMemory(&pem.Block{

-        Type: "CERTIFICATE REQUEST",

-        Bytes: csrCert,

-    })

-

-    csrObj :=  Resource{

-        ApiVersion: "certificates.k8s.io/v1beta1",

-        Kind:       "CertificateSigningRequest",

-        MetaData:  MetaDatas{

-            Name:  strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-user-csr"}, ""),

-            Namespace: logicalcloud.Specification.NameSpace,

-        },

-        Specification:  Specs{

-            Request: base64.StdEncoding.EncodeToString(csr),

-            Usages: []string{"digital signature", "key encipherment"},

-        },

-    }

-

-    csrData, err := yaml.Marshal(&csrObj)

-    if err != nil {

-        return "", err

-    }

-

-

-    return string(csrData), nil

-

-

-}

-

-// TODO:

-// Install istio

-// Store user key for user creation

-// Code to run kubectl commands for user

-// kubectl certificate approve lc1-user-cert

-// kubectl get csr lc1-user-cert -o jsonpath='{.status.certificate}' | base64 --decode > user.crt

-// kubectl config set-credentials user --client-certificate=<user.crt>  --client-key=<user.key>

-// kubectl config set-context user-context --cluster=cluster-name --namespace=lc1 --user=user

-

-

-func CreateEtcdContext(logicalcloud LogicalCloud, clusterList []Cluster,

-     quotaList []Quota  ) error {

-

-    APP := "logical-cloud"

-    logicalCloudName := logicalcloud.MetaData.LogicalCloudName

-

-

-    //Resource Names

-    namespaceName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+namespace"}, "")

-    roleName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+role"}, "")

-    roleBindingName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+roleBinding"}, "")

-    quotaName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+quota"}, "")

-    csrName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+CertificateSigningRequest"}, "")

-

-    // Get resources to be added

-    namespace, err := createNamespace(logicalcloud)

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error Creating Namespace YAML for logical cloud")

-    }

-

-    role, err := createRole(logicalcloud)

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error Creating Role YAML for logical cloud")

-    }

-

-    roleBinding, err := createRoleBinding(logicalcloud)

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error Creating RoleBinding YAML for logical cloud")

-    }

-

-    quota, err := createQuota(quotaList, logicalcloud.Specification.NameSpace)

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error Creating Quota YAML for logical cloud")

-    }

-

-    csr, err := createUserCSR(logicalcloud)

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error Creating User CSR for logical cloud")

-    }

-

-

-    context := appcontext.AppContext{}

-    ctxVal, err := context.InitAppContext()

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error creating AppContext")

-    }

-

-    fmt.Printf("%v\n", ctxVal)

-

-    handle, err := context.CreateCompositeApp()

-    if err != nil {

-        return pkgerrors.Wrap(err, "Error creating AppContext CompositeApp")

-    }

-

-

-    appHandle, err := context.AddApp(handle, APP)

-    if err != nil {

-        cleanuperr := context.DeleteCompositeApp()

-        if cleanuperr != nil {

-            log.Warn("Error cleaning AppContext CompositeApp create failure", log.Fields{

-                "logical-cloud": logicalCloudName,

-            })

-        }

-        return pkgerrors.Wrap(err, "Error adding App to AppContext")

-    }

-

-

-    // Iterate through cluster list and add all the clusters

-    for _, cluster:= range clusterList {

-        clusterName := strings.Join([]string{cluster.Specification.ClusterProvider, "+", cluster.Specification.ClusterName, }, "")

-        clusterHandle, err := context.AddCluster(appHandle, clusterName)

-

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add cluster failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding Cluster to AppContext")

-        }

-

-        // Add namespace resource to each cluster

-        _, err = context.AddResource(clusterHandle, namespaceName, namespace)

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add namespace resource failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding Namespace Resource to AppContext")

-        }

-

-        // Add csr resource to each cluster

-        _, err = context.AddResource(clusterHandle, csrName, csr)

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add CSR resource failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding CSR Resource to AppContext")

-        }

-

-

-

-        // Add Role resource to each cluster

-        _, err = context.AddResource(clusterHandle, roleName, role)

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add role resource failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding role Resource to AppContext")

-        }

-

-        // Add RoleBinding resource to each cluster

-        _, err = context.AddResource(clusterHandle, roleBindingName, roleBinding)

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add roleBinding resource failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding roleBinding Resource to AppContext")

-        }

-

-        // Add quota resource to each cluster

-        _, err = context.AddResource(clusterHandle, quotaName, quota)

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add quota resource failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding quota Resource to AppContext")

-        }

-

-        // Add Resource Order and Resource Dependency

-        resOrder, err := json.Marshal(map[string][]string{"resorder" : []string{namespaceName, quotaName, csrName, roleName, roleBindingName}})

-        if err != nil {

-            return pkgerrors.Wrap(err, "Error creating resource order JSON")

-        }

-

-        resDependency, err  :=  json.Marshal(map[string]map[string]string{"resdependency" : map[string]string{namespaceName : "go",

-                quotaName : strings.Join([]string{"wait on ", namespaceName}, ""), csrName:  strings.Join([]string{"wait on ", quotaName}, ""),

-                roleName : strings.Join([]string{"wait on ", csrName}, ""), roleBindingName: strings.Join([]string{"wait on ", roleName}, ""),}})

-

-        if err != nil {

-            return pkgerrors.Wrap(err, "Error creating resource dependency JSON")

-        }

-

-        _, err = context.AddInstruction(clusterHandle, "resource", "order", string(resOrder))

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add instruction  failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding instruction order to AppContext")

-        }

-

-        _, err = context.AddInstruction(clusterHandle, "resource", "dependency", string(resDependency))

-        if err != nil {

-            cleanuperr := context.DeleteCompositeApp()

-            if cleanuperr != nil {

-                log.Warn("Error cleaning AppContext after add instruction  failure", log.Fields{

-                    "cluster-provider": cluster.Specification.ClusterProvider,

-                    "cluster":          cluster.Specification.ClusterName,

-                    "logical-cloud": logicalCloudName,

-

-                })

-            }

-            return pkgerrors.Wrap(err, "Error adding instruction dependency to AppContext")

-        }

-

-

-

-    }

-

-    return nil

-

-

-}

+/*
+* 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 module
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/base64"
+	"encoding/json"
+	"encoding/pem"
+	"fmt"
+	"strings"
+
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/appcontext"
+	log "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/logutils"
+	pkgerrors "github.com/pkg/errors"
+	"gopkg.in/yaml.v2"
+)
+
+type Resource struct {
+	ApiVersion    string         `yaml:"apiVersion"`
+	Kind          string         `yaml:"kind"`
+	MetaData      MetaDatas      `yaml:"metadata"`
+	Specification Specs          `yaml:"spec,omitempty"`
+	Rules         []RoleRules    `yaml:"rules,omitempty"`
+	Subjects      []RoleSubjects `yaml:"subjects,omitempty"`
+	RoleRefs      RoleRef        `yaml:"roleRef,omitempty"`
+}
+
+type MetaDatas struct {
+	Name      string `yaml:"name"`
+	Namespace string `yaml:"namespace,omitempty"`
+}
+
+type Specs struct {
+	Request string   `yaml:"request,omitempty"`
+	Usages  []string `yaml:"usages,omitempty"`
+	//Hard           logicalcloud.QSpec    `yaml:"hard,omitempty"`
+	Hard QSpec `yaml:"hard,omitempty"`
+}
+
+type RoleRules struct {
+	ApiGroups []string `yaml:"apiGroups"`
+	Resources []string `yaml:"resources"`
+	Verbs     []string `yaml:"verbs"`
+}
+
+type RoleSubjects struct {
+	Kind     string `yaml:"kind"`
+	Name     string `yaml:"name"`
+	ApiGroup string `yaml:"apiGroup"`
+}
+
+type RoleRef struct {
+	Kind     string `yaml:"kind"`
+	Name     string `yaml:"name"`
+	ApiGroup string `yaml:"apiGroup"`
+}
+
+func createNamespace(logicalcloud LogicalCloud) (string, error) {
+
+	namespace := Resource{
+		ApiVersion: "v1",
+		Kind:       "Namespace",
+		MetaData: MetaDatas{
+			Name: logicalcloud.Specification.NameSpace,
+		},
+	}
+
+	nsData, err := yaml.Marshal(&namespace)
+	if err != nil {
+		return "", err
+	}
+
+	return string(nsData), nil
+}
+
+func createRole(logicalcloud LogicalCloud) (string, error) {
+
+	userPermissions := logicalcloud.Specification.User.UserPermissions[0]
+
+	role := Resource{
+		ApiVersion: "rbac.authorization.k8s.io/v1beta1",
+		Kind:       "Role",
+		MetaData: MetaDatas{
+			Name:      strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-role"}, ""),
+			Namespace: logicalcloud.Specification.NameSpace,
+		},
+		Rules: []RoleRules{RoleRules{
+			ApiGroups: userPermissions.APIGroups,
+			Resources: userPermissions.Resources,
+			Verbs:     userPermissions.Verbs,
+		},
+		},
+	}
+
+	roleData, err := yaml.Marshal(&role)
+	if err != nil {
+		return "", err
+	}
+
+	return string(roleData), nil
+}
+
+func createRoleBinding(logicalcloud LogicalCloud) (string, error) {
+
+	roleBinding := Resource{
+		ApiVersion: "rbac.authorization.k8s.io/v1beta1",
+		Kind:       "RoleBinding",
+		MetaData: MetaDatas{
+			Name:      strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-roleBinding"}, ""),
+			Namespace: logicalcloud.Specification.NameSpace,
+		},
+		Subjects: []RoleSubjects{RoleSubjects{
+			Kind:     "User",
+			Name:     logicalcloud.Specification.User.UserName,
+			ApiGroup: "",
+		},
+		},
+
+		RoleRefs: RoleRef{
+			Kind:     "Role",
+			Name:     strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-role"}, ""),
+			ApiGroup: "",
+		},
+	}
+
+	rBData, err := yaml.Marshal(&roleBinding)
+	if err != nil {
+		return "", err
+	}
+
+	return string(rBData), nil
+
+}
+
+func createQuota(quota []Quota, namespace string) (string, error) {
+	lcQuota := quota[0]
+
+	q := Resource{
+		ApiVersion: "v1",
+		Kind:       "ResourceQuota",
+		MetaData: MetaDatas{
+			Name:      lcQuota.MetaData.QuotaName,
+			Namespace: namespace,
+		},
+		Specification: Specs{
+			Hard: lcQuota.Specification,
+		},
+	}
+
+	qData, err := yaml.Marshal(&q)
+	if err != nil {
+		return "", err
+	}
+
+	return string(qData), nil
+
+}
+
+func createUserCSR(logicalcloud LogicalCloud) (string, error) {
+	KEYSIZE := 4096
+	userName := logicalcloud.Specification.User.UserName
+
+	key, err := rsa.GenerateKey(rand.Reader, KEYSIZE)
+	if err != nil {
+		return "", err
+	}
+
+	csrTemplate := x509.CertificateRequest{Subject: pkix.Name{CommonName: userName}}
+
+	csrCert, err := x509.CreateCertificateRequest(rand.Reader, &csrTemplate, key)
+	if err != nil {
+		return "", err
+	}
+
+	//Encode csr
+	csr := pem.EncodeToMemory(&pem.Block{
+		Type:  "CERTIFICATE REQUEST",
+		Bytes: csrCert,
+	})
+
+	csrObj := Resource{
+		ApiVersion: "certificates.k8s.io/v1beta1",
+		Kind:       "CertificateSigningRequest",
+		MetaData: MetaDatas{
+			Name:      strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-user-csr"}, ""),
+			Namespace: logicalcloud.Specification.NameSpace,
+		},
+		Specification: Specs{
+			Request: base64.StdEncoding.EncodeToString(csr),
+			Usages:  []string{"digital signature", "key encipherment"},
+		},
+	}
+
+	csrData, err := yaml.Marshal(&csrObj)
+	if err != nil {
+		return "", err
+	}
+
+	return string(csrData), nil
+
+}
+
+// TODO:
+// Install istio
+// Store user key for user creation
+// Code to run kubectl commands for user
+// kubectl certificate approve lc1-user-cert
+// kubectl get csr lc1-user-cert -o jsonpath='{.status.certificate}' | base64 --decode > user.crt
+// kubectl config set-credentials user --client-certificate=<user.crt>  --client-key=<user.key>
+// kubectl config set-context user-context --cluster=cluster-name --namespace=lc1 --user=user
+
+func CreateEtcdContext(logicalcloud LogicalCloud, clusterList []Cluster,
+	quotaList []Quota) error {
+
+	APP := "logical-cloud"
+	logicalCloudName := logicalcloud.MetaData.LogicalCloudName
+
+	//Resource Names
+	namespaceName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+namespace"}, "")
+	roleName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+role"}, "")
+	roleBindingName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+roleBinding"}, "")
+	quotaName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+quota"}, "")
+	csrName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+CertificateSigningRequest"}, "")
+
+	// Get resources to be added
+	namespace, err := createNamespace(logicalcloud)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error Creating Namespace YAML for logical cloud")
+	}
+
+	role, err := createRole(logicalcloud)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error Creating Role YAML for logical cloud")
+	}
+
+	roleBinding, err := createRoleBinding(logicalcloud)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error Creating RoleBinding YAML for logical cloud")
+	}
+
+	quota, err := createQuota(quotaList, logicalcloud.Specification.NameSpace)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error Creating Quota YAML for logical cloud")
+	}
+
+	csr, err := createUserCSR(logicalcloud)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error Creating User CSR for logical cloud")
+	}
+
+	context := appcontext.AppContext{}
+	ctxVal, err := context.InitAppContext()
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error creating AppContext")
+	}
+
+	fmt.Printf("%v\n", ctxVal)
+
+	handle, err := context.CreateCompositeApp()
+	if err != nil {
+		return pkgerrors.Wrap(err, "Error creating AppContext CompositeApp")
+	}
+
+	appHandle, err := context.AddApp(handle, APP)
+	if err != nil {
+		cleanuperr := context.DeleteCompositeApp()
+		if cleanuperr != nil {
+			log.Warn("Error cleaning AppContext CompositeApp create failure", log.Fields{
+				"logical-cloud": logicalCloudName,
+			})
+		}
+		return pkgerrors.Wrap(err, "Error adding App to AppContext")
+	}
+
+	// Iterate through cluster list and add all the clusters
+	for _, cluster := range clusterList {
+		clusterName := strings.Join([]string{cluster.Specification.ClusterProvider, "+", cluster.Specification.ClusterName}, "")
+		clusterHandle, err := context.AddCluster(appHandle, clusterName)
+
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add cluster failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding Cluster to AppContext")
+		}
+
+		// Add namespace resource to each cluster
+		_, err = context.AddResource(clusterHandle, namespaceName, namespace)
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add namespace resource failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding Namespace Resource to AppContext")
+		}
+
+		// Add csr resource to each cluster
+		_, err = context.AddResource(clusterHandle, csrName, csr)
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add CSR resource failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding CSR Resource to AppContext")
+		}
+
+		// Add Role resource to each cluster
+		_, err = context.AddResource(clusterHandle, roleName, role)
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add role resource failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding role Resource to AppContext")
+		}
+
+		// Add RoleBinding resource to each cluster
+		_, err = context.AddResource(clusterHandle, roleBindingName, roleBinding)
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add roleBinding resource failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding roleBinding Resource to AppContext")
+		}
+
+		// Add quota resource to each cluster
+		_, err = context.AddResource(clusterHandle, quotaName, quota)
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add quota resource failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding quota Resource to AppContext")
+		}
+
+		// Add Resource Order and Resource Dependency
+		resOrder, err := json.Marshal(map[string][]string{"resorder": []string{namespaceName, quotaName, csrName, roleName, roleBindingName}})
+		if err != nil {
+			return pkgerrors.Wrap(err, "Error creating resource order JSON")
+		}
+
+		resDependency, err := json.Marshal(map[string]map[string]string{"resdependency": map[string]string{namespaceName: "go",
+			quotaName: strings.Join([]string{"wait on ", namespaceName}, ""), csrName: strings.Join([]string{"wait on ", quotaName}, ""),
+			roleName: strings.Join([]string{"wait on ", csrName}, ""), roleBindingName: strings.Join([]string{"wait on ", roleName}, "")}})
+
+		if err != nil {
+			return pkgerrors.Wrap(err, "Error creating resource dependency JSON")
+		}
+
+		_, err = context.AddInstruction(clusterHandle, "resource", "order", string(resOrder))
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add instruction  failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding instruction order to AppContext")
+		}
+
+		_, err = context.AddInstruction(clusterHandle, "resource", "dependency", string(resDependency))
+		if err != nil {
+			cleanuperr := context.DeleteCompositeApp()
+			if cleanuperr != nil {
+				log.Warn("Error cleaning AppContext after add instruction  failure", log.Fields{
+					"cluster-provider": cluster.Specification.ClusterProvider,
+					"cluster":          cluster.Specification.ClusterName,
+					"logical-cloud":    logicalCloudName,
+				})
+			}
+			return pkgerrors.Wrap(err, "Error adding instruction dependency to AppContext")
+		}
+
+	}
+
+	return nil
+
+}
diff --git a/src/dcm/pkg/module/cluster.go b/src/dcm/pkg/module/cluster.go
index 38848990..206d79a6 100644
--- a/src/dcm/pkg/module/cluster.go
+++ b/src/dcm/pkg/module/cluster.go
@@ -12,194 +12,192 @@
 * 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 module
 
 import (
-    pkgerrors "github.com/pkg/errors"
+	pkgerrors "github.com/pkg/errors"
 )
 
 // Cluster contains the parameters needed for a Cluster
 type Cluster struct {
-    MetaData            ClusterMeta         `json:"metadata"`
-    Specification       ClusterSpec         `json:"spec"`
+	MetaData      ClusterMeta `json:"metadata"`
+	Specification ClusterSpec `json:"spec"`
 }
 
 type ClusterMeta struct {
-    ClusterReference    string  `json:"name"`
-    Description         string  `json:"description"`
-    UserData1           string  `json:"userData1"`
-    UserData2           string  `json:"userData2"`
+	ClusterReference string `json:"name"`
+	Description      string `json:"description"`
+	UserData1        string `json:"userData1"`
+	UserData2        string `json:"userData2"`
 }
 
 type ClusterSpec struct {
-    ClusterProvider     string      `json:"cluster-provider"`
-    ClusterName         string      `json:"cluster-name"`
-    LoadBalancerIP      string      `json:"loadbalancer-ip"`
+	ClusterProvider string `json:"cluster-provider"`
+	ClusterName     string `json:"cluster-name"`
+	LoadBalancerIP  string `json:"loadbalancer-ip"`
 }
 
-
 type ClusterKey struct {
-    Project             string      `json:"project"`
-    LogicalCloudName    string      `json:"logical-cloud-name"`
-    ClusterReference    string      `json:"clname"`
+	Project          string `json:"project"`
+	LogicalCloudName string `json:"logical-cloud-name"`
+	ClusterReference string `json:"clname"`
 }
 
 // ClusterManager is an interface that exposes the connection
 // functionality
 type ClusterManager interface {
-    CreateCluster(project, logicalCloud string, c Cluster) (Cluster, error)
-    GetCluster(project, logicalCloud, name string) (Cluster, error)
-    GetAllClusters(project, logicalCloud string) ([]Cluster, error)
-    DeleteCluster(project, logicalCloud, name string) error
-    UpdateCluster(project, logicalCloud, name string, c Cluster) (Cluster, error)
+	CreateCluster(project, logicalCloud string, c Cluster) (Cluster, error)
+	GetCluster(project, logicalCloud, name string) (Cluster, error)
+	GetAllClusters(project, logicalCloud string) ([]Cluster, error)
+	DeleteCluster(project, logicalCloud, name string) error
+	UpdateCluster(project, logicalCloud, name string, c Cluster) (Cluster, error)
 }
 
 // ClusterClient implements the ClusterManager
 // It will also be used to maintain some localized state
 type ClusterClient struct {
-    storeName   string
-    tagMeta     string
-    util        Utility
+	storeName string
+	tagMeta   string
+	util      Utility
 }
 
 // ClusterClient returns an instance of the ClusterClient
 // which implements the ClusterManager
 func NewClusterClient() *ClusterClient {
-    service := DBService{}
-    return &ClusterClient{
-        storeName:   "orchestrator",
-        tagMeta:     "cluster",
-        util:       service,
-    }
+	service := DBService{}
+	return &ClusterClient{
+		storeName: "orchestrator",
+		tagMeta:   "cluster",
+		util:      service,
+	}
 }
 
 // Create entry for the cluster reference resource in the database
 func (v *ClusterClient) CreateCluster(project, logicalCloud string, c Cluster) (Cluster, error) {
 
-    //Construct key consisting of name
-    key := ClusterKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        ClusterReference:   c.MetaData.ClusterReference,
-    }
-
-    //Check if project exists
-    err := v.util.CheckProject(project)
-    if err != nil {
-        return Cluster{}, pkgerrors.New("Unable to find the project")
-    }
-    //check if logical cloud exists
-    err = v.util.CheckLogicalCloud(project, logicalCloud)
-    if err != nil {
-        return Cluster{}, pkgerrors.New("Unable to find the logical cloud")
-    }
-    //Check if this Cluster reference already exists
-    _, err = v.GetCluster(project, logicalCloud, c.MetaData.ClusterReference)
-    if err == nil {
-        return Cluster{}, pkgerrors.New("Cluster reference already exists")
-    }
-
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return Cluster{}, pkgerrors.Wrap(err, "Creating DB Entry")
-    }
-
-    return c, nil
+	//Construct key consisting of name
+	key := ClusterKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		ClusterReference: c.MetaData.ClusterReference,
+	}
+
+	//Check if project exists
+	err := v.util.CheckProject(project)
+	if err != nil {
+		return Cluster{}, pkgerrors.New("Unable to find the project")
+	}
+	//check if logical cloud exists
+	err = v.util.CheckLogicalCloud(project, logicalCloud)
+	if err != nil {
+		return Cluster{}, pkgerrors.New("Unable to find the logical cloud")
+	}
+	//Check if this Cluster reference already exists
+	_, err = v.GetCluster(project, logicalCloud, c.MetaData.ClusterReference)
+	if err == nil {
+		return Cluster{}, pkgerrors.New("Cluster reference already exists")
+	}
+
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return Cluster{}, pkgerrors.Wrap(err, "Creating DB Entry")
+	}
+
+	return c, nil
 }
 
 // Get returns  Cluster for corresponding cluster reference
-func (v *ClusterClient) GetCluster(project, logicalCloud, clusterReference string)(Cluster, error) {
-
-    //Construct the composite key to select the entry
-    key := ClusterKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        ClusterReference:   clusterReference,
-    }
-
-    value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return Cluster{}, pkgerrors.Wrap(err, "Get Cluster reference")
-    }
-
-    //value is a byte array
-    if value != nil {
-        cl := Cluster{}
-        err = v.util.DBUnmarshal(value[0], &cl)
-        if err != nil {
-            return Cluster{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        return cl, nil
-    }
-
-    return Cluster{}, pkgerrors.New("Error getting Cluster")
+func (v *ClusterClient) GetCluster(project, logicalCloud, clusterReference string) (Cluster, error) {
+
+	//Construct the composite key to select the entry
+	key := ClusterKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		ClusterReference: clusterReference,
+	}
+
+	value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return Cluster{}, pkgerrors.Wrap(err, "Get Cluster reference")
+	}
+
+	//value is a byte array
+	if value != nil {
+		cl := Cluster{}
+		err = v.util.DBUnmarshal(value[0], &cl)
+		if err != nil {
+			return Cluster{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		return cl, nil
+	}
+
+	return Cluster{}, pkgerrors.New("Error getting Cluster")
 }
 
-
 // GetAll returns all cluster references in the logical cloud
-func (v *ClusterClient) GetAllClusters(project, logicalCloud string)([]Cluster, error) {
-    //Construct the composite key to select clusters
-    key := ClusterKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        ClusterReference:   "",
-    }
-    var resp  []Cluster
-    values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return []Cluster{}, pkgerrors.Wrap(err, "Get All Cluster references")
-    }
-
-    for _, value := range values {
-        cl := Cluster{}
-        err = v.util.DBUnmarshal(value, &cl)
-        if err != nil {
-            return []Cluster{}, pkgerrors.Wrap(err, "Unmarshaling values")
-        }
-        resp = append(resp, cl)
-    }
-
-    return resp, nil
+func (v *ClusterClient) GetAllClusters(project, logicalCloud string) ([]Cluster, error) {
+	//Construct the composite key to select clusters
+	key := ClusterKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		ClusterReference: "",
+	}
+	var resp []Cluster
+	values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return []Cluster{}, pkgerrors.Wrap(err, "Get All Cluster references")
+	}
+
+	for _, value := range values {
+		cl := Cluster{}
+		err = v.util.DBUnmarshal(value, &cl)
+		if err != nil {
+			return []Cluster{}, pkgerrors.Wrap(err, "Unmarshaling values")
+		}
+		resp = append(resp, cl)
+	}
+
+	return resp, nil
 }
 
 // Delete the Cluster reference entry from database
 func (v *ClusterClient) DeleteCluster(project, logicalCloud, clusterReference string) error {
-    //Construct the composite key to select the entry
-    key := ClusterKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        ClusterReference:   clusterReference,
-    }
-    err := v.util.DBRemove(v.storeName, key)
-    if err != nil {
-        return pkgerrors.Wrap(err, "Delete Cluster Reference")
-    }
-    return nil
+	//Construct the composite key to select the entry
+	key := ClusterKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		ClusterReference: clusterReference,
+	}
+	err := v.util.DBRemove(v.storeName, key)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete Cluster Reference")
+	}
+	return nil
 }
 
 // Update an entry for the Cluster reference in the database
 func (v *ClusterClient) UpdateCluster(project, logicalCloud, clusterReference string, c Cluster) (Cluster, error) {
 
-    key := ClusterKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        ClusterReference:   clusterReference,
-    }
-
-    //Check for name mismatch in cluster reference
-    if c.MetaData.ClusterReference != clusterReference {
-        return Cluster{}, pkgerrors.New("Update Error - Cluster reference mismatch")
-    }
-    //Check if this Cluster reference exists
-    _, err := v.GetCluster(project, logicalCloud, clusterReference)
-    if err != nil {
-        return Cluster{}, pkgerrors.New("Update Error - Cluster reference doesn't exist")
-    }
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return Cluster{}, pkgerrors.Wrap(err, "Updating DB Entry")
-    }
-    return c, nil
+	key := ClusterKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		ClusterReference: clusterReference,
+	}
+
+	//Check for name mismatch in cluster reference
+	if c.MetaData.ClusterReference != clusterReference {
+		return Cluster{}, pkgerrors.New("Update Error - Cluster reference mismatch")
+	}
+	//Check if this Cluster reference exists
+	_, err := v.GetCluster(project, logicalCloud, clusterReference)
+	if err != nil {
+		return Cluster{}, pkgerrors.New("Update Error - Cluster reference doesn't exist")
+	}
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return Cluster{}, pkgerrors.Wrap(err, "Updating DB Entry")
+	}
+	return c, nil
 }
diff --git a/src/dcm/pkg/module/cluster_test.go b/src/dcm/pkg/module/cluster_test.go
index d42935db..626adff7 100644
--- a/src/dcm/pkg/module/cluster_test.go
+++ b/src/dcm/pkg/module/cluster_test.go
@@ -1,115 +1,112 @@
-package module

-

-import (

-    "testing"

-

-    "github.com/pkg/errors"

-

-)

-

-

-func TestCreateCluster(t *testing.T) {

-

-    mData := ClusterMeta{

-        ClusterReference: "test_cluster",

-    }

-

-    cl := Cluster {

-        MetaData:   mData,

-    }

-    data1 := [][]byte{}

-

-

-    key := ClusterKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        ClusterReference:   "test_cluster",

-    }

-    myMocks := new(mockValues)

-    // just to get an error value

-    err1 := errors.New("math: square root of negative number")

-

-    myMocks.On("CheckProject", "test_project").Return(nil)

-    myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", cl).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)

-

-    clClient := ClusterClient{"test_dcm", "test_meta", myMocks}

-    _, err := clClient.CreateCluster("test_project", "test_asdf", cl)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestGetCluster(t *testing.T) {

-    key := ClusterKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        ClusterReference:   "test_cluster",

-    }

-

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    clClient := ClusterClient{"test_dcm", "test_meta", myMocks}

-    _, err := clClient.GetCluster("test_project", "test_asdf", "test_cluster")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestDeleteCluster(t *testing.T) {

-

-    key := ClusterKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        ClusterReference:   "test_cluster",

-    }

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBRemove", "test_dcm", key).Return(nil)

-

-    clClient := ClusterClient{"test_dcm", "test_meta", myMocks}

-    err := clClient.DeleteCluster("test_project", "test_asdf", "test_cluster")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-

-}

-

-func TestUpdateCluster(t *testing.T) {

-    key := ClusterKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        ClusterReference:   "test_cluster",

-    }

-    mData := ClusterMeta{

-        ClusterReference: "test_cluster",

-    }

-    cl := Cluster{

-        MetaData: mData,

-    }

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", cl).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    clClient := ClusterClient{"test_dcm", "test_meta", myMocks}

-    _, err := clClient.UpdateCluster("test_project", "test_asdf", "test_cluster", cl)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

+package module
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+)
+
+func TestCreateCluster(t *testing.T) {
+
+	mData := ClusterMeta{
+		ClusterReference: "test_cluster",
+	}
+
+	cl := Cluster{
+		MetaData: mData,
+	}
+	data1 := [][]byte{}
+
+	key := ClusterKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		ClusterReference: "test_cluster",
+	}
+	myMocks := new(mockValues)
+	// just to get an error value
+	err1 := errors.New("math: square root of negative number")
+
+	myMocks.On("CheckProject", "test_project").Return(nil)
+	myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", cl).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)
+
+	clClient := ClusterClient{"test_dcm", "test_meta", myMocks}
+	_, err := clClient.CreateCluster("test_project", "test_asdf", cl)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestGetCluster(t *testing.T) {
+	key := ClusterKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		ClusterReference: "test_cluster",
+	}
+
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	clClient := ClusterClient{"test_dcm", "test_meta", myMocks}
+	_, err := clClient.GetCluster("test_project", "test_asdf", "test_cluster")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestDeleteCluster(t *testing.T) {
+
+	key := ClusterKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		ClusterReference: "test_cluster",
+	}
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBRemove", "test_dcm", key).Return(nil)
+
+	clClient := ClusterClient{"test_dcm", "test_meta", myMocks}
+	err := clClient.DeleteCluster("test_project", "test_asdf", "test_cluster")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+
+}
+
+func TestUpdateCluster(t *testing.T) {
+	key := ClusterKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		ClusterReference: "test_cluster",
+	}
+	mData := ClusterMeta{
+		ClusterReference: "test_cluster",
+	}
+	cl := Cluster{
+		MetaData: mData,
+	}
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", cl).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	clClient := ClusterClient{"test_dcm", "test_meta", myMocks}
+	_, err := clClient.UpdateCluster("test_project", "test_asdf", "test_cluster", cl)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
diff --git a/src/dcm/pkg/module/keyvalue.go b/src/dcm/pkg/module/keyvalue.go
index 4e3e0fab..37c74a84 100644
--- a/src/dcm/pkg/module/keyvalue.go
+++ b/src/dcm/pkg/module/keyvalue.go
@@ -12,194 +12,193 @@
 * 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 module
 
 import (
-    pkgerrors "github.com/pkg/errors"
+	pkgerrors "github.com/pkg/errors"
 )
 
 // KeyValue contains the parameters needed for a key value
 type KeyValue struct {
-    MetaData            KVMetaDataList        `json:"metadata"`
-    Specification       KVSpec                `json:"spec"`
+	MetaData      KVMetaDataList `json:"metadata"`
+	Specification KVSpec         `json:"spec"`
 }
 
-
 // MetaData contains the parameters needed for metadata
 type KVMetaDataList struct {
-    KeyValueName        string  `json:"name"`
-    Description         string  `json:"description"`
-    UserData1           string  `json:"userData1"`
-    UserData2           string  `json:"userData2"`
+	KeyValueName string `json:"name"`
+	Description  string `json:"description"`
+	UserData1    string `json:"userData1"`
+	UserData2    string `json:"userData2"`
 }
 
 // Spec contains the parameters needed for spec
 type KVSpec struct {
-    Kv []map[string]interface{} `json:"kv"`
+	Kv []map[string]interface{} `json:"kv"`
 }
 
 // KeyValueKey is the key structure that is used in the database
 type KeyValueKey struct {
-    Project             string      `json:"project"`
-    LogicalCloudName    string      `json:"logical-cloud-name"`
-    KeyValueName        string      `json:"kvname"`
+	Project          string `json:"project"`
+	LogicalCloudName string `json:"logical-cloud-name"`
+	KeyValueName     string `json:"kvname"`
 }
 
 // KeyValueManager is an interface that exposes the connection
 // functionality
 type KeyValueManager interface {
-    CreateKVPair(project, logicalCloud string, c KeyValue) (KeyValue, error)
-    GetKVPair(project, logicalCloud, name string) (KeyValue, error)
-    GetAllKVPairs(project, logicalCloud string) ([]KeyValue, error)
-    DeleteKVPair(project, logicalCloud, name string) error
-    UpdateKVPair(project, logicalCloud, name string, c KeyValue) (KeyValue, error)
+	CreateKVPair(project, logicalCloud string, c KeyValue) (KeyValue, error)
+	GetKVPair(project, logicalCloud, name string) (KeyValue, error)
+	GetAllKVPairs(project, logicalCloud string) ([]KeyValue, error)
+	DeleteKVPair(project, logicalCloud, name string) error
+	UpdateKVPair(project, logicalCloud, name string, c KeyValue) (KeyValue, error)
 }
 
 // KeyValueClient implements the KeyValueManager
 // It will also be used to maintain some localized state
 type KeyValueClient struct {
-    storeName   string
-    tagMeta     string
-    util        Utility
+	storeName string
+	tagMeta   string
+	util      Utility
 }
 
 // KeyValueClient returns an instance of the KeyValueClient
 // which implements the KeyValueManager
 func NewKeyValueClient() *KeyValueClient {
-    service := DBService{}
-    return &KeyValueClient{
-        storeName:  "orchestrator",
-        tagMeta:    "keyvalue",
-        util:       service,
-    }
+	service := DBService{}
+	return &KeyValueClient{
+		storeName: "orchestrator",
+		tagMeta:   "keyvalue",
+		util:      service,
+	}
 }
 
 // Create entry for the key value resource in the database
 func (v *KeyValueClient) CreateKVPair(project, logicalCloud string, c KeyValue) (KeyValue, error) {
 
-    //Construct key consisting of name
-    key := KeyValueKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        KeyValueName:       c.MetaData.KeyValueName,
-    }
-
-    //Check if project exist
-    err := v.util.CheckProject(project)
-    if err != nil {
-        return KeyValue{}, pkgerrors.New("Unable to find the project")
-    }
-    //check if logical cloud exists
-    err = v.util.CheckLogicalCloud(project, logicalCloud)
-    if err != nil {
-        return KeyValue{}, pkgerrors.New("Unable to find the logical cloud")
-    }
-    //Check if this Key Value already exists
-    _, err = v.GetKVPair(project, logicalCloud, c.MetaData.KeyValueName)
-    if err == nil {
-        return KeyValue{}, pkgerrors.New("Key Value already exists")
-    }
-
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return KeyValue{}, pkgerrors.Wrap(err, "Creating DB Entry")
-    }
-
-    return c, nil
+	//Construct key consisting of name
+	key := KeyValueKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		KeyValueName:     c.MetaData.KeyValueName,
+	}
+
+	//Check if project exist
+	err := v.util.CheckProject(project)
+	if err != nil {
+		return KeyValue{}, pkgerrors.New("Unable to find the project")
+	}
+	//check if logical cloud exists
+	err = v.util.CheckLogicalCloud(project, logicalCloud)
+	if err != nil {
+		return KeyValue{}, pkgerrors.New("Unable to find the logical cloud")
+	}
+	//Check if this Key Value already exists
+	_, err = v.GetKVPair(project, logicalCloud, c.MetaData.KeyValueName)
+	if err == nil {
+		return KeyValue{}, pkgerrors.New("Key Value already exists")
+	}
+
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return KeyValue{}, pkgerrors.Wrap(err, "Creating DB Entry")
+	}
+
+	return c, nil
 }
 
 // Get returns Key Value for correspondin name
 func (v *KeyValueClient) GetKVPair(project, logicalCloud, kvPairName string) (KeyValue, error) {
 
-    //Construct the composite key to select the entry
-    key := KeyValueKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        KeyValueName:       kvPairName,
-    }
-    value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return KeyValue{}, pkgerrors.Wrap(err, "Get Key Value")
-    }
-
-    //value is a byte array
-    if value != nil {
-        kv := KeyValue{}
-        err = v.util.DBUnmarshal(value[0], &kv)
-        if err != nil {
-            return KeyValue{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        return kv, nil
-    }
-
-    return KeyValue{}, pkgerrors.New("Error getting Key Value")
+	//Construct the composite key to select the entry
+	key := KeyValueKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		KeyValueName:     kvPairName,
+	}
+	value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return KeyValue{}, pkgerrors.Wrap(err, "Get Key Value")
+	}
+
+	//value is a byte array
+	if value != nil {
+		kv := KeyValue{}
+		err = v.util.DBUnmarshal(value[0], &kv)
+		if err != nil {
+			return KeyValue{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		return kv, nil
+	}
+
+	return KeyValue{}, pkgerrors.New("Error getting Key Value")
 }
 
 // Get All lists all key value pairs
 func (v *KeyValueClient) GetAllKVPairs(project, logicalCloud string) ([]KeyValue, error) {
 
-    //Construct the composite key to select the entry
-    key := KeyValueKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        KeyValueName:       "",
-    }
-    var resp  []KeyValue
-    values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return []KeyValue{}, pkgerrors.Wrap(err, "Get Key Value")
-    }
-
-    for _, value := range values {
-        kv := KeyValue{}
-        err = v.util.DBUnmarshal(value, &kv)
-        if err != nil {
-            return []KeyValue{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        resp = append(resp, kv)
-    }
-
-    return resp, nil
+	//Construct the composite key to select the entry
+	key := KeyValueKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		KeyValueName:     "",
+	}
+	var resp []KeyValue
+	values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return []KeyValue{}, pkgerrors.Wrap(err, "Get Key Value")
+	}
+
+	for _, value := range values {
+		kv := KeyValue{}
+		err = v.util.DBUnmarshal(value, &kv)
+		if err != nil {
+			return []KeyValue{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		resp = append(resp, kv)
+	}
+
+	return resp, nil
 }
 
 // Delete the Key Value entry from database
 func (v *KeyValueClient) DeleteKVPair(project, logicalCloud, kvPairName string) error {
 
-    //Construct the composite key to select the entry
-    key := KeyValueKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        KeyValueName:       kvPairName,
-    }
-        err := v.util.DBRemove(v.storeName, key)
-        if err != nil {
-                return pkgerrors.Wrap(err, "Delete Key Value")
-        }
-        return nil
+	//Construct the composite key to select the entry
+	key := KeyValueKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		KeyValueName:     kvPairName,
+	}
+	err := v.util.DBRemove(v.storeName, key)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete Key Value")
+	}
+	return nil
 }
 
 // Update an entry for the Key Value in the database
 func (v *KeyValueClient) UpdateKVPair(project, logicalCloud, kvPairName string, c KeyValue) (KeyValue, error) {
 
-    key := KeyValueKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        KeyValueName:       kvPairName,
-    }
-    //Check if KV pair URl name is the same name in json
-    if c.MetaData.KeyValueName != kvPairName {
-        return KeyValue{}, pkgerrors.New("Update Error - KV pair name mismatch")
-    }
-    //Check if this Key Value exists
-    _, err := v.GetKVPair(project, logicalCloud, kvPairName)
-    if err != nil {
-        return KeyValue{}, pkgerrors.New("Update Error - Key Value Pair doesn't exist")
-    }
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return KeyValue{}, pkgerrors.Wrap(err, "Updating DB Entry")
-    }
-    return c, nil
+	key := KeyValueKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		KeyValueName:     kvPairName,
+	}
+	//Check if KV pair URl name is the same name in json
+	if c.MetaData.KeyValueName != kvPairName {
+		return KeyValue{}, pkgerrors.New("Update Error - KV pair name mismatch")
+	}
+	//Check if this Key Value exists
+	_, err := v.GetKVPair(project, logicalCloud, kvPairName)
+	if err != nil {
+		return KeyValue{}, pkgerrors.New("Update Error - Key Value Pair doesn't exist")
+	}
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return KeyValue{}, pkgerrors.Wrap(err, "Updating DB Entry")
+	}
+	return c, nil
 }
diff --git a/src/dcm/pkg/module/keyvalue_test.go b/src/dcm/pkg/module/keyvalue_test.go
index 9faceda4..25fd55cb 100644
--- a/src/dcm/pkg/module/keyvalue_test.go
+++ b/src/dcm/pkg/module/keyvalue_test.go
@@ -1,115 +1,112 @@
-package module

-

-import (

-    "testing"

-

-    "github.com/pkg/errors"

-

-)

-

-

-func TestCreateKVPair(t *testing.T) {

-

-    mData := KVMetaDataList{

-        KeyValueName: "test_kv_pair",

-    }

-

-    kv := KeyValue {

-        MetaData:   mData,

-    }

-    data1 := [][]byte{}

-

-

-    key := KeyValueKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        KeyValueName:       "test_kv_pair",

-    }

-    myMocks := new(mockValues)

-    // just to get an error value

-    err1 := errors.New("math: square root of negative number")

-

-    myMocks.On("CheckProject", "test_project").Return(nil)

-    myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", kv).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)

-

-    kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}

-    _, err := kvClient.CreateKVPair("test_project", "test_asdf", kv)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestGetKVPair(t *testing.T) {

-    key := KeyValueKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        KeyValueName:       "test_kv_pair",

-    }

-

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}

-    _, err := kvClient.GetKVPair("test_project", "test_asdf", "test_kv_pair")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestDeleteKVPair(t *testing.T) {

-

-    key := KeyValueKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        KeyValueName:       "test_kv_pair",

-    }

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBRemove", "test_dcm", key).Return(nil)

-

-    kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}

-    err := kvClient.DeleteKVPair("test_project", "test_asdf", "test_kv_pair")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-

-}

-

-func TestUpdateKVPair(t *testing.T) {

-    key := KeyValueKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        KeyValueName:       "test_kv_pair",

-    }

-    mData := KVMetaDataList{

-        KeyValueName:       "test_kv_pair",

-    }

-    kv := KeyValue{

-        MetaData: mData,

-    }

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", kv).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}

-    _, err := kvClient.UpdateKVPair("test_project", "test_asdf", "test_kv_pair", kv)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

+package module
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+)
+
+func TestCreateKVPair(t *testing.T) {
+
+	mData := KVMetaDataList{
+		KeyValueName: "test_kv_pair",
+	}
+
+	kv := KeyValue{
+		MetaData: mData,
+	}
+	data1 := [][]byte{}
+
+	key := KeyValueKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		KeyValueName:     "test_kv_pair",
+	}
+	myMocks := new(mockValues)
+	// just to get an error value
+	err1 := errors.New("math: square root of negative number")
+
+	myMocks.On("CheckProject", "test_project").Return(nil)
+	myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", kv).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)
+
+	kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}
+	_, err := kvClient.CreateKVPair("test_project", "test_asdf", kv)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestGetKVPair(t *testing.T) {
+	key := KeyValueKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		KeyValueName:     "test_kv_pair",
+	}
+
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}
+	_, err := kvClient.GetKVPair("test_project", "test_asdf", "test_kv_pair")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestDeleteKVPair(t *testing.T) {
+
+	key := KeyValueKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		KeyValueName:     "test_kv_pair",
+	}
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBRemove", "test_dcm", key).Return(nil)
+
+	kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}
+	err := kvClient.DeleteKVPair("test_project", "test_asdf", "test_kv_pair")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+
+}
+
+func TestUpdateKVPair(t *testing.T) {
+	key := KeyValueKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		KeyValueName:     "test_kv_pair",
+	}
+	mData := KVMetaDataList{
+		KeyValueName: "test_kv_pair",
+	}
+	kv := KeyValue{
+		MetaData: mData,
+	}
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", kv).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	kvClient := KeyValueClient{"test_dcm", "test_meta", myMocks}
+	_, err := kvClient.UpdateKVPair("test_project", "test_asdf", "test_kv_pair", kv)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
diff --git a/src/dcm/pkg/module/logicalcloud.go b/src/dcm/pkg/module/logicalcloud.go
index 9fb1b6fb..51ee387d 100644
--- a/src/dcm/pkg/module/logicalcloud.go
+++ b/src/dcm/pkg/module/logicalcloud.go
@@ -12,280 +12,277 @@
 * 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 module
 
 import (
-    "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"
-    "github.com/onap/multicloud-k8s/src/orchestrator/pkg/module"
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/module"
 
-    pkgerrors "github.com/pkg/errors"
+	pkgerrors "github.com/pkg/errors"
 )
 
 // LogicalCloud contains the parameters needed for a Logical Cloud
 type LogicalCloud struct {
-    MetaData            MetaDataList        `json:"metadata"`
-    Specification       Spec                `json:"spec"`
+	MetaData      MetaDataList `json:"metadata"`
+	Specification Spec         `json:"spec"`
 }
 
-
 // MetaData contains the parameters needed for metadata
 type MetaDataList struct {
-    LogicalCloudName    string  `json:"name"`
-    Description         string  `json:"description"`
-    UserData1           string  `json:"userData1"`
-    UserData2           string  `json:"userData2"`
+	LogicalCloudName string `json:"name"`
+	Description      string `json:"description"`
+	UserData1        string `json:"userData1"`
+	UserData2        string `json:"userData2"`
 }
 
 // Spec contains the parameters needed for spec
 type Spec struct {
-    NameSpace   string      `json:"namespace"`
-    User        UserData    `json:"user"`
-
+	NameSpace string   `json:"namespace"`
+	User      UserData `json:"user"`
 }
 
 // UserData contains the parameters needed for user
 type UserData struct {
-    UserName            string        `json:"user-name"`
-    Type                string        `json:"type"`
-    UserPermissions     []UserPerm    `json:"user-permissions"`
+	UserName        string     `json:"user-name"`
+	Type            string     `json:"type"`
+	UserPermissions []UserPerm `json:"user-permissions"`
 }
 
 //  UserPerm contains the parameters needed for user permissions
 type UserPerm struct {
-    PermName        string          `json:"permission-name"`
-    APIGroups       []string        `json:"apiGroups"`
-    Resources       []string        `json:"resources"`
-    Verbs           []string        `json:"verbs"`
+	PermName  string   `json:"permission-name"`
+	APIGroups []string `json:"apiGroups"`
+	Resources []string `json:"resources"`
+	Verbs     []string `json:"verbs"`
 }
 
 // LogicalCloudKey is the key structure that is used in the database
 type LogicalCloudKey struct {
-    Project             string  `json:"project"`
-    LogicalCloudName    string  `json:"logical-cloud-name"`
+	Project          string `json:"project"`
+	LogicalCloudName string `json:"logical-cloud-name"`
 }
 
 // LogicalCloudManager is an interface that exposes the connection
 // functionality
 type LogicalCloudManager interface {
-    Create(project string, c LogicalCloud) (LogicalCloud, error)
-    Get(project, name string) (LogicalCloud, error)
-    GetAll(project string) ([]LogicalCloud, error)
-    Delete(project, name string) error
-    Update(project, name string, c LogicalCloud) (LogicalCloud, error)
-
+	Create(project string, c LogicalCloud) (LogicalCloud, error)
+	Get(project, name string) (LogicalCloud, error)
+	GetAll(project string) ([]LogicalCloud, error)
+	Delete(project, name string) error
+	Update(project, name string, c LogicalCloud) (LogicalCloud, error)
 }
 
 // Interface facilitates unit testing by mocking functions
 type Utility interface {
-    DBInsert(storeName string, key db.Key, query interface{}, meta string, c interface{}) error
-    DBFind(storeName string, key db.Key, meta string) ([][]byte, error)
-    DBUnmarshal(value []byte, out interface{}) error
-    DBRemove(storeName string, key db.Key) error
-    CheckProject(project string) error
-    CheckLogicalCloud(project, logicalCloud string) error
+	DBInsert(storeName string, key db.Key, query interface{}, meta string, c interface{}) error
+	DBFind(storeName string, key db.Key, meta string) ([][]byte, error)
+	DBUnmarshal(value []byte, out interface{}) error
+	DBRemove(storeName string, key db.Key) error
+	CheckProject(project string) error
+	CheckLogicalCloud(project, logicalCloud string) error
 }
 
 // LogicalCloudClient implements the LogicalCloudManager
 // It will also be used to maintain some localized state
 type LogicalCloudClient struct {
-    storeName   string
-    tagMeta     string
-    util        Utility
+	storeName string
+	tagMeta   string
+	util      Utility
 }
 
 // Added for unit testing; implements Utility interface
-type DBService struct {}
+type DBService struct{}
 
 // LogicalCloudClient returns an instance of the LogicalCloudClient
 // which implements the LogicalCloudManager
 func NewLogicalCloudClient() *LogicalCloudClient {
-    service := DBService{}
-    return &LogicalCloudClient{
-        storeName:  "orchestrator",
-        tagMeta:    "logicalcloud",
-        util:       service,
-    }
+	service := DBService{}
+	return &LogicalCloudClient{
+		storeName: "orchestrator",
+		tagMeta:   "logicalcloud",
+		util:      service,
+	}
 }
 
 // Create entry for the logical cloud resource in the database
 func (v *LogicalCloudClient) Create(project string, c LogicalCloud) (LogicalCloud, error) {
 
-    //Construct key consisting of name
-    key := LogicalCloudKey{
-        Project:            project,
-        LogicalCloudName:   c.MetaData.LogicalCloudName,
-    }
-
-    //Check if project exists
-    err := v.util.CheckProject(project)
-    if err != nil {
-        return LogicalCloud{}, pkgerrors.New("Unable to find the project")
-    }
-
-    //Check if this Logical Cloud already exists
-    _, err = v.Get(project, c.MetaData.LogicalCloudName)
-    if err == nil {
-        return LogicalCloud{}, pkgerrors.New("Logical Cloud already exists")
-    }
-
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return LogicalCloud{}, pkgerrors.Wrap(err, "Creating DB Entry")
-    }
-
-    return c, nil
+	//Construct key consisting of name
+	key := LogicalCloudKey{
+		Project:          project,
+		LogicalCloudName: c.MetaData.LogicalCloudName,
+	}
+
+	//Check if project exists
+	err := v.util.CheckProject(project)
+	if err != nil {
+		return LogicalCloud{}, pkgerrors.New("Unable to find the project")
+	}
+
+	//Check if this Logical Cloud already exists
+	_, err = v.Get(project, c.MetaData.LogicalCloudName)
+	if err == nil {
+		return LogicalCloud{}, pkgerrors.New("Logical Cloud already exists")
+	}
+
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return LogicalCloud{}, pkgerrors.Wrap(err, "Creating DB Entry")
+	}
+
+	return c, nil
 }
 
 // Get returns Logical Cloud corresponding to logical cloud name
 func (v *LogicalCloudClient) Get(project, logicalCloudName string) (LogicalCloud, error) {
 
-    //Construct the composite key to select the entry
-    key := LogicalCloudKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloudName,
-    }
-    value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return LogicalCloud{}, pkgerrors.Wrap(err, "Get Logical Cloud")
-    }
-
-    //value is a byte array
-    if value != nil {
-        lc := LogicalCloud{}
-        err = v.util.DBUnmarshal(value[0], &lc)
-        if err != nil {
-            return LogicalCloud{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        return lc, nil
-    }
-
-    return LogicalCloud{}, pkgerrors.New("Error getting Logical Cloud")
+	//Construct the composite key to select the entry
+	key := LogicalCloudKey{
+		Project:          project,
+		LogicalCloudName: logicalCloudName,
+	}
+	value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return LogicalCloud{}, pkgerrors.Wrap(err, "Get Logical Cloud")
+	}
+
+	//value is a byte array
+	if value != nil {
+		lc := LogicalCloud{}
+		err = v.util.DBUnmarshal(value[0], &lc)
+		if err != nil {
+			return LogicalCloud{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		return lc, nil
+	}
+
+	return LogicalCloud{}, pkgerrors.New("Error getting Logical Cloud")
 }
 
 // GetAll returns Logical Clouds in the project
 func (v *LogicalCloudClient) GetAll(project string) ([]LogicalCloud, error) {
 
-    //Construct the composite key to select the entry
-    key := LogicalCloudKey{
-        Project:            project,
-        LogicalCloudName:   "",
-    }
-
-    var resp []LogicalCloud
-    values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return []LogicalCloud{}, pkgerrors.Wrap(err, "Get Logical Clouds")
-    }
-
-    for _, value := range values {
-        lc := LogicalCloud{}
-        err = v.util.DBUnmarshal(value, &lc)
-        if err != nil {
-            return []LogicalCloud{}, pkgerrors.Wrap(err, "Unmarshaling values")
-        }
-        resp = append(resp, lc)
-    }
-
-    return resp, nil
+	//Construct the composite key to select the entry
+	key := LogicalCloudKey{
+		Project:          project,
+		LogicalCloudName: "",
+	}
+
+	var resp []LogicalCloud
+	values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return []LogicalCloud{}, pkgerrors.Wrap(err, "Get Logical Clouds")
+	}
+
+	for _, value := range values {
+		lc := LogicalCloud{}
+		err = v.util.DBUnmarshal(value, &lc)
+		if err != nil {
+			return []LogicalCloud{}, pkgerrors.Wrap(err, "Unmarshaling values")
+		}
+		resp = append(resp, lc)
+	}
+
+	return resp, nil
 }
 
 // Delete the Logical Cloud entry from database
 func (v *LogicalCloudClient) Delete(project, logicalCloudName string) error {
 
-    //Construct the composite key to select the entry
-    key := LogicalCloudKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloudName,
-    }
-    err := v.util.DBRemove(v.storeName, key)
-    if err != nil {
-        return pkgerrors.Wrap(err, "Delete Logical Cloud")
-    }
-
-    return nil
+	//Construct the composite key to select the entry
+	key := LogicalCloudKey{
+		Project:          project,
+		LogicalCloudName: logicalCloudName,
+	}
+	err := v.util.DBRemove(v.storeName, key)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete Logical Cloud")
+	}
+
+	return nil
 }
 
 // Update an entry for the Logical Cloud in the database
 func (v *LogicalCloudClient) Update(project, logicalCloudName string, c LogicalCloud) (LogicalCloud, error) {
 
-    key := LogicalCloudKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloudName,
-    }
-    // Check for mismatch, logicalCloudName and payload logical cloud name
-    if c.MetaData.LogicalCloudName != logicalCloudName {
-        return LogicalCloud{}, pkgerrors.New("Update Error - Logical Cloud name mismatch")
-    }
-    //Check if this Logical Cloud exists
-    _, err := v.Get(project, logicalCloudName)
-    if err != nil {
-        return LogicalCloud{}, pkgerrors.New("Update Error - Logical Cloud doesn't exist")
-    }
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return LogicalCloud{}, pkgerrors.Wrap(err, "Updating DB Entry")
-    }
-    return c, nil
+	key := LogicalCloudKey{
+		Project:          project,
+		LogicalCloudName: logicalCloudName,
+	}
+	// Check for mismatch, logicalCloudName and payload logical cloud name
+	if c.MetaData.LogicalCloudName != logicalCloudName {
+		return LogicalCloud{}, pkgerrors.New("Update Error - Logical Cloud name mismatch")
+	}
+	//Check if this Logical Cloud exists
+	_, err := v.Get(project, logicalCloudName)
+	if err != nil {
+		return LogicalCloud{}, pkgerrors.New("Update Error - Logical Cloud doesn't exist")
+	}
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return LogicalCloud{}, pkgerrors.Wrap(err, "Updating DB Entry")
+	}
+	return c, nil
 }
 
 func (d DBService) DBInsert(storeName string, key db.Key, query interface{}, meta string, c interface{}) error {
 
-    err := db.DBconn.Insert(storeName, key, nil, meta, c)
-    if err != nil {
-        return pkgerrors.Wrap(err, "Creating DB Entry")
-    }
+	err := db.DBconn.Insert(storeName, key, nil, meta, c)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Creating DB Entry")
+	}
 
-    return nil
+	return nil
 }
 
 func (d DBService) DBFind(storeName string, key db.Key, meta string) ([][]byte, error) {
 
-    value, err := db.DBconn.Find(storeName, key, meta)
-    if err != nil {
-        return [][]byte{}, pkgerrors.Wrap(err, "Get Resource")
-    }
+	value, err := db.DBconn.Find(storeName, key, meta)
+	if err != nil {
+		return [][]byte{}, pkgerrors.Wrap(err, "Get Resource")
+	}
 
-    return value, nil
+	return value, nil
 }
 
 func (d DBService) DBUnmarshal(value []byte, out interface{}) error {
 
-    err := db.DBconn.Unmarshal(value, out)
-    if err != nil {
-        return pkgerrors.Wrap(err, "Unmarshaling Value")
-    }
+	err := db.DBconn.Unmarshal(value, out)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Unmarshaling Value")
+	}
 
-    return nil
+	return nil
 }
 
 func (d DBService) DBRemove(storeName string, key db.Key) error {
 
-    err := db.DBconn.Remove(storeName, key)
-    if err != nil {
-        return pkgerrors.Wrap(err, "Delete Resource")
-    }
+	err := db.DBconn.Remove(storeName, key)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete Resource")
+	}
 
-    return nil
+	return nil
 }
 
 func (d DBService) CheckProject(project string) error {
-    // Check if project exists
-    _, err := module.NewProjectClient().GetProject(project)
-    if err != nil {
-        return pkgerrors.New("Unable to find the project")
-    }
+	// Check if project exists
+	_, err := module.NewProjectClient().GetProject(project)
+	if err != nil {
+		return pkgerrors.New("Unable to find the project")
+	}
 
-    return nil
+	return nil
 }
 
 func (d DBService) CheckLogicalCloud(project, logicalCloud string) error {
-    // Check if logical cloud exists
-    _, err := NewLogicalCloudClient().Get(project, logicalCloud)
-    if err != nil {
-        return pkgerrors.New("Unable to find the logical cloud")
-    }
+	// Check if logical cloud exists
+	_, err := NewLogicalCloudClient().Get(project, logicalCloud)
+	if err != nil {
+		return pkgerrors.New("Unable to find the logical cloud")
+	}
 
-    return nil
+	return nil
 }
diff --git a/src/dcm/pkg/module/logicalcloud_test.go b/src/dcm/pkg/module/logicalcloud_test.go
index 882cc292..fb205753 100644
--- a/src/dcm/pkg/module/logicalcloud_test.go
+++ b/src/dcm/pkg/module/logicalcloud_test.go
@@ -1,157 +1,156 @@
-package module

-

-import (

-  "fmt"

-  "testing"

-

-  "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"

-  "github.com/stretchr/testify/mock"

-  "github.com/pkg/errors"

-

-)

-

-type mockValues struct {

-  mock.Mock

-}

-

-func (m *mockValues) DBInsert(name string, key db.Key, query interface {}, meta string, c interface {}) error{

-    fmt.Println("Mocked Insert operation in Mongo")

-    args := m.Called(name, key, nil, meta, c)

-

-    return args.Error(0)

-}

-

-func (m *mockValues) DBFind(name string, key db.Key, meta string) ([][]byte, error) {

-    fmt.Println("Mocked Mongo DB Find Operation")

-    args := m.Called(name, key, meta)

-

-    return args.Get(0).([][]byte), args.Error(1)

-}

-

-func (m *mockValues) DBUnmarshal(value []byte, out interface{}) error {

-    fmt.Println("Mocked Mongo DB Unmarshal Operation")

-    args := m.Called(value)

-

-    return args.Error(0)

-}

-

-func (m *mockValues) DBRemove(name string, key db.Key) error {

-    fmt.Println("Mocked Mongo DB Remove operation")

-    args := m.Called(name, key)

-

-    return args.Error(0)

-}

-

-func (m *mockValues) CheckProject(project string) error {

-    fmt.Println("Mocked Check Project exists")

-    args := m.Called(project)

-

-    return args.Error(0)

-}

-

-func (m *mockValues) CheckLogicalCloud(project, logicalCloud string) error {

-    fmt.Println("Mocked Check Logical Cloud exists")

-    args := m.Called(project, logicalCloud)

-

-    return args.Error(0)

-}

-

-func TestCreateLogicalCloud(t *testing.T) {

-

-    mData := MetaDataList{

-        LogicalCloudName: "test_asdf",

-    }

-

-    lc := LogicalCloud {

-        MetaData:   mData,

-    }

-    data1 := [][]byte{}

-

-    key := LogicalCloudKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-    }

-    myMocks := new(mockValues)

-    // just to get an error value

-    err1 := errors.New("math: square root of negative number")

-

-    myMocks.On("CheckProject", "test_project").Return(nil)

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", lc).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)

-

-    lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}

-    _, err := lcClient.Create("test_project", lc)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestGetLogicalCloud(t *testing.T) {

-    key := LogicalCloudKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-    }

-

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}

-    _, err := lcClient.Get("test_project", "test_asdf")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestDeleteLogicalCloud(t *testing.T) {

-

-    key := LogicalCloudKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-    }

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBRemove", "test_dcm", key).Return(nil)

-

-    lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}

-    err := lcClient.Delete("test_project", "test_asdf")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-

-}

-

-func TestUpdateLogicalCloud(t *testing.T) {

-    key := LogicalCloudKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-    }

-    mData := MetaDataList{

-        LogicalCloudName: "test_asdf",

-    }

-    lc := LogicalCloud{

-        MetaData: mData,

-    }

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", lc).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}

-    _, err := lcClient.Update("test_project", "test_asdf", lc)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

+package module
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/mock"
+)
+
+type mockValues struct {
+	mock.Mock
+}
+
+func (m *mockValues) DBInsert(name string, key db.Key, query interface{}, meta string, c interface{}) error {
+	fmt.Println("Mocked Insert operation in Mongo")
+	args := m.Called(name, key, nil, meta, c)
+
+	return args.Error(0)
+}
+
+func (m *mockValues) DBFind(name string, key db.Key, meta string) ([][]byte, error) {
+	fmt.Println("Mocked Mongo DB Find Operation")
+	args := m.Called(name, key, meta)
+
+	return args.Get(0).([][]byte), args.Error(1)
+}
+
+func (m *mockValues) DBUnmarshal(value []byte, out interface{}) error {
+	fmt.Println("Mocked Mongo DB Unmarshal Operation")
+	args := m.Called(value)
+
+	return args.Error(0)
+}
+
+func (m *mockValues) DBRemove(name string, key db.Key) error {
+	fmt.Println("Mocked Mongo DB Remove operation")
+	args := m.Called(name, key)
+
+	return args.Error(0)
+}
+
+func (m *mockValues) CheckProject(project string) error {
+	fmt.Println("Mocked Check Project exists")
+	args := m.Called(project)
+
+	return args.Error(0)
+}
+
+func (m *mockValues) CheckLogicalCloud(project, logicalCloud string) error {
+	fmt.Println("Mocked Check Logical Cloud exists")
+	args := m.Called(project, logicalCloud)
+
+	return args.Error(0)
+}
+
+func TestCreateLogicalCloud(t *testing.T) {
+
+	mData := MetaDataList{
+		LogicalCloudName: "test_asdf",
+	}
+
+	lc := LogicalCloud{
+		MetaData: mData,
+	}
+	data1 := [][]byte{}
+
+	key := LogicalCloudKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+	}
+	myMocks := new(mockValues)
+	// just to get an error value
+	err1 := errors.New("math: square root of negative number")
+
+	myMocks.On("CheckProject", "test_project").Return(nil)
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", lc).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)
+
+	lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}
+	_, err := lcClient.Create("test_project", lc)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestGetLogicalCloud(t *testing.T) {
+	key := LogicalCloudKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+	}
+
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}
+	_, err := lcClient.Get("test_project", "test_asdf")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestDeleteLogicalCloud(t *testing.T) {
+
+	key := LogicalCloudKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+	}
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBRemove", "test_dcm", key).Return(nil)
+
+	lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}
+	err := lcClient.Delete("test_project", "test_asdf")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+
+}
+
+func TestUpdateLogicalCloud(t *testing.T) {
+	key := LogicalCloudKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+	}
+	mData := MetaDataList{
+		LogicalCloudName: "test_asdf",
+	}
+	lc := LogicalCloud{
+		MetaData: mData,
+	}
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", lc).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	lcClient := LogicalCloudClient{"test_dcm", "test_meta", myMocks}
+	_, err := lcClient.Update("test_project", "test_asdf", lc)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
diff --git a/src/dcm/pkg/module/module.go b/src/dcm/pkg/module/module.go
index 293f6dd5..70e348e7 100644
--- a/src/dcm/pkg/module/module.go
+++ b/src/dcm/pkg/module/module.go
@@ -18,22 +18,22 @@ package module
 
 // Client for using the services in the orchestrator
 type Client struct {
-    LogicalCloud    *LogicalCloudClient
-    Cluster         *ClusterClient
-    Quota           *QuotaClient
-    UserPermission  *UserPermissionClient
-    KeyValue        *KeyValueClient
-    // Add Clients for API's here
+	LogicalCloud   *LogicalCloudClient
+	Cluster        *ClusterClient
+	Quota          *QuotaClient
+	UserPermission *UserPermissionClient
+	KeyValue       *KeyValueClient
+	// Add Clients for API's here
 }
 
 // NewClient creates a new client for using the services
 func NewClient() *Client {
-    c := &Client{}
-    c.LogicalCloud = NewLogicalCloudClient()
-    c.Cluster = NewClusterClient()
-    c.Quota = NewQuotaClient()
-    c.UserPermission = NewUserPermissionClient()
-    c.KeyValue = NewKeyValueClient()
-    // Add Client API handlers here
-    return c
+	c := &Client{}
+	c.LogicalCloud = NewLogicalCloudClient()
+	c.Cluster = NewClusterClient()
+	c.Quota = NewQuotaClient()
+	c.UserPermission = NewUserPermissionClient()
+	c.KeyValue = NewKeyValueClient()
+	// Add Client API handlers here
+	return c
 }
diff --git a/src/dcm/pkg/module/quota.go b/src/dcm/pkg/module/quota.go
index 1a7012f6..cbd9c8b7 100644
--- a/src/dcm/pkg/module/quota.go
+++ b/src/dcm/pkg/module/quota.go
@@ -12,211 +12,210 @@
 * 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 module
 
 import (
-    pkgerrors "github.com/pkg/errors"
+	pkgerrors "github.com/pkg/errors"
 )
 
-// Quota contains the parameters needed for a Quota 
+// Quota contains the parameters needed for a Quota
 type Quota struct {
-    MetaData            QMetaDataList        `json:"metadata"`
-    Specification       QSpec                `json:"spec"`
+	MetaData      QMetaDataList `json:"metadata"`
+	Specification QSpec         `json:"spec"`
 }
 
-
 // MetaData contains the parameters needed for metadata
 type QMetaDataList struct {
-    QuotaName           string  `json:"name"`
-    Description         string  `json:"description"`
+	QuotaName   string `json:"name"`
+	Description string `json:"description"`
 }
 
 // Spec contains the parameters needed for spec
 type QSpec struct {
-    LimitsCPU                   string      `json:"limits.cpu"`
-    LimitsMemory                string      `json:"limits.memory"`
-    RequestsCPU                 string      `json:"requests.cpu"`
-    RequestsMemory              string      `json:"requests.memory"`
-    RequestsStorage             string      `json:"requests.storage"`
-    LimitsEphemeralStorage      string      `json:"limits.ephemeral.storage"`
-    PersistentVolumeClaims      string      `json:"persistentvolumeclaims"`
-    Pods                        string      `json:"pods"`
-    ConfigMaps                  string      `json:"configmaps"`
-    ReplicationControllers      string      `json:"replicationcontrollers"`
-    ResourceQuotas              string      `json:"resourcequotas"`
-    Services                    string      `json:"services"`
-    ServicesLoadBalancers       string      `json:"services.loadbalancers"`
-    ServicesNodePorts           string      `json:"services.nodeports"`
-    Secrets                     string      `json:"secrets"`
-    CountReplicationControllers string      `json:"count/replicationcontrollers"`
-    CountDeploymentsApps        string      `json:"count/deployments.apps"`
-    CountReplicasetsApps        string      `json:"count/replicasets.apps"`
-    CountStatefulSets           string      `json:"count/statefulsets.apps"`
-    CountJobsBatch              string      `json:"count/jobs.batch"`
-    CountCronJobsBatch          string      `json:"count/cronjobs.batch"`
-    CountDeploymentsExtensions  string      `json:"count/deployments.extensions"`
+	LimitsCPU                   string `json:"limits.cpu"`
+	LimitsMemory                string `json:"limits.memory"`
+	RequestsCPU                 string `json:"requests.cpu"`
+	RequestsMemory              string `json:"requests.memory"`
+	RequestsStorage             string `json:"requests.storage"`
+	LimitsEphemeralStorage      string `json:"limits.ephemeral.storage"`
+	PersistentVolumeClaims      string `json:"persistentvolumeclaims"`
+	Pods                        string `json:"pods"`
+	ConfigMaps                  string `json:"configmaps"`
+	ReplicationControllers      string `json:"replicationcontrollers"`
+	ResourceQuotas              string `json:"resourcequotas"`
+	Services                    string `json:"services"`
+	ServicesLoadBalancers       string `json:"services.loadbalancers"`
+	ServicesNodePorts           string `json:"services.nodeports"`
+	Secrets                     string `json:"secrets"`
+	CountReplicationControllers string `json:"count/replicationcontrollers"`
+	CountDeploymentsApps        string `json:"count/deployments.apps"`
+	CountReplicasetsApps        string `json:"count/replicasets.apps"`
+	CountStatefulSets           string `json:"count/statefulsets.apps"`
+	CountJobsBatch              string `json:"count/jobs.batch"`
+	CountCronJobsBatch          string `json:"count/cronjobs.batch"`
+	CountDeploymentsExtensions  string `json:"count/deployments.extensions"`
 }
 
 // QuotaKey is the key structure that is used in the database
 type QuotaKey struct {
-    Project             string      `json:"project"`
-    LogicalCloudName    string      `json:"logical-cloud-name"`
-    QuotaName           string      `json:"qname"`
+	Project          string `json:"project"`
+	LogicalCloudName string `json:"logical-cloud-name"`
+	QuotaName        string `json:"qname"`
 }
 
 // QuotaManager is an interface that exposes the connection
 // functionality
 type QuotaManager interface {
-    CreateQuota(project, logicalCloud string, c Quota) (Quota, error)
-    GetQuota(project, logicalCloud, name string) (Quota, error)
-    GetAllQuotas(project, logicalCloud string) ([]Quota, error)
-    DeleteQuota(project, logicalCloud, name string) error
-    UpdateQuota(project, logicalCloud, name string, c Quota) (Quota, error)
+	CreateQuota(project, logicalCloud string, c Quota) (Quota, error)
+	GetQuota(project, logicalCloud, name string) (Quota, error)
+	GetAllQuotas(project, logicalCloud string) ([]Quota, error)
+	DeleteQuota(project, logicalCloud, name string) error
+	UpdateQuota(project, logicalCloud, name string, c Quota) (Quota, error)
 }
 
 // QuotaClient implements the QuotaManager
 // It will also be used to maintain some localized state
 type QuotaClient struct {
-    storeName   string
-    tagMeta     string
-    util        Utility
+	storeName string
+	tagMeta   string
+	util      Utility
 }
 
 // QuotaClient returns an instance of the QuotaClient
 // which implements the QuotaManager
 func NewQuotaClient() *QuotaClient {
-    service := DBService{}
-    return &QuotaClient{
-        storeName:   "orchestrator",
-        tagMeta:     "quota",
-        util:       service,
-    }
+	service := DBService{}
+	return &QuotaClient{
+		storeName: "orchestrator",
+		tagMeta:   "quota",
+		util:      service,
+	}
 }
 
 // Create entry for the quota resource in the database
 func (v *QuotaClient) CreateQuota(project, logicalCloud string, c Quota) (Quota, error) {
 
-    //Construct key consisting of name
-    key := QuotaKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        QuotaName:          c.MetaData.QuotaName,
-    }
-
-    //Check if project exists
-    err := v.util.CheckProject(project)
-    if err != nil {
-        return Quota{}, pkgerrors.New("Unable to find the project")
-    }
-    //check if logical cloud exists
-    err = v.util.CheckLogicalCloud(project, logicalCloud)
-    if err != nil {
-        return Quota{}, pkgerrors.New("Unable to find the logical cloud")
-    }
-    //Check if this Quota already exists
-    _, err = v.GetQuota(project, logicalCloud, c.MetaData.QuotaName)
-    if err == nil {
-        return Quota{}, pkgerrors.New("Quota already exists")
-    }
-
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return Quota{}, pkgerrors.Wrap(err, "Creating DB Entry")
-    }
-
-    return c, nil
+	//Construct key consisting of name
+	key := QuotaKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		QuotaName:        c.MetaData.QuotaName,
+	}
+
+	//Check if project exists
+	err := v.util.CheckProject(project)
+	if err != nil {
+		return Quota{}, pkgerrors.New("Unable to find the project")
+	}
+	//check if logical cloud exists
+	err = v.util.CheckLogicalCloud(project, logicalCloud)
+	if err != nil {
+		return Quota{}, pkgerrors.New("Unable to find the logical cloud")
+	}
+	//Check if this Quota already exists
+	_, err = v.GetQuota(project, logicalCloud, c.MetaData.QuotaName)
+	if err == nil {
+		return Quota{}, pkgerrors.New("Quota already exists")
+	}
+
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return Quota{}, pkgerrors.Wrap(err, "Creating DB Entry")
+	}
+
+	return c, nil
 }
 
 // Get returns Quota for corresponding quota name
 func (v *QuotaClient) GetQuota(project, logicalCloud, quotaName string) (Quota, error) {
 
-    //Construct the composite key to select the entry
-    key := QuotaKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        QuotaName:          quotaName,
-    }
-    value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return Quota{}, pkgerrors.Wrap(err, "Quota")
-    }
-
-    //value is a byte array
-    if value != nil {
-        q := Quota{}
-        err = v.util.DBUnmarshal(value[0], &q)
-        if err != nil {
-            return Quota{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        return q, nil
-    }
-
-    return Quota{}, pkgerrors.New("Error getting Quota")
+	//Construct the composite key to select the entry
+	key := QuotaKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		QuotaName:        quotaName,
+	}
+	value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return Quota{}, pkgerrors.Wrap(err, "Quota")
+	}
+
+	//value is a byte array
+	if value != nil {
+		q := Quota{}
+		err = v.util.DBUnmarshal(value[0], &q)
+		if err != nil {
+			return Quota{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		return q, nil
+	}
+
+	return Quota{}, pkgerrors.New("Error getting Quota")
 }
 
 // GetAll returns all cluster quotas in the logical cloud
 func (v *QuotaClient) GetAllQuotas(project, logicalCloud string) ([]Quota, error) {
-    //Construct the composite key to select the entry
-    key := QuotaKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        QuotaName:          "",
-    }
-    var resp []Quota
-    values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return []Quota{}, pkgerrors.Wrap(err, "Get All Quotas")
-    }
-
-    for _, value := range values {
-        q := Quota{}
-        err = v.util.DBUnmarshal(value, &q)
-        if err != nil {
-            return []Quota{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        resp = append(resp, q)
-    }
-
-    return resp, nil
+	//Construct the composite key to select the entry
+	key := QuotaKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		QuotaName:        "",
+	}
+	var resp []Quota
+	values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return []Quota{}, pkgerrors.Wrap(err, "Get All Quotas")
+	}
+
+	for _, value := range values {
+		q := Quota{}
+		err = v.util.DBUnmarshal(value, &q)
+		if err != nil {
+			return []Quota{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		resp = append(resp, q)
+	}
+
+	return resp, nil
 }
 
 // Delete the Quota entry from database
 func (v *QuotaClient) DeleteQuota(project, logicalCloud, quotaName string) error {
-    //Construct the composite key to select the entry
-    key := QuotaKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        QuotaName:          quotaName,
-    }
-    err := v.util.DBRemove(v.storeName, key)
-    if err != nil {
-        return pkgerrors.Wrap(err, "Delete Quota")
-    }
-    return nil
+	//Construct the composite key to select the entry
+	key := QuotaKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		QuotaName:        quotaName,
+	}
+	err := v.util.DBRemove(v.storeName, key)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete Quota")
+	}
+	return nil
 }
 
 // Update an entry for the Quota in the database
 func (v *QuotaClient) UpdateQuota(project, logicalCloud, quotaName string, c Quota) (Quota, error) {
 
-    key := QuotaKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        QuotaName:          quotaName,
-    }
-    //Check quota URL name against the quota json name
-    if c.MetaData.QuotaName != quotaName {
-        return Quota{}, pkgerrors.New("Update Error - Quota name mismatch")
-    }
-    //Check if this Quota exists
-    _, err := v.GetQuota(project, logicalCloud, quotaName)
-    if err != nil {
-        return Quota{}, pkgerrors.New("Update Error - Quota doesn't exist")
-    }
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return Quota{}, pkgerrors.Wrap(err, "Updating DB Entry")
-    }
-    return c, nil
+	key := QuotaKey{
+		Project:          project,
+		LogicalCloudName: logicalCloud,
+		QuotaName:        quotaName,
+	}
+	//Check quota URL name against the quota json name
+	if c.MetaData.QuotaName != quotaName {
+		return Quota{}, pkgerrors.New("Update Error - Quota name mismatch")
+	}
+	//Check if this Quota exists
+	_, err := v.GetQuota(project, logicalCloud, quotaName)
+	if err != nil {
+		return Quota{}, pkgerrors.New("Update Error - Quota doesn't exist")
+	}
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return Quota{}, pkgerrors.Wrap(err, "Updating DB Entry")
+	}
+	return c, nil
 }
diff --git a/src/dcm/pkg/module/quota_test.go b/src/dcm/pkg/module/quota_test.go
index 87a60d71..5b70cf77 100644
--- a/src/dcm/pkg/module/quota_test.go
+++ b/src/dcm/pkg/module/quota_test.go
@@ -1,115 +1,112 @@
-package module

-

-import (

-    "testing"

-

-    "github.com/pkg/errors"

-

-)

-

-

-func TestCreateQuota(t *testing.T) {

-

-    mData := QMetaDataList{

-        QuotaName:  "test_quota",

-    }

-

-    q := Quota {

-        MetaData:   mData,

-    }

-    data1 := [][]byte{}

-

-

-    key := QuotaKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        QuotaName:          "test_quota",

-    }

-    myMocks := new(mockValues)

-    // just to get an error value

-    err1 := errors.New("math: square root of negative number")

-

-    myMocks.On("CheckProject", "test_project").Return(nil)

-    myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", q).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)

-

-    qClient := QuotaClient{"test_dcm", "test_meta", myMocks}

-    _, err := qClient.CreateQuota("test_project", "test_asdf", q)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestGetQuota(t *testing.T) {

-    key := QuotaKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        QuotaName:          "test_quota",

-    }

-

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    qClient := QuotaClient{"test_dcm", "test_meta", myMocks}

-    _, err := qClient.GetQuota("test_project", "test_asdf", "test_quota")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestDeleteQuota(t *testing.T) {

-

-    key := QuotaKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        QuotaName:          "test_quota",

-    }

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBRemove", "test_dcm", key).Return(nil)

-

-    qClient := QuotaClient{"test_dcm", "test_meta", myMocks}

-    err := qClient.DeleteQuota("test_project", "test_asdf", "test_quota")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-

-}

-

-func TestUpdateQuota(t *testing.T) {

-    key := QuotaKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        QuotaName:          "test_quota",

-    }

-    mData := QMetaDataList{

-        QuotaName:          "test_quota",

-    }

-    q := Quota{

-        MetaData: mData,

-    }

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", q).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    qClient := QuotaClient{"test_dcm", "test_meta", myMocks}

-    _, err := qClient.UpdateQuota("test_project", "test_asdf", "test_quota", q)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

+package module
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+)
+
+func TestCreateQuota(t *testing.T) {
+
+	mData := QMetaDataList{
+		QuotaName: "test_quota",
+	}
+
+	q := Quota{
+		MetaData: mData,
+	}
+	data1 := [][]byte{}
+
+	key := QuotaKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		QuotaName:        "test_quota",
+	}
+	myMocks := new(mockValues)
+	// just to get an error value
+	err1 := errors.New("math: square root of negative number")
+
+	myMocks.On("CheckProject", "test_project").Return(nil)
+	myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", q).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)
+
+	qClient := QuotaClient{"test_dcm", "test_meta", myMocks}
+	_, err := qClient.CreateQuota("test_project", "test_asdf", q)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestGetQuota(t *testing.T) {
+	key := QuotaKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		QuotaName:        "test_quota",
+	}
+
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	qClient := QuotaClient{"test_dcm", "test_meta", myMocks}
+	_, err := qClient.GetQuota("test_project", "test_asdf", "test_quota")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestDeleteQuota(t *testing.T) {
+
+	key := QuotaKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		QuotaName:        "test_quota",
+	}
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBRemove", "test_dcm", key).Return(nil)
+
+	qClient := QuotaClient{"test_dcm", "test_meta", myMocks}
+	err := qClient.DeleteQuota("test_project", "test_asdf", "test_quota")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+
+}
+
+func TestUpdateQuota(t *testing.T) {
+	key := QuotaKey{
+		Project:          "test_project",
+		LogicalCloudName: "test_asdf",
+		QuotaName:        "test_quota",
+	}
+	mData := QMetaDataList{
+		QuotaName: "test_quota",
+	}
+	q := Quota{
+		MetaData: mData,
+	}
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", q).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	qClient := QuotaClient{"test_dcm", "test_meta", myMocks}
+	_, err := qClient.UpdateQuota("test_project", "test_asdf", "test_quota", q)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
diff --git a/src/dcm/pkg/module/userpermissions.go b/src/dcm/pkg/module/userpermissions.go
index cf961a65..2cff712b 100644
--- a/src/dcm/pkg/module/userpermissions.go
+++ b/src/dcm/pkg/module/userpermissions.go
@@ -12,182 +12,183 @@
 * 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 module
 
 import (
-    pkgerrors "github.com/pkg/errors"
+	pkgerrors "github.com/pkg/errors"
 )
 
 // UserPermission contains the parameters needed for a user permission
 type UserPermission struct {
-    UserPermissionName      string          `json:"name"`
-    APIGroups               []string        `json:"apiGroups"`
-    Resources               []string        `json:"resources"`
-    Verbs                   []string        `json:"verbs"`
+	UserPermissionName string   `json:"name"`
+	APIGroups          []string `json:"apiGroups"`
+	Resources          []string `json:"resources"`
+	Verbs              []string `json:"verbs"`
 }
 
 // UserPermissionKey is the key structure that is used in the database
 type UserPermissionKey struct {
-    Project                 string      `json:"project"`
-    LogicalCloudName        string      `json:"logical-cloud-name"`
-    UserPermissionName      string      `json:"upname"`
+	Project            string `json:"project"`
+	LogicalCloudName   string `json:"logical-cloud-name"`
+	UserPermissionName string `json:"upname"`
 }
 
 // UserPermissionManager is an interface that exposes the connection
 // functionality
 type UserPermissionManager interface {
-    CreateUserPerm(project, logicalCloud string, c UserPermission) (UserPermission, error)
-    GetUserPerm(project, logicalCloud, name string) (UserPermission, error)
-    GetAllUserPerms(project, logicalCloud string) ([]UserPermission, error)
-    DeleteUserPerm(project, logicalCloud, name string) error
-    UpdateUserPerm(project, logicalCloud, name string, c UserPermission) (UserPermission, error)
+	CreateUserPerm(project, logicalCloud string, c UserPermission) (UserPermission, error)
+	GetUserPerm(project, logicalCloud, name string) (UserPermission, error)
+	GetAllUserPerms(project, logicalCloud string) ([]UserPermission, error)
+	DeleteUserPerm(project, logicalCloud, name string) error
+	UpdateUserPerm(project, logicalCloud, name string, c UserPermission) (UserPermission, error)
 }
 
 // UserPermissionClient implements the UserPermissionManager
 // It will also be used to maintain some localized state
 type UserPermissionClient struct {
-    storeName   string
-    tagMeta     string
-    util        Utility
+	storeName string
+	tagMeta   string
+	util      Utility
 }
 
 // UserPermissionClient returns an instance of the UserPermissionClient
 // which implements the UserPermissionManager
 func NewUserPermissionClient() *UserPermissionClient {
-    service := DBService{}
-    return &UserPermissionClient{
-        storeName:  "orchestrator",
-        tagMeta:    "userpermission",
-        util:       service,
-    }
+	service := DBService{}
+	return &UserPermissionClient{
+		storeName: "orchestrator",
+		tagMeta:   "userpermission",
+		util:      service,
+	}
 }
 
 // Create entry for the User Permission resource in the database
 func (v *UserPermissionClient) CreateUserPerm(project, logicalCloud string, c UserPermission) (UserPermission, error) {
 
-    //Construct key consisting of name
-    key := UserPermissionKey {
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        UserPermissionName: c.UserPermissionName,
-    }
-
-    //Check if project exists
-    err := v.util.CheckProject(project)
-    if err != nil {
-        return UserPermission{}, pkgerrors.New("Unable to find the project")
-    }
-    //check if logical cloud exists
-    err = v.util.CheckLogicalCloud(project, logicalCloud)
-    if err != nil {
-        return UserPermission{}, pkgerrors.New("Unable to find the logical cloud")
-    }
-
-    //Check if this User Permission already exists
-    _, err = v.GetUserPerm(project, logicalCloud, c.UserPermissionName)
-    if err == nil {
-        return UserPermission{}, pkgerrors.New("User Permission already exists")
-    }
-
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return UserPermission{}, pkgerrors.Wrap(err, "Creating DB Entry")
-    }
-
-    return c, nil
+	//Construct key consisting of name
+	key := UserPermissionKey{
+		Project:            project,
+		LogicalCloudName:   logicalCloud,
+		UserPermissionName: c.UserPermissionName,
+	}
+
+	//Check if project exists
+	err := v.util.CheckProject(project)
+	if err != nil {
+		return UserPermission{}, pkgerrors.New("Unable to find the project")
+	}
+	//check if logical cloud exists
+	err = v.util.CheckLogicalCloud(project, logicalCloud)
+	if err != nil {
+		return UserPermission{}, pkgerrors.New("Unable to find the logical cloud")
+	}
+
+	//Check if this User Permission already exists
+	_, err = v.GetUserPerm(project, logicalCloud, c.UserPermissionName)
+	if err == nil {
+		return UserPermission{}, pkgerrors.New("User Permission already exists")
+	}
+
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return UserPermission{}, pkgerrors.Wrap(err, "Creating DB Entry")
+	}
+
+	return c, nil
 }
 
 // Get returns User Permission for corresponding name
 func (v *UserPermissionClient) GetUserPerm(project, logicalCloud, userPermName string) (UserPermission, error) {
 
-    //Construct the composite key to select the entry
-    key := UserPermissionKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        UserPermissionName: userPermName,
-    }
-
-    value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return UserPermission{}, pkgerrors.Wrap(err, "Get User Permission")
-    }
-
-    //value is a byte array
-    if value != nil {
-        up := UserPermission{}
-        err = v.util.DBUnmarshal(value[0], &up)
-        if err != nil {
-            return UserPermission{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        return up, nil
-    }
-
-    return UserPermission{}, pkgerrors.New("Error getting User Permission")
+	//Construct the composite key to select the entry
+	key := UserPermissionKey{
+		Project:            project,
+		LogicalCloudName:   logicalCloud,
+		UserPermissionName: userPermName,
+	}
+
+	value, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return UserPermission{}, pkgerrors.Wrap(err, "Get User Permission")
+	}
+
+	//value is a byte array
+	if value != nil {
+		up := UserPermission{}
+		err = v.util.DBUnmarshal(value[0], &up)
+		if err != nil {
+			return UserPermission{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		return up, nil
+	}
+
+	return UserPermission{}, pkgerrors.New("Error getting User Permission")
 }
 
 // GetAll lists all user permissions
 func (v *UserPermissionClient) GetAllUserPerms(project, logicalCloud string) ([]UserPermission, error) {
-    //Construct the composite key to select the entry
-    key := UserPermissionKey {
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        UserPermissionName: "",
-    }
-    var resp  []UserPermission
-    values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
-    if err != nil {
-        return []UserPermission{}, pkgerrors.Wrap(err, "Get All User Permissions")
-    }
-
-    for _, value := range values {
-        up := UserPermission{}
-        err = v.util.DBUnmarshal(value, &up)
-        if err != nil {
-            return []UserPermission{}, pkgerrors.Wrap(err, "Unmarshaling value")
-        }
-        resp = append(resp, up)
-    }
-    return resp, nil
+	//Construct the composite key to select the entry
+	key := UserPermissionKey{
+		Project:            project,
+		LogicalCloudName:   logicalCloud,
+		UserPermissionName: "",
+	}
+	var resp []UserPermission
+	values, err := v.util.DBFind(v.storeName, key, v.tagMeta)
+	if err != nil {
+		return []UserPermission{}, pkgerrors.Wrap(err, "Get All User Permissions")
+	}
+
+	for _, value := range values {
+		up := UserPermission{}
+		err = v.util.DBUnmarshal(value, &up)
+		if err != nil {
+			return []UserPermission{}, pkgerrors.Wrap(err, "Unmarshaling value")
+		}
+		resp = append(resp, up)
+	}
+	return resp, nil
 }
+
 // Delete the User Permission entry from database
 func (v *UserPermissionClient) DeleteUserPerm(project, logicalCloud, userPermName string) error {
-    //Construct the composite key to select the entry
-    key := UserPermissionKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        UserPermissionName: userPermName,
-    }
-    err := v.util.DBRemove(v.storeName, key)
-        if err != nil {
-                return pkgerrors.Wrap(err, "Delete User Permission")
-        }
-        return nil
+	//Construct the composite key to select the entry
+	key := UserPermissionKey{
+		Project:            project,
+		LogicalCloudName:   logicalCloud,
+		UserPermissionName: userPermName,
+	}
+	err := v.util.DBRemove(v.storeName, key)
+	if err != nil {
+		return pkgerrors.Wrap(err, "Delete User Permission")
+	}
+	return nil
 }
 
 // Update an entry for the User Permission in the database
 func (v *UserPermissionClient) UpdateUserPerm(project, logicalCloud, userPermName string, c UserPermission) (
-    UserPermission, error) {
-
-    key := UserPermissionKey{
-        Project:            project,
-        LogicalCloudName:   logicalCloud,
-        UserPermissionName: userPermName,
-    }
-    //Check for URL name and json permission name mismatch
-    if c.UserPermissionName != userPermName {
-        return UserPermission{}, pkgerrors.New("Update Error - Permission name mismatch")
-    }
-    //Check if this User Permission exists
-    _, err := v.GetUserPerm(project, logicalCloud, userPermName)
-    if err != nil {
-        return UserPermission{}, pkgerrors.New(
-            "Update Error - User Permission doesn't exist")
-    }
-    err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
-    if err != nil {
-        return UserPermission{}, pkgerrors.Wrap(err, "Updating DB Entry")
-    }
-    return c, nil
+	UserPermission, error) {
+
+	key := UserPermissionKey{
+		Project:            project,
+		LogicalCloudName:   logicalCloud,
+		UserPermissionName: userPermName,
+	}
+	//Check for URL name and json permission name mismatch
+	if c.UserPermissionName != userPermName {
+		return UserPermission{}, pkgerrors.New("Update Error - Permission name mismatch")
+	}
+	//Check if this User Permission exists
+	_, err := v.GetUserPerm(project, logicalCloud, userPermName)
+	if err != nil {
+		return UserPermission{}, pkgerrors.New(
+			"Update Error - User Permission doesn't exist")
+	}
+	err = v.util.DBInsert(v.storeName, key, nil, v.tagMeta, c)
+	if err != nil {
+		return UserPermission{}, pkgerrors.Wrap(err, "Updating DB Entry")
+	}
+	return c, nil
 }
diff --git a/src/dcm/pkg/module/userpermissions_test.go b/src/dcm/pkg/module/userpermissions_test.go
index f134aa0f..5ada2303 100644
--- a/src/dcm/pkg/module/userpermissions_test.go
+++ b/src/dcm/pkg/module/userpermissions_test.go
@@ -1,110 +1,108 @@
-package module

-

-import (

-    "testing"

-

-    "github.com/pkg/errors"

-

-)

-

-

-func TestCreateUserPerm(t *testing.T) {

-

-    up := UserPermission {

-        UserPermissionName: "test_user_perm",

-    }

-    data1 := [][]byte{}

-

-   // data2 := []byte("abc")

-

-    key := UserPermissionKey{

-        Project:                "test_project",

-        LogicalCloudName:       "test_asdf",

-        UserPermissionName:     "test_user_perm",

-    }

-    myMocks := new(mockValues)

-    // just to get an error value

-    err1 := errors.New("math: square root of negative number")

-

-    myMocks.On("CheckProject", "test_project").Return(nil)

-    myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", up).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)

-   // myMocks.On("DBUnmarshal", data2).Return(nil)

-

-    upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}

-    _, err := upClient.CreateUserPerm("test_project", "test_asdf", up)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestGetUserPerm(t *testing.T) {

-    key := UserPermissionKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        UserPermissionName: "test_user_perm",

-    }

-

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}

-    _, err := upClient.GetUserPerm("test_project", "test_asdf", "test_user_perm")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

-

-func TestDeleteUserPerm(t *testing.T) {

-

-    key := UserPermissionKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        UserPermissionName: "test_user_perm",

-    }

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBRemove", "test_dcm", key).Return(nil)

-

-    upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}

-    err := upClient.DeleteUserPerm("test_project", "test_asdf", "test_user_perm")

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-

-}

-

-func TestUpdateUserPerm(t *testing.T) {

-    key := UserPermissionKey{

-        Project:            "test_project",

-        LogicalCloudName:   "test_asdf",

-        UserPermissionName: "test_user_perm",

-    }

-    up := UserPermission{

-        UserPermissionName: "test_user_perm",

-    }

-    data1 := [][]byte{

-        []byte("abc"),

-    }

-    data2 := []byte("abc")

-

-    myMocks := new(mockValues)

-

-    myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", up).Return(nil)

-    myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)

-    myMocks.On("DBUnmarshal", data2).Return(nil)

-    upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}

-    _, err := upClient.UpdateUserPerm("test_project", "test_asdf", "test_user_perm", up)

-    if err != nil {

-        t.Errorf("Some error occured!")

-    }

-}

+package module
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+)
+
+func TestCreateUserPerm(t *testing.T) {
+
+	up := UserPermission{
+		UserPermissionName: "test_user_perm",
+	}
+	data1 := [][]byte{}
+
+	// data2 := []byte("abc")
+
+	key := UserPermissionKey{
+		Project:            "test_project",
+		LogicalCloudName:   "test_asdf",
+		UserPermissionName: "test_user_perm",
+	}
+	myMocks := new(mockValues)
+	// just to get an error value
+	err1 := errors.New("math: square root of negative number")
+
+	myMocks.On("CheckProject", "test_project").Return(nil)
+	myMocks.On("CheckLogicalCloud", "test_project", "test_asdf").Return(nil)
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", up).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, err1)
+	// myMocks.On("DBUnmarshal", data2).Return(nil)
+
+	upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}
+	_, err := upClient.CreateUserPerm("test_project", "test_asdf", up)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestGetUserPerm(t *testing.T) {
+	key := UserPermissionKey{
+		Project:            "test_project",
+		LogicalCloudName:   "test_asdf",
+		UserPermissionName: "test_user_perm",
+	}
+
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}
+	_, err := upClient.GetUserPerm("test_project", "test_asdf", "test_user_perm")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
+
+func TestDeleteUserPerm(t *testing.T) {
+
+	key := UserPermissionKey{
+		Project:            "test_project",
+		LogicalCloudName:   "test_asdf",
+		UserPermissionName: "test_user_perm",
+	}
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBRemove", "test_dcm", key).Return(nil)
+
+	upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}
+	err := upClient.DeleteUserPerm("test_project", "test_asdf", "test_user_perm")
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+
+}
+
+func TestUpdateUserPerm(t *testing.T) {
+	key := UserPermissionKey{
+		Project:            "test_project",
+		LogicalCloudName:   "test_asdf",
+		UserPermissionName: "test_user_perm",
+	}
+	up := UserPermission{
+		UserPermissionName: "test_user_perm",
+	}
+	data1 := [][]byte{
+		[]byte("abc"),
+	}
+	data2 := []byte("abc")
+
+	myMocks := new(mockValues)
+
+	myMocks.On("DBInsert", "test_dcm", key, nil, "test_meta", up).Return(nil)
+	myMocks.On("DBFind", "test_dcm", key, "test_meta").Return(data1, nil)
+	myMocks.On("DBUnmarshal", data2).Return(nil)
+	upClient := UserPermissionClient{"test_dcm", "test_meta", myMocks}
+	_, err := upClient.UpdateUserPerm("test_project", "test_asdf", "test_user_perm", up)
+	if err != nil {
+		t.Errorf("Some error occured!")
+	}
+}
diff --git a/src/dcm/test/dcm_call_api.sh b/src/dcm/test/dcm_call_api.sh
index 3bf27524..966bc3d6 100755
--- a/src/dcm/test/dcm_call_api.sh
+++ b/src/dcm/test/dcm_call_api.sh
@@ -15,11 +15,24 @@
 #  */
 
 
+dcm_addr="http://localhost:9077"
+
+# parameters
 project="test-project"
 description="test-description"
 logical_cloud_name="lc1"
-logical_cloud_url="http://localhost:9015/v2/projects/${project}/logical-clouds"
+namespace="ns1"
+user="user-1"
+permission="permission-1"
+cluster_provider_name="cp-1"
+cluster_1_name="c1"
+cluster_1_name="c2"
+lc_cluster_1_name="lc-cl-1"
+lc_cluster_2_name="lc-cl-2"
 quota_name="quota-1"
+
+# endpoints
+logical_cloud_url="$dcm_addr/v2/projects/${project}/logical-clouds"
 quota_url="${logical_cloud_url}/${logical_cloud_name}/cluster-quotas"
 cluster_url="${logical_cloud_url}/${logical_cloud_name}/cluster-references"
 
@@ -28,17 +41,17 @@ logical_cloud_data="$(cat << EOF
 {
  "metadata" : {
     "name": "${logical_cloud_name}",
-    "description": "${test-description}",
+    "description": "${description}",
     "userData1":"<user data>",
     "userData2":"<user data>"
    },
  "spec" : {
-    "namespace" : "ns-1",
+    "namespace" : "${namespace}",
     "user" : {
-    "user-name" : "user-1",
+    "user-name" : "${user}",
     "type" : "certificate",
     "user-permissions" : [
-       { "permission-name" : "permission-1",
+       { "permission-name" : "${permission}",
          "apiGroups" : ["stable.example.com"],
          "resources" : ["secrets", "pods"],
          "verbs" : ["get", "watch", "list", "create"]
@@ -53,15 +66,15 @@ EOF
 cluster_1_data="$(cat << EOF
 {
  "metadata" : {
-    "name": "lc-cl-1",
-    "description": "${test-description}",
+    "name": "${lc_cluster_1_name}",
+    "description": "${description}",
     "userData1":"<user data>",
     "userData2":"<user data>"
    },
 
  "spec" : {
-    "cluster-provider": "cp-1",
-    "cluster-name": "c1",
+    "cluster-provider": "${cluster_provider_name}",
+    "cluster-name": "${cluster_1_name}",
     "loadbalancer-ip" : "0.0.0.0"
   }
 }
@@ -71,26 +84,47 @@ EOF
 cluster_2_data="$(cat << EOF
 {
  "metadata" : {
-    "name": "lc-cl-2",
-    "description": "${test-description}",
+    "name": "${lc_cluster_2_name}",
+    "description": "${description}",
     "userData1":"<user data>",
     "userData2":"<user data>"
    },
 
  "spec" : {
-    "cluster-provider": "cp-1",
-    "cluster-name": "c2",
+    "cluster-provider": "${cluster_provider_name}",
+    "cluster-name": "${cluster_2_name}",
     "loadbalancer-ip" : "0.0.0.1"
   }
 }
 EOF
 )"
 
+# removed all special chars from quota spec keys
+# due to loss of data when unmarshalling from json
 quota_data="$(cat << EOF
 {
     "metadata" : {
       "name" : "${quota_name}",
-      "description": "${test-description}"
+      "description": "${description}"
+     },
+    "spec" : {
+      "persistentvolumeclaims" : "10",
+      "pods": "500",
+      "configmaps" : "10",
+      "replicationcontrollers": "10",
+      "resourcequotas" : "10",
+      "services": "10",
+      "secrets" : "10"
+     }
+}
+EOF
+)"
+
+quota_data_original="$(cat << EOF
+{
+    "metadata" : {
+      "name" : "${quota_name}",
+      "description": "${description}"
      },
     "spec" : {
       "limits.cpu": "400",
@@ -143,5 +177,24 @@ curl -X GET "${logical_cloud_url}/${logical_cloud_name}"
 printf "\n\nGetting clusters info for logical cloud\n\n"
 curl -X GET ${cluster_url}
 
+printf "\n\nGetting first cluster of logical cloud\n"
+curl -X GET ${cluster_url}/${lc_cluster_1_name}
+
+printf "\n\nGetting second cluster of logical cloud\n"
+curl -X GET ${cluster_url}/${lc_cluster_2_name}
+
 printf "\n\nGetting Quota info for the logical cloud\n\n"
-curl -X GET "${quota_url}/${quota_name}"
\ No newline at end of file
+curl -X GET "${quota_url}/${quota_name}"
+
+# Cleanup (delete created resources)
+if [ "$1" == "clean" ]; then
+    printf "\n\nDeleting Quota info for the logical cloud\n\n"
+    curl -X DELETE "${quota_url}/${quota_name}"
+
+    printf "\n\nDeleting the two clusters from logical cloud\n\n"
+    curl -X DELETE ${cluster_url}/${lc_cluster_1_name}
+    curl -X DELETE ${cluster_url}/${lc_cluster_2_name}
+
+    printf "\n\nDeleting logical cloud data\n\n"
+    curl -X DELETE ${logical_cloud_url}/${logical_cloud_name}
+fi