src/ncm/api/netcontrolintenthandler.go

   1 /*
   2  * Copyright 2020 Intel Corporation, Inc
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package api
  18
  19 import (
  20         "encoding/json"
  21         "fmt"
  22         "io"
  23         "net/http"
  24
  25         moduleLib "github.com/onap/multicloud-k8s/src/ncm/pkg/module"
  26         pkgerrors "github.com/pkg/errors"
  27
  28         "github.com/gorilla/mux"
  29 )
  30
  31 // Used to store backend implementations objects
  32 // Also simplifies mocking for unit testing purposes
  33 type netcontrolintentHandler struct {
  34         // Interface that implements Cluster operations
  35         // We will set this variable with a mock interface for testing
  36         client moduleLib.NetControlIntentManager
  37 }
  38
  39 // Check for valid format of input parameters
  40 func validateNetControlIntentInputs(nci moduleLib.NetControlIntent) error {
  41         // validate metadata
  42         err := moduleLib.IsValidMetadata(nci.Metadata)
  43         if err != nil {
  44                 return pkgerrors.Wrap(err, "Invalid network controller intent metadata")
  45         }
  46         return nil
  47 }
  48
  49 // Create handles creation of the NetControlIntent entry in the database
  50 func (h netcontrolintentHandler) createHandler(w http.ResponseWriter, r *http.Request) {
  51         var nci moduleLib.NetControlIntent
  52         vars := mux.Vars(r)
  53         project := vars["project"]
  54         compositeApp := vars["composite-app-name"]
  55         compositeAppVersion := vars["version"]
  56
  57         err := json.NewDecoder(r.Body).Decode(&nci)
  58
  59         switch {
  60         case err == io.EOF:
  61                 http.Error(w, "Empty body", http.StatusBadRequest)
  62                 return
  63         case err != nil:
  64                 http.Error(w, err.Error(), http.StatusUnprocessableEntity)
  65                 return
  66         }
  67
  68         // Name is required.
  69         if nci.Metadata.Name == "" {
  70                 http.Error(w, "Missing name in POST request", http.StatusBadRequest)
  71                 return
  72         }
  73
  74         err = validateNetControlIntentInputs(nci)
  75         if err != nil {
  76                 http.Error(w, err.Error(), http.StatusBadRequest)
  77                 return
  78         }
  79
  80         ret, err := h.client.CreateNetControlIntent(nci, project, compositeApp, compositeAppVersion, false)
  81         if err != nil {
  82                 http.Error(w, err.Error(), http.StatusInternalServerError)
  83                 return
  84         }
  85
  86         w.Header().Set("Content-Type", "application/json")
  87         w.WriteHeader(http.StatusCreated)
  88         err = json.NewEncoder(w).Encode(ret)
  89         if err != nil {
  90                 http.Error(w, err.Error(), http.StatusInternalServerError)
  91                 return
  92         }
  93 }
  94
  95 // Put handles creation/update of the NetControlIntent entry in the database
  96 func (h netcontrolintentHandler) putHandler(w http.ResponseWriter, r *http.Request) {
  97         var nci moduleLib.NetControlIntent
  98         vars := mux.Vars(r)
  99         name := vars["name"]
 100         project := vars["project"]
 101         compositeApp := vars["composite-app-name"]
 102         compositeAppVersion := vars["version"]
 103
 104         err := json.NewDecoder(r.Body).Decode(&nci)
 105
 106         switch {
 107         case err == io.EOF:
 108                 http.Error(w, "Empty body", http.StatusBadRequest)
 109                 return
 110         case err != nil:
 111                 http.Error(w, err.Error(), http.StatusUnprocessableEntity)
 112                 return
 113         }
 114
 115         // Name is required.
 116         if nci.Metadata.Name == "" {
 117                 http.Error(w, "Missing name in PUT request", http.StatusBadRequest)
 118                 return
 119         }
 120
 121         // Name in URL should match name in body
 122         if nci.Metadata.Name != name {
 123                 fmt.Printf("bodyname = %v, name= %v\n", nci.Metadata.Name, name)
 124                 http.Error(w, "Mismatched name in PUT request", http.StatusBadRequest)
 125                 return
 126         }
 127
 128         err = validateNetControlIntentInputs(nci)
 129         if err != nil {
 130                 http.Error(w, err.Error(), http.StatusBadRequest)
 131                 return
 132         }
 133
 134         ret, err := h.client.CreateNetControlIntent(nci, project, compositeApp, compositeAppVersion, true)
 135         if err != nil {
 136                 http.Error(w, err.Error(), http.StatusInternalServerError)
 137                 return
 138         }
 139
 140         w.Header().Set("Content-Type", "application/json")
 141         w.WriteHeader(http.StatusCreated)
 142         err = json.NewEncoder(w).Encode(ret)
 143         if err != nil {
 144                 http.Error(w, err.Error(), http.StatusInternalServerError)
 145                 return
 146         }
 147 }
 148
 149 // Get handles GET operations on a particular NetControlIntent Name
 150 // Returns a NetControlIntent
 151 func (h netcontrolintentHandler) getHandler(w http.ResponseWriter, r *http.Request) {
 152         vars := mux.Vars(r)
 153         name := vars["name"]
 154         project := vars["project"]
 155         compositeApp := vars["composite-app-name"]
 156         compositeAppVersion := vars["version"]
 157         var ret interface{}
 158         var err error
 159
 160         if len(name) == 0 {
 161                 ret, err = h.client.GetNetControlIntents(project, compositeApp, compositeAppVersion)
 162                 if err != nil {
 163                         http.Error(w, err.Error(), http.StatusInternalServerError)
 164                         return
 165                 }
 166         } else {
 167                 ret, err = h.client.GetNetControlIntent(name, project, compositeApp, compositeAppVersion)
 168                 if err != nil {
 169                         http.Error(w, err.Error(), http.StatusInternalServerError)
 170                         return
 171                 }
 172         }
 173
 174         w.Header().Set("Content-Type", "application/json")
 175         w.WriteHeader(http.StatusOK)
 176         err = json.NewEncoder(w).Encode(ret)
 177         if err != nil {
 178                 http.Error(w, err.Error(), http.StatusInternalServerError)
 179                 return
 180         }
 181 }
 182
 183 // Delete handles DELETE operations on a particular NetControlIntent  Name
 184 func (h netcontrolintentHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
 185         vars := mux.Vars(r)
 186         name := vars["name"]
 187         project := vars["project"]
 188         compositeApp := vars["composite-app-name"]
 189         compositeAppVersion := vars["version"]
 190
 191         err := h.client.DeleteNetControlIntent(name, project, compositeApp, compositeAppVersion)
 192         if err != nil {
 193                 http.Error(w, err.Error(), http.StatusInternalServerError)
 194                 return
 195         }
 196
 197         w.WriteHeader(http.StatusNoContent)
 198 }