kitchen-docker 3.0.0 → 3.2.3

data/lib/kitchen/docker/container/linux.rb

@@ -11,13 +11,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'base64'
-require 'openssl'
-require 'securerandom'
-require 'shellwords'
+require "base64" unless defined?(Base64)
+require "openssl" unless defined?(OpenSSL)
+require "securerandom" unless defined?(SecureRandom)
+require "shellwords" unless defined?(Shellwords)
 
-require_relative '../container'
-require_relative '../helpers/dockerfile_helper'
+require_relative "../container"
+require_relative "../helpers/dockerfile_helper"
 
 module Kitchen
   module Docker
@@ -34,7 +34,7 @@ module Kitchen
         def create(state)
           super
 
-          debug('Creating Linux container')
+          debug("Creating Linux container")
           generate_keys
 
           state[:ssh_key] = @config[:private_key]
@@ -58,7 +58,7 @@ module Kitchen
           debug("Uploading temp file #{temp_file} to #{remote_path} on container")
           upload(temp_file, remote_path)
 
-          debug('Deleting temp file from local filesystem')
+          debug("Deleting temp file from local filesystem")
           ::File.delete(temp_file)
 
           # Replace any environment variables used in the path and execute script file
@@ -76,13 +76,13 @@ module Kitchen
           MUTEX_FOR_SSH_KEYS.synchronize do
             if !File.exist?(@config[:public_key]) || !File.exist?(@config[:private_key])
               private_key = OpenSSL::PKey::RSA.new(2048)
-              blobbed_key = Base64.encode64(private_key.to_blob).gsub("\n", '')
+              blobbed_key = Base64.encode64(private_key.to_blob).gsub("\n", "")
               public_key = "ssh-rsa #{blobbed_key} kitchen_docker_key"
-              File.open(@config[:private_key], 'w') do |file|
+              File.open(@config[:private_key], "w") do |file|
                 file.write(private_key)
                 file.chmod(0600)
               end
-              File.open(@config[:public_key], 'w') do |file|
+              File.open(@config[:public_key], "w") do |file|
                 file.write(public_key)
                 file.chmod(0600)
               end
@@ -91,7 +91,7 @@ module Kitchen
         end
 
         def parse_container_ssh_port(output)
-          _host, port = output.split(':')
+          _host, port = output.split(":")
           port.to_i
         rescue => e
           raise ActionFailed, "Could not parse Docker port output for container SSH port. #{e}"
@@ -113,10 +113,10 @@ module Kitchen
           platform = dockerfile_platform
           username = @config[:username]
           public_key = IO.read(@config[:public_key]).strip
-          homedir = username == 'root' ? '/root' : "/home/#{username}"
+          homedir = username == "root" ? "/root" : "/home/#{username}"
           base = dockerfile_base_linux(username, homedir)
 
-          custom = ''
+          custom = ""
           Array(@config[:provision_command]).each do |cmd|
             custom << "RUN #{cmd}\n"
           end
@@ -124,10 +124,10 @@ module Kitchen
           ssh_key = "RUN echo #{Shellwords.escape(public_key)} >> #{homedir}/.ssh/authorized_keys"
 
           # Empty string to ensure the file ends with a newline.
-          output = [from, dockerfile_proxy_config, platform, base, custom, ssh_key, ''].join("\n")
-          debug('--- Start Dockerfile ---')
+          output = [from, dockerfile_proxy_config, platform, base, custom, ssh_key, ""].join("\n")
+          debug("--- Start Dockerfile ---")
           debug(output.strip)
-          debug('--- End Dockerfile ---')
+          debug("--- End Dockerfile ---")
           output
         end
       end

data/lib/kitchen/docker/container/windows.rb

@@ -11,9 +11,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'securerandom'
+require "securerandom" unless defined?(SecureRandom)
 
-require_relative '../container'
+require_relative "../container"
 
 module Kitchen
   module Docker
@@ -26,7 +26,7 @@ module Kitchen
         def create(state)
           super
 
