chef-provisioning-docker 0.11.0 → 1.0.0.beta.1

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

@@ -28,10 +28,6 @@ module DockerDriver
       Driver.new(driver_url, config)
     end
 
-    def driver_url
-      "docker:#{Docker.url}"
-    end
-
     def initialize(driver_url, config)
       super
       url = Driver.connection_url(driver_url)
@@ -41,14 +37,10 @@ module DockerDriver
         # to be set for command-line utilities
         ENV['DOCKER_HOST'] = url
         Chef::Log.debug("Setting Docker URL to #{url}")
+        Docker.url = url
       end
 
-      ENV['DOCKER_HOST'] ||= url if url
-      Docker.logger = Chef::Log
-      options = Docker.options.dup || {}
-      options.merge!(read_timeout: 600)
-      options.merge!(config[:docker_connection].hash_dup) if config && config[:docker_connection]
-      @connection = Docker::Connection.new(url || Docker.url, options)
+      @connection = Docker.connection
     end
 
     def self.canonicalize_url(driver_url, config)
@@ -83,8 +75,6 @@ module DockerDriver
         action_handler,
         machine_spec
       )
-
-      # Grab options from existing machine (TODO seems wrong) and set the machine_spec to that
       docker_options = machine_options[:docker_options]
       container_id = nil
       image_id = machine_options[:image_id]
@@ -94,6 +84,7 @@ module DockerDriver
         image_id ||= machine_spec.reference['image_id']
         docker_options ||= machine_spec.reference['docker_options']
       end
+
       container_name ||= machine_spec.name
       machine_spec.reference = {
         'driver_url' => driver_url,
@@ -105,66 +96,125 @@ module DockerDriver
         'docker_options' => stringize_keys(docker_options),
         'container_id' => container_id
       }
+      build_container(machine_spec, docker_options)
     end
 
     def ready_machine(action_handler, machine_spec, machine_options)
+      start_machine(action_handler, machine_spec, machine_options)
       machine_for(machine_spec, machine_options)
     end
 
-    def start_machine(action_handler, machine_spec, machine_options)
+    def build_container(machine_spec, docker_options)
       container = container_for(machine_spec)
-      if container && !container.info['State']['Running']
-        action_handler.perform_action "start container #{machine_spec.name}" do
-          container.start!
+      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
+
+      # We create the initial container with --net host so it can access things
+      # while it converges. When the final container starts, it will have its
+      # normal network.
+      args << '--net'
+      args << 'host'
+
+      if docker_options[:env]
+        docker_options[:env].each do |key, value|
+          args << '-e'
+          args << "#{key}=#{value}"
         end
       end
-    end
 
-    # Connect to machine without acquiring it
-    def connect_to_machine(machine_spec, machine_options)
-      Chef::Log.debug('Connect to machine')
-      machine_for(machine_spec, machine_options)
-    end
+      if docker_options[:ports]
+        docker_options[:ports].each do |portnum|
+          args << '-p'
+          args << "#{portnum}"
+        end
+      end
 
-    def destroy_machine(action_handler, machine_spec, machine_options)
-      container = container_for(machine_spec)
-      if container
-        image_id = container.info['Image']
-        action_handler.perform_action "stop and destroy container #{machine_spec.name}" do
-          container.stop
-          container.delete
+      if docker_options[:volumes]
+        docker_options[:volumes].each do |volume|
+          args << '-v'
+          args << "#{volume}"
         end
       end
-    end
 
-    def stop_machine(action_handler, machine_spec, machine_options)
-      container = container_for(machine_spec)
-      if container.info['State']['Running']
-        action_handler.perform_action "stop container #{machine_spec.name}" do
-          container.stop!
+      if docker_options[:dns]
+        docker_options[:dns].each do |entry|
+          args << '--dns'
+          args << "#{entry}"
         end
       end
+
+      if docker_options[:dns_search]
+        args << '--dns-search'
+        args << "#{docker_options[:dns_search]}"
+      end
+
+      args << image.id
+      args += Shellwords.split("/bin/sh -c 'while true;do sleep 1000; 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
 
-    #
-    # Images
-    #
+    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]
 
-    def allocate_image(action_handler, image_spec, image_options, machine_spec, machine_options)
-      tag_container_image(action_handler, machine_spec, image_spec)
+      target_tag = machine_spec.reference['container_name']
+
+      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)
       # Set machine options on the image to match our newly created image
       image_spec.reference = {
         'driver_url' => driver_url,
         'driver_version' => Chef::Provisioning::DockerDriver::VERSION,
         'allocated_at' => Time.now.to_i,
-        'docker_options' => {
-          'base_image' => {
-            'name' => image_spec.name
-          }
+        :docker_options => {
+          :base_image => {
+            :name => "chef_#{image_spec.name}",
+            :repository => 'chef',
+            :tag => image_spec.name
+          },
+          :from_image => true
         }
       }
-
       # Workaround for chef/chef-provisioning-docker#37
       machine_spec.attrs[:keep_image] = true
     end
@@ -175,33 +225,66 @@ module DockerDriver
 
     # workaround for https://github.com/chef/chef-provisioning/issues/358.
     def destroy_image(action_handler, image_spec, image_options, machine_options={})
-      image = image_for(image_spec)
+      image = Docker::Image.get("chef:#{image_spec.name}")
       image.delete unless image.nil?
     end
 
-    private
+    # Connect to machine without acquiring it
+    def connect_to_machine(machine_spec, machine_options)
+      Chef::Log.debug('Connect to machine')
+      machine_for(machine_spec, machine_options)
+    end
 
-    def tag_container_image(action_handler, machine_spec, image_spec)
+    def destroy_machine(action_handler, machine_spec, machine_options)
       container = container_for(machine_spec)
-      existing_image = image_for(image_spec)
-      unless existing_image && existing_image.id == container.info['Image']
-        image = Docker::Image.get(container.info['Image'], {}, @connection)
-        action_handler.perform_action "tag image #{container.info['Image']} as chef-images/#{image_spec.name}" do
-          image.tag('repo' => image_spec.name, 'force' => true)
-        end
+      if container
+        Chef::Log.debug("Destroying container: #{container.id}")
+        container.delete(:force => true)
+      end
+
+      if !machine_spec.attrs[:keep_image] && !machine_options[:keep_image]
+        image = find_image(machine_spec)
+        Chef::Log.debug("Destroying image: chef:#{image.id}")
+        image.delete
       end
     end
 
-    def to_camel_case(name)
-      name.split('_').map { |x| x.capitalize }.join("")
+    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 to_snake_case(name)
-      # ExposedPorts -> _exposed_ports
-      name = name.gsub(/[A-Z]/) { |x| "_#{x.downcase}" }
-      # _exposed_ports -> exposed_ports
-      name = name[1..-1] if name.start_with?('_')
-      name
+    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 from_image_from_action_handler(action_handler, machine_spec)
@@ -215,11 +298,22 @@ module DockerDriver
       end
     end
 
+    def driver_url
+      "docker:#{Docker.url}"
+    end
+
+    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)
       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] || Mash.from_hash(machine_spec.reference['docker_options'])
 
-      container = container_for(machine_spec)
+      container = Docker::Container.get(machine_spec.reference['container_id'], @connection)
 
       if machine_spec.from_image
         convergence_strategy = Chef::Provisioning::ConvergenceStrategy::NoConverge.new({}, config)
@@ -234,31 +328,28 @@ module DockerDriver
         machine_spec,
         transport,
         convergence_strategy,
-        @connection,
         docker_options[:command]
       )
     end
 
     def container_for(machine_spec)
+      container_id = machine_spec.reference['container_id']
       begin
-        Docker::Container.get(machine_spec.name, {}, @connection)
+        container = Docker::Container.get(container_id, @connection) if container_id
       rescue Docker::Error::NotFoundError
       end
     end
 
-    def image_for(image_spec)
-      begin
-        Docker::Image.get(image_spec.name, {}, @connection)
-      rescue Docker::Error::NotFoundError
-      end
+    def base_image_for(machine_spec)
+      Chef::Log.debug("Looking for image #{machine_spec.from_image}")
+      image_spec = machine_spec.managed_entry_store.get!(:machine_image, machine_spec.from_image)
+      Mash.new(image_spec.reference)[:docker_options][:base_image]
     end
 
     def stringize_keys(hash)
-      if hash
-        hash.each_with_object({}) do |(k,v),hash|
-          v = stringize_keys(v) if v.is_a?(Hash)
-          hash[k.to_s] = v
-        end
+      hash.each_with_object({}) do |(k,v),hash|
+        v = stringize_keys(v) if v.is_a?(Hash)
+        hash[k.to_s] = v
       end
     end
   end

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

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module DockerDriver
-  VERSION = '0.11.0'
+  VERSION = '1.0.0.beta.1'
 end
 end
 end

data/lib/chef/provisioning/driver_init/docker.rb

@@ -1,3 +1,3 @@
 require 'chef/provisioning/docker_driver/driver'
 
-Chef::Provisioning.register_driver_class('docker', Chef::Provisioning::DockerDriver::Driver)
+ChefMetal.register_driver_class('docker', Chef::Provisioning::DockerDriver::Driver)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-docker
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 1.0.0.beta.1
 platform: ruby
 authors:
 - Tom Duffield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-12 00:00:00.000000000 Z
+date: 2016-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -28,42 +28,30 @@ dependencies:
   name: chef-provisioning
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: docker-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.26'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.26.2
+        version: '1.25'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.26'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.26.2
+        version: '1.25'
 - !ruby/object:Gem::Dependency
   name: minitar
   requirement: !ruby/object:Gem::Requirement
@@ -135,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Provisioner for creating Docker containers in Chef Provisioning.
-email: tom@chef.io
+email: tom@getchef.com
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -148,9 +136,7 @@ files:
 - 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
-- lib/chef/provisioning/docker_driver/docker_run_options.rb
 - lib/chef/provisioning/docker_driver/docker_transport.rb
 - lib/chef/provisioning/docker_driver/driver.rb
 - lib/chef/provisioning/docker_driver/version.rb
@@ -158,7 +144,7 @@ files:
 - spec/docker_support.rb
 - spec/integration/primitives_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/chef/chef-provisioning-docker
+homepage: https://github.com/opscode/chef-provisioning-docker
 licenses: []
 metadata: {}
 post_install_message: 
@@ -172,13 +158,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.5
+rubygems_version: 2.6.1
 signing_key: 
 specification_version: 4
 summary: Provisioner for creating Docker containers in Chef Provisioning.
 test_files: []
+has_rdoc: