Merge pull request #154 from vdemeester/run-command

Run command

Author: vdemeester

cli/app/app.go

@@ -138,6 +138,27 @@ func ProjectUp(p *project.Project, c *cli.Context) {
 	}
 }
 
+// ProjectRun runs a given command within a service's container.
+func ProjectRun(p *project.Project, c *cli.Context) {
+	if len(c.Args()) == 1 {
+		logrus.Fatal("No service specified")
+	}
+
+	serviceName := c.Args()[0]
+	commandParts := c.Args()[1:]
+
+	if _, ok := p.Configs[serviceName]; !ok {
+		logrus.Fatalf("%s is not defined in the template", serviceName)
+	}
+
+	exitCode, err := p.Run(serviceName, commandParts)
+	if err != nil {
+		logrus.Fatal(err)
+	}
+
+	os.Exit(exitCode)
+}
+
 // ProjectStart starts services.
 func ProjectStart(p *project.Project, c *cli.Context) {
 	err := p.Start(c.Args()...)

cli/command/command.go

@@ -124,6 +124,16 @@ func StartCommand(factory app.ProjectFactory) cli.Command {
 	}
 }
 
+// RunCommand defines the libcompose run subcommand.
+func RunCommand(factory app.ProjectFactory) cli.Command {
+	return cli.Command{
+		Name:   "run",
+		Usage:  "Run a one-off command",
+		Action: app.WithProject(factory, app.ProjectRun),
+		Flags:  []cli.Flag{},
+	}
+}
+
 // PullCommand defines the libcompose pull subcommand.
 func PullCommand(factory app.ProjectFactory) cli.Command {
 	return cli.Command{

cli/main/main.go

@@ -24,21 +24,23 @@ func main() {
 	app.Commands = []cli.Command{
 		command.BuildCommand(factory),
 		command.CreateCommand(factory),
-		command.UpCommand(factory),
-		command.StartCommand(factory),
-		command.LogsCommand(factory),
-		command.RestartCommand(factory),
-		command.StopCommand(factory),
 		command.DownCommand(factory),
-		command.ScaleCommand(factory),
-		command.RmCommand(factory),
-		command.PullCommand(factory),
 		command.KillCommand(factory),
+		command.LogsCommand(factory),
+		command.PauseCommand(factory),
 		command.PortCommand(factory),
 		command.PsCommand(factory),
-		command.PauseCommand(factory),
+		command.PullCommand(factory),
+		command.RestartCommand(factory),
+		command.RmCommand(factory),
+		command.RunCommand(factory),
+		command.ScaleCommand(factory),
+		command.StartCommand(factory),
+		command.StopCommand(factory),
 		command.UnpauseCommand(factory),
+		command.UpCommand(factory),
 	}
 
 	app.Run(os.Args)
+
 }

docker/container.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/Sirupsen/logrus"
 	"github.com/docker/docker/pkg/jsonmessage"
+	"github.com/docker/docker/pkg/promise"
 	"github.com/docker/docker/pkg/stdcopy"
 	"github.com/docker/docker/pkg/term"
 	"github.com/docker/docker/reference"
@@ -145,7 +146,7 @@ func (c *Container) Recreate(imageName string) (*types.Container, error) {
 		return nil, err
 	}
 
-	newContainer, err := c.createContainer(imageName, info.ID)
+	newContainer, err := c.createContainer(imageName, info.ID, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -168,13 +169,20 @@ func (c *Container) Recreate(imageName string) (*types.Container, error) {
 // to notify the container has been created. If the container already exists, does
 // nothing.
 func (c *Container) Create(imageName string) (*types.Container, error) {
+	return c.CreateWithOverride(imageName, nil)
+}
+
+// CreateWithOverride create container and override parts of the config to
+// allow special situations to override the config generated from the compose
+// file
+func (c *Container) CreateWithOverride(imageName string, configOverride *project.ServiceConfig) (*types.Container, error) {
 	container, err := c.findExisting()
 	if err != nil {
 		return nil, err
 	}
 
 	if container == nil {
-		container, err = c.createContainer(imageName, "")
+		container, err = c.createContainer(imageName, "", configOverride)
 		if err != nil {
 			return nil, err
 		}
@@ -274,6 +282,126 @@ func (c *Container) IsRunning() (bool, error) {
 	return info.State.Running, nil
 }
 
+// Run creates, start and attach to the container based on the image name,
+// the specified configuration.
+// It will always create a new container.
+func (c *Container) Run(imageName string, configOverride *project.ServiceConfig) (int, error) {
+	var (
+		errCh       chan error
+		out, stderr io.Writer
+		in          io.ReadCloser
+	)
+
+	container, err := c.createContainer(imageName, "", configOverride)
+	if err != nil {
+		return -1, err
+	}
+
+	info, err := c.client.ContainerInspect(context.Background(), container.ID)
+	if err != nil {
+		return -1, err
+	}
+
+	if configOverride.StdinOpen {
+		in = os.Stdin
+	}
+	if configOverride.Tty {
+		out = os.Stdout
+	}
+	if configOverride.Tty {
+		stderr = os.Stderr
+	}
+
+	options := types.ContainerAttachOptions{
+		ContainerID: container.ID,
+		Stream:      true,
+		Stdin:       configOverride.StdinOpen,
+		Stdout:      configOverride.Tty,
+		Stderr:      configOverride.Tty,
+	}
+
+	resp, err := c.client.ContainerAttach(context.Background(), options)
+	if err != nil {
+		return -1, err
+	}
+
+	// set raw terminal
+	inFd, _ := term.GetFdInfo(in)
+	state, err := term.SetRawTerminal(inFd)
+	if err != nil {
+		return -1, err
+	}
+	// restore raw terminal
+	defer term.RestoreTerminal(inFd, state)
+	// holdHijackedConnection (in goroutine)
+	errCh = promise.Go(func() error {
+		return holdHijackedConnection(configOverride.Tty, in, out, stderr, resp)
+	})
+
+	if err := c.client.ContainerStart(context.Background(), container.ID); err != nil {
+		return -1, err
+	}
+
+	if err := <-errCh; err != nil {
+		logrus.Debugf("Error hijack: %s", err)
+		return -1, err
+	}
+
+	info, err = c.client.ContainerInspect(context.Background(), container.ID)
+	if err != nil {
+		return -1, err
+	}
+
+	return info.State.ExitCode, nil
+}
+
+func holdHijackedConnection(tty bool, inputStream io.ReadCloser, outputStream, errorStream io.Writer, resp types.HijackedResponse) error {
+	var err error
+	receiveStdout := make(chan error, 1)
+	if outputStream != nil || errorStream != nil {
+		go func() {
+			// When TTY is ON, use regular copy
+			if tty && outputStream != nil {
+				_, err = io.Copy(outputStream, resp.Reader)
+			} else {
+				_, err = stdcopy.StdCopy(outputStream, errorStream, resp.Reader)
+			}
+			logrus.Debugf("[hijack] End of stdout")
+			receiveStdout <- err
+		}()
+	}
+
+	stdinDone := make(chan struct{})
+	go func() {
+		if inputStream != nil {
+			io.Copy(resp.Conn, inputStream)
+			logrus.Debugf("[hijack] End of stdin")
+		}
+
+		if err := resp.CloseWrite(); err != nil {
+			logrus.Debugf("Couldn't send EOF: %s", err)
+		}
+		close(stdinDone)
+	}()
+
+	select {
+	case err := <-receiveStdout:
+		if err != nil {
+			logrus.Debugf("Error receiveStdout: %s", err)
+			return err
+		}
+	case <-stdinDone:
+		if outputStream != nil || errorStream != nil {
+			if err := <-receiveStdout; err != nil {
+				logrus.Debugf("Error receiveStdout: %s", err)
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
 // Up creates and start the container based on the image name and send an event
 // to notify the container has been created. If the container exists but is stopped
 // it tries to start it.
@@ -297,20 +425,25 @@ func (c *Container) Up(imageName string) error {
 	}
 
 	if !info.State.Running {
-		logrus.WithFields(logrus.Fields{"container.ID": container.ID, "c.name": c.name}).Debug("Starting container")
-		if err = c.client.ContainerStart(context.Background(), container.ID); err != nil {
-			logrus.WithFields(logrus.Fields{"container.ID": container.ID, "c.name": c.name}).Debug("Failed to start container")
-			return err
-		}
-
-		c.service.context.Project.Notify(project.EventContainerStarted, c.service.Name(), map[string]string{
-			"name": c.Name(),
-		})
+		c.Start(container)
 	}
 
 	return nil
 }
 
+// Start the specified container with the specified host config
+func (c *Container) Start(container *types.Container) error {
+	logrus.WithFields(logrus.Fields{"container.ID": container.ID, "c.name": c.name}).Debug("Starting container")
+	if err := c.client.ContainerStart(context.Background(), container.ID); err != nil {
+		logrus.WithFields(logrus.Fields{"container.ID": container.ID, "c.name": c.name}).Debug("Failed to start container")
+		return err
+	}
+	c.service.context.Project.Notify(project.EventContainerStarted, c.service.Name(), map[string]string{
+		"name": c.Name(),
+	})
+	return nil
+}
+
 // OutOfSync checks if the container is out of sync with the service definition.
 // It looks if the the service hash container label is the same as the computed one.
 func (c *Container) OutOfSync(imageName string) (bool, error) {
@@ -356,7 +489,13 @@ func volumeBinds(volumes map[string]struct{}, container *types.ContainerJSON) []
 	return result
 }
 
-func (c *Container) createContainer(imageName, oldContainer string) (*types.Container, error) {
+func (c *Container) createContainer(imageName, oldContainer string, configOverride *project.ServiceConfig) (*types.Container, error) {
+	serviceConfig := c.service.serviceConfig
+	if configOverride != nil {
+		serviceConfig.Command = configOverride.Command
+		serviceConfig.Tty = configOverride.Tty
+		serviceConfig.StdinOpen = configOverride.StdinOpen
+	}
 	configWrapper, err := ConvertToAPI(c.service)
 	if err != nil {
 		return nil, err

docker/service.go

@@ -205,6 +205,25 @@ func (s *Service) Up() error {
 	return s.up(imageName, true)
 }
 
+// Run implements Service.Run. It runs a one of command within the service container.
+func (s *Service) Run(commandParts []string) (int, error) {
+	imageName, err := s.ensureImageExists()
+	if err != nil {
+		return -1, err
+	}
+
+	client := s.context.ClientFactory.Create(s)
+
+	namer := NewNamer(client, s.context.Project.Name, s.name+"_run")
+	defer namer.Close()
+
+	containerName := namer.Next()
+
+	c := NewContainer(client, containerName, s)
+
+	return c.Run(imageName, &project.ServiceConfig{Command: project.NewCommand(commandParts...), Tty: true, StdinOpen: true})
+}
+
 // Info implements Service.Info. It returns an project.InfoSet with the containers
 // related to this service (can be multiple if using the scale command).
 func (s *Service) Info(qFlag bool) (project.InfoSet, error) {

integration/assets/run/docker-compose.yml

@@ -0,0 +1,2 @@
+hello:
+  image: busybox

integration/common_test.go

@@ -127,11 +127,7 @@ func (s *RunSuite) FromText(c *C, projectName, command string, argsAndInput ...s
 	}
 
 	err := cmd.Run()
-	if err != nil {
-		logrus.Errorf("Failed to run %s %v: %v\n with input:\n%s", s.command, err, args, input)
-	}
-
-	c.Assert(err, IsNil)
+	c.Assert(err, IsNil, Commentf("Failed to run %s %v: %v\n with input:\n%s", s.command, err, args, input))
 
 	return projectName
 }

integration/run_test.go

@@ -0,0 +1,49 @@
+package integration
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+
+	. "gopkg.in/check.v1"
+
+	"github.com/kr/pty"
+)
+
+// FIXME find out why it fails with "inappropriate ioctl for device"
+func (s *RunSuite) TestRun(c *C) {
+	p := s.RandomProject()
+	cmd := exec.Command(s.command, "-f", "./assets/run/docker-compose.yml", "-p", p, "run", "hello", "echo", "test")
+	var b bytes.Buffer
+	wbuf := bufio.NewWriter(&b)
+
+	tty, err := pty.Start(cmd)
+
+	_, err = io.Copy(wbuf, tty)
+	if e, ok := err.(*os.PathError); ok && e.Err == syscall.EIO {
+		// We can safely ignore this error, because it's just
+		// the PTY telling us that it closed successfully.
+		// See:
+		// https://github.com/buildkite/agent/pull/34#issuecomment-46080419
+		err = nil
+	}
+	c.Assert(cmd.Wait(), IsNil)
+	output := string(b.Bytes())
+
+	c.Assert(err, IsNil, Commentf("%s", output))
+
+	name := fmt.Sprintf("%s_%s_run_1", p, "hello")
+	cn := s.GetContainerByName(c, name)
+	c.Assert(cn, NotNil)
+
+	lines := strings.Split(output, "\r\n")
+	lastLine := lines[len(lines)-2 : len(lines)-1][0]
+
+	c.Assert(cn.State.Running, Equals, false)
+	c.Assert(lastLine, Equals, "test")
+}