docker_boss 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b4605ecf2c6938cbd8a53c54afc58505775e5d8a
+  data.tar.gz: 2c16b891bb87d053705ab5665282674c9208d65a
+SHA512:
+  metadata.gz: 32b694b16f875586a504b7be2e15cf7fb0a5a3e0ba4f18a153bbd2cd6fd1fe281fa0deeab2317b71d21b68924bfc5abfd15bf85147501416e2a0f5b4341b7918
+  data.tar.gz: 094c3b74f01c15a92f5284faaf3b150fbd62c441ee366b5170f93e7dcba39f689883e93a6ac089ca50ae9b76841b5c544d74d075e85e3bf8d91be9d3f31b59bf

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in docker_boss.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alex Hornung
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,377 @@
+# DockerBoss
+
+DockerBoss monitors Docker containers and keeps track of when a container is started, stopped, changed, etc. On such an event, DockerBoss triggers actions such as updating files, controlling other containers, updating entries in etcd, updating records in a built-in DNS server, etc.
+
+DockerBoss has been built from the start to be completely pluggable. By default, it ships with 3 different modules:
+
+ - templates: Allows re-rendering configuration files on e.g. a docker volume and then performing an action on either the host or a container, such as restarting, sending a signal, etc.
+
+ - etcd: Allows inserting/removing keys in etcd depending on the currently running containers. This allows, for example, automatically updating etcd entries for a service such as SkyDNS when a container changes IP because it is restarted.
+
+ - dns: The dns module has a very simple built-in DNS server. The DNS server's records get updated based on the container's addresses, names, environment variables, etc. The DNS server will pass through requests for zones that it is not the authoritative server for.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'docker_boss'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install docker_boss
+
+This installs a binary called `docker-boss`.
+
+
+## Usage
+
+DockerBoss can run in a one-off mode, in which it only triggers actions based on the currently running containers and then exits. In addition, it can run in a continuous mode, in which it will trigger actions based on the currently running containers, but then continues to watch Docker for further events, triggering updates on any change.
+
+To run it in one-off mode, execute:
+
+    $ docker-boss once -c /path/to/config.yml
+
+To run in watch mode, execute:
+
+    $ docker-boss watch -c /path/to/config.yml
+
+By default, DockerBoss runs in the foreground. If you want to run DockerBoss as a daemon, execute:
+
+    $ docker-boss watch -c /path/to/config.yml -D
+
+Both modes support an optional log argument, which allows logging to stdout, syslog or a file:
+
+    $ docker-boss watch -c /path/to/config.yml -l syslog
+    $ docker-boss watch -c /path/to/config.yml -l -
+    $ docker-boss watch -c /path/to/config.yml -l /var/log/docker_boss.log
+
+
+## Configuration
+
+An example configuration file with some settings for each of the bundled modules is included in `example.cfg.yml`.
+
+Each top-level key in the configuration file corresponds to the name of a module. All entries under that key are passed to the module for configuration of that particular module.
+
+If, for example, a key called `etcd` exists, then the DockerBoss `etcd` module will be instantiated and configured with the settings under the `etcd` key in the configuration.
+
+For more details about the configuration for each module, have a look at the detailed description of that module.
+
+### Container description
+
+Wherever templates are used in configuration settings or external template files, they are generally passed either a single container or an array of containers. Each container is a Ruby Hash, as follows:
+
+```json
+{
+   "AppArmorProfile":"",
+   "Args":[
+      "mysqld"
+   ],
+   "Config":{
+      "AttachStderr":true,
+      "AttachStdin":false,
+      "AttachStdout":true,
+      "Cmd":[
+         "mysqld"
+      ],
+      "CpuShares":0,
+      "Cpuset":"",
+      "Domainname":"",
+      "Entrypoint":[
+         "/docker-entrypoint.sh"
+      ],
+      "Env":{
+         "MYSQL_ROOT_PASSWORD":"assbYrwVnWxP",
+         "PATH":"/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+         "MARIADB_MAJOR":"10.0",
+         "MARIADB_VERSION":"10.0.15+maria-1~wheezy"
+      },
+      "ExposedPorts":{
+         "3306/tcp":{
+
+         }
+      },
+      "Hostname":"6b2bbdac4b6e",
+      "Image":"mariadb",
+      "MacAddress":"",
+      "Memory":0,
+      "MemorySwap":0,
+      "NetworkDisabled":false,
+      "OnBuild":null,
+      "OpenStdin":false,
+      "PortSpecs":null,
+      "StdinOnce":false,
+      "Tty":false,
+      "User":"",
+      "Volumes":{
+         "/var/lib/mysql":{
+
+         }
+      },
+      "WorkingDir":""
+   },
+   "Created":"2014-12-24T15:54:44.830878163Z",
+   "Driver":"devicemapper",
+   "ExecDriver":"native-0.2",
+   "HostConfig":{
+      "Binds":null,
+      "CapAdd":null,
+      "CapDrop":null,
+      "ContainerIDFile":"",
+      "Devices":[
+
+      ],
+      "Dns":null,
+      "DnsSearch":null,
+      "ExtraHosts":null,
+      "IpcMode":"",
+      "Links":null,
+      "LxcConf":[
+
+      ],
+      "NetworkMode":"bridge",
+      "PortBindings":{
+
+      },
+      "Privileged":false,
+      "PublishAllPorts":false,
+      "RestartPolicy":{
+         "MaximumRetryCount":0,
+         "Name":""
+      },
+      "SecurityOpt":null,
+      "VolumesFrom":null
+   },
+   "HostnamePath":"/var/lib/docker/containers/6b2bbdac4b6e01caccf84346aff37f31740760a95d131b519de6e6e0ca6ba2d9/hostname",
+   "HostsPath":"/var/lib/docker/containers/6b2bbdac4b6e01caccf84346aff37f31740760a95d131b519de6e6e0ca6ba2d9/hosts",
+   "Id":"6b2bbdac4b6e01caccf84346aff37f31740760a95d131b519de6e6e0ca6ba2d9",
+   "Image":"dc7e7b74d729c8b7ffab9ac5bc4b9a1463739e085b461b29928bf2fee1ff8303",
+   "MountLabel":"",
+   "Name":"/differentdb",
+   "NetworkSettings":{
+      "Bridge":"docker0",
+      "Gateway":"172.17.42.1",
+      "IPAddress":"172.17.0.19",
+      "IPPrefixLen":16,
+      "MacAddress":"02:42:ac:11:00:13",
+      "PortMapping":null,
+      "Ports":{
+         "3306/tcp":null
+      }
+   },
+   "Path":"/docker-entrypoint.sh",
+   "ProcessLabel":"",
+   "ResolvConfPath":"/var/lib/docker/containers/6b2bbdac4b6e01caccf84346aff37f31740760a95d131b519de6e6e0ca6ba2d9/resolv.conf",
+   "State":{
+      "Error":"",
+      "ExitCode":0,
+      "FinishedAt":"0001-01-01T00:00:00Z",
+      "OOMKilled":false,
+      "Paused":false,
+      "Pid":13435,
+      "Restarting":false,
+      "Running":true,
+      "StartedAt":"2014-12-24T15:54:45.133773245Z"
+   },
+   "Volumes":{
+      "/var/lib/mysql":"/var/lib/docker/vfs/dir/1e3963ffc558c14d4b29bea89d6eafca9945500f5c80ea94b94b6e8664d5a1dc"
+   },
+   "VolumesRW":{
+      "/var/lib/mysql":true
+   }
+}
+```
+
+## Modules
+
+The core of DockerBoss only keeps track of changes to container state. All actions are part of modules.
+
+### templates
+
+The templates module allows re-rendering configuration files on e.g. docker volumes and then running actions such as restarting a container or sending a signal to the root process of the container.
+
+Each configuration entry can have an optional linked container. The container is specified via its name. If the action(s) performed by a particular configuration entry can themselves trigger further update events, it is important to provide the `linked_container` configuration to avoid an infinite amount of events because each event's actions triggers further events.
+
+The `linked_container` `action` setting allows performing one of the following actions on the container:
+
+ - `shell:<cmd>` - Execute a command inside the container in a shell
+ - `shell_bg:<cmd>` - Same as `shell`, but does not wait for the result
+ - `exec:<cmd>` - Execute a command inside the container without a shell
+ - `exec_bg:<cmd>` - Same as `exec`, but does not wait for the result
+ - `restart` - Restarts the container
+ - `start` - Starts the container
+ - `stop` - Stops the container
+ - `pause` - Pause the container
+ - `unpause` - Unpause the container
+ - `kill` - Kill the container
+ - `kill:<SIG>` - Send a signal, e.g. `SIGHUP`, to the container's root process
+
+The `action` setting outside the `linked_container` setting allows running an arbitrary shell command on the host.
+
+The `files` section allows specifying an array of `file` - `template` pairs. The file and template names themselves can contain ERB templates. These ERB templates can access information about the linked container via the `container` variable.
+
+The templates themselves should also be ERB templates. They will be rendered with ERB, with a single variable in the namespace called `containers`, which is an array of all currently running containers.
+
+Example configuration:
+
+```yaml
+templates:
+  auto_haproxy:
+    linked_container:
+      name:   "front-haproxy"
+      action: "kill:SIGHUP"
+      # Other examples:
+      # action: "shell:cat /proc/cpuinfo > /tmp/cpuinfo"
+      # action: "exec:touch /tmp/foobar"
+      # action: "restart"
+
+    files:
+      - file:     "<%= container['Volumes']['/etc/haproxy/proxies'] %>/proxies.cfg"
+        template: "<%= container['Volumes']['/etc/haproxy/proxies'] %>/proxies.cfg.erb"
+
+    action: "echo 'This happens on the host' > /tmp/foo.test"
+```
+
+A very simple example template file could look as follows:
+
+```
+<% containers.each do |c| %>
+<%= c['Id'] %> -> <%= c['Name'] %>
+<% end %>
+```
+
+### etcd
+
+The etcd module adds/updates/removes keys in etcd based on changes to the containers. This can be used to provide dynamic settings based on the containers to other tools interfacing with etcd, such as SkyDNS and confd.
+
+The `server` setting defines the host and port of the etcd server. SSL and basic HTTP auth are not yet supported.
+
+The `setup` setting is a template, each line of which can manipulate keys in etcd. These key manipulations are run once when the module/DockerBoss starts, and can be used to ensure a clean slate, free of any old keys from a previous run. Each line must follow one of the following formats:
+
+ - `ensure <key> <value>` - sets a given key in etcd to the given value.
+ - `absent <key>` - removes a given key in etcd.
+ - `absent_recursive <key>` removes a key and all its children.
+
+The `sets` setting supports any number of children, each of which is an ERB template that will be rendered for each container. The output of the template rendering must be lines of the following format:
+
+ - `ensure <key> <value>` - ensure a key exists in etcd with the given value.
+
+The etcd will keep track of keys set during previous state updates, and if a key is no longer present, it will be removed from etcd.
+
+Example configuration:
+
+```yaml
+etcd:
+  server:
+    host: '127.0.0.1'
+    port: 4001
+
+  setup: |
+    absent_recursive /skydns/docker
+    absent_recursive /vhosts
+
+  sets:
+    skydns: |
+      <% if container['Config']['Env'].has_key? 'SERVICES' %>
+        <% container['Config']['Env']['SERVICES'].split(',').each do |s| %>
+          ensure <%= "/skydns/#{s.split(':')[0].split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress'], port: s.split(':')[1]) %>
+        <% end %>
+      <% elsif container['Config']['Env'].has_key? 'SERVICE_NAME' %>
+        ensure <%= "/skydns/#{container['Config']['Env']['SERVICE_NAME'].split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress']) %>
+      <% else %>
+        ensure <%= "/skydns/#{(container['Config']['Hostname'] + ".docker").split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress']) %>
+        ensure <%= "/skydns/#{(container['Name'][1..-1] + ".docker").split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress']) %>
+      <% end %>
+
+    vhosts: |
+      <% container['Config']['Env'].fetch('VHOSTS', '').split(',').each do |vh| %>
+        ensure <%= "/vhosts/#{vh.split(':')[0]}/#{container['Id']}" %> <%= as_json(host: container['NetworkSettings']['IPAddress'], port: vh.split(':').fetch(1, '80')) %>
+      <% end %>
+```
+
+
+### dns
+
+The DNS module starts a built-in DNS server based on `rubydns`. The DNS server can be configured to support a number of upstream DNS servers, to which queries fall through if no known record is available and it doesn't match any of the internal DNS zones. As Docker can currently only handle IPv4, no `AAAA` records are ever served for containers.
+
+The `ttl` setting determines the `ttl` for each response, both positive and NXDOMAIN.
+
+The `listen` setting is an array of addresses/ports on which the DNS server should listen.
+
+The `upstream` setting is an array of upstream DNS servers to which requests should be forwarded to if no record is available locally and the name is not within one of the local zones.
+
+The `zones` setting is an array of zones for which the DNS server is authoritative. The DNS server will not forward requests in these zones to upstream DNS servers, not even if no local record is found.
+
+The `spec` setting is an ERB template which should render out all hostnames for a given container, each on a separate line. A container can have any number of host records, even none at all (by simply not rendering out any hostname).
+
+Example configuration:
+
+```yaml
+dns:
+  ttl: 5
+  listen:
+    - host: 0.0.0.0
+      port: 5300
+
+  upstream:
+    - 8.8.8.8
+    - 8.8.4.4
+
+  zones:
+    - .local
+    - .docker
+
+  spec: |
+    <%= container['Config']['Env'].fetch('SERVICE_NAME', container['Name'][1..-1]) %>.docker
+    <%= container['Config']['Hostname'] %>.docker
+```
+
+### Writing your own
+
+Writing your own module is really quite simple. You only have to provide a `trigger` method that will be called on each state change, and is passed an array of all the currently running containers, as well as the ID of the container that triggered the state change.
+
+Additionally, you can provide a `run` method which can spawn off a long-running thread. The `run` method must return a `Thread` instance.
+
+Here's a basic skeleton:
+```ruby
+require 'docker_boss'
+require 'docker_boss/module'
+
+class DockerBoss::Module::Foo < DockerBoss::Module
+  def initialize(config)
+    @config = config
+    DockerBoss.logger.debug "foo: Set up with config: #{config}"
+  end
+
+  # This method is optional; you should omit it unless you spawn off a
+  # separate, long-running, thread.
+  def run
+    Thread.new do
+      loop do
+        sleep 10
+      end
+    end
+  end
+
+  def trigger(containers, trigger_id)
+    DockerBoss.logger.debug "foo: State change triggered by container_id=#{trigger_id}"
+    containers.each do |c|
+      DockerBoss.logger.debug "foo: container: #{c['Id]}"
+    end
+  end
+end
+```
+
+Any class extending `DockerBoss::Module` is automatically registered as a module. The name of the class defines the name of the configuration key in the config yaml. For the example above, the name of the key would be `foo`. Any key under `foo` in the config yaml would be passed as `config` to the class constructor.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/docker-boss

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "docker_boss/cli"
+
+DockerBoss::CLI.start

