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)
}