chef-metal-docker 0.2 → 0.4.1

data/lib/chef_metal_docker/docker_transport.rb

@@ -6,15 +6,18 @@ require 'uri'
 require 'socket'
 require 'em-proxy'
 require 'mixlib/shellout'
+require 'sys/proctable'
+require 'chef_metal_docker/chef_zero_http_proxy'
 
 module ChefMetalDocker
   class DockerTransport < ChefMetal::Transport
-    def initialize(repository_name, container_name, credentials, connection)
-      @repository_name = repository_name
+    def initialize(container_name, base_image_name, credentials, connection, tunnel_transport = nil)
+      @repository_name = 'chef'
       @container_name = container_name
-      @image = Docker::Image.get("#{repository_name}:latest", connection)
+      @image = Docker::Image.get(base_image_name, connection)
       @credentials = credentials
       @connection = connection
+      @tunnel_transport = tunnel_transport
     end
 
     include Chef::Mixin::ShellOut
@@ -24,12 +27,16 @@ module ChefMetalDocker
     attr_reader :image
     attr_reader :credentials
     attr_reader :connection
+    attr_reader :tunnel_transport
 
     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
@@ -45,15 +52,17 @@ module ChefMetalDocker
       live_stream = nil
       live_stream = STDOUT if options[:stream]
       live_stream = options[:stream_stdout] if options[:stream_stdout]
-      cmd = Mixlib::ShellOut.new(Shellwords.join(['docker', 'run', '--name', container_name, "#{repository_name}:latest" ] + command),
+      cmd = Mixlib::ShellOut.new(Shellwords.join(['docker', 'run', '--name', container_name, @image.id ] + command),
         :live_stream => live_stream, :timeout => execute_timeout(options))
+
+      Chef::Log.debug("Executing #{cmd}")
       cmd.run_command
 
 
       unless options[:read_only]
-        Chef::Log.debug("Committing #{container_name} as #{repository_name}")
+        Chef::Log.debug("Committing #{container_name} as #{repository_name}:#{container_name}")
         container = Docker::Container.get(container_name)
-        @image = container.commit('repo' => repository_name)
+        @image = container.commit('repo' => repository_name, 'tag' => container_name)
       end
 
       Chef::Log.debug("Execute complete: status #{cmd.exitstatus}")
@@ -62,7 +71,7 @@ module ChefMetalDocker
 
     def read_file(path)
       container = Docker::Container.create({
-        'Image' => "#{repository_name}:latest",
+        'Image' => @image.id,
         'Cmd' => %w(echo true)
       }, connection)
       begin
@@ -99,7 +108,7 @@ module ChefMetalDocker
       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}:latest")
+        @image = @image.insert_local('localPath' => file.path, 'outputPath' => path, 't' => "#{repository_name}:#{container_name}")
       end
     end
 
@@ -115,26 +124,38 @@ module ChefMetalDocker
     end
 
     def upload_file(local_path, path)
-      @image = @image.insert_local('localPath' => local_path, 'outputPath' => path, 't' => "#{repository_name}:latest")
+      @image = @image.insert_local('localPath' => local_path, 'outputPath' => path, 't' => "#{repository_name}:#{container_name}")
     end
 
     def make_url_available_to_remote(url)
       # The host is already open to the container.  Just find out its address and return it!
       uri = URI(url)
       host = Socket.getaddrinfo(uri.host, uri.scheme, nil, :STREAM)[0][3]
+      Chef::Log.debug("Making URL available: #{host}")
+
       if host == '127.0.0.1' || host == '[::1]'
         result = execute('ip route ls', :read_only => true)
+
+        Chef::Log.debug("IP route: #{result.stdout}")
+
         if result.stdout =~ /default via (\S+)/
-          uri.host = $1
+
+          uri.host = if using_boot2docker?
+                       # Intermediate VM does NAT, so local address should be fine here
+                       Chef::Log.debug("Using boot2docker!")
+                       IPSocket.getaddress(Socket.gethostname)
+                     else
+                       $1
+                     end
 
           if !@proxy_thread
             # Listen to docker instances only, and forward to localhost
             @proxy_thread = Thread.new do
-              Proxy.start(:host => uri.host, :port => uri.port, :debug => true) do |conn|
-                conn.server :srv, :host => host, :port => uri.port
-              end
+              Chef::Log.debug("Starting proxy thread: #{uri.host}:#{uri.port} <--> #{host}:#{uri.port}")
+              ChefZeroHttpProxy.new(uri.host, uri.port, host, uri.port).run
             end
           end
+          Chef::Log.debug("Using Chef server URL: #{uri.to_s}")
 
           return uri.to_s
         else
@@ -153,60 +174,15 @@ module ChefMetalDocker
 
     private
 
