chef-metal-docker 0.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f6ac421bc65fa8a3497942dbd04d15efb23badc
-  data.tar.gz: 1b23d70778b4bbece79836bb419cb3ecd462fc19
+  metadata.gz: 423d34630e6382c7d8d9ad91597e5d34e5b7191b
+  data.tar.gz: 702af2043c4db494e3b67ed8c38bf9c94de24d45
 SHA512:
-  metadata.gz: ec3d7947e1e67187603842051249713a662ee9f800a8d4abd72fd10334a4e692c0005fd1f25c34a7121b01a5f6a5c3e5aea8f3f18416a2e8d5ccb882c943e3ce
-  data.tar.gz: a2df491bf80e944a349f256e333d6e759f2b4e2f46aab7a3ed6e7727507338a9c93dda64331ae516f50761a35b29464e70637891bb43f3dd44f8d47bb7629a72
+  metadata.gz: 149d95a39c819994ecf0cbbd7d2784f4a4b224d174d96c7a1860095340e8e554793d1de341ab5acc5be496fe41324bc79022f1b6e6ac71c2ece5c228818668b2
+  data.tar.gz: 7f4a173fde92f6a011aac0d221c2499ffeb382109d330b5e205236358a6222a1ba329eabda08d91b14a64acf6e15ddfcef9d0553ca04770624cb331b2cbdc799

data/README.md

@@ -1,3 +1,64 @@
 # chef-metal-docker
 
-This is the Docker provisioner for chef-metal.
+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 driver like the following:
+
+```  
+CHEF_DRIVER=docker bundle exec chef-client -z docker_ubuntu_image.rb
+```   
+
+This will run Chef-zero and use the description stored in docker_ubuntu_image.rb (the second example below). Note that some configuration syntax is likely to change a little bit so be sure to check the documentation. 
+
+## Machine creation
+
+Using this driver, you can then define a machine similar to the following example:
+
+```ruby   
+require 'chef_metal_docker'
+
+machine 'wario' do
+    recipe 'apache'
+    
+    machine_options :docker_options => {
+      :base_image => {
+          :name => 'ubuntu',
+          :repository => 'ubuntu',
+          :tag => '14.04'
+      },
+      :command => '/usr/sbin/httpd'
+    }
+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. 
+
+## Machine images
+
+This driver 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_metal_docker'
+
+machine_image 'web_server' do
+  recipe 'apache'
+
+  machine_options :docker_options => {
+      :base_image => {
+          :name => 'ubuntu',
+          :repository => 'ubuntu',
+          :tag => '14.04'
+      }
+  }
+end
+
+machine 'web00' do
+  from_image 'web_server'
+
+  machine_options :docker_options => {
+      :command => '/usr/sbin/httpd'
+  }
+end
+```

data/lib/chef/provider/docker_container.rb

@@ -1,127 +1,21 @@
 require 'chef/provider/lwrp_base'
-require 'chef_metal_docker/helpers/container'
 
 class Chef::Provider::DockerContainer < Chef::Provider::LWRPBase
 
-  include ChefMetalDocker::Helpers::Container
-
   def whyrun_supported?
     true
   end
 
   def load_current_resource
-    @current_resource = Chef::Resource::DockerContainer.new(new_resource)
-    wait_until_ready!
-    docker_containers.each do |ps|
-      unless container_id_matches?(ps['id'])
-        next unless container_image_matches?(ps['image'])
-        next unless container_command_matches_if_exists?(ps['command'])
-        next unless container_name_matches_if_exists?(ps['names'])
-      end
-      Chef::Log.debug('Matched docker container: ' + ps['line'].squeeze(' '))
-      @current_resource.container_name(ps['names'])
-      @current_resource.created(ps['created'])
-      @current_resource.id(ps['id'])
-      @current_resource.status(ps['status'])
-      break
-    end
-    @current_resource
-  end
-
-  action :commit do
-    if exists?
-      converge_by("create docker image based on #{current_resource.id}") do
-        commit
-      end
-    end
-  end
-
-  action :cp do
-    if exists?
-      converge_by("copy #{new_resource.source} from #{current_resource.id} to #{new_resource.desitnation}") do
-        cp
-      end
-    end
-  end
-
-  action :export do
-    if exists?
-      converge_by("export the contents of #{current_resource.id} to #{new_resource.desitniation}") do
-        export
-      end
-    end
-  end
-
-  action :kill do
-    if running?
-      converge_by("kill container #{current_resource.id}") do
-        kill
-      end
-    end
-  end
-
-  action :redeploy do
-    converge_by("redeploy container #{current_resource.id}") do
-      redeploy
-    end
-  end
-
-  action :remove do
-    if running?
-      converge_by("stop container #{current_resource.id}") do
-        stop
-      end
-    end
-    if exists?
-      converge_by("remove container #{current_resource.id}") do
-        remove
-      end
-    end
+    # Don't do this here...
   end
 
-  action :restart do
-    if exists?
-      converge_by("restart container #{current_resource.id}") do
-        restart
-      end
-    end
-  end
+  action :create do
 
-  action :run do
-    unless running?
-      if exists?
-        converge_by("container #{current_resource.id} already exists...starting") do
-          start
-        end
-      else
-        converge_by("run container #{current_resource.id}") do
-          run
-        end
-      end
-    end
   end
 
-  action :start do
-    unless running?
-      converge_by("start container #{current_resource.id}") do
-        start
-      end
-    end
-  end
+  action :delete do
 
-  action :stop do
-    if running?
-      converge_by("stop container #{current_resource.id}") do
-        stop
-      end
-    end
   end
 
-  action :wait do
-    if running?
-      converge_by("tell container #{current_resource.id} to wait") do
-        wait
-      end
-    end
-  end
 end

data/lib/chef/resource/docker_container.rb

@@ -1,12 +1,6 @@
 require 'chef/resource/lwrp_base'
 
-class Chef::Resource::DockerContainer < Chef::Resource::LWRPBase
-
-  self.resource_name = 'docker_container'
-  
-  actions :commit, :cp, :export, :kill, :redeploy, :remove, :restart, :run, :start, :stop, :wait
-
-  default_action :run
+class Chef::Resource::DockerContainer < Chef::Resource::Machine
 
   attribute :image, :name_attribute => true
   attribute :attach, :kind_of => [TrueClass, FalseClass]

data/lib/chef_metal/driver_init/docker.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_docker/docker_driver'
+
+ChefMetal.register_driver_class('docker', ChefMetalDocker::DockerDriver)

data/lib/chef_metal_docker.rb

@@ -1,4 +1,4 @@
 require 'chef_metal'
-require 'chef_metal_docker/docker_provisioner'
+require 'chef_metal_docker/docker_driver'
 require 'chef/resource/docker_container'
-require 'chef/provider/docker_container'
+require 'chef/provider/docker_container'

data/lib/chef_metal_docker/chef_zero_http_proxy.rb

@@ -0,0 +1,92 @@
+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)
+    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 = ''
+    loop do
+      to_server.read(8192, buff)
+      to_client.write(buff)
+      break if buff.size < 8192
+    end
+
+    # Close the sockets
+    to_client.close
+    to_server.close
+  end
+  
+end
+ 
+ 

data/lib/chef_metal_docker/docker_container_machine.rb

@@ -0,0 +1,26 @@
+require 'chef_metal/machine/unix_machine'
+
+module ChefMetalDocker
+  class DockerContainerMachine < ChefMetal::Machine::UnixMachine
+
+    def initialize(machine_spec, transport, convergence_strategy, command)
+      super(machine_spec, transport, convergence_strategy)
+      @command = command
+      @container_name = machine_spec.location['container_name']
+      @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)
+      end
+    end
+
+  end
+end

data/lib/chef_metal_docker/docker_driver.rb

@@ -0,0 +1,238 @@
+
+require 'chef/mixin/shell_out'
+require 'chef_metal/driver'
+require 'chef_metal_docker/version'
+require 'chef_metal_docker/docker_transport'
+require 'chef_metal_docker/docker_container_machine'
+require 'chef_metal/convergence_strategy/install_cached'
+require 'chef_metal/convergence_strategy/no_converge'
+
+require 'yaml'
+require 'docker/container'
+require 'docker'
+
+module ChefMetalDocker
+  # Provisions machines using Docker
+  class DockerDriver < ChefMetal::Driver
+
+    include Chef::Mixin::ShellOut
+
+    attr_reader :connection
+
+    # URL scheme:
+    # docker:<path>
+    # canonical URL calls realpath on <path>
+    def self.from_url(driver_url, config)
+      DockerDriver.new(driver_url, config)
+    end
+
+    def initialize(driver_url, config)
+      super
+      url = DockerDriver.connection_url(driver_url)
+
+      if url
+        # Export this as it's expected
+        # to be set for command-line utilities
+        ENV['DOCKER_HOST'] = url
+        Chef::Log.debug("Setting Docker URL to #{url}")
+        Docker.url = url
+      end
+
+      @connection = Docker.connection
+    end
+
+    def self.canonicalize_url(driver_url, config)
+      url = DockerDriver.connection_url(driver_url)
+      [ "docker:#{url}", config ]
+    end
+
+    # Parse the url from a driver URL, try to clean it up
+    # Returns a proper URL from the driver_url string. Examples include:
+    #   docker:/var/run/docker.sock => unix:///var/run/docker.sock
+    #   docker:192.168.0.1:1234 => tcp://192.168.0.1:1234
+    def self.connection_url(driver_url)
+      scheme, url = driver_url.split(':', 2)
+
+      if url && url.size > 0
+        # Clean up the URL with the protocol if needed (within reason)
+        case url
+        when /^\d+\.\d+\.\d+\.\d+:\d+$/
+          "tcp://#{url}"
+        when /^\//
+          "unix://#{url}"
+        when /^(tcp|unix)/
+          url
+        else
+          "tcp://#{url}"
+        end
+      end
+    end
+
+
+    def allocate_machine(action_handler, machine_spec, machine_options)
+
+      container_name = machine_spec.name
+      machine_spec.location = {
+          'driver_url' => driver_url,
+          'driver_version' => ChefMetalDocker::VERSION,
+          'allocated_at' => Time.now.utc.to_s,
+          'host_node' => action_handler.host_node,
+          'container_name' => container_name,
+          'image_id' => machine_options[:image_id]
+      }
+    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)
+    end
+
+    def build_container(machine_spec, machine_options)
+
+      docker_options = machine_options[:docker_options]
+
+      base_image = docker_options[:base_image]
+      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
+
+        image = find_image(target_repository, target_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}")
+        end
+
+        "#{target_repository}:#{target_tag}"
+      end
+    end
+
+    def allocate_image(action_handler, image_spec, image_options, machine_spec)
+      # Set machine options on the image to match our newly created image
+      image_spec.machine_options = {
+        :docker_options => {
+          :base_image => {
+            :name => "chef_#{image_spec.name}",
+            :repository => 'chef',
+            :tag => image_spec.name
+          },
+          :from_image => true
+        }
+      }
+    end
+
+    def ready_image(action_handler, image_spec, image_options)
+      Chef::Log.debug('READY IMAGE!')
+    end
+
+    # Connect to machine without acquiring it
+    def connect_to_machine(machine_spec, machine_options)
+      Chef::Log.debug('Connect to machine!')
+    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!')
+      end
+
+      Chef::Log.debug("Removing #{container_name}")
+      container.delete
+
+      Chef::Log.debug("Destroying image: chef:#{container_name}")
+      image = Docker::Image.get("chef:#{container_name}")
+      image.delete
+
+    end
+
+    def stop_machine(action_handler, node)
+      Chef::Log.debug("Stop machine: #{node.inspect}")
+    end
+
+    def image_named(image_name)
+      Docker::Image.all.select {
+          |i| i.info['RepoTags'].include? image_name
+      }.first
+    end
+
+    def find_image(repository, tag)
+      Docker::Image.all.select {
+          |i| i.info['RepoTags'].include? "#{repository}:#{tag}"
+      }.first
+    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
+      end
+
+    end
+
+    def machine_for(machine_spec, machine_options, base_image_name)
+      Chef::Log.debug('machine_for...')
+
+      docker_options = machine_options[:docker_options]
+
+      transport = DockerTransport.new(machine_spec.location['container_name'],
+                                      base_image_name,
+                                      nil,
+                                      Docker.connection)
+
+      convergence_strategy = if docker_options[:from_image]
+                               ChefMetal::ConvergenceStrategy::NoConverge.new({}, config)
+                             else
+                               convergence_strategy_for(machine_spec, machine_options)
+                             end
+
+        ChefMetalDocker::DockerContainerMachine.new(
+          machine_spec,
+          transport,
+          convergence_strategy,
+          docker_options[:command]
+        )
+    end
+
+    def convergence_strategy_for(machine_spec, machine_options)
+      @unix_convergence_strategy ||= begin
+        ChefMetal::ConvergenceStrategy::InstallCached.
+            new(machine_options[:convergence_options], config)
+      end
+    end
+
+  end
+end