Update Changelog

When a container is stopped with 'docker stop', SIGTERM is sent to the
init process. Unfortunately neither bash nor runit-init handle that correctly,
so we write our own init system in Python that also waits for all services to
shutdown.

Changelog.md

@@ -1,3 +1,7 @@
+## 0.9.1 (release date: 2013-11-12)
+
+ * Improved init process script (`/sbin/my_init`): it now handles shutdown correctly. Previously, `docker stop` would not have any effect on `my_init`, causing the whole container to be killed with SIGKILL. The new init process script gracefully shuts down all runit services, then exits.
+
 ## 0.9.0 (release date: 2013-11-12)
 
  * Initial release

Makefile

@@ -1,5 +1,5 @@
 NAME = phusion/baseimage
-VERSION = 0.9.0
+VERSION = 0.9.1
 
 .PHONY: all build tag_latest release
 
@@ -12,5 +12,6 @@ tag_latest:
 	docker tag $(NAME):$(VERSION) $(NAME):latest
 
 release: tag_latest
+	@if ! docker images phusion/baseimage | awk '{ print $$2 }' | grep -q -F $(VERSION); then echo "$(NAME) version $(VERSION) is not yet built. Please run 'make build'"; false; fi
 	docker push $(NAME)
 	@echo "*** Don't forget to create a tag. git tag rel-$(VERSION) && git push origin rel-$(VERSION)"

README.md

