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