docker-provider 0.0.1

data/lib/docker-provider/action/created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Created
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine      = env[:machine]
+          driver       = machine.provider.driver
+          env[:result] = machine.id && driver.created?(machine.id)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/action/destroy.rb

@@ -0,0 +1,24 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.destroy.destroying")
+
+          machine = env[:machine]
+          config  = machine.provider_config
+          driver  = machine.provider.driver
+
+          driver.rm(machine.id)
+          machine.id = nil
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/action/forward_ports.rb

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class ForwardPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          env[:forwarded_ports] = compile_forwarded_ports(env[:machine].config)
+
+          if env[:forwarded_ports].any?
+            env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
+            inform_forwarded_ports(env[:forwarded_ports])
+          end
+
+          # FIXME: Check whether the container has already been created with
+          #        different exposed ports and let the user know about it
+
+          @app.call env
+        end
+
+        def inform_forwarded_ports(ports)
+          ports.each do |fp|
+            message_attributes = {
+              :adapter    => 'eth0',
+              :guest_port => fp[:guest],
+              :host_port  => fp[:host]
+            }
+
+            @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
+                                  message_attributes))
+          end
+        end
+
+        private
+
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            if type == :forwarded_port && options[:id] != 'ssh'
+              mappings[options[:host]] = options
+            end
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/action/is_running.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class IsRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine    = env[:machine]
+          driver     = machine.provider.driver
+
+          env[:result] = driver.running?(machine.id)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/action/message.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      # XXX: Is this really needed? Should we contribute this back to Vagrant's core?
+      class Message
+        def initialize(app, env, msg_key, type = :info)
+          @app     = app
+          @msg_key = msg_key
+          @type    = type
+        end
+
+        def call(env)
+          machine = env[:machine]
+          message = I18n.t("docker_provider.messages.#{@msg_key}", name: machine.name)
+
+          env[:ui].send @type, message
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/action/share_folders.rb

@@ -0,0 +1,63 @@
+module VagrantPlugins
+	module DockerProvider
+		module Action
+			class ShareFolders
+				def initialize(app, env)
+					@app = app
+				end
+
+				def call(env)
+					@env = env
+					prepare_folders
+
+					# FIXME: Check whether the container has already been created with
+					#        different synced folders and let the user know about it
+					folders = []
+					shared_folders.each do |id, data|
+						folders << {
+							:name      => id,
+							:hostpath  => File.expand_path(data[:hostpath], @env[:root_path]),
+							:guestpath => data[:guestpath]
+						}
+					end
+					@env[:synced_folders] = folders
+
+					@app.call(env)
+				end
+
+				# This method returns an actual list of synced folders to create and their
+				# proper path.
+				def shared_folders
+					{}.tap do |result|
+						@env[:machine].config.vm.synced_folders.each do |id, data|
+							# Ignore disabled shared folders
+							next if data[:disabled]
+							# This to prevent overwriting the actual shared folders data
+							result[id] = data.dup
+						end
+					end
+				end
+
+				# Prepares the shared folders by verifying they exist and creating them
+				# if they don't.
+				def prepare_folders
+					shared_folders.each do |id, options|
+						hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+						if !hostpath.directory? && options[:create]
+							# Host path doesn't exist, so let's create it.
+							@logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+							begin
+								hostpath.mkpath
+							rescue Errno::EACCES
+								raise Vagrant::Errors::SharedFolderCreateFailed,
+									:path => hostpath.to_s
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/docker-provider/action/start.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Start
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          driver  = machine.provider.driver
+          driver.start(machine.id)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/action/stop.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class Stop
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+          driver  = machine.provider.driver
+          if driver.running?(machine.id)
+            env[:ui].info I18n.t("docker_provider.messages.stopping")
+            driver.stop(machine.id)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/config.rb

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module DockerProvider
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :image, :cmd, :ports
+
+      def initialize
+        @image = UNSET_VALUE
+        @cmd   = UNSET_VALUE
+        @ports = UNSET_VALUE
+      end
+
+      def finalize!
+        @ports = [] if @ports == UNSET_VALUE
+        @cmd   = [] if @cmd == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t("docker_provider.errors.config.image_not_set") if @image == UNSET_VALUE
+        # TODO: Detect if base image has a CMD / ENTRYPOINT set before erroring out
+        errors << I18n.t("docker_provider.errors.config.cmd_not_set")   if @cmd == UNSET_VALUE
+
+        { "docker-provider" => errors }
+      end
+    end
+  end
+end

data/lib/docker-provider/driver.rb