-          debug('Creating Windows container')
+          debug("Creating Windows container")
           state[:username] = @config[:username]
           state[:image_id] = build_image(state, dockerfile) unless state[:image_id]
           state[:container_id] = run_container(state) unless state[:container_id]
@@ -35,19 +35,19 @@ module Kitchen
 
         def execute(command)
           # Create temp script file and upload files to container
-          debug('Executing command on Windows container')
+          debug("Executing command on Windows container")
           filename = "docker-#{::SecureRandom.uuid}.ps1"
           temp_file = ".\\.kitchen\\temp\\#{filename}"
           create_temp_file(temp_file, command)
 
-          remote_path = @config[:temp_dir].tr('/', '\\')
+          remote_path = @config[:temp_dir].tr("/", "\\")
           debug("Creating directory #{remote_path} on container")
           create_dir_on_container(@config, remote_path)
 
           debug("Uploading temp file #{temp_file} to #{remote_path} on container")
           upload(temp_file, remote_path)
 
-          debug('Deleting temp file from local filesystem')
+          debug("Deleting temp file from local filesystem")
           ::File.delete(temp_file)
 
           # Replace any environment variables used in the path and execute script file
@@ -63,20 +63,20 @@ module Kitchen
         protected
 
         def dockerfile
-          raise ActionFailed, "Unknown platform '#{@config[:platform]}'" unless @config[:platform] == 'windows'
+          raise ActionFailed, "Unknown platform '#{@config[:platform]}'" unless @config[:platform] == "windows"
           return dockerfile_template if @config[:dockerfile]
 
           from = "FROM #{@config[:image]}"
 
-          custom = ''
+          custom = ""
           Array(@config[:provision_command]).each do |cmd|
             custom << "RUN #{cmd}\n"
           end
 
-          output = [from, dockerfile_proxy_config, custom, ''].join("\n")
-          debug('--- Start Dockerfile ---')
+          output = [from, dockerfile_proxy_config, custom, ""].join("\n")
+          debug("--- Start Dockerfile ---")
           debug(output.strip)
-          debug('--- End Dockerfile ---')
+          debug("--- End Dockerfile ---")
           output
         end
       end

data/lib/kitchen/docker/container.rb

@@ -11,10 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative 'helpers/cli_helper'
-require_relative 'helpers/container_helper'
-require_relative 'helpers/file_helper'
-require_relative 'helpers/image_helper'
+require_relative "helpers/cli_helper"
+require_relative "helpers/container_helper"
+require_relative "helpers/file_helper"
+require_relative "helpers/image_helper"
 
 module Kitchen
   module Docker
@@ -32,8 +32,8 @@ module Kitchen
         if container_exists?(state)
           info("Container ID #{state[:container_id]} already exists.")
         elsif !container_exists?(state) && state[:container_id]
-          raise ActionFailed, "Container ID #{state[:container_id]} was found in the kitchen state data, "\
-                              'but the container does not exist.'
+          raise ActionFailed, "Container ID #{state[:container_id]} was found in the kitchen state data, " \
+                              "but the container does not exist."
         end
 
         state[:username] = @config[:username]
@@ -49,7 +49,7 @@ module Kitchen
       end
 
       def hostname(state)
-        hostname = 'localhost'
+        hostname = "localhost"
 
         if remote_socket?
           hostname = socket_uri.host

data/lib/kitchen/docker/docker_version.rb

@@ -16,6 +16,6 @@
 module Kitchen
   module Docker
     # Version string for Docker Kitchen driver
-    DOCKER_VERSION = "3.0.0"
+    DOCKER_VERSION = "3.2.3".freeze
   end
 end

data/lib/kitchen/docker/erb_context.rb

@@ -13,14 +13,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'erb'
+require "erb" unless defined?(Erb)
 
 module Kitchen
   module Docker
     class ERBContext
-      def initialize(config={})
+      def initialize(config = {})
         config.each do |key, value|
-          instance_variable_set('@' + key.to_s, value)
+          instance_variable_set("@" + key.to_s, value)
         end
       end
 

data/lib/kitchen/docker/helpers/cli_helper.rb

