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
}
* 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
}
-/*\r
-* Copyright 2020 Intel Corporation, Inc\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*/\r
-\r
-package module\r
-\r
-import (\r
- "strings"\r
- "fmt"\r
- "crypto/rsa"\r
- "crypto/rand"\r
- "crypto/x509"\r
- "crypto/x509/pkix"\r
- "encoding/json"\r
- "encoding/pem"\r
- "encoding/base64"\r
- "github.com/onap/multicloud-k8s/src/orchestrator/pkg/appcontext"\r
- log "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/logutils"\r
- "gopkg.in/yaml.v2"\r
- pkgerrors "github.com/pkg/errors"\r
-\r
-)\r
-\r
-type Resource struct {\r
- ApiVersion string `yaml:"apiVersion"`\r
- Kind string `yaml:"kind"`\r
- MetaData MetaDatas `yaml:"metadata"`\r
- Specification Specs `yaml:"spec,omitempty"`\r
- Rules []RoleRules `yaml:"rules,omitempty"`\r
- Subjects []RoleSubjects `yaml:"subjects,omitempty"`\r
- RoleRefs RoleRef `yaml:"roleRef,omitempty"`\r
-}\r
-\r
-type MetaDatas struct {\r
- Name string `yaml:"name"`\r
- Namespace string `yaml:"namespace,omitempty"`\r
-}\r
-\r
-type Specs struct {\r
- Request string `yaml:"request,omitempty"`\r
- Usages []string `yaml:"usages,omitempty"`\r
- //Hard logicalcloud.QSpec `yaml:"hard,omitempty"`\r
- Hard QSpec `yaml:"hard,omitempty"`\r
-}\r
-\r
-type RoleRules struct {\r
- ApiGroups []string `yaml:"apiGroups"`\r
- Resources []string `yaml:"resources"`\r
- Verbs []string `yaml:"verbs"`\r
-}\r
-\r
-type RoleSubjects struct {\r
- Kind string `yaml:"kind"`\r
- Name string `yaml:"name"`\r
- ApiGroup string `yaml:"apiGroup"`\r
-}\r
-\r
-type RoleRef struct {\r
- Kind string `yaml:"kind"`\r
- Name string `yaml:"name"`\r
- ApiGroup string `yaml:"apiGroup"`\r
-}\r
-\r
-\r
-func createNamespace(logicalcloud LogicalCloud) (string, error) {\r
-\r
- namespace := Resource{\r
- ApiVersion: "v1",\r
- Kind: "Namespace",\r
- MetaData: MetaDatas{\r
- Name: logicalcloud.Specification.NameSpace,\r
- },\r
- }\r
-\r
- nsData, err := yaml.Marshal(&namespace)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
-\r
- return string(nsData), nil\r
-}\r
-\r
-func createRole(logicalcloud LogicalCloud) (string, error) {\r
-\r
- userPermissions := logicalcloud.Specification.User.UserPermissions[0]\r
- \r
- role := Resource{\r
- ApiVersion: "rbac.authorization.k8s.io/v1beta1",\r
- Kind: "Role",\r
- MetaData: MetaDatas{\r
- Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-role"}, ""),\r
- Namespace: logicalcloud.Specification.NameSpace,\r
- },\r
- Rules: []RoleRules{ RoleRules{\r
- ApiGroups: userPermissions.APIGroups,\r
- Resources: userPermissions.Resources,\r
- Verbs: userPermissions.Verbs,\r
- },\r
- },\r
-\r
- }\r
-\r
- roleData, err := yaml.Marshal(&role)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
- return string(roleData), nil\r
-}\r
-\r
-func createRoleBinding(logicalcloud LogicalCloud) (string, error) {\r
-\r
- roleBinding := Resource{\r
- ApiVersion: "rbac.authorization.k8s.io/v1beta1",\r
- Kind: "RoleBinding",\r
- MetaData: MetaDatas{\r
- Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-roleBinding"}, ""),\r
- Namespace: logicalcloud.Specification.NameSpace,\r
- },\r
- Subjects: []RoleSubjects{ RoleSubjects{\r
- Kind: "User",\r
- Name: logicalcloud.Specification.User.UserName,\r
- ApiGroup: "",\r
- },\r
- },\r
-\r
- RoleRefs: RoleRef{\r
- Kind: "Role",\r
- Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-role"}, ""),\r
- ApiGroup: "",\r
- },\r
- }\r
-\r
- rBData, err := yaml.Marshal(&roleBinding)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
-\r
- return string(rBData), nil\r
-\r
-}\r
-\r
-func createQuota(quota []Quota, namespace string) (string, error) {\r
- lcQuota := quota[0]\r
-\r
- q := Resource{\r
- ApiVersion: "v1",\r
- Kind: "ResourceQuota",\r
- MetaData: MetaDatas{\r
- Name: lcQuota.MetaData.QuotaName,\r
- Namespace: namespace,\r
- },\r
- Specification: Specs{\r
- Hard: lcQuota.Specification,\r
- },\r
- }\r
-\r
- qData, err := yaml.Marshal(&q)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
-\r
-\r
- return string(qData), nil\r
-\r
-}\r
-\r
-func createUserCSR(logicalcloud LogicalCloud) (string, error) {\r
- KEYSIZE := 4096\r
- userName := logicalcloud.Specification.User.UserName\r
-\r
- key, err := rsa.GenerateKey(rand.Reader, KEYSIZE)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
- csrTemplate := x509.CertificateRequest{Subject: pkix.Name{CommonName: userName,},\r
- }\r
-\r
- csrCert, err := x509.CreateCertificateRequest(rand.Reader, &csrTemplate, key)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
- //Encode csr\r
- csr := pem.EncodeToMemory(&pem.Block{\r
- Type: "CERTIFICATE REQUEST",\r
- Bytes: csrCert,\r
- })\r
-\r
- csrObj := Resource{\r
- ApiVersion: "certificates.k8s.io/v1beta1",\r
- Kind: "CertificateSigningRequest",\r
- MetaData: MetaDatas{\r
- Name: strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "-user-csr"}, ""),\r
- Namespace: logicalcloud.Specification.NameSpace,\r
- },\r
- Specification: Specs{\r
- Request: base64.StdEncoding.EncodeToString(csr),\r
- Usages: []string{"digital signature", "key encipherment"},\r
- },\r
- }\r
-\r
- csrData, err := yaml.Marshal(&csrObj)\r
- if err != nil {\r
- return "", err\r
- }\r
-\r
-\r
- return string(csrData), nil\r
-\r
-\r
-}\r
-\r
-// TODO:\r
-// Install istio\r
-// Store user key for user creation\r
-// Code to run kubectl commands for user\r
-// kubectl certificate approve lc1-user-cert\r
-// kubectl get csr lc1-user-cert -o jsonpath='{.status.certificate}' | base64 --decode > user.crt\r
-// kubectl config set-credentials user --client-certificate=<user.crt> --client-key=<user.key>\r
-// kubectl config set-context user-context --cluster=cluster-name --namespace=lc1 --user=user\r
-\r
-\r
-func CreateEtcdContext(logicalcloud LogicalCloud, clusterList []Cluster,\r
- quotaList []Quota ) error {\r
-\r
- APP := "logical-cloud"\r
- logicalCloudName := logicalcloud.MetaData.LogicalCloudName\r
-\r
-\r
- //Resource Names\r
- namespaceName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+namespace"}, "")\r
- roleName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+role"}, "")\r
- roleBindingName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+roleBinding"}, "")\r
- quotaName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+quota"}, "")\r
- csrName := strings.Join([]string{logicalcloud.MetaData.LogicalCloudName, "+CertificateSigningRequest"}, "")\r
-\r
- // Get resources to be added\r
- namespace, err := createNamespace(logicalcloud)\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error Creating Namespace YAML for logical cloud")\r
- }\r
-\r
- role, err := createRole(logicalcloud)\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error Creating Role YAML for logical cloud")\r
- }\r
-\r
- roleBinding, err := createRoleBinding(logicalcloud)\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error Creating RoleBinding YAML for logical cloud")\r
- }\r
-\r
- quota, err := createQuota(quotaList, logicalcloud.Specification.NameSpace)\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error Creating Quota YAML for logical cloud")\r
- }\r
-\r
- csr, err := createUserCSR(logicalcloud)\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error Creating User CSR for logical cloud")\r
- }\r
-\r
-\r
- context := appcontext.AppContext{}\r
- ctxVal, err := context.InitAppContext()\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error creating AppContext")\r
- }\r
-\r
- fmt.Printf("%v\n", ctxVal)\r
-\r
- handle, err := context.CreateCompositeApp()\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error creating AppContext CompositeApp")\r
- }\r
-\r
-\r
- appHandle, err := context.AddApp(handle, APP)\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext CompositeApp create failure", log.Fields{\r
- "logical-cloud": logicalCloudName,\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding App to AppContext")\r
- }\r
-\r
-\r
- // Iterate through cluster list and add all the clusters\r
- for _, cluster:= range clusterList {\r
- clusterName := strings.Join([]string{cluster.Specification.ClusterProvider, "+", cluster.Specification.ClusterName, }, "")\r
- clusterHandle, err := context.AddCluster(appHandle, clusterName)\r
-\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add cluster failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding Cluster to AppContext")\r
- }\r
-\r
- // Add namespace resource to each cluster\r
- _, err = context.AddResource(clusterHandle, namespaceName, namespace)\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add namespace resource failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding Namespace Resource to AppContext")\r
- }\r
-\r
- // Add csr resource to each cluster\r
- _, err = context.AddResource(clusterHandle, csrName, csr)\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add CSR resource failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding CSR Resource to AppContext")\r
- }\r
-\r
-\r
-\r
- // Add Role resource to each cluster\r
- _, err = context.AddResource(clusterHandle, roleName, role)\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add role resource failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding role Resource to AppContext")\r
- }\r
-\r
- // Add RoleBinding resource to each cluster\r
- _, err = context.AddResource(clusterHandle, roleBindingName, roleBinding)\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add roleBinding resource failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding roleBinding Resource to AppContext")\r
- }\r
-\r
- // Add quota resource to each cluster\r
- _, err = context.AddResource(clusterHandle, quotaName, quota)\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add quota resource failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding quota Resource to AppContext")\r
- }\r
-\r
- // Add Resource Order and Resource Dependency\r
- resOrder, err := json.Marshal(map[string][]string{"resorder" : []string{namespaceName, quotaName, csrName, roleName, roleBindingName}})\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error creating resource order JSON")\r
- }\r
-\r
- resDependency, err := json.Marshal(map[string]map[string]string{"resdependency" : map[string]string{namespaceName : "go",\r
- quotaName : strings.Join([]string{"wait on ", namespaceName}, ""), csrName: strings.Join([]string{"wait on ", quotaName}, ""),\r
- roleName : strings.Join([]string{"wait on ", csrName}, ""), roleBindingName: strings.Join([]string{"wait on ", roleName}, ""),}})\r
-\r
- if err != nil {\r
- return pkgerrors.Wrap(err, "Error creating resource dependency JSON")\r
- }\r
-\r
- _, err = context.AddInstruction(clusterHandle, "resource", "order", string(resOrder))\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add instruction failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding instruction order to AppContext")\r
- }\r
-\r
- _, err = context.AddInstruction(clusterHandle, "resource", "dependency", string(resDependency))\r
- if err != nil {\r
- cleanuperr := context.DeleteCompositeApp()\r
- if cleanuperr != nil {\r
- log.Warn("Error cleaning AppContext after add instruction failure", log.Fields{\r
- "cluster-provider": cluster.Specification.ClusterProvider,\r
- "cluster": cluster.Specification.ClusterName,\r
- "logical-cloud": logicalCloudName,\r
-\r
- })\r
- }\r
- return pkgerrors.Wrap(err, "Error adding instruction dependency to AppContext")\r
- }\r
-\r
-\r
-\r
- }\r
-\r
- return nil\r
-\r
-\r
-}\r
+/*
+* 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
+
+}
* 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
}
Code Review / multicloud / k8s.git / commitdiff