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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: a042e9a753dc5de10f2238f555c255fa725816f52432b826c51aeb356ef0c929
-  data.tar.gz: 0bee673f49e227e01f2a74b2cca37c9842779e65409bcd132864b1ff2392ea2d
+SHA1:
+  metadata.gz: a24a00feb49b30d7a76c5f0d2c6441114b961264
+  data.tar.gz: 4c24b6bd38a87d0afd01127e9266610e5efe1624
 SHA512:
-  metadata.gz: c303b979b6558672db6bf8d7056ecc80751f30d0fd1e61e3e590a10bd7c10eb4f02073343409a3501b94aca50a3f66c20fd51830526deb6edb97b6b636c23b99
-  data.tar.gz: 6c9ec2a45a4ec5399d91e3cd378af31ba9753ab079756eae4f684f41d4d431dda94d4831a2f811956169b58bdff0dd1b6716845c9a79b7dc7e4cebeb67ee9c94
+  metadata.gz: c86add037f7fcb734e8884ab2116d2b13cc5eb9cbb2cd0c976e58f7e37313bde3ba82979aa950c6313c84d3ca5b048201d0b1ab7a067a378508d897773e7eeb2
+  data.tar.gz: ea5067b1773a9ec1eb218989de89d5023723a5fdfb3bdca40aa07d417f31e36f3ebe283847ca26d39f790c96eaac3b32b4b250633fe6bfe74f39562bb1cf172b

data/Gemfile

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

data/README.md

@@ -1,10 +1,8 @@
 # chef-provisioning-docker
 
