docker-provider 0.0.2 → 0.1.0

data/lib/docker-provider/errors.rb

@@ -0,0 +1,14 @@
+require 'vagrant/errors'
+
+module VagrantPlugins
+  module DockerProvider
+    module Errors
+      class ImageNotConfiguredError < Vagrant::Errors::VagrantError
+        error_key(:docker_provider_image_not_configured)
+      end
+      class NfsWithoutPrivilegedError < Vagrant::Errors::VagrantError
+        error_key(:docker_provider_nfs_without_privileged)
+      end
+    end
+  end
+end

data/lib/docker-provider/plugin.rb

@@ -1,6 +1,8 @@
-require_relative "version"
-
-require 'vagrant'
+# TODO: Switch to Vagrant.require_version before 1.0.0
+#       see: https://github.com/mitchellh/vagrant/blob/bc55081e9ffaa6820113e449a9f76b293a29b27d/lib/vagrant.rb#L202-L228
+unless Gem::Requirement.new('>= 1.4.0').satisfied_by?(Gem::Version.new(Vagrant::VERSION))
+  raise 'docker-provider requires Vagrant >= 1.4.0 in order to work!'
+end
 
 I18n.load_path << File.expand_path(File.dirname(__FILE__) + '/../../locales/en.yml')
 I18n.reload!
@@ -19,6 +21,11 @@ module VagrantPlugins
         require_relative 'config'
         Config
       end
+
+      synced_folder(:docker) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
     end
   end
 end

data/lib/docker-provider/provider.rb

@@ -25,7 +25,7 @@ module VagrantPlugins
         # we return nil.
         return nil if state == :not_created
 
-        network = @driver.inspect(@machine.id)['NetworkSettings']
+        network = @driver.inspect_container(@machine.id)['NetworkSettings']
         ip      = network['IPAddress']
 
         # If we were not able to identify the container's IP, we return nil

data/lib/docker-provider/synced_folder.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module DockerProvider
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine)
+        # These synced folders only work if the provider is Docker
+        machine.provider_name == :docker
+      end
+
+      def prepare(machine, folders, _opts)
+        # FIXME: Check whether the container has already been created with
+        #        different synced folders and let the user know about it
+        folders.each do |id, data|
+          host_path  = File.expand_path(data[:hostpath], machine.env.root_path)
+          guest_path = data[:guestpath]
+          machine.provider_config.volumes << "#{host_path}:#{guest_path}"
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module DockerProvider
-    VERSION = "0.0.2"
+    VERSION = "0.1.0"
   end
 end

data/locales/en.yml

@@ -17,5 +17,16 @@ en:
 
     errors:
       config:
-        image_not_set: 'The base Docker image has not been set!'
-        image_not_set: 'The Docker command has not been set!'
+        cmd_not_set: |-
+          The Docker command has not been set!
+
+  vagrant:
+    errors:
+      docker_provider_nfs_without_privileged: |-
+        You've configured a NFS synced folder but didn't enable privileged
+        mode for the container. Please set the `privileged` option to true
+        on the provider block from your Vagrantfile, recreate the container
+        and try again.
+
+      docker_provider_image_not_configured: |-
+        The base Docker image has not been set for the '%{name}' VM!

data/spec/acceptance/provider/basic_spec.rb

