test-kitchen 1.4.2 → 1.5.0

data/lib/kitchen/transport/winrm.rb

@@ -24,9 +24,7 @@ require "uri"
 require "kitchen"
 
 module Kitchen
-
   module Transport
-
     # Wrapped exception for any internally raised WinRM-related errors.
     #
     # @author Fletcher Nichol <fnichol@nichol.ca>
@@ -38,19 +36,43 @@ module Kitchen
     # @author Salim Afiune <salim@afiunemaya.com.mx>
     # @author Fletcher Nichol <fnichol@nichol.ca>
     class Winrm < Kitchen::Transport::Base
-
       kitchen_transport_api_version 1
 
       plugin_version Kitchen::VERSION
 
-      default_config :port, 5985
       default_config :username, "administrator"
       default_config :password, nil
-      default_config :endpoint_template, "http://%{hostname}:%{port}/wsman"
       default_config :rdp_port, 3389
       default_config :connection_retries, 5
       default_config :connection_retry_sleep, 1
       default_config :max_wait_until_ready, 600
+      default_config :winrm_transport, "plaintext"
+      default_config :port do |transport|
+        transport[:winrm_transport] == :ssl ? 5986 : 5985
+      end
+      default_config :endpoint_template do |transport|
+        scheme = transport[:winrm_transport] == :ssl ? "https" : "http"
+        "#{scheme}://%{hostname}:%{port}/wsman"
+      end
+
+      def finalize_config!(instance)
+        super
+
+        transport = config[:winrm_transport].to_sym
+        config[:winrm_transport] =
+         case transport
+         when :sspinegotiate
+           if host_os_windows?
+             transport
+           else
+             :plaintext
+           end
+         else
+           transport
+         end
+
+        self
+      end
 
       # (see Base#connection)
       def connection(state, &block)
@@ -70,7 +92,6 @@ module Kitchen
       #
       # @author Fletcher Nichol <fnichol@nichol.ca>
       class Connection < Kitchen::Transport::Base::Connection
-
         # (see Base::Connection#close)
         def close
           return if @session.nil?
@@ -87,6 +108,10 @@ module Kitchen
         def execute(command)
           return if command.nil?
           logger.debug("[WinRM] #{self} (#{command})")
+
+          if command.length > MAX_COMMAND_SIZE
+            command = run_from_file_command(command)
+          end
           exit_code, stderr = execute_with_exit_code(command)
 
           if logger.debug? && exit_code == 0
@@ -108,7 +133,7 @@ module Kitchen
           when /linux/
             login_command_for_linux
           else
-            raise ActionFailed, "Remote login not supported in #{self.class} " \
+            fail ActionFailed, "Remote login not supported in #{self.class} " \
               "from host OS '#{RbConfig::CONFIG["host_os"]}'."
           end
         end
@@ -122,9 +147,9 @@ module Kitchen
         def wait_until_ready
           delay = 3
           session(
-            :retries  => max_wait_until_ready / delay,
-            :delay    => delay,
-            :message  => "Waiting for WinRM service on #{endpoint}, " \
+            :retries => max_wait_until_ready / delay,
+            :delay => delay,
+            :message => "Waiting for WinRM service on #{endpoint}, " \
               "retrying in #{delay} seconds"
           )
           execute(PING_COMMAND.dup)
@@ -134,9 +159,14 @@ module Kitchen
 
         PING_COMMAND = "Write-Host '[WinRM] Established\n'".freeze
 
