test-kitchen 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80afb157c2779c990f0194d9711cf3a35d949a1916515fbaf722056306314a6d
-  data.tar.gz: d06ecf45e9c7c2288a772c2202505f2d5cdd722b357fb7fa9cf0433e06eec725
+  metadata.gz: 37110df4f18f03d75c627d0095a7cfee87e12add45de4265ddbcb3afe5d207da
+  data.tar.gz: 94c3173ff1268904ec591d0de22f15635e1e1a453ce9f3167a4e10c26f6eed48
 SHA512:
-  metadata.gz: 323e94d69dfadaa75a6214b504f47c7114227ee5ce98ae5dcdd64f9961945caf8212d9ef015a778ace055b6b63eb6fa5917dc072aa7f977a9da2a734ccfa66cd
-  data.tar.gz: fcf0647d42a9482a9da0656ed68b90b6cc17eb8a14cd999a6316b3be4a2cc02796a3ef4a0ccf7ee8938a0cd92bb8910efb7243342f6677f63b624f8b9756cb64
+  metadata.gz: 30070f63b980cdf6ee9139232b013092c08ee838c6534b4af11736beeab7bf0aab1e3bba152665bbc07ac6a9723cee89e1c0cf6251dc4054a8c281c2866274d8
+  data.tar.gz: 1e1ab92e31f6b83b97df09df37e6e853be9f982b78aeabbf96045a1b0ee61fd8012704ad45fdcf2ff249fb489211e470ab5eed8a2db49209597fa05ae473a121

data/Gemfile

@@ -7,7 +7,7 @@ group :test do
   gem "rb-readline"
   gem "aruba",     ">= 0.11", "< 3.0"
   gem "countloc",  "~> 0.4"
-  gem "cucumber",  ">= 9.2", "< 11"
+  gem "cucumber",  ">= 9.2", "< 12"
   gem "fakefs",    "~> 3.0"
   gem "maruku",    "~> 0.7"
   gem "minitest",  "~> 6.0", "< 6.1"
@@ -15,11 +15,13 @@ group :test do
 end
 
 group :integration do
-  gem "chef-cli"
+  gem "cinc-auditor-bin", source: "https://rubygems.cinc.sh"
+  gem "kitchen-cinc"
+  gem "kitchen-cinc-auditor",
+    git: "https://github.com/test-kitchen/kitchen-cinc-auditor.git",
+    ref: "3d0b89eaa13f12da08a8761970e39c0f564c24c6"
   gem "kitchen-dokken"
   gem "kitchen-vagrant"
-  gem "kitchen-inspec"
-  gem "kitchen-omnibus-chef", ">= 1.0"
 end
 
 group :linting do

data/lib/kitchen/cli.rb

@@ -110,13 +110,20 @@ module Kitchen
       aliases: "-j",
       type: :boolean,
       desc: "Print data as JSON"
+    method_option :live,
+      type: :boolean,
+      desc: "Include driver-reported live instance status"
+    method_option :probe,
+      type: :boolean,
+      desc: "Probe transport connectivity in addition to driver status"
     method_option :debug,
       aliases: "-d",
       type: :boolean,
       desc: "[Deprecated] Please use `kitchen diagnose'"
     log_options
     def list(*args)
-      update_config!
+      log_overwrite = options[:log_overwrite].nil? ? false : options[:log_overwrite]
+      update_config!(log_overwrite:)
       perform("list", "list", args)
     end
     map status: :list
@@ -148,8 +155,7 @@ module Kitchen
       converge: "Change instance state to converge. " \
                    "Use a provisioner to configure one or more instances",
       setup: "Change instance state to setup. " \
-                   "Prepare to run automated tests. " \
-                   "Install busser and related gems on one or more instances",
+                   "Prepare one or more instances for verification",
       verify: "Change instance state to verify. " \
                    "Run automated tests on one or more instances",
       destroy: "Change instance state to destroy. " \
@@ -257,6 +263,27 @@ module Kitchen
       perform("login", "login", args)
     end
 
