chef-metal-docker 0.1

data/lib/chef_metal_docker/docker_unix_machine.rb

@@ -0,0 +1,9 @@
+require 'chef_metal/machine/unix_machine'
+
+module ChefMetalDocker
+  class DockerUnixMachine < ChefMetal::Machine::UnixMachine
+    def execute_always(command, options = {})
+      transport.execute(command, { :read_only => true }.merge(options))
+    end
+  end
+end

data/lib/chef_metal_docker/helpers.rb

@@ -0,0 +1,146 @@
+require 'chef/mixin/shell_out'
+include Chef::Mixin::ShellOut
+
+# Helpers module
+module ChefMetalDocker
+  # Helpers::Docker module
+  module Helpers
+    # Exception to signify that the Docker daemon is not yet ready to handle
+    # docker commands.
+    class DockerNotReady < StandardError
+      def initialize(timeout)
+        super <<-EOH
+The Docker daemon did not become ready within #{timeout} seconds.
+This most likely means that Docker failed to start.
+Docker can fail to start if:
+
+  - a configuration file is invalid
+  - permissions are incorrect for the root directory of the docker runtime.
+
+If this problem persists, check your service log files.
+EOH
+      end
+    end
+
+    # Exception to signify that the docker command timed out.
+    class CommandTimeout < RuntimeError; end
+
+    def cli_args(spec)
+      cli_line = ''
+      spec.each_pair do |arg, value|
+        case value
+        when Array
+          next if value.empty?
+          args = value.map do |v|
+            v = "\"#{v}\"" if v.is_a?(String)
+            " --#{arg}=#{v}"
+          end
+          cli_line += args.join
+        when FalseClass, Fixnum, Integer, String, TrueClass
+          value = "\"#{value}\"" if value.is_a?(String)
+          cli_line += " --#{arg}=#{value}"
+        end
+      end
+      cli_line
+    end
+
+    def docker_inspect(id)
+      require 'json'
+      JSON.parse(docker_cmd("inspect #{id}").stdout)[0]
+    end
+
+    def docker_inspect_id(id)
+      inspect = docker_inspect(id)
+      inspect['id'] if inspect
+    end
+
+    def dockercfg_parse
+      require 'json'
+      dockercfg = JSON.parse(::File.read(::File.join(::Dir.home, '.dockercfg')))
+      dockercfg.each_pair do |k, v|
+        dockercfg[k].merge!(dockercfg_parse_auth(v['auth']))
+      end
+      dockercfg
+    end
+
+    def dockercfg_parse_auth(str)
+      require 'base64'
+      decoded_str = Base64.decode64(str)
+      if decoded_str
+        auth = {}
+        auth['username'], auth['password'] = decoded_str.split(':')
+        auth
+      end
+    end
+
+    def timeout
+      10
+    end
+
+    # This is based upon wait_until_ready! from the opscode jenkins cookbook.
+    #
+    # Since the docker service returns immediately and the actual docker
+    # process is started as a daemon, we block the Chef Client run until the
+    # daemon is actually ready.
+    #
+    # This method will effectively "block" the current thread until the docker
+    # daemon is ready
+    #
+    # @raise [DockerNotReady]
+    #   if the Docker master does not respond within (+timeout+) seconds
+    #
+    def wait_until_ready!
+      Timeout.timeout(timeout) do
+        loop do
+          result = shell_out('docker info')
+          break if Array(result.valid_exit_codes).include?(result.exitstatus)
+          Chef::Log.debug("Docker daemon is not running - #{result.stdout}\n#{result.stderr}")
+          sleep(0.5)
+        end
+      end
+    rescue Timeout::Error
+      raise DockerNotReady.new(timeout), 'docker timeout exceeded'
+    end
+
+    # the Error message to display if a command times out. Subclasses
+    # may want to override this to provide more details on the timeout.
+    def command_timeout_error_message
+      <<-EOM
+
+Command timed out:
+#{cmd}
+
+EOM
+    end
+
+    # Runs a docker command. Does not raise exception on non-zero exit code.
+    def docker_cmd(cmd, timeout = new_resource.cmd_timeout)
+      execute_cmd('docker ' + cmd, timeout)
+    end
+
+    # Executes the given command with the specified timeout. Does not raise an
+    # exception on a non-zero exit code.
+    def execute_cmd(cmd, timeout = new_resource.cmd_timeout)
+      Chef::Log.debug('Executing: ' + cmd)
+      begin
+        shell_out(cmd, :timeout => timeout)
+      rescue Mixlib::ShellOut::CommandTimeout
+        raise CommandTimeout, command_timeout_error_message(cmd)
+      end
+    end
+
+    # Executes the given docker command with the specified timeout. Raises an
+    # exception if the command returns a non-zero exit code.
+    def docker_cmd!(cmd, timeout = new_resource.cmd_timeout)
+      execute_cmd!('docker ' + cmd, timeout)
+    end
+
+    # Executes the given command with the specified timeout. Raises an
+    # exception if the command returns a non-zero exit code.
+    def execute_cmd!(cmd, timeout = new_resource.cmd_timeout)
+      cmd = execute_cmd(cmd, timeout)
+      cmd.error!
+      cmd
+    end
+  end
+end

