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         "sms/backend"
  25 )
  26
  27 // handler stores two interface implementations that implement
  28 // the backend functionality
  29 type handler struct {
  30         secretBackend backend.SecretBackend
  31         loginBackend  backend.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 backend.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         h.secretBackend.CreateSecretDomain(d.Name)
  45 }
  46
  47 // getSecretDomainHandler returns list of secret domains
  48 func (h handler) getSecretDomainHandler(w http.ResponseWriter, r *http.Request) {
  49         vars := mux.Vars(r)
  50         domName := vars["domName"]
  51
  52         h.secretBackend.GetSecretDomain(domName)
  53         //encode data into json and return
  54 }
  55
  56 // deleteSecretDomainHandler deletes a secret domain with the name provided
  57 func (h handler) deleteSecretDomainHandler(w http.ResponseWriter, r *http.Request) {
  58         vars := mux.Vars(r)
  59         domName := vars["domName"]
  60
  61         h.secretBackend.DeleteSecretDomain(domName)
  62 }
  63
  64 // createSecretHandler handles creation of secrets on a given domain name
  65 func (h handler) createSecretHandler(w http.ResponseWriter, r *http.Request) {
  66         vars := mux.Vars(r)
  67         domName := vars["domName"]
  68
  69         var b backend.Secret
  70         err := json.NewDecoder(r.Body).Decode(&b)
  71         if err != nil {
  72                 http.Error(w, err.Error(), 400)
  73                 return
  74         }
  75
  76         h.secretBackend.CreateSecret(domName, b)
  77 }
  78
  79 // getSecretHandler handles reading a secret by given domain name and secret name
  80 func (h handler) getSecretHandler(w http.ResponseWriter, r *http.Request) {
  81         vars := mux.Vars(r)
  82         domName := vars["domName"]
  83         secName := vars["secretName"]
  84
  85         h.secretBackend.GetSecret(domName, secName)
  86         //encode and return response
  87 }
  88
  89 // deleteSecretHandler handles deleting a secret by given domain name and secret name
  90 func (h handler) deleteSecretHandler(w http.ResponseWriter, r *http.Request) {
  91         vars := mux.Vars(r)
  92         domName := vars["domName"]
  93         secName := vars["secretName"]
  94
  95         h.secretBackend.DeleteSecret(domName, secName)
  96 }
  97
  98 // struct that tracks various status items for SMS and backend
  99 type backendStatus struct {
 100         Seal bool `json:"sealstatus"`
 101 }
 102
 103 // statusHandler returns information related to SMS and SMS backend services
 104 func (h handler) statusHandler(w http.ResponseWriter, r *http.Request) {
 105         s, err := h.secretBackend.GetStatus()
 106         if err != nil {
 107                 http.Error(w, err.Error(), 500)
 108                 return
 109         }
 110
 111         status := backendStatus{Seal: s}
 112         err = json.NewEncoder(w).Encode(status)
 113         if err != nil {
 114                 http.Error(w, err.Error(), 500)
 115                 return
 116         }
 117 }
 118
 119 // loginHandler handles login via password and username
 120 func (h handler) loginHandler(w http.ResponseWriter, r *http.Request) {
 121
 122 }
 123
 124 // CreateRouter returns an http.Handler for the registered URLs
 125 // Takes an interface implementation as input
 126 func CreateRouter(b backend.SecretBackend) http.Handler {
 127         h := handler{secretBackend: b}
 128
 129         // Create a new mux to handle URL endpoints
 130         router := mux.NewRouter()
 131
 132         router.HandleFunc("/v1/sms/login", h.loginHandler).Methods("POST")
 133
 134         router.HandleFunc("/v1/sms/status", h.statusHandler).Methods("GET")
 135
 136         router.HandleFunc("/v1/sms/domain", h.createSecretDomainHandler).Methods("POST")
 137         router.HandleFunc("/v1/sms/domain/{domName}", h.getSecretDomainHandler).Methods("GET")
 138         router.HandleFunc("/v1/sms/domain/{domName}", h.deleteSecretDomainHandler).Methods("DELETE")
 139
 140         router.HandleFunc("v1/sms/domain/{domainName}/secret", h.createSecretHandler).Methods("POST")
 141         router.HandleFunc("v1/sms/domain/{domainName}/secret/{secretName}", h.getSecretHandler).Methods("GET")
 142         router.HandleFunc("v1/sms/domain/{domainName}/secret/{secretName}", h.deleteSecretHandler).Methods("DELETE")
 143
 144         return router
 145 }