+    desc "logs [INSTANCE|REGEXP|all]", "Show structured logs"
+    method_option :level,
+      desc: "Minimum log level to print (debug, info, warn, error, fatal)"
+    method_option :session_id,
+      desc: "Only print logs for the given instance session id"
+    method_option :all_sessions,
+      type: :boolean,
+      desc: "Print logs from all instance sessions; defaults to all instances"
+    method_option :format,
+      default: "text",
+      desc: "Output format (ndjson, text)"
+    method_option :follow,
+      aliases: "-f",
+      type: :boolean,
+      desc: "Follow the structured log file"
+    log_options
+    def logs(*args)
+      update_config!(log_overwrite: false)
+      perform("logs", "logs", args)
+    end
+
     desc "package INSTANCE|REGEXP", "package an instance"
     log_options
     def package(*args)
@@ -334,12 +361,10 @@ module Kitchen
     # Update and finalize options for logging, concurrency, and other concerns.
     #
     # @api private
-    def update_config!
+    def update_config!(log_overwrite: options[:log_overwrite])
       @config.log_level = log_level if log_level
 
-      unless options[:log_overwrite].nil?
-        @config.log_overwrite = options[:log_overwrite]
-      end
+      @config.log_overwrite = log_overwrite unless log_overwrite.nil?
       @config.colorize = options[:color] unless options[:color].nil?
 
       if options[:test_base_path]
@@ -352,7 +377,7 @@ module Kitchen
       # Now that we have required configs, lets create our file logger
       Kitchen.logger = Kitchen.default_file_logger(
         log_level,
-        options[:log_overwrite]
+        log_overwrite
       )
 
       update_parallel!

data/lib/kitchen/command/list.rb

@@ -57,7 +57,7 @@ module Kitchen
       # @return [Array<String>]
       # @api private
       def display_instance(instance)
