kitchen-dokken 2.10.0 → 2.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9457c866ed76959da525c5c6ff2cf79ec23ce6f1bc0b3b4f19a1d65dbb8c53d1
-  data.tar.gz: 12416b24465f12771c00ff3d702f0c2283a763e113710da7f5fa43b8f4c21ae5
+  metadata.gz: 517d0d0706aed8e8fc5889c874d6817fe65cfa571ba3a7a082d8256f707986cd
+  data.tar.gz: f5beb66dc47d9c4f58022c26af3ce8657c7fae40443eb2d3ee1b5ef2c01f5d0e
 SHA512:
-  metadata.gz: 6b1bd8719579b19eca0d091b713c00d94cdfd08e4f3d4a5c79caae06301bfd0bc0f2e84dac691f4a55824e7e0a87a6bf7cc5cce1c3b29c35b9b4414aa2cf687a
-  data.tar.gz: b943f80b7f0664155366080e2a9fe4d3b07e897b77c396d87d31d103c32935d16a7b44c75bf2525f729b028d2bb8bb7a77f8c9f2e98dd2a57ae7e67cb03fc326
+  metadata.gz: fd3d097a36e249e21f88ea3a1999207f9e45e464a9eb649d10c870d24d4a0705766dfb57df3ced2c82cda4e6cee04d5b53587b36743dbdd887da036d00c5d7c8
+  data.tar.gz: 755b9671c1aa2cbf14a90ddb9c730e3d50d5326a6244f2d8ece875b5bf5b5e9567c3c5f9661cd6cb6a00e6e4ec0594efcd5aa2fe0daf56e0fca7bf78c6a76d61

data/lib/kitchen/driver/dokken.rb

@@ -15,12 +15,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'digest'
-require 'kitchen'
-require 'tmpdir'
-require 'docker'
-require 'lockfile'
-require_relative '../helpers'
+require "digest" unless defined?(Digest)
+require "kitchen"
+require "tmpdir" unless defined?(Dir.mktmpdir)
+require "docker"
+require "lockfile"
+require_relative "../helpers"
 
 include Dokken::Helpers
 
@@ -37,31 +37,32 @@ module Kitchen
       default_config :binds, []
       default_config :cap_add, nil
       default_config :cap_drop, nil
-      default_config :chef_image, 'chef/chef'
-      default_config :chef_version, 'latest'
-      default_config :data_image, 'dokken/kitchen-cache:latest'
+      default_config :chef_image, "chef/chef"
+      default_config :chef_version, "latest"
+      default_config :data_image, "dokken/kitchen-cache:latest"
       default_config :dns, nil
       default_config :dns_search, nil
+      default_config :docker_host_url, default_docker_host
       default_config :docker_info, docker_info
+      default_config :docker_registry, nil
       default_config :entrypoint, nil
       default_config :env, nil
-      default_config :ports, nil
-      default_config :docker_host_url, default_docker_host
-      default_config :hostname, 'dokken'
+      default_config :hostname, "dokken"
       default_config :image_prefix, nil
       default_config :links, nil
-      default_config :network_mode, 'dokken'
+      default_config :memory_limit, 0
+      default_config :network_mode, "dokken"
       default_config :pid_one_command, 'sh -c "trap exit 0 SIGTERM; while :; do sleep 1; done"'
+      default_config :ports, nil
       default_config :privileged, false
+      default_config :pull_chef_image, true
+      default_config :pull_platform_image, true
       default_config :read_timeout, 3600
       default_config :security_opt, nil
       default_config :tmpfs, {}
+      default_config :userns_host, false
       default_config :volumes, nil
       default_config :write_timeout, 3600
-      default_config :userns_host, false
-      default_config :pull_platform_image, true
-      default_config :pull_chef_image, true
-      default_config :memory_limit, 0
 
       # (see Base#create)
       def create(state)
@@ -126,37 +127,38 @@ module Kitchen
 
       def delete_work_image
         return unless ::Docker::Image.exist?(work_image, {}, docker_connection)
+
         with_retries { @work_image = ::Docker::Image.get(work_image, {}, docker_connection) }
 
         with_retries do
-          begin
-            with_retries { @work_image.remove(force: true) }
-          rescue ::Docker::Error::ConflictError
-            debug "driver - #{work_image} cannot be removed"
-          end
+
+          with_retries { @work_image.remove(force: true) }
+        rescue ::Docker::Error::ConflictError
+          debug "driver - #{work_image} cannot be removed"
+
         end
       end
 
       def build_work_image(state)
-        info('Building work image..')
+        info("Building work image..")
         return if ::Docker::Image.exist?(work_image, {}, docker_connection)
 
         begin
           @intermediate_image = ::Docker::Image.build(
             work_image_dockerfile,
             {
-              't' => work_image,
+              "t" => work_image,
             },
             docker_connection
           )
         # credit to https://github.com/someara/kitchen-dokken/issues/95#issue-224697526
         rescue Docker::Error::UnexpectedResponseError => e
