chef-provisioning-docker 0.7 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e6789da274574121591c374a64e0d9da7b53092
-  data.tar.gz: eaf4c266978efe1a32247ce4a21f25daf77e1a6d
+  metadata.gz: eb7082e943ebcd274d30997976c1049a8eda063c
+  data.tar.gz: e453939b728683c8d9c0a74a313413a83496ec08
 SHA512:
-  metadata.gz: 0ae43fca9bbb00973288ae92d1386802fc97403ce5e8f85dd5002e421f01026a9509247232a345810e94bdb64e40aa0cd28628dee71eea00e93e1a5f2f73a133
-  data.tar.gz: 2e4533eee5d21ab3c049be12494c279333906fc9c6364de16d965174c22b3f71f0295f5be0aa9ed027324ca2f944770ee1d3d69bbf346075b6a4173d4ef6e135
+  metadata.gz: f4852d7f066c734ecf52dc2cbe2b2121f40327d82078503c1ef98ac2ed3e2565a43c33e916fac11ac8fdaa5c726270b7c1bd805355ba8120d734e8e9d6282f40
+  data.tar.gz: c6c7f6e92b01b9451fafb5f46db02b28f92944394aab21cc08f556d694e481f874ad95692e31a84cba4d14d0dc4756dad52036288b2955c0b645191d3661454f

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+gemfile
+gemspec
+
+gem 'chef-provisioning', :git => 'https://github.com/opscode/chef-provisioning.git', :branch => 'master'

data/README.md

@@ -72,8 +72,8 @@ This  supports the new machine image paradigm; with Docker you can build a base
 ```ruby
 require 'chef/provisioning/docker_driver'
 
-machine_image 'web_server' do
-  recipe 'apache'
+machine_image 'ssh_server' do
+  recipe 'openssh'
 
   machine_options :docker_options => {
       :base_image => {
@@ -84,11 +84,12 @@ machine_image 'web_server' do
   }
 end
 
-machine 'web00' do
-  from_image 'web_server'
+machine 'ssh00' do
+  from_image 'ssh_server'
 
   machine_options :docker_options => {
-      :command => '/usr/sbin/httpd'
+      :command => '/usr/sbin/sshd -D -o UsePAM=no -o UsePrivilegeSeparation=no -o PidFile=/tmp/sshd.pid',
+      :ports => [22]
   }
 end
 ```

data/Rakefile

@@ -4,3 +4,12 @@ require 'bundler/gem_tasks'
 task :spec do
   require File.expand_path('spec/run')
 end
+
+require "github_changelog_generator/task"
+
+GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+  config.future_release = Chef::Provisioning::DockerDriver::VERSION
+  config.enhancement_labels = "enhancement,Enhancement,New Feature".split(",")
+  config.bug_labels = "bug,Bug,Improvement,Upstream Bug".split(",")
+  config.exclude_labels = "duplicate,question,invalid,wontfix,no_changelog,Exclude From Changelog,Question".split(",")
+end

data/chef-provisioning-docker.gemspec

@@ -0,0 +1,31 @@
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'chef/provisioning/docker_driver/version'
+
+Gem::Specification.new do |s|
+  s.name = 'chef-provisioning-docker'
+  s.version = Chef::Provisioning::DockerDriver::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.extra_rdoc_files = ['README.md', 'LICENSE' ]
+  s.summary = 'Provisioner for creating Docker containers in Chef Provisioning.'
+  s.description = s.summary
+  s.author = 'Tom Duffield'
+  s.email = 'tom@getchef.com'
+  s.homepage = 'https://github.com/opscode/chef-provisioning-docker'
+
+  s.add_dependency 'chef'
+  s.add_dependency 'chef-provisioning', '~> 1.0'
+  s.add_dependency 'docker-api'
+  s.add_dependency 'minitar'
+  s.add_dependency 'sys-proctable'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'github_changelog_generator'
+
+  s.bindir       = "bin"
+  s.executables  = %w( )
+
+  s.require_path = 'lib'
+  s.files = %w(Gemfile Rakefile LICENSE README.md) + Dir.glob("*.gemspec") +
+      Dir.glob("{distro,lib,tasks,spec}/**/*", File::FNM_DOTMATCH).reject {|f| File.directory?(f) }
+end

data/lib/chef/provisioning/docker_driver/docker_container_machine.rb

@@ -9,29 +9,30 @@ module DockerDriver
     # Options is expected to contain the optional keys
     #   :command => the final command to execute
     #   :ports => a list of port numbers to listen on