@@ -0,0 +1,94 @@
+# This tests the basic functionality of a provider: that it can run
+# a machine, provide SSH access, and destroy that machine.
+shared_examples "provider/basic" do |provider, options|
+  if !options[:box]
+    raise ArgumentError,
+      "box option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    assert_execute("vagrant", "box", "add", "box", options[:box])
+    assert_execute("vagrant", "init", "box")
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    # TODO: Can we just shell out to something?
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+  end
+
+  after do
+    # Just always do this just in case
+    execute("vagrant", "destroy", "--force", log: false)
+  end
+
+  def assert_running
+    result = execute("vagrant", "ssh", "-c", "echo foo")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/foo\n$/)
+  end
+
+  def assert_not_running
+    result = execute("vagrant", "ssh", "-c", "echo foo")
+    expect(result).to exit_with(1)
+  end
+
+=begin
+TODO(mitchellh): These all exit with exit code 0. Unsure if bug.
+
+  it "can't halt before an up" do
+    expect(execute("vagrant", "halt")).to exit_with(1)
+  end
+
+  it "can't resume before an up" do
+    expect(execute("vagrant", "resume")).to exit_with(1)
+  end
+
+  it "can't suspend before an up" do
+    expect(execute("vagrant", "suspend")).to exit_with(1)
+  end
+=end
+
+  context "after an up" do
+    before do
+      assert_execute("vagrant", "up", "--provider=#{provider}")
+    end
+
+    after do
+      assert_execute("vagrant", "destroy", "--force")
+    end
+
+    it "can manage machine lifecycle" do
+      status("Test: machine is running after up")
+      assert_running
+
+      if !options[:features].include?("!suspend")
+        status("Test: suspend")
+        assert_execute("vagrant", "suspend")
+
+        status("Test: ssh doesn't work during suspended state")
+        assert_not_running
+
+        status("Test: resume after suspend")
+        assert_execute("vagrant", "resume")
+        assert_running
+      else
+        status("Not testing 'suspend', provider doesn't support it")
+      end
+
+      if !options[:features].include?("!halt")
+        status("Test: halt")
+        assert_execute("vagrant", "halt")
+
+        status("Test: ssh doesn't work during halted state")
+        assert_not_running
+
+        status("Test: up after halt")
+        assert_execute("vagrant", "up")
+        assert_running
+      else
+        status("Not testing 'halt', provider doesn't support it")
+      end
+    end
+  end
+end

data/spec/acceptance/provider/network_forwarded_port_spec.rb

@@ -0,0 +1,29 @@
+shared_examples "provider/network/forwarded_port" do |provider, options|
+  if !options[:box]
+    raise ArgumentError,
+      "box option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("network_forwarded_port")
+
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    # TODO: Can we just shell out to something?
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+
+    assert_execute("vagrant", "box", "add", "box", options[:box])
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  it "properly configures forwarded ports" do
+    status("Test: TCP forwarded port (default)")
+    assert_network("http://localhost:8080/", 8080)
+  end
+end

data/spec/acceptance/provider/synced_folder_spec.rb

@@ -0,0 +1,39 @@
+# This tests that synced folders work with a given provider.
+shared_examples "provider/synced_folder" do |provider, options|
+  if !options[:box]
+    raise ArgumentError,
+      "box option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("synced_folders")
+
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    # TODO: Can we just shell out to something?
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+
+    assert_execute("vagrant", "box", "add", "basic", options[:box])
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  # We put all of this in a single RSpec test so that we can test all
+  # the cases within a single VM rather than having to `vagrant up` many
+  # times.
+  it "properly configures synced folder types" do
+    status("Test: mounts the default /vagrant synced folder")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant/foo")
+    expect(result.exit_code).to eql(0)
+    expect(result.stdout).to match(/hello$/)
+
+    status("Test: doesn't mount a disabled folder")
+    result = execute("vagrant", "ssh", "-c", "test -d /foo")
+    expect(result.exit_code).to eql(1)
+  end
+end

data/spec/acceptance/provisioner/chef_solo_spec.rb

@@ -0,0 +1,37 @@
+shared_examples "provider/provisioner/chef-solo" do |provider, options|
+  box = options[:box_chef] || options[:box]
+  if !box
+    raise ArgumentError,
+      "box_basic option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("provisioner_chef_solo")
+
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    # TODO: Can we just shell out to something?
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+
+    assert_execute("vagrant", "box", "add", "box", box)
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  it "provisions with chef-solo" do
+    status("Test: basic cookbooks and recipes")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-chef-basic")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/basic$/)
+
+    status("Test: works with roles")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-chef-basic-roles")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/basic-roles$/)
+  end
+end