@@ -11,10 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen'
-require 'kitchen/configurable'
-require 'kitchen/logging'
-require 'kitchen/shell_out'
+require "kitchen"
+require "kitchen/configurable"
+require "kitchen/logging"
+require "kitchen/shell_out"
 
 module Kitchen
   module Docker
@@ -26,11 +26,11 @@ module Kitchen
         include ShellOut
 
         # rubocop:disable Metrics/AbcSize
-        def docker_command(cmd, options={})
+        def docker_command(cmd, options = {})
           docker = config[:binary].dup
           docker << " -H #{config[:socket]}" if config[:socket]
-          docker << ' --tls' if config[:tls]
-          docker << ' --tlsverify' if config[:tls_verify]
+          docker << " --tls" if config[:tls]
+          docker << " --tlsverify" if config[:tls_verify]
           docker << " --tlscacert=#{config[:tls_cacert]}" if config[:tls_cacert]
           docker << " --tlscert=#{config[:tls_cert]}" if config[:tls_cert]
           docker << " --tlskey=#{config[:tls_key]}" if config[:tls_key]
@@ -63,9 +63,9 @@ module Kitchen
 
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/AbcSize
         def build_run_command(image_id, transport_port = nil)
-          cmd = 'run -d'
-          cmd << ' -i' if config[:interactive]
-          cmd << ' -t' if config[:tty]
+          cmd = "run -d"
+          cmd << " -i" if config[:interactive]
+          cmd << " -t" if config[:tty]
           cmd << build_env_variable_args(config[:env_variables]) if config[:env_variables]
           cmd << " -p #{transport_port}" unless transport_port.nil?
           Array(config[:forward]).each { |port| cmd << " -p #{port}" }
@@ -75,21 +75,21 @@ module Kitchen
           Array(config[:volumes_from]).each { |container| cmd << " --volumes-from #{container}" }
           Array(config[:links]).each { |link| cmd << " --link #{link}" }
           Array(config[:devices]).each { |device| cmd << " --device #{device}" }
-          Array(config[:mount]).each {|mount| cmd << " --mount #{mount}"}
-          Array(config[:tmpfs]).each {|tmpfs| cmd << " --tmpfs #{tmpfs}"}
+          Array(config[:mount]).each { |mount| cmd << " --mount #{mount}" }
+          Array(config[:tmpfs]).each { |tmpfs| cmd << " --tmpfs #{tmpfs}" }
           cmd << " --name #{config[:instance_name]}" if config[:instance_name]
-          cmd << ' -P' if config[:publish_all]
+          cmd << " -P" if config[:publish_all]
           cmd << " -h #{config[:hostname]}" if config[:hostname]
           cmd << " -m #{config[:memory]}" if config[:memory]
           cmd << " -c #{config[:cpu]}" if config[:cpu]
           cmd << " --gpus #{config[:gpus]}" if config[:gpus]
           cmd << " -e http_proxy=#{config[:http_proxy]}" if config[:http_proxy]
           cmd << " -e https_proxy=#{config[:https_proxy]}" if config[:https_proxy]
-          cmd << ' --privileged' if config[:privileged]
+          cmd << " --privileged" if config[:privileged]
           cmd << " --isolation #{config[:isolation]}" if config[:isolation]
-          Array(config[:cap_add]).each { |cap| cmd << " --cap-add=#{cap}"} if config[:cap_add]
-          Array(config[:cap_drop]).each { |cap| cmd << " --cap-drop=#{cap}"} if config[:cap_drop]
-          Array(config[:security_opt]).each { |opt| cmd << " --security-opt=#{opt}"} if config[:security_opt]
+          Array(config[:cap_add]).each { |cap| cmd << " --cap-add=#{cap}" } if config[:cap_add]
+          Array(config[:cap_drop]).each { |cap| cmd << " --cap-drop=#{cap}" } if config[:cap_drop]
+          Array(config[:security_opt]).each { |opt| cmd << " --security-opt=#{opt}" } if config[:security_opt]
           cmd << " --platform=#{config[:docker_platform]}" if config[:docker_platform]
           extra_run_options = config_to_options(config[:run_options])
           cmd << " #{extra_run_options}" unless extra_run_options.empty?