-    def initialize(machine_spec, transport, convergence_strategy, opts = {})
+    def initialize(machine_spec, transport, convergence_strategy, command = nil)
       super(machine_spec, transport, convergence_strategy)
-      @env = opts[:env]
-      @command = opts[:command]
-      @ports = opts[:ports]
-      @volumes = opts[:volumes]
-      @keep_stdin_open = opts[:keep_stdin_open]
-      @container_name = machine_spec.location['container_name']
+      @command = command
       @transport = transport
     end
 
-    def execute_always(command, options = {})
-      transport.execute(command, { :read_only => true }.merge(options))
-    end
-
     def converge(action_handler)
       super action_handler
-      if @command
-        Chef::Log.debug("DockerContainerMachine converge complete, executing #{@command} in #{@container_name}")
-        @transport.execute(@command, :env => @env ,:detached => true, :read_only => true, :ports => @ports, :volumes => @volumes, :keep_stdin_open => @keep_stdin_open)
+      Chef::Log.debug("DockerContainerMachine converge complete, executing #{@command} in #{@container_name}")
+      image = transport.container.commit(
+        'repo' => 'chef',
+        'tag' => machine_spec.reference['container_name']
+      )
+      machine_spec.reference['image_id'] = image.id
+
+      if @command && transport.container.info['Config']['Cmd'].join(' ') != @command
+        transport.container.delete(:force => true)
+        container = image.run(Shellwords.split(@command))
+        container.rename(machine_spec.reference['container_name'])
+        machine_spec.reference['container_id'] = container.id
+        transport.container = container
       end
+      machine_spec.save(action_handler)
     end
-
   end
 end
 end

data/lib/chef/provisioning/docker_driver/docker_transport.rb

@@ -12,117 +12,38 @@ class Chef
 module Provisioning
 module DockerDriver
   class DockerTransport < Chef::Provisioning::Transport
-    def initialize(container_name, base_image_name, credentials, connection, tunnel_transport = nil)
-      @repository_name = 'chef'
-      @container_name = container_name
-      @image = Docker::Image.get(base_image_name, connection)
-      @credentials = credentials
-      @connection = connection
-      @tunnel_transport = tunnel_transport
+    def initialize(container, config)
+      @container = container
+      @config = config
     end
 
-    include Chef::Mixin::ShellOut
+    attr_reader :config
+    attr_accessor :container
 
-    attr_reader :container_name
-    attr_reader :repository_name
-    attr_reader :image
-    attr_reader :credentials
-    attr_reader :connection
-    attr_reader :tunnel_transport
-
-    # Execute the specified command inside the container, returns a Mixlib::Shellout object
-    # Options contains the optional keys:
-    #   :env => env vars
-    #   :read_only => Do not commit this execute operation, just execute it
-    #   :ports => ports to listen on (-p command-line options)
-    #   :detached => true/false, execute this command in detached mode (for final program to run)
     def execute(command, options={})
       Chef::Log.debug("execute '#{command}' with options #{options}")
 
-      begin
-        connection.post("/containers/#{container_name}/stop?t=0", '')
-        Chef::Log.debug("stopped /containers/#{container_name}")
-      rescue Excon::Errors::NotModified
-        Chef::Log.debug("Already stopped #{container_name}")
-      rescue Docker::Error::NotFoundError
-      end
-
-      begin
-        # Delete the container if it exists and is dormant
-        connection.delete("/containers/#{container_name}?v=true&force=true")
-        Chef::Log.debug("deleted /containers/#{container_name}")
-      rescue Docker::Error::NotFoundError
+      opts = {}
+      if options[:keep_stdin_open]
+        opts[:stdin] = true
       end
 
       command = Shellwords.split(command) if command.is_a?(String)
-
-      # TODO shell_out has no way to live stream stderr???
-      live_stream = nil
-      live_stream = STDOUT if options[:stream]
-      live_stream = options[:stream_stdout] if options[:stream_stdout]
-
-      args = ['docker', 'run', '--name', container_name]
-
-      if options[:env]
-        options[:env].each do |key, value|
-          args << '-e'
-          args << "#{key}=#{value}"
-        end
-      end
-
-      if options[:detached]
-        args << '--detach'
-      end
-
-      if options[:ports]
-        options[:ports].each do |portnum|
-          args << '-p'
-          args << "#{portnum}"
-        end
-      end
-
-      if options[:volumes]
-        options[:volumes].each do |volume|
-          args << '-v'
-          args << "#{volume}"
+      response = container.exec(command, opts) do |stream, chunk|
+        case stream
+        when :stdout
+          stream_chunk(options, chunk, nil)
+        when :stderr
+          stream_chunk(options, nil, chunk)
         end
       end
 
