@@ -249,6 +249,24 @@ RUN set -x \

 	&& go build -v -o /usr/local/bin/rsrc github.com/akavel/rsrc \

 	&& rm -rf "$GOPATH"

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

 ENTRYPOINT ["hack/dind"]

@@ -186,6 +186,24 @@ RUN set -x \

 	&& go build -v -o /usr/local/bin/tomlv github.com/BurntSushi/toml/cmd/tomlv \

 	&& rm -rf "$GOPATH"

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

 ENTRYPOINT ["hack/dind"]

@@ -205,6 +205,24 @@ RUN set -x \

 	&& go build -v -o /usr/local/bin/rsrc github.com/akavel/rsrc \

 	&& rm -rf "$GOPATH"

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

 ENTRYPOINT ["hack/dind"]

@@ -73,6 +73,24 @@ VOLUME /var/lib/docker

 WORKDIR /go/src/github.com/docker/docker

 ENV DOCKER_BUILDTAGS apparmor seccomp selinux

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

 ENTRYPOINT ["hack/dind"]

@@ -197,6 +197,24 @@ RUN set -x \

 	&& go build -v -o /usr/local/bin/rsrc github.com/akavel/rsrc \

 	&& rm -rf "$GOPATH"

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

 ENTRYPOINT ["hack/dind"]

@@ -176,6 +176,24 @@ RUN set -x \

 	&& go build -v -o /usr/local/bin/rsrc github.com/akavel/rsrc \

 	&& rm -rf "$GOPATH"

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

 ENTRYPOINT ["hack/dind"]