-[![Build Status](https://travis-ci.org/chef/chef-provisioning-docker.svg?branch=master)](https://travis-ci.org/chef/chef-provisioning-docker) [![Gem Version](https://badge.fury.io/rb/chef-provisioning-docker.svg)](http://badge.fury.io/rb/chef-provisioning-docker)
-
 How to use:
 
-First you need to ensure that Docker is running. This can be done on a Linux host using Docker's installers or on OSX using boot2docker. Once you have that, you can install the dependencies with Bundler and then use the Docker like the following:
+First you need to ensure that Docker is running. This can be done on a Linux host using Docker's installers or on OSX using boot2docker. Once you have that, you can install the dependencies with Bundler and then use the Docker  like the following:
 
 ```
 CHEF_DRIVER=docker bundle exec chef-client -z docker_ubuntu_image.rb
@@ -18,66 +16,58 @@ 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'
-
-  machine_options(
-    docker_options: {
-      base_image: {
-        name: 'ubuntu',
-        repository: 'ubuntu',
-        tag: '14.04'
-        },
-        :command => '/usr/sbin/sshd -p 8022 -D',
-
-        #ENV (Environment Variables)
-        #Set any env var in the container by using one or more -e flags, even overriding those already defined by the developer with a Dockerfile ENV
-        :env => {
-           "deep" => 'purple',
-           "led" => 'zeppelin'
-        },
-
-        # Ports can be one of two forms:
-        # src_port (string or integer) is a pass-through, i.e 8022 or "9933"
-        # src:dst (string) is a map from src to dst, i.e "8022:8023" maps 8022 externally to 8023 in the container
-
-        # Example (multiple):
-        :ports => [8022, "8023:9000", "9500"],
-
-        # Examples (single):
-        :ports => 1234,
-        :ports => "2345:6789",
-
-        # Volumes can be one of three forms:
-        # src_volume (string) is volume to add to container, i.e. creates new volume inside container at "/tmp"
-        # src:dst (string) mounts host's directory src to container's dst, i.e "/tmp:/tmp1" mounts host's directory /tmp to container's /tmp1
-        # src:dst:mode (string) mounts host's directory src to container's dst with the specified mount option, i.e "/:/rootfs:ro" mounts read-only host's root (/) folder to container's /rootfs
-        # See more details on Docker volumes at https://github.com/docker/docker/blob/master/docs/sources/userguide/dockervolumes.md .
-
-        # Example (single):
-        :volumes => "/tmp",
-
-        # Example (multiple):
-        :volumes => ["/tmp:/tmp", "/:/rootfs:ro"],
-
-        # if you need to keep stdin open (i.e docker run -i)
-        # :keep_stdin_open => true
+    recipe 'openssh::default'
+
+    machine_options :docker_options => {
+      :base_image => {
+          :name => 'ubuntu',
+          :repository => 'ubuntu',
+          :tag => '14.04'
+      },
+      :command => '/usr/sbin/sshd -p 8022 -D',
 
+      #ENV (Environment Variables)
+      #Set any env var in the container by using one or more -e flags, even overriding those already defined by the developer with a Dockerfile ENV
+      :env => {
+         "deep" => 'purple',
+         "led" => 'zeppelin'
       },
-      # optional, default timeout is 600
-      docker_connection: {
-       :read_timeout => 1000,
-      }
-  )
 
+      # Ports can be one of two forms:
+      # src_port (string or integer) is a pass-through, i.e 8022 or "9933"
+      # src:dst (string) is a map from src to dst, i.e "8022:8023" maps 8022 externally to 8023 in the container
+
+      # Example (multiple):
+      :ports => [8022, "8023:9000", "9500"],
+
+      # Examples (single):
+      :ports => 1234,
+      :ports => "2345:6789",
+
+      # Volumes can be one of three forms:
+      # src_volume (string) is volume to add to container, i.e. creates new volume inside container at "/tmp"
+      # src:dst (string) mounts host's directory src to container's dst, i.e "/tmp:/tmp1" mounts host's directory /tmp to container's /tmp1
+      # src:dst:mode (string) mounts host's directory src to container's dst with the specified mount option, i.e "/:/rootfs:ro" mounts read-only host's root (/) folder to container's /rootfs
+      # See more details on Docker volumes at https://github.com/docker/docker/blob/master/docs/sources/userguide/dockervolumes.md .
+
+      # Example (single):
+      :volumes => "/tmp",
+
+      # Example (multiple):
+      :volumes => ["/tmp:/tmp", "/:/rootfs:ro"],
+
+      # if you need to keep stdin open (i.e docker run -i)
+      # :keep_stdin_open => true
+
+    }
 end
 ```
 
 ## Machine images
 
-This supports the new machine image paradigm; with Docker you can build a base image, save that and use it to create a new container. Here is an example of this:
+This  supports the new machine image paradigm; with Docker you can build a base image, save that and use it to create a new container. Here is an example of this:
 
 ```ruby
 require 'chef/provisioning/docker_driver'
@@ -85,27 +75,26 @@ require 'chef/provisioning/docker_driver'
 machine_image 'ssh_server' do
   recipe 'openssh'
 
-  machine_options(
-    :docker_options => {
+  machine_options :docker_options => {
       :base_image => {
           :name => 'ubuntu',
           :repository => 'ubuntu',
           :tag => '14.04'
       }
-    }
-  )
+  }
 end
 
 machine 'ssh00' do
   from_image 'ssh_server'
 
-  machine_options(
-    :docker_options => {
+  machine_options :docker_options => {
       :command => '/usr/sbin/sshd -D -o UsePAM=no -o UsePrivilegeSeparation=no -o PidFile=/tmp/sshd.pid',
       :ports => [22]
-    }
-  )
+  }
 end
 ```
 
-This will create a docker container based on Ubuntu 14.04 and then execute the openssh recipe and run the /usr/sbin/sshd command as the container's run command.
+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

@@ -9,12 +9,12 @@ Gem::Specification.new do |s|
   s.summary = 'Provisioner for creating Docker containers in Chef Provisioning.'
   s.description = s.summary
   s.author = 'Tom Duffield'
-  s.email = 'tom@chef.io'
-  s.homepage = 'https://github.com/chef/chef-provisioning-docker'
+  s.email = 'tom@getchef.com'
+  s.homepage = 'https://github.com/opscode/chef-provisioning-docker'
 
   s.add_dependency 'chef'
-  s.add_dependency 'chef-provisioning', '>= 2.0', '< 3.0'
-  s.add_dependency 'docker-api', '~> 1.26', '>= 1.26.2'
+  s.add_dependency 'chef-provisioning', '~> 1.0'
+  s.add_dependency 'docker-api', '~> 1.25'
   s.add_dependency 'minitar'
   s.add_dependency 'sys-proctable'
 

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

@@ -1,5 +1,4 @@
 require 'chef/provisioning/machine/unix_machine'
-require 'chef/provisioning/docker_driver/docker_run_options'
 
 class Chef
 module Provisioning
@@ -10,214 +9,29 @@ 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, connection, command = nil)
+    def initialize(machine_spec, transport, convergence_strategy, 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)
-      # 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" ],
+      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']
       )
-      # 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
+      machine_spec.reference['image_id'] = image.id
 
-      # 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)
+      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
-        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
+        transport.container = container
       end
-
-      image.id
+      machine_spec.save(action_handler)
     end
   end
 end

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

@@ -1,6 +1,5 @@
 require 'chef/provisioning/transport'
 require 'chef/provisioning/transport/ssh'
-require 'chef/provisioning/docker_driver/chef_zero_http_proxy'
 require 'docker'
 require 'archive/tar/minitar'
 require 'shellwords'
@@ -22,12 +21,11 @@ module DockerDriver
     attr_reader :config
     attr_accessor :container
 
-    def execute(command, timeout: nil, keep_stdin_open: nil, tty: nil, detached: nil, **options)
+    def execute(command, options={})
       opts = {}