-          msg = 'work_image build failed: '
-          msg += JSON.parse(e.to_s.split("\r\n").last)['error'].to_s
-          msg += '. The common scenerios are incorrect intermediate'
-          msg += 'instructions such as not including `-y` on an `apt-get` '
-          msg += 'or similar. The other common scenerio is a transient '
-          msg += 'error such as an unresponsive mirror.'
+          msg = "work_image build failed: "
+          msg += JSON.parse(e.to_s.split("\r\n").last)["error"].to_s
+          msg += ". The common scenarios are incorrect intermediate "
+          msg += "instructions such as not including `-y` on an `apt-get` "
+          msg += "or similar. The other common scenario is a transient "
+          msg += "error such as an unresponsive mirror."
           raise msg
         # fallback rescue above should catch most of the errors
         rescue => e
@@ -167,8 +169,10 @@ module Kitchen
       end
 
       def work_image_dockerfile
+        from = registry_image_path(platform_image)
+        debug("driver - Building work image from #{from}")
         dockerfile_contents = [
-          "FROM #{platform_image}",
+          "FROM #{from}",
           "LABEL X-Built-By=kitchen-dokken X-Built-From=#{platform_image}",
         ]
         Array(config[:intermediate_instructions]).each do |c|
@@ -219,6 +223,7 @@ module Kitchen
 
       def work_image
         return "#{image_prefix}/#{instance_name}" unless image_prefix.nil?
+
         instance_name
       end
 
@@ -244,7 +249,7 @@ module Kitchen
           v
         else
           Array(v).each_with_object({}) do |y, h|
-            name, opts = y.split(':', 2)
+            name, opts = y.split(":", 2)
             h[name.to_s] = opts.to_s
           end
         end
@@ -260,12 +265,13 @@ module Kitchen
           b = []
           v = Array(v).to_a # in case v.is_A?(Chef::Node::ImmutableArray)
           v.delete_if do |x|
-            parts = x.split(':')
+            parts = x.split(":")
             b << x if parts.length > 1
           end
           b = nil if b.empty?
           config[:binds].push(b) unless config[:binds].include?(b) || b.nil?
           return PartialHash.new if v.empty?
+
           v.each_with_object(PartialHash.new) { |volume, h| h[volume] = {} }
         end
       end