data/docker_boss.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'docker_boss/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "docker_boss"
+  spec.version       = DockerBoss::VERSION
+  spec.authors       = ["Alex Hornung"]
+  spec.email         = ["alex@alexhornung.com"]
+  spec.description   = %q{Templating using docker container information}
+  spec.summary       = %q{Templating using docker container information}
+  spec.homepage      = "https://github.com/bwalex/docker_boss"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_dependency "docker-api", "~> 1.17.0"
+  spec.add_dependency "thor", "~> 0.19.1"
+  spec.add_dependency "daemons", "~> 1.1.9"
+  spec.add_dependency "rubydns", "~> 0.9.2"
+  spec.add_dependency "etcd", "~> 0.2.4"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.4.2"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+end

data/example.cfg.yml

@@ -0,0 +1,59 @@
+dns:
+  ttl: 5
+  listen:
+    - host: 0.0.0.0
+      port: 5300
+
+  upstream:
+    - 8.8.8.8
+    - 8.8.4.4
+
+  zones:
+    - .local
+    - .docker
+
+  spec: |
+    <%= container['Config']['Env'].fetch('SERVICE_NAME', container['Name'][1..-1]) %>.docker
+    <%= container['Config']['Hostname'] %>.docker
+
+etcd:
+  server:
+    host: '127.0.0.1'
+    port: 4001
+
+  setup: |
+    absent_recursive /skydns/docker
+
+  sets:
+    skydns: |
+      <% if container['Config']['Env'].has_key? 'SERVICES' %>
+        <% container['Config']['Env']['SERVICES'].split(',').each do |s| %>
+          ensure <%= "/skydns/#{s.split(':')[0].split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress'], port: s.split(':')[1]) %>
+        <% end %>
+      <% elsif container['Config']['Env'].has_key? 'SERVICE_NAME' %>
+        ensure <%= "/skydns/#{container['Config']['Env']['SERVICE_NAME'].split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress']) %>
+      <% else %>
+        ensure <%= "/skydns/#{(container['Config']['Hostname'] + ".docker").split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress']) %>
+        ensure <%= "/skydns/#{(container['Name'][1..-1] + ".docker").split('.').reverse.join('/')}" %> <%= as_json(host: container['NetworkSettings']['IPAddress']) %>
+      <% end %>
+
+    vhosts: |
+      <% container['Config']['Env'].fetch('VHOSTS', '').split(',').each do |vh| %>
+        ensure <%= "/vhosts/#{vh.split(':')[0]}/#{container['Id']}" %> <%= as_json(host: container['NetworkSettings']['IPAddress'], port: vh.split(':').fetch(1, '80')) %>
+      <% end %>
+
+templates:
+  auto_haproxy:
+    linked_container:
+      name:   "mydb"
+      action: "restart"
+      # Other examples:
+      # action: "shell:cat /proc/cpuinfo > /tmp/cpuinfo"
+      # action: "exec:touch /tmp/foobar"
+      # action: "kill:SIGHUP"
+
+    files:
+      - file:     "<%= container['Volumes']['/var/lib/mysql'] %>/foo.cfg"
+        template: "<%= container['Volumes']['/var/lib/mysql'] %>/foo.cfg.erb"
+
+    action: "echo 'This happens on the host' > /tmp/foo.test"