@@ -3,6 +3,7 @@
 Baseimage-docker is a [Docker](http://www.docker.io) image meant to serve as a good base for any other Docker container. It contains a minimal base system with the most important things already installed and set up correctly.
 
  * **Github**: https://github.com/phusion/baseimage-docker
+ * **Docker registry entry**: https://index.docker.io/u/phusion/baseimage/
  * **Discussion forum**: https://groups.google.com/d/forum/passenger-docker
  * **Twitter**: https://twitter.com/phusion_nl
  * **Blog**: http://blog.phusion.nl/
@@ -14,6 +15,7 @@ Why use baseimage-docker instead of doing everything yourself in Dockerfile?
  * It reduces the time needed to write a correct Dockerfile. You won't have to worry about the base system and can focus on your stack and your app.
  * It sets up the base system **correctly**. It's very easy to get the base system wrong, but this image does everything correctly.
  * It reduces the time needed to run `docker build`, allowing you to iterate your Dockerfile more quickly.
+ * It reduces download time during redeploys. Docker only needs to download the base image once: during the first deploy. On every subsequent deploys, only the changes you make on top of the base image are downloaded.
 
 ## Contents
 
@@ -22,7 +24,7 @@ Why use baseimage-docker instead of doing everything yourself in Dockerfile?
 | Component        | Why is it included? / Remarks |
 | ---------------- | ------------------- |
 | Ubuntu 12.04 LTS | The base system. |
-| A **correct** init process | According to the Unix process model, [the init process](https://en.wikipedia.org/wiki/Init) -- PID 1 -- inherit all [orphaned child processes](https://en.wikipedia.org/wiki/Orphan_process) and must [reap them](https://en.wikipedia.org/wiki/Wait_(system_call)). Most Docker containers do not have an init process that does this correctly, and as a result their containers become filled with [zombie processes](https://en.wikipedia.org/wiki/Zombie_process) over time. Baseimage-docker comes with an init process `/sbin/my_init` that performs reaping correctly. |
+| A **correct** init process | According to the Unix process model, [the init process](https://en.wikipedia.org/wiki/Init) -- PID 1 -- inherits all [orphaned child processes](https://en.wikipedia.org/wiki/Orphan_process) and must [reap them](https://en.wikipedia.org/wiki/Wait_(system_call). Most Docker containers do not have an init process that does this correctly, and as a result their containers become filled with [zombie processes](https://en.wikipedia.org/wiki/Zombie_process) over time. <br><br>Furthermore, `docker stop` sends SIGTERM to the init process, which is then supposed to stop all services. Unfortunately most init systems don't do this correctly within Docker since they're built for hardware shutdowns instead. This causes processes to be hard killed with SIGKILL, which doesn't give them a chance to correctly deinitialize things. This can cause file corruption. <br><br>Baseimage-docker comes with an init process `/sbin/my_init` that performs both of these tasks correctly. |
 | Fixes APT incompatibilities with Docker | See https://github.com/dotcloud/docker/issues/1024. |
 | syslog-ng | A syslog daemon is necessary so that many services - including the kernel itself - can correctly log to /var/log/syslog. If no syslog daemon is running, a lot of important messages are silently swallowed. <br><br>Only listens locally. |
 | ssh server | Allows you to easily login to your container to inspect or administer things. <br><br>Password and challenge-response authentication are disabled by default. Only key authentication is allowed.<br>It allows an predefined key by default to make debugging easy. You should replace this ASAP. See instructions. |
@@ -30,7 +32,7 @@ Why use baseimage-docker instead of doing everything yourself in Dockerfile?
 | [runit](http://smarden.org/runit/) | For service supervision and management. Much easier to use than SysV init and supports restarting daemons when they crash. Much easier to use and more lightweight than Upstart. |
 | `setuser` | A tool for running a command as another user. Easier to use than `su`, has a smaller attack vector than `sudo`, and unlike `chpst` this tool sets `$HOME` correctly. Available as `/sbin/setuser`. |
 
-Baseimage-docker is very lightweight: it only consumes 4 MB of memory.
+Baseimage-docker is very lightweight: it only consumes 6 MB of memory.
 
 ### Wait, I thought Docker is about running a single process in a container?
 
@@ -92,6 +94,26 @@ Here's an example showing you how to a memached server runit entry can be made.
 
 Note that the shell script must run the daemon **without letting it daemonize/fork it**. Usually, daemons provide a command line flag or a config file option for that.
 
+### Login in to the container
+
+You can use SSH to login to any container that is based on baseimage-docker.
+
+Start a container based on baseimage-docker (or a container based on an image based on baseimage-docker):
+
+    docker run phusion/baseimage
+
+Find out the ID of the container that you just ran:
+
+    docker ps
+
+Once you have the ID, look for its IP address with:
+
+    docker inspect <ID> | grep IPAddress
+
+Now SSH into the container. In this example we're using [the default insecure key](https://github.com/phusion/baseimage-docker/blob/master/image/insecure_key), but if you're followed the instructions well then you've already replaced that with your own key. You did replace the key, didn't you?
+
+    ssh -i insecure_key root@<IP address>
+
 ## Building the image yourself
 
 If for whatever reason you want to build the image yourself instead of downloading it from the Docker registry, follow these instructions.

image/my_init

@@ -1,5 +1,64 @@
-#!/bin/bash
-set -e
-# No exec. We want bash to be the init process so that it can kill
-# zombie processes.
-/usr/sbin/runsvdir-start
+#!/usr/bin/python2
+import os, sys, signal, errno
+
+def reap_child(signum, frame):
+	global pid, status, waiting_for_runit
+	try:
+		result = os.wait3(os.WNOHANG)
+		if result is not None and pid == result[0]:
+			status = result[1]
+	except OSError:
+		pass
+
+def stop_runit(signum, frame):
+	global pid
+	print("*** Shutting down runit (PID %d)..." % pid)
+	try:
+		os.kill(pid, signal.SIGHUP)
+	except OSError:
+		pass
+
+# Start runit.
+signal.signal(signal.SIGCHLD, reap_child)
+print("*** Booting runit...")
+pid = os.spawnl(os.P_NOWAIT, "/usr/sbin/runsvdir-start", "/usr/sbin/runsvdir-start")
+print("*** Runit started as PID %d" % pid)
+signal.signal(signal.SIGTERM, stop_runit)
+
+# Wait for runit, and while waiting, reap any adopted orphans.
+done = False
+while not done:
+	try:
+		this_pid, status = os.waitpid(pid, 0)
+		done = True
+	except OSError as e:
+		if e.errno == errno.EINTR:
+			# Try again
+			pass
+		else:
+			# The SIGCHLD handler probably caught it.
+			done = True
+
+# Runit has exited. Reset signal handlers.
+print("*** Runit exited with code %s. Waiting for all services to shut down..." % status)
+signal.signal(signal.SIGCHLD, signal.SIG_DFL)
+signal.signal(signal.SIGTERM, signal.SIG_DFL)
+signal.siginterrupt(signal.SIGCHLD, False)
+signal.siginterrupt(signal.SIGTERM, False)
+
+# Wait at most 5 seconds for services to shut down.
+import time
+
+def shutdown(signum = None, frame = None):
+	global status
+	if status is not None:
+		sys.exit(status)
+
+signal.signal(signal.SIGALRM, shutdown)
+signal.alarm(5)
+done = False
+while not done:
+	done = os.system("/usr/bin/sv status /etc/service/* | grep -q '^run:'") != 0
+	if not done:
+		time.sleep(0.5)
+shutdown()