@@ -281,41 +287,42 @@ module Kitchen
         debug "driver - starting #{runner_container_name}"
 
         config = {
-          'name' => runner_container_name,
-          'Cmd' => Shellwords.shellwords(self[:pid_one_command]),
-          'Image' => "#{repo(work_image)}:#{tag(work_image)}",
-          'Hostname' => self[:hostname],
-          'Env' => self[:env],
-          'ExposedPorts' => exposed_ports,
-          'Volumes' => dokken_volumes,
-          'HostConfig' => {
-            'Privileged' => self[:privileged],
-            'VolumesFrom' => dokken_volumes_from,
-            'Binds' => dokken_binds,
-            'Dns' => self[:dns],
-            'DnsSearch' => self[:dns_search],
-            'Links' => Array(self[:links]),
-            'CapAdd' => Array(self[:cap_add]),
-            'CapDrop' => Array(self[:cap_drop]),
-            'SecurityOpt' => Array(self[:security_opt]),
-            'NetworkMode' => self[:network_mode],
-            'PortBindings' => port_bindings,
-            'Tmpfs' => dokken_tmpfs,
-            'Memory' => self[:memory_limit],
+          "name" => runner_container_name,
+          "Cmd" => Shellwords.shellwords(self[:pid_one_command]),
+          # locally built image, must use short-name
+          "Image" => short_image_path(work_image),
+          "Hostname" => self[:hostname],
+          "Env" => self[:env],
+          "ExposedPorts" => exposed_ports,
+          "Volumes" => dokken_volumes,
+          "HostConfig" => {
+            "Privileged" => self[:privileged],
+            "VolumesFrom" => dokken_volumes_from,
+            "Binds" => dokken_binds,
+            "Dns" => self[:dns],
+            "DnsSearch" => self[:dns_search],
+            "Links" => Array(self[:links]),
+            "CapAdd" => Array(self[:cap_add]),
+            "CapDrop" => Array(self[:cap_drop]),
+            "SecurityOpt" => Array(self[:security_opt]),
+            "NetworkMode" => self[:network_mode],
+            "PortBindings" => port_bindings,
+            "Tmpfs" => dokken_tmpfs,
+            "Memory" => self[:memory_limit],
           },
-          'NetworkingConfig' => {
-            'EndpointsConfig' => {
+          "NetworkingConfig" => {
+            "EndpointsConfig" => {
               self[:network_mode] => {
-                'Aliases' => Array(self[:hostname]),
+                "Aliases" => Array(self[:hostname]),
               },
             },
           },
         }
         unless self[:entrypoint].to_s.empty?
-          config['Entrypoint'] = self[:entrypoint]
+          config["Entrypoint"] = self[:entrypoint]
         end
         if self[:userns_host]
-          config['HostConfig']['UsernsMode'] = 'host'
+          config["HostConfig"]["UsernsMode"] = "host"
         end
         runner_container = run_container(config)
         state[:runner_container] = runner_container.json
@@ -324,17 +331,18 @@ module Kitchen
       def start_data_container(state)
         debug "driver - creating #{data_container_name}"
         config = {
-          'name' => data_container_name,
-          'Image' => "#{repo(data_image)}:#{tag(data_image)}",
-          'HostConfig' => {
-            'PortBindings' => port_bindings,
-            'PublishAllPorts' => true,
-            'NetworkMode' => 'bridge',
+          "name" => data_container_name,
+          # locally built image, must use short-name
+          "Image" => short_image_path(data_image),
+          "HostConfig" => {
+            "PortBindings" => port_bindings,
+            "PublishAllPorts" => true,
+            "NetworkMode" => "bridge",
           },
-          'NetworkingConfig' => {
-            'EndpointsConfig' => {
+          "NetworkingConfig" => {
+            "EndpointsConfig" => {
               self[:network_mode] => {
-                'Aliases' => Array(self[:hostname]),
+                "Aliases" => Array(self[:hostname]),
               },
             },
           },
@@ -347,10 +355,10 @@ module Kitchen
         lockfile = Lockfile.new "#{home_dir}/.dokken-network.lock"
         begin
           lockfile.lock
-          with_retries { ::Docker::Network.get('dokken', {}, docker_connection) }
-        rescue
+          with_retries { ::Docker::Network.get("dokken", {}, docker_connection) }
+        rescue ::Docker::Error::NotFoundError
           begin
-            with_retries { ::Docker::Network.create('dokken', {}) }
+            with_retries { ::Docker::Network.create("dokken", {}) }
           rescue ::Docker::Error => e
             debug "driver - error :#{e}:"
           end
@@ -360,32 +368,39 @@ module Kitchen
       end
 
       def make_data_image
-        debug 'driver - calling create_data_image'
-        create_data_image
+        debug "driver - calling create_data_image"
+        create_data_image(config[:docker_registry])
       end
 
       def create_chef_container(state)
         lockfile = Lockfile.new "#{home_dir}/.dokken-#{chef_container_name}.lock"
         begin
           lockfile.lock
-          with_retries { ::Docker::Container.get(chef_container_name, {}, docker_connection) }
+          with_retries {
+            # TEMPORARY FIX - docker-api 2.0.0 has a buggy Docker::Container.get - use .all instead
+            # https://github.com/swipely/docker-api/issues/566
+            # ::Docker::Container.get(chef_container_name, {}, docker_connection)
+            found = ::Docker::Container.all({ all: true }, docker_connection).select { |c| c.info["Names"].include?("/#{chef_container_name}") }
+            raise ::Docker::Error::NotFoundError.new(chef_container_name) if found.empty?
+
+            debug "Chef container already exists, continuing"
+          }
         rescue ::Docker::Error::NotFoundError
+          debug "Chef container does not exist, creating a new Chef container"
           with_retries do
-            begin
-              debug "driver - creating volume container #{chef_container_name} from #{chef_image}"
-              config = {
-                'name' => chef_container_name,
-                'Cmd' => 'true',
-                'Image' => "#{repo(chef_image)}:#{tag(chef_image)}",
-                'HostConfig' => {
-                  'NetworkMode' => self[:network_mode],
-                },
-              }
-              chef_container = create_container(config)
-              state[:chef_container] = chef_container.json
-            rescue ::Docker::Error => e
-              raise "driver - #{chef_container_name} failed to create #{e}"
-            end
+            debug "driver - creating volume container #{chef_container_name} from #{chef_image}"
+            config = {
+              "name" => chef_container_name,
+              "Cmd" => "true",
+              "Image" => registry_image_path(chef_image),
+              "HostConfig" => {
+                "NetworkMode" => self[:network_mode],
+              },
+            }
+            chef_container = create_container(config)
+            state[:chef_container] = chef_container.json
+          rescue ::Docker::Error, StandardError => e
+            raise "driver - #{chef_container_name} failed to create #{e}"
           end
         ensure
           lockfile.unlock
@@ -393,12 +408,12 @@ module Kitchen
       end
 
       def pull_platform_image
-        debug "driver - pulling #{chef_image} #{repo(platform_image)} #{tag(platform_image)}"
+        debug "driver - pulling #{short_image_path(platform_image)}"
         config[:pull_platform_image] ? pull_image(platform_image) : pull_if_missing(platform_image)
       end
 
       def pull_chef_image
-        debug "driver - pulling #{chef_image} #{repo(chef_image)} #{tag(chef_image)}"
+        debug "driver - pulling #{short_image_path(chef_image)}"
         config[:pull_chef_image] ? pull_image(chef_image) : pull_if_missing(chef_image)
       end
 
@@ -411,50 +426,83 @@ module Kitchen
 
       def container_exist?(name)
         return true if ::Docker::Container.get(name, {}, docker_connection)
-      rescue
+      rescue StandardError, ::Docker::Error::NotFoundError
         false
       end
 
       def parse_image_name(image)
-        parts = image.split(':')
+        parts = image.split(":")
 
         if parts.size > 2
           tag = parts.pop
-          repo = parts.join(':')
+          repo = parts.join(":")
         else
-          tag = parts[1] || 'latest'
+          tag = parts[1] || "latest"
           repo = parts[0]
         end
 
         [repo, tag]
       end
 
+      # Return the 'repo' half of a docker image path. Agnostic about if a
+      # registry is included, this effectively is just "before the colon"
+      #
+      # @param image [String] the docker image path to parse
+      # @return [String] the repo portion of `image`
       def repo(image)
         parse_image_name(image)[0]
       end
 
+      # Return the 'tag' of a docker image path. Will be `latest` if there
+      # is no explicit tag in the image path.
+      #
+      # @param image [String] the docker image path to parse
+      # @return [String] the tag of `image`
+      def tag(image)
+        parse_image_name(image)[1]
+      end
+
+      # Ensures an explicit tag on an image path.
+      #
+      # @param image [String] the docker image path to parse
+      # @return [String] `repo`:`tag`
+      def short_image_path(image)
+        "#{repo(image)}:#{tag(image)}"
+      end
+
+      # Qualifies the results of `short_image_path` with any registry the
+      # user has requested
+      #
+      # @param image [String] the docker image path to parse
+      # @return [String] The most fully-qualified registry path we cn make
+      def registry_image_path(image)
+        if config[:docker_registry]
+          "#{config[:docker_registry]}/#{short_image_path(image)}"
+        else
+          short_image_path(image)
+        end
+      end
+
       def create_container(args)
-        with_retries { @container = ::Docker::Container.get(args['name'], {}, docker_connection) }
+        with_retries { @container = ::Docker::Container.get(args["name"], {}, docker_connection) }
       rescue
         with_retries do
-          begin
-            args['Env'] = [] if args['Env'].nil?
-            args['Env'] << 'TEST_KITCHEN=1'
-            args['Env'] << "CI=#{ENV['CI']}" if ENV.include? 'CI'
-            info "Creating container #{args['name']}"
-            debug "driver - create_container args #{args}"
-            with_retries do
-              begin
-                @container = ::Docker::Container.create(args.clone, docker_connection)
-              rescue ::Docker::Error::ConflictError
-                debug "driver - rescue ConflictError: #{args['name']}"
-                with_retries { @container = ::Docker::Container.get(args['name'], {}, docker_connection) }
-              end
-            end
-          rescue ::Docker::Error => e
-            debug "driver - error :#{e}:"
-            raise "driver - failed to create_container #{args['name']}"
+          args["Env"] = [] if args["Env"].nil?
+          args["Env"] << "TEST_KITCHEN=1"
+          args["Env"] << "CI=#{ENV["CI"]}" if ENV.include? "CI"
+          info "Creating container #{args["name"]}"
+          debug "driver - create_container args #{args}"
+          with_retries do
+
+            @container = ::Docker::Container.create(args.clone, docker_connection)
+          rescue ::Docker::Error::ConflictError
+            debug "driver - rescue ConflictError: #{args["name"]}"
+            with_retries { @container = ::Docker::Container.get(args["name"], {}, docker_connection) }
           end
+        rescue ::Docker::Error => e
+          debug "driver - error :#{e}:"
+          raise "driver - failed to create_container #{args["name"]}"
+
         end
       end
 
@@ -462,14 +510,14 @@ module Kitchen
         create_container(args)
         with_retries do
           @container.start
-          @container = ::Docker::Container.get(args['name'], {}, docker_connection)
-          wait_running_state(args['name'], true)
+          @container = ::Docker::Container.get(args["name"], {}, docker_connection)
+          wait_running_state(args["name"], true)
         end
         @container
       end
 
       def container_state
-        @container ? @container.info['State'] : {}
+        @container ? @container.info["State"] : {}
       end
 
       def stop_container(name)
@@ -493,18 +541,15 @@ module Kitchen
         @container = ::Docker::Container.get(name, {}, docker_connection)
         i = 0
         tries = 20
-        until container_state['Running'] == v || container_state['FinishedAt'] != '0001-01-01T00:00:00Z'
+        until container_state["Running"] == v || container_state["FinishedAt"] != "0001-01-01T00:00:00Z"
           i += 1
           break if i == tries
+
           sleep 0.1
           @container = ::Docker::Container.get(name, {}, docker_connection)
         end
       end
 
-      def tag(image)
-        parse_image_name(image)[1]
-      end
-
       def chef_container_name
         "chef-#{chef_version}"
       end
@@ -514,7 +559,8 @@ module Kitchen
       end
 
       def chef_version
-        return 'latest' if config[:chef_version] == 'stable'
+        return "latest" if config[:chef_version] == "stable"
+
         config[:chef_version]
       end
 
@@ -531,27 +577,29 @@ module Kitchen
       end
 
       def platform_image_from_name
-        platform, release = instance.platform.name.split('-')
-        release ? [platform, release].join(':') : platform
+        platform, release = instance.platform.name.split("-")
+        release ? [platform, release].join(":") : platform
       end
 
       def pull_if_missing(image)
-        return if ::Docker::Image.exist?("#{repo(image)}:#{tag(image)}", {}, docker_connection)
+        return if ::Docker::Image.exist?(registry_image_path(image), {}, docker_connection)
+
         pull_image image
       end
 
       # https://github.com/docker/docker/blob/4fcb9ac40ce33c4d6e08d5669af6be5e076e2574/registry/auth.go#L231
       def parse_registry_host(val)
-        val.sub(%r{https?://}, '').split('/').first
+        val.sub(%r{https?://}, "").split("/").first
       end
 
       def pull_image(image)
+        path = registry_image_path(image)
         with_retries do
-          if Docker::Image.exist?("#{repo(image)}:#{tag(image)}", {}, docker_connection)
-            original_image = Docker::Image.get("#{repo(image)}:#{tag(image)}", {}, docker_connection)
+          if Docker::Image.exist?(path, {}, docker_connection)
+            original_image = Docker::Image.get(path, {}, docker_connection)
           end
 
-          new_image = Docker::Image.create({ 'fromImage' => "#{repo(image)}:#{tag(image)}" }, docker_connection)
+          new_image = Docker::Image.create({ "fromImage" => path }, docker_connection)
 
           !(original_image && original_image.id.start_with?(new_image.id))
         end

data/lib/kitchen/driver/dokken_version.rb

@@ -18,6 +18,6 @@
 module Kitchen
   module Driver
     # Version string for Dokken Kitchen driver
-    DOKKEN_VERSION = '2.10.0'.freeze
+    DOKKEN_VERSION = "2.12.1".freeze
   end
 end

data/lib/kitchen/helpers.rb

@@ -1,23 +1,20 @@
 module Dokken
   module Helpers
     # https://stackoverflow.com/questions/517219/ruby-see-if-a-port-is-open
-    require 'socket'
-    require 'timeout'
+    require "socket" unless defined?(Socket)
+    require "timeout" unless defined?(Timeout)
 
     def port_open?(ip, port)
       begin
         Timeout.timeout(1) do
-          begin
-            s = TCPSocket.new(ip, port)
-            s.close
-            return true
-          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-            return false
-          end
+          s = TCPSocket.new(ip, port)
+          s.close
+          return true
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN
+          return false
         end
       rescue Timeout::Error
       end
-
       false
     end
 
@@ -59,9 +56,13 @@ X8N2N9ZNnORJqK374yGj1jWUU66mQhPvn49QpG8P2HEoh2RQjNvyHA==
       EOF
     end
 
-    def data_dockerfile
+    def data_dockerfile(registry)
+      from = "centos:7"
+      if registry
+        from = "#{registry}/#{from}"
+      end
       <<-EOF
-FROM centos:7
+FROM #{from}
 MAINTAINER Sean OMeara \"sean@sean.io\"
 ENV LANG en_US.UTF-8
 
@@ -86,32 +87,32 @@ VOLUME /opt/verifier
       EOF
     end
 
-    def create_data_image
+    def create_data_image(registry)
       return if ::Docker::Image.exist?(data_image)
 
       tmpdir = Dir.tmpdir
       FileUtils.mkdir_p "#{tmpdir}/dokken"
-      File.write("#{tmpdir}/dokken/Dockerfile", data_dockerfile)
+      File.write("#{tmpdir}/dokken/Dockerfile", data_dockerfile(registry))
       File.write("#{tmpdir}/dokken/authorized_keys", insecure_ssh_public_key)
 
       i = ::Docker::Image.build_from_dir(
         "#{tmpdir}/dokken",
-        'nocache' => true,
-        'rm' => true
+        "nocache" => true,
+        "rm" => true
       )
-      i.tag('repo' => repo(data_image), 'tag' => tag(data_image), 'force' => true)
+      i.tag("repo" => repo(data_image), "tag" => tag(data_image), "force" => true)
     end
 
     def default_docker_host
-      if ENV['DOCKER_HOST']
-        ENV['DOCKER_HOST']
-      elsif File.exist?('/var/run/docker.sock')
-        'unix:///var/run/docker.sock'
+      if ENV["DOCKER_HOST"]
+        ENV["DOCKER_HOST"]
+      elsif File.exist?("/var/run/docker.sock")
+        "unix:///var/run/docker.sock"
       # TODO: Docker for Windows also operates over a named pipe at
       # //./pipe/docker_engine that can be used if named pipe support is
       # added to the docker-api gem.
       else
-        'tcp://127.0.0.1:2375'
+        "tcp://127.0.0.1:2375"
       end
     end
 
@@ -152,7 +153,8 @@ VOLUME /opt/verifier
       # refs:
       # https://github.com/docker/machine/issues/1814
       # https://github.com/docker/toolbox/issues/607
-      return Dir.home.sub 'C:/Users', '/c/Users' if Dir.home =~ /^C:/ && remote_docker_host?
+      return Dir.home.sub "C:/Users", "/c/Users" if Dir.home =~ /^C:/ && remote_docker_host?
+
       Dir.home
     end
 
@@ -185,7 +187,7 @@ VOLUME /opt/verifier
         x = Array(v).map { |a| parse_port(a) }
         x.flatten!
         x.each_with_object({}) do |y, h|
-          h[y['container_port']] = {}
+          h[y["container_port"]] = {}
         end
       end
     end
@@ -198,52 +200,53 @@ VOLUME /opt/verifier
         x = Array(v).map { |a| parse_port(a) }
         x.flatten!
         x.each_with_object({}) do |y, h|
-          h[y['container_port']] = [] unless h[y['container_port']]
-          h[y['container_port']] << {
-            'HostIp' => y['host_ip'],
-            'HostPort' => y['host_port'],
+          h[y["container_port"]] = [] unless h[y["container_port"]]
+          h[y["container_port"]] << {
+            "HostIp" => y["host_ip"],
+            "HostPort" => y["host_port"],
           }
         end
       end
     end
 
     def parse_port(v)
-      parts = v.split(':')
+      parts = v.split(":")
       case parts.length
       when 3
         host_ip = parts[0]
         host_port = parts[1]
         container_port = parts[2]
       when 2
-        host_ip = '0.0.0.0'
+        host_ip = "0.0.0.0"
         host_port = parts[0]
         container_port = parts[1]
       when 1
-        host_ip = ''
-        host_port = ''
+        host_ip = ""
+        host_port = ""
         container_port = parts[0]
       end
-      port_range, protocol = container_port.split('/')
-      if port_range.include?('-')
-        port_range = container_port.split('-')
+      port_range, protocol = container_port.split("/")
+      if port_range.include?("-")
+        port_range = container_port.split("-")
         port_range.map!(&:to_i)
         Chef::Log.fatal("FATAL: Invalid port range! #{container_port}") if port_range[0] > port_range[1]
         port_range = (port_range[0]..port_range[1]).to_a
       end
       # qualify the port-binding protocol even when it is implicitly tcp #427.
-      protocol = 'tcp' if protocol.nil?
+      protocol = "tcp" if protocol.nil?
       Array(port_range).map do |port|
         {
-          'host_ip' => host_ip,
-          'host_port' => host_port,
-          'container_port' => "#{port}/#{protocol}",
+          "host_ip" => host_ip,
+          "host_port" => host_port,
+          "container_port" => "#{port}/#{protocol}",
         }
       end
     end
 
     def remote_docker_host?
-      return false if config[:docker_info]['OperatingSystem'].include?('Boot2Docker')
-      return true if config[:docker_host_url] =~ /^tcp:/
+      return false if config[:docker_info]["OperatingSystem"].include?("Boot2Docker")
+      return true if /^tcp:/.match?(config[:docker_host_url])
+
       false
     end
 
@@ -252,13 +255,13 @@ VOLUME /opt/verifier
     end
 
     def sandbox_dirs
-      Dir.glob(File.join(sandbox_path, '*'))
+      Dir.glob(File.join(sandbox_path, "*"))
     end
 
     def create_sandbox
       info("Creating kitchen sandbox in #{sandbox_path}")
       unless ::Dir.exist?(sandbox_path)
-        FileUtils.mkdir_p(sandbox_path, :mode => 0o755)
+        FileUtils.mkdir_p(sandbox_path, mode: 0o755)
       end
     end
   end
@@ -269,7 +272,7 @@ module Kitchen
     class Base
       def create_sandbox
         info("Creating kitchen sandbox in #{sandbox_path}")
-        FileUtils.mkdir_p(sandbox_path, :mode => 0o755)
+        FileUtils.mkdir_p(sandbox_path, mode: 0o755)
       end
 
       # this MUST be named 'sandbox_path' because ruby.
@@ -291,7 +294,7 @@ module Kitchen
       def create_sandbox
         info("Creating kitchen sandbox in #{sandbox_path}")
         unless ::Dir.exist?(sandbox_path)
-          FileUtils.mkdir_p(sandbox_path, :mode => 0o755)
+          FileUtils.mkdir_p(sandbox_path, mode: 0o755)
         end
       end
 
@@ -313,7 +316,7 @@ module Kitchen
             conn.execute(init_command)
             info("Transferring files to #{instance.to_str}")
             conn.upload(sandbox_dirs, config[:root_path])
-            debug('Transfer complete')
+            debug("Transfer complete")
           end
 
           conn.execute(prepare_command)

data/lib/kitchen/provisioner/dokken.rb

@@ -15,9 +15,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen'
-require 'kitchen/provisioner/chef_zero'
-require_relative '../helpers'
+require "kitchen"
+require "kitchen/provisioner/chef_zero"
+require_relative "../helpers"
 
 include Dokken::Helpers
 
@@ -29,11 +29,12 @@ module Kitchen
 
       plugin_version Kitchen::VERSION
 
-      default_config :root_path, '/opt/kitchen'
-      default_config :chef_binary, '/opt/chef/bin/chef-client'
-      default_config :chef_options, ' -z'
-      default_config :chef_log_level, 'warn'
-      default_config :chef_output_format, 'doc'
+      default_config :root_path, "/opt/kitchen"
+      default_config :chef_binary, "/opt/chef/bin/chef-client"
+      default_config :chef_options, " -z"
+      default_config :chef_log_level, "warn"
+      default_config :chef_output_format, "doc"
+      default_config :profile_ruby, false
       default_config :docker_info, docker_info
       default_config :docker_host_url, default_docker_host
 
@@ -45,7 +46,7 @@ module Kitchen
       # driver and set it here. If we remove this, users will set their chef_version
       # to 14 in the driver and still get prompted for license acceptance because
       # the ChefZero provisioner defaults product_version to 'latest'.
-      default_config :product_name, 'chef'
+      default_config :product_name, "chef"
       default_config :product_version do |provisioner|
         driver = provisioner.instance.driver
         driver[:chef_version]
@@ -73,15 +74,16 @@ module Kitchen
       rescue Kitchen::Transport::TransportFailed => ex
         raise ActionFailed, ex.message
       ensure
-        return unless config[:clean_dokken_sandbox]
+        return unless config[:clean_dokken_sandbox] # rubocop: disable Lint/EnsureReturn
+
         cleanup_dokken_sandbox
       end
 
       def validate_config
         # check if we have an space for the user provided options
         # or add it if not to avoid issues
-        unless config[:chef_options].start_with? ' '
-          config[:chef_options].prepend(' ')
+        unless config[:chef_options].start_with? " "
+          config[:chef_options].prepend(" ")
         end
 
         # strip spaces from all other options
@@ -91,8 +93,8 @@ module Kitchen
 
         # if the user wants to be funny and pass empty strings
         # just use the defaults
-        config[:chef_log_level] = 'warn' if config[:chef_log_level].empty?
-        config[:chef_output_format] = 'doc' if config[:chef_output_format].empty?
+        config[:chef_log_level] = "warn" if config[:chef_log_level].empty?
+        config[:chef_output_format] = "doc" if config[:chef_output_format].empty?
       end
 
       private
@@ -104,8 +106,9 @@ module Kitchen
         cmd << config[:chef_options].to_s
         cmd << " -l #{config[:chef_log_level]}"
         cmd << " -F #{config[:chef_output_format]}"
-        cmd << ' -c /opt/kitchen/client.rb'
-        cmd << ' -j /opt/kitchen/dna.json'
+        cmd << " -c /opt/kitchen/client.rb"
+        cmd << " -j /opt/kitchen/dna.json"
+        cmd << "--profile-ruby" if config[:profile_ruby]
 
         chef_cmd(cmd)
       end

data/lib/kitchen/transport/dokken.rb

@@ -15,11 +15,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen'
-require 'net/scp'
-require 'tmpdir'
-require 'digest/sha1'
-require_relative '../helpers'
+require "kitchen"
+require "net/scp"
+require "tmpdir" unless defined?(Dir.mktmpdir)
+require "digest/sha1" unless defined?(Digest::SHA1)
+require_relative "../helpers"
 
 include Dokken::Helpers
 
@@ -44,7 +44,7 @@ module Kitchen
       default_config :read_timeout, 3600
       default_config :write_timeout, 3600
       default_config :host_ip_override do |transport|
-        transport.docker_for_mac_or_win? ? 'localhost' : false
+        transport.docker_for_mac_or_win? ? "localhost" : false
       end
 
       # (see Base#connection)
@@ -69,7 +69,7 @@ module Kitchen
 
           with_retries { @runner = ::Docker::Container.get(instance_name, {}, docker_connection) }
           with_retries do
-            o = @runner.exec(Shellwords.shellwords(command), wait: options[:timeout], 'e' => { 'TERM' => 'xterm' }) { |_stream, chunk| print chunk.to_s }
+            o = @runner.exec(Shellwords.shellwords(command), wait: options[:timeout], "e" => { "TERM" => "xterm" }) { |_stream, chunk| print chunk.to_s }
             @exit_code = o[2]
           end
 
@@ -82,26 +82,26 @@ module Kitchen
             ssh_ip = options[:host_ip_override]
             ssh_port = options[:data_container][:NetworkSettings][:Ports][:"22/tcp"][0][:HostPort]
 
-          elsif options[:docker_host_url] =~ /unix:/
-            if options[:data_container][:NetworkSettings][:Ports][:"22/tcp"][0][:HostIp] == '0.0.0.0'
+          elsif /unix:/.match?(options[:docker_host_url])
+            if options[:data_container][:NetworkSettings][:Ports][:"22/tcp"][0][:HostIp] == "0.0.0.0"
               ssh_ip = options[:data_container][:NetworkSettings][:IPAddress]
-              ssh_port = '22'
+              ssh_port = "22"
             else
               # we should read the proper mapped ip, since this allows us to upload the files
               ssh_ip = options[:data_container][:NetworkSettings][:Ports][:"22/tcp"][0][:HostIp]
               ssh_port = options[:data_container][:NetworkSettings][:Ports][:"22/tcp"][0][:HostPort]
             end
 
-          elsif options[:docker_host_url] =~ /tcp:/
+          elsif /tcp:/.match?(options[:docker_host_url])
             name = options[:data_container][:Name]
 
             # DOCKER_HOST
-            docker_host_url_ip = options[:docker_host_url].split('tcp://')[1].split(':')[0]
+            docker_host_url_ip = options[:docker_host_url].split("tcp://")[1].split(":")[0]
 
             # mapped IP of data container
-            candidate_ip = ::Docker::Container.all.select do |x|
-              x.info['Names'][0].eql?(name)
-            end.first.info['NetworkSettings']['Networks']['dokken']['IPAddress']
+            candidate_ip = ::Docker::Container.all.find do |x|
+              x.info["Names"][0].eql?(name)
+            end.info["NetworkSettings"]["Networks"]["dokken"]["IPAddress"]
 
             # mapped port
             candidate_ssh_port = options[:data_container][:NetworkSettings][:Ports][:"22/tcp"][0][:HostPort]
@@ -114,22 +114,22 @@ module Kitchen
               ssh_ip = candidate_ip
               ssh_port = candidate_ssh_port
 
-            elsif port_open?(candidate_ip, '22')
+            elsif port_open?(candidate_ip, "22")
               ssh_ip = candidate_ip
-              ssh_port = '22'
+              ssh_port = "22"
               debug "candidate_ip - #{candidate_ip}/22 open"
             else
               ssh_ip = docker_host_url_ip
               ssh_port = candidate_ssh_port
             end
           else
-            raise Kitchen::UserError, 'docker_host_url must be tcp:// or unix://'
+            raise Kitchen::UserError, "docker_host_url must be tcp:// or unix://"
           end
 
           debug "ssh_ip : #{ssh_ip}"
           debug "ssh_port : #{ssh_port}"
 
-          tmpdir = Dir.tmpdir + '/dokken/'
+          tmpdir = Dir.tmpdir + "/dokken/"
           FileUtils.mkdir_p tmpdir.to_s, mode: 0o777
           tmpdir += Process.uid.to_s
           FileUtils.mkdir_p tmpdir.to_s
@@ -137,26 +137,26 @@ module Kitchen
           FileUtils.chmod(0o600, "#{tmpdir}/id_rsa")
 
           begin
-            rsync_cmd = '/usr/bin/rsync -a -e'
-            rsync_cmd << ' \''
-            rsync_cmd << 'ssh -2'
+            rsync_cmd = "/usr/bin/rsync -a -e"
+            rsync_cmd << " '"
+            rsync_cmd << "ssh -2"
             rsync_cmd << " -i #{tmpdir}/id_rsa"
-            rsync_cmd << ' -o CheckHostIP=no'
-            rsync_cmd << ' -o Compression=no'
-            rsync_cmd << ' -o PasswordAuthentication=no'
-            rsync_cmd << ' -o StrictHostKeyChecking=no'
-            rsync_cmd << ' -o UserKnownHostsFile=/dev/null'
-            rsync_cmd << ' -o LogLevel=ERROR'
+            rsync_cmd << " -o CheckHostIP=no"
+            rsync_cmd << " -o Compression=no"
+            rsync_cmd << " -o PasswordAuthentication=no"
+            rsync_cmd << " -o StrictHostKeyChecking=no"
+            rsync_cmd << " -o UserKnownHostsFile=/dev/null"
+            rsync_cmd << " -o LogLevel=ERROR"
             rsync_cmd << " -p #{ssh_port}"
-            rsync_cmd << '\''
-            rsync_cmd << " #{locals.join(' ')} root@#{ssh_ip}:#{remote}"
+            rsync_cmd << "'"
+            rsync_cmd << " #{locals.join(" ")} root@#{ssh_ip}:#{remote}"
             debug "rsync_cmd :#{rsync_cmd}:"
             `#{rsync_cmd}`
           rescue Errno::ENOENT
-            debug 'Rsync is not installed. Falling back to SCP.'
+            debug "Rsync is not installed. Falling back to SCP."
             locals.each do |local|
               Net::SCP.upload!(ssh_ip,
-                               'root',
+                               "root",
                                local,
                                remote,
                                recursive: true,
@@ -169,8 +169,8 @@ module Kitchen
           @runner = options[:instance_name].to_s
           cols = `tput cols`
           lines = `tput lines`
-          args = ['exec', '-e', "COLUMNS=#{cols}", '-e', "LINES=#{lines}", '-it', @runner, '/bin/bash', '-login', '-i']
-          LoginCommand.new('docker', args)
+          args = ["exec", "-e", "COLUMNS=#{cols}", "-e", "LINES=#{lines}", "-it", @runner, "/bin/bash", "-login", "-i"]
+          LoginCommand.new("docker", args)
         end
 
         private
@@ -181,6 +181,7 @@ module Kitchen
 
         def work_image
           return "#{image_prefix}/#{instance_name}" unless image_prefix.nil?
+
           instance_name
         end
 
@@ -208,7 +209,7 @@ module Kitchen
       #
       # @return [TrueClass,FalseClass]
       def docker_for_mac_or_win?
-        ::Docker.info(::Docker::Connection.new(config[:docker_host_url], {}))['Name'] == 'moby'
+        ::Docker.info(::Docker::Connection.new(config[:docker_host_url], {}))["Name"] == "moby"
       rescue
         false
       end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-dokken
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.12.1
 platform: ruby
 authors:
 - Sean OMeara
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-14 00:00:00.000000000 Z
+date: 2021-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docker-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.33'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.33'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: lockfile
   requirement: !ruby/object:Gem::Requirement
@@ -58,7 +64,8 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
-description: A Test Kitchen Driver for Dokken
+description: A Test Kitchen Driver for Docker & Chef Infra optimized for rapid testing
+  using Chef Infra docker images
 email:
 - sean@sean.io
 executables: []
@@ -83,16 +90,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: A Test Kitchen Driver that talks to the Docker Remote API and uses Volumes
-  to produce sparse container images
+summary: A Test Kitchen Driver for Docker & Chef Infra optimized for rapid testing
+  using Chef Infra docker images
 test_files: []