-        [
+        row = [
           color_pad(instance.name),
           color_pad(instance.driver.name),
           color_pad(instance.provisioner.name),
@@ -66,6 +66,8 @@ module Kitchen
           format_last_action(instance.last_action),
           format_last_error(instance.last_error),
         ]
+        row << format_live_status(instance_status(instance)) if status_requested?
+        row
       end
 
       # Format and color the given last action.
@@ -96,19 +98,39 @@ module Kitchen
         end
       end
 
+      # Format and color live status.
+      #
+      # @param status [Hash] normalized status data
+      # @return [String] formatted live status
+      # @api private
+      def format_live_status(status)
+        probe = status[:transport_probe]
+        if probe && probe[:reachable] == false
+          return colorize("#{status[:state]} (#{probe[:state]})", :red)
+        elsif probe && probe[:reachable] == true
+          return colorize("#{status[:state]} (#{probe[:state]})", :green)
+        end
+
+        case status[:live]
+        when true then colorize(status[:state], :green)
+        when false then colorize(status[:state], :red)
+        else colorize(status[:state], :white)
+        end
+      end
+
       # Constructs a list display table and output it to the screen.
       #
       # @param result [Array<Instance>] an array of instances
       # @api private
       def list_table(result)
-        table = [
-          [
-            colorize("Instance", :green), colorize("Driver", :green),
-            colorize("Provisioner", :green), colorize("Verifier", :green),
-            colorize("Transport", :green), colorize("Last Action", :green),
-            colorize("Last Error", :green)
-          ],
+        headings = [
+          colorize("Instance", :green), colorize("Driver", :green),
+          colorize("Provisioner", :green), colorize("Verifier", :green),
+          colorize("Transport", :green), colorize("Last Action", :green),
+          colorize("Last Error", :green)
         ]
+        headings << colorize("Live Status", :green) if status_requested?
+        table = [headings]
         table += Array(result).map { |i| display_instance(i) }
         print_table(table)
       end
@@ -118,7 +140,7 @@ module Kitchen
       # @param result [Hash{Symbol => String}] hash of a single instance
       # @api private
       def to_hash(result)
-        {
+        data = {
           instance: result.name,
           driver: result.driver.name,
           provisioner: result.provisioner.name,
@@ -127,6 +149,24 @@ module Kitchen
           last_action: result.last_action,
           last_error: result.last_error,
         }
+        if status_requested?
+          data.merge!(
+            log_path: result.log_path,
+            structured_log_path: result.structured_log_path,
+            state_path: result.state_path,
+            instance_session_id: result.current_session_id,
+            status: instance_status(result)
+          )
+        end
+        data
+      end
+
+      def status_requested?
+        options[:live] || options[:probe]
+      end
+
+      def instance_status(instance)
+        options[:probe] ? instance.status(probe: true) : instance.status
       end
 
       # Outputs a formatted display table.

data/lib/kitchen/command/logs.rb

@@ -0,0 +1,185 @@
+#
+# 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
+#
+#    https://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_relative "../command"
+
+require "json" unless defined?(JSON)
+
+module Kitchen
+  module Command
+    # Command to print structured logs for one instance.
+    class Logs < Kitchen::Command::Base
+      LEVELS = %w{debug info warn error fatal unknown}.freeze
+
+      # Invoke the command.
+      def call
+        validate_format!
+        validate_level!
+        if options[:all_sessions]
+          emit_all_session_logs
+          return
+        end
+
+        target_instances = instances
+        validate_follow_target!(target_instances)
+
+        target_instances.each do |instance|
+          session_id = selected_session_id(instance)
+          die "No structured log file found at #{instance.structured_log_path}" unless
+            File.file?(instance.structured_log_path)
+
+          emit_file(instance.structured_log_path, session_id)
+          follow_file(instance.structured_log_path, session_id) if options[:follow]
+        end
+      end
+
+      private
+
+      def emit_all_session_logs
+        log_paths = all_session_log_paths
+        validate_follow_target!(log_paths)
+
+        log_paths.each do |path|
+          emit_file(path, nil)
+          follow_file(path, nil) if options[:follow]
+        end
+      end
+
+      def all_session_log_paths
+        paths = structured_log_paths(args.first)
+        return paths unless paths.empty?
+
+        die "No structured log files found in #{Kitchen::DEFAULT_LOG_DIR}"
+      end
+
+      def structured_log_paths(arg)
+        paths = all_structured_log_paths
+        return paths if arg.nil? || arg == "all"
+
+        exact_path = File.join(Kitchen::DEFAULT_LOG_DIR, "#{arg}.ndjson")
+        return [exact_path] if File.file?(exact_path)
+
+        regexp = Regexp.new(arg)
+        paths.select { |path| File.basename(path, ".ndjson") =~ regexp }
+      rescue RegexpError => e
+        die "Invalid Ruby regular expression, " \
+          "you may need to single quote the argument. " \
+          "Please try again or consult https://rubular.com/ (#{e.message})"
+      end
+
+      def all_structured_log_paths
+        Dir[File.join(Kitchen::DEFAULT_LOG_DIR, "*.ndjson")]
+          .reject { |path| File.basename(path) == "kitchen.ndjson" }
+          .sort
+      end
+
+      def validate_follow_target!(targets)
+        return unless options[:follow] && targets.size > 1
+
+        die "Following multiple instance logs is not supported; choose one instance"
+      end
+
+      def instances
+        results = parse_subcommand(args.first)
+        if results.size > 1 && !options[:all_sessions]
+          die "Argument `#{args.first}' returned multiple results:\n" +
+            results.map { |i| "  * #{i.name}" }.join("\n")
+        end
+        results
+      end
+
+      def selected_session_id(instance)
+        return if options[:all_sessions]
+        return options[:session_id] if options[:session_id]
+        return instance.current_session_id if instance.current_session_id
+
+        if File.file?(instance.structured_log_path)
+          session_id = latest_session_id(instance.structured_log_path)
+          return session_id if session_id
+        end
+
+        die "Instance #{instance.to_str} has no current session id; use --all-sessions"
+      end
+
+      def latest_session_id(path)
+        File.foreach(path).filter_map do |line|
+          JSON.parse(line)["instance_session_id"]
+        rescue JSON::ParserError
+          nil
+        end.last
+      end
+
+      def emit_file(path, session_id)
+        File.foreach(path) { |line| emit_line(line, session_id) }
+      end
+
+      def follow_file(path, session_id)
+        File.open(path, "r") do |file|
+          file.seek(0, IO::SEEK_END)
+          loop do
+            line = file.gets
+            if line
+              emit_line(line, session_id)
+            else
+              sleep 1
+            end
+          end
+        end
+      end
+
+      def emit_line(line, session_id)
+        event = JSON.parse(line)
+        return unless session_match?(event, session_id)
+        return unless level_match?(event)
+
+        puts format_event(event)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def format_event(event)
+        case options[:format]
+        when "ndjson" then JSON.generate(event)
+        when nil, "text" then event["message"].to_s
+        end
+      end
+
+      def session_match?(event, session_id)
+        session_id.nil? || event["instance_session_id"] == session_id
+      end
+
+      def level_match?(event)
+        return true unless options[:level]
+
+        level_index(event["level"]) >= level_index(options[:level])
+      end
+
+      def level_index(level)
+        LEVELS.index(level.to_s) || LEVELS.index("unknown")
+      end
+
+      def validate_format!
+        return if [nil, "ndjson", "text"].include?(options[:format])
+
+        die "Invalid logs format `#{options[:format]}'; use ndjson or text"
+      end
+
+      def validate_level!
+        return unless options[:level]
+        return if LEVELS.include?(options[:level])
+
+        die "Invalid log level `#{options[:level]}'; use debug, info, warn, error, or fatal"
+      end
+    end
+  end
+end

data/lib/kitchen/command/test.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 
 require_relative "../command"
+require_relative "../errors"
 
 require "benchmark" unless defined?(Benchmark)
 
@@ -30,7 +31,7 @@ module Kitchen
       # Invoke the command.
       def call
         unless %w{passing always never}.include?(options[:destroy])
-          raise ArgumentError, "Destroy mode must be passing, always, or never."
+          raise UserError, "Destroy mode must be passing, always, or never."
         end
 
         banner "Starting Test Kitchen (v#{Kitchen::VERSION})"

data/lib/kitchen/command.rb

@@ -15,6 +15,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative "errors"
+require_relative "logging"
+
 module Kitchen
   module Command
     # Base class for CLI commands.
@@ -160,16 +163,22 @@ module Kitchen
 
         threads = []
         @action_errors = []
-        concurrency.times do
-          threads << Thread.new do
-            while (instance = queue.pop)
-              run_action_in_thread(action, instance, *args)
+        @action_errors_mutex = Mutex.new
+        previous_abort_on_exception = Thread.abort_on_exception
+        begin
+          Thread.abort_on_exception = true if options[:fail_fast]
+          concurrency.times do
+            threads << Thread.new do
+              while (instance = queue.pop)
+                run_action_in_thread(action, instance, *args)
+              end
             end
           end
+          threads.map(&:join)
+          report_errors
+        ensure
+          Thread.abort_on_exception = previous_abort_on_exception
         end
-        Thread.abort_on_exception = true if options[:fail_fast]
-        threads.map(&:join)
-        report_errors
       end
 
       # private
@@ -194,14 +203,18 @@ module Kitchen
       def run_action_in_thread(action, instance, *args)
         instance.public_send(action, *args)
       rescue Kitchen::InstanceFailure => e
-        @action_errors << e
+        record_action_error(e)
       rescue Kitchen::ActionFailed => e
         new_error = Kitchen::ActionFailed.new("#{e.message} on #{instance.name}")
         new_error.set_backtrace(e.backtrace)
-        @action_errors << new_error
+        record_action_error(new_error)
       ensure
         instance.cleanup!
       end
+
+      def record_action_error(error)
+        @action_errors_mutex.synchronize { @action_errors << error }
+      end
     end
   end
 end

data/lib/kitchen/config.rb

@@ -270,13 +270,21 @@ module Kitchen
     def new_instance_logger(suite, platform, index)
       name = instance_name(suite, platform)
       log_location = File.join(log_root, "#{name}.log").to_s
+      structured_log_location = File.join(log_root, "#{name}.ndjson").to_s
       Logger.new(
         stdout: STDOUT,
         color: Color::COLORS[index % Color::COLORS.size].to_sym,
         logdev: log_location,
+        structured_logdev: structured_log_location,
         level: Util.to_logger_level(log_level),
         log_overwrite:,
         progname: name,
+        metadata: {
+          kitchen_run_id: Kitchen.run_id,
+          instance: name,
+          suite: suite.name,
+          platform: platform.name,
+        },
         colorize: @colorize
       )
     end

data/lib/kitchen/data_munger.rb

@@ -38,13 +38,7 @@ module Kitchen
     def initialize(data, kitchen_config = {})
       @data = data
       @kitchen_config = kitchen_config
-      convert_legacy_driver_format!
-      convert_legacy_chef_paths_format!
-      convert_legacy_require_chef_omnibus_format!
-      convert_legacy_busser_format!
-      convert_legacy_driver_http_proxy_format!
-      move_chef_data_to_provisioner!
-      convert_legacy_pre_create_command!
+      LegacyConfigNormalizer.new(self).normalize!
     end
 
     # Generate a new Hash of configuration data that can be used to construct
@@ -651,12 +645,53 @@ module Kitchen
     # @return [Hash] a new merged Hash
     # @api private
     def merged_data_for(key, suite, platform, default_key = :name)
-      ddata = normalized_default_data(key, default_key, suite, platform)
-      cdata = normalized_common_data(key, default_key)
-      pdata = normalized_platform_data(key, default_key, platform)
-      sdata = normalized_suite_data(key, default_key, suite)
+      MergeResolver.new(self).merged_data_for(key, suite, platform, default_key)
+    end
+
+    # Runs all legacy configuration conversions while keeping DataMunger as the
+    # public facade for destructive normalization.
+    class LegacyConfigNormalizer
+      STEPS = %i{
+        convert_legacy_driver_format!
+        convert_legacy_chef_paths_format!
+        convert_legacy_require_chef_omnibus_format!
+        convert_legacy_busser_format!
+        convert_legacy_driver_http_proxy_format!
+        move_chef_data_to_provisioner!
+        convert_legacy_pre_create_command!
+      }.freeze
+
+      def initialize(data_munger)
+        @data_munger = data_munger
+      end
+
+      def normalize!
+        STEPS.each { |step| data_munger.send(step) }
+      end
+
+      private
+
+      attr_reader :data_munger
+    end
+
+    # Resolves the default/common/platform/suite layers for one plugin key.
+    class MergeResolver
+      def initialize(data_munger)
+        @data_munger = data_munger
+      end
+
+      def merged_data_for(key, suite, platform, default_key)
+        ddata = data_munger.send(:normalized_default_data, key, default_key, suite, platform)
+        cdata = data_munger.send(:normalized_common_data, key, default_key)
+        pdata = data_munger.send(:normalized_platform_data, key, default_key, platform)
+        sdata = data_munger.send(:normalized_suite_data, key, default_key, suite)
+
+        ddata.rmerge(cdata.rmerge(pdata.rmerge(sdata)))
+      end
+
+      private
 
-      ddata.rmerge(cdata.rmerge(pdata.rmerge(sdata)))
+      attr_reader :data_munger
     end
 
     # Destructively moves key Chef configuration key/value pairs from being

data/lib/kitchen/driver/base.rb

@@ -16,6 +16,7 @@ require_relative "../lazy_hash"
 require_relative "../logging"
 require_relative "../plugin_base"
 require_relative "../shell_out"
+require "time" unless defined?(Time)
 
 module Kitchen
   module Driver
@@ -63,6 +64,24 @@ module Kitchen
         false
       end
 
+      # Reports whether the backing instance is known to be live.
+      #
+      # Drivers that can ask their provider should override this method.
+      # Existing drivers remain compatible by inheriting an unknown status.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @return [Hash] normalized status data
+      def status(state) # rubocop:disable Lint/UnusedMethodArgument
+        {
+          live: nil,
+          state: "unknown",
+          source: "driver",
+          resource_id: nil,
+          message: "#{self.class} does not support status checks",
+          checked_at: Time.now.utc.iso8601,
+        }
+      end
+
       # Sets the API version for this driver. If the driver does not set this
       # value, then `nil` will be used and reported.
       #

data/lib/kitchen/driver/dummy.rb

@@ -11,6 +11,7 @@
 # limitations under the License.
 
 require_relative "../../kitchen"
+require "time" unless defined?(Time)
 
 module Kitchen
   module Driver
@@ -51,6 +52,32 @@ module Kitchen
         state.delete(:my_id)
       end
 
+      # Reports whether the dummy instance has a generated resource id.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @return [Hash] normalized status data
+      def status(state)
+        if state[:my_id]
+          {
+            live: true,
+            state: "running",
+            source: "driver",
+            resource_id: state[:my_id],
+            message: "Dummy instance exists",
+            checked_at: Time.now.utc.iso8601,
+          }
+        else
+          {
+            live: false,
+            state: "not_created",
+            source: "driver",
+            resource_id: nil,
+            message: "Dummy instance has no resource id",
+            checked_at: Time.now.utc.iso8601,
+          }
+        end
+      end
+
       private
 
       # Report what action is taking place, sleeping if so configured, and

data/lib/kitchen/errors.rb

@@ -206,6 +206,7 @@ module Kitchen
         Kitchen.logger.debug(line)
       else
         Kitchen.logger.logdev && Kitchen.logger.logdev.public_send(level, line)
+        Kitchen.logger.structured_logdev && Kitchen.logger.structured_logdev.public_send(level, line)
       end
     end
   end