@@ -101,12 +101,12 @@ module Kitchen
 
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
         def build_exec_command(state, command)
-          cmd = 'exec'
-          cmd << ' -d' if config[:detach]
+          cmd = "exec"
+          cmd << " -d" if config[:detach]
           cmd << build_env_variable_args(config[:env_variables]) if config[:env_variables]
-          cmd << ' --privileged' if config[:privileged]
-          cmd << ' -t' if config[:tty]
-          cmd << ' -i' if config[:interactive]
+          cmd << " --privileged" if config[:privileged]
+          cmd << " -t" if config[:tty]
+          cmd << " -i" if config[:interactive]
           cmd << " -u #{config[:username]}" if config[:username]
           cmd << " -w #{config[:working_dir]}" if config[:working_dir]
           cmd << " #{state[:container_id]}"
@@ -117,23 +117,23 @@ module Kitchen
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
 
         def build_copy_command(local_file, remote_file, opts = {})
-          cmd = 'cp'
-          cmd << ' -a' if opts[:archive]
+          cmd = "cp"
+          cmd << " -a" if opts[:archive]
           cmd << " #{local_file} #{remote_file}"
           cmd
         end
 
         def build_powershell_command(args)
-          cmd = 'powershell -ExecutionPolicy Bypass -NoLogo '
+          cmd = "powershell -ExecutionPolicy Bypass -NoLogo "
           cmd << args
           logger.debug("build_powershell_command: #{cmd}")
           cmd
         end
 
         def build_env_variable_args(vars)
-          raise ActionFailed, 'Environment variables are not of a Hash type' unless vars.is_a?(Hash)
+          raise ActionFailed, "Environment variables are not of a Hash type" unless vars.is_a?(Hash)
 
-          args = ''
+          args = ""
           vars.each do |k, v|
             args << " -e #{k.to_s.strip}=\"#{v.to_s.strip}\""
           end
@@ -142,11 +142,11 @@ module Kitchen
         end
 
         def dev_null
-          case RbConfig::CONFIG['host_os']
+          case RbConfig::CONFIG["host_os"]
           when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-            'NUL'
+            "NUL"
           else
-            '/dev/null'
+            "/dev/null"
           end
         end
 
@@ -167,13 +167,13 @@ module Kitchen
         def config_to_options(config)
           case config
           when nil
-            ''
+            ""
           when String
             config
           when Array
-            config.map { |c| config_to_options(c) }.join(' ')
+            config.map { |c| config_to_options(c) }.join(" ")
           when Hash
-            config.map { |k, v| Array(v).map { |c| "--#{k}=#{Shellwords.escape(c)}" }.join(' ') }.join(' ')
+            config.map { |k, v| Array(v).map { |c| "--#{k}=#{Shellwords.escape(c)}" }.join(" ") }.join(" ")
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity

data/lib/kitchen/docker/helpers/container_helper.rb

@@ -11,16 +11,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'erb'
-require 'json'
-require 'shellwords'
-require 'tempfile'
-require 'uri'
+require "erb" unless defined?(Erb)
+require "json" unless defined?(JSON)
+require "shellwords" unless defined?(Shellwords)
+require "tempfile" unless defined?(Tempfile)
+require "uri" unless defined?(URI)
 
-require 'kitchen'
-require 'kitchen/configurable'
-require_relative '../erb_context'
-require_relative 'cli_helper'
+require "kitchen"
+require "kitchen/configurable"
+require_relative "../erb_context"
+require_relative "cli_helper"
 
 module Kitchen
   module Docker
@@ -34,7 +34,7 @@ module Kitchen
           container_id = output.chomp
 
           unless [12, 64].include?(container_id.size)
-            raise ActionFailed, 'Could not parse Docker run output for container ID'
+            raise ActionFailed, "Could not parse Docker run output for container ID"
           end
 
           container_id
@@ -47,7 +47,7 @@ module Kitchen
         end
 
         def remote_socket?
-          config[:socket] ? socket_uri.scheme == 'tcp' : false
+          config[:socket] ? socket_uri.scheme == "tcp" : false
         end
 
         def socket_uri