-      if options[:keep_stdin_open]
-        args << '-i'
-      end
-
-      args << @image.id
-      args += command
+      Chef::Log.debug("Execute complete: status #{response[2]}")
 
-      cmdstr = Shellwords.join(args)
-      Chef::Log.debug("Executing #{cmdstr}")
-
-      # Remove this when https://github.com/opscode/chef/pull/2100 gets merged and released
-      # nullify live_stream because at the moment EventsOutputStream doesn't understand <<, which
-      # ShellOut uses
-      live_stream = nil unless live_stream.respond_to? :<<
-
-      cmd = Mixlib::ShellOut.new(cmdstr, :live_stream => live_stream, :timeout => execute_timeout(options))
-
-      cmd.run_command
-
-      unless options[:read_only]
-        Chef::Log.debug("Committing #{container_name} as #{repository_name}:#{container_name}")
-        container = Docker::Container.get(container_name)
-        @image = container.commit('repo' => repository_name, 'tag' => container_name)
-      end
-
-      Chef::Log.debug("Execute complete: status #{cmd.exitstatus}")
-
-      cmd
+      DockerResult.new(command.join(' '), options, response[0].join, response[1].join, response[2])
     end
 
     def read_file(path)
-      container = Docker::Container.create({
-        'Image' => @image.id,
-        'Cmd' => %w(echo true)
-      }, connection)
       begin
         tarfile = ''
         # NOTE: this would be more efficient if we made it a stream and passed that to Minitar
@@ -135,8 +56,6 @@ module DockerDriver
         else
           raise
         end
-      ensure
-        container.delete
       end
 
       output = ''
@@ -153,12 +72,7 @@ module DockerDriver
     end
 
     def write_file(path, content)
-      # TODO hate tempfiles.  Find an in memory way.
-      Tempfile.open('metal_docker_write_file') do |file|
-        file.write(content)
-        file.close
-        @image = @image.insert_local('localPath' => file.path, 'outputPath' => path, 't' => "#{repository_name}:#{container_name}")
-      end
+      File.open(container_path(path), 'w') { |file| file.write(content) }
     end
 
     def download_file(path, local_path)
@@ -173,7 +87,7 @@ module DockerDriver
     end
 
     def upload_file(local_path, path)
-      @image = @image.insert_local('localPath' => local_path, 'outputPath' => path, 't' => "#{repository_name}:#{container_name}")
+      FileUtils.cp(local_path, container_path(path))
     end
 
     def make_url_available_to_remote(url)
@@ -236,40 +150,8 @@ module DockerDriver
       end
     end
 
-    # Copy of container.attach with timeout support and pipeline
-    def attach_with_timeout(container, read_timeout, options = {}, &block)
-      opts = {
-        :stream => true, :stdout => true, :stderr => true
-      }.merge(options)
-      # Creates list to store stdout and stderr messages
-      msgs = Docker::Messages.new
-      connection.start_request(
-        :post,
-        "/containers/#{container.id}/attach",
-        opts,
-        :response_block => attach_for(block, msgs),
-        :read_timeout => read_timeout,
-        :pipeline => true,
-        :persistent => true
-      )
-    end
-
-    # Method that takes chunks and calls the attached block for each mux'd message
-    def attach_for(block, msg_stack)
-      messages = Docker::Messages.new
-      lambda do |c,r,t|
-        messages = messages.decipher_messages(c)
-        msg_stack.append(messages)
-
-        unless block.nil?
-          messages.stdout_messages.each do |msg|
-            block.call(:stdout, msg)
-          end
-          messages.stderr_messages.each do |msg|
-            block.call(:stderr, msg)
-          end
-        end
-      end
+    def container_path(path)
+      File.join('proc', container.info['State']['Pid'].to_s, 'root', path)
     end
 
     class DockerResult
@@ -300,26 +182,3 @@ module DockerDriver
 end
 end
 end
