Refactoring execdriver.Command and Container structs to support 'docker exec' and other

similar features in the future.

Docker-DCO-1.1-Signed-off-by: Vishnu Kannan <vishnuk@google.com> (github: vishh)

daemon/attach.go

@@ -103,7 +103,6 @@ func (daemon *Daemon) ContainerAttach(job *engine.Job) engine.Status {
 		}
 
 		<-daemon.Attach(container, cStdin, cStdinCloser, cStdout, cStderr)
-
 		// If we are in stdinonce mode, wait for the process to end
 		// otherwise, simply return
 		if container.Config.StdinOnce && !container.Config.Tty {
@@ -128,7 +127,7 @@ func (daemon *Daemon) Attach(container *Container, stdin io.ReadCloser, stdinClo
 
 	if stdin != nil && container.Config.OpenStdin {
 		nJobs++
-		if cStdin, err := container.StdinPipe(); err != nil {
+		if cStdin, err := container.StdConfig.StdinPipe(); err != nil {
 			errors <- err
 		} else {
 			go func() {
@@ -164,7 +163,7 @@ func (daemon *Daemon) Attach(container *Container, stdin io.ReadCloser, stdinClo
 	}
 	if stdout != nil {
 		nJobs++
-		if p, err := container.StdoutPipe(); err != nil {
+		if p, err := container.StdConfig.StdoutPipe(); err != nil {
 			errors <- err
 		} else {
 			cStdout = p
@@ -193,7 +192,7 @@ func (daemon *Daemon) Attach(container *Container, stdin io.ReadCloser, stdinClo
 			if stdinCloser != nil {
 				defer stdinCloser.Close()
 			}
-			if cStdout, err := container.StdoutPipe(); err != nil {
+			if cStdout, err := container.StdConfig.StdoutPipe(); err != nil {
 				log.Errorf("attach: stdout pipe: %s", err)
 			} else {
 				io.Copy(&utils.NopWriter{}, cStdout)
@@ -202,7 +201,7 @@ func (daemon *Daemon) Attach(container *Container, stdin io.ReadCloser, stdinClo
 	}
 	if stderr != nil {
 		nJobs++
-		if p, err := container.StderrPipe(); err != nil {
+		if p, err := container.StdConfig.StderrPipe(); err != nil {
 			errors <- err
 		} else {
 			cStderr = p
@@ -232,7 +231,7 @@ func (daemon *Daemon) Attach(container *Container, stdin io.ReadCloser, stdinClo
 				defer stdinCloser.Close()
 			}
 
-			if cStderr, err := container.StderrPipe(); err != nil {
+			if cStderr, err := container.StdConfig.StderrPipe(); err != nil {
 				log.Errorf("attach: stdout pipe: %s", err)
 			} else {
 				io.Copy(&utils.NopWriter{}, cStderr)

daemon/container.go

@@ -41,6 +41,13 @@ var (
 	ErrContainerStartTimeout = errors.New("The container failed to start due to timed out.")
 )
 
+type StdConfig struct {
+	stdout    *broadcastwriter.BroadcastWriter
+	stderr    *broadcastwriter.BroadcastWriter
+	stdin     io.ReadCloser
+	stdinPipe io.WriteCloser
+}
+
 type Container struct {
 	*State
 	root   string // Path to the "home" of the container, including metadata.
@@ -66,10 +73,7 @@ type Container struct {
 	ExecDriver     string
 
 	command   *execdriver.Command
-	stdout    *broadcastwriter.BroadcastWriter
-	stderr    *broadcastwriter.BroadcastWriter
-	stdin     io.ReadCloser
-	stdinPipe io.WriteCloser
+	StdConfig StdConfig
 
 	daemon                   *Daemon
 	MountLabel, ProcessLabel string
@@ -247,26 +251,31 @@ func populateCommand(c *Container, env []string) error {
 		CpuShares:  c.Config.CpuShares,
 		Cpuset:     c.Config.Cpuset,
 	}
+
+	processConfig := execdriver.ProcessConfig{
+		Privileged: c.hostConfig.Privileged,
+		Entrypoint: c.Path,
+		Arguments:  c.Args,
+		Tty:        c.Config.Tty,
+		User:       c.Config.User,
+	}
+	processConfig.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+	processConfig.Env = env
 	c.command = &execdriver.Command{
 		ID:                 c.ID,
-		Privileged:         c.hostConfig.Privileged,
 		Rootfs:             c.RootfsPath(),
 		InitPath:           "/.dockerinit",
-		Entrypoint:         c.Path,
-		Arguments:          c.Args,
 		WorkingDir:         c.Config.WorkingDir,
 		Network:            en,
-		Tty:                c.Config.Tty,
-		User:               c.Config.User,
 		Config:             context,
 		Resources:          resources,
 		AllowedDevices:     allowedDevices,
 		AutoCreatedDevices: autoCreatedDevices,
 		CapAdd:             c.hostConfig.CapAdd,
 		CapDrop:            c.hostConfig.CapDrop,
+		ProcessConfig:      processConfig,
 	}
-	c.command.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
-	c.command.Env = env
+
 	return nil
 }
 
@@ -329,7 +338,7 @@ func (container *Container) Run() error {
 }
 
 func (container *Container) Output() (output []byte, err error) {
-	pipe, err := container.StdoutPipe()
+	pipe, err := container.StdConfig.StdoutPipe()
 	if err != nil {
 		return nil, err
 	}
@@ -342,7 +351,7 @@ func (container *Container) Output() (output []byte, err error) {
 	return output, err
 }
 
-// Container.StdinPipe returns a WriteCloser which can be used to feed data
+// StdConfig.StdinPipe returns a WriteCloser which can be used to feed data
 // to the standard input of the container's active process.
 // Container.StdoutPipe and Container.StderrPipe each return a ReadCloser
 // which can be used to retrieve the standard output (and error) generated
@@ -350,31 +359,31 @@ func (container *Container) Output() (output []byte, err error) {
 // copied and delivered to all StdoutPipe and StderrPipe consumers, using
 // a kind of "broadcaster".
 
-func (container *Container) StdinPipe() (io.WriteCloser, error) {
-	return container.stdinPipe, nil
+func (stdConfig *StdConfig) StdinPipe() (io.WriteCloser, error) {
+	return stdConfig.stdinPipe, nil
 }
 
-func (container *Container) StdoutPipe() (io.ReadCloser, error) {
+func (stdConfig *StdConfig) StdoutPipe() (io.ReadCloser, error) {
 	reader, writer := io.Pipe()
-	container.stdout.AddWriter(writer, "")
+	stdConfig.stdout.AddWriter(writer, "")
 	return utils.NewBufReader(reader), nil
 }
 
-func (container *Container) StderrPipe() (io.ReadCloser, error) {
+func (stdConfig *StdConfig) StderrPipe() (io.ReadCloser, error) {
 	reader, writer := io.Pipe()
-	container.stderr.AddWriter(writer, "")
+	stdConfig.stderr.AddWriter(writer, "")
 	return utils.NewBufReader(reader), nil
 }
 
 func (container *Container) StdoutLogPipe() io.ReadCloser {
 	reader, writer := io.Pipe()
-	container.stdout.AddWriter(writer, "stdout")
+	container.StdConfig.stdout.AddWriter(writer, "stdout")
 	return utils.NewBufReader(reader)
 }
 
 func (container *Container) StderrLogPipe() io.ReadCloser {
 	reader, writer := io.Pipe()
-	container.stderr.AddWriter(writer, "stderr")
+	container.StdConfig.stderr.AddWriter(writer, "stderr")
 	return utils.NewBufReader(reader)
 }
 
@@ -631,7 +640,7 @@ func (container *Container) Restart(seconds int) error {
 }
 
 func (container *Container) Resize(h, w int) error {
-	return container.command.Terminal.Resize(h, w)
+	return container.command.ProcessConfig.Terminal.Resize(h, w)
 }
 
 func (container *Container) ExportRw() (archive.Archive, error) {
@@ -815,7 +824,7 @@ func (container *Container) Exposes(p nat.Port) bool {
 }
 
 func (container *Container) GetPtyMaster() (*os.File, error) {
-	ttyConsole, ok := container.command.Terminal.(execdriver.TtyTerminal)
+	ttyConsole, ok := container.command.ProcessConfig.Terminal.(execdriver.TtyTerminal)
 	if !ok {
 		return nil, ErrNoTTY
 	}
@@ -1083,11 +1092,11 @@ func (container *Container) startLoggingToDisk() error {
 		return err
 	}
 
-	if err := container.daemon.LogToDisk(container.stdout, pth, "stdout"); err != nil {
+	if err := container.daemon.LogToDisk(container.StdConfig.stdout, pth, "stdout"); err != nil {
 		return err
 	}
 
-	if err := container.daemon.LogToDisk(container.stderr, pth, "stderr"); err != nil {
+	if err := container.daemon.LogToDisk(container.StdConfig.stderr, pth, "stderr"); err != nil {
 		return err
 	}
 

daemon/daemon.go

@@ -195,13 +195,13 @@ func (daemon *Daemon) register(container *Container, updateSuffixarray bool) err
 	container.daemon = daemon
 
 	// Attach to stdout and stderr
-	container.stderr = broadcastwriter.New()
-	container.stdout = broadcastwriter.New()
+	container.StdConfig.stderr = broadcastwriter.New()
+	container.StdConfig.stdout = broadcastwriter.New()
 	// Attach to stdin
 	if container.Config.OpenStdin {
-		container.stdin, container.stdinPipe = io.Pipe()
+		container.StdConfig.stdin, container.StdConfig.stdinPipe = io.Pipe()
 	} else {
-		container.stdinPipe = utils.NopWriteCloser(ioutil.Discard) // Silently drop stdin
+		container.StdConfig.stdinPipe = utils.NopWriteCloser(ioutil.Discard) // Silently drop stdin
 	}
 	// done
 	daemon.containers.Add(container.ID, container)
@@ -229,7 +229,7 @@ func (daemon *Daemon) register(container *Container, updateSuffixarray bool) err
 				ID: container.ID,
 			}
 			var err error
-			cmd.Process, err = os.FindProcess(existingPid)
+			cmd.ProcessConfig.Process, err = os.FindProcess(existingPid)
 			if err != nil {
 				log.Debugf("cannot find existing process for %d", existingPid)
 			}

daemon/execdriver/driver.go

@@ -20,7 +20,7 @@ var (
 	ErrDriverNotFound          = errors.New("The requested docker init has not been found")
 )
 
-type StartCallback func(*Command)
+type StartCallback func(*ProcessConfig)
 
 // Driver specific information based on
 // processes registered with the driver
@@ -80,20 +80,27 @@ type Mount struct {
 	Private     bool   `json:"private"`
 }
 
-// Process wrapps an os/exec.Cmd to add more metadata
-type Command struct {
+// Describes a process that will be run inside a container.
+type ProcessConfig struct {
 	exec.Cmd `json:"-"`
 
+	Privileged   bool     `json:"privileged"`
+	User         string   `json:"user"`
+	Tty          bool     `json:"tty"`
+	Entrypoint   string   `json:"entrypoint"`
+	Arguments    []string `json:"arguments"`
+	Terminal     Terminal `json:"-"`             // standard or tty terminal
+	ContainerPid int      `json:"container_pid"` // the pid for the process inside a container
+	Console      string   `json:"-"`             // dev/console path
+}
+
+// Process wrapps an os/exec.Cmd to add more metadata
+type Command struct {
 	ID                 string              `json:"id"`
-	Privileged         bool                `json:"privileged"`
-	User               string              `json:"user"`
 	Rootfs             string              `json:"rootfs"`   // root fs of the container
 	InitPath           string              `json:"initpath"` // dockerinit
-	Entrypoint         string              `json:"entrypoint"`
-	Arguments          []string            `json:"arguments"`
 	WorkingDir         string              `json:"working_dir"`
 	ConfigPath         string              `json:"config_path"` // this should be able to be removed when the lxc template is moved into the driver
-	Tty                bool                `json:"tty"`
 	Network            *Network            `json:"network"`
 	Config             map[string][]string `json:"config"` //  generic values that specific drivers can consume
 	Resources          *Resources          `json:"resources"`
@@ -103,13 +110,11 @@ type Command struct {
 	CapAdd             []string            `json:"cap_add"`
 	CapDrop            []string            `json:"cap_drop"`
 
-	Terminal     Terminal `json:"-"`             // standard or tty terminal
-	Console      string   `json:"-"`             // dev/console path
-	ContainerPid int      `json:"container_pid"` // the pid for the process inside a container
+	ProcessConfig ProcessConfig `json:"process_config"` // Describes the init process of the container.
 }
 
 // Return the pid of the process
 // If the process is nil -1 will be returned
-func (c *Command) Pid() int {
-	return c.ContainerPid
+func (processConfig *ProcessConfig) Pid() int {
+	return processConfig.ContainerPid
 }

daemon/execdriver/lxc/driver.go

@@ -59,12 +59,12 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 		err  error
 	)
 
-	if c.Tty {
-		term, err = NewTtyConsole(c, pipes)
+	if c.ProcessConfig.Tty {
+		term, err = NewTtyConsole(&c.ProcessConfig, pipes)
 	} else {
-		term, err = execdriver.NewStdConsole(c, pipes)
+		term, err = execdriver.NewStdConsole(&c.ProcessConfig, pipes)
 	}
-	c.Terminal = term
+	c.ProcessConfig.Terminal = term
 
 	c.Mounts = append(c.Mounts, execdriver.Mount{
 		Source:      d.initPath,
@@ -98,11 +98,11 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 		"-mtu", strconv.Itoa(c.Network.Mtu),
 	)
 
-	if c.User != "" {
-		params = append(params, "-u", c.User)
+	if c.ProcessConfig.User != "" {
+		params = append(params, "-u", c.ProcessConfig.User)
 	}
 
-	if c.Privileged {
+	if c.ProcessConfig.Privileged {
 		if d.apparmor {
 			params[0] = path.Join(d.root, "lxc-start-unconfined")
 
@@ -122,8 +122,8 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 		params = append(params, fmt.Sprintf("-cap-drop=%s", strings.Join(c.CapDrop, ":")))
 	}
 
-	params = append(params, "--", c.Entrypoint)
-	params = append(params, c.Arguments...)
+	params = append(params, "--", c.ProcessConfig.Entrypoint)
+	params = append(params, c.ProcessConfig.Arguments...)
 
 	if d.sharedRoot {
 		// lxc-start really needs / to be non-shared, or all kinds of stuff break
@@ -149,14 +149,14 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 	if err != nil {
 		aname = name
 	}
-	c.Path = aname
-	c.Args = append([]string{name}, arg...)
+	c.ProcessConfig.Path = aname
+	c.ProcessConfig.Args = append([]string{name}, arg...)
 
 	if err := nodes.CreateDeviceNodes(c.Rootfs, c.AutoCreatedDevices); err != nil {
 		return -1, err
 	}
 
-	if err := c.Start(); err != nil {
+	if err := c.ProcessConfig.Start(); err != nil {
 		return -1, err
 	}
 
@@ -166,7 +166,7 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 	)
 
 	go func() {
-		if err := c.Wait(); err != nil {
+		if err := c.ProcessConfig.Wait(); err != nil {
 			if _, ok := err.(*exec.ExitError); !ok { // Do not propagate the error if it's simply a status code != 0
 				waitErr = err
 			}
@@ -177,17 +177,17 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 	// Poll lxc for RUNNING status
 	pid, err := d.waitForStart(c, waitLock)
 	if err != nil {
-		if c.Process != nil {
-			c.Process.Kill()
-			c.Wait()
+		if c.ProcessConfig.Process != nil {
+			c.ProcessConfig.Process.Kill()
+			c.ProcessConfig.Wait()
 		}
 		return -1, err
 	}
 
-	c.ContainerPid = pid
+	c.ProcessConfig.ContainerPid = pid
 
 	if startCallback != nil {
-		startCallback(c)
+		startCallback(&c.ProcessConfig)
 	}
 
 	<-waitLock
@@ -198,10 +198,10 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 /// Return the exit code of the process
 // if the process has not exited -1 will be returned
 func getExitCode(c *execdriver.Command) int {
-	if c.ProcessState == nil {
+	if c.ProcessConfig.ProcessState == nil {
 		return -1
 	}
-	return c.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
+	return c.ProcessConfig.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
 }
 
 func (d *driver) Kill(c *execdriver.Command, sig int) error {
@@ -442,7 +442,7 @@ func (d *driver) generateLXCConfig(c *execdriver.Command) (string, error) {
 }
 
 func (d *driver) generateEnvConfig(c *execdriver.Command) error {
-	data, err := json.Marshal(c.Env)
+	data, err := json.Marshal(c.ProcessConfig.Env)
 	if err != nil {
 		return err
 	}
@@ -462,7 +462,7 @@ type TtyConsole struct {
 	SlavePty  *os.File
 }
 
-func NewTtyConsole(command *execdriver.Command, pipes *execdriver.Pipes) (*TtyConsole, error) {
+func NewTtyConsole(processConfig *execdriver.ProcessConfig, pipes *execdriver.Pipes) (*TtyConsole, error) {
 	// lxc is special in that we cannot create the master outside of the container without
 	// opening the slave because we have nothing to provide to the cmd.  We have to open both then do
 	// the crazy setup on command right now instead of passing the console path to lxc and telling it
@@ -478,12 +478,12 @@ func NewTtyConsole(command *execdriver.Command, pipes *execdriver.Pipes) (*TtyCo
 		SlavePty:  ptySlave,
 	}
 
-	if err := tty.AttachPipes(&command.Cmd, pipes); err != nil {
+	if err := tty.AttachPipes(&processConfig.Cmd, pipes); err != nil {
 		tty.Close()
 		return nil, err
 	}
 
-	command.Console = tty.SlavePty.Name()
+	processConfig.Console = tty.SlavePty.Name()
 
 	return tty, nil
 }

daemon/execdriver/lxc/lxc_template.go

@@ -42,7 +42,7 @@ lxc.se_context = {{ .ProcessLabel}}
 # no controlling tty at all
 lxc.tty = 1
 
-{{if .Privileged}}
+{{if .ProcessConfig.Privileged}}
 lxc.cgroup.devices.allow = a
 {{else}}
 # no implicit access to devices
@@ -66,7 +66,7 @@ lxc.pivotdir = lxc_putold
 lxc.mount.entry = proc {{escapeFstabSpaces $ROOTFS}}/proc proc nosuid,nodev,noexec 0 0
 lxc.mount.entry = sysfs {{escapeFstabSpaces $ROOTFS}}/sys sysfs nosuid,nodev,noexec 0 0
 
-{{if .Tty}}
+{{if .ProcessConfig.Tty}}
 lxc.mount.entry = {{.Console}} {{escapeFstabSpaces $ROOTFS}}/dev/console none bind,rw 0 0
 {{end}}
 
@@ -81,7 +81,7 @@ lxc.mount.entry = {{$value.Source}} {{escapeFstabSpaces $ROOTFS}}/{{escapeFstabS
 {{end}}
 {{end}}
 
-{{if .Privileged}}
+{{if .ProcessConfig.Privileged}}
 {{if .AppArmor}}
 lxc.aa_profile = unconfined
 {{else}}

daemon/execdriver/lxc/lxc_template_unit_test.go

@@ -77,9 +77,11 @@ func TestCustomLxcConfig(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	command := &execdriver.Command{
-		ID:         "1",
+	processConfig := execdriver.ProcessConfig{
 		Privileged: false,
+	}
+	command := &execdriver.Command{
+		ID: "1",
 		Config: map[string][]string{
 			"lxc": {
 				"lxc.utsname = docker",
@@ -90,6 +92,7 @@ func TestCustomLxcConfig(t *testing.T) {
 			Mtu:       1500,
 			Interface: nil,
 		},
+		ProcessConfig: processConfig,
 	}
 
 	p, err := driver.generateLXCConfig(command)

daemon/execdriver/native/create.go

@@ -23,11 +23,11 @@ import (
 func (d *driver) createContainer(c *execdriver.Command) (*libcontainer.Config, error) {
 	container := template.New()
 
-	container.Hostname = getEnv("HOSTNAME", c.Env)
-	container.Tty = c.Tty
-	container.User = c.User
+	container.Hostname = getEnv("HOSTNAME", c.ProcessConfig.Env)
+	container.Tty = c.ProcessConfig.Tty
+	container.User = c.ProcessConfig.User
 	container.WorkingDir = c.WorkingDir
-	container.Env = c.Env
+	container.Env = c.ProcessConfig.Env
 	container.Cgroups.Name = c.ID
 	container.Cgroups.AllowedDevices = c.AllowedDevices
 	container.MountConfig.DeviceNodes = c.AutoCreatedDevices
@@ -40,7 +40,7 @@ func (d *driver) createContainer(c *execdriver.Command) (*libcontainer.Config, e
 		return nil, err
 	}
 
-	if c.Privileged {
+	if c.ProcessConfig.Privileged {
 		if err := d.setPrivileged(container); err != nil {
 			return nil, err
 		}

daemon/execdriver/native/driver.go

@@ -68,26 +68,26 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 
 	var term execdriver.Terminal
 
-	if c.Tty {
-		term, err = NewTtyConsole(c, pipes)
+	if c.ProcessConfig.Tty {
+		term, err = NewTtyConsole(&c.ProcessConfig, pipes)
 	} else {
-		term, err = execdriver.NewStdConsole(c, pipes)
+		term, err = execdriver.NewStdConsole(&c.ProcessConfig, pipes)
 	}
 	if err != nil {
 		return -1, err
 	}
-	c.Terminal = term
+	c.ProcessConfig.Terminal = term
 
 	d.Lock()
 	d.activeContainers[c.ID] = &activeContainer{
 		container: container,
-		cmd:       &c.Cmd,
+		cmd:       &c.ProcessConfig.Cmd,
 	}
 	d.Unlock()
 
 	var (
 		dataPath = filepath.Join(d.root, c.ID)
-		args     = append([]string{c.Entrypoint}, c.Arguments...)
+		args     = append([]string{c.ProcessConfig.Entrypoint}, c.ProcessConfig.Arguments...)
 	)
 
 	if err := d.createContainerRoot(c.ID); err != nil {
@@ -99,9 +99,9 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 		return -1, err
 	}
 
-	return namespaces.Exec(container, c.Stdin, c.Stdout, c.Stderr, c.Console, c.Rootfs, dataPath, args, func(container *libcontainer.Config, console, rootfs, dataPath, init string, child *os.File, args []string) *exec.Cmd {
-		c.Path = d.initPath
-		c.Args = append([]string{
+	return namespaces.Exec(container, c.ProcessConfig.Stdin, c.ProcessConfig.Stdout, c.ProcessConfig.Stderr, c.ProcessConfig.Console, c.Rootfs, dataPath, args, func(container *libcontainer.Config, console, rootfs, dataPath, init string, child *os.File, args []string) *exec.Cmd {
+		c.ProcessConfig.Path = d.initPath
+		c.ProcessConfig.Args = append([]string{
 			DriverName,
 			"-console", console,
 			"-pipe", "3",
@@ -110,25 +110,25 @@ func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallba
 		}, args...)
 
 		// set this to nil so that when we set the clone flags anything else is reset
-		c.SysProcAttr = &syscall.SysProcAttr{
+		c.ProcessConfig.SysProcAttr = &syscall.SysProcAttr{
 			Cloneflags: uintptr(namespaces.GetNamespaceFlags(container.Namespaces)),
 		}
-		c.ExtraFiles = []*os.File{child}
+		c.ProcessConfig.ExtraFiles = []*os.File{child}
 
-		c.Env = container.Env
-		c.Dir = c.Rootfs
+		c.ProcessConfig.Env = container.Env
+		c.ProcessConfig.Dir = c.Rootfs
 
-		return &c.Cmd
+		return &c.ProcessConfig.Cmd
 	}, func() {
 		if startCallback != nil {
-			c.ContainerPid = c.Process.Pid
-			startCallback(c)
+			c.ProcessConfig.ContainerPid = c.ProcessConfig.Process.Pid
+			startCallback(&c.ProcessConfig)
 		}
 	})
 }
 
 func (d *driver) Kill(p *execdriver.Command, sig int) error {
-	return syscall.Kill(p.Process.Pid, syscall.Signal(sig))
+	return syscall.Kill(p.ProcessConfig.Process.Pid, syscall.Signal(sig))
 }
 
 func (d *driver) Pause(c *execdriver.Command) error {
@@ -176,14 +176,14 @@ func (d *driver) Terminate(p *execdriver.Command) error {
 		state = &libcontainer.State{InitStartTime: string(data)}
 	}
 
-	currentStartTime, err := system.GetProcessStartTime(p.Process.Pid)
+	currentStartTime, err := system.GetProcessStartTime(p.ProcessConfig.Process.Pid)
 	if err != nil {
 		return err
 	}
 
 	if state.InitStartTime == currentStartTime {
-		err = syscall.Kill(p.Process.Pid, 9)
-		syscall.Wait4(p.Process.Pid, nil, 0, nil)
+		err = syscall.Kill(p.ProcessConfig.Process.Pid, 9)
+		syscall.Wait4(p.ProcessConfig.Process.Pid, nil, 0, nil)
 	}
 	d.removeContainerRoot(p.ID)
 
@@ -252,7 +252,7 @@ type TtyConsole struct {
 	MasterPty *os.File
 }
 
-func NewTtyConsole(command *execdriver.Command, pipes *execdriver.Pipes) (*TtyConsole, error) {
+func NewTtyConsole(processConfig *execdriver.ProcessConfig, pipes *execdriver.Pipes) (*TtyConsole, error) {
 	ptyMaster, console, err := consolepkg.CreateMasterAndConsole()
 	if err != nil {
 		return nil, err
@@ -262,12 +262,12 @@ func NewTtyConsole(command *execdriver.Command, pipes *execdriver.Pipes) (*TtyCo
 		MasterPty: ptyMaster,
 	}
 
-	if err := tty.AttachPipes(&command.Cmd, pipes); err != nil {
+	if err := tty.AttachPipes(&processConfig.Cmd, pipes); err != nil {
 		tty.Close()
 		return nil, err
 	}
 
-	command.Console = console
+	processConfig.Console = console
 
 	return tty, nil
 }

daemon/execdriver/termconsole.go

@@ -8,10 +8,10 @@ import (
 type StdConsole struct {
 }
 
-func NewStdConsole(command *Command, pipes *Pipes) (*StdConsole, error) {
+func NewStdConsole(processConfig *ProcessConfig, pipes *Pipes) (*StdConsole, error) {
 	std := &StdConsole{}
 
-	if err := std.AttachPipes(&command.Cmd, pipes); err != nil {
+	if err := std.AttachPipes(&processConfig.Cmd, pipes); err != nil {
 		return nil, err
 	}
 	return std, nil

daemon/monitor.go

@@ -128,7 +128,7 @@ func (m *containerMonitor) Start() error {
 			return err
 		}
 
-		pipes := execdriver.NewPipes(m.container.stdin, m.container.stdout, m.container.stderr, m.container.Config.OpenStdin)
+		pipes := execdriver.NewPipes(m.container.StdConfig.stdin, m.container.StdConfig.stdout, m.container.StdConfig.stderr, m.container.Config.OpenStdin)
 
 		m.container.LogEvent("start")
 
@@ -233,17 +233,17 @@ func (m *containerMonitor) shouldRestart(exitStatus int) bool {
 
 // callback ensures that the container's state is properly updated after we
 // received ack from the execution drivers
-func (m *containerMonitor) callback(command *execdriver.Command) {
-	if command.Tty {
+func (m *containerMonitor) callback(processConfig *execdriver.ProcessConfig) {
+	if processConfig.Tty {
 		// The callback is called after the process Start()
 		// so we are in the parent process. In TTY mode, stdin/out/err is the PtySlace
 		// which we close here.
-		if c, ok := command.Stdout.(io.Closer); ok {
+		if c, ok := processConfig.Stdout.(io.Closer); ok {
 			c.Close()
 		}
 	}
 
-	m.container.State.setRunning(command.Pid())
+	m.container.State.setRunning(processConfig.Pid())
 
 	// signal that the process has started
 	// close channel only if not closed
@@ -269,33 +269,33 @@ func (m *containerMonitor) resetContainer(lock bool) {
 	}
 
 	if container.Config.OpenStdin {
-		if err := container.stdin.Close(); err != nil {
+		if err := container.StdConfig.stdin.Close(); err != nil {
 			log.Errorf("%s: Error close stdin: %s", container.ID, err)
 		}
 	}
 
-	if err := container.stdout.Clean(); err != nil {
+	if err := container.StdConfig.stdout.Clean(); err != nil {
 		log.Errorf("%s: Error close stdout: %s", container.ID, err)
 	}
 
-	if err := container.stderr.Clean(); err != nil {
+	if err := container.StdConfig.stderr.Clean(); err != nil {
 		log.Errorf("%s: Error close stderr: %s", container.ID, err)
 	}
 
-	if container.command != nil && container.command.Terminal != nil {
-		if err := container.command.Terminal.Close(); err != nil {
+	if container.command != nil && container.command.ProcessConfig.Terminal != nil {
+		if err := container.command.ProcessConfig.Terminal.Close(); err != nil {
 			log.Errorf("%s: Error closing terminal: %s", container.ID, err)
 		}
 	}
 
 	// Re-create a brand new stdin pipe once the container exited
 	if container.Config.OpenStdin {
-		container.stdin, container.stdinPipe = io.Pipe()
+		container.StdConfig.stdin, container.StdConfig.stdinPipe = io.Pipe()
 	}
 
-	c := container.command.Cmd
+	c := container.command.ProcessConfig.Cmd
 
-	container.command.Cmd = exec.Cmd{
+	container.command.ProcessConfig.Cmd = exec.Cmd{
 		Stdin:       c.Stdin,
 		Stdout:      c.Stdout,
 		Stderr:      c.Stderr,

integration/commands_test.go

@@ -467,7 +467,7 @@ func TestAttachDisconnect(t *testing.T) {
 	}
 
 	// Try to avoid the timeout in destroy. Best effort, don't check error
-	cStdin, _ := container.StdinPipe()
+	cStdin, _ := container.StdConfig.StdinPipe()
 	cStdin.Close()
 	container.State.WaitStop(-1 * time.Second)
 }

integration/container_test.go

@@ -25,11 +25,11 @@ func TestRestartStdin(t *testing.T) {
 	}
 	defer daemon.Destroy(container)
 
-	stdin, err := container.StdinPipe()
+	stdin, err := container.StdConfig.StdinPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	stdout, err := container.StdoutPipe()
+	stdout, err := container.StdConfig.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -55,11 +55,11 @@ func TestRestartStdin(t *testing.T) {
 	}
 
 	// Restart and try again
-	stdin, err = container.StdinPipe()
+	stdin, err = container.StdConfig.StdinPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	stdout, err = container.StdoutPipe()
+	stdout, err = container.StdConfig.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -101,11 +101,11 @@ func TestStdin(t *testing.T) {
 	}
 	defer daemon.Destroy(container)
 
-	stdin, err := container.StdinPipe()
+	stdin, err := container.StdConfig.StdinPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	stdout, err := container.StdoutPipe()
+	stdout, err := container.StdConfig.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -146,11 +146,11 @@ func TestTty(t *testing.T) {
 	}
 	defer daemon.Destroy(container)
 
-	stdin, err := container.StdinPipe()
+	stdin, err := container.StdConfig.StdinPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	stdout, err := container.StdoutPipe()
+	stdout, err := container.StdConfig.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
 	}

integration/runtime_test.go

@@ -611,7 +611,7 @@ func TestRestore(t *testing.T) {
 	}
 
 	// Simulate a crash/manual quit of dockerd: process dies, states stays 'Running'
-	cStdin, _ := container2.StdinPipe()
+	cStdin, _ := container2.StdConfig.StdinPipe()
 	cStdin.Close()
 	if _, err := container2.State.WaitStop(2 * time.Second); err != nil {
 		t.Fatal(err)

integration/utils_test.go

@@ -84,11 +84,11 @@ func containerFileExists(eng *engine.Engine, id, dir string, t log.Fataler) bool
 
 func containerAttach(eng *engine.Engine, id string, t log.Fataler) (io.WriteCloser, io.ReadCloser) {
 	c := getContainer(eng, id, t)
-	i, err := c.StdinPipe()
+	i, err := c.StdConfig.StdinPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	o, err := c.StdoutPipe()
+	o, err := c.StdConfig.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -289,7 +289,7 @@ func runContainer(eng *engine.Engine, r *daemon.Daemon, args []string, t *testin
 		return "", err
 	}
 	defer r.Destroy(container)
-	stdout, err := container.StdoutPipe()
+	stdout, err := container.StdConfig.StdoutPipe()
 	if err != nil {
 		return "", err
 	}