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(), 400)
  41                 return
  42         }
  43
  44         dom, err := h.secretBackend.CreateSecretDomain(d.Name)
  45         if err != nil {
  46                 http.Error(w, err.Error(), 400)
  47                 return
  48         }
  49
  50         err = json.NewEncoder(w).Encode(dom)
  51         if err != nil {
  52                 http.Error(w, err.Error(), 400)
  53                 return
  54         }
  55 }
  56
  57 // getSecretDomainHandler returns list of secret domains
  58 func (h handler) getSecretDomainHandler(w http.ResponseWriter, r *http.Request) {
  59         vars := mux.Vars(r)
  60         domName := vars["domName"]
  61
  62         h.secretBackend.GetSecretDomain(domName)
  63         //encode data into json and return
  64 }
  65
  66 // deleteSecretDomainHandler deletes a secret domain with the name provided
  67 func (h handler) deleteSecretDomainHandler(w http.ResponseWriter, r *http.Request) {
  68         vars := mux.Vars(r)
  69         domName := vars["domName"]
  70
  71         h.secretBackend.DeleteSecretDomain(domName)
  72 }
  73
  74 // createSecretHandler handles creation of secrets on a given domain name
  75 func (h handler) createSecretHandler(w http.ResponseWriter, r *http.Request) {
  76         // Get domain name from URL
  77         vars := mux.Vars(r)
  78         domName := vars["domName"]
  79
  80         // Get secrets to be stored from body
  81         var b smsbackend.Secret
  82         err := json.NewDecoder(r.Body).Decode(&b)
  83         if err != nil {
  84                 http.Error(w, err.Error(), 400)
  85                 return
  86         }
  87
  88         h.secretBackend.CreateSecret(domName, b)
  89 }
  90
  91 // getSecretHandler handles reading a secret by given domain name and secret name
  92 func (h handler) getSecretHandler(w http.ResponseWriter, r *http.Request) {
  93         vars := mux.Vars(r)
  94         domName := vars["domName"]
  95         secName := vars["secretName"]
  96
  97         h.secretBackend.GetSecret(domName, secName)
  98         //encode and return response
  99 }
 100
 101 // deleteSecretHandler handles deleting a secret by given domain name and secret name
 102 func (h handler) deleteSecretHandler(w http.ResponseWriter, r *http.Request) {
 103         vars := mux.Vars(r)
 104         domName := vars["domName"]
 105         secName := vars["secretName"]
 106
 107         h.secretBackend.DeleteSecret(domName, secName)
 108 }
 109
 110 // struct that tracks various status items for SMS and backend
 111 type backendStatus struct {
 112         Seal bool `json:"sealstatus"`
 113 }
 114
 115 // statusHandler returns information related to SMS and SMS backend services
 116 func (h handler) statusHandler(w http.ResponseWriter, r *http.Request) {
 117         s, err := h.secretBackend.GetStatus()
 118         if err != nil {
 119                 http.Error(w, err.Error(), 500)
 120                 return
 121         }
 122
 123         status := backendStatus{Seal: s}
 124         err = json.NewEncoder(w).Encode(status)
 125         if err != nil {
 126                 http.Error(w, err.Error(), 500)
 127                 return
 128         }
 129 }
 130
 131 // loginHandler handles login via password and username
 132 func (h handler) loginHandler(w http.ResponseWriter, r *http.Request) {
 133
 134 }
 135
 136 // initSMSHandler
 137 func (h handler) initSMSHandler(w http.ResponseWriter, r *http.Request) {
 138
 139 }
 140
 141 // unsealHandler
 142 func (h handler) unsealHandler(w http.ResponseWriter, r *http.Request) {
 143
 144 }
 145
 146 // CreateRouter returns an http.Handler for the registered URLs
 147 // Takes an interface implementation as input
 148 func CreateRouter(b smsbackend.SecretBackend) http.Handler {
 149         h := handler{secretBackend: b}
 150
 151         // Create a new mux to handle URL endpoints
 152         router := mux.NewRouter()
 153
 154         router.HandleFunc("/v1/sms/login", h.loginHandler).Methods("POST")
 155
 156         // Initialization APIs which will be used by quorum client
 157         // to unseal and to provide root token to sms service
 158         router.HandleFunc("/v1/sms/status", h.statusHandler).Methods("GET")
 159         router.HandleFunc("/v1/sms/unseal", h.unsealHandler).Methods("POST")
 160         router.HandleFunc("/v1/sms/init", h.initSMSHandler).Methods("POST")
 161
 162         router.HandleFunc("/v1/sms/domain", h.createSecretDomainHandler).Methods("POST")
 163         router.HandleFunc("/v1/sms/domain/{domName}", h.getSecretDomainHandler).Methods("GET")
 164         router.HandleFunc("/v1/sms/domain/{domName}", h.deleteSecretDomainHandler).Methods("DELETE")
 165
 166         router.HandleFunc("v1/sms/domain/{domainName}/secret", h.createSecretHandler).Methods("POST")
 167         router.HandleFunc("v1/sms/domain/{domainName}/secret/{secretName}", h.getSecretHandler).Methods("GET")
 168         router.HandleFunc("v1/sms/domain/{domainName}/secret/{secretName}", h.deleteSecretHandler).Methods("DELETE")
 169
 170         return router
 171 }