-
-class Docker::Connection
-  def start_request(method, *args, &block)
-    request = compile_request_params(method, *args, &block)
-    if Docker.logger
-      Docker.logger.debug(
-        [request[:method], request[:path], request[:query], request[:body]]
-      )
-    end
-    excon = resource
-    [ excon, excon.request(request) ]
-  rescue Excon::Errors::BadRequest => ex
-    raise ClientError, ex.message
-  rescue Excon::Errors::Unauthorized => ex
-    raise UnauthorizedError, ex.message
-  rescue Excon::Errors::NotFound => ex
-    raise NotFoundError, ex.message
-  rescue Excon::Errors::InternalServerError => ex
-    raise ServerError, ex.message
-  rescue Excon::Errors::Timeout => ex
-    raise TimeoutError, ex.message
-  end
-end

data/lib/chef/provisioning/docker_driver/driver.rb

@@ -70,66 +70,116 @@ module DockerDriver
       end
     end
 
-
     def allocate_machine(action_handler, machine_spec, machine_options)
+      machine_spec.from_image = from_image_from_action_handler(
+        action_handler,
+        machine_spec
+      )
+      docker_options = machine_options[:docker_options]
+      container_id = nil
+      image_id = machine_options[:image_id]
+      if machine_spec.reference
+        container_name = machine_spec.reference['container_name']
+        container_id = machine_spec.reference['container_id']
+        image_id ||= machine_spec.reference['image_id']
+        docker_options ||= machine_spec.reference['docker_options']
+      end
 
-      container_name = machine_spec.name
+      container_name ||= machine_spec.name
       machine_spec.reference = {
-          'driver_url' => driver_url,
-          'driver_version' => Chef::Provisioning::DockerDriver::VERSION,
-          'allocated_at' => Time.now.utc.to_s,
-          'host_node' => action_handler.host_node,
-          'container_name' => container_name,
-          'image_id' => machine_options[:image_id],
-          'docker_options' => machine_options[:docker_options]
+        'driver_url' => driver_url,
+        'driver_version' => Chef::Provisioning::DockerDriver::VERSION,
+        'allocated_at' => Time.now.utc.to_s,
+        'host_node' => action_handler.host_node,
+        'container_name' => container_name,
+        'image_id' => image_id,
+        'docker_options' => docker_options,
+        'container_id' => container_id
       }
+      build_container(machine_spec, docker_options)
     end
 
     def ready_machine(action_handler, machine_spec, machine_options)
-      base_image_name = build_container(machine_spec, machine_options)
-      start_machine(action_handler, machine_spec, machine_options, base_image_name)
-      machine_for(machine_spec, machine_options, base_image_name)
+      start_machine(action_handler, machine_spec, machine_options)
+      machine_for(machine_spec, machine_options)
     end
 
-    def build_container(machine_spec, machine_options)
-      docker_options = machine_options[:docker_options]
+    def build_container(machine_spec, docker_options)
+      container = container_for(machine_spec)
+      return container unless container.nil?
+
+      image = find_image(machine_spec) ||
+        build_image(machine_spec, docker_options)
+
+      args = [
+        'docker',
+        'run',
+        '--name',
+        machine_spec.reference['container_name'],
+        '--detach'
+      ]
+
+      if docker_options[:keep_stdin_open]
+        args << '-i'
+      end
+
+      if docker_options[:env]      
+        docker_options[:env].each do |key, value|
+          args << '-e'
+          args << "#{key}=#{value}"
+        end
+      end
+
+      if docker_options[:ports]
+        docker_options[:ports].each do |portnum|
+          args << '-p'
+          args << "#{portnum}"
+        end
+      end
 
-      base_image = docker_options[:base_image]
-      if !base_image
-        Chef::Log.debug("No base images specified in docker options.")
-        base_image = base_image_for(machine_spec)
+      if docker_options[:volumes]
+        docker_options[:volumes].each do |volume|
+          args << '-v'
+          args << "#{volume}"
+        end
       end
+
+      args << image.id
+      args += Shellwords.split("/bin/sh -c 'while true;do sleep 1; done'")
+
+      cmdstr = Shellwords.join(args)
+      Chef::Log.debug("Executing #{cmdstr}")
+
+      cmd = Mixlib::ShellOut.new(cmdstr)
+      cmd.run_command
+
+      container = Docker::Container.get(machine_spec.reference['container_name'])
+
+      Chef::Log.debug("Container id: #{container.id}")
+      machine_spec.reference['container_id'] = container.id
+      container
+    end
+
+    def build_image(machine_spec, docker_options)
+      base_image = docker_options[:base_image] || base_image_for(machine_spec)
       source_name = base_image[:name]
       source_repository = base_image[:repository]
       source_tag = base_image[:tag]
 
