dock

#!/usr/bin/python
#
#

import sys
import json
import docker.client
import random
import time
import subprocess
import os
import string
import optparse
from urlparse import urlparse

def new_id(size=6, chars=string.ascii_uppercase + string.digits):
	return ''.join(random.choice(chars) for x in range(size))

class Configuration:
	def __init__(self):
		self.cfg = json.load(open('settings.json'))

	def get_offset_ip(offset):
		None

class Instance:
	def __init__(self, name, cfg):
		self.name = name
		self.cfg = cfg

	def short_id(self):
		return self.cfg.get('container')

	def exists(self, docker):
		if self.short_id() is None:
			return False
		try:
			details = docker.inspect_container(self.short_id())
			return True
		except:
			return False
		
	def is_running(self, docker):
		if self.short_id() is None:
			return False
		try:
			details = docker.inspect_container(self.short_id())
			return details["State"]["Running"]
		except:
			return False

	def make_params(self):
 		return { 'image':        self.cfg['image'],
			 'command':      self.cfg.get('command'),
			 'ports':        self.cfg.get('ports'),
			 'environment':  self.cfg.get('env'),
			 'detach':       True,
			 'hostname':     self.name,
		        }

	def provision(self, docker):
		if self.exists(docker):
			if self.is_running(docker):
				print "%s: skipping, %s is running" % (self.name, self.short_id())
			else:
				print "%s: %s exists, starting" % (self.name, self.short_id())
				docker.start(self.short_id())
			return self.short_id()

		print "%s: starting instance" % (self.name)
		container = docker.create_container(**self.make_params())
		short_id = container['Id']
		details = docker.inspect_container(short_id)
		long_id = details['ID']
		docker.start(short_id)

		# this is all kinds of race condition prone, too bad we
		# can't do this before we start the container
		self.configure_networking(short_id, long_id, "br0", self.cfg['ip'])
		print "%s: instance started %s" % (self.name, short_id)
		self.cfg['container'] = short_id
		return short_id

	def configure_networking(self, short_id, long_id, bridge, ip):
		iface_suffix = new_id()
		iface_local_name = "pvnetl%s" % iface_suffix
		iface_remote_name = "pvnetr%s" % iface_suffix

		# poll for the file, it'll be created when the container starts
		# up and we should spend very little time waiting
		while True:
			try:
				npsid = open("/sys/fs/cgroup/devices/lxc/" + long_id + "/tasks", "r").readline().strip()
				break
			except IOError:
				print "%s: waiting for container %s cgroup" % (self.name, short_id)
				time.sleep(0.1)

		print "%s: configuring %s networking, assigning %s" % (self.name, short_id, ip)

		# strategy from unionize.sh
        	commands = [
			"mkdir -p /var/run/netns",
        		"rm -f /var/run/netns/%s" % long_id,
        		"ln -s /proc/%s/ns/net /var/run/netns/%s" % (npsid, long_id),
        		"ip link add name %s type veth peer name %s" % (iface_local_name, iface_remote_name),
        		"brctl addif %s %s" % (bridge, iface_local_name),
        		"ifconfig %s up" % (iface_local_name),
        		"ip link set %s netns %s" % (iface_remote_name, npsid),
        		"ip netns exec %s ip link set %s name eth1" % (long_id, iface_remote_name),
        		"ip netns exec %s ifconfig eth1 %s" % (long_id, ip)
		]

		for command in commands:
			if os.system(command) != 0:
				raise Exception("Error configuring networking: '%s' failed!" % command)

	def stop(self, docker):
		if self.is_running(docker):
			print "%s: stopping %s" % (self.name, self.short_id())
			docker.stop(self.short_id())
			return self.short_id()

	def kill(self, docker):
		if self.is_running(docker):
			print "%s: killing %s" % (self.name, self.short_id())
			docker.kill(self.short_id())
			return self.short_id()

class Manifest:
	def __init__(self, path):
		self.path = path
		self.cfg = json.load(open(self.path))

	def apply(self, docker, callback):
		for name in self.cfg:
			for index, instance in enumerate(self.cfg[name]):
				instance_name = "%s-%d" % (name, index)
				callback(Instance(instance_name, instance), docker)
	
	def provision(self, docker):
		self.apply(docker, lambda instance, docker: instance.provision(docker))

	def stop(self, docker):
		self.apply(docker, lambda instance, docker: instance.stop(docker))
	
	def kill(self, docker):
		self.apply(docker, lambda instance, docker: instance.kill(docker))
	
	def save(self):
		json.dump(self.cfg, open(self.path, "w"), sort_keys=True, indent=4, separators=(',', ': '))

class Options:
	def __init__(self, entries, args): 
		self.__dict__.update(entries)	
		self.manifest = args[0]

def get_docker():
	docker_url = urlparse("http://127.0.0.1:4243")
	return docker.Client(base_url = docker_url.geturl())

def get_options():
	parser = optparse.OptionParser()
	parser.add_option("--stop", action="store_true", dest="stop", default=False, help="stop instances")
	parser.add_option("--kill", action="store_true", dest="kill", default=False, help="kill instances")
	raw_options, args = parser.parse_args()
	if not args:
		exit("No manifest given.")
	return Options(vars(raw_options), args)

def main():
	options = get_options()
	docker = get_docker()

	if os.geteuid() != 0:
		exit("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")

	manifest = Manifest(options.manifest)
	if options.stop:
		manifest.stop(docker)
	elif options.kill:
		manifest.kill(docker)
	else:
		manifest.provision(docker)
	manifest.save()

main()