vocker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 834fa1d18bf8e23e1faa503aa702833f1bcd4b31
+  data.tar.gz: bb7ab7702c172a3288187936928e449a35f0e22a
+SHA512:
+  metadata.gz: 7ff4f1feb914ce2a7c664a4773b7459adcdbb5b0a5db8b7758542a3f63281344c1358d2c99c2e1bea44fc525a19edee2d63c23826e4dc474ba8d5179900aed74
+  data.tar.gz: 1016810d2ea2364b09b245bfc2ac260fb3ca705b01a82b7ed9792b29834bca931398b47fc6adf4f041bf34ee79a25425284a5cde3e19fc3a4ace90bfd2b38b5f

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-docker-provisioner.gemspec
+gemspec
+
+group :development do
+  gem 'vagrant', github: 'mitchellh/vagrant'
+  gem 'vagrant-lxc'
+  gem 'vagrant-cachier'
+  gem 'vagrant-pristine'
+  gem 'vagrant-global-status'
+
+  gem 'rspec'
+  gem 'simplecov', require: false
+  gem 'bogus'
+  gem 'guard-rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,96 @@
+GIT
+  remote: git://github.com/mitchellh/vagrant.git
+  revision: e34cdbf86dca4a02f528b52d02cc10ca1c7682c3
+  specs:
+    vagrant (1.2.8.dev)
+      childprocess (~> 0.3.7)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6.0)
+      log4r (~> 1.1.9)
+      net-scp (~> 1.1.0)
+      net-ssh (~> 2.6.6)
+
+PATH
+  remote: .
+  specs:
+    vocker (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bogus (0.1.4)
+      dependor (>= 0.0.4)
+    childprocess (0.3.9)
+      ffi (~> 1.0, >= 1.0.11)
+    coderay (1.0.9)
+    dependor (0.0.6)
+    diff-lcs (1.2.4)
+    erubis (2.7.0)
+    ffi (1.9.0)
+    formatador (0.2.4)
+    guard (1.8.1)
+      formatador (>= 0.2.4)
+      listen (>= 1.0.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-rspec (3.0.2)
+      guard (>= 1.8)
+      rspec (~> 2.13)
+    i18n (0.6.4)
+    listen (1.2.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    log4r (1.1.10)
+    lumberjack (1.0.4)
+    method_source (0.8.2)
+    multi_json (1.7.7)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.6.8)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.0)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.1)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.6)
+    thor (0.18.1)
+    vagrant-cachier (0.3.0)
+    vagrant-global-status (0.1.0)
+    vagrant-lxc (0.5.0)
+    vagrant-pristine (0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bogus
+  bundler (~> 1.3)
+  guard-rspec
+  rake
+  rspec
+  simplecov
+  vagrant!
+  vagrant-cachier
+  vagrant-global-status
+  vagrant-lxc
+  vagrant-pristine
+  vocker!

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/vocker/(.+)\.rb$})     { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Fabio Rehm
+
+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,163 @@
+# Vocker
+
+An experimental plugin that introduces [Docker](http://docker.io) to [Vagrant](http://www.vagrantup.com/)
+as a [provisioner](http://docs.vagrantup.com/v2/plugins/provisioners.html) and
+as a command that allows you to interact with the guest machine Docker
+installation. It can also be used for building other Vagrant plugins that
+needs interaction with a Docker instance.
+
+
+## Installation
+
+Make sure you have Vagrant 1.2+ and run:
+
+```
+vagrant plugin install vocker
+```
+
+
+## Features
+
+* Automatically installs Docker on guest machines
+* Adds a command to interact with guest's Docker from the host machine
+* Allows you to provision VMs with Docker images / containers from within your `Vagrantfile`
+* Can be used to build other plugins (and I'm currently working on one :)
+
+
+## Status
+
+Early development. It can be useful for trying out Docker and it's growing "ecossystem"
+but the feature set and configuration format might change rapidly.
+
+Apart from that I've only used the plugin on the following Ubuntu 13.04 VMs:
+
+* http://cloud-images.ubuntu.com/vagrant/raring/current/raring-server-cloudimg-amd64-vagrant-disk1.box
+* http://bit.ly/vagrant-lxc-raring64-2013-07-12 (yes! LXC inception :)
+
+_Please note that in order to use the plugin on [vagrant-lxc](https://github.com/fgrehm/vagrant-lxc)
+containers you need some extra steps described below_
+
+
+## Usage
+
+Currently Vocker can be used in three different ways: as a provisioner, as a command
+and as a foundation for other Vagrant plugins.
+
+### Provisioner
+
+On the same spirit as the undocumented [CFEngine](https://github.com/mitchellh/vagrant/tree/master/plugins/provisioners/cfengine)
+provisioner, this plugin will automatically [install](https://github.com/fgrehm/vocker/blob/master/lib/vocker/cap/debian/docker_install.rb)
+Docker on Guest machines if you specify the provisioner on your `Vagrantfile`
+like:
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = 'your-box'
+  config.vm.provision :docker
+end
+```
+
+_Please note that only Ubuntu / Debian guests are currently capable of automatic
+Docker installation. For usage on other guests you'll need to manually install it
+prior to use this plugin._
+
+You can also use the provisioner block to specify images to be pulled and / or
+containers to run:
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.provision :docker do |docker|
+    docker.pull_images 'ubuntu', 'busybox'
+
+    # Command + image
+    docker.run 'echo ls -la --color', 'ubuntu'
+
+    # Unique container name + other configs
+    docker.run 'date', image: 'ubuntu', cmd: '/bin/sh -c "while true; date; do echo hello world; sleep 1; done"'
+
+    # Base image (requires ENTRYPOINT / CMD) to be configured:
+    #   * http://docs.docker.io/en/latest/use/builder/#entrypoint
+    #   * http://docs.docker.io/en/latest/use/builder/#cmd
+    docker.run 'mysql'
+  end
+end
+```
+
+The provisioner will also ensure that a single instance of the container is
+running at a time and you can run `vagrant provision` as many times as you want
+without leaving lots of unused containers behind. If you are interested on
+understanding how it works, have a look at [_DockerClient#run_](https://github.com/fgrehm/vocker/blob/master/lib/vocker/docker_client.rb#L22)
+
+
+### `vagrant docker` command
+
+The command is basically a wrapper over `vagrant ssh -c` that allows you
+to run `docker` commands on the guest VM:
+
+```
+Usage: vagrant docker [vm-name] COMMAND [ARGS]
+
+COMMAND can be any of attach, build, commit, diff, events, export, history,
+images, import, info, insert, inspect, kill, login, logs, port, top, ps,
+pull, push, restart, rm, rmi, run, search, start, stop, tag, version, wait
+
+    -h, --help                       Print this help
+```
+
+
+### _your-awesome-vagrant-plugin™_
+
+In case you want to build a Vagrant plugin that needs to interact with Docker you
+can add this plugin as a dependency and use [DockerClient](lib/vocker/docker_client.rb)
+/ [DockerInstaller](lib/vocker/docker_installer.rb) classes. An example of usage
+will be provided _"soon"_.
+
+
+### Usage with [vagrant-lxc](https://github.com/fgrehm/vagrant-lxc)
+
+If you are on a Linux machine, you can use vagrant-lxc to avoid messing up with
+your working environment. While developing this plugin I was able to recreate
+containers that were capable of using Docker without issues multiple times on
+an up to date Ubuntu 13.04 host and guest.
+
+In order to allow a vagrant-lxc container to boot nested Docker containers you'll
+just need to `apt-get install apparmor-utils && aa-complain /usr/bin/lxc-start`
+and add the code below to your Vagrantfile:
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.provider :lxc do |lxc|
+    lxc.customize 'aa_profile', 'unconfined'
+  end
+
+  config.vm.provision :shell, inline: %[
+    if ! [ -f /etc/default/lxc ]; then
+      cat <<STR > /etc/default/lxc
+LXC_AUTO="true"
+USE_LXC_BRIDGE="true"
+LXC_BRIDGE="lxcbr0"
+LXC_ADDR="10.0.253.1"
+LXC_NETMASK="255.255.255.0"
+LXC_NETWORK="10.0.253.0/24"
+LXC_DHCP_RANGE="10.0.253.2,10.0.253.254"
+LXC_DHCP_MAX="253"
+LXC_SHUTDOWN_TIMEOUT=120
+STR
+    fi
+  ]
+end
+```
+
+The LXC networking configs are only required if you are on an Ubuntu host as
+it automatically creates the `lxcbr0` bridge for you on the host machine and
+if you don't do that the vagrant-lxc container will end up crashing as it
+will collide with the host's `lxcbr0`.
+
+
+## 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,3 @@
+Dir['./tasks/**/*.rake'].each { |f| load f }
+
+require "bundler/gem_tasks"

data/development/Vagrantfile

@@ -0,0 +1,51 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.require_plugin 'vagrant-lxc'
+Vagrant.require_plugin 'vagrant-cachier'
+Vagrant.require_plugin 'vagrant-pristine'
+Vagrant.require_plugin 'vagrant-global-status'
+Vagrant.require_plugin 'vocker'
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "raring64"
+  config.vm.synced_folder "../", "/vagrant", id: 'vagrant-root'#, nfs: true
+  config.vm.synced_folder "~/projetos/oss/ventriloquist", "/home/vagrant/ventriloquist"
+  config.vm.network :private_network, ip: "192.168.123.123"
+
+  config.cache.auto_detect = true
+
+  config.vm.provider :lxc do |lxc|
+    # Required to boot nested containers
+    lxc.customize 'aa_profile', 'unconfined'
+  end
+
+  config.vm.provision :shell, inline: %[
+    if ! [ -f /etc/default/lxc ]; then
+      cat <<STR > /etc/default/lxc
+LXC_AUTO="true"
+USE_LXC_BRIDGE="true"
+LXC_BRIDGE="lxcbr0"
+LXC_ADDR="10.0.253.1"
+LXC_NETMASK="255.255.255.0"
+LXC_NETWORK="10.0.253.0/24"
+LXC_DHCP_RANGE="10.0.253.2,10.0.253.254"
+LXC_DHCP_MAX="253"
+LXC_SHUTDOWN_TIMEOUT=120
+STR
+    fi
+  ]
+
+  config.vm.define :vm1 do |vm1|
+    vm1.vm.provision :docker do |docker|
+      docker.pull_images 'ubuntu', 'busybox'
+      docker.run 'echo ls -la --color', 'ubuntu'
+      docker.run 'echo ls -la --color', image: 'ubuntu'  # Above is the default
+      docker.run 'date', image: 'ubuntu', cmd: '/bin/sh -c "while true; date; do echo hello world; sleep 1; done"'
+    end
+  end
+
+  config.vm.define :vm2 do |vm2|
+    vm2.vm.provision :docker
+  end
+end

data/lib/vocker/cap/debian/docker_install.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Vocker
+    module Cap
+      module Debian
+        module DockerInstall
+          def self.docker_install(machine)
+            # Inspired on https://github.com/progrium/dokku/blob/master/Makefile#L33-L40
+            machine.communicate.tap do |comm|
+              # TODO: Try to not depend on installing software-properties-common
+              comm.sudo("apt-get install -y -q software-properties-common")
+              comm.sudo("apt-add-repository -y ppa:dotcloud/lxc-docker")
+              comm.sudo("apt-get update")
+              comm.sudo("apt-get install -y -q xz-utils lxc-docker -o Dpkg::Options::='--force-confdef' -o Dpkg::Options::='--force-confold'")
+              # TODO: Error out if provider is lxc
+              # comm.sudo("lsmod | grep aufs || modprobe aufs || apt-get install -y linux-image-extra-`uname -r`")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vocker/cap/linux/docker_installed.rb

@@ -0,0 +1,13 @@
+module VagrantPlugins
+  module Vocker
+    module Cap
+      module Linux
+        module DockerInstalled
+          def self.docker_installed(machine)
+            machine.communicate.test("test -d /var/lib/docker", sudo: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vocker/command.rb

@@ -0,0 +1,46 @@
+module VagrantPlugins
+  module Vocker
+    class Command < Vagrant.plugin("2", :command)
+      DOCKER_COMMANDS = %w(
+        attach build commit diff events export history images import info
+        insert inspect kill login logs port top ps pull push restart rm
+        rmi run search start stop tag version wait
+      )
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant docker [vm-name] COMMAND [ARGS]"
+          o.separator ""
+          o.separator "COMMAND can be any of #{DOCKER_COMMANDS.join(', ')}"
+          o.separator ""
+        end
+
+        # Parse out docker commands
+        options = {}
+        command_index = @argv.index{|cmd| DOCKER_COMMANDS.include? cmd}
+        if command_index
+          options[:command] = @argv.drop(command_index)
+          @argv             = @argv.take(command_index)
+        end
+
+        # Parse the options and return if we don't have any target.
+        argv = parse_options(opts)
+        return if !argv
+
+        # Execute the actual Docker command
+        # TODO: Make it work with multiple VMs
+        with_target_vms(argv, :single_target => true) do |vm|
+          # FIXME: - Check if docker is running first
+          #        - Handle empty command
+
+          @logger.debug("Executing docker command on remote machine: #{options[:command]}")
+          env = vm.action(:ssh_run, :ssh_run_command => "sudo docker #{options[:command].join(' ')}")
+
+          # Exit with the exit status of the command or a 0 if we didn't
+          # get one.
+          exit_status = env[:ssh_run_exit_status] || 0
+          return exit_status
+        end
+      end
+    end
+  end
+end

data/lib/vocker/config.rb

@@ -0,0 +1,41 @@
+require 'set'
+
+module VagrantPlugins
+  module Vocker
+    class Config < Vagrant.plugin("2", :config)
+      attr_reader :images, :containers
+
+      def initialize
+        @images     = Set.new
+        @containers = Hash.new
+      end
+
+      def pull_images(*images)
+        @images += images.map(&:to_s)
+      end
+
+      def run(*args)
+        container_name = args.shift
+        params         = {}
+
+        if args.empty?
+          params[:image] = container_name
+        elsif args.first.is_a?(String)
+          params[:image] = args.shift
+          params[:cmd]   = container_name
+        else
+          params = args.shift
+          params[:cmd] ||= container_name
+        end
+
+        @containers[container_name.to_s] = params
+      end
+
+      def merge(other)
+        super.tap do |result|
+          result.pull_images *(other.images + self.images)
+        end
+      end
+    end
+  end
+end

data/lib/vocker/docker_client.rb

@@ -0,0 +1,54 @@
+require 'digest/sha1'
+
+module VagrantPlugins
+  module Vocker
+    class DockerClient
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def pull_images(*images)
+        @machine.communicate.tap do |comm|
+          images.each do |image|
+            comm.sudo("docker images | grep -q #{image} || docker pull #{image}")
+          end
+        end
+      end
+
+      def daemon_running?
+        @machine.communicate.test('test -f /var/run/docker.pid')
+      end
+
+      def run(containers)
+        containers.each do |name, config|
+          cids_dir = "/var/lib/vocker/cids"
+          config[:cidfile] ||= "#{cids_dir}/#{Digest::SHA1.hexdigest name}"
+
+          id = "$(cat #{config[:cidfile]})"
+
+          @machine.communicate.sudo("mkdir -p #{cids_dir}")
+          if container_exist?(id)
+            start_container(id)
+          else
+            create_container(config)
+          end
+        end
+      end
+
+      def container_exist?(id)
+        @machine.communicate.test("sudo docker ps -a -q | grep -q #{id}")
+      end
+
+      def start_container(id)
+        @machine.communicate.sudo("docker start #{id}")
+      end
+
+      def create_container(config)
+        @machine.communicate.sudo %[
+          rm -f #{config[:cidfile]}
+          docker run -cidfile=#{config[:cidfile]} -d #{config[:image]} #{config[:cmd]}
+        ]
+      end
+    end
+  end
+end

data/lib/vocker/docker_installer.rb

@@ -0,0 +1,30 @@
+require_relative "errors"
+
+module VagrantPlugins
+  module Vocker
+    class DockerInstaller
+      def initialize(machine)
+        @machine = machine
+      end
+
+      # This handles verifying the Docker installation, installing it if it was
+      # requested, and so on. This method will raise exceptions if things are
+      # wrong.
+      def ensure_installed
+        if !@machine.guest.capability?(:docker_installed)
+          @machine.ui.warn(I18n.t("vagrant.docker_cant_detect"))
+          return
+        end
+
+        if !@machine.guest.capability(:docker_installed)
+          @machine.ui.info(I18n.t("vagrant.docker_installing"))
+          @machine.guest.capability(:docker_install)
+
+          if !@machine.guest.capability(:docker_installed)
+            raise Errors::DockerInstallFailed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vocker/errors.rb

@@ -0,0 +1,11 @@
+module VagrantPlugins
+  module Vocker
+    module Errors
+      class DockerInstallFailed < ::Vagrant::Errors::VagrantError
+      end
+
+      class DockerNotRunning < ::Vagrant::Errors::VagrantError
+      end
+    end
+  end
+end

data/lib/vocker/plugin.rb

@@ -0,0 +1,40 @@
+require "vagrant"
+
+I18n.load_path << File.expand_path(File.dirname(__FILE__) + '/../../locales/en.yml')
+I18n.reload!
+
+module VagrantPlugins
+  module Vocker
+    class Plugin < Vagrant.plugin("2")
+      name "Vocker"
+      description <<-DESC
+      Introduces Docker to Vagrant
+      DESC
+
+      config(:docker, :provisioner) do
+        require_relative "config"
+        Config
+      end
+
+      guest_capability("debian", "docker_install") do
+        require_relative "cap/debian/docker_install"
+        Cap::Debian::DockerInstall
+      end
+
+      guest_capability("linux", "docker_installed") do
+        require_relative "cap/linux/docker_installed"
+        Cap::Linux::DockerInstalled
+      end
+
+      provisioner(:docker) do
+        require_relative "provisioner"
+        Provisioner
+      end
+
+      command(:docker) do
+        require_relative "command"
+        Command
+      end
+    end
+  end
+end

data/lib/vocker/provisioner.rb

@@ -0,0 +1,38 @@
+require_relative "errors"
+require_relative "docker_client"
+require_relative "docker_installer"
+
+module VagrantPlugins
+  module Vocker
+    # TODO: Improve handling of vagrant-lxc specifics (like checking for apparmor
+    #       profile stuff + autocorrection)
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def initialize(machine, config, installer = nil, client = nil)
+        super(machine, config)
+        @installer = installer || DockerInstaller.new(@machine)
+        @client    = client    || DockerClient.new(@machine)
+      end
+
+      def provision
+        @logger = Log4r::Logger.new("vagrant::plugins::docker-provisioner")
+
+        @logger.info("Checking for Docker installation...")
+        @installer.ensure_installed
+
+        unless @client.daemon_running?
+          raise Errors::DockerNotRunning
+        end
+
+        if config.images.any?
+          @machine.ui.info(I18n.t("vagrant.docker_pulling_images"))
+          @client.pull_images(*config.images)
+        end
+
+        if config.containers.any?
+          @machine.ui.info(I18n.t("vagrant.docker_starting_containers"))
+          @client.run(config.containers)
+        end
+      end
+    end
+  end
+end

data/lib/vocker/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Vocker
+    VERSION = "0.1.0"
+  end
+end

data/lib/vocker.rb

@@ -0,0 +1 @@
+require_relative 'vocker/plugin'

data/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  vagrant:
+    docker_installing: |-
+      Installing Docker onto machine...
+    docker_pulling_images:
+      Pulling Docker images...
+    docker_starting_containers:
+      Starting Docker containers...

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'bogus/rspec'
+
+require 'vocker'
+
+Bogus.configure do |c|
+  c.search_modules << VagrantPlugins::Vocker
+  c.search_modules << Vagrant
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'vocker/config'
+
+describe VagrantPlugins::Vocker::Config do
+  verify_contract(:config)
+
+  it 'combines images when merging' do
+    config = described_class.new.tap{|c| c.pull_images 'ubuntu', 'basebox' }
+    other  = described_class.new.tap{|c| c.pull_images 'basebox', 'centos' }
+    merged = config.merge(other)
+
+    expect(merged.images.to_a).to match_array(['basebox', 'centos', 'ubuntu'])
+  end
+
+  it 'merges containers definitions' do
+    config = described_class.new.tap{|c| c.run 'ls', cmd: 'ls', image: 'ubuntu' }
+    other  = described_class.new.tap{|c| c.run 'ls', cmd: 'ls -la', image: 'ubuntu' }
+    merged = config.merge(other)
+
+    expect(merged.containers).to include({'ls' => {cmd: 'ls -la', image: 'ubuntu'}})
+  end
+
+  describe 'containers arguments normalization' do
+    it 'maps a single argument as the image name' do
+      config = described_class.new.tap{|c| c.run 'mysql' }
+      expect(config.containers).to include('mysql' => {image: 'mysql'})
+    end
+
+    context 'when two strings are provided' do
+      subject { described_class.new.tap{|c| c.run 'ls -la', 'ubuntu' } }
+
+      it 'maps the first argument as the command' do
+        expect(subject.containers.values.first).to include(cmd: 'ls -la')
+      end
+
+      it 'maps the second argument as the image name' do
+        expect(subject.containers.values.first).to include(image: 'ubuntu')
+      end
+    end
+  end
+end

data/spec/unit/docker_client_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+require Vagrant.source_root.join('plugins/communicators/ssh/communicator')
+
+require 'vocker/docker_client'
+
+describe VagrantPlugins::Vocker::DockerClient do
+  verify_contract(:docker_client)
+
+  fake(:communicator, test: true) { VagrantPlugins::CommunicatorSSH::Communicator }
+
+  let(:machine) { fake(:machine, communicate: communicator) }
+
+  subject { described_class.new(machine) }
+
+  it 'pulls configured images' do
+    subject.pull_images 'base', 'mysql'
+    expect(communicator).to have_received.sudo(with{|cmd| cmd =~ /docker pull base/})
+    expect(communicator).to have_received.sudo(with{|cmd| cmd =~ /docker pull mysql/})
+  end
+
+  it 'verifies if the docker daemon is running' do
+    stub(communicator).test(with{|cmd| cmd == 'test -f /var/run/docker.pid'}) { true }
+    expect(subject.daemon_running?).to be_true
+
+    stub(communicator).test(any_args) { false }
+    expect(subject.daemon_running?).to be_false
+  end
+
+  context 'running containers' do
+    let(:containers) { {'mysql' => {image: 'mysql'}} }
+
+    it 'ensures container ids folder exists' do
+      subject.run containers
+      expect(communicator).to have_received.sudo(with{|cmd| cmd == 'mkdir -p /var/lib/vocker/cids'})
+    end
+
+    it 'automatically assigns a digest of the command as the cidfile if not specified' do
+      stub(communicator).test(with{|cmd| cmd =~ /docker ps/}) { false }
+      stub(Digest::SHA1).hexdigest('mysql') { 'digest' }
+      subject.run containers
+      expect(communicator).to have_received.sudo(with{|cmd| cmd =~ /-cidfile=\/var\/lib\/vocker\/cids\/digest/})
+    end
+
+    it 'allows cidfile to be specified' do
+      stub(communicator).test(with{|cmd| cmd =~ /docker ps/}) { false }
+      containers['mysql'][:cidfile] = '/foo/bla'
+      subject.run containers
+      expect(communicator).to have_received.sudo(with{|cmd| cmd =~ /-cidfile=\/foo\/bla/})
+    end
+
+    context 'when the container already exists' do
+      before do
+        stub(communicator).test(with{|cmd| cmd =~ /docker ps/}) { true }
+        subject.run containers
+      end
+
+      it 'starts the container' do
+        expect(communicator).to have_received.sudo(with{|cmd| cmd =~ /docker start/})
+      end
+    end
+
+    context 'when the container does not exist' do
+      before do
+        stub(communicator).test(with{|cmd| cmd =~ /docker ps/}) { false }
+        subject.run containers
+      end
+
+      it 'creates a new container' do
+        expect(communicator).to have_received.sudo(with{|cmd| cmd =~ /docker run/})
+      end
+    end
+  end
+end

data/spec/unit/docker_installer_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+require 'vagrant/ui'
+require Vagrant.source_root.join('plugins/communicators/ssh/communicator')
+
+require 'vocker/docker_installer'
+
+describe VagrantPlugins::Vocker::DockerInstaller do
+  verify_contract(:docker_installer)
+
+  fake(:guest)
+  fake(:ui) { Vagrant::UI::Interface }
+  let(:machine) { fake(:machine, guest: guest, ui: ui) }
+
+  subject { described_class.new(machine) }
+
+  it 'skips docker installation if guest is not capable' do
+    stub(guest).capability?(:docker_installed) { false }
+
+    subject.ensure_installed
+
+    expect(guest).to_not have_received.capability(:docker_installed)
+    expect(guest).to_not have_received.capability(:docker_install)
+  end
+
+  it 'skips docker installation if already installed' do
+    stub(guest).capability(:docker_installed) { true }
+
+    subject.ensure_installed
+
+    expect(guest).to have_received.capability(:docker_installed)
+    expect(guest).to_not have_received.capability(:docker_install)
+  end
+
+  it 'installs docker if not installed' do
+    # XXX: This is kinda hacky I believe
+    stub(guest).capability(:docker_installed) {
+      stub(guest).capability(:docker_installed) { true }
+      false
+    }
+
+    subject.ensure_installed
+
+    expect(guest).to have_received.capability(:docker_installed)
+    expect(guest).to have_received.capability(:docker_install)
+  end
+
+  it 'errors out if docker could not be installed' do
+    stub(guest).capability(:docker_installed) { false }
+
+    expect {
+      subject.ensure_installed
+    }.to raise_error(VagrantPlugins::Vocker::Errors::DockerInstallFailed)
+  end
+end

data/spec/unit/provisioner_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+require 'vagrant/ui'
+
+require 'vocker/config'
+require 'vocker/provisioner'
+
+describe VagrantPlugins::Vocker::Provisioner do
+  verify_contract(:provisioner)
+
+  fake(:guest)
+  fake(:ui) { Vagrant::UI::Interface }
+
+  let(:installer) { fake(:docker_installer, ensure_installed: nil) }
+  let(:client)    { fake(:docker_client, daemon_running?: true) }
+  let(:config)    { VagrantPlugins::Vocker::Config.new }
+  let(:machine)   { fake(:machine, guest: guest, ui: ui) }
+
+  subject { described_class.new(machine, config, installer, client) }
+
+  before do
+    config.pull_images 'base', 'mysql'
+    config.run 'mysql'
+  end
+
+  context 'docker can be installed and daemon is running' do
+    before { subject.provision }
+
+    it 'ensures docker gets installed' do
+      expect(installer).to have_received.ensure_installed
+    end
+
+    it 'pulls configured images' do
+      expect(client).to have_received.pull_images(*config.images)
+    end
+
+    it 'runs configured containers' do
+      expect(client).to have_received.run(with{|c| c['mysql'][:image] == 'mysql'})
+    end
+  end
+
+  context 'docker daemon is not able to start' do
+    before { stub(client).daemon_running? { false } }
+
+    it 'raises an error' do
+      expect{
+        subject.provision
+      }.to raise_error(VagrantPlugins::Vocker::Errors::DockerNotRunning)
+    end
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,9 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  ENV['COVERAGE'] = 'true'
+  t.pattern = "./spec/**/*_spec.rb"
+end
+
+desc 'Default task which runs all specs with code coverage enabled'
+task :default => ['spec']

data/vocker.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vocker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vocker"
+  spec.version       = VagrantPlugins::Vocker::VERSION
+  spec.authors       = ["Fabio Rehm"]
+  spec.email         = ["fgrehm@gmail.com"]
+  spec.description   = %q{Introduces Docker to Vagrant}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/fgrehm/vocker"
+  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.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: vocker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fabio Rehm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-15 00:00:00.000000000 Z
+dependencies:
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Introduces Docker to Vagrant
+email:
+- fgrehm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- development/Vagrantfile
+- lib/vocker.rb
+- lib/vocker/cap/debian/docker_install.rb
+- lib/vocker/cap/linux/docker_installed.rb
+- lib/vocker/command.rb
+- lib/vocker/config.rb
+- lib/vocker/docker_client.rb
+- lib/vocker/docker_installer.rb
+- lib/vocker/errors.rb
+- lib/vocker/plugin.rb
+- lib/vocker/provisioner.rb
+- lib/vocker/version.rb
+- locales/en.yml
+- spec/spec_helper.rb
+- spec/unit/config_spec.rb
+- spec/unit/docker_client_spec.rb
+- spec/unit/docker_installer_spec.rb
+- spec/unit/provisioner_spec.rb
+- tasks/spec.rake
+- vocker.gemspec
+homepage: https://github.com/fgrehm/vocker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Introduces Docker to Vagrant
+test_files:
+- spec/spec_helper.rb
+- spec/unit/config_spec.rb
+- spec/unit/docker_client_spec.rb
+- spec/unit/docker_installer_spec.rb
+- spec/unit/provisioner_spec.rb