-      # Don't do this if we're loading from an image
-      if docker_options[:from_image]
-        "#{source_repository}:#{source_tag}"
-      else
-        target_repository = 'chef'
-        target_tag = machine_spec.name
-
-        # check if target image exists, if not try to look up for source image.
-        image = find_image(target_repository, target_tag) || find_image(source_repository, source_tag)
-
-        # kick off image creation
-        if image == nil
-          Chef::Log.debug("No matching images for #{target_repository}:#{target_tag}, creating!")
-          image = Docker::Image.create('fromImage' => source_name,
-                                       'repo' => source_repository ,
-                                       'tag' => source_tag)
-          Chef::Log.debug("Allocated #{image}")
-          image.tag('repo' => 'chef', 'tag' => target_tag)
-          Chef::Log.debug("Tagged image #{image}")
-        elsif not image.info['RepoTags'].include? "#{target_repository}:#{target_tag}"
-          # if `find_image(source_repository, source_tag)` returned result, assign target tag to it to be able
-          # find it in `start_machine`.
-          image.tag('repo' => target_repository, 'tag' => target_tag)
-        end
+      target_tag = machine_spec.reference['container_name']
 
-        "#{target_repository}:#{target_tag}"
-      end
+      image = Docker::Image.create(
+        'fromImage' => source_name,
+        'repo' => source_repository,
+        'tag' => source_tag
+      )
+      
+      Chef::Log.debug("Allocated #{image}")
+      image.tag('repo' => 'chef', 'tag' => target_tag)
+      Chef::Log.debug("Tagged image #{image}")
+
+      machine_spec.reference['image_id'] = image.id
+      image
     end
 
     def allocate_image(action_handler, image_spec, image_options, machine_spec, machine_options)
@@ -163,101 +213,112 @@ module DockerDriver
 
     # Connect to machine without acquiring it
     def connect_to_machine(machine_spec, machine_options)
-      Chef::Log.debug('Connect to machine!')
+      Chef::Log.debug('Connect to machine')
+      machine_for(machine_spec, machine_options)
     end
 
     def destroy_machine(action_handler, machine_spec, machine_options)
-      container_name = machine_spec.location['container_name']
-      Chef::Log.debug("Destroying container: #{container_name}")
-      container = Docker::Container.get(container_name, @connection)
-
-      begin
-        Chef::Log.debug("Stopping #{container_name}")
-        container.stop
-      rescue Excon::Errors::NotModified
-        # this is okay
-        Chef::Log.debug('Already stopped!')
+      container = container_for(machine_spec)
+      if container
+        Chef::Log.debug("Destroying container: #{container.id}")
+        container.delete(:force => true)
       end
 
-      Chef::Log.debug("Removing #{container_name}")
-      container.delete
-
       if !machine_spec.attrs[:keep_image] && !machine_options[:keep_image]
-        Chef::Log.debug("Destroying image: chef:#{container_name}")
-        image = Docker::Image.get("chef:#{container_name}")
+        image = find_image(machine_spec)
+        Chef::Log.debug("Destroying image: chef:#{image.id}")
         image.delete
       end
     end
 
-    def stop_machine(action_handler, node)
-      Chef::Log.debug("Stop machine: #{node.inspect}")
+    def stop_machine(action_handler, machine_spec, machine_options)
+      container = container_for(machine_spec)
+      return if container.nil?
+
+      container.stop if container.info['State']['Running']
     end
 
-    def image_named(image_name)
-      Docker::Image.all.select {
-          |i| i.info['RepoTags'].include? image_name
-      }.first
+    def find_image(machine_spec)
+      image = nil
+
+      if machine_spec.reference['image_id']
+        begin
+          image = Docker::Image.get(machine_spec.reference['image_id'])
+        rescue Docker::Error::NotFoundError
+        end
+      end
+
+      if image.nil?
+        image_name = "chef:#{machine_spec.reference['container_name']}"
+        if machine_spec.from_image
+          base_image = base_image_for(machine_spec)
+          image_name = "#{base_image[:repository]}:#{base_image[:tag]}"
+        end
+
+        image = Docker::Image.all.select {
+            |i| i.info['RepoTags'].include? image_name
+        }.first
+
+        if machine_spec.from_image && image.nil?
+          raise "Unable to locate machine_image for #{image_name}"
+        end
+      end
+
+      machine_spec.reference['image_id'] = image.id if image
+
+      image
     end
 