data/lib/chef_metal_docker/helpers/container.rb

@@ -0,0 +1,15 @@
+require 'chef_metal_docker/helpers'
+require 'chef_metal_docker/helpers/container/actions'
+require 'chef_metal_docker/helpers/container/helpers'
+
+module ChefMetalDocker
+  module Helpers
+    module Container
+
+      include ChefMetalDocker::Helpers
+      include ChefMetalDocker::Helpers::Container::Helpers
+      include ChefMetalDocker::Helpers::Container::Actions
+  
+    end
+  end
+end

data/lib/chef_metal_docker/helpers/container/actions.rb

@@ -0,0 +1,313 @@
+module ChefMetalDocker
+  module Helpers
+    module Container
+      # This is a collection of helper methods that are used to trigger actions in
+      # the LWRPs. By putting them in a separate file we can a) keep the LWRPs cleaner
+      # and b) unit test them!
+      module Actions
+
+        def commit
+          commit_args = cli_args(
+            'author' => new_resource.author,
+            'message' => new_resource.message,
+            'run' => new_resource.run
+          )
+          commit_end_args = ''
+
+          if new_resource.repository
+            commit_end_args = new_resource.repository
+            commit_end_args += ":#{new_resource.tag}" if new_resource.tag
+          end
+
+          docker_cmd!("commit #{commit_args} #{current_resource.id} #{commit_end_args}")
+        end
+
+        def cp
+          docker_cmd!("cp #{current_resource.id}:#{new_resource.source} #{new_resource.destination}")
+        end
+
+        def export
+          docker_cmd!("export #{current_resource.id} > #{new_resource.destination}")
+        end
+
+        def kill
+          if service?
+            service_stop
+          else
+            docker_cmd!("kill #{current_resource.id}")
+          end
+        end
+
+        def remove
+          rm_args = cli_args(
+            'force' => new_resource.force,
+            'link' => new_resource.link
+          )
+          docker_cmd!("rm #{rm_args} #{current_resource.id}")
+          service_remove if service?
+        end
+
+        def redeploy 
+          stop if running?
+          remove if exists?
+          run
+        end 
+
+        def restart
+          if service?
+            service_restart
+          else
+            docker_cmd!("restart #{current_resource.id}")
+          end
+        end
+
+        # rubocop:disable MethodLength
+        def run
+          run_args = cli_args(
+            'cpu-shares' => new_resource.cpu_shares,
+            'cidfile' => cidfile,
+            'detach' => new_resource.detach,
+            'dns' => Array(new_resource.dns),
+            'dns-search' => Array(new_resource.dns_search),
+            'env' => Array(new_resource.env),
+            'entrypoint' => new_resource.entrypoint,
+            'expose' => Array(new_resource.expose),
+            'hostname' => new_resource.hostname,
+            'interactive' => new_resource.stdin,
+            'label' => new_resource.label,
+            'link' => Array(new_resource.link),
+            'lxc-conf' => Array(new_resource.lxc_conf),
+            'memory' => new_resource.memory,
+            'networking' => new_resource.networking,
+            'name' => container_name,
+            'opt' => Array(new_resource.opt),
+            'publish' => Array(port),
+            'publish-all' => new_resource.publish_exposed_ports,
+            'privileged' => new_resource.privileged,
+            'rm' => new_resource.remove_automatically,
+            'tty' => new_resource.tty,
+            'user' => new_resource.user,
+            'volume' => Array(new_resource.volume),
+            'volumes-from' => new_resource.volumes_from,
+            'workdir' => new_resource.working_directory
+          )
+          dr = docker_cmd!("run #{run_args} #{new_resource.image} #{new_resource.command}")
+          dr.error!
+          new_resource.id(dr.stdout.chomp)
+          service_create if service?
+        end
+        # rubocop:enable MethodLength
+
+        def service_action(actions)
+          if new_resource.init_type == 'runit'
+            runit_service service_name do
+              run_template_name 'docker-container'
+              action actions
+            end
+          else
+            service service_name do
+              case new_resource.init_type
+              when 'systemd'
+                provider Chef::Provider::Service::Systemd
+              when 'upstart'
+                provider Chef::Provider::Service::Upstart
+              end
+              supports :status => true, :restart => true, :reload => true
+              action actions
+            end
+          end
+        end
+
+        def service_create
+          case new_resource.init_type
+          when 'runit'
+            service_create_runit
+          when 'systemd'
+            service_create_systemd
+          when 'sysv'
+            service_create_sysv
+          when 'upstart'
+            service_create_upstart
+          end
+        end
+
+        def service_create_runit
+          runit_service service_name do
+            cookbook new_resource.cookbook
+            default_logger true
+            options(
+              'service_name' => service_name
+            )
+            run_template_name service_template
+          end
+        end
+
+        def service_create_systemd
+          template "/usr/lib/systemd/system/#{service_name}.socket" do
+            if new_resource.socket_template.nil?
+              source 'docker-container.socket.erb'
+            else
+              source new_resource.socket_template
+            end
+            cookbook new_resource.cookbook
+            mode '0644'
+            owner 'root'
+            group 'root'
+            variables(
+              :service_name => service_name,
+              :sockets => sockets
+            )
+            not_if port.empty?
+          end
+
+          template "/usr/lib/systemd/system/#{service_name}.service" do
+            source service_template
+            cookbook new_resource.cookbook
+            mode '0644'
+            owner 'root'
+            group 'root'
+            variables(
+              :cmd_timeout => new_resource.cmd_timeout,
+              :service_name => service_name
+            )
+          end
+
+          service_action([:start, :enable])
+        end
+
+        def service_create_sysv
+          template "/etc/init.d/#{service_name}" do
+            source service_template
+            cookbook new_resource.cookbook
+            mode '0755'
+            owner 'root'
+            group 'root'
+            variables(
+              :cmd_timeout => new_resource.cmd_timeout,
+              :service_name => service_name
+            )
+          end
+
+          service_action([:start, :enable])
+        end
+
+        def service_create_upstart
+          # The upstart init script requires inotifywait, which is in inotify-tools
+          package 'inotify-tools'
+
+          template "/etc/init/#{service_name}.conf" do
+            source service_template
+            cookbook new_resource.cookbook
+            mode '0600'
+            owner 'root'
+            group 'root'
+            variables(
+              :cmd_timeout => new_resource.cmd_timeout,
+              :service_name => service_name
+            )
+          end
+
+          service_action([:start, :enable])
+        end
+
+        def service_remove
+          case new_resource.init_type
+          when 'runit'
+            service_remove_runit
+          when 'systemd'
+            service_remove_systemd
+          when 'sysv'
+            service_remove_sysv
+          when 'upstart'
+            service_remove_upstart
+          end
+        end
+
+        def service_remove_runit
+          runit_service service_name do
+            action :disable
+          end
+        end
+
+        def service_remove_systemd
+          service_action([:stop, :disable])
+
+          %w(service socket).each do |f|
+            file "/usr/lib/systemd/system/#{service_name}.#{f}" do
+              action :delete
+            end
+          end
+        end
+
+        def service_remove_sysv
+          service_action([:stop, :disable])
+
+          file "/etc/init.d/#{service_name}" do
+            action :delete
+          end
+        end
+
+        def service_remove_upstart
+          service_action([:stop, :disable])
+
+          file "/etc/init/#{service_name}" do
+            action :delete
+          end
+        end
+
+        def service_restart
+          service_action([:restart])
+        end
+
+        def service_start
+          service_action([:start])
+        end
+
+        def service_stop
+          service_action([:stop])
+        end
+
+        def service_template
+          return new_resource.init_template unless new_resource.init_template.nil?
+          case new_resource.init_type
+          when 'runit'
+            'docker-container'
+          when 'systemd'
+            'docker-container.service.erb'
+          when 'upstart'
+            'docker-container.conf.erb'
+          when 'sysv'
+            'docker-container.sysv.erb'
+          end
+        end
+
+        def start
+          start_args = cli_args(
+            'attach' => new_resource.attach,
+            'interactive' => new_resource.stdin
+          )
+          if service?
+            service_create
+          else
+            docker_cmd!("start #{start_args} #{current_resource.id}")
+          end
+        end
+
+        def stop
+          stop_args = cli_args(
+            'time' => new_resource.cmd_timeout
+          )
+          if service?
+            service_stop
+          else
+            docker_cmd!("stop #{stop_args} #{current_resource.id}", (new_resource.cmd_timeout + 15))
+          end
+        end
+
+        def wait
+          docker_cmd!("wait #{current_resource.id}")
+        end
+      end
+    end
+  end
+end