data/spec/acceptance/provisioner/puppet_spec.rb

@@ -0,0 +1,37 @@
+shared_examples "provider/provisioner/puppet" do |provider, options|
+  box = options[:box_puppet] || options[:box]
+  if !box
+    raise ArgumentError,
+      "box_basic option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("provisioner_puppet")
+
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    # TODO: Can we just shell out to something?
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+
+    assert_execute("vagrant", "box", "add", "box", box)
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  it "provisions with puppet" do
+    status("Test: basic manifests")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-puppet-basic")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/basic$/)
+
+    status("Test: basic modules")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-puppet-basic-modules")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/modules$/)
+  end
+end

data/spec/acceptance/provisioner/shell_spec.rb

@@ -0,0 +1,51 @@
+shared_examples "provider/provisioner/shell" do |provider, options|
+  if !options[:box]
+    raise ArgumentError,
+      "box_basic option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("provisioner_shell")
+
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    # TODO: Can we just shell out to something?
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+
+    assert_execute("vagrant", "box", "add", "box", options[:box])
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  it "provisions with the shell script" do
+    status("Test: inline script")
+    result = execute("vagrant", "ssh", "-c", "cat /foo")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/foo\n$/)
+
+    status("Test: script from path")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-path")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/bar\n$/)
+
+    status("Test: script with args")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-args")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/hello\ntwo words\n$/)
+
+    status("Test: privileged scripts")
+    result = execute("vagrant", "ssh", "-c", "cat /tmp/vagrant-user-root")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/root$/)
+
+    status("Test: non-privileged scripts")
+    result = execute("vagrant", "ssh", "-c", "cat /tmp/vagrant-user")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to_not match(/root$/)
+  end
+end

data/spec/acceptance/synced_folder/nfs_spec.rb

@@ -0,0 +1,36 @@
+shared_examples "provider/synced_folder/nfs" do |provider, options|
+  if !options[:box]
+    raise ArgumentError,
+      "box option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("synced_folder_nfs")
+
+    vagrantfile = environment.workdir.join('Vagrantfile')
+    new_vagrantfile = "Vagrant.require_plugin('docker-provider')\n#{vagrantfile.read}"
+    new_vagrantfile.gsub!(/(config\.vm\.box = "box")/, "\\1\nconfig.vm.provider :docker do |docker|\ndocker.privileged = true\nend\n")
+    new_vagrantfile.gsub!(/(, type: "nfs")/, '\1, mount_options: ["rw", "vers=3", "tcp", "nolock"]')
+    vagrantfile.open('w') { |f| f.puts(new_vagrantfile) }
+
+    assert_execute("vagrant", "box", "add", "box", options[:box])
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  it "properly configures NFS" do
+    status("Test: mounts the NFS folder")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant-nfs/foo")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/hello$/)
+
+    status("Test: doesn't mount a disabled folder")
+    result = execute("vagrant", "ssh", "-c", "test -d /foo")
+    expect(result.exit_code).to eql(1)
+  end
+end

data/spec/unit/driver_spec.rb

@@ -12,12 +12,13 @@ describe VagrantPlugins::DockerProvider::Driver do
 
   describe '#create' do
     let(:params) { {
-      image:    'jimi/hendrix:eletric-ladyland',
-      cmd:      ['play', 'voodoo-chile'],
-      ports:    '8080:80',
-      volumes:  '/host/path:guest/path',
-      name:     cid,
-      hostname: 'jimi-hendrix'
+      image:      'jimi/hendrix:eletric-ladyland',
+      cmd:        ['play', 'voodoo-chile'],
+      ports:      '8080:80',
+      volumes:    '/host/path:guest/path',
+      name:       cid,
+      hostname:   'jimi-hendrix',
+      privileged: true
     } }
 
     before { subject.create(params) }
