sms-service/src/sms/handler/handler.go

   1 /*
   2  * Copyright 2018 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 handler
  18
  19 import (
  20         "encoding/json"
  21         "github.com/gorilla/mux"
  22         "net/http"
  23
  24         smsbackend "sms/backend"
  25 )
  26
  27 // handler stores two interface implementations that implement
  28 // the backend functionality
  29 type handler struct {
  30         secretBackend smsbackend.SecretBackend
  31         loginBackend  smsbackend.LoginBackend
  32 }
  33
  34 // createSecretDomainHandler creates a secret domain with a name provided
  35 func (h handler) createSecretDomainHandler(w http.ResponseWriter, r *http.Request) {
  36         var d smsbackend.SecretDomain
  37
  38         err := json.NewDecoder(r.Body).Decode(&d)
  39         if err != nil {
  40                 http.Error(w, err.Error(), http.StatusBadRequest)
  41                 return
  42         }
  43
  44         dom, err := h.secretBackend.CreateSecretDomain(d.Name)
  45         if err != nil {
  46                 http.Error(w, err.Error(), http.StatusInternalServerError)
  47                 return
  48         }
  49
  50         err = json.NewEncoder(w).Encode(dom)
  51         if err != nil {
  52                 http.Error(w, err.Error(), http.StatusInternalServerError)
  53                 return
  54         }
  55
  56         w.WriteHeader(http.StatusCreated)
  57 }
  58
  59 // deleteSecretDomainHandler deletes a secret domain with the name provided
  60 func (h handler) deleteSecretDomainHandler(w http.ResponseWriter, r *http.Request) {
  61         vars := mux.Vars(r)
  62         domName := vars["domName"]
  63
  64         err := h.secretBackend.DeleteSecretDomain(domName)
  65         if err != nil {
  66                 http.Error(w, err.Error(), http.StatusInternalServerError)
  67                 return
  68         }
  69
  70         w.WriteHeader(http.StatusNoContent)
  71 }
  72
  73 // createSecretHandler handles creation of secrets on a given domain name
  74 func (h handler) createSecretHandler(w http.ResponseWriter, r *http.Request) {
  75         // Get domain name from URL
  76         vars := mux.Vars(r)
  77         domName := vars["domName"]
  78
  79         // Get secrets to be stored from body
  80         var b smsbackend.Secret
  81         err := json.NewDecoder(r.Body).Decode(&b)
  82         if err != nil {
  83                 http.Error(w, err.Error(), http.StatusBadRequest)
  84                 return
  85         }
  86
  87         err = h.secretBackend.CreateSecret(domName, b)
  88         if err != nil {
  89                 http.Error(w, err.Error(), http.StatusInternalServerError)
  90                 return
  91         }
  92
  93         w.WriteHeader(http.StatusCreated)
  94 }
  95
  96 // getSecretHandler handles reading a secret by given domain name and secret name
  97 func (h handler) getSecretHandler(w http.ResponseWriter, r *http.Request) {
  98         vars := mux.Vars(r)
  99         domName := vars["domName"]
 100         secName := vars["secretName"]
 101
 102         sec, err := h.secretBackend.GetSecret(domName, secName)
 103         if err != nil {
 104                 http.Error(w, err.Error(), http.StatusInternalServerError)
 105                 return
 106         }
 107
 108         err = json.NewEncoder(w).Encode(sec)
 109         if err != nil {
 110                 http.Error(w, err.Error(), http.StatusInternalServerError)
 111                 return
 112         }
 113 }
 114
 115 // listSecretHandler handles listing all secrets under a particular domain name
 116 func (h handler) listSecretHandler(w http.ResponseWriter, r *http.Request) {
 117         vars := mux.Vars(r)
 118         domName := vars["domName"]
 119
 120         sec, err := h.secretBackend.ListSecret(domName)
 121         if err != nil {
 122                 http.Error(w, err.Error(), http.StatusInternalServerError)
 123                 return
 124         }
 125
 126         err = json.NewEncoder(w).Encode(sec)
 127         if err != nil {
 128                 http.Error(w, err.Error(), http.StatusInternalServerError)
 129                 return
 130         }
 131 }
 132
 133 // deleteSecretHandler handles deleting a secret by given domain name and secret name
 134 func (h handler) deleteSecretHandler(w http.ResponseWriter, r *http.Request) {
 135         vars := mux.Vars(r)
 136         domName := vars["domName"]
 137         secName := vars["secretName"]
 138
 139         err := h.secretBackend.DeleteSecret(domName, secName)
 140         if err != nil {
 141                 http.Error(w, err.Error(), http.StatusInternalServerError)
 142                 return
 143         }
 144 }
 145
 146 // struct that tracks various status items for SMS and backend
 147 type backendStatus struct {
 148         Seal bool `json:"sealstatus"`
 149 }
 150
 151 // statusHandler returns information related to SMS and SMS backend services
 152 func (h handler) statusHandler(w http.ResponseWriter, r *http.Request) {
 153         s, err := h.secretBackend.GetStatus()
 154         if err != nil {
 155                 http.Error(w, err.Error(), http.StatusInternalServerError)
 156                 return
 157         }
 158
 159         status := backendStatus{Seal: s}
 160         err = json.NewEncoder(w).Encode(status)
 161         if err != nil {
 162                 http.Error(w, err.Error(), http.StatusInternalServerError)
 163                 return
 164         }
 165 }
 166
 167 // loginHandler handles login via password and username
 168 func (h handler) loginHandler(w http.ResponseWriter, r *http.Request) {
 169
 170 }
 171
 172 // initSMSHandler
 173 func (h handler) initSMSHandler(w http.ResponseWriter, r *http.Request) {
 174
 175 }
 176
 177 // unsealHandler
 178 func (h handler) unsealHandler(w http.ResponseWriter, r *http.Request) {
 179
 180 }
 181
 182 // CreateRouter returns an http.Handler for the registered URLs
 183 // Takes an interface implementation as input
 184 func CreateRouter(b smsbackend.SecretBackend) http.Handler {
 185         h := handler{secretBackend: b}
 186
 187         // Create a new mux to handle URL endpoints
 188         router := mux.NewRouter()
 189
 190         router.HandleFunc("/v1/sms/login", h.loginHandler).Methods("POST")
 191
 192         // Initialization APIs which will be used by quorum client
 193         // to unseal and to provide root token to sms service
 194         router.HandleFunc("/v1/sms/status", h.statusHandler).Methods("GET")
 195         router.HandleFunc("/v1/sms/unseal", h.unsealHandler).Methods("POST")
 196         router.HandleFunc("/v1/sms/init", h.initSMSHandler).Methods("POST")
 197
 198         router.HandleFunc("/v1/sms/domain", h.createSecretDomainHandler).Methods("POST")
 199         router.HandleFunc("/v1/sms/domain/{domName}", h.deleteSecretDomainHandler).Methods("DELETE")
 200
 201         router.HandleFunc("/v1/sms/domain/{domName}/secret", h.createSecretHandler).Methods("POST")
 202         router.HandleFunc("/v1/sms/domain/{domName}/secret", h.listSecretHandler).Methods("GET")
 203         router.HandleFunc("/v1/sms/domain/{domName}/secret/{secretName}", h.getSecretHandler).Methods("GET")
 204         router.HandleFunc("/v1/sms/domain/{domName}/secret/{secretName}", h.deleteSecretHandler).Methods("DELETE")
 205
 206         return router
 207 }