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 *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 (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 *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 (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 *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 *envUnset) 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/env", appName))
if err != nil {
return err
}
var buf bytes.Buffer
json.NewEncoder(&buf).Encode(context.Args)
request, err := http.NewRequest("DELETE", url, &buf)
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 fmt.Errorf("unparsed message error: %s", string(unparsed))
}
return nil
}
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 *moveContainersCmd) Run(context *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/docker/containers/move")
if err != nil {
return err
}
params := map[string]string{
"from": context.Args[0],
"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
}
defer response.Body.Close()
w := tsuruIo.NewStreamWriter(context.Stdout, progressFormatter{})
for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) {
}
return nil
}
func (c *rebalanceContainersCmd) Run(context *cmd.Context, client *cmd.Client) error {
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]string{
"dry": fmt.Sprintf("%t", c.dry),
}
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
}
defer response.Body.Close()
w := tsuruIo.NewStreamWriter(context.Stdout, progressFormatter{})
for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) {
}
return nil
}
func (c *envSet) Run(context *cmd.Context, client *cmd.Client) error {
context.RawOutput()
appName, err := c.Guess()
if err != nil {
return err
}
raw := strings.Join(context.Args, "\n")
regex := regexp.MustCompile(`(\w+=[^\n]+)(\n|$)`)
decls := regex.FindAllStringSubmatch(raw, -1)
if len(decls) < 1 || len(decls) != len(context.Args) {
return errors.New(envSetValidationMessage)
}
variables := make(map[string]string, len(decls))
for _, v := range decls {
parts := strings.SplitN(v[1], "=", 2)
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
}
if c.private {
url += "?private=1"
}
request, err := http.NewRequest("POST", url, &buf)
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 fmt.Errorf("unparsed message error: %s", string(unparsed))
}
return nil
}
// StreamJSONResponse supports the JSON streaming format from the tsuru API.
func StreamJSONResponse(w io.Writer, response *http.Response) error {
if response == nil {
return errors.New("response cannot be nil")
}
defer response.Body.Close()
var err error
output := tsuruio.NewStreamWriter(w, nil)
for n := int64(1); n > 0 && err == nil; n, err = io.Copy(output, response.Body) {
}
if err != nil {
return err
}
unparsed := output.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
}
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 *appLog) 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/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.unit != "" {
url = fmt.Sprintf("%s&unit=%s", url, c.unit)
}
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 := tsuruIo.NewStreamWriter(context.Stdout, logFormatter{
noDate: c.noDate,
noSource: c.noSource,
})
for n := int64(1); n > 0 && err == nil; n, err = io.Copy(w, response.Body) {
}
unparsed := w.Remaining()
if len(unparsed) > 0 {
fmt.Fprintf(context.Stdout, "Error: %s", string(unparsed))
}
return nil
}
func (c *appDeployRollback) Run(context *cmd.Context, client *cmd.Client) error {
context.RawOutput()
appName, err := c.Guess()
if err != nil {
return err
}
imgName := context.Args[0]
if !c.Confirm(context, fmt.Sprintf("Are you sure you want to rollback app %q to image %q?", appName, imgName)) {
return nil
}
url, err := cmd.GetURL(fmt.Sprintf("/apps/%s/deploy/rollback?origin=%s", appName, "rollback"))
if err != nil {
return err
}
body := strings.NewReader("image=" + imgName)
request, err := http.NewRequest("POST", url, body)
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
}