data/lib/docker_boss.rb

@@ -0,0 +1,13 @@
+require 'docker_boss/version'
+require 'celluloid'
+
+module DockerBoss
+  def self.logger
+    @@logger ||= Logger.new(STDOUT)
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+    Celluloid.logger = logger
+  end
+end

data/lib/docker_boss/cli.rb

@@ -0,0 +1,85 @@
+require 'docker_boss/version'
+require 'docker_boss/engine'
+require 'docker_boss'
+require 'thor'
+require 'docker'
+require 'logger'
+require 'syslog/logger'
+require 'daemons'
+require 'yaml'
+
+class DockerBoss::CLI < Thor
+  desc "once", "Run once and exit"
+  method_option :config, :aliases => "-c", :type => :string, :required => true
+  method_option :log,    :aliases => "-l", :type => :string, :default => "-", :desc => "Specify a file to log to, or '-' to log to the standard output, or 'syslog' to log to syslog"
+  method_option :debug,  :aliases => "-d", :type => :boolean, :default => false, :desc => "Specify this option to run with debug logging enabled"
+  def once
+    setup_logging
+    read_config
+    begin
+      engine.refresh_and_trigger
+    rescue Docker::Error::DockerError => e
+      DockerBoss.logger.fatal "Error communicating with Docker: #{e.message}"
+      exit 1
+    end
+  end
+
+  desc "watch", "Run once, then watch for events"
+  method_option :config,        :aliases => "-c", :type => :string,  :required => true
+  method_option :log,           :aliases => "-l", :type => :string,  :default => "-", :desc => "Specify a file to log to, or '-' to log to the standard output, or 'syslog' to log to syslog"
+  method_option :debug,         :aliases => "-d", :type => :boolean, :default => false, :desc => "Specify this option to run with debug logging enabled"
+  method_option :daemonize,     :aliases => "-D", :type => :boolean, :default => false, :desc => "Specify this option to daemonize the process instead of running in the foreground"
+  method_option :incr_refresh,                    :type => :boolean, :default => false
+  def watch
+    setup_logging
+    read_config
+
+    thw = engine.event_loop
+
+    Daemons.daemonize if options[:daemonize]
+
+    begin
+      engine.refresh_and_trigger
+      thw.next_wait.join
+    rescue Docker::Error::DockerError => e
+      DockerBoss.logger.fatal "Error communicating with Docker: #{e.message}"
+      exit 1
+    rescue Exception => e
+      DockerBoss.logger.fatal "Fatal unhandled exception in event loop: #{e.class.name} -> #{e.message}"
+      e.backtrace.each { |line| DockerBoss.logger.fatal "    #{line}" }
+      exit 1
+    end
+  end
+
+  no_tasks do
+    def engine
+      @engine ||= begin
+        engine = DockerBoss::Engine.new(options, @config)
+        engine
+      end
+    end
+
+    def setup_logging
+      case options[:log]
+      when "syslog"
+        @logger = Syslog::Logger.new('docker-boss')
+      when "-"
+        @logger = Logger.new(STDOUT)
+      else
+        @logger = Logger.new(options[:log])
+      end
+
+      @logger.level = options[:debug] ? Logger::DEBUG : Logger::INFO
+      DockerBoss.logger=(@logger)
+    end
+
+    def read_config
+      begin
+        @config = YAML.load_file(options[:config])
+      rescue SyntaxError => e
+        DockerBoss.logger.fatal "Error loading config: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/docker_boss/engine.rb