-    def old_execute
-      Chef::Log.debug("Creating #{container_name} from #{repository_name}:latest")
-      @container = Docker::Container.create({
-        'name' => container_name,
-        'Image' => "#{repository_name}:latest",
-        'Cmd' => (command.is_a?(String) ? Shellwords.shellsplit(command) : command),
-        'AttachStdout' => true,
-        'AttachStderr' => true,
-        'TTY' => false
-      }, connection)
-
-      Docker.options[:read_timeout] = read_timeout
-      begin
-        stdout = ''
-        stderr = ''
-
-        Chef::Log.debug("Attaching to #{container_name}")
-        # Capture stdout / stderr
-        excon, attach_datum = attach_with_timeout(@container, read_timeout) do |type, str|
-          puts "got something"
-          case type
-          when :stdout
-            stdout << str
-            stream_chunk(options, stdout, nil)
-          when :stderr
-            stderr << str
-            stream_chunk(options, nil, stderr)
-          else
-            raise "unexpected message type #{type}"
+    # boot2docker introduces an intermediate VM so we need to use a slightly different
+    # mechanism for getting to the running chef-zero
+    def using_boot2docker?
+      Sys::ProcTable.ps do |proc|
+        if proc.respond_to?(:cmdline)
+          if proc.send(:cmdline).to_s =~ /.*--comment boot2docker.*/
+            return true
           end
         end
-
-        begin
-          Chef::Log.debug("Starting #{container_name}")
-          # Start the container
-          @container.start
-
-          Chef::Log.debug("Grabbing exit status from #{container_name}")
-          # Capture exit code
-          exit_status = @container.wait(read_timeout)
-
-          Chef::Log.debug("Waiting for attach to complete ...")
-          wait_for_attach(excon, attach_datum)
-
-          Chef::Log.debug("Execute complete: status #{exit_status['StatusCode']}")
-          DockerResult.new(command, options, stdout, stderr, exit_status['StatusCode'])
-        rescue
-          # Make sure we close off outstanding connections if we exit the method
-          excon.reset
-          raise
-        end
-      ensure
-        Chef::Log.debug("Removing temporary read timeout")
-        Docker.options.delete(:read_timeout)
       end
     end
 

data/lib/chef_metal_docker/version.rb

@@ -1,3 +1,3 @@
 module ChefMetalDocker
-  VERSION = '0.2'
+  VERSION = '0.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal-docker
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.4.1
 platform: ruby
 authors:
 - Tom Duffield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -66,6 +66,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -102,21 +116,18 @@ extra_rdoc_files:
 - README.md
 - LICENSE
 files:
-- Rakefile
 - LICENSE
 - README.md
+- Rakefile
 - lib/chef/provider/docker_container.rb
 - lib/chef/resource/docker_container.rb
-- lib/chef_metal/provisioner_init/docker_init.rb
-- lib/chef_metal_docker/docker_provisioner.rb
+- lib/chef_metal/driver_init/docker.rb
+- lib/chef_metal_docker.rb
+- lib/chef_metal_docker/chef_zero_http_proxy.rb
+- lib/chef_metal_docker/docker_container_machine.rb
+- lib/chef_metal_docker/docker_driver.rb
 - lib/chef_metal_docker/docker_transport.rb
-- lib/chef_metal_docker/docker_unix_machine.rb
-- lib/chef_metal_docker/helpers/container/actions.rb
-- lib/chef_metal_docker/helpers/container/helpers.rb
-- lib/chef_metal_docker/helpers/container.rb
-- lib/chef_metal_docker/helpers.rb
 - lib/chef_metal_docker/version.rb
-- lib/chef_metal_docker.rb
 homepage: https://github.com/opscode/chef-metal-docker
 licenses: []
 metadata: {}
@@ -136,9 +147,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Provisioner for creating Docker containers in Chef Metal.
 test_files: []
-has_rdoc: 

data/lib/chef_metal/provisioner_init/docker_init.rb

@@ -1,4 +0,0 @@
-require 'chef_metal_docker/docker_provisioner'
-
-ChefMetal.add_registered_provisioner_class("docker",
-  ChefMetalDocker::DockerProvisioner)

data/lib/chef_metal_docker/docker_provisioner.rb

@@ -1,272 +0,0 @@
-require 'chef_metal/provisioner'
-require 'chef_metal/convergence_strategy/no_converge'
-require 'chef_metal/convergence_strategy/install_cached'
-require 'chef_metal_docker/helpers/container'
-require 'chef_metal_docker/docker_transport'
-require 'chef_metal_docker/docker_unix_machine'
-require 'chef_metal/transport/ssh'
-require 'docker'
-
-module ChefMetalDocker
-  class DockerProvisioner < ChefMetal::Provisioner
-
-    include ChefMetalDocker::Helpers::Container
-
-    def initialize(credentials = nil, connection = Docker.connection)
-      @credentials = credentials
-      @connection = connection
-    end
-
-    attr_reader :credentials
-    attr_reader :connection
-
-    # Inflate a provisioner from node information; we don't want to force the
-    # driver to figure out what the provisioner really needs, since it varies
-    # from provisioner to provisioner.
-    #
-    # ## Parameters
-    # node - node to inflate the provisioner for
-    #
-    # returns a DockerProvisioner
-    def self.inflate(node)
-      self.new
-    end
-
-    #
-    # Acquire a machine, generally by provisioning it.  Returns a Machine
-    # object pointing at the machine, allowing useful actions like setup,
-    # converge, execute, file and directory.  The Machine object will have a
-    # "node" property which must be saved to the server (if it is any
-    # different from the original node object).
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that plugs into the host.
-    # node - node object (deserialized json) representing this machine.  If
-    #        the node has a provisioner_options hash in it, these will be used
-    #        instead of options provided by the provisioner.  TODO compare and
-    #        fail if different?
-    #        node will have node['normal']['provisioner_options'] in it with any options.
-    #        It is a hash with this format:
-    #
-    #           -- provisioner_url: docker:<URL of Docker API endpoint>
-    #           -- base_image: Base image name to use, or repository_name:tag_name to use a specific tagged revision of that image
-    #           -- create_container: hash of a container to create.  If present, no image will be created, just a container.
-    #              Hash options:
-    #              - command: command to run (if unspecified or nil, will spin up the container.  If false, will not run anything and will just leave the image alone.)
-    #              - container_options: options for container create (see http://docs.docker.io/en/latest/reference/api/docker_remote_api_v1.10/#create-a-container)
-    #              - host_options: options for container start (see http://docs.docker.io/en/latest/reference/api/docker_remote_api_v1.10/#start-a-container)
-    #              - ssh_options: hash of ssh options.  Presence of hash indicates sshd is running in the container.  Net::SSH.new(ssh_options['username'], ssh_options) will be called.  Set 'sudo' to true to sudo all commands (will be detected if username != root)
-    #
-    #        node['normal']['provisioner_output'] will be populated with information
-    #        about the created machine.  For lxc, it is a hash with this
-    #        format:
-    #
-    #           -- provisioner_url: docker:<URL of Docker API endpoint>
-    #           -- container_name: docker container name
-    #           -- repository_name: docker image repository name from which container was inflated
-    #
-    def acquire_machine(action_handler, node)
-      # Set up the modified node data
-      provisioner_options = node['normal']['provisioner_options']
-      provisioner_output = node['normal']['provisioner_output'] || {
-        'provisioner_url' => "docker:", # TODO put in the Docker API endpoint
-        'repository_name' => "#{node['name']}_image", # TODO disambiguate with chef_server_url/path!
-        'container_name' => node['name'] # TODO disambiguate with chef_server_url/path!
-      }
-
-      repository_name = provisioner_output['repository_name']
-      container_name = provisioner_output['container_name']
-      base_image_name = provisioner_options['base_image']
-      raise "base_image not specified in provisioner options!" if !base_image_name
-
-      if provisioner_options['create_container']
-        create_container(action_handler, provisioner_options, provisioner_output)
-        # We don't bother waiting ... our only job is to bring it up.
-      else # We are in image build mode.  Get prepped.
-        # Tag the initial image.  We aren't going to actually DO anything yet.
-        # We will start up after we converge!
-        base_image = Docker::Image.get(base_image_name)
-        begin
-          repository_image = Docker::Image.get("#{repository_name}:latest")
-          # If the current image does NOT have the base_image as an ancestor,
-          # we are going to have to re-tag it and rebuild.
-          if repository_image.history.any? { |entry| entry['Id'] == base_image.id }
-            tag_base_image = false
-          else
-            tag_base_image = true
-          end
-        rescue Docker::Error::NotFoundError
-          tag_base_image = true
-        end
-        if tag_base_image
-          action_handler.perform_action "Tag base image #{base_image_name} as #{repository_name}" do
-            base_image.tag('repo' => repository_name, 'force' => true)
-          end
-        end
-      end
-
-      node['normal']['provisioner_output'] = provisioner_output
-
-      if provisioner_options['create_container'] && provisioner_options['create_container']['ssh_options']
-        action_handler.perform_action "wait for node to start ssh" do
-          transport = transport_for(node)
-          Timeout::timeout(5*60) do
-            while !transport.available?
-              sleep(0.5)
-            end
-          end
-        end
-      end
-
-      # Nothing else needs to happen until converge.  We already have the image we need!
-      machine_for(node)
-    end
-
-    def connect_to_machine(node)
-      machine_for(node)
-    end
-
-    def delete_machine(action_handler, node)
-      if node['normal'] && node['normal']['provisioner_output']
-        container_name = node['normal']['provisioner_output']['container_name']
-        ChefMetal.inline_resource(action_handler) do
-          docker_container container_name do
-            action [:kill, :remove]
-          end
-        end
-      end
-      convergence_strategy_for(node).cleanup_convergence(action_handler, node)
-    end
-
-    def stop_machine(action_handler, node)
-      if node['normal'] && node['normal']['provisioner_output']
-        container_name = node['normal']['provisioner_output']['container_name']
-        ChefMetal.inline_resource(action_handler) do
-          docker_container container_name do
-            action [:stop]
-          end
-        end
-      end
-    end
-
-    # This is docker-only, not Metal, at the moment.
-    # TODO this should be metal.  Find a nice interface.
-    def snapshot(action_handler, node, name=nil)
-      container_name = node['normal']['provisioner_output']['container_name']
-      ChefMetal.inline_resource(action_handler) do
-        docker_container container_name do
-          action [:commit]
-        end
-      end
-    end
-
-    # Output Docker tar format image
-    # TODO this should be metal.  Find a nice interface.
-    def save_repository(action_handler, node, path)
-      container_name = node['normal']['provisioner_output']['container_name']
-      ChefMetal.inline_resource(action_handler) do
-        docker_container container_name do
-          action [:export]
-        end
-      end
-    end
-
-    # Load Docker tar format image into Docker repository
-    def load_repository(path)
-    end
-
-    # Push an image back to Docker
-    def push_image(name)
-    end
-
-    # Pull an image from Docker
-    def pull_image(name)
-    end
-
-    private
-
-    def machine_for(node)
-      strategy = convergence_strategy_for(node)
-      ChefMetalDocker::DockerUnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
-    end
-
-    def convergence_strategy_for(node)
-      provisioner_output = node['normal']['provisioner_output']
-      provisioner_options = node['normal']['provisioner_options']
-      strategy = begin
-        options = {}
-        provisioner_options = node['normal']['provisioner_options'] || {}
-        options[:chef_client_timeout] = provisioner_options['chef_client_timeout'] if provisioner_options.has_key?('chef_client_timeout')
-        ChefMetal::ConvergenceStrategy::InstallCached.new(options)
-      end
-    end
-
-    def transport_for(node)
-      provisioner_options = node['normal']['provisioner_options']
-      provisioner_output = node['normal']['provisioner_output']
-      if provisioner_options['create_container'] && provisioner_options['create_container']['ssh_options']
-        container = Docker::Container.get(provisioner_output['container_name'])
-        ssh_options = {
-  # TODO create a user known hosts file
-  #          :user_known_hosts_file => vagrant_ssh_config['UserKnownHostsFile'],
-  #          :paranoid => true,
-          :host_key_alias => "#{container.id}.docker"
-        }.merge(provisioner_options['create_container']['ssh_options'])
-        username = ssh_options.delete(:username)
-        options = {}
-        if ssh_options[:sudo] || (!ssh_options.has_key?(:sudo) && username != 'root')
-          if ssh_options[:password]
-            options[:prefix] = "echo #{ssh_options[:password]} | sudo -S -p '' "
-          else
-            options[:prefix] = 'sudo '
-          end
-        end
-        ssh_options.delete(:sudo)
-        ip_address = container.info['NetworkSettings']['IPAddress']
-        Chef::Log.debug("Container #{provisioner_output['container_name']} address is #{ip_address}")
-        ChefMetal::Transport::SSH.new(ip_address, username, ssh_options, options)
-      else
-        ChefMetalDocker::DockerTransport.new(
-          provisioner_output['repository_name'],
-          provisioner_output['container_name'],
-          credentials,
-          connection)
-      end
-    end
-
-    def create_container(action_handler, provisioner_options, provisioner_output)
-      container_name = provisioner_output['container_name']
-
-      container_configuration = provisioner_options['create_container']['container_configuration'] || {}
-      host_configuration = provisioner_options['create_container']['host_configuration'] || {}
-      command = provisioner_options['create_container']['command']
-      raise "Must pass create_container.command if creating a container" if !command
-      command = command.split(/\s+/) if command.is_a?(String)
-      container_configuration['Cmd'] = command
-      need_to_create = false
-      begin
-        # Try to get the container; if that fails, it doesn't exist and we start it.
-        container = Docker::Container.get(container_name)
-        if !container.info['State']['Running']
-          action_handler.perform_action "Delete old, non-running container" do
-            container.delete
-          end
-          need_to_create = true
-        end
-
-      rescue Docker::Error::NotFoundError
-        need_to_create = true
-      end
-
-      if need_to_create
-        action_handler.perform_action "Create new container and run container_configuration['Cmd']" do
-          container = Docker::Container.create({
-            'name' => container_name,
-            'Image' => provisioner_options['base_image']
-          }.merge(container_configuration), connection)
-          container.start!(host_configuration)
-        end
-      end
-    end
-  end
-end