func handleRegister(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
// Upgrade to a websocket
ws, err := websocket.Upgrade(w, r, nil)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, err.Error())
return
}
// Set up RPC. The service is a websocket _server_ but an RPC
// _client_.
rpcClient := rpc.NewClient(ws)
// Make platform available to clients
// This should block until the daemon disconnects
// TODO: Handle the error here
s.RegisterDaemon(inst, rpcClient)
// Clean up
// TODO: Handle the error here
rpcClient.Close()
})
}
func handleHistory(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
service := mux.Vars(r)["service"]
spec, err := flux.ParseServiceSpec(service)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, errors.Wrapf(err, "parsing service spec %q", spec).Error())
return
}
h, err := s.History(inst, spec)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if err := json.NewEncoder(w).Encode(h); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
})
}
func handlePostRelease(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var (
inst = getInstanceID(r)
vars = mux.Vars(r)
service = vars["service"]
image = vars["image"]
kind = vars["kind"]
)
serviceSpec, err := flux.ParseServiceSpec(service)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, errors.Wrapf(err, "parsing service spec %q", service).Error())
return
}
imageSpec := flux.ParseImageSpec(image)
releaseKind, err := flux.ParseReleaseKind(kind)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, errors.Wrapf(err, "parsing release kind %q", kind).Error())
return
}
var excludes []flux.ServiceID
for _, ex := range r.URL.Query()["exclude"] {
s, err := flux.ParseServiceID(ex)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, errors.Wrapf(err, "parsing excluded service %q", ex).Error())
return
}
excludes = append(excludes, s)
}
id, err := s.PostRelease(inst, jobs.ReleaseJobParams{
ServiceSpec: serviceSpec,
ImageSpec: imageSpec,
Kind: releaseKind,
Excludes: excludes,
})
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if err := json.NewEncoder(w).Encode(postReleaseResponse{
Status: "Queued.",
ReleaseID: id,
}); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
})
}
func handleIsConnected(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
switch s.IsDaemonConnected(inst) {
case platform.ErrPlatformNotAvailable:
w.WriteHeader(http.StatusNotFound)
case nil:
w.WriteHeader(http.StatusNoContent)
default:
w.WriteHeader(http.StatusInternalServerError)
}
return
})
}
func handleGetRelease(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
id := mux.Vars(r)["id"]
job, err := s.GetRelease(inst, jobs.JobID(id))
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if err := json.NewEncoder(w).Encode(job); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
})
}
func handleListServices(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
namespace := mux.Vars(r)["namespace"]
res, err := s.ListServices(inst, namespace)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if err := json.NewEncoder(w).Encode(res); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
})
}
func handleUnlock(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
service := mux.Vars(r)["service"]
id, err := flux.ParseServiceID(service)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, errors.Wrapf(err, "parsing service ID %q", id).Error())
return
}
if err = s.Unlock(inst, id); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.WriteHeader(http.StatusOK)
})
}
func handleSetConfig(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
var config flux.UnsafeInstanceConfig
if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, err.Error())
return
}
if err := s.SetConfig(inst, config); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.WriteHeader(http.StatusOK)
return
})
}
func handleGetConfig(s api.FluxService) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inst := getInstanceID(r)
config, err := s.GetConfig(inst)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
configBytes := bytes.Buffer{}
if err = json.NewEncoder(&configBytes).Encode(config); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
return
}
w.WriteHeader(http.StatusOK)
w.Write(configBytes.Bytes())
return
})
}