test-kitchen 3.9.1 → 4.0.0

data/lib/kitchen/provisioner/chef_infra.rb

@@ -1,167 +0,0 @@
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2013, Fletcher Nichol
-#
-# 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 "chef_base"
-
-module Kitchen
-  module Provisioner
-    # Chef Zero provisioner.
-    #
-    # @author Fletcher Nichol <fnichol@nichol.ca>
-    class ChefInfra < ChefBase
-      kitchen_provisioner_api_version 2
-
-      plugin_version Kitchen::VERSION
-
-      default_config :client_rb, {}
-      default_config :named_run_list, {}
-      default_config :json_attributes, true
-      default_config :chef_zero_host, nil
-      default_config :chef_zero_port, 8889
-
-      default_config :chef_client_path do |provisioner|
-        provisioner
-          .remote_path_join(%W{#{provisioner[:chef_omnibus_root]} bin chef-client})
-          .tap { |path| path.concat(".bat") if provisioner.windows_os? }
-      end
-
-      default_config :ruby_bindir do |provisioner|
-        provisioner
-          .remote_path_join(%W{#{provisioner[:chef_omnibus_root]} embedded bin})
-      end
-
-      # (see Base#create_sandbox)
-      def create_sandbox
-        super
-        prepare_validation_pem
-        prepare_config_rb
-      end
-
-      def run_command
-        cmd = "#{sudo(config[:chef_client_path])} --local-mode".tap { |str| str.insert(0, "& ") if powershell_shell? }
-
-        chef_cmd(cmd)
-      end
-
-      private
-
-      # Adds optional flags to a chef-client command, depending on
-      # configuration data. Note that this method mutates the incoming Array.
-      #
-      # @param args [Array<String>] array of flags
-      # @api private
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def add_optional_chef_client_args!(args)
-        if config[:json_attributes]
-          json = remote_path_join(config[:root_path], "dna.json")
-          args << "--json-attributes #{json}"
-        end
-
-        args << "--logfile #{config[:log_file]}" if config[:log_file]
-
-        # these flags are chef-client local mode only and will not work
-        # on older versions of chef-client
-        if config[:chef_zero_host]
-          args << "--chef-zero-host #{config[:chef_zero_host]}"
-        end
-
-        if config[:chef_zero_port]
-          args << "--chef-zero-port #{config[:chef_zero_port]}"
-        end
-
-        args << "--profile-ruby" if config[:profile_ruby]
-
-        if config[:slow_resource_report]
-          if config[:slow_resource_report].is_a?(Integer)
-            args << "--slow-report #{config[:slow_resource_report]}"
-          else
-            args << "--slow-report"
-          end
-        end
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity
-
-      # Returns an Array of command line arguments for the chef client.
-      #
-      # @return [Array<String>] an array of command line arguments
-      # @api private
-      def chef_args(client_rb_filename)
-        level = config[:log_level]
-        args = [
-            "--config #{remote_path_join(config[:root_path], client_rb_filename)}",
-            "--log_level #{level}",
-            "--force-formatter",
-            "--no-color",
-        ]
-        add_optional_chef_client_args!(args)
-
-        args
-      end
-
-      # Generates a string of shell environment variables needed for the
-      # chef-client-zero.rb shim script to properly function.
-      #
-      # @return [String] a shell script string
-      # @api private
-      def chef_client_zero_env
-        root = config[:root_path]
-        gem_home = gem_path = remote_path_join(root, "chef-client-zero-gems")
-        gem_cache = remote_path_join(gem_home, "cache")
-
-        [
-            shell_env_var("CHEF_REPO_PATH", root),
-            shell_env_var("GEM_HOME", gem_home),
-            shell_env_var("GEM_PATH", gem_path),
-            shell_env_var("GEM_CACHE", gem_cache),
-        ].join("\n").concat("\n")
-      end
-
-      # Writes a fake (but valid) validation.pem into the sandbox directory.
-      #
-      # @api private
-      def prepare_validation_pem
-        info("Preparing validation.pem")
-        debug("Using a dummy validation.pem")
-
-        source = File.join(File.dirname(__FILE__),
-          %w{.. .. .. support dummy-validation.pem})
-        FileUtils.cp(source, File.join(sandbox_path, "validation.pem"))
-      end
-
-      # Returns the command that will run a backwards compatible shim script
-      # that approximates local mode in a modern chef-client run.
-      #
-      # @return [String] the command string
-      # @api private
-      def shim_command
-        ruby = remote_path_join(config[:ruby_bindir], "ruby")
-          .tap { |path| path.concat(".exe") if windows_os? }
-        shim = remote_path_join(config[:root_path], "chef-client-zero.rb")
-
-        "#{chef_client_zero_env}\n#{sudo(ruby)} #{shim}"
-      end
-
-      # This provisioner supports policyfiles, so override the default (which
-      # is false)
-      # @return [true] always returns true
-      # @api private
-      def supports_policyfile?
-        true
-      end
-    end
-  end
-end

data/lib/kitchen/provisioner/chef_solo.rb

@@ -1,82 +0,0 @@
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2013, Fletcher Nichol
-#
-# 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 "chef_base"
-
-module Kitchen
-  module Provisioner
-    # Chef Solo provisioner.
-    #
-    # @author Fletcher Nichol <fnichol@nichol.ca>
-    class ChefSolo < ChefBase
-      kitchen_provisioner_api_version 2
-
-      plugin_version Kitchen::VERSION
-
-      # ChefSolo is dependent on Berkshelf, which is not thread-safe.
-      # See discussion on https://github.com/test-kitchen/test-kitchen/issues/1307
-      no_parallel_for :converge
-
-      default_config :solo_rb, {}
-
-      default_config :chef_solo_path do |provisioner|
-        provisioner
-          .remote_path_join(%W{#{provisioner[:chef_omnibus_root]} bin chef-solo})
-          .tap { |path| path.concat(".bat") if provisioner.windows_os? }
-      end
-
-      # (see Base#config_filename)
-      def config_filename
-        "solo.rb"
-      end
-
-      # (see Base#create_sandbox)
-      def create_sandbox
-        super
-        prepare_config_rb
-      end
-
-      # (see Base#run_command)
-      def run_command
-        cmd = sudo(config[:chef_solo_path]).dup
-          .tap { |str| str.insert(0, "& ") if powershell_shell? }
-
-        chef_cmd(cmd)
-      end
-
-      private
-
-      # Returns an Array of command line arguments for the chef client.
-      #
-      # @return [Array<String>] an array of command line arguments
-      # @api private
-      def chef_args(solo_rb_filename)
-        args = [
-          "--config #{remote_path_join(config[:root_path], solo_rb_filename)}",
-          "--log_level #{config[:log_level]}",
-          "--force-formatter",
-          "--no-color",
-          "--json-attributes #{remote_path_join(config[:root_path], "dna.json")}",
-        ]
-        args << "--logfile #{config[:log_file]}" if config[:log_file]
-        args << "--profile-ruby" if config[:profile_ruby]
-        args << "--legacy-mode" if config[:legacy_mode]
-        args
-      end
-    end
-  end
-end

data/lib/kitchen/provisioner/chef_target.rb

@@ -1,130 +0,0 @@
-#
-# Author:: Thomas Heinen (<thomas.heinen@gmail.com>)
-#
-# Copyright (C) 2023, Thomas Heinen
-#
-# 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 "chef_infra"
-
-module Kitchen
-  module Provisioner
-    # Chef Target provisioner.
-    #
-    # @author Thomas Heinen <thomas.heinen@gmail.com>
-    class ChefTarget < ChefInfra
-      MIN_VERSION_REQUIRED = "19.0.0".freeze
-      class ChefVersionTooLow < UserError; end
-      class ChefClientNotFound < UserError; end
-      class RequireTrainTransport < UserError; end
-
-      default_config :install_strategy, "none"
-      default_config :sudo, true
-
-      def install_command; ""; end
-      def init_command; ""; end
-      def prepare_command; ""; end
-
-      def chef_args(client_rb_filename)
-        # Dummy execution to initialize and test remote connection
-        connection = instance.remote_exec("echo Connection established")
-
-        check_transport(connection)
-        check_local_chef_client
-
-        instance_name = instance.name
-        credentials_file = File.join(kitchen_basepath, ".kitchen", instance_name + ".ini")
-        File.write(credentials_file, connection.credentials_file)
-
-        super.push(
-          "--target #{instance_name}",
-          "--credentials #{credentials_file}"
-        )
-      end
-
-      def check_transport(connection)
-        debug("Checking for active transport")
-
-        unless connection.respond_to? "train_uri"
-          error("Chef Target Mode provisioner requires a Train-based transport like kitchen-transport-train")
-          raise RequireTrainTransport.new("No Train transport")
-        end
-
-        debug("Kitchen transport responds to train_uri function call, as required")
-      end
-
-      def check_local_chef_client
-        debug("Checking for chef-client version")
-
-        begin
-          client_version = `chef-client -v`.chop.split(":")[-1]
-        rescue Errno::ENOENT => e
-          error("Error determining Chef Infra version: #{e.exception.message}")
-          raise ChefClientNotFound.new("Need chef-client installed locally")
-        end
-
-        minimum_version = Gem::Version.new(MIN_VERSION_REQUIRED)
-        installed_version = Gem::Version.new(client_version)
-
-        if installed_version < minimum_version
-          error("Found Chef Infra version #{installed_version}, but require #{minimum_version} for Target Mode")
-          raise ChefVersionTooLow.new("Need version #{MIN_VERSION_REQUIRED} or higher")
-        end
-
-        debug("Chef Infra found and version constraints match")
-      end
-
-      def kitchen_basepath
-        instance.driver.config[:kitchen_root]
-      end
-
-      def create_sandbox
-        super
-
-        # Change config.rb to point to the local sandbox path, not to /tmp/kitchen
-        config[:root_path] = sandbox_path
-        prepare_config_rb
-      end
-
-      def call(state)
-        remote_connection = instance.transport.connection(state)
-
-        config[:uploads].to_h.each do |locals, remote|
-          debug("Uploading #{Array(locals).join(", ")} to #{remote}")
-          remote_connection.upload(locals.to_s, remote)
-        end
-
-        # no installation
-        create_sandbox
-        # no prepare command
-
-        # Stream output to logger
-        require "open3"
-        Open3.popen2e(run_command) do |_stdin, output, _thread|
-          output.each { |line| logger << line }
-        end
-
-        info("Downloading files from #{instance.to_str}")
-        config[:downloads].to_h.each do |remotes, local|
-          debug("Downloading #{Array(remotes).join(", ")} to #{local}")
-          remote_connection.download(remotes, local)
-        end
-        debug("Download complete")
-      rescue Kitchen::Transport::TransportFailed => ex
-        raise ActionFailed, ex.message
-      ensure
-        cleanup_sandbox
-      end
-    end
-  end
-end

data/lib/kitchen/provisioner/chef_zero.rb

@@ -1,12 +0,0 @@
-# Deprecated AS PER THE PR - https://github.com/test-kitchen/test-kitchen/pull/1730
-require_relative "chef_infra"
-
-module Kitchen
-  module Provisioner
-    # Chef Zero provisioner.
-    #
-    # @author Fletcher Nichol <fnichol@nichol.ca>
-    class ChefZero < ChefInfra
-    end
-  end
-end

data/lib/kitchen/ssh.rb

@@ -1,296 +0,0 @@
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2013, Fletcher Nichol
-#
-# 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 "logger"
-module Net
-  autoload :SSH, "net/ssh"
-end
-require "socket" unless defined?(Socket)
-
-require_relative "errors"
-require_relative "login_command"
-require_relative "util"
-
-module Kitchen
-  # Wrapped exception for any internally raised SSH-related errors.
-  #
-  # @author Fletcher Nichol <fnichol@nichol.ca>
-  class SSHFailed < TransientFailure; end
-
-  # Class to help establish SSH connections, issue remote commands, and
-  # transfer files between a local system and remote node.
-  #
-  # @author Fletcher Nichol <fnichol@nichol.ca>
-  class SSH
-    # Constructs a new SSH object.
-    #
-    # @example basic usage
-    #
-    #   ssh = Kitchen::SSH.new("remote.example.com", "root")
-    #   ssh.exec("sudo apt-get update")
-    #   ssh.upload!("/tmp/data.txt", "/var/lib/data.txt")
-    #   ssh.shutdown
-    #
-    # @example block usage
-    #
-    #   Kitchen::SSH.new("remote.example.com", "root") do |ssh|
-    #     ssh.exec("sudo apt-get update")
-    #     ssh.upload!("/tmp/data.txt", "/var/lib/data.txt")
-    #   end
-    #
-    # @param hostname [String] the remote hostname (IP address, FQDN, etc.)
-    # @param username [String] the username for the remote host
-    # @param options [Hash] configuration options
-    # @option options [Logger] :logger the logger to use
-    #   (default: `::Logger.new(STDOUT)`)
-    # @yield [self] if a block is given then the constructed object yields
-    #   itself and calls `#shutdown` at the end, closing the remote connection
-    def initialize(hostname, username, options = {})
-      @hostname = hostname
-      @username = username
-      @options = options.dup
-      @logger = @options.delete(:logger) || ::Logger.new(STDOUT)
-
-      if block_given?
-        yield self
-        shutdown
-      end
-    end
-
-    # Execute a command on the remote host.
-    #
-    # @param cmd [String] command string to execute
-    # @raise [SSHFailed] if the command does not exit with a 0 code
-    def exec(cmd)
-      string_to_mask = "[SSH] #{self} (#{cmd})"
-      masked_string = Util.mask_values(string_to_mask, %w{password ssh_http_proxy_password})
-      logger.debug(masked_string)
-      exit_code = exec_with_exit(cmd)
-
-      if exit_code != 0
-        raise SSHFailed, "SSH exited (#{exit_code}) for command: [#{cmd}]"
-      end
-    end
-
-    # Uploads a local file to remote host.
-    #
-    # @param local [String] path to local file
-    # @param remote [String] path to remote file destination
-    # @param options [Hash] configuration options that are passed to
-    #   `Net::SCP.upload`
-    # @see https://net-ssh.github.io/net-scp/classes/Net/SCP.html#method-i-upload
-    def upload!(local, remote, options = {}, &progress)
-      require "net/scp" unless defined?(Net::SCP)
-      if progress.nil?
-        progress = lambda do |_ch, name, sent, total|
-          logger.debug("Uploaded #{name} (#{total} bytes)") if sent == total
-        end
-      end
-
-      session.scp.upload!(local, remote, options, &progress)
-    end
-
-    def upload(local, remote, options = {}, &progress)
-      require "net/scp" unless defined?(Net::SCP)
-      if progress.nil?
-        progress = lambda do |_ch, name, sent, total|
-          if sent == total
-            logger.debug("Async Uploaded #{name} (#{total} bytes)")
-          end
-        end
-      end
-
-      session.scp.upload(local, remote, options, &progress)
-    end
-
-    # Uploads a recursive directory to remote host.
-    #
-    # @param local [String] path to local file or directory
-    # @param remote [String] path to remote file destination
-    # @param options [Hash] configuration options that are passed to
-    #   `Net::SCP.upload`
-    # @option options [true,false] :recursive recursive copy (default: `true`)
-    # @see https://net-ssh.github.io/net-scp/classes/Net/SCP.html#method-i-upload
-    def upload_path!(local, remote, options = {}, &progress)
-      options = { recursive: true }.merge(options)
-
-      upload!(local, remote, options, &progress)
-    end
-
-    def upload_path(local, remote, options = {}, &progress)
-      options = { recursive: true }.merge(options)
-      upload(local, remote, options, &progress)
-    end
-
-    # Shuts down the session connection, if it is still active.
-    def shutdown
-      return if @session.nil?
-
-      string_to_mask = "[SSH] closing connection to #{self}"
-      masked_string = Util.mask_values(string_to_mask, %w{password ssh_http_proxy_password})
-      logger.debug(masked_string)
-      session.shutdown!
-    ensure
-      @session = nil
-    end
-
-    # Blocks until the remote host's SSH TCP port is listening.
-    def wait
-      logger.info("Waiting for #{hostname}:#{port}...") until test_ssh
-    end
-
-    # Builds a LoginCommand which can be used to open an interactive session
-    # on the remote host.
-    #
-    # @return [LoginCommand] the login command
-    def login_command
-      args  = %w{ -o UserKnownHostsFile=/dev/null }
-      args += %w{ -o StrictHostKeyChecking=no }
-      args += %w{ -o IdentitiesOnly=yes } if options[:keys]
-      args += %W{ -o LogLevel=#{logger.debug? ? "VERBOSE" : "ERROR"} }
-      if options.key?(:forward_agent)
-        args += %W{ -o ForwardAgent=#{options[:forward_agent] ? "yes" : "no"} }
-      end
-      Array(options[:keys]).each { |ssh_key| args += %W{ -i #{ssh_key} } }
-      args += %W{ -p #{port} }
-      args += %W{ #{username}@#{hostname} }
-
-      LoginCommand.new("ssh", args)
-    end
-
-    private
-
-    # TCP socket exceptions
-    SOCKET_EXCEPTIONS = [
-      SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH,
-      Errno::ENETUNREACH, IOError
-    ].freeze
-
-    # @return [String] the remote hostname
-    # @api private
-    attr_reader :hostname
-
-    # @return [String] the username for the remote host
-    # @api private
-    attr_reader :username
-
-    # @return [Hash] SSH options, passed to `Net::SSH.start`
-    attr_reader :options
-
-    # @return [Logger] the logger to use
-    # @api private
-    attr_reader :logger
-
-    # Builds the Net::SSH session connection or returns the existing one if
-    # built.
-    #
-    # @return [Net::SSH::Connection::Session] the SSH connection session
-    # @api private
-    def session
-      @session ||= establish_connection
-    end
-
-    # Establish a connection session to the remote host.
-    #
-    # @return [Net::SSH::Connection::Session] the SSH connection session
-    # @api private
-    def establish_connection
-      rescue_exceptions = [
-        Errno::EACCES, Errno::EADDRINUSE, Errno::ECONNREFUSED,
-        Errno::ECONNRESET, Errno::ENETUNREACH, Errno::EHOSTUNREACH,
-        Net::SSH::Disconnect, Net::SSH::AuthenticationFailed, Net::SSH::ConnectionTimeout
-      ]
-      retries = options[:ssh_retries] || 3
-
-      begin
-        string_to_mask = "[SSH] opening connection to #{self}"
-        masked_string = Util.mask_values(string_to_mask, %w{password ssh_http_proxy_password})
-        logger.debug(masked_string)
-        Net::SSH.start(hostname, username, options)
-      rescue *rescue_exceptions => e
-        retries -= 1
-        if retries > 0
-          logger.info("[SSH] connection failed, retrying (#{e.inspect})")
-          sleep options[:ssh_timeout] || 1
-          retry
-        else
-          logger.warn("[SSH] connection failed, terminating (#{e.inspect})")
-          raise
-        end
-      end
-    end
-
-    # String representation of object, reporting its connection details and
-    # configuration.
-    #
-    # @api private
-    def to_s
-      "#{username}@#{hostname}:#{port}<#{options.inspect}>"
-    end
-
-    # @return [Integer] SSH port (default: 22)
-    # @api private
-    def port
-      options.fetch(:port, 22)
-    end
-
-    # Execute a remote command and return the command's exit code.
-    #
-    # @param cmd [String] command string to execute
-    # @return [Integer] the exit code of the command
-    # @api private
-    def exec_with_exit(cmd)
-      exit_code = nil
-      session.open_channel do |channel|
-        channel.request_pty
-
-        channel.exec(cmd) do |_ch, _success|
-          channel.on_data do |_ch, data|
-            logger << data
-          end
-
-          channel.on_extended_data do |_ch, _type, data|
-            logger << data
-          end
-
-          channel.on_request("exit-status") do |_ch, data|
-            exit_code = data.read_long
-          end
-        end
-      end
-      session.loop
-      exit_code
-    end
-
-    # Test a remote TCP socket (presumably SSH) for connectivity.
-    #
-    # @return [true,false] a truthy value if the socket is ready and false
-    #   otherwise
-    # @api private
-    def test_ssh
-      socket = TCPSocket.new(hostname, port)
-      IO.select([socket], nil, nil, 5)
-    rescue *SOCKET_EXCEPTIONS
-      sleep options[:ssh_timeout] || 2
-      false
-    rescue Errno::EPERM, Errno::ETIMEDOUT
-      false
-    ensure
-      socket && socket.close
-    end
-  end
-end