@@ -0,0 +1,112 @@
+require 'docker_boss'
+require 'docker_boss/module'
+require 'docker_boss/modules/templates'
+require 'docker_boss/modules/dns'
+require 'docker_boss/modules/etcd'
+require 'docker'
+require 'thread'
+require 'thwait'
+
+class DockerBoss::Engine
+  def initialize(options, config)
+    @containers = []
+    @options = options
+    @config = config
+    @mutex = Mutex.new
+    @last_etcds
+    @modules = []
+
+    @config.each do |k,v|
+      @modules << DockerBoss::ModuleManager[k].new(v)
+    end
+  end
+
+  def trigger(id = nil)
+    @modules.each do |mod|
+      mod.trigger(@containers, id)
+    end
+  end
+
+  def refresh_all
+    @containers = Docker::Container.all.map { |c| xform_container(c.json) }
+  end
+
+  def refresh_and_trigger
+    @mutex.synchronize {
+      refresh_all
+      trigger
+    }
+  end
+
+  def xform_container(container)
+    new_env = {}
+    container['Config']['Env'].each do |env|
+      (k,v) = env.split('=', 2)
+      new_env[k] = v || true
+    end
+    container['Config']['Env'] = new_env
+    container
+  end
+
+  def process_event(event)
+    DockerBoss.logger.info "Processing event: #{event}"
+    case event[:status]
+    when 'start' # 'create' also triggers 'start'
+      @mutex.synchronize {
+        if @options[:incr_refresh]
+          new_container = Docker::Container.get(event[:id]).json
+          @containers.delete_if { |c| c['Id'] == event[:id] }
+          @containers << xform_container(new_container)
+        else
+          refresh_all
+        end
+        trigger(event[:id])
+      }
+    when 'die' # 'destroy', 'kill', 'stop' also trigger 'die'
+      @mutex.synchronize {
+        if @options[:incr_refresh]
+          @containers.delete_if { |c| c['Id'] == event[:id] }
+        else
+          refresh_all
+        end
+        trigger(event[:id])
+      }
+    when 'pause'
+    when 'unpause'
+    end
+  end
+
+  def event_loop
+    @events = Queue.new
+    threads = []
+    threads << Thread.new do
+      loop do
+        event = @events.deq
+        process_event(event)
+      end
+    end
+
+    threads << Thread.new do
+      loop do
+        begin
+          #Docker::Event.stream({}, Docker::Connection.new(Docker.url, {:nonblock => true})) do |event|
+          Docker::Event.stream do |event|
+            DockerBoss.logger.debug "New event on socket: #{event}"
+            @events.enq({:id => event.id, :status => event.status})
+          end
+        rescue Docker::Error::TimeoutError
+          next
+        end
+      end
+    end
+
+    @modules.each do |mod|
+      begin
+        threads << mod.run
+      rescue NoMethodError
+      end
+    end
+
+    ThreadsWait.new(*threads)
+  end
+end

