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