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 *AppRemove) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
var answer string
if !c.yes {
fmt.Fprintf(context.Stdout, `Are you sure you want to remove app "%s"? (y/n) `, appName)
fmt.Fscanf(context.Stdin, "%s", &answer)
if answer != "y" {
fmt.Fprintln(context.Stdout, "Abort.")
return nil
}
}
url, err := cmd.GetURL(fmt.Sprintf("/apps/%s", 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
}
fmt.Fprintf(context.Stdout, `App "%s" successfully removed!`+"\n", appName)
return nil
}
func (c *changeQuota) Run(context *cmd.Context, client *cmd.Client) error {
if c.owner == "" {
return errors.New("The owner's name required.")
}
uri := "/quota/" + c.owner
url, err := cmd.GetURL(uri)
if err != nil {
return err
}
if c.quota == 0 {
return errors.New("Number of quotas required.")
}
body := fmt.Sprintf("quota=%d", c.quota)
request, err := http.NewRequest("PUT", url, strings.NewReader(body))
if err != nil {
return err
}
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprintf(context.Stdout, "Quotas successfully changed!\n")
return nil
}
func (c *EnvSet) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
raw := strings.Join(context.Args, " ")
regex := regexp.MustCompile(`(\w+=[^=]+)(\s|$)`)
decls := regex.FindAllStringSubmatch(raw, -1)
if len(decls) < 1 {
return errors.New(envSetValidationMessage)
}
variables := make(map[string]string, len(decls))
for _, v := range decls {
parts := strings.Split(v[1], "=")
variables[parts[0]] = parts[1]
}
var buf bytes.Buffer
json.NewEncoder(&buf).Encode(variables)
url, err := cmd.GetUrl(fmt.Sprintf("/apps/%s/env", appName))
if err != nil {
return err
}
request, err := http.NewRequest("POST", url, &buf)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprint(context.Stdout, "variable(s) successfully exported\n")
return nil
}
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 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 requestEnvUrl(method string, g GuessingCommand, args []string, client *cmd.Client) ([]byte, error) {
appName, err := g.Guess()
if err != nil {
return nil, err
}
url, err := cmd.GetUrl(fmt.Sprintf("/apps/%s/env", appName))
if err != nil {
return nil, err
}
var buf bytes.Buffer
json.NewEncoder(&buf).Encode(args)
request, err := http.NewRequest(method, url, &buf)
if err != nil {
return nil, err
}
r, err := client.Do(request)
if err != nil {
return nil, err
}
defer r.Body.Close()
b, err := ioutil.ReadAll(r.Body)
if err != nil {
return nil, err
}
return b, nil
}
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 (platformList) Run(context *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetUrl("/platforms")
if err != nil {
return err
}
request, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
var platforms []platform
resp, err := client.Do(request)
if err != nil {
return err
}
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(&platforms)
if err != nil {
return err
}
if len(platforms) == 0 {
fmt.Fprintln(context.Stdout, "No platforms available.")
return nil
}
for _, p := range platforms {
fmt.Fprintf(context.Stdout, "- %s\n", p.Name)
}
return nil
}
func (c *AppLog) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/log?lines=%d", appName, c.lines))
if err != nil {
return err
}
if c.source != "" {
url = fmt.Sprintf("%s&source=%s", url, c.source)
}
if c.follow {
url += "&follow=1"
}
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()
w := jsonWriter{w: context.Stdout}
for n, err := io.Copy(&w, response.Body); n > 0 && err == nil; n, err = io.Copy(&w, response.Body) {
}
return nil
}
func (c *KeyRemove) Run(context *cmd.Context, client *cmd.Client) error {
keyPath, err := getKeyPath(context.Args)
if err != nil {
return err
}
key, err := c.readKey(keyPath)
if os.IsNotExist(err) {
return c.fileNotFound(context)
}
b := bytes.NewBufferString(fmt.Sprintf(`{"key":"%s"}`, strings.Replace(key, "\n", "", -1)))
url, err := cmd.GetUrl("/users/keys")
if err != nil {
return err
}
request, err := http.NewRequest("DELETE", url, b)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprint(context.Stdout, "Key successfully removed!\n")
return nil
}
func (c *AppInfo) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
url, err := cmd.GetURL(fmt.Sprintf("/apps/%s", appName))
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 *ServiceList) Run(ctx *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/services")
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
}
b, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
if err != nil {
return err
}
rslt, err := cmd.ShowServicesInstancesList(b)
if err != nil {
return err
}
ctx.Stdout.Write(rslt)
return nil
}
func (c *AppCreate) Run(context *cmd.Context, client *cmd.Client) error {
appName := context.Args[0]
platform := context.Args[1]
b := bytes.NewBufferString(fmt.Sprintf(`{"name":"%s","platform":"%s","memory":"%d"}`, appName, platform, c.memory))
url, err := cmd.GetURL("/apps")
if err != nil {
return err
}
request, err := http.NewRequest("POST", url, b)
if err != nil {
return err
}
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
return err
}
defer response.Body.Close()
result, err := ioutil.ReadAll(response.Body)
if err != nil {
return err
}
out := make(map[string]string)
err = json.Unmarshal(result, &out)
if err != nil {
return err
}
fmt.Fprintf(context.Stdout, "App %q is being created!\n", appName)
fmt.Fprintln(context.Stdout, "Use app-info to check the status of the app and its units.")
fmt.Fprintf(context.Stdout, "Your repository for %q project is %q\n", appName, out["repository_url"])
return nil
}
func (c *ServiceCreate) Run(context *cmd.Context, client *cmd.Client) error {
manifest := context.Args[0]
url, err := cmd.GetURL("/services")
if err != nil {
return err
}
b, err := ioutil.ReadFile(manifest)
if err != nil {
return err
}
request, err := http.NewRequest("POST", url, bytes.NewReader(b))
if err != nil {
return err
}
r, err := client.Do(request)
if err != nil {
return err
}
b, err = ioutil.ReadAll(r.Body)
if err != nil {
return err
}
fmt.Fprintf(context.Stdout, "%s", b)
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 (swap) Run(context *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL(fmt.Sprintf("/swap?app1=%s&app2=%s", context.Args[0], context.Args[1]))
if err != nil {
return err
}
request, err := http.NewRequest("PUT", url, nil)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprintln(context.Stdout, "Apps successfully swapped!")
return nil
}
func (c *ServiceRemove) Run(context *cmd.Context, client *cmd.Client) error {
serviceName := context.Args[0]
url, err := cmd.GetURL("/services/" + serviceName)
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.Fprintln(context.Stdout, "Service successfully removed.")
return nil
}
func (c *ServiceDocAdd) Run(ctx *cmd.Context, client *cmd.Client) error {
serviceName := ctx.Args[0]
url, err := cmd.GetURL("/services/" + serviceName + "/doc")
if err != nil {
return err
}
docPath := ctx.Args[1]
b, err := ioutil.ReadFile(docPath)
request, err := http.NewRequest("PUT", url, bytes.NewReader(b))
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprintf(ctx.Stdout, "Documentation for '%s' successfully updated.\n", serviceName)
return nil
}
func (c ServiceInfo) BuildInstancesTable(serviceName string, ctx *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/services/" + 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 instances []ServiceInstanceModel
err = json.Unmarshal(result, &instances)
if err != nil {
return err
}
ctx.Stdout.Write([]byte(fmt.Sprintf("Info for \"%s\"\n\n", serviceName)))
if len(instances) > 0 {
ctx.Stdout.Write([]byte("Instances\n"))
table := cmd.NewTable()
extraHeaders := c.ExtraHeaders(instances)
for _, instance := range instances {
apps := strings.Join(instance.Apps, ", ")
data := []string{instance.Name, apps}
for _, h := range extraHeaders {
data = append(data, instance.Info[h])
}
table.AddRow(cmd.Row(data))
}
headers := []string{"Instances", "Apps"}
headers = append(headers, extraHeaders...)
table.Headers = cmd.Row(headers)
ctx.Stdout.Write(table.Bytes())
}
return nil
}
func unsetCName(g 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
}
request, err := http.NewRequest("DELETE", url, nil)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
return nil
}
func (c *UnitAdd) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/units", appName))
if err != nil {
return err
}
request, err := http.NewRequest("PUT", url, bytes.NewBufferString(context.Args[0]))
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprintln(context.Stdout, "Units successfully added!")
return nil
}
func setCName(v string, g 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
}
body := strings.NewReader(fmt.Sprintf(`{"cname": "%s"}`, v))
request, err := http.NewRequest("POST", url, body)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
return nil
}
func (sa ServiceAdd) Run(ctx *cmd.Context, client *cmd.Client) error {
srvName, instName := ctx.Args[0], ctx.Args[1]
fmtBody := fmt.Sprintf(`{"name": "%s", "service_name": "%s"}`, instName, srvName)
b := bytes.NewBufferString(fmtBody)
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 (sb *ServiceBind) Run(ctx *cmd.Context, client *cmd.Client) error {
appName, err := sb.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("PUT", url, nil)
if err != nil {
return err
}
resp, err := client.Do(request)
if err != nil {
return err
}
defer resp.Body.Close()
var variables []string
dec := json.NewDecoder(resp.Body)
msg := fmt.Sprintf("Instance %q is now bound to the app %q.", instanceName, appName)
if err = dec.Decode(&variables); err == nil {
msg += fmt.Sprintf(`
The following environment variables are now available for use in your app:
- %s
For more details, please check the documentation for the service, using service-doc command.
`, strings.Join(variables, "\n- "))
}
n, err := fmt.Fprint(ctx.Stdout, msg)
if err != nil {
return err
}
if n != len(msg) {
return io.ErrShortWrite
}
return nil
}
func (c *AppRevoke) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
teamName := context.Args[0]
url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/%s", appName, teamName))
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(context.Stdout, `Team "%s" was removed from the "%s" app`+"\n", teamName, appName)
return nil
}
func (c *tokenGen) Run(ctx *cmd.Context, client *cmd.Client) error {
app := ctx.Args[0]
url, err := cmd.GetURL("/tokens")
if err != nil {
return err
}
body := strings.NewReader(fmt.Sprintf(`{"client":"%s","export":%v}`, app, c.export))
request, _ := http.NewRequest("POST", url, body)
resp, err := client.Do(request)
if err != nil {
return err
}
defer resp.Body.Close()
var token map[string]string
err = json.NewDecoder(resp.Body).Decode(&token)
if err != nil {
return err
}
fmt.Fprintf(ctx.Stdout, "Application token: %q.\n", token["token"])
return nil
}
func (c *AppGrant) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
teamName := context.Args[0]
url, err := cmd.GetUrl(fmt.Sprintf("/apps/%s/%s", appName, teamName))
if err != nil {
return err
}
request, err := http.NewRequest("PUT", url, nil)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprintf(context.Stdout, `Team "%s" was added to the "%s" app`+"\n", teamName, appName)
return nil
}
func (c *UnitRemove) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
if err != nil {
return err
}
url, err := cmd.GetUrl(fmt.Sprintf("/apps/%s/units", appName))
if err != nil {
return err
}
body := bytes.NewBufferString(context.Args[0])
request, err := http.NewRequest("DELETE", url, body)
if err != nil {
return err
}
_, err = client.Do(request)
if err != nil {
return err
}
fmt.Fprintln(context.Stdout, "Units successfully removed!")
return nil
}
func (c *logRemove) Run(context *cmd.Context, client *cmd.Client) error {
appName, err := c.Guess()
uri := "/logs"
if err == nil {
uri += "?app=" + appName
}
url, err := cmd.GetURL(uri)
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(context.Stdout, "Logs successfully removed!\n")
return nil
}