@@ -73,8 +73,8 @@ module Kitchen
           path = replace_env_variables(state, path)
           cmd = "mkdir -p #{path}"
 
-          if state[:platform].include?('windows')
-            psh = "-Command if(-not (Test-Path \'#{path}\')) { New-Item -Path \'#{path}\' -Force }"
+          if state[:platform].include?("windows")
+            psh = "-Command if(-not (Test-Path '#{path}')) { New-Item -Path '#{path}' -Force }"
             cmd = build_powershell_command(psh)
           end
 
@@ -101,15 +101,15 @@ module Kitchen
           # Retrieves all environment variables from inside container
           vars = {}
 
-          if state[:platform].include?('windows')
-            cmd = build_powershell_command('-Command [System.Environment]::GetEnvironmentVariables() ^| ConvertTo-Json')
+          if state[:platform].include?("windows")
+            cmd = build_powershell_command("-Command [System.Environment]::GetEnvironmentVariables() ^| ConvertTo-Json")
             cmd = build_exec_command(state, cmd)
             stdout = docker_command(cmd, suppress_output: !logger.debug?).strip
             vars = ::JSON.parse(stdout)
           else
-            cmd = build_exec_command(state, 'printenv')
+            cmd = build_exec_command(state, "printenv")
             stdout = docker_command(cmd, suppress_output: !logger.debug?).strip
-            stdout.split("\n").each { |line| vars[line.split('=')[0]] = line.split('=')[1] }
+            stdout.split("\n").each { |line| vars[line.split("=")[0]] = line.split("=")[1] }
           end
 
           vars
@@ -117,12 +117,12 @@ module Kitchen
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def replace_env_variables(state, str)
-          if str.include?('$env:')
+          if str.include?("$env:")
             key = str[/\$env:(.*?)(\\|$)/, 1]
             value = container_env_variables(state)[key].to_s.strip
             str = str.gsub("$env:#{key}", value)
-          elsif str.include?('$')
-            key = str[/\$(.*?)(\/|$)/, 1]
+          elsif str.include?("$")
+            key = str[%r{\$(.*?)(/|$)}, 1]
             value = container_env_variables(state)[key].to_s.strip
             str = str.gsub("$#{key}", value)
           end
@@ -141,7 +141,7 @@ module Kitchen
           cmd << " #{state[:container_id]}"
           docker_command(cmd).strip
         rescue
-          raise ActionFailed, 'Error getting internal IP of Docker container'
+          raise ActionFailed, "Error getting internal IP of Docker container"
         end
 
         def remove_container(state)
@@ -150,25 +150,27 @@ module Kitchen
           docker_command("rm #{container_id}")
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def dockerfile_proxy_config
-          env_variables = ''
+          env_variables = ""
           if config[:http_proxy]
-            env_variables << "ENV http_proxy #{config[:http_proxy]}\n"
-            env_variables << "ENV HTTP_PROXY #{config[:http_proxy]}\n"
+            env_variables << "ENV http_proxy=#{config[:http_proxy]}\n"
+            env_variables << "ENV HTTP_PROXY=#{config[:http_proxy]}\n"
           end
 
           if config[:https_proxy]
-            env_variables << "ENV https_proxy #{config[:https_proxy]}\n"
-            env_variables << "ENV HTTPS_PROXY #{config[:https_proxy]}\n"
+            env_variables << "ENV https_proxy=#{config[:https_proxy]}\n"
+            env_variables << "ENV HTTPS_PROXY=#{config[:https_proxy]}\n"
           end
 
           if config[:no_proxy]
-            env_variables << "ENV no_proxy #{config[:no_proxy]}\n"
-            env_variables << "ENV NO_PROXY #{config[:no_proxy]}\n"
+            env_variables << "ENV no_proxy=#{config[:no_proxy]}\n"
+            env_variables << "ENV NO_PROXY=#{config[:no_proxy]}\n"
           end
 
           env_variables
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
       end
       # rubocop:enable Metrics/ModuleLength, Style/Documentation
     end