func (c *templateList) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/iaas/templates") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } var templates []iaas.Template err = json.NewDecoder(response.Body).Decode(&templates) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"Name", "IaaS", "Params"}) table.LineSeparator = true for _, template := range templates { var params []string for _, data := range template.Data { params = append(params, fmt.Sprintf("%s=%s", data.Name, data.Value)) } sort.Strings(params) table.AddRow(cmd.Row([]string{template.Name, template.IaaSName, strings.Join(params, "\n")})) } table.Sort() context.Stdout.Write(table.Bytes()) return nil }
func (c *InfoCmd) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/docker/bs") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() var conf provision.ScopedConfig err = json.NewDecoder(response.Body).Decode(&conf) if err != nil { return err } fmt.Fprintf(context.Stdout, "Image: %s\n\nEnvironment Variables [Default]:\n", conf.Extra["image"]) t := cmd.Table{Headers: cmd.Row([]string{"Name", "Value"})} for _, envVar := range conf.Envs { t.AddRow(cmd.Row([]string{envVar.Name, fmt.Sprintf("%v", envVar.Value)})) } context.Stdout.Write(t.Bytes()) for _, pool := range conf.Pools { t := cmd.Table{Headers: cmd.Row([]string{"Name", "Value"})} fmt.Fprintf(context.Stdout, "\nEnvironment Variables [%s]:\n", pool.Name) for _, envVar := range pool.Envs { t.AddRow(cmd.Row([]string{envVar.Name, fmt.Sprintf("%v", envVar.Value)})) } context.Stdout.Write(t.Bytes()) } return nil }
func (c *autoScaleSetRuleCmd) Run(context *cmd.Context, client *cmd.Client) error { if (c.enable && c.disable) || (!c.enable && !c.disable) { return errors.New("either --disable or --enable must be set") } rule := autoScaleRule{ MetadataFilter: c.filterValue, MaxContainerCount: c.maxContainerCount, MaxMemoryRatio: float32(c.maxMemoryRatio), ScaleDownRatio: float32(c.scaleDownRatio), PreventRebalance: c.noRebalanceOnScale, Enabled: c.enable, } val, err := form.EncodeToValues(rule) if err != nil { return err } body := strings.NewReader(val.Encode()) u, err := cmd.GetURL("/docker/autoscale/rules") if err != nil { return err } req, err := http.NewRequest("POST", u, body) if err != nil { return err } req.Header.Set("Content-Type", "application/x-www-form-urlencoded") _, err = client.Do(req) if err != nil { return err } fmt.Fprintln(context.Stdout, "Rule successfully defined.") return nil }
func (c serviceInfo) BuildPlansTable(serviceName string, ctx *cmd.Context, client *cmd.Client) error { ctx.Stdout.Write([]byte("\nPlans\n")) url, err := cmd.GetURL(fmt.Sprintf("/services/%s/plans", serviceName)) if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() result, err := ioutil.ReadAll(resp.Body) if err != nil { return err } var plans []map[string]string err = json.Unmarshal(result, &plans) if err != nil { return err } if len(plans) > 0 { table := cmd.NewTable() for _, plan := range plans { data := []string{plan["Name"], plan["Description"]} table.AddRow(cmd.Row(data)) } table.Headers = cmd.Row([]string{"Name", "Description"}) ctx.Stdout.Write(table.Bytes()) } return nil }
func (c *serviceAdd) Run(ctx *cmd.Context, client *cmd.Client) error { serviceName, instanceName := ctx.Args[0], ctx.Args[1] var plan string if len(ctx.Args) > 2 { plan = ctx.Args[2] } var b bytes.Buffer params := map[string]string{ "name": instanceName, "service_name": serviceName, "plan": plan, "owner": c.teamOwner, } err := json.NewEncoder(&b).Encode(params) if err != nil { return err } url, err := cmd.GetURL("/services/instances") if err != nil { return err } request, err := http.NewRequest("POST", url, &b) if err != nil { return err } request.Header.Set("Content-Type", "application/json") _, err = client.Do(request) if err != nil { return err } fmt.Fprint(ctx.Stdout, "Service successfully added.\n") return nil }
func (su *ServiceUnbind) Run(ctx *cmd.Context, client *cmd.Client) error { appName, err := su.Guess() if err != nil { return err } instanceName := ctx.Args[0] url, err := cmd.GetURL("/services/instances/" + instanceName + "/" + appName) if err != nil { return err } request, err := http.NewRequest("DELETE", url, nil) if err != nil { return err } _, err = client.Do(request) if err != nil { return err } msg := fmt.Sprintf("Instance %q is not bound to the app %q anymore.\n", instanceName, appName) n, err := fmt.Fprint(ctx.Stdout, msg) if err != nil { return err } if n != len(msg) { return errors.New("Failed to write to standard output.\n") } return nil }
func (c serviceInstanceStatus) Run(ctx *cmd.Context, client *cmd.Client) error { instName := ctx.Args[0] url, err := cmd.GetURL("/services/instances/" + instName + "/status") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() bMsg, err := ioutil.ReadAll(resp.Body) if err != nil { return err } msg := string(bMsg) + "\n" n, err := fmt.Fprint(ctx.Stdout, msg) if err != nil { return err } if n != len(msg) { return errors.New("Failed to write to standard output.\n") } return nil }
func (c *appStart) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() appName, err := c.Guess() if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/start?process=%s", appName, c.process)) if err != nil { return err } request, err := http.NewRequest("POST", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() _, err = io.Copy(context.Stdout, response.Body) if err != nil { return err } return nil }
func (c *appRestart) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() appName, err := c.Guess() if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/restart?process=%s", appName, c.process)) if err != nil { return err } request, err := http.NewRequest("POST", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() w := tsuruIo.NewStreamWriter(context.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return fmt.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (c *unitRemove) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() appName, err := c.Guess() if err != nil { return err } val := url.Values{} val.Add("units", context.Args[0]) val.Add("process", c.process) url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/units?%s", appName, val.Encode())) if err != nil { return err } request, err := http.NewRequest("DELETE", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() w := tsuruIo.NewStreamWriter(context.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return fmt.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (c *appList) Run(context *cmd.Context, client *cmd.Client) error { qs, err := c.filter.queryString(client) if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/apps?%s", qs.Encode())) if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } if response.StatusCode == http.StatusNoContent { return nil } defer response.Body.Close() result, err := ioutil.ReadAll(response.Body) if err != nil { return err } return c.Show(result, context) }
func (c *appRun) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() appName, err := c.Guess() if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/run?once=%t", appName, c.once)) if err != nil { return err } b := strings.NewReader(strings.Join(context.Args, " ")) request, err := http.NewRequest("POST", url, b) if err != nil { return err } r, err := client.Do(request) if err != nil { return err } defer r.Body.Close() w := tsuruIo.NewStreamWriter(context.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, r.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return fmt.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (c *machineList) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/iaas/machines") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } var machines []iaas.Machine err = json.NewDecoder(response.Body).Decode(&machines) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"Id", "IaaS", "Address", "Creation Params"}) table.LineSeparator = true for _, machine := range machines { var params []string for k, v := range machine.CreationParams { params = append(params, fmt.Sprintf("%s=%s", k, v)) } sort.Strings(params) table.AddRow(cmd.Row([]string{machine.Id, machine.Iaas, machine.Address, strings.Join(params, "\n")})) } table.Sort() context.Stdout.Write(table.Bytes()) return nil }
func (c *templateUpdate) Run(context *cmd.Context, client *cmd.Client) error { var template iaas.Template template.Name = context.Args[0] for _, param := range context.Args[1:] { if strings.Contains(param, "=") { keyValue := strings.SplitN(param, "=", 2) template.Data = append(template.Data, iaas.TemplateData{ Name: keyValue[0], Value: keyValue[1], }) } } templateBytes, err := json.Marshal(template) if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/iaas/templates/%s", template.Name)) if err != nil { return err } request, err := http.NewRequest("PUT", url, bytes.NewBuffer(templateBytes)) if err != nil { return err } _, err = client.Do(request) if err != nil { context.Stderr.Write([]byte("Failed to update template.\n")) return err } context.Stdout.Write([]byte("Template successfully updated.\n")) return nil }
func (c *autoScaleSetRuleCmd) Run(context *cmd.Context, client *cmd.Client) error { rule := autoScaleRule{ MetadataFilter: c.filterValue, MaxContainerCount: c.maxContainerCount, MaxMemoryRatio: float32(c.maxMemoryRatio), ScaleDownRatio: float32(c.scaleDownRatio), PreventRebalance: !c.rebalanceOnScale, Enabled: c.enabled, } data, err := json.Marshal(rule) if err != nil { return err } body := bytes.NewBuffer(data) url, err := cmd.GetURL("/docker/autoscale/rules") if err != nil { return err } req, err := http.NewRequest("POST", url, body) if err != nil { return err } _, err = client.Do(req) if err != nil { return err } fmt.Fprintln(context.Stdout, "Rule successfully defined.") return nil }
func addCName(v []string, g cmd.GuessingCommand, client *cmd.Client) error { appName, err := g.Guess() if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/cname", appName)) if err != nil { return err } cnames := make(map[string][]string) cnames["cname"] = v c, err := json.Marshal(cnames) if err != nil { return err } body := bytes.NewReader(c) request, err := http.NewRequest("POST", url, body) if err != nil { return err } _, err = client.Do(request) if err != nil { return err } return nil }
func (c *ListHealingHistoryCmd) Run(ctx *cmd.Context, client *cmd.Client) error { var filter string if c.nodeOnly && !c.containerOnly { filter = "node" } if c.containerOnly && !c.nodeOnly { filter = "container" } url, err := cmd.GetURL(fmt.Sprintf("/docker/healing?filter=%s", filter)) if err != nil { return err } req, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(req) if err != nil { return err } defer resp.Body.Close() var history []HealingEvent err = json.NewDecoder(resp.Body).Decode(&history) if err != nil { return err } if filter != "" { renderHistoryTable(history, filter, ctx) } else { renderHistoryTable(history, "node", ctx) renderHistoryTable(history, "container", ctx) } return nil }
func (c *unitAdd) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() appName, err := c.Guess() if err != nil { return err } u, err := cmd.GetURL(fmt.Sprintf("/apps/%s/units", appName)) if err != nil { return err } val := url.Values{} val.Add("units", context.Args[0]) val.Add("process", c.process) request, err := http.NewRequest("PUT", u, bytes.NewBufferString(val.Encode())) if err != nil { return err } request.Header.Add("Content-Type", "application/x-www-form-urlencoded") response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() w := tsuruIo.NewStreamWriter(context.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return fmt.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (su *serviceUnbind) Run(ctx *cmd.Context, client *cmd.Client) error { ctx.RawOutput() appName, err := su.Guess() if err != nil { return err } instanceName := ctx.Args[0] url, err := cmd.GetURL("/services/instances/" + instanceName + "/" + appName) if err != nil { return err } request, err := http.NewRequest("DELETE", url, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() w := tsuruIo.NewStreamWriter(ctx.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, resp.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return fmt.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (c *rebalanceContainersCmd) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() if !c.dry && !c.Confirm(context, "Are you sure you want to rebalance containers?") { return nil } url, err := cmd.GetURL("/docker/containers/rebalance") if err != nil { return err } params := map[string]interface{}{ "dry": fmt.Sprintf("%t", c.dry), } if len(c.metadataFilter) > 0 { params["metadataFilter"] = c.metadataFilter } if len(c.appFilter) > 0 { params["appFilter"] = c.appFilter } b, err := json.Marshal(params) if err != nil { return err } buffer := bytes.NewBuffer(b) request, err := http.NewRequest("POST", url, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") response, err := client.Do(request) if err != nil { return err } return cmd.StreamJSONResponse(context.Stdout, response) }
func (s serviceList) Run(ctx *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/services/instances") if err != nil { return err } req, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(req) if err != nil { return err } defer resp.Body.Close() b, err := ioutil.ReadAll(resp.Body) if err != nil { return err } rslt, err := cmd.ShowServicesInstancesList(b) if err != nil { return err } n, err := ctx.Stdout.Write(rslt) if n != len(rslt) { return errors.New("Failed to write the output of the command") } return nil }
func (c *moveContainerCmd) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() url, err := cmd.GetURL(fmt.Sprintf("/docker/container/%s/move", context.Args[0])) if err != nil { return err } params := map[string]string{ "to": context.Args[1], } b, err := json.Marshal(params) if err != nil { return err } buffer := bytes.NewBuffer(b) request, err := http.NewRequest("POST", url, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") response, err := client.Do(request) if err != nil { return err } return cmd.StreamJSONResponse(context.Stdout, response) }
func (c *serviceRemove) Run(ctx *cmd.Context, client *cmd.Client) error { name := ctx.Args[0] var answer string if !c.yes { fmt.Fprintf(ctx.Stdout, `Are you sure you want to remove service "%s"? (y/n) `, name) fmt.Fscanf(ctx.Stdin, "%s", &answer) if answer != "y" { fmt.Fprintln(ctx.Stdout, "Abort.") return nil } } url := fmt.Sprintf("/services/instances/%s", name) url, err := cmd.GetURL(url) if err != nil { return err } request, err := http.NewRequest("DELETE", url, nil) if err != nil { return err } _, err = client.Do(request) if err != nil { return err } fmt.Fprintf(ctx.Stdout, `Service "%s" successfully removed!`+"\n", name) return nil }
func (a *updateNodeToSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error { jsonParams := map[string]string{} for _, param := range ctx.Args[1:] { if strings.Contains(param, "=") { keyValue := strings.SplitN(param, "=", 2) jsonParams[keyValue[0]] = keyValue[1] } } jsonParams["address"] = ctx.Args[0] b, err := json.Marshal(jsonParams) if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/docker/node?disabled=%t&enabled=%t", a.disabled, a.enabled)) if err != nil { return err } req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b)) if err != nil { return err } _, err = client.Do(req) if err != nil { return err } ctx.Stdout.Write([]byte("Node successfully updated.\n")) return nil }
func (c *moveContainerCmd) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() url, err := cmd.GetURL(fmt.Sprintf("/docker/container/%s/move", context.Args[0])) if err != nil { return err } params := map[string]string{ "to": context.Args[1], } b, err := json.Marshal(params) if err != nil { return err } buffer := bytes.NewBuffer(b) request, err := http.NewRequest("POST", url, buffer) if err != nil { return err } request.Header.Set("Content-Type", "application/json") response, err := client.Do(request) if err != nil { return err } w := tsuruIo.NewStreamWriter(context.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return fmt.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (c *removeNodeFromSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error { msg := "Are you sure you sure you want to remove \"%s\" from cluster" if c.destroy { msg += " and DESTROY the machine from IaaS" } if !c.Confirm(ctx, fmt.Sprintf(msg+"?", ctx.Args[0])) { return nil } params := map[string]string{"address": ctx.Args[0]} if c.destroy { params["remove_iaas"] = "true" } b, err := json.Marshal(params) if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/docker/node?no-rebalance=%t", c.noRebalance)) if err != nil { return err } req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(b)) if err != nil { return err } _, err = client.Do(req) if err != nil { return err } ctx.Stdout.Write([]byte("Node successfully removed.\n")) return nil }
func (c *autoScaleRunCmd) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() if !c.Confirm(context, "Are you sure you want to run auto scaling checks?") { return nil } u, err := cmd.GetURL("/docker/autoscale/run") if err != nil { return err } request, err := http.NewRequest("POST", u, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } w := tsuruIo.NewStreamWriter(context.Stdout, nil) for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) { } if err != nil { return err } unparsed := w.Remaining() if len(unparsed) > 0 { return errors.Errorf("unparsed message error: %s", string(unparsed)) } return nil }
func (a *addNodeToSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error { jsonParams := map[string]string{} for _, param := range ctx.Args { if strings.Contains(param, "=") { keyValue := strings.SplitN(param, "=", 2) jsonParams[keyValue[0]] = keyValue[1] } } b, err := json.Marshal(jsonParams) if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/docker/node?register=%t", a.register)) if err != nil { return err } req, err := http.NewRequest("POST", url, bytes.NewBuffer(b)) if err != nil { return err } _, err = client.Do(req) if err != nil { result := make(map[string]string) unmarshalErr := json.Unmarshal([]byte(err.Error()), &result) if unmarshalErr != nil { return err } fmt.Fprintf(ctx.Stderr, "Error: %s\n\n%s\n", result["error"], result["description"]) return nil } ctx.Stdout.Write([]byte("Node successfully registered.\n")) return nil }
func (c *autoScaleDeleteRuleCmd) Run(context *cmd.Context, client *cmd.Client) error { var rule string confirmMsg := "Are you sure you want to remove the default rule?" if len(context.Args) > 0 { rule = context.Args[0] confirmMsg = fmt.Sprintf("Are you sure you want to remove the rule %q?", rule) } if !c.Confirm(context, confirmMsg) { return nil } u, err := cmd.GetURL("/docker/autoscale/rules/" + rule) if err != nil { return err } req, err := http.NewRequest("DELETE", u, nil) if err != nil { return err } _, err = client.Do(req) if err != nil { return err } fmt.Fprintln(context.Stdout, "Rule successfully removed.") return nil }
func (c *unitAdd) Run(context *cmd.Context, client *cmd.Client) error { context.RawOutput() appName, err := c.Guess() if err != nil { return err } u, err := cmd.GetURL(fmt.Sprintf("/apps/%s/units", appName)) if err != nil { return err } val := url.Values{} val.Add("units", context.Args[0]) val.Add("process", c.process) request, err := http.NewRequest("PUT", u, bytes.NewBufferString(val.Encode())) if err != nil { return err } request.Header.Add("Content-Type", "application/x-www-form-urlencoded") response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() return cmd.StreamJSONResponse(context.Stdout, response) }