@@ -0,0 +1,114 @@
+require "vagrant/util/busy"
+require "vagrant/util/subprocess"
+require "vagrant/util/retryable"
+
+require 'log4r'
+require 'json'
+
+module VagrantPlugins
+  module DockerProvider
+    class Driver
+      include Vagrant::Util::Retryable
+
+      def initialize
+        @logger = Log4r::Logger.new("vagrant::docker::driver")
+      end
+
+      def create(params)
+        image   = params.fetch(:image)
+        ports   = Array(params[:ports])
+        volumes = Array(params[:volumes])
+        name    = params.fetch(:name)
+        cmd     = Array(params.fetch(:cmd))
+
+        run_cmd = %W(docker run -name #{name} -d)
+        run_cmd += ports.map { |p| ['-p', p.to_s] }
+        run_cmd += volumes.map { |v| ['-v', v.to_s] }
+        run_cmd += %W(-h #{params[:hostname]}) if params[:hostname]
+        run_cmd += [image, cmd]
+
+        retryable(tries: 10, sleep: 1) do
+          execute(*run_cmd.flatten).chomp
+        end
+      end
+
+      def state(cid)
+        case
+        when running?(cid)
+          :running
+        when created?(cid)
+          :stopped
+        else
+          :not_created
+        end
+      end
+
+      def created?(cid)
+        result = execute('docker', 'ps', '-a', '-q').to_s
+        result =~ /^#{Regexp.escape cid}$/
+      end
+
+      def running?(cid)
+        result = execute('docker', 'ps', '-q')
+        result =~ /^#{Regexp.escape cid}$/m
+      end
+
+      def start(cid)
+        unless running?(cid)
+          execute('docker', 'start', cid)
+        end
+      end
+
+      def stop(cid)
+        if running?(cid)
+          execute('docker', 'stop', cid)
+        end
+      end
+
+      def rm(cid)
+        if created?(cid)
+          execute('docker', 'rm', cid)
+        end
+      end
+
+      def inspect(cid)
+        # DISCUSS: Is there a chance that this will change?
+        @data ||= JSON.parse(execute('docker', 'inspect', cid)).first
+      end
+
+      private
+
+      def execute(*cmd, &block)
+        result = raw(*cmd, &block)
+
+        if result.exit_code != 0
+          if @interrupted
+            @logger.info("Exit code != 0, but interrupted. Ignoring.")
+          else
+            msg = result.stdout.gsub("\r\n", "\n")
+            msg << result.stderr.gsub("\r\n", "\n")
+            raise "#{cmd.inspect}\n#{msg}" #Errors::ExecuteError, :command => command.inspect
+          end
+        end
+
+        # Return the output, making sure to replace any Windows-style
+        # newlines with Unix-style.
+        result.stdout.gsub("\r\n", "\n")
+      end
+
+      def raw(*cmd, &block)
+        int_callback = lambda do
+          @interrupted = true
+          @logger.info("Interrupted.")
+        end
+
+        # Append in the options for subprocess
+        cmd << { :notify => [:stdout, :stderr] }
+
+        Vagrant::Util::Busy.busy(int_callback) do
+          Vagrant::Util::Subprocess.execute(*cmd, &block)
+        end
+      end
+    end
+  end
+end

data/lib/docker-provider/plugin.rb

@@ -0,0 +1,24 @@
+require_relative "version"
+
+require 'vagrant'
+
+I18n.load_path << File.expand_path(File.dirname(__FILE__) + '/../../locales/en.yml')
+I18n.reload!
+
+module VagrantPlugins
+  module DockerProvider
+    class Plugin < Vagrant.plugin("2")
+      name "docker-provider"
+
+      provider(:docker, parallel: true) do
+        require_relative 'provider'
+        Provider
+      end
+
+      config(:docker, :provider) do
+        require_relative 'config'
+        Config
+      end
+    end
+  end
+end

data/lib/docker-provider/provider.rb

@@ -0,0 +1,59 @@
+require_relative 'driver'
+require_relative 'action'
+
+module VagrantPlugins
+  module DockerProvider
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::provider::docker")
+        @machine = machine
+        @driver  = Driver.new
+      end
+
+      # @see Vagrant::Plugin::V2::Provider#action
+      def action(name)
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # Returns the SSH info for accessing the Container.
+      def ssh_info
+        # If the Container is not created then we cannot possibly SSH into it, so
+        # we return nil.
+        return nil if state == :not_created
+
+        network = @driver.inspect(@machine.id)['NetworkSettings']
+        ip      = network['IPAddress']
+
+        # If we were not able to identify the container's IP, we return nil
+        # here and we let Vagrant core deal with it ;)
+        return nil unless ip
+
+        {
+          :host => ip,
+          :port => @machine.config.ssh.guest_port
+        }
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created if !@machine.id || !@driver.created?(@machine.id)
+        state_id = @driver.state(@machine.id) if @machine.id && !state_id
+        state_id = :unknown if !state_id
+
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("vagrant.commands.status.#{state_id}")
+
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id ? @machine.id : "new container"
+        "Docker (#{id})"
+      end
+    end
+  end
+end