-    def find_image(repository, tag)
-      Docker::Image.all.select {
-          |i| i.info['RepoTags'].include? "#{repository}:#{tag}"
-      }.first
+    def from_image_from_action_handler(action_handler, machine_spec)
+      case action_handler
+      when Chef::Provisioning::AddPrefixActionHandler
+        machines = action_handler.action_handler.provider.new_resource.machines
+        this_machine = machines.select { |m| m.name == machine_spec.name}.first
+        this_machine.from_image
+      else
+        action_handler.provider.new_resource.from_image
+      end
     end
 
     def driver_url
       "docker:#{Docker.url}"
     end
 
-    def start_machine(action_handler, machine_spec, machine_options, base_image_name)
-      # Spin up a docker instance if needed, otherwise use the existing one
-      container_name = machine_spec.location['container_name']
-
-      begin
-        Docker::Container.get(container_name, @connection)
-      rescue Docker::Error::NotFoundError
-        docker_options = machine_options[:docker_options]
-        Chef::Log.debug("Start machine for container #{container_name} using base image #{base_image_name} with options #{docker_options.inspect}")
-        image = image_named(base_image_name)
-        container = Docker::Container.create('Image' => image.id, 'name' => container_name)
-        Chef::Log.debug("Container id: #{container.id}")
-        machine_spec.location['container_id'] = container.id
+    def start_machine(action_handler, machine_spec, machine_options)
+      container = container_for(machine_spec)
+      if container && !container.info['State']['Running']
+        container.start
       end
-
     end
 
-    def machine_for(machine_spec, machine_options, base_image_name)
+    def machine_for(machine_spec, machine_options)
       Chef::Log.debug('machine_for...')
+      docker_options = machine_options[:docker_options] || Mash.from_hash(machine_spec.reference['docker_options'])
 
-      docker_options = machine_options[:docker_options]
+      container = Docker::Container.get(machine_spec.reference['container_id'], @connection)
+
+      if machine_spec.from_image
+        convergence_strategy = Chef::Provisioning::ConvergenceStrategy::NoConverge.new({}, config)
+      else
+        convergence_strategy = Chef::Provisioning::ConvergenceStrategy::InstallCached.
+          new(machine_options[:convergence_options], config)
+      end
 
-      transport = DockerTransport.new(machine_spec.location['container_name'],
-                                      base_image_name,
-                                      nil,
-                                      Docker.connection)
-
-      convergence_strategy = if docker_options[:from_image]
-                               Chef::Provisioning::ConvergenceStrategy::NoConverge.new({}, config)
-                             else
-                               convergence_strategy_for(machine_spec, machine_options)
-                             end
-
-        Chef::Provisioning::DockerDriver::DockerContainerMachine.new(
-          machine_spec,
-          transport,
-          convergence_strategy,
-          :command => docker_options[:command],
-          :env => docker_options[:env],
-          :ports => Array(docker_options[:ports]),
-          :volumes => Array(docker_options[:volumes]),
-          :keep_stdin_open => docker_options[:keep_stdin_open]
-        )
+      transport = DockerTransport.new(container, config)
+
+      Chef::Provisioning::DockerDriver::DockerContainerMachine.new(
+        machine_spec,
+        transport,
+        convergence_strategy,
+        docker_options[:command]
+      )
     end
 
-    def convergence_strategy_for(machine_spec, machine_options)
-      @unix_convergence_strategy ||= begin
-        Chef::Provisioning::ConvergenceStrategy::InstallCached.
-            new(machine_options[:convergence_options], config)
+    def container_for(machine_spec)
+      container_id = machine_spec.reference['container_id']
+      begin
+        container = Docker::Container.get(container_id, @connection) if container_id
+      rescue Docker::Error::NotFoundError
       end
     end
 

data/lib/chef/provisioning/docker_driver/version.rb

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module DockerDriver
-  VERSION = '0.7'
+  VERSION = '0.8.0'
 end
 end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-docker
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: 0.8.0
 platform: ruby
 authors:
 - Tom Duffield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-22 00:00:00.000000000 Z
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: github_changelog_generator
+  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: Provisioner for creating Docker containers in Chef Provisioning.
 email: tom@getchef.com
 executables: []
@@ -116,9 +130,11 @@ extra_rdoc_files:
 - README.md
 - LICENSE
 files:
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- chef-provisioning-docker.gemspec
 - lib/chef/provisioning/docker_driver.rb
 - lib/chef/provisioning/docker_driver/chef_zero_http_proxy.rb
 - lib/chef/provisioning/docker_driver/docker_container_machine.rb
@@ -148,9 +164,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Provisioner for creating Docker containers in Chef Provisioning.
 test_files: []
-has_rdoc: