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