@@ -29,6 +29,24 @@ RUN apt-get update && apt-get install -y --no-install-recommends \

 		aufs-tools \

 	&& rm -rf /var/lib/apt/lists/*

+# Install runc

+ENV RUNC_COMMIT bbde9c426ff363d813b8722f0744115c13b408b6

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

+	&& cd "$GOPATH/src/github.com/opencontainers/runc" \

+	&& git checkout -q "$RUNC_COMMIT" \

+	&& make BUILDTAGS="seccomp apparmor selinux" && make install

+

+# Install containerd

+ENV CONTAINERD_COMMIT 7146b01a3d7aaa146414cdfb0a6c96cfba5d9091

+RUN set -x \

+	&& export GOPATH="$(mktemp -d)" \

+  && git clone git://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \

+	&& cd "$GOPATH/src/github.com/docker/containerd" \

+	&& git checkout -q "$CONTAINERD_COMMIT" \

+	&& make && make install

+

 ENV AUTO_GOPATH 1

 WORKDIR /usr/src/docker

 COPY . /usr/src/docker

@@ -14,7 +14,6 @@ import (

 	"github.com/docker/docker/opts"

 	"github.com/docker/docker/pkg/promise"

 	"github.com/docker/docker/pkg/signal"

-	"github.com/docker/docker/pkg/stringid"

 	runconfigopts "github.com/docker/docker/runconfig/opts"

 	"github.com/docker/engine-api/types"

 	"github.com/docker/libnetwork/resolvconf/dns"

@@ -256,16 +255,6 @@ func (cli *DockerCli) CmdRun(args ...string) error {

 	// Attached mode

 	if *flAutoRemove {

-		// Warn user if they detached us

-		js, err := cli.client.ContainerInspect(context.Background(), createResponse.ID)

-		if err != nil {

-			return runStartContainerErr(err)

-		}

-		if js.State.Running == true || js.State.Paused == true {

-			fmt.Fprintf(cli.out, "Detached from %s, awaiting its termination in order to uphold \"--rm\".\n",

-				stringid.TruncateID(createResponse.ID))

-		}

-

 		// Autoremove: wait for the container to finish, retrieve

 		// the exit code and remove the container

 		if status, err = cli.client.ContainerWait(context.Background(), createResponse.ID); err != nil {

@@ -112,7 +112,9 @@ func (s *containerRouter) postContainerExecStart(ctx context.Context, w http.Res

 		if execStartCheck.Detach {

 			return err

 		}

+		stdout.Write([]byte(err.Error()))

 		logrus.Errorf("Error running exec in container: %v\n", err)

+		return err

 	}

 	return nil

 }

@@ -17,7 +17,6 @@ import (

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/daemon/exec"

-	"github.com/docker/docker/daemon/execdriver"

 	"github.com/docker/docker/daemon/logger"

 	"github.com/docker/docker/daemon/logger/jsonfilelog"

 	"github.com/docker/docker/daemon/network"

@@ -27,6 +26,7 @@ import (

 	"github.com/docker/docker/pkg/promise"

 	"github.com/docker/docker/pkg/signal"

 	"github.com/docker/docker/pkg/symlink"

+	"github.com/docker/docker/restartmanager"

 	"github.com/docker/docker/runconfig"

 	runconfigopts "github.com/docker/docker/runconfig/opts"

 	"github.com/docker/docker/volume"

@@ -74,13 +74,12 @@ type CommonContainer struct {

 	HasBeenManuallyStopped bool // used for unless-stopped restart policy

 	MountPoints            map[string]*volume.MountPoint

 	HostConfig             *containertypes.HostConfig `json:"-"` // do not serialize the host config in the json, otherwise we'll make the container unportable

-	Command                *execdriver.Command        `json:"-"`

-	monitor                *containerMonitor

-	ExecCommands           *exec.Store `json:"-"`

+	ExecCommands           *exec.Store                `json:"-"`

 	// logDriver for closing

-	LogDriver     logger.Logger  `json:"-"`

-	LogCopier     *logger.Copier `json:"-"`

-	attachContext *attachContext

+	LogDriver      logger.Logger  `json:"-"`

+	LogCopier      *logger.Copier `json:"-"`

+	restartManager restartmanager.RestartManager

+	attachContext  *attachContext

 }

 // NewBaseContainer creates a new container with its

@@ -276,19 +275,9 @@ func (container *Container) GetRootResourcePath(path string) (string, error) {

 // ExitOnNext signals to the monitor that it should not restart the container

 // after we send the kill signal.

 func (container *Container) ExitOnNext() {

-	container.monitor.ExitOnNext()

-}

-

-// Resize changes the TTY of the process running inside the container

-// to the given height and width. The container must be running.

-func (container *Container) Resize(h, w int) error {

-	if container.Command.ProcessConfig.Terminal == nil {

-		return fmt.Errorf("Container %s does not have a terminal ready", container.ID)

-	}

-	if err := container.Command.ProcessConfig.Terminal.Resize(h, w); err != nil {

-		return err

+	if container.restartManager != nil {

+		container.restartManager.Cancel()

 	}

-	return nil

 }

 // HostConfigPath returns the path to the container's JSON hostconfig

@@ -897,19 +886,33 @@ func (container *Container) BuildCreateEndpointOptions(n libnetwork.Network, epC

 // UpdateMonitor updates monitor configure for running container

 func (container *Container) UpdateMonitor(restartPolicy containertypes.RestartPolicy) {

-	monitor := container.monitor

-	// No need to update monitor if container hasn't got one

-	// monitor will be generated correctly according to container

-	if monitor == nil {

-		return

+	type policySetter interface {

+		SetPolicy(containertypes.RestartPolicy)

+	}

+

+	if rm, ok := container.RestartManager(false).(policySetter); ok {

+		rm.SetPolicy(restartPolicy)

+	}

+}

+

+// FullHostname returns hostname and optional domain appended to it.

+func (container *Container) FullHostname() string {

+	fullHostname := container.Config.Hostname

+	if container.Config.Domainname != "" {

+		fullHostname = fmt.Sprintf("%s.%s", fullHostname, container.Config.Domainname)

 	}

+	return fullHostname

+}

-	monitor.mux.Lock()

-	// to check whether restart policy has changed.

-	if restartPolicy.Name != "" && !monitor.restartPolicy.IsSame(&restartPolicy) {

-		monitor.restartPolicy = restartPolicy

+// RestartManager returns the current restartmanager instace connected to container.

+func (container *Container) RestartManager(reset bool) restartmanager.RestartManager {

+	if reset {

+		container.RestartCount = 0

+	}

+	if container.restartManager == nil {

+		container.restartManager = restartmanager.New(container.HostConfig.RestartPolicy)

 	}

-	monitor.mux.Unlock()

+	return container.restartManager

 }

 type attachContext struct {

@@ -11,7 +11,6 @@ import (

 	"syscall"

 	"github.com/Sirupsen/logrus"

-	"github.com/docker/docker/daemon/execdriver"

 	"github.com/docker/docker/pkg/chrootarchive"

 	"github.com/docker/docker/pkg/symlink"

 	"github.com/docker/docker/pkg/system"

@@ -39,6 +38,15 @@ type Container struct {

 	NoNewPrivileges bool

 }

+// ExitStatus provides exit reasons for a container.

+type ExitStatus struct {

+	// The exit code with which the container exited.

+	ExitCode int

+

+	// Whether the container encountered an OOM.

+	OOMKilled bool

+}

+

 // CreateDaemonEnvironment returns the list of all environment variables given the list of

 // environment variables related to links.

 // Sets PATH, HOSTNAME and if container.Config.Tty is set: TERM.

@@ -57,7 +65,6 @@ func (container *Container) CreateDaemonEnvironment(linkedEnv []string) []string

 	// we need to replace the 'env' keys where they match and append anything

 	// else.

 	env = utils.ReplaceOrAppendEnvValues(env, container.Config.Env)

-

 	return env

 }

@@ -103,8 +110,8 @@ func appendNetworkMounts(container *Container, volumeMounts []volume.MountPoint)

 }

 // NetworkMounts returns the list of network mounts.

-func (container *Container) NetworkMounts() []execdriver.Mount {

-	var mounts []execdriver.Mount

+func (container *Container) NetworkMounts() []Mount {

+	var mounts []Mount

 	shared := container.HostConfig.NetworkMode.IsContainer()

 	if container.ResolvConfPath != "" {

 		if _, err := os.Stat(container.ResolvConfPath); err != nil {

@@ -115,7 +122,7 @@ func (container *Container) NetworkMounts() []execdriver.Mount {

 			if m, exists := container.MountPoints["/etc/resolv.conf"]; exists {

 				writable = m.RW

 			}

-			mounts = append(mounts, execdriver.Mount{

+			mounts = append(mounts, Mount{

 				Source:      container.ResolvConfPath,

 				Destination: "/etc/resolv.conf",

 				Writable:    writable,

@@ -132,7 +139,7 @@ func (container *Container) NetworkMounts() []execdriver.Mount {

 			if m, exists := container.MountPoints["/etc/hostname"]; exists {

 				writable = m.RW

 			}

-			mounts = append(mounts, execdriver.Mount{

+			mounts = append(mounts, Mount{

 				Source:      container.HostnamePath,

 				Destination: "/etc/hostname",

 				Writable:    writable,

@@ -149,7 +156,7 @@ func (container *Container) NetworkMounts() []execdriver.Mount {

 			if m, exists := container.MountPoints["/etc/hosts"]; exists {

 				writable = m.RW

 			}

-			mounts = append(mounts, execdriver.Mount{

+			mounts = append(mounts, Mount{

 				Source:      container.HostsPath,

 				Destination: "/etc/hosts",

 				Writable:    writable,

@@ -224,37 +231,26 @@ func (container *Container) UnmountIpcMounts(unmount func(pth string) error) {

 }

 // IpcMounts returns the list of IPC mounts

-func (container *Container) IpcMounts() []execdriver.Mount {

-	var mounts []execdriver.Mount

+func (container *Container) IpcMounts() []Mount {

+	var mounts []Mount

 	if !container.HasMountFor("/dev/shm") {

 		label.SetFileLabel(container.ShmPath, container.MountLabel)

-		mounts = append(mounts, execdriver.Mount{

+		mounts = append(mounts, Mount{

 			Source:      container.ShmPath,

 			Destination: "/dev/shm",

 			Writable:    true,

 			Propagation: volume.DefaultPropagationMode,

 		})

 	}

-	return mounts

-}

-func updateCommand(c *execdriver.Command, resources containertypes.Resources) {

-	c.Resources.BlkioWeight = resources.BlkioWeight

-	c.Resources.CPUShares = resources.CPUShares

-	c.Resources.CPUPeriod = resources.CPUPeriod

-	c.Resources.CPUQuota = resources.CPUQuota

-	c.Resources.CpusetCpus = resources.CpusetCpus

-	c.Resources.CpusetMems = resources.CpusetMems

-	c.Resources.Memory = resources.Memory

-	c.Resources.MemorySwap = resources.MemorySwap

-	c.Resources.MemoryReservation = resources.MemoryReservation

-	c.Resources.KernelMemory = resources.KernelMemory

+	return mounts

 }

 // UpdateContainer updates configuration of a container.

 func (container *Container) UpdateContainer(hostConfig *containertypes.HostConfig) error {

 	container.Lock()

+	defer container.Unlock()

 	// update resources of container

 	resources := hostConfig.Resources

@@ -294,19 +290,8 @@ func (container *Container) UpdateContainer(hostConfig *containertypes.HostConfi

 	if hostConfig.RestartPolicy.Name != "" {

 		container.HostConfig.RestartPolicy = hostConfig.RestartPolicy

 	}

-	container.Unlock()

-

-	// If container is not running, update hostConfig struct is enough,

-	// resources will be updated when the container is started again.

-	// If container is running (including paused), we need to update

-	// the command so we can update configs to the real world.

-	if container.IsRunning() {

-		container.Lock()

-		updateCommand(container.Command, *cResources)

-		container.Unlock()

-	}

-	if err := container.ToDiskLocking(); err != nil {

+	if err := container.ToDisk(); err != nil {

 		logrus.Errorf("Error saving updated container: %v", err)

 		return err

 	}

@@ -400,10 +385,10 @@ func copyOwnership(source, destination string) error {

 }

 // TmpfsMounts returns the list of tmpfs mounts

-func (container *Container) TmpfsMounts() []execdriver.Mount {

-	var mounts []execdriver.Mount

+func (container *Container) TmpfsMounts() []Mount {

+	var mounts []Mount

 	for dest, data := range container.HostConfig.Tmpfs {

-		mounts = append(mounts, execdriver.Mount{

+		mounts = append(mounts, Mount{

 			Source:      "tmpfs",

 			Destination: dest,

 			Data:        data,

@@ -5,7 +5,7 @@ import "sync"

 // memoryStore implements a Store in memory.

 type memoryStore struct {

 	s map[string]*Container

-	sync.Mutex

+	sync.RWMutex

 }

 // NewMemoryStore initializes a new memory store.

@@ -25,9 +25,9 @@ func (c *memoryStore) Add(id string, cont *Container) {

 // Get returns a container from the store by id.

 func (c *memoryStore) Get(id string) *Container {

-	c.Lock()

+	c.RLock()

 	res := c.s[id]

-	c.Unlock()

+	c.RUnlock()

 	return res

 }

@@ -42,26 +42,26 @@ func (c *memoryStore) Delete(id string) {

 // The containers are ordered by creation date.

 func (c *memoryStore) List() []*Container {

 	containers := new(History)

-	c.Lock()

+	c.RLock()

 	for _, cont := range c.s {

 		containers.Add(cont)

 	}

-	c.Unlock()

+	c.RUnlock()

 	containers.sort()

 	return *containers

 }

 // Size returns the number of containers in the store.

 func (c *memoryStore) Size() int {

-	c.Lock()

-	defer c.Unlock()

+	c.RLock()

+	defer c.RUnlock()

 	return len(c.s)

 }

 // First returns the first container found in the store by a given filter.

 func (c *memoryStore) First(filter StoreFilter) *Container {

-	c.Lock()

-	defer c.Unlock()

+	c.RLock()

+	defer c.RUnlock()

 	for _, cont := range c.s {

 		if filter(cont) {

 			return cont

@@ -72,9 +72,10 @@ func (c *memoryStore) First(filter StoreFilter) *Container {

 // ApplyAll calls the reducer function with every container in the store.

 // This operation is asyncronous in the memory store.

+// NOTE: Modifications to the store MUST NOT be done by the StoreReducer.

 func (c *memoryStore) ApplyAll(apply StoreReducer) {

-	c.Lock()

-	defer c.Unlock()

+	c.RLock()

+	defer c.RUnlock()

 	wg := new(sync.WaitGroup)

 	for _, cont := range c.s {

@@ -1,24 +1,13 @@

 package container

 import (

-	"fmt"

-	"io"

-	"os/exec"

-	"strings"

-	"sync"

-	"syscall"

 	"time"

 	"github.com/Sirupsen/logrus"

-	"github.com/docker/docker/daemon/execdriver"

-	"github.com/docker/docker/pkg/promise"

-	"github.com/docker/docker/pkg/stringid"

-	"github.com/docker/engine-api/types/container"

 )

 const (

-	defaultTimeIncrement = 100

-	loggerCloseTimeout   = 10 * time.Second

+	loggerCloseTimeout = 10 * time.Second

 )

 // supervisor defines the interface that a supervisor must implement

@@ -30,311 +19,13 @@ type supervisor interface {

 	// StartLogging starts the logging driver for the container

 	StartLogging(*Container) error

 	// Run starts a container

-	Run(c *Container, pipes *execdriver.Pipes, startCallback execdriver.DriverCallback) (execdriver.ExitStatus, error)

+	Run(c *Container) error

 	// IsShuttingDown tells whether the supervisor is shutting down or not

 	IsShuttingDown() bool

 }

-// containerMonitor monitors the execution of a container's main process.

-// If a restart policy is specified for the container the monitor will ensure that the

-// process is restarted based on the rules of the policy.  When the container is finally stopped

-// the monitor will reset and cleanup any of the container resources such as networking allocations

-// and the rootfs

-type containerMonitor struct {

-	mux sync.Mutex

-

-	// supervisor keeps track of the container and the events it generates

-	supervisor supervisor

-

-	// container is the container being monitored

-	container *Container

-

-	// restartPolicy is the current policy being applied to the container monitor

-	restartPolicy container.RestartPolicy

-

-	// failureCount is the number of times the container has failed to

-	// start in a row

-	failureCount int

-

-	// shouldStop signals the monitor that the next time the container exits it is

-	// either because docker or the user asked for the container to be stopped

-	shouldStop bool

-

-	// startSignal is a channel that is closes after the container initially starts

-	startSignal chan struct{}

-

-	// stopChan is used to signal to the monitor whenever there is a wait for the

-	// next restart so that the timeIncrement is not honored and the user is not

-	// left waiting for nothing to happen during this time

-	stopChan chan struct{}

-

-	// timeIncrement is the amount of time to wait between restarts

-	// this is in milliseconds

-	timeIncrement int

-

-	// lastStartTime is the time which the monitor last exec'd the container's process

-	lastStartTime time.Time

-}

-

-// StartMonitor initializes a containerMonitor for this container with the provided supervisor and restart policy

-// and starts the container's process.

-func (container *Container) StartMonitor(s supervisor) error {

-	container.monitor = &containerMonitor{

-		supervisor:    s,

-		container:     container,

-		restartPolicy: container.HostConfig.RestartPolicy,

-		timeIncrement: defaultTimeIncrement,

-		stopChan:      make(chan struct{}),

-		startSignal:   make(chan struct{}),

-	}

-

-	return container.monitor.wait()

-}

-

-// wait starts the container and wait until

-// we either receive an error from the initial start of the container's

-// process or until the process is running in the container

-func (m *containerMonitor) wait() error {

-	select {

-	case <-m.startSignal:

-	case err := <-promise.Go(m.start):

-		return err

-	}

-

-	return nil

-}

-

-// Stop signals to the container monitor that it should stop monitoring the container

-// for exits the next time the process dies

-func (m *containerMonitor) ExitOnNext() {

-	m.mux.Lock()

-

-	// we need to protect having a double close of the channel when stop is called

-	// twice or else we will get a panic

-	if !m.shouldStop {

-		m.shouldStop = true

-		close(m.stopChan)

-	}

-

-	m.mux.Unlock()

-}

-

-// Close closes the container's resources such as networking allocations and

-// unmounts the container's root filesystem

-func (m *containerMonitor) Close() error {

-	// Cleanup networking and mounts

-	m.supervisor.Cleanup(m.container)

-

-	if err := m.container.ToDisk(); err != nil {

-		logrus.Errorf("Error dumping container %s state to disk: %s", m.container.ID, err)

-

-		return err

-	}

-

-	return nil

-}

-

-// Start starts the containers process and monitors it according to the restart policy

-func (m *containerMonitor) start() error {

-	var (

-		err        error

-		exitStatus execdriver.ExitStatus

-		// this variable indicates where we in execution flow:

-		// before Run or after

-		afterRun bool

-	)

-

-	// ensure that when the monitor finally exits we release the networking and unmount the rootfs

-	defer func() {

-		if afterRun {

-			m.container.Lock()

-			defer m.container.Unlock()

-			m.container.SetStopped(&exitStatus)

-		}

-		m.Close()

-	}()

-	// reset stopped flag

-	if m.container.HasBeenManuallyStopped {

-		m.container.HasBeenManuallyStopped = false

-	}

-

-	// reset the restart count

-	m.container.RestartCount = -1

-

-	for {

-		m.container.RestartCount++

-

-		if err := m.supervisor.StartLogging(m.container); err != nil {

-			m.resetContainer(false)

-

-			return err

-		}

-

-		pipes := execdriver.NewPipes(m.container.Stdin(), m.container.Stdout(), m.container.Stderr(), m.container.Config.OpenStdin)

-

-		m.logEvent("start")

-

-		m.lastStartTime = time.Now()

-

-		if exitStatus, err = m.supervisor.Run(m.container, pipes, m.callback); err != nil {

-			// if we receive an internal error from the initial start of a container then lets

-			// return it instead of entering the restart loop

-			// set to 127 for container cmd not found/does not exist)

-			if strings.Contains(err.Error(), "executable file not found") ||

-				strings.Contains(err.Error(), "no such file or directory") ||

-				strings.Contains(err.Error(), "system cannot find the file specified") {

-				if m.container.RestartCount == 0 {

-					m.container.ExitCode = 127

-					m.resetContainer(false)

-					return fmt.Errorf("Container command not found or does not exist.")

-				}

-			}

-			// set to 126 for container cmd can't be invoked errors

-			if strings.Contains(err.Error(), syscall.EACCES.Error()) {

-				if m.container.RestartCount == 0 {

-					m.container.ExitCode = 126

-					m.resetContainer(false)

-					return fmt.Errorf("Container command could not be invoked.")

-				}

-			}

-

-			if m.container.RestartCount == 0 {

-				m.container.ExitCode = -1

-				m.resetContainer(false)

-

-				return fmt.Errorf("Cannot start container %s: %v", m.container.ID, err)

-			}

-

-			logrus.Errorf("Error running container: %s", err)

-		}

-

-		// here container.Lock is already lost

-		afterRun = true

-

-		m.resetMonitor(err == nil && exitStatus.ExitCode == 0)

-

-		if m.shouldRestart(exitStatus.ExitCode) {

-			m.container.SetRestartingLocking(&exitStatus)

-			m.logEvent("die")

-			m.resetContainer(true)

-

-			// sleep with a small time increment between each restart to help avoid issues cased by quickly

-			// restarting the container because of some types of errors ( networking cut out, etc... )

-			m.waitForNextRestart()

-

-			// we need to check this before reentering the loop because the waitForNextRestart could have

-			// been terminated by a request from a user

-			if m.shouldStop {

-				return err

-			}

-			continue

-		}

-

-		m.logEvent("die")

-		m.resetContainer(true)

-		return err

-	}

-}

-

-// resetMonitor resets the stateful fields on the containerMonitor based on the

-// previous runs success or failure.  Regardless of success, if the container had

-// an execution time of more than 10s then reset the timer back to the default

-func (m *containerMonitor) resetMonitor(successful bool) {

-	executionTime := time.Now().Sub(m.lastStartTime).Seconds()

-

-	if executionTime > 10 {

-		m.timeIncrement = defaultTimeIncrement

-	} else {

-		// otherwise we need to increment the amount of time we wait before restarting

-		// the process.  We will build up by multiplying the increment by 2

-		m.timeIncrement *= 2

-	}

-

-	// the container exited successfully so we need to reset the failure counter

-	if successful {

-		m.failureCount = 0

-	} else {

-		m.failureCount++

-	}

-}

-

-// waitForNextRestart waits with the default time increment to restart the container unless

-// a user or docker asks for the container to be stopped

-func (m *containerMonitor) waitForNextRestart() {

-	select {

-	case <-time.After(time.Duration(m.timeIncrement) * time.Millisecond):

-	case <-m.stopChan:

-	}

-}

-

-// shouldRestart checks the restart policy and applies the rules to determine if

-// the container's process should be restarted

-func (m *containerMonitor) shouldRestart(exitCode int) bool {

-	m.mux.Lock()

-	defer m.mux.Unlock()

-

-	// do not restart if the user or docker has requested that this container be stopped

-	if m.shouldStop {

-		m.container.HasBeenManuallyStopped = !m.supervisor.IsShuttingDown()

-		return false

-	}

-

-	switch {

-	case m.restartPolicy.IsAlways(), m.restartPolicy.IsUnlessStopped():

-		return true

-	case m.restartPolicy.IsOnFailure():

-		// the default value of 0 for MaximumRetryCount means that we will not enforce a maximum count

-		if max := m.restartPolicy.MaximumRetryCount; max != 0 && m.failureCount > max {

-			logrus.Debugf("stopping restart of container %s because maximum failure could of %d has been reached",

-				stringid.TruncateID(m.container.ID), max)

-			return false

-		}

-

-		return exitCode != 0

-	}

-

-	return false

-}

-

-// callback ensures that the container's state is properly updated after we

-// received ack from the execution drivers

-func (m *containerMonitor) callback(processConfig *execdriver.ProcessConfig, pid int, chOOM <-chan struct{}) error {

-	go func() {

-		for range chOOM {

-			m.logEvent("oom")

-		}

-	}()

-

-	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 PtySlave

-		// which we close here.

-		if c, ok := processConfig.Stdout.(io.Closer); ok {

-			c.Close()

-		}