func addChartRepoHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: add chart repository" util.LogHandlerEntry(handler, r) defer r.Body.Close() cr := &repo.Repo{} if err := httputil.Decode(w, r, cr); err != nil { httputil.BadRequest(w, r, err) return nil } if string(cr.Format) == "" { cr.Format = repo.GCSRepoFormat } if string(cr.Type) == "" { cr.Type = repo.GCSRepoType } if err := c.Manager.AddRepo(cr); err != nil { httputil.BadRequest(w, r, err) return nil } msg, _ := json.Marshal(cr.Name + " has been added to the list of chart repositories.") util.LogHandlerExitWithJSON(handler, w, msg, http.StatusCreated) return nil }
func expanderSuccessHandler(w http.ResponseWriter, r *http.Request) { handler := "expandybird: expand" util.LogHandlerEntry(handler, r) defer r.Body.Close() body, err := ioutil.ReadAll(r.Body) if err != nil { status := fmt.Sprintf("cannot read request body:%s", err) http.Error(w, status, http.StatusInternalServerError) return } svcReq := &expansion.ServiceRequest{} if err := json.Unmarshal(body, svcReq); err != nil { status := fmt.Sprintf("cannot unmarshal request body:%s\n%s\n", err, body) http.Error(w, status, http.StatusInternalServerError) return } /* if !reflect.DeepEqual(validRequestTestCaseData, *svcReq) { status := fmt.Sprintf("error in http handler:\nwant:%s\nhave:%s\n", util.ToJSONOrError(validRequestTestCaseData), util.ToJSONOrError(template)) http.Error(w, status, http.StatusInternalServerError) return } */ svcResp := getValidServiceResponse() util.LogHandlerExitWithJSON(handler, w, svcResp, http.StatusOK) }
func listRepoChartsHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: list repository charts" util.LogHandlerEntry(handler, r) repoURL, err := pos(w, r, 2) if err != nil { return err } values, err := url.ParseQuery(r.URL.RawQuery) if err != nil { httputil.BadRequest(w, r, err) return nil } var regex *regexp.Regexp regexString := values.Get("regex") if regexString != "" { regex, err = regexp.Compile(regexString) if err != nil { httputil.BadRequest(w, r, err) return nil } } repoCharts, err := c.Manager.ListRepoCharts(repoURL, regex) if err != nil { return err } util.LogHandlerExitWithJSON(handler, w, repoCharts, http.StatusOK) return nil }
func getConfigurationHandlerFunc(w http.ResponseWriter, r *http.Request) { handler := "resourcifier: get configuration" util.LogHandlerEntry(handler, r) rtype, err := getPathVariable(w, r, "type", handler) if err != nil { return } rname, err := getPathVariable(w, r, "name", handler) if err != nil { return } c := &common.Configuration{ Resources: []*common.Resource{ {Name: rname, Type: rtype}, }, } output, err := backend.Configure(c, configurator.GetOperation) if err != nil { util.LogAndReturnError(handler, http.StatusBadRequest, err, w) return } util.LogHandlerExit(handler, http.StatusOK, output, w) util.WriteYAML(handler, w, []byte(output), http.StatusOK) }
func getCredential(w http.ResponseWriter, r *http.Request, handler string) *repo.Credential { util.LogHandlerEntry(handler, r) t := &repo.Credential{} if err := httputil.Decode(w, r, t); err != nil { httputil.BadRequest(w, r, err) return nil } return t }
func getDeploymentRequest(w http.ResponseWriter, r *http.Request, handler string) *common.DeploymentRequest { util.LogHandlerEntry(handler, r) depReq := &common.DeploymentRequest{} if err := httputil.Decode(w, r, depReq); err != nil { httputil.BadRequest(w, r, err) return nil } return depReq }
// Putting Type handlers here for now because deployments.go // currently owns its own Manager backend and doesn't like to share. func listChartsHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: list charts" util.LogHandlerEntry(handler, r) types, err := c.Manager.ListCharts() if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, types, http.StatusOK) return nil }
func listDeploymentsHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: list deployments" util.LogHandlerEntry(handler, r) l, err := c.Manager.ListDeployments() if err != nil { util.LogAndReturnError(handler, http.StatusInternalServerError, err, w) return nil } var names []string for _, d := range l { names = append(names, d.Name) } util.LogHandlerExitWithJSON(handler, w, names, http.StatusOK) return nil }
// NewService encapsulates code to open an HTTP server on the given address:port that serves the // expansion API using the given Expander backend to do the actual expansion. After calling // NewService, call ListenAndServe to start the returned service. func NewService(address string, port int, backend Expander) *Service { restful.EnableTracing(true) webService := new(restful.WebService) webService.Consumes(restful.MIME_JSON) webService.Produces(restful.MIME_JSON) handler := func(req *restful.Request, resp *restful.Response) { util.LogHandlerEntry("expansion service", req.Request) request := &ServiceRequest{} if err := req.ReadEntity(&request); err != nil { badRequest(resp, err.Error()) return } reqMsg := fmt.Sprintf("\nhandling request:\n%s\n", util.ToYAMLOrError(request)) util.LogHandlerText("expansion service", reqMsg) response, err := backend.ExpandChart(request) if err != nil { badRequest(resp, fmt.Sprintf("error expanding chart: %s", err)) return } util.LogHandlerExit("expansion service", http.StatusOK, "OK", resp.ResponseWriter) respMsg := fmt.Sprintf("\nreturning response:\n%s\n", util.ToYAMLOrError(response.Resources)) util.LogHandlerText("expansion service", respMsg) resp.WriteEntity(response) } webService.Route( webService.POST("/expand"). To(handler). Doc("Expand a chart."). Reads(&ServiceRequest{}). Writes(&ServiceResponse{})) container := restful.DefaultContainer container.Add(webService) server := &http.Server{ Addr: fmt.Sprintf("%s:%d", address, port), Handler: container, } return &Service{ webService: webService, server: server, container: container, } }
func deleteDeploymentHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: delete deployment" util.LogHandlerEntry(handler, r) defer r.Body.Close() name, err := pos(w, r, 2) if err != nil { return err } d, err := c.Manager.DeleteDeployment(name, true) if err != nil { return err } util.LogHandlerExitWithJSON(handler, w, d, http.StatusOK) return nil }
func getDeploymentHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: get deployment" util.LogHandlerEntry(handler, r) name, err := pos(w, r, 2) if err != nil { return nil } d, err := c.Manager.GetDeployment(name) if err != nil { util.LogAndReturnError(handler, http.StatusBadRequest, err, w) return nil } util.LogHandlerExitWithJSON(handler, w, d, http.StatusOK) return nil }
func expandHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: expand config" util.LogHandlerEntry(handler, r) defer r.Body.Close() depReq := getDeploymentRequest(w, r, handler) if depReq != nil { c, err := c.Manager.Expand(depReq) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, c, http.StatusCreated) } return nil }
func getCredentialHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: get credential" util.LogHandlerEntry(handler, r) credentialName, err := pos(w, r, 2) if err != nil { return err } cr, err := c.Manager.GetCredential(credentialName) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, cr, http.StatusOK) return nil }
func getMetadataForChartHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: get chart metadata" util.LogHandlerEntry(handler, r) chartName, err := pos(w, r, 2) if err != nil { return err } metadata, err := c.Manager.GetMetadataForChart(chartName) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, metadata, http.StatusOK) return nil }
func listChartInstancesHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: list chart instances" util.LogHandlerEntry(handler, r) chartName, err := pos(w, r, 2) if err != nil { return err } instances, err := c.Manager.ListChartInstances(chartName) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, instances, http.StatusOK) return nil }
func getChartRepoHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: get repository" util.LogHandlerEntry(handler, r) repoURL, err := pos(w, r, 2) if err != nil { return err } cr, err := c.Manager.GetRepo(repoURL) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, cr, http.StatusOK) return nil }
func removeChartRepoHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: remove chart repository" util.LogHandlerEntry(handler, r) defer r.Body.Close() name, err := pos(w, r, 2) if err != nil { return err } err = c.Manager.RemoveRepo(name) if err != nil { return err } msg, _ := json.Marshal(name + " has been removed from the list of chart repositories.") util.LogHandlerExitWithJSON(handler, w, msg, http.StatusOK) return nil }
func putConfigurationHandlerFunc(w http.ResponseWriter, r *http.Request) { handler := "resourcifier: update configuration" util.LogHandlerEntry(handler, r) defer r.Body.Close() c := getConfiguration(w, r, handler) if c != nil { if _, err := backend.Configure(c, configurator.ReplaceOperation); err != nil { e := errors.New("cannot replace configuration: " + err.Error() + "\n") util.LogAndReturnError(handler, http.StatusBadRequest, e, w) return } util.LogHandlerExitWithYAML(handler, w, c, http.StatusCreated) return } util.LogHandlerExit(handler, http.StatusOK, "OK", w) }
func createConfigurationHandlerFunc(w http.ResponseWriter, r *http.Request) { handler := "resourcifier: create configuration" util.LogHandlerEntry(handler, r) defer r.Body.Close() c := getConfiguration(w, r, handler) if c != nil { _, err := backend.Configure(c, configurator.CreateOperation) if err != nil { util.LogAndReturnError(handler, http.StatusBadRequest, err, w) return } util.LogHandlerExitWithYAML(handler, w, c, http.StatusCreated) return } util.LogHandlerExit(handler, http.StatusOK, "OK", w) }
func deleteConfigurationHandlerFunc(w http.ResponseWriter, r *http.Request) { handler := "resourcifier: delete configuration" util.LogHandlerEntry(handler, r) defer r.Body.Close() c := getConfiguration(w, r, handler) if c != nil { if _, err := backend.Configure(c, configurator.DeleteOperation); err != nil { e := errors.New("cannot delete configuration: " + err.Error() + "\n") util.LogAndReturnError(handler, http.StatusBadRequest, e, w) return } w.WriteHeader(http.StatusNoContent) util.LogHandlerExit(handler, http.StatusNoContent, "No Content", w) return } util.LogHandlerExit(handler, http.StatusOK, "OK", w) }
func createCredentialHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: create credential" util.LogHandlerEntry(handler, r) defer r.Body.Close() credentialName, err := pos(w, r, 2) if err != nil { return err } cr := getCredential(w, r, handler) if cr != nil { err = c.Manager.CreateCredential(credentialName, cr) if err != nil { httputil.BadRequest(w, r, err) return nil } } util.LogHandlerExitWithJSON(handler, w, c, http.StatusOK) return nil }
func listManifestsHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: list manifests" util.LogHandlerEntry(handler, r) deploymentName, err := pos(w, r, 2) if err != nil { return err } m, err := c.Manager.ListManifests(deploymentName) if err != nil { return err } var manifestNames []string for _, manifest := range m { manifestNames = append(manifestNames, manifest.Name) } util.LogHandlerExitWithJSON(handler, w, manifestNames, http.StatusOK) return nil }
func getRepoChartHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: get repository charts" util.LogHandlerEntry(handler, r) repoURL, err := pos(w, r, 2) if err != nil { return err } chartName, err := pos(w, r, 4) if err != nil { return err } repoChart, err := c.Manager.GetChartForRepo(repoURL, chartName) if err != nil { return err } util.LogHandlerExitWithJSON(handler, w, repoChart, http.StatusOK) return nil }
func putDeploymentHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: update deployment" util.LogHandlerEntry(handler, r) defer r.Body.Close() name, err := pos(w, r, 2) if err != nil { return err } depReq := getDeploymentRequest(w, r, handler) if depReq != nil { d, err := c.Manager.PutDeployment(name, depReq) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, d, http.StatusCreated) } return nil }
func getManifestHandlerFunc(w http.ResponseWriter, r *http.Request, c *router.Context) error { handler := "manager: get manifest" util.LogHandlerEntry(handler, r) deploymentName, err := pos(w, r, 2) if err != nil { return err } manifestName, err := pos(w, r, 4) if err != nil { return err } m, err := c.Manager.GetManifest(deploymentName, manifestName) if err != nil { httputil.BadRequest(w, r, err) return nil } util.LogHandlerExitWithJSON(handler, w, m, http.StatusOK) return nil }
func healthCheckHandlerFunc(w http.ResponseWriter, r *http.Request) { handler := "manager: get health" util.LogHandlerEntry(handler, r) util.LogHandlerExitWithText(handler, w, "OK", http.StatusOK) }