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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a24a00feb49b30d7a76c5f0d2c6441114b961264
-  data.tar.gz: 4c24b6bd38a87d0afd01127e9266610e5efe1624
+  metadata.gz: 08110106616725e446a740a4a3a309ab9afca476
+  data.tar.gz: d35e453ec12ac3b2a2fcb33999fcb4d3014d3fc3
 SHA512:
-  metadata.gz: c86add037f7fcb734e8884ab2116d2b13cc5eb9cbb2cd0c976e58f7e37313bde3ba82979aa950c6313c84d3ca5b048201d0b1ab7a067a378508d897773e7eeb2
-  data.tar.gz: ea5067b1773a9ec1eb218989de89d5023723a5fdfb3bdca40aa07d417f31e36f3ebe283847ca26d39f790c96eaac3b32b4b250633fe6bfe74f39562bb1cf172b
+  metadata.gz: 664c9d9ff139e4f84425b2f5561053c4bf7da9fc610d280830575dcf768401a1febfc84a2c7fb4d3d3aebc1adbd3ca7d66a530a4b44488757ea49e009f13bb05
+  data.tar.gz: 81605d7138ce4f1b95a7725ec4748af023811c768bfd181676a94b9fd680b258ad01879292f0897a6fbce56d4a1f4e077f1d43d2ef0ee0318f0cd040fcf1132e

data/README.md