+        # Maximum string to send to the transport to execute. WinRM has an 8000 character
+        # command line limit. The original command string is coverted to a base 64 encoded
+        # UTF-16 string which will double the string size.
+        MAX_COMMAND_SIZE = 3000
+
         RESCUE_EXCEPTIONS_ON_ESTABLISH = lambda do
           [
-            Errno::EACCES, Errno::EADDRINUSE, Errno::ECONNREFUSED,
+            Errno::EACCES, Errno::EADDRINUSE, Errno::ECONNREFUSED, Errno::ETIMEDOUT,
             Errno::ECONNRESET, Errno::ENETUNREACH, Errno::EHOSTUNREACH,
             ::WinRM::WinRMHTTPTransportError, ::WinRM::WinRMAuthorizationError,
             HTTPClient::KeepAliveDisconnected,
@@ -290,9 +320,9 @@ module Kitchen
         # @return [LoginCommand] a login command
         # @api private
         def login_command_for_linux
-          args  = %W[ -u #{options[:user]} ]
-          args += %W[ -p #{options[:pass]} ] if options.key?(:pass)
-          args += %W[ #{URI.parse(endpoint).host}:#{rdp_port} ]
+          args  = %W[-u #{options[:user]}]
+          args += %W[-p #{options[:pass]}] if options.key?(:pass)
+          args += %W[#{URI.parse(endpoint).host}:#{rdp_port}]
 
           LoginCommand.new("rdesktop", args)
         end
@@ -364,7 +394,7 @@ module Kitchen
         def session(retry_options = {})
           @session ||= establish_shell({
             :retries => connection_retries.to_i,
-            :delay   => connection_retry_sleep.to_i
+            :delay => connection_retry_sleep.to_i
           }.merge(retry_options))
         end
 
@@ -375,11 +405,36 @@ module Kitchen
         def to_s
           "#{winrm_transport}::#{endpoint}<#{options.inspect}>"
         end
+
+        # takes a long (greater than 3000 characters) command and saves it to a
+        # file and uploads it to the test instance.
+        #
+        # @param command [String] a long command to be saved and uploaded
+        # @return [String] a command that executes the uploaded script
+        # @api private
+        def run_from_file_command(command)
+          temp_dir = Dir.mktmpdir("kitchen-long-script")
+          begin
+            script_name = "#{instance_name}-long_script.ps1"
+            script_path = File.join(temp_dir, script_name)
+
+            File.open(script_path, "wb") do |file|
+              file.write(command)
+            end
+
+            target_path = File.join("$env:TEMP", "kitchen")
+            upload(script_path, target_path)
+
+            %{& "#{File.join(target_path, script_name)}"}
+          ensure
+            FileUtils.rmtree(temp_dir)
+          end
+        end
       end
 
       private
 
-      WINRM_TRANSPORT_SPEC_VERSION = "~> 1.0".freeze
+      WINRM_TRANSPORT_SPEC_VERSION = ["~> 1.0", ">= 1.0.3"].freeze
 
       # Builds the hash of options needed by the Connection object on
       # construction.
@@ -389,24 +444,38 @@ module Kitchen
       # @api private
       def connection_options(data)
         opts = {
-          :instance_name          => instance.name,
-          :kitchen_root           => data[:kitchen_root],
-          :logger                 => logger,
-          :winrm_transport        => :plaintext,
-          :disable_sspi           => true,
-          :basic_auth_only        => true,
-          :endpoint               => data[:endpoint_template] % data,
-          :user                   => data[:username],
-          :pass                   => data[:password],
-          :rdp_port               => data[:rdp_port],
-          :connection_retries     => data[:connection_retries],
+          :instance_name => instance.name,
+          :kitchen_root => data[:kitchen_root],
+          :logger => logger,
+          :endpoint => data[:endpoint_template] % data,
+          :user => data[:username],
+          :pass => data[:password],
+          :rdp_port => data[:rdp_port],
+          :connection_retries => data[:connection_retries],
           :connection_retry_sleep => data[:connection_retry_sleep],
-          :max_wait_until_ready   => data[:max_wait_until_ready]
+          :max_wait_until_ready => data[:max_wait_until_ready],
+          :winrm_transport => data[:winrm_transport]
         }
-
+        opts.merge!(additional_transport_args(opts[:winrm_transport]))
         opts
       end
 
+      def additional_transport_args(transport_type)
+        case transport_type
+        when :ssl, :sspinegotiate
+          {
+            :no_ssl_peer_verification => true,
+            :disable_sspi => false,
+            :basic_auth_only => false
+          }
+        when :plaintext
+          {
+            :disable_sspi => true,
+            :basic_auth_only => true
+          }
+        end
+      end
+
       # Creates a new WinRM Connection instance and save it for potential
       # future reuse.
       #
@@ -424,41 +493,90 @@ module Kitchen
       end
 
       # (see Base#load_needed_dependencies!)
-      def load_needed_dependencies! # rubocop:disable Metrics/MethodLength
+      def load_needed_dependencies!
         super
-        spec_version = WINRM_TRANSPORT_SPEC_VERSION.dup
-        logger.debug("Winrm Transport requested," \
-          " loading WinRM::Transport gem (#{spec_version})")
-        gem "winrm-transport", spec_version
-        first_load = require "winrm/transport/version"
         load_winrm_transport!
-
-        version = ::WinRM::Transport::VERSION
-        if first_load
-          logger.debug("WinRM::Transport #{version} library loaded")
-        else
-          logger.debug("WinRM::Transport #{version} previously loaded")
-        end
-      rescue LoadError => e
-        logger.fatal("The `winrm-transport' gem is missing and must" \
-          " be installed or cannot be properly activated. Run" \
-          " `gem install winrm-transport --version '#{spec_version}'`" \
-          " or add the following to your Gemfile if you are using Bundler:" \
-          " `gem 'winrm-transport', '#{spec_version}'`.")
-        raise UserError,
-          "Could not load or activate WinRM::Transport (#{e.message})"
+        load_winrm_s! if host_os_windows?
       end
 
       # Load WinRM::Transport code.
       #
       # @api private
       def load_winrm_transport!
+        spec_version = WINRM_TRANSPORT_SPEC_VERSION.dup
+        options = {
+          :load_msg => "Winrm Transport requested," \
+          " loading WinRM::Transport gem (#{spec_version})",
+          :success_msg => "WinRM::Transport library loaded",
+          :already_msg => "WinRM::Transport previously loaded",
+          :name => "winrm-transport",
+          :version => spec_version
+        }
+
+        load_with_rescue!(options) do
+          gem "winrm-transport", WINRM_TRANSPORT_SPEC_VERSION.dup
+          require "winrm/transport/version"
+        end
+
         silence_warnings { require "winrm" }
         require "winrm/transport/shell_closer"
         require "winrm/transport/command_executor"
         require "winrm/transport/file_transporter"
       end
 
+      def load_winrm_s!
+        options = {
+          :load_msg => "The winrm-s gem is being loaded" \
+          " to enable sspiauthentication.",
+          :success_msg => "winrm-s is loaded." \
+            "  sspinegotiate auth is now available.",
+          :already_msg => "winrm-s was already loaded.",
+          :name => "winrm-s"
+        }
+
+        load_with_rescue!(options) { require "winrm-s" }
+      end
+
+      def load_with_rescue!(options = {}, &block)
+        logger.debug(options[:load_msg])
+        attempt_load = execute_block(&block)
+        if attempt_load
+          logger.debug(options[:success_msg])
+        else
+          logger.debug(options[:already_msg])
+        end
+      rescue LoadError => e
+        message = fail_to_load_gem_message(options[:name],
+          options[:version])
+        logger.fatal(message)
+        raise UserError,
+          "Could not load or activate #{options[:name]}. (#{e.message})"
+      end
+
+      def execute_block
+        yield if block_given?
+      end
+
+      def fail_to_load_gem_message(name, version = nil)
+        version_cmd = "--version '#{version}'" if version
+        version_file = "', '#{version}"
+
+        "The `#{name}` gem is missing and must" \
+          " be installed or cannot be properly activated. Run" \
+          " `gem install #{name} #{version_cmd}`" \
+          " or add the following to your Gemfile if you are using Bundler:" \
+          " `gem '#{name} #{version_file}'`."
+      end
+
+      def host_os_windows?
+        case RbConfig::CONFIG["host_os"]
+        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+          true
+        else
+          false
+        end
+      end
+
       # Return the last saved WinRM connection instance.
       #
       # @return [Winrm::Connection] a WinRM Connection instance

data/lib/kitchen/verifier/base.rb

@@ -33,8 +33,8 @@ module Kitchen
       include Logging
 
       default_config :http_proxy, nil
-
       default_config :https_proxy, nil
+      default_config :ftp_proxy, nil
 
       default_config :root_path do |verifier|
         verifier.windows_os? ? "$env:TEMP\\verifier" : "/tmp/verifier"
@@ -44,10 +44,14 @@ module Kitchen
         verifier.windows_os? ? nil : true
       end
 
+      default_config :chef_omnibus_root, "/opt/chef"
+
       default_config :sudo_command do |verifier|
         verifier.windows_os? ? nil : "sudo -E"
       end
 
+      default_config :command_prefix, nil
+
       default_config(:suite_name) { |busser| busser.instance.suite.name }
 
       # Creates a new Verifier object using the provided configuration data
@@ -213,6 +217,19 @@ module Kitchen
       def sudo(script)
         config[:sudo] ? "#{config[:sudo_command]} #{script}" : script
       end
+
+      # Conditionally prefixes a command with a command prefix.
+      # This should generally be done after a command has been
+      # conditionally prefixed by #sudo as certain platforms, such as
+      # Cisco Nexus, require all commands to be run with a prefix to
+      # obtain outbound network access.
+      #
+      # @param command [String] command to be prefixed
+      # @return [String] the command, conditionally prefixed with the configured prefix
+      # @api private
+      def prefix_command(script)
+        config[:command_prefix] ? "#{config[:command_prefix]} #{script}" : script
+      end
     end
   end
 end

data/lib/kitchen/verifier/busser.rb

@@ -46,7 +46,7 @@ module Kitchen
         if verifier.windows_os?
           "$env:systemdrive\\opscode\\chef\\embedded\\bin"
         else
-          "/opt/chef/embedded/bin"
+          verifier.remote_path_join(%W[#{verifier[:chef_omnibus_root]} embedded bin])
         end
       end
 
@@ -76,7 +76,7 @@ module Kitchen
         cmd = sudo(config[:busser_bin]).dup.
           tap { |str| str.insert(0, "& ") if powershell_shell? }
 
-        wrap_shell_code(Util.outdent!(<<-CMD))
+        prefix_command(wrap_shell_code(Util.outdent!(<<-CMD)))
           #{busser_env}
 
           #{cmd} suite cleanup
@@ -89,7 +89,7 @@ module Kitchen
 
         vars = install_command_vars
 
-        shell_code_from_file(vars, "busser_install_command")
+        prefix_command(shell_code_from_file(vars, "busser_install_command"))
       end
 
       # (see Base#run_command)
@@ -99,7 +99,7 @@ module Kitchen
         cmd = sudo(config[:busser_bin]).dup.
           tap { |str| str.insert(0, "& ") if powershell_shell? }
 
-        wrap_shell_code(Util.outdent!(<<-CMD))
+        prefix_command(wrap_shell_code(Util.outdent!(<<-CMD)))
           #{busser_env}
 
           #{cmd} test
@@ -173,9 +173,16 @@ module Kitchen
         gem, version = config[:version].split("@")
         gem, version = "busser", gem if gem =~ /^\d+\.\d+\.\d+/
 
+        root = config[:root_path]
+        gem_bin = remote_path_join(root, "bin")
+
+        # We don't want the gems to be installed in the home directory,
+        # this will force the bindir and the gem install location both
+        # to be under /tmp/verifier
         args = gem
         args += " --version #{version}" if version
-        args += " --no-rdoc --no-ri"
+        args += " --no-rdoc --no-ri --no-format-executable -n #{gem_bin}"
+        args += " --no-user-install"
         args
       end
 

data/lib/kitchen/verifier/shell.rb

@@ -0,0 +1,101 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: SAWANOBORI Yukihiko (<sawanoboriyu@higanworks.com>)
+#
+# Copyright (C) 2015, HiganWorks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "kitchen/verifier/base"
+
+module Kitchen
+
+  module Verifier
+
+    # Shell verifier for Kitchen. This verifier just execute shell command from local.
+    #
+    # @author SAWANOBORI Yukihiko (<sawanoboriyu@higanworks.com>)
+    class Shell < Kitchen::Verifier::Base
+      require "mixlib/shellout"
+
+      kitchen_verifier_api_version 1
+
+      plugin_version Kitchen::VERSION
+
+      default_config :sleep, 0
+      default_config :command, "true"
+      default_config :shellout_opts, {}
+      default_config :live_stream, $stdout
+      default_config :remote_exec, false
+
+      # (see Base#call)
+      def call(state)
+        info("[#{name}] Verify on instance=#{instance} with state=#{state}")
+        sleep_if_set
+        merge_state_to_env(state)
+        if config[:remote_exec]
+          instance.transport.connection(state) do |conn|
+            conn.execute(config[:command])
+          end
+        else
+          shellout
+        end
+        debug("[#{name}] Verify completed.")
+      end
+
+      # for legacy drivers.
+      def run_command
+        if config[:remote_exec]
+          config[:command]
+        else
+          shellout
+          nil
+        end
+      end
+
+      private
+
+      # Sleep for a period of time, if a value is set in the config.
+      #
+      # @api private
+      def sleep_if_set
+        config[:sleep].to_i.times do
+          info(".")
+          sleep 1
+        end
+      end
+
+      def shellout
+        cmd = Mixlib::ShellOut.new(config[:command], config[:shellout_opts])
+        cmd.live_stream = config[:live_stream]
+        cmd.run_command
+        begin
+          cmd.error!
+        rescue Mixlib::ShellOut::ShellCommandFailed
+          raise ActionFailed, "Action #verify failed for #{instance.to_str}."
+        end
+      end
+
+      def merge_state_to_env(state)
+        env_state = { :environment => {} }
+        env_state[:environment]["KITCHEN_INSTANCE"] = instance.name
+        env_state[:environment]["KITCHEN_PLATFORM"] = instance.platform.name
+        env_state[:environment]["KITCHEN_SUITE"] = instance.suite.name
+        state.each_pair do |key, value|
+          env_state[:environment]["KITCHEN_" + key.to_s.upcase] = value
+        end
+        config[:shellout_opts].merge!(env_state)
+      end
+    end
+  end
+end

data/lib/kitchen/version.rb

@@ -17,6 +17,5 @@
 # limitations under the License.
 
 module Kitchen
-
-  VERSION = "1.4.2"
+  VERSION = "1.5.0"
 end

data/spec/kitchen/collection_spec.rb

@@ -58,7 +58,7 @@ describe Kitchen::Collection do
       result.get_all(/one/).size.must_equal 1
     end
 
-    it "returns an empty Collection if on matches are found" do
+    it "returns an empty Collection if no matches are found" do
       result = collection.get_all(/noppa/)
       result.must_equal []
       result.get("nahuh").must_be_nil