data/lib/docker_boss/helpers.rb

@@ -0,0 +1,45 @@
+require 'yaml'
+require 'erb'
+require 'ostruct'
+require 'json'
+
+module DockerBoss::Helpers
+  def self.render_erb(template_str, data)
+    tmpl = ERB.new(template_str)
+    ns = OpenStruct.new(data)
+    tmpl.result(ns.instance_eval { binding })
+  end
+
+  def self.render_erb_file(file, data)
+    contents = File.read(file)
+    render_erb(contents, data)
+  end
+
+  def self.hash_diff(old, new)
+    changes = {
+      :added => {},
+      :removed => {},
+      :changed => {}
+    }
+
+    new.each do |k,v|
+      if old.has_key? k
+        changes[:changed][k] = v if old[k] != v
+      else
+        changes[:added][k] = v
+      end
+    end
+
+    old.each do |k,v|
+      changes[:removed][k] = v unless new.has_key? k
+    end
+
+    changes
+  end
+
+  module TemplateHelpers
+    def as_json(hash)
+      hash.to_json
+    end
+  end
+end

data/lib/docker_boss/module.rb

@@ -0,0 +1,33 @@
+require 'docker_boss'
+require 'docker_boss/engine'
+
+module DockerBoss::ModuleManager
+  @modules = {}
+
+  def self.<<(klass)
+    key = klass.name.split('::')[-1].downcase
+    @modules[key] = klass
+  end
+
+  def self.[](key)
+    raise IndexError, "Unnknown module #{key}" unless @modules.has_key? key
+    @modules[key]
+  end
+end
+
+class DockerBoss::Module
+  def self.inherited(klass)
+    DockerBoss::ModuleManager << klass
+  end
+
+  def initialize
+  end
+
+  def run
+    raise NoMethodError
+  end
+
+  def trigger(containers, trigger_id)
+    raise NoMethodError
+  end
+end