-      opts[:tty] = tty unless tty.nil?
-      opts[:detached] = detached unless detached.nil?
-      opts[:stdin] = keep_stdin_open unless keep_stdin_open.nil?
-      opts[:wait] = timeout unless timeout.nil?
+      if options[:keep_stdin_open]
+        opts[:stdin] = true
+      end
 
       command = Shellwords.split(command) if command.is_a?(String)
       Chef::Log.debug("execute #{command.inspect} on container #{container.id} with options #{opts}'")
@@ -81,7 +79,7 @@ module DockerDriver
     end
 
     def download_file(path, local_path)
-      file = File.open(local_path, 'wb')
+      file = File.open(local_path, 'w')
       begin
         file.write(read_file(path))
         file.close
@@ -91,7 +89,7 @@ module DockerDriver
     end
 
     def upload_file(local_path, path)
-      write_file(path, IO.read(local_path, mode: "rb"))
+      write_file(path, IO.read(local_path))
     end
 
     def make_url_available_to_remote(local_url)
@@ -117,35 +115,16 @@ module DockerDriver
             Chef::Log.debug("Session loop completed normally")
           end
         else
-          # We are the host. Find the docker machine's gateway (us) and talk to that;
-          # and set up a little proxy that will forward the container's requests to
-          # chef-zero
-          result = execute('ip route list', :read_only => true)
-
-          Chef::Log.debug("IP route: #{result.stdout}")
-
-          if result.stdout =~ /default via (\S+)/
-
-            old_uri = uri.dup
-
-            uri.host = ENV["PROXY_HOST_OVERRIDE"] ?  ENV["PROXY_HOST_OVERRIDE"] : $1
-
-            if !@proxy_thread
-              # Listen to docker instances only, and forward to localhost
-              @proxy_thread = Thread.new do
-                begin
-                  Chef::Log.debug("Starting proxy thread: #{old_uri.host}:#{old_uri.port} <--> #{uri.host}:#{uri.port}")
-                  ChefZeroHttpProxy.new(uri.host, uri.port, old_uri.host, old_uri.port).run
-                rescue
-                  Chef::Log.error("Proxy thread unable to start: #{$!}")
-                end
-              end
-            end
-          else
-            raise "Cannot forward port: ip route ls did not show default in expected format.\nSTDOUT: #{result.stdout}"
-          end
-
+          # We are the host. The docker machine was run with --net=host, so it
+          # will be able to talk to us automatically.
         end
+      else
+        old_uri = uri.dup
+        # Find out our external network address of the URL and report it
+        # to the container in case it has no DNS (often the case).
+        uri.scheme = 'http' if 'chefzero' == uri.scheme && uri.host == 'localhost'
+        uri.host = Socket.getaddrinfo(uri.host, uri.scheme, nil, :STREAM)[0][3]
+        Chef::Log.debug("Looked up IP address of #{old_uri} and modified URL to point at it: #{uri}")
       end
 
       uri.to_s
@@ -161,6 +140,8 @@ module DockerDriver
     def available?
     end
 
+    private
+
     def is_local_machine(host)
       local_addrs = Socket.ip_address_list
       host_addrs = Addrinfo.getaddrinfo(host, nil)
@@ -171,7 +152,7 @@ module DockerDriver
       end
     end
 
-    def docker_toolkit_transport(connection_url=nil)
+    def docker_toolkit_transport
       if !defined?(@docker_toolkit_transport)
         # Figure out which docker-machine this container is in
         begin
@@ -181,21 +162,18 @@ module DockerDriver
           @docker_toolkit_transport = nil
           return
         end
-
-        connection_url ||= container.connection.url
-
         Chef::Log.debug("Found docker machines:")
         docker_machine = nil
         docker_machines.lines.each do |line|
           machine_name, machine_url = line.chomp.split(',', 2)
           Chef::Log.debug("- #{machine_name} at URL #{machine_url.inspect}")
-          if machine_url == connection_url
-            Chef::Log.debug("Docker machine #{machine_name} at URL #{machine_url} matches the container's URL #{connection_url}! Will use it for port forwarding.")
+          if machine_url == container.connection.url
+            Chef::Log.debug("Docker machine #{machine_name} at URL #{machine_url} matches the container's URL #{container.connection.url}! Will use it for port forwarding.")
             docker_machine = machine_name
           end
         end
         if !docker_machine
-          Chef::Log.debug("Docker Toolkit is installed, but no Docker machine's URL matches #{connection_url.inspect}. Assuming docker must be installed as well ...")
+          Chef::Log.debug("Docker Toolkit is installed, but no Docker machine's URL matches #{container.connection.url.inspect}. Assuming docker must be installed as well ...")
           @docker_toolkit_transport = nil
           return
         end