@@ -38,6 +39,10 @@ describe VagrantPlugins::DockerProvider::Driver do
       expect(cmd_executed).to match(/-v #{params[:volumes]} .+ #{Regexp.escape params[:image]}/)
     end
 
+    it 'is able to run a privileged container' do
+      expect(cmd_executed).to match(/-privileged .+ #{Regexp.escape params[:image]}/)
+    end
+
     it 'sets the hostname if specified' do
       expect(cmd_executed).to match(/-h #{params[:hostname]} #{Regexp.escape params[:image]}/)
     end
@@ -86,6 +91,18 @@ describe VagrantPlugins::DockerProvider::Driver do
     end
   end
 
+  describe '#privileged?' do
+    it 'identifies privileged containers' do
+      subject.stub(inspect_container: {'HostConfig' => {"Privileged" => true}})
+      expect(subject).to be_privileged(cid)
+    end
+
+    it 'identifies unprivileged containers' do
+      subject.stub(inspect_container: {'HostConfig' => {"Privileged" => false}})
+      expect(subject).to_not be_privileged(cid)
+    end
+  end
+
   describe '#start' do
     context 'when container is running' do
       before { subject.stub(running?: true) }
@@ -111,7 +128,7 @@ describe VagrantPlugins::DockerProvider::Driver do
       before { subject.stub(running?: true) }
 
       it 'stops the container' do
-        subject.should_receive(:execute).with('docker', 'stop', cid)
+        subject.should_receive(:execute).with('docker', 'stop', '-t', '1', cid)
         subject.stop(cid)
       end
     end
@@ -120,24 +137,66 @@ describe VagrantPlugins::DockerProvider::Driver do
       before { subject.stub(running?: false) }
 
       it 'does not stop container' do
-        subject.should_not_receive(:execute).with('docker', 'stop', cid)
+        subject.should_not_receive(:execute).with('docker', 'stop', '-t', '1', cid)
         subject.stop(cid)
       end
     end
   end
 
-  describe '#inspect' do
+  describe '#rm' do
+    context 'when container has been created' do
+      before { subject.stub(created?: true) }
+
+      it 'removes the container' do
+        subject.should_receive(:execute).with('docker', 'rm', '-v', cid)
+        subject.rm(cid)
+      end
+    end
+
+    context 'when container has not been created' do
+      before { subject.stub(created?: false) }
+
+      it 'does not attempt to remove the container' do
+        subject.should_not_receive(:execute).with('docker', 'rm', '-v', cid)
+        subject.rm(cid)
+      end
+    end
+  end
+
+  describe '#inspect_container' do
     let(:data) { '[{"json": "value"}]' }
 
     before { subject.stub(execute: data) }
 
     it 'inspects the container' do
       subject.should_receive(:execute).with('docker', 'inspect', cid)
-      subject.inspect(cid)
+      subject.inspect_container(cid)
     end
 
     it 'parses the json output' do
-      expect(subject.inspect(cid)).to eq('json' => 'value')
+      expect(subject.inspect_container(cid)).to eq('json' => 'value')
+    end
+  end
+
+  describe '#all_containers' do
+    let(:containers) { "container1\ncontainer2" }
+
+    before { subject.stub(execute: containers) }
+
+    it 'returns an array of all known containers' do
+      subject.should_receive(:execute).with('docker', 'ps', '-a', '-q', '-notrunc')
+      expect(subject.all_containers).to eq(['container1', 'container2'])
+    end
+  end
+
+  describe '#docker_bridge_ip' do
+    let(:containers) { " inet 123.456.789.012/16 " }
+
+    before { subject.stub(execute: containers) }
+
+    it 'returns an array of all known containers' do
+      subject.should_receive(:execute).with('/sbin/ip', '-4', 'addr', 'show', 'scope', 'global', 'docker0')
+      expect(subject.docker_bridge_ip).to eq('123.456.789.012')
     end
   end
 end