data/lib/docker_boss/modules/dns.rb

@@ -0,0 +1,79 @@
+require 'rubydns'
+require 'resolv'
+require 'docker_boss'
+require 'docker_boss/module'
+require 'thread'
+
+class DockerBoss::Module::DNS < DockerBoss::Module
+  attr_reader :records
+
+  def initialize(config)
+    @records = {}
+    @config = config
+    DockerBoss.logger.debug "dns: Set up"
+  end
+
+  def run
+    listen = []
+    @config['listen'].each do |l|
+      listen << [:udp, l['host'], l['port'].to_i]
+      listen << [:tcp, l['host'], l['port'].to_i]
+    end
+
+    DockerBoss.logger.debug "dns: Starting DNS server"
+
+    Thread.new do
+      RubyDNS::run_server(:listen => listen, :ttl => @config['ttl'], :upstream_dns => @config['upstream'], :zones => @config['zones'], :supervisor_class => Server, :manager => self)
+    end
+  end
+
+  def trigger(containers, trigger_id)
+    records = {}
+    containers.each do |c|
+      names = DockerBoss::Helpers.render_erb(@config['spec'], :container => c)
+      names.lines.each do |n|
+        records[n.lstrip.chomp] = c['NetworkSettings']['IPAddress']
+      end
+    end
+
+    @records = records
+  end
+
+  class Server < RubyDNS::Server
+    attr_writer :records
+    IN = Resolv::DNS::Resource::IN
+
+    def records
+      @manager.records
+    end
+
+    def initialize(options = {})
+      super(options)
+      @manager = options[:manager]
+
+      @ttl = options[:ttl].to_i
+      @zones = options[:zones]
+      servers = options[:upstream_dns].map { |ip| [:udp, ip, 53] }
+      servers.concat(options[:upstream_dns].map { |ip| [:tcp, ip, 53] })
+      @resolver = RubyDNS::Resolver.new(servers)
+    end
+
+    def process(name, resource_class, transaction)
+      zone = @zones.find { |z| name =~ /#{z}$/ }
+      if records.has_key? name
+        # XXX: revisit whenever docker supports IPv6, for AAAA records...
+        if [IN::A].include? resource_class
+          transaction.respond!(records[name], :ttl => @ttl)
+        else
+          transaction.fail!(:NXDomain)
+        end
+      elsif zone
+        soa = Resolv::DNS::Resource::IN::SOA.new(Resolv::DNS::Name.create("#{zone}"), Resolv::DNS::Name.create("dockerboss."), 1, @ttl, @ttl, @ttl, @ttl)
+        transaction.add([soa], :name => "#{zone}.", :ttl => @ttl, :section => :authority)
+        transaction.fail!(:NXDomain)
+      else
+        transaction.passthrough!(@resolver)
+      end
+    end
+  end
+end

data/lib/docker_boss/modules/etcd.rb

@@ -0,0 +1,73 @@
+require 'docker_boss'
+require 'docker_boss/module'
+require 'docker_boss/helpers'
+
+require 'erb'
+require 'ostruct'
+
+require 'etcd'
+
+class DockerBoss::Module::Etcd < DockerBoss::Module
+  def initialize(config)
+    @config = config
+    DockerBoss.logger.debug "etcd: Set up to connect to #{@config['server']['host']}, port #{@config['server']['port']}"
+    @client = ::Etcd.client(host: @config['server']['host'], port: @config['server']['port'])
+    @previous_keys = {}
+    setup
+  end
+
+  def setup
+    @config.fetch('setup', '').lines.each do |line|
+      (kw, k, v) = line.lstrip.chomp.split(" ", 3)
+      case kw
+      when 'absent'
+        DockerBoss.logger.debug "etcd: (setup) Remove key `#{k}`"
+        @client.delete(k)
+      when 'absent_recursive'
+        DockerBoss.logger.debug "etcd: (setup) Remove key `#{k}` recursively"
+        @client.delete(k, recursive: true)
+      when 'ensure'
+        DockerBoss.logger.debug "etcd: (setup) Set key `#{k}` => `#{v}`"
+        @client.set(k, value: v)
+      end
+    end
+  end
+
+  def trigger(containers, trigger_id)
+    @new_keys = process_specs(containers)
+    changes = DockerBoss::Helpers.hash_diff(@previous_keys, @new_keys)
+    @previous_keys = @new_keys
+
+    changes[:removed].each do |k,v|
+      DockerBoss.logger.debug "etcd: Remove key `#{k}`"
+      @client.delete(k)
+    end
+
+    changes[:added].each do |k,v|
+      DockerBoss.logger.debug "etcd: Add key `#{k}` => `#{v}`"
+      @client.set(k, value: v)
+    end
+
+    changes[:changed].each do |k,v|
+      DockerBoss.logger.debug "etcd: Update key `#{k}` => `#{v}`"
+      @client.set(k, value: v)
+    end
+  end
+
+  def process_specs(containers)
+    values = {}
+    @config['sets'].each do |name,template|
+      tmpl = ERB.new(template)
+      containers.each do |container|
+        ns = OpenStruct.new({ container: container })
+        ns.extend(DockerBoss::Helpers::TemplateHelpers)
+        entries = tmpl.result(ns.instance_eval { binding })
+        entries.lines.each do |line|
+          (keyword, key, value) = line.lstrip.chomp.split(" ", 3)
+          values[key] = value.to_s if keyword == 'ensure'
+        end
+      end
+    end
+    values
+  end
+end

data/lib/docker_boss/modules/templates.rb

@@ -0,0 +1,131 @@
+require 'docker_boss'
+require 'docker_boss/helpers'
+require 'docker_boss/module'
+require 'docker'
+require 'yaml'
+require 'erb'
+require 'ostruct'
+require 'shellwords'
+
+class DockerBoss::Module::Templates < DockerBoss::Module
+  def initialize(config)
+    @config = config
+    @instances = []
+
+    config.each do |name, inst_cfg|
+      @instances << Instance.new(name, inst_cfg)
+    end
+  end
+
+  def trigger(containers, trigger_id)
+    @instances.each do |instance|
+      begin
+        instance.trigger(containers, trigger_id)
+      rescue ArgumentError => e
+        DockerBoss.logger.error "templates: Error in configuration for instance `#{instance.name}`: #{e.message}"
+      rescue Docker::Error::DockerError => e
+        DockerBoss.logger.error "templates: Error occurred processing instance `#{instance.name}`: #{e.message}"
+      end
+    end
+  end
+
+
+  class Instance
+    attr_reader :name
+
+    def initialize(name, config)
+      @name = name
+      @config = config
+      DockerBoss.logger.debug "templates: Instance `#{@name}`: created"
+    end
+
+    def do_file(f, containers)
+      tmpl_path = DockerBoss::Helpers.render_erb(f['template'], :container => linked_container.json)
+      file_path = DockerBoss::Helpers.render_erb(f['file'], :container => linked_container.json)
+
+      file_contents = DockerBoss::Helpers.render_erb_file(tmpl_path, :containers => containers)
+
+      new_digest = Digest::SHA256.hexdigest file_contents
+      old_digest = (f.has_key? 'checksum') ? f['checksum'] : ""
+      f['checksum'] = new_digest
+
+      File.write(file_path, file_contents) if new_digest != old_digest
+      new_digest != old_digest
+    end
+
+    def do_actions
+      err = false
+
+      if @config.has_key? 'action'
+        err ||= !system(@config['action'])
+      end
+
+      if @config.has_key? 'linked_container' and @config['linked_container'].has_key? 'action'
+        args = @config['linked_container']['action'].split(':', 2)
+        case args.first
+        when 'shell'
+          raise ArgumentError, "action `shell` needs at least one more argument" if args.size < 2
+          command = ["sh", "-c", args[1]]
+          linked_container.exec(command)
+        when 'shell_bg'
+          raise ArgumentError, "action `shell_bg` needs at least one more argument" if args.size < 2
+          command = ["sh", "-c", args[1]]
+          linked_container.exec(command, detach: true)
+        when 'exec'
+          raise ArgumentError, "action `exec` needs at least one more argument" if args.size < 2
+          linked_container.exec(Shellwords.split(args[1]))
+        when 'exec_bg'
+          raise ArgumentError, "action `exec_bg` needs at least one more argument" if args.size < 2
+          linked_container.exec(Shellwords.split(args[1]), detach: true)
+        when 'restart'
+          linked_container.restart
+        when 'start'
+          linked_container.start
+        when 'stop'
+          linked_container.stop
+        when 'pause'
+          linked_container.pause
+        when 'unpause'
+          linked_container.unpause
+        when 'kill'
+          if args.size == 2
+            linked_container.kill(:signal => args[1])
+          else
+            linked_container.kill
+          end
+        else
+          raise ArgumentError, "unknown action `#{args.first}`"
+        end
+      end
+    end
+
+    def trigger(containers, trigger_id = nil)
+      if trigger_id.nil? or
+          not has_link? or
+          linked_container.id != trigger_id
+        # Only do something if the linked container is not also the triggering container
+        changed = @config['files'].inject (false) { |changed,f| do_file(f, containers) || changed }
+        DockerBoss.logger.info "templates: Instance `#{@name}`: triggered; changed=#{changed}"
+        do_actions if changed
+      else
+        DockerBoss.logger.info "templates: Instance `#{@name}`: ignored event"
+      end
+    end
+
+    def has_link?
+      @config.has_key? 'linked_container'
+    end
+
+    def linked_container
+      if has_link?
+        (Docker::Container.all(:all => true).find { |c| c.json['Name'] == "/#{@config['linked_container']['name']}" })
+      else
+        nil
+      end
+    end
+
+    def linked_container_props
+      data = linked_container.json
+    end
+  end
+end

data/lib/docker_boss/version.rb

@@ -0,0 +1,3 @@
+module DockerBoss
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: docker_boss
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Hornung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.17.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+- !ruby/object:Gem::Dependency
+  name: rubydns
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: etcd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: Templating using docker container information
+email:
+- alex@alexhornung.com
+executables:
+- docker-boss
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/docker-boss
+- docker_boss.gemspec
+- example.cfg.yml
+- lib/docker_boss.rb
+- lib/docker_boss/cli.rb
+- lib/docker_boss/engine.rb
+- lib/docker_boss/helpers.rb
+- lib/docker_boss/module.rb
+- lib/docker_boss/modules/dns.rb
+- lib/docker_boss/modules/etcd.rb
+- lib/docker_boss/modules/templates.rb
+- lib/docker_boss/version.rb
+homepage: https://github.com/bwalex/docker_boss
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Templating using docker container information
+test_files: []