//Store persists the listener defintions in the supplied key value store
func (listenerConfig *ListenerConfig) Store(kvs kvstore.KVStore) (err error) {
b, err := json.Marshal(listenerConfig)
if err != nil {
return err
}
key := fmt.Sprintf("listeners/%s", listenerConfig.Name)
log.Info(fmt.Sprintf("adding %s under key %s", string(b), key))
err = kvs.Put(key, b)
return
}
//ListListenerConfigs retrieves the listener defs from the KVS
func ListListenerConfigs(kvs kvstore.KVStore) ([]*ListenerConfig, error) {
pairs, err := kvs.List("listeners/")
if err != nil {
return nil, err
}
var listeners []*ListenerConfig
for _, p := range pairs {
listeners = append(listeners, JSONToListener(p.Value))
}
return listeners, nil
}
//ListBackendConfigs lists the backend definitions present in the supplied KVS
func ListBackendConfigs(kvs kvstore.KVStore) ([]*BackendConfig, error) {
pairs, err := kvs.List("backends/")
if err != nil {
return nil, err
}
var backends []*BackendConfig
for _, p := range pairs {
backends = append(backends, JSONToBackend(p.Value))
}
return backends, nil
}
//ListRouteConfigs returns the route configs in the key value store
func ListRouteConfigs(kvs kvstore.KVStore) ([]*RouteConfig, error) {
pairs, err := kvs.List("routes/")
if err != nil {
return nil, err
}
var routes []*RouteConfig
for _, p := range pairs {
routes = append(routes, JSONToRoute(p.Value))
}
return routes, nil
}
//Store persists a backend definition using the supplied key value store
func (backendConfig *BackendConfig) Store(kvs kvstore.KVStore) error {
b, err := json.Marshal(backendConfig)
if err != nil {
return err
}
key := fmt.Sprintf("backends/%s", backendConfig.Name)
log.Info(fmt.Sprintf("Adding %s under key %s", string(b), key))
err = kvs.Put(key, b)
if err != nil {
return err
}
return nil
}
//Store persists the route definition using the supplied KVS
func (routeConfig *RouteConfig) Store(kvs kvstore.KVStore) error {
b, err := json.Marshal(routeConfig)
if err != nil {
return nil
}
key := fmt.Sprintf("routes/%s", routeConfig.Name)
log.Info(fmt.Sprintf("adding %s under key %s", string(b), key))
err = kvs.Put(key, b)
if err != nil {
return err
}
return nil
}
//PutDefinition creates or updates a server definition
func (ServerDef) PutDefinition(kvs kvstore.KVStore, resp http.ResponseWriter, req *http.Request) (interface{}, error) {
body, err := ioutil.ReadAll(req.Body)
req.Body.Close()
log.Info(fmt.Sprintf("Put request with payload %s", string(body)))
if err != nil {
resp.WriteHeader(http.StatusInternalServerError)
return nil, nil
}
serverName := resourceIDFromURI(req.RequestURI)
log.Info(serverName)
if serverName == "" {
resp.WriteHeader(http.StatusNotFound)
return nil, errServiceResourceMissing
}
serverConfig := new(config.ServerConfig)
err = json.Unmarshal(body, serverConfig)
if err != nil {
log.Warn("Error unmarshaling request body")
resp.WriteHeader(http.StatusBadRequest)
return nil, err
}
serverConfig.Name = serverName
err = serverConfig.Store(kvs)
if err != nil {
log.Warn("Error persisting server definition")
resp.WriteHeader(http.StatusInternalServerError)
return nil, err
}
err = kvs.Flush()
if err != nil {
return nil, err
}
return nil, nil
}
func readKey(key string, kvs kvstore.KVStore) ([]byte, error) {
log.Info("Read key " + key)
return kvs.Get(key)
}