234 lines
6.2 KiB
Go
234 lines
6.2 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"strings"
|
|
|
|
"coopcloud.tech/abra/cli/internal"
|
|
"coopcloud.tech/abra/pkg/autocomplete"
|
|
"coopcloud.tech/abra/pkg/client"
|
|
"coopcloud.tech/abra/pkg/config"
|
|
containerPkg "coopcloud.tech/abra/pkg/container"
|
|
"coopcloud.tech/abra/pkg/formatter"
|
|
"coopcloud.tech/abra/pkg/upstream/container"
|
|
"github.com/docker/cli/cli/command"
|
|
"github.com/docker/docker/api/types"
|
|
"github.com/docker/docker/api/types/filters"
|
|
"github.com/docker/docker/pkg/archive"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/urfave/cli"
|
|
)
|
|
|
|
var localCmd bool
|
|
var localCmdFlag = &cli.BoolFlag{
|
|
Name: "local, l",
|
|
Usage: "Run command locally",
|
|
Destination: &localCmd,
|
|
}
|
|
|
|
var remoteUser string
|
|
var remoteUserFlag = &cli.StringFlag{
|
|
Name: "user, u",
|
|
Value: "",
|
|
Usage: "User to run command within a service context",
|
|
Destination: &remoteUser,
|
|
}
|
|
|
|
var appCmdCommand = cli.Command{
|
|
Name: "command",
|
|
Aliases: []string{"cmd"},
|
|
Usage: "Run app commands",
|
|
Description: `
|
|
Run an app specific command.
|
|
|
|
These commands are bash functions, defined in the abra.sh of the recipe itself.
|
|
They can be run within the context of a service (e.g. app) or locally on your
|
|
work station by passing "--local". Arguments can be passed into these functions
|
|
using the "-- <args>" syntax.
|
|
|
|
Example:
|
|
|
|
abra app cmd example.com app create_user -- me@example.com
|
|
`,
|
|
ArgsUsage: "<domain> [<service>] <command>",
|
|
Flags: []cli.Flag{
|
|
internal.DebugFlag,
|
|
localCmdFlag,
|
|
remoteUserFlag,
|
|
},
|
|
BashComplete: autocomplete.AppNameComplete,
|
|
Before: internal.SubCommandBefore,
|
|
Action: func(c *cli.Context) error {
|
|
app := internal.ValidateApp(c)
|
|
|
|
if localCmd && remoteUser != "" {
|
|
internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & <user> together"))
|
|
}
|
|
|
|
abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
|
|
if _, err := os.Stat(abraSh); err != nil {
|
|
if os.IsNotExist(err) {
|
|
logrus.Fatalf("%s does not exist for %s?", abraSh, app.Name)
|
|
}
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
var parsedCmdArgs string
|
|
var cmdArgsIdx int
|
|
var hasCmdArgs bool
|
|
for idx, arg := range c.Args() {
|
|
if arg == "--" {
|
|
cmdArgsIdx = idx
|
|
hasCmdArgs = true
|
|
}
|
|
|
|
if hasCmdArgs && idx > cmdArgsIdx {
|
|
parsedCmdArgs += fmt.Sprintf("%s ", c.Args().Get(idx))
|
|
}
|
|
}
|
|
|
|
if localCmd {
|
|
cmdName := c.Args().Get(1)
|
|
if err := ensureCommand(abraSh, app.Recipe, cmdName); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
logrus.Debugf("--local detected, running %s on local work station", cmdName)
|
|
|
|
var sourceAndExec string
|
|
if hasCmdArgs {
|
|
logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
|
|
sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; . %s; %s %s", app.Name, app.StackName(), abraSh, cmdName, parsedCmdArgs)
|
|
} else {
|
|
logrus.Debug("did not detect any command arguments")
|
|
sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; . %s; %s", app.Name, app.StackName(), abraSh, cmdName)
|
|
}
|
|
|
|
cmd := exec.Command("/bin/sh", "-c", sourceAndExec)
|
|
|
|
if err := internal.RunCmd(cmd); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
} else {
|
|
targetServiceName := c.Args().Get(1)
|
|
|
|
cmdName := c.Args().Get(2)
|
|
if err := ensureCommand(abraSh, app.Recipe, cmdName); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
serviceNames, err := config.GetAppServiceNames(app.Name)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
matchingServiceName := false
|
|
for _, serviceName := range serviceNames {
|
|
if serviceName == targetServiceName {
|
|
matchingServiceName = true
|
|
}
|
|
}
|
|
|
|
if !matchingServiceName {
|
|
logrus.Fatalf("no service %s for %s?", targetServiceName, app.Name)
|
|
}
|
|
|
|
logrus.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
|
|
|
|
if hasCmdArgs {
|
|
logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
|
|
} else {
|
|
logrus.Debug("did not detect any command arguments")
|
|
}
|
|
|
|
if err := runCmdRemote(app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
func ensureCommand(abraSh, recipeName, execCmd string) error {
|
|
bytes, err := ioutil.ReadFile(abraSh)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !strings.Contains(string(bytes), execCmd) {
|
|
return fmt.Errorf("%s doesn't have a %s function", recipeName, execCmd)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func runCmdRemote(app config.App, abraSh, serviceName, cmdName, cmdArgs string) error {
|
|
cl, err := client.New(app.Server)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
filters := filters.NewArgs()
|
|
filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
|
|
|
|
targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server)
|
|
|
|
toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}
|
|
content, err := archive.TarWithOptions(abraSh, toTarOpts)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
|
|
if err := cl.CopyToContainer(context.Background(), targetContainer.ID, "/tmp", content, copyOpts); err != nil {
|
|
return err
|
|
}
|
|
|
|
var cmd []string
|
|
if cmdArgs != "" {
|
|
cmd = []string{"/bin/sh", "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; STACK_NAME=%s; . /tmp/abra.sh; %s %s", serviceName, app.Name, app.StackName(), cmdName, cmdArgs)}
|
|
} else {
|
|
cmd = []string{"/bin/sh", "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; STACK_NAME=%s; . /tmp/abra.sh; %s", serviceName, app.Name, app.StackName(), cmdName)}
|
|
}
|
|
|
|
logrus.Debugf("running command: %s", strings.Join(cmd, " "))
|
|
|
|
execCreateOpts := types.ExecConfig{
|
|
AttachStderr: true,
|
|
AttachStdin: true,
|
|
AttachStdout: true,
|
|
Cmd: cmd,
|
|
Detach: false,
|
|
Tty: true,
|
|
}
|
|
|
|
if remoteUser != "" {
|
|
logrus.Debugf("running command with user %s", remoteUser)
|
|
execCreateOpts.User = remoteUser
|
|
}
|
|
|
|
// FIXME: avoid instantiating a new CLI
|
|
dcli, err := command.NewDockerCli()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|