test-kitchen 1.5.0 → 1.6.0

data/CONTRIBUTING.md

@@ -6,12 +6,9 @@ This release process applies to all Test Kitchen projects, but each project may
 2. Check out the master branch of the project being prepared for release.
 3. Branch into a release-branch of the form `150_release_prep`.
 4. Modify the `version.rb` file to specify the version for releasing.
-5. Update the changelog to include what is being released.
-  1. For these projects we use [PimpMyChangelog](https://github.com/pcreux/pimpmychangelog).  All this does is make the CHANGELOG look pretty - for now we manually import the PRs / Issues and categorize them.
-  2. Start a [diff](https://github.com/test-kitchen/test-kitchen/compare/v1.4.2...master) in Github between master and the last release
-  3. Look for all the merged PRs and add them to the CHANGELOG.md under the appropriate category.  They should have the form `* PR #999: PR Description (@author)`.
-  4. Install and run `pimpmychangelog`.  This should change all the PR numbers and @ mentions into links.
+5. Run `rake changelog` to regenerate the changelog.
 6. `git commit` the `version.rb` and `CHANGELOG.md` changes to the branch and setup a PR for them.  Allow the PR to run any automated tests and review the CHANGELOG for accuracy.
 7. Merge the PR to master after review.
-8. Switch your local copy to the master branch and `git pull` to pull in the release preperation changes.
+8. Switch your local copy to the master branch and `git pull` to pull in the release preparation changes.
 9. Run `rake release` on the master branch.
+10. Modify the `version.rb` file and bump the patch or minor version, and commit/push.

data/Rakefile

@@ -65,3 +65,12 @@ task :deploy_over_dk do
 end
 
 task :dk_install => [:deploy_over_dk, :install]
+
+require "github_changelog_generator/task"
+
+GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+  config.future_release = Kitchen::VERSION
+  config.enhancement_labels = "enhancement,Enhancement,New Feature,Feature".split(",")
+  config.bug_labels = "bug,Bug,Improvement".split(",")
+  config.exclude_labels = %w[Duplicate Question Discussion]
+end

data/lib/kitchen/command/driver_discover.rb

@@ -19,8 +19,12 @@
 require "kitchen/command"
 
 require "rubygems/spec_fetcher"
-require "chef-config/config"
-require "chef-config/workstation_config_loader"
+begin
+  require "chef-config/config"
+  require "chef-config/workstation_config_loader"
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+  # This space left intentionally blank.
+end
 
 module Kitchen
 
@@ -36,8 +40,10 @@ module Kitchen
         # We are introducing the idea of using the Chef configuration as a
         # unified config for all the ChefDK tools.  The first practical
         # implementation of this is 1 location to setup proxy configurations.
-        ChefConfig::WorkstationConfigLoader.new(options[:chef_config_path]).load
-        ChefConfig::Config.export_proxies
+        if defined?(ChefConfig::WorkstationConfigLoader)
+          ChefConfig::WorkstationConfigLoader.new(options[:chef_config_path]).load
+        end
+        ChefConfig::Config.export_proxies if defined?(ChefConfig::Config.export_proxies)
 
         specs = fetch_gem_specs.sort { |x, y| x[0] <=> y[0] }
         specs = specs[0, 49].push(["...", "..."]) if specs.size > 49

data/lib/kitchen/driver/ssh_base.rb

@@ -123,6 +123,10 @@ module Kitchen
         raise ClientError, "#{self.class}#destroy must be implemented"
       end
 
+      def legacy_state(state)
+        backcompat_merged_state(state)
+      end
+
       # (see Base#login_command)
       def login_command(state)
         instance.transport.connection(backcompat_merged_state(state)).

data/lib/kitchen/instance.rb

@@ -391,6 +391,20 @@ module Kitchen
       self
     end
 
+    # returns true, if the verifier is busser
+    def verifier_busser?(verifier)
+      !defined?(Kitchen::Verifier::Busser).nil? && verifier.is_a?(Kitchen::Verifier::Busser)
+    end
+
+    # returns true, if the verifier is dummy
+    def verifier_dummy?(verifier)
+      !defined?(Kitchen::Verifier::Dummy).nil? && verifier.is_a?(Kitchen::Verifier::Dummy)
+    end
+
+    def use_legacy_ssh_verifier?(verifier)
+      verifier_busser?(verifier) || verifier_dummy?(verifier)
+    end
+
     # Perform the verify action.
     #
     # @see Driver::Base#verify
@@ -399,8 +413,12 @@ module Kitchen
     def verify_action
       banner "Verifying #{to_str}..."
       elapsed = action(:verify) do |state|
-        if legacy_ssh_base_driver?
+        # use special handling for legacy driver
+        if legacy_ssh_base_driver? && use_legacy_ssh_verifier?(verifier)
           legacy_ssh_base_verify(state)
+        elsif legacy_ssh_base_driver?
+          # read ssh options from legacy driver
+          verifier.call(driver.legacy_state(state))
         else
           verifier.call(state)
         end

data/lib/kitchen/platform.rb

@@ -44,13 +44,19 @@ module Kitchen
         raise ClientError, "Platform#new requires option :name"
       end
       @os_type = options.fetch(:os_type) do
-        @name.downcase =~ /^win/ ? "windows" : "unix"
+        windows?(options) ? "windows" : "unix"
       end
       @shell_type = options.fetch(:shell_type) do
-        @name.downcase =~ /^win/ ? "powershell" : "bourne"
+        windows?(options) ? "powershell" : "bourne"
       end
     end
 
+    def windows?(options)
+      @name.downcase =~ /^win/ || (
+        !options[:transport].nil? && options[:transport][:name] == "winrm"
+      )
+    end
+
     # Returns a Hash of configuration and other useful diagnostic information.
     #
     # @return [Hash] a diagnostic hash

data/lib/kitchen/provisioner/base.rb

@@ -205,10 +205,18 @@ module Kitchen
       # Conditionally prefixes a command with a sudo command.
       #
       # @param command [String] command to be prefixed
-      # @return [String] the command, conditionaly prefixed with sudo
+      # @return [String] the command, conditionally prefixed with sudo
       # @api private
       def sudo(script)
-        config[:sudo] ? "#{config[:sudo_command]} #{script}" : script
+        "#{sudo_command} #{script}".lstrip
+      end
+
+      # Returns the sudo command to use or empty string if sudo is not configured
+      #
+      # @return [String] the sudo command if sudo config is true
+      # @api private
+      def sudo_command
+        config[:sudo] ? config[:sudo_command].to_s : ""
       end
 
       # Conditionally prefixes a command with a command prefix.

data/lib/kitchen/provisioner/chef_apply.rb

@@ -0,0 +1,125 @@
+# -*- 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.
+
+# Usage:
+#
+# puts your recipes to` apply/` directory.
+#
+# An example of .kitchen.yml.
+#
+# ---
+# driver:
+#   name: vagrant
+#
+# provisioner:
+#   name: chef_apply
+#
+# platforms:
+#   - name: ubuntu-12.04
+#   - name: centos-6.4
+#
+# suites:
+#   - name: default
+#     run_list:
+#       - recipe1
+#       - recipe2
+#
+#
+# The chef-apply runs twice below.
+#
+# chef-apply apply/recipe1.rb
+# chef-apply apply/recipe2.rb
+
+require "kitchen/provisioner/chef_base"
+
+module Kitchen
+
+  module Provisioner
+
+    # Chef Apply provisioner.
+    #
+    # @author SAWANOBORI Yukihiko <sawanoboriyu@higanworks.com>)
+    class ChefApply < ChefBase
+
+      kitchen_provisioner_api_version 2
+
+      plugin_version Kitchen::VERSION
+
+      default_config :chef_apply_path do |provisioner|
+        provisioner.
+          remote_path_join(%W[#{provisioner[:chef_omnibus_root]} bin chef-apply]).
+          tap { |path| path.concat(".bat") if provisioner.windows_os? }
+      end
+
+      default_config :apply_path do |provisioner|
+        provisioner.calculate_path("apply")
+      end
+      expand_path_for :apply_path
+
+      # (see ChefBase#create_sandbox)
+      def create_sandbox
+        @sandbox_path = Dir.mktmpdir("#{instance.name}-sandbox-")
+        File.chmod(0755, sandbox_path)
+        info("Preparing files for transfer")
+        debug("Creating local sandbox in #{sandbox_path}")
+
+        prepare_json
+        prepare(:apply)
+      end
+
+      # (see ChefBase#init_command)
+      def init_command
+        dirs = %w[
+          apply
+        ].sort.map { |dir| remote_path_join(config[:root_path], dir) }
+
+        vars = if powershell_shell?
+          init_command_vars_for_powershell(dirs)
+        else
+          init_command_vars_for_bourne(dirs)
+        end
+
+        prefix_command(shell_code_from_file(vars, "chef_base_init_command"))
+      end
+
+      # (see ChefSolo#run_command)
+      def run_command
+        level = config[:log_level] == :info ? :auto : config[:log_level]
+
+        lines = []
+        config[:run_list].map do |recipe|
+          cmd = sudo(config[:chef_apply_path]).dup.
+            tap { |str| str.insert(0, "& ") if powershell_shell? }
+          args = [
+            "apply/#{recipe}.rb",
+            "--log_level #{level}",
+            "--no-color"
+          ]
+          args << "--logfile #{config[:log_file]}" if config[:log_file]
+
+          lines << wrap_shell_code(
+            [cmd, *args].join(" ").
+            tap { |str| str.insert(0, reload_ps1_path) if windows_os? }
+          )
+        end
+
+        prefix_command(lines.join("\n"))
+      end
+    end
+  end
+end

data/lib/kitchen/provisioner/chef_base.rb

@@ -26,8 +26,12 @@ require "kitchen/provisioner/chef/common_sandbox"
 require "kitchen/provisioner/chef/librarian"
 require "kitchen/util"
 require "mixlib/install"
-require "chef-config/config"
-require "chef-config/workstation_config_loader"
+begin
+  require "chef-config/config"
+  require "chef-config/workstation_config_loader"
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+  # This space left intentionally blank.
+end
 
 module Kitchen
 
@@ -96,10 +100,12 @@ module Kitchen
       def initialize(config = {})
         super(config)
 
-        ChefConfig::WorkstationConfigLoader.new(config[:config_path]).load
+        if defined?(ChefConfig::WorkstationConfigLoader)
+          ChefConfig::WorkstationConfigLoader.new(config[:config_path]).load
+        end
         # This exports any proxy config present in the Chef config to
         # appropriate environment variables, which Test Kitchen respects
-        ChefConfig::Config.export_proxies
+        ChefConfig::Config.export_proxies if defined?(ChefConfig::Config.export_proxies)
       end
 
       # (see Base#create_sandbox)
@@ -149,7 +155,8 @@ module Kitchen
         {
           :omnibus_url => config[:chef_omnibus_url],
           :project => project.nil? ? nil : project[1],
-          :install_flags => config[:chef_omnibus_install_options]
+          :install_flags => config[:chef_omnibus_install_options],
+          :sudo_command => sudo_command
         }.tap do |opts|
           opts[:root] = config[:chef_omnibus_root] if config.key? :chef_omnibus_root
           opts[:http_proxy] = config[:http_proxy] if config.key? :http_proxy

data/lib/kitchen/transport/winrm.rb

@@ -46,7 +46,7 @@ module Kitchen
       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 :winrm_transport, :negotiate
       default_config :port do |transport|
         transport[:winrm_transport] == :ssl ? 5986 : 5985
       end
@@ -58,18 +58,7 @@ module Kitchen
       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
+        config[:winrm_transport] = config[:winrm_transport].to_sym
 
         self
       end
@@ -96,10 +85,7 @@ module Kitchen
         def close
           return if @session.nil?
 
-          shell_id = session.shell
-          logger.debug("[WinRM] closing remote shell #{shell_id} on #{self}")
           session.close
-          logger.debug("[WinRM] remote shell #{shell_id} closed")
         ensure
           @session = nil
         end
@@ -147,10 +133,8 @@ module Kitchen
         def wait_until_ready
           delay = 3
           session(
-            :retries => max_wait_until_ready / delay,
-            :delay => delay,
-            :message => "Waiting for WinRM service on #{endpoint}, " \
-              "retrying in #{delay} seconds"
+            :retry_limit => max_wait_until_ready / delay,
+            :retry_delay => delay
           )
           execute(PING_COMMAND.dup)
         end
@@ -164,16 +148,6 @@ module Kitchen
         # 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::ETIMEDOUT,
-            Errno::ECONNRESET, Errno::ENETUNREACH, Errno::EHOSTUNREACH,
-            ::WinRM::WinRMHTTPTransportError, ::WinRM::WinRMAuthorizationError,
-            HTTPClient::KeepAliveDisconnected,
-            HTTPClient::ConnectTimeoutError
-          ].freeze
-        end
-
         # @return [Integer] how many times to retry when failing to execute
         #   a command or transfer files
         # @api private
@@ -235,31 +209,6 @@ module Kitchen
           end
         end
 
-        # Establish a remote shell session on the remote host.
-        #
-        # @param opts [Hash] retry options
-        # @option opts [Integer] :retries the number of times to retry before
-        #   failing
-        # @option opts [Float] :delay the number of seconds to wait until
-        #   attempting a retry
-        # @option opts [String] :message an optional message to be logged on
-        #   debug (overriding the default) when a rescuable exception is raised
-        # @return [Winrm::CommandExecutor] the command executor session
-        # @api private
-        def establish_shell(opts)
-          service_args = [endpoint, winrm_transport, options]
-          @service = ::WinRM::WinRMWebService.new(*service_args)
-          closer = WinRM::Transport::ShellCloser.new("#{self}", logger.debug?, service_args)
-
-          executor = WinRM::Transport::CommandExecutor.new(@service, logger, closer)
-          retryable(opts) do
-            logger.debug("[WinRM] opening remote shell on #{self}")
-            shell_id = executor.open
-            logger.debug("[WinRM] remote shell #{shell_id} is open on #{self}")
-          end
-          executor
-        end
-
         # Execute a Powershell script over WinRM and return the command's
         # exit code and standard error.
         #
@@ -278,7 +227,7 @@ module Kitchen
         # @return [Winrm::FileTransporter] a file transporter
         # @api private
         def file_transporter
-          @file_transporter ||= WinRM::Transport::FileTransporter.new(session, logger)
+          @file_transporter ||= WinRM::FS::Core::FileTransporter.new(session)
         end
 
         # (see Base#init_options)
@@ -353,38 +302,6 @@ module Kitchen
           File.join(kitchen_root, ".kitchen", "#{instance_name}.rdp")
         end
 
-        # Yields to a block and reties the block if certain rescuable
-        # exceptions are raised.
-        #
-        # @param opts [Hash] retry options
-        # @option opts [Integer] :retries the number of times to retry before
-        #   failing
-        # @option opts [Float] :delay the number of seconds to wait until
-        #   attempting a retry
-        # @option opts [String] :message an optional message to be logged on
-        #   debug (overriding the default) when a rescuable exception is raised
-        # @return [Winrm::CommandExecutor] the command executor session
-        # @api private
-        def retryable(opts)
-          yield
-        rescue *RESCUE_EXCEPTIONS_ON_ESTABLISH.call => e
-          if (opts[:retries] -= 1) > 0
-            message = if opts[:message]
-              logger.debug("[WinRM] connection failed (#{e.inspect})")
-              opts[:message]
-            else
-              "[WinRM] connection failed, " \
-                "retrying in #{opts[:delay]} seconds (#{e.inspect})"
-            end
-            logger.info(message)
-            sleep(opts[:delay])
-            retry
-          else
-            logger.warn("[WinRM] connection failed, terminating (#{e.inspect})")
-            raise
-          end
-        end
-
         # Establishes a remote shell session, or establishes one when invoked
         # the first time.
         #
@@ -392,10 +309,17 @@ module Kitchen
         # @return [Winrm::CommandExecutor] the command executor session
         # @api private
         def session(retry_options = {})
-          @session ||= establish_shell({
-            :retries => connection_retries.to_i,
-            :delay => connection_retry_sleep.to_i
-          }.merge(retry_options))
+          @session ||= begin
+            opts = {
+              :retry_limit => connection_retries.to_i,
+              :retry_delay   => connection_retry_sleep.to_i
+            }.merge(retry_options)
+
+            service_args = [endpoint, winrm_transport, options.merge(opts)]
+            @service = ::WinRM::WinRMWebService.new(*service_args)
+            @service.logger = logger
+            @service.create_executor
+          end
         end
 
         # String representation of object, reporting its connection details and
@@ -425,7 +349,7 @@ module Kitchen
             target_path = File.join("$env:TEMP", "kitchen")
             upload(script_path, target_path)
 
-            %{& "#{File.join(target_path, script_name)}"}
+            %{powershell -ExecutionPolicy Bypass -File "#{File.join(target_path, script_name)}"}
           ensure
             FileUtils.rmtree(temp_dir)
           end
@@ -434,7 +358,8 @@ module Kitchen
 
       private
 
-      WINRM_TRANSPORT_SPEC_VERSION = ["~> 1.0", ">= 1.0.3"].freeze
+      WINRM_SPEC_VERSION = ["~> 1.6"].freeze
+      WINRM_FS_SPEC_VERSION = ["~> 0.3"].freeze
 
       # Builds the hash of options needed by the Connection object on
       # construction.
@@ -461,8 +386,8 @@ module Kitchen
       end
 
       def additional_transport_args(transport_type)
-        case transport_type
-        when :ssl, :sspinegotiate
+        case transport_type.to_sym
+        when :ssl, :negotiate
           {
             :no_ssl_peer_verification => true,
             :disable_sspi => false,
@@ -473,6 +398,8 @@ module Kitchen
             :disable_sspi => true,
             :basic_auth_only => true
           }
+        else
+          {}
         end
       end
 
@@ -495,66 +422,27 @@ module Kitchen
       # (see Base#load_needed_dependencies!)
       def load_needed_dependencies!
         super
-        load_winrm_transport!
-        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" }
+        load_with_rescue!("winrm", WINRM_SPEC_VERSION.dup)
+        load_with_rescue!("winrm-fs", WINRM_FS_SPEC_VERSION.dup)
       end
 
-      def load_with_rescue!(options = {}, &block)
-        logger.debug(options[:load_msg])
-        attempt_load = execute_block(&block)
+      def load_with_rescue!(gem_name, spec_version)
+        logger.debug("#{gem_name} requested," \
+          " loading #{gem_name} gem (#{spec_version})")
+        attempt_load = false
+        gem gem_name, spec_version
+        silence_warnings { attempt_load = require gem_name }
         if attempt_load
-          logger.debug(options[:success_msg])
+          logger.debug("#{gem_name} is loaded.")
         else
-          logger.debug(options[:already_msg])
+          logger.debug("#{gem_name} was already loaded.")
         end
       rescue LoadError => e
-        message = fail_to_load_gem_message(options[:name],
-          options[:version])
+        message = fail_to_load_gem_message(gem_name,
+          spec_version)
         logger.fatal(message)
         raise UserError,
-          "Could not load or activate #{options[:name]}. (#{e.message})"
-      end
-
-      def execute_block
-        yield if block_given?
+          "Could not load or activate #{gem_name}. (#{e.message})"
       end
 
       def fail_to_load_gem_message(name, version = nil)