@@ -16,15 +16,16 @@ Using this , you can then define a machine similar to the following example:
 
 ```ruby
 require 'chef/provisioning/docker_driver'
+with_driver 'docker'
 
 machine 'wario' do
-    recipe 'openssh::default'
+  recipe 'openssh::default'
 
-    machine_options :docker_options => {
-      :base_image => {
-          :name => 'ubuntu',
-          :repository => 'ubuntu',
-          :tag => '14.04'
+  machine_options docker_options: {
+    base_image: {
+      name: 'ubuntu',
+      repository: 'ubuntu',
+      tag: '14.04'
       },
       :command => '/usr/sbin/sshd -p 8022 -D',
 
@@ -97,4 +98,3 @@ end
 This will create a docker container based on Ubuntu 14.04 and
 then execute the Apache recipe and run the /usr/sbin/httpd command
 as the container's run command.
-

data/chef-provisioning-docker.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'chef'
   s.add_dependency 'chef-provisioning', '~> 1.0'
-  s.add_dependency 'docker-api', '~> 1.25'
+  s.add_dependency 'docker-api', '~> 1.26', '>= 1.26.2'
   s.add_dependency 'minitar'
   s.add_dependency 'sys-proctable'
 

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

@@ -0,0 +1,95 @@
+require 'socket'
+require 'uri'
+
+class ChefZeroHttpProxy
+
+  def initialize(local_address, local_port, remote_address, remote_port)
+    @local_address = local_address
+    @local_port = local_port
+    @remote_address = remote_address
+    @remote_port = remote_port
+  end
+
+  def run
+    begin
+      Chef::Log.debug("Running proxy main loop on #{@local_address}:#{@local_port}!")
+
+      # Start our server to handle connections (will raise things on errors)
+      @socket = TCPServer.new @local_address, @local_port
+
+      # Handle every request in another thread
+      loop do
+        s = @socket.accept
+        Thread.new s, &method(:handle_request)
+      end
+
+    ensure
+      @socket.close if @socket
+    end
+  end
+
+  def handle_request(to_client)
+    begin
+      request_line = to_client.readline
+
+      verb = request_line[/^\w+/]
+      url = request_line[/^\w+\s+(\S+)/, 1]
+      version = request_line[/HTTP\/(1\.\d)\s*$/, 1]
+      uri = URI::parse url
+
+      # Show what got requested
+      Chef::Log.debug("[C->S]: #{verb} ->  #{url}")
+
+      querystr = if uri.query
+                   "#{uri.path}?#{uri.query}"
+                 else
+                   uri.path
+                 end
+
+      to_server = TCPSocket.new(@remote_address, @remote_port)
+
+      to_server.write("#{verb} #{querystr} HTTP/#{version}\r\n")
+
+      content_len = 0
+
+      loop do
+        line = to_client.readline
+
+        if line =~ /^Content-Length:\s+(\d+)\s*$/
+          content_len = $1.to_i
+        end
+
+        # Strip proxy headers
+        if line =~ /^proxy/i
+          next
+        elsif line.strip.empty?
+          to_server.write("Connection: close\r\n\r\n")
+
+          if content_len >= 0
+            to_server.write(to_client.read(content_len))
+            Chef::Log.debug("[C->S]: Wrote #{content_len} bytes")
+          end
+
+          break
+        else
+          to_server.write(line)
+        end
+      end
+
+      buff = ''
+      while to_server.read(8192, buff)
+        to_client.write(buff)
+      end
+
+    rescue
+      Chef::Log.error $!
+      raise
+
+    ensure
+      # Close the sockets
+      to_client.close
+      to_server.close
+    end
+  end
+
+end

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

@@ -1,4 +1,5 @@
 require 'chef/provisioning/machine/unix_machine'
+require 'chef/provisioning/docker_driver/docker_run_options'
 
 class Chef
 module Provisioning
@@ -9,29 +10,214 @@ 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, command = nil)
+    def initialize(machine_spec, transport, convergence_strategy, connection, command = nil)
       super(machine_spec, transport, convergence_strategy)
       @command = command
       @transport = transport
+      @connection = connection
+    end
+
+    def setup_convergence(action_handler)
+      # Build a converge container to converge in
+      transport.container = build_converge_container(action_handler)
+      unless transport.container.info['State']['Running']
+        action_handler.perform_action "start converge container chef-converge.#{machine_spec.name}" do
+          transport.container.start!
+        end
+      end
+      super(action_handler)
+      # Commit after convergence setup (such as the install of Chef)
+      # to break up the cost of the commit and avoid read timeouts
+      transport.container.commit
     end
 
     def converge(action_handler)
-      super action_handler
-      Chef::Log.debug("DockerContainerMachine converge complete, executing #{@command} in #{@container_name}")
-      image = transport.container.commit(
-        'repo' => 'chef',
-        'tag' => machine_spec.reference['container_name']
+      # First, grab and start the converge container if it's there ...
+      transport.container = converge_container_for(machine_spec)
+      if !transport.container
+        raise "No converge container found! Did you run `:converge` without first running `:setup`?"
+      end
+      unless transport.container.info['State']['Running']
+        action_handler.perform_action "start converge container chef-converge.#{machine_spec.name}" do
+          transport.container.start!
+        end
+      end
+
+      # Then, converge ...
+      super(action_handler)
+
+      # Save the converged image ...
+      converged_image = commit_converged_image(action_handler, machine_spec, transport.container)
+
+      # Build the new container
+      transport.container = create_container(action_handler, machine_spec, converged_image)
+
+      # Finally, start it!
+      action_handler.perform_action "start container #{machine_spec.name}" do
+        transport.container.start!
+      end
+    end
+
+    private
+
+    def container_config(action_handler, machine_spec)
+      docker_options = machine_spec.reference['docker_options'] || {}
+
+      # We're going to delete things to make it easier on ourselves, back it up
+      docker_options = docker_options.dup
+
+      # Bring in from_image
+      if machine_spec.from_image
+        docker_options['base_image'] ||= {}
+        docker_options['base_image']['name'] = machine_spec.from_image
+      end
+
+      # Respect :container_config
+      config = stringize_keys(docker_options.delete('container_config') || {})
+
+      # Respect :base_image
+      image = base_image(action_handler, docker_options.delete('base_image'))
+      config['Image'] = image if image
+
+      # Respect everything else
+      DockerRunOptions.include_command_line_options_in_container_config(config, docker_options)
+    end
+
+    # Get the converge container for this machine
+    def converge_container_for(machine_spec)
+      begin
+        Docker::Container.get("chef-converge.#{machine_spec.name}", {}, @connection)
+      rescue Docker::Error::NotFoundError
+      end
+    end
+
+    def container_for(machine_spec)
+      begin
+        Docker::Container.get(machine_spec.name, {}, @connection)
+      rescue Docker::Error::NotFoundError
+      end
+    end
+
+    # Builds a container that has the same properties as the final container,
+    # but with a couple of tweaks to allow processes to run and converge the
+    # container.
+    def build_converge_container(action_handler)
+      # If a converge container already exists, do nothing. TODO check if it's different!!!
+      converge_container = converge_container_for(machine_spec)
+      if converge_container
+        return converge_container
+      end
+
+      # Create a chef-capable container (just like the final one, but with --net=host
+      # and a command that keeps it open). Base it on the image.
+      config = container_config(action_handler, machine_spec)
+      config.merge!(
+        'name' => "chef-converge.#{machine_spec.reference['container_name']}",
+        'Cmd' => [ "/bin/sh", "-c", "while true;do sleep 1000; done" ],
       )
-      machine_spec.reference['image_id'] = image.id
+      # If we're using Docker Toolkit, we need to use host networking for the converge
+      # so we can open up the port we need. Don't force it in other cases, though.
+      if transport.is_local_machine(URI(transport.config[:chef_server_url]).host) &&
+         transport.docker_toolkit_transport(@connection.url)
+        config['HostConfig'] ||= {}
+        config['HostConfig'].merge!('NetworkMode' => 'host')
+        # These are incompatible with NetworkMode: host
+        config['HostConfig'].delete('Links')
+        config['HostConfig'].delete('ExtraHosts')
+        config.delete('NetworkSettings')
+      end
+      # Don't use any resources that need to be shared (such as exposed ports)
+      config.delete('ExposedPorts')
+
+      Chef::Log.debug("Creating converge container with config #{config} ...")
+      action_handler.perform_action "create container to converge #{machine_spec.name}" do
+        # create deletes the name :(
+        Docker::Container.create(config.dup, @connection)
+        converge_container = Docker::Container.get(config['name'], {}, @connection)
+        Chef::Log.debug("Created converge container #{converge_container.id}")
+      end
+      converge_container
+    end
+
+    # Commit the converged container to an image. Called by converge.
+    def commit_converged_image(action_handler, machine_spec, converge_container)
+      # Commit the converged container to an image
+      converged_image = nil
+      action_handler.perform_action "commit and delete converged container for #{machine_spec.name}" do
+        converged_image = converge_container.commit
+        converge_container.stop!
+        converge_container.delete
+      end
+      converged_image
+    end
+
+    # Create the final container from the converged image
+    def create_container(action_handler, machine_spec, converged_image)
+      # Check if the container already exists.
+      container = container_for(machine_spec)
+      if container
+        # If it's the same image, just return; don't stop and start.
+        if container.info['Image'] == converged_image.id
+          return container
+        else
+          # If the container exists but is based on an old image, destroy it.
+          action_handler.perform_action "stop and delete running container for #{machine_spec.name}" do
+            container.stop!
+            container.delete
+          end
+        end
+      end
 
-      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'])
+      # Create the new container
+      config = container_config(action_handler, machine_spec)
+      config.merge!(
+        'name' => machine_spec.reference['container_name'],
+        'Image' => converged_image.id
+      )
+      action_handler.perform_action "create final container for #{machine_spec.name}" do
+        container = Docker::Container.create(config, @connection)
         machine_spec.reference['container_id'] = container.id
-        transport.container = container
+        machine_spec.save(action_handler)
+      end
+      container
+    end
+
+    def stringize_keys(hash)
+      hash.each_with_object({}) do |(k,v),hash|
+        v = stringize_keys(v) if v.is_a?(Hash)
+        hash[k.to_s] = v
+      end
+    end
+
+    def base_image(action_handler, base_image_value)
+      case base_image_value
+      when Hash
+        params = base_image_value.dup
+        if !params['fromImage']
+          params['fromImage'] = params.delete('name')
+          params['fromImage'] = "#{params['fromImage']}:#{params.delete('tag')}" if params['tag']
+        end
+      when String
+        params = { 'fromImage' => base_image_value }
+      when nil
+        return nil
+      else
+        raise "Unexpected type #{base_image_value.class} for docker_options[:base_image]!"
+      end
+
+      image_name = params['fromImage']
+      repo, image_name = params['fromImage'].split('/', 2) if params['fromImage'].include?('/')
+
+      begin
+        image = Docker::Image.get(image_name, {}, @connection)
+      rescue Docker::Error::NotFoundError
+        # If it's not found, pull it.
+        action_handler.perform_action "pull #{params}" do
+          image = Docker::Image.create(params, @connection)
+        end
       end
-      machine_spec.save(action_handler)
+
+      image.id
     end
   end
 end