stop docker service before exit

DOCS.md

@@ -1,6 +1,7 @@
 Use the Docker plugin to build and push Docker images to a registry.
 The following parameters are used to configuration this plugin:
 
+* **registry** - authenticates to this registry
 * **username** - authenticates with this username
 * **password** - authenticates with this password
 * **email** - authenticates with this email

Dockerfile

@@ -5,10 +5,16 @@
 FROM ubuntu:14.04
 
 RUN apt-get update -qq                               \
-	&& apt-get -y install curl                       \
+	&& apt-get -y install curl                       \ 
+		apt-transport-https                          \
+		ca-certificates                              \
+		curl                                         \
+		lxc                                          \
+		iptables                                     \
 	&& curl -sSL https://get.docker.com/ubuntu/ | sh \
 	&& rm -rf /var/lib/apt/lists/*
 
 ADD drone-docker /go/bin/
+ADD wrapdocker /bin/
 
 ENTRYPOINT ["/go/bin/drone-docker"]

main.go

@@ -32,13 +32,27 @@ func main() {
 		os.Exit(1)
 	}
 
+	stop := func() {
+		cmd := exec.Command("start-stop-daemon", "--stop", "--pidfile", "/var/run/docker.pid")
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		trace(cmd)
+		cmd.Run()
+	}
+	defer stop()
+
 	// Starts the Docker daemon
 	go func() {
-		cmd := exec.Command("docker", "-d")
-		cmd.Dir = clone.Dir
+		cmd := exec.Command("/bin/bash", "/bin/wrapdocker")
 		cmd.Stdout = ioutil.Discard
 		cmd.Stderr = ioutil.Discard
 		cmd.Run()
+
+		cmd = exec.Command("docker", "-d", "-s", "overlay")
+		cmd.Stdout = ioutil.Discard
+		cmd.Stderr = ioutil.Discard
+		trace(cmd)
+		cmd.Run()
 	}()
 
 	// Sleep for a few seconds
@@ -71,6 +85,7 @@ func main() {
 	trace(cmd)
 	err := cmd.Run()
 	if err != nil {
+		stop()
 		os.Exit(1)
 	}
 
@@ -81,6 +96,7 @@ func main() {
 	cmd.Stderr = os.Stderr
 	err = cmd.Run()
 	if err != nil {
+		stop()
 		os.Exit(1)
 	}
 
@@ -92,6 +108,7 @@ func main() {
 	trace(cmd)
 	err = cmd.Run()
 	if err != nil {
+		stop()
 		os.Exit(1)
 	}
 }

wrapdocker

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Ensure that all nodes in /dev/mapper correspond to mapped devices currently loaded by the device-mapper kernel driver
+dmsetup mknodes
+
+# First, make sure that cgroups are mounted correctly.
+CGROUP=/sys/fs/cgroup
+: {LOG:=stdio}
+
+[ -d $CGROUP ] || 
+	mkdir $CGROUP
+
+mountpoint -q $CGROUP || 
+	mount -n -t tmpfs -o uid=0,gid=0,mode=0755 cgroup $CGROUP || {
+		echo "Could not make a tmpfs mount. Did you use --privileged?"
+		exit 1
+	}
+
+if [ -d /sys/kernel/security ] && ! mountpoint -q /sys/kernel/security
+then
+    mount -t securityfs none /sys/kernel/security || {
+        echo "Could not mount /sys/kernel/security."
+        echo "AppArmor detection and --privileged mode might break."
+    }
+fi
+
+# Mount the cgroup hierarchies exactly as they are in the parent system.
+for SUBSYS in $(cut -d: -f2 /proc/1/cgroup)
+do
+        [ -d $CGROUP/$SUBSYS ] || mkdir $CGROUP/$SUBSYS
+        mountpoint -q $CGROUP/$SUBSYS || 
+                mount -n -t cgroup -o $SUBSYS cgroup $CGROUP/$SUBSYS
+
+        # The two following sections address a bug which manifests itself
+        # by a cryptic "lxc-start: no ns_cgroup option specified" when
+        # trying to start containers withina container.
+        # The bug seems to appear when the cgroup hierarchies are not
+        # mounted on the exact same directories in the host, and in the
+        # container.
+
+        # Named, control-less cgroups are mounted with "-o name=foo"
+        # (and appear as such under /proc/<pid>/cgroup) but are usually
+        # mounted on a directory named "foo" (without the "name=" prefix).
+        # Systemd and OpenRC (and possibly others) both create such a
+        # cgroup. To avoid the aforementioned bug, we symlink "foo" to
+        # "name=foo". This shouldn't have any adverse effect.
+        echo $SUBSYS | grep -q ^name= && {
+                NAME=$(echo $SUBSYS | sed s/^name=//)
+                ln -s $SUBSYS $CGROUP/$NAME
+        }
+
+        # Likewise, on at least one system, it has been reported that
+        # systemd would mount the CPU and CPU accounting controllers
+        # (respectively "cpu" and "cpuacct") with "-o cpuacct,cpu"
+        # but on a directory called "cpu,cpuacct" (note the inversion
+        # in the order of the groups). This tries to work around it.
+        [ $SUBSYS = cpuacct,cpu ] && ln -s $SUBSYS $CGROUP/cpu,cpuacct
+done
+
+
+# Note: as I write those lines, the LXC userland tools cannot setup
+# a "sub-container" properly if the "devices" cgroup is not in its
+# own hierarchy. Let's detect this and issue a warning.
+grep -q :devices: /proc/1/cgroup ||
+	echo "WARNING: the 'devices' cgroup should be in its own hierarchy."
+grep -qw devices /proc/1/cgroup ||
+	echo "WARNING: it looks like the 'devices' cgroup is not mounted."
+
+# Now, close extraneous file descriptors.
+pushd /proc/self/fd >/dev/null
+for FD in *
+do
+	case "$FD" in
+	# Keep stdin/stdout/stderr
+	[012])
+		;;
+	# Nuke everything else
+	*)
+		eval exec "$FD>&-"
+		;;
+	esac
+done
+popd >/dev/null
+
+
+# If a pidfile is still around (for example after a container restart),
+# delete it so that docker can start.
+rm -rf /var/run/docker.pid