chef-metal-docker 0.1.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a106532b6fa395835377aed7d7e8952db0f78552
-  data.tar.gz: 3f8998e4a21485428004f1d93273eff5639d1cb3
+  metadata.gz: 9f6ac421bc65fa8a3497942dbd04d15efb23badc
+  data.tar.gz: 1b23d70778b4bbece79836bb419cb3ecd462fc19
 SHA512:
-  metadata.gz: f1d1150a775d7b98c59004b3f365c35aa08a31cbb3241cd5640e1cd14002ce4390f9f90ab21a2a8743e668bd8b0d48384ac22dc5a17457ddd5a0cc64c6972e0b
-  data.tar.gz: 45407348ba54a5d1ebefc101bd490581261a6e2f7b9957cf01a36bf3af7c8d3f5ea643c8625a79e1cc54b7ff7eaad1f521047ee681e4bcf27da687ed0afc8554
+  metadata.gz: ec3d7947e1e67187603842051249713a662ee9f800a8d4abd72fd10334a4e692c0005fd1f25c34a7121b01a5f6a5c3e5aea8f3f18416a2e8d5ccb882c943e3ce
+  data.tar.gz: a2df491bf80e944a349f256e333d6e759f2b4e2f46aab7a3ed6e7727507338a9c93dda64331ae516f50761a35b29464e70637891bb43f3dd44f8d47bb7629a72

data/lib/chef_metal_docker/docker_provisioner.rb

@@ -3,8 +3,8 @@ 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_convergence_strategy'
 require 'chef_metal_docker/docker_unix_machine'
+require 'chef_metal/transport/ssh'
 require 'docker'
 
 module ChefMetalDocker
@@ -50,10 +50,12 @@ module ChefMetalDocker
     #
     #           -- 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
-    #           -- 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)
-    #           -- convergence_strategy: :no_converge or :install_cached (former will not converge, latter will set up chef-client and converge)
+    #           -- 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
@@ -77,29 +79,45 @@ module ChefMetalDocker
       base_image_name = provisioner_options['base_image']
       raise "base_image not specified in provisioner options!" if !base_image_name
 
-      # 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
+      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
-      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)
+        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
@@ -168,48 +186,87 @@ module ChefMetalDocker
     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 = case provisioner_options['convergence_strategy']
-        when 'no_converge'
-          ChefMetal::ConvergenceStrategy::NoConverge.new
-        else
-          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
-      container_configuration = provisioner_options['container_configuration'] || {}
-      if provisioner_options['command']
-        command = provisioner_options['command']
-        command = command.split(/\s+/) if command.is_a?(String)
-        container_configuration['Cmd'] = command
-      elsif provisioner_options['command'] == false
-        container_configuration = nil
-      else
-        # TODO how do we get things started?  runit?  cron?  wassup here.
-        container_configuration['Cmd'] = %w(while 1; sleep 1000; end)
+      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
-      ChefMetalDocker::DockerConvergenceStrategy.new(strategy,
-        provisioner_output['repository_name'],
-        provisioner_output['container_name'],
-        container_configuration,
-        provisioner_options['host_configuration'] || {},
-        credentials,
-        connection)
     end
 
     def transport_for(node)
+      provisioner_options = node['normal']['provisioner_options']
       provisioner_output = node['normal']['provisioner_output']
-      ChefMetalDocker::DockerTransport.new(
-        provisioner_output['repository_name'],
-        provisioner_output['container_name'],
-        credentials,
-        connection)
+      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

data/lib/chef_metal_docker/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal-docker
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: '0.2'
 platform: ruby
 authors:
 - Tom Duffield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-12 00:00:00.000000000 Z
+date: 2014-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -108,7 +108,6 @@ files:
 - 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_convergence_strategy.rb
 - lib/chef_metal_docker/docker_provisioner.rb
 - lib/chef_metal_docker/docker_transport.rb
 - lib/chef_metal_docker/docker_unix_machine.rb

data/lib/chef_metal_docker/docker_convergence_strategy.rb

@@ -1,55 +0,0 @@
-require 'chef_metal/convergence_strategy'
-require 'docker'
-
-module ChefMetalDocker
-  class DockerConvergenceStrategy < ChefMetal::ConvergenceStrategy
-    def initialize(real_convergence_strategy, repository_name, container_name, container_configuration, host_configuration, credentials, connection)
-      @real_convergence_strategy = real_convergence_strategy
-      @repository_name = repository_name
-      @container_name = container_name
-      @container_configuration = container_configuration
-      @host_configuration = host_configuration
-      @credentials = credentials
-      @connection = connection
-    end
-
-    attr_reader :real_convergence_strategy
-    attr_reader :repository_name
-    attr_reader :container_name
-    attr_reader :container_configuration
-    attr_reader :host_configuration
-    attr_reader :credentials
-    attr_reader :connection
-
-    def setup_convergence(action_handler, machine, machine_resource)
-      real_convergence_strategy.setup_convergence(action_handler, machine, machine_resource)
-    end
-
-    def converge(action_handler, machine, chef_server)
-      real_convergence_strategy.converge(action_handler, machine, chef_server)
-
-      # After converge, we bring up the container command
-      if container_configuration
-        begin
-          container = Docker::Container.get(container_name)
-          action_handler.perform_action "Delete existing container" do
-            container.delete
-          end
-        rescue Docker::Error::NotFoundError
-        end
-        action_handler.perform_action "Create new container and run container_configuration['Cmd']" do
-          container = Docker::Container.create({
-            'name' => container_name,
-            'Image' => "#{repository_name}:latest"
-          }.merge(container_configuration), connection)
-          container.start!(host_configuration)
-        end
-        # We don't bother waiting ... our only job is to bring it up.
-      end
-    end
-
-    def cleanup_convergence(action_handler, node)
-      real_convergence_strategy.cleanup_convergence(action_handler, node)
-    end
-  end
-end