test-kitchen-rsync 3.0.0.pre.1

data/lib/kitchen/shell_out.rb

@@ -0,0 +1,90 @@
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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
+#
+#    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 "mixlib/shellout" unless defined?(Mixlib::ShellOut)
+
+module Kitchen
+  # Mixin that wraps a command shell out invocation, providing a #run_command
+  # method.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  module ShellOut
+    # Wrapped exception for any interally raised shell out commands.
+    class ShellCommandFailed < TransientFailure; end
+
+    # Executes a command in a subshell on the local running system.
+    #
+    # @param cmd [String] command to be executed locally
+    # @param options [Hash] additional configuration of command
+    # @option options [TrueClass, FalseClass] :use_sudo whether or not to use
+    #   sudo
+    # @option options [String] :sudo_command custom sudo command to use.
+    #   Default is "sudo -E".
+    # @option options [String] :log_subject used in the output or log header
+    #   for clarity and context. Default is "local".
+    # @option options [String] :cwd the directory to chdir to before running
+    #   the command
+    # @option options [Hash] :environment a Hash of environment variables to
+    #   set before the command is run. By default, the environment will
+    #   *always* be set to `'LC_ALL' => 'C'` to prevent issues with multibyte
+    #   characters in Ruby 1.8. To avoid this, use :environment => nil for
+    #   *no* extra environment settings, or
+    #   `:environment => {'LC_ALL'=>nil, ...}` to set other environment
+    #   settings without changing the locale.
+    # @option options [Integer] :timeout Numeric value for the number of
+    #   seconds to wait on the child process before raising an Exception.
+    #   This is calculated as the total amount of time that ShellOut waited on
+    #   the child process without receiving any output (i.e., IO.select
+    #   returned nil). Default is 60000 seconds. Note: the stdlib Timeout
+    #   library is not used.
+    # @return [String] the standard output of the command as a String
+    # @raise [ShellCommandFailed] if the command fails
+    # @raise [Error] for all other unexpected exceptions
+    def run_command(cmd, options = {})
+      if options.fetch(:use_sudo, false)
+        cmd = "#{options.fetch(:sudo_command, "sudo -E")} #{cmd}"
+      end
+      subject = "[#{options.fetch(:log_subject, "local")} command]"
+
+      debug("#{subject} BEGIN (#{cmd})")
+      sh = Mixlib::ShellOut.new(cmd, shell_opts(options))
+      sh.run_command
+      debug("#{subject} END #{Util.duration(sh.execution_time)}")
+      sh.error!
+      sh.stdout
+    rescue Mixlib::ShellOut::ShellCommandFailed => ex
+      raise ShellCommandFailed, ex.message
+    rescue Exception => error # rubocop:disable Lint/RescueException
+      error.extend(Kitchen::Error)
+      raise
+    end
+
+    private
+
+    # Returns a hash of MixLib::ShellOut options for the command.
+    #
+    # @param options [Hash] a Hash of options
+    # @return [Hash] a new Hash of options, filterd and merged with defaults
+    # @api private
+    def shell_opts(options)
+      filtered_opts = options.reject do |key, _value|
+        %i{use_sudo sudo_command log_subject quiet}.include?(key)
+      end
+      { live_stream: logger, timeout: 60_000 }.merge(filtered_opts)
+    end
+  end
+end

data/lib/kitchen/ssh.rb

@@ -0,0 +1,289 @@
+#
+# 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
+#
+#    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 "logger"
+module Net
+  autoload :SSH, "net/ssh"
+end
+require "socket" unless defined?(Socket)
+
+require_relative "errors"
+require_relative "login_command"
+
+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)
+      logger.debug("[SSH] #{self} (#{cmd})")
+      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 http://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 http://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?
+
+      logger.debug("[SSH] closing connection to #{self}")
+      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
+        logger.debug("[SSH] opening connection to #{self}")
+        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

data/lib/kitchen/state_file.rb

@@ -0,0 +1,112 @@
+#
+# 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
+#
+#    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.
+
+autoload :YAML, "yaml"
+
+module Kitchen
+  # Exception class for any exceptions raised when reading and parsing a state
+  # file from disk
+  class StateFileLoadError < StandardError; end
+
+  # State persistence manager for instances between actions and invocations.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class StateFile
+    # Constructs an new instance taking the kitchen root and instance name.
+    #
+    # @param kitchen_root [String] path to the Kitchen project's root directory
+    # @param name [String] name of the instance representing this state
+    def initialize(kitchen_root, name)
+      @file_name = File.expand_path(
+        File.join(kitchen_root, ".kitchen", "#{name}.yml")
+      )
+    end
+
+    # Reads and loads an instance's state into a Hash data structure which is
+    # returned.
+    #
+    # @return [Hash] a hash representation of an instance's state
+    # @raise [StateFileLoadError] if there is a problem loading the state file
+    #   from disk and loading it into a Hash
+    def read
+      if File.exist?(file_name) && !File.zero?(file_name)
+        Util.symbolized_hash(deserialize_string(read_file))
+      else
+        {}
+      end
+    end
+
+    # Serializes the state hash and writes a state file to disk.
+    #
+    # @param state [Hash] the current state of the instance
+    def write(state)
+      dir = File.dirname(file_name)
+      serialized_string = serialize_hash(Util.stringified_hash(state))
+
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      File.open(file_name, "wb") { |f| f.write(serialized_string) }
+    end
+
+    # Destroys a state file on disk if it exists.
+    def destroy
+      FileUtils.rm_f(file_name) if File.exist?(file_name)
+    end
+
+    # Returns a Hash of configuration and other useful diagnostic information.
+    #
+    # @return [Hash] a diagnostic hash
+    def diagnose
+      raw = read
+      result = {}
+      raw.keys.sort.each { |k| result[k] = raw[k] }
+      result
+    end
+
+    private
+
+    # @return [String] absolute path to the yaml state file on disk
+    # @api private
+    attr_reader :file_name
+
+    # @return [String] a string representation of the yaml state file
+    # @api private
+    def read_file
+      IO.read(file_name)
+    end
+
+    # Parses a YAML string and returns a Hash.
+    #
+    # @param string [String] a yaml document as a string
+    # @return [Hash] a hash
+    # @raise [StateFileLoadError] if the string document cannot be parsed
+    # @api private
+    def deserialize_string(string)
+      YAML.safe_load(string)
+    rescue SyntaxError, Psych::SyntaxError, Psych::DisallowedClass => ex
+      raise StateFileLoadError, "Error parsing #{file_name} (#{ex.message})"
+    end
+
+    # Serializes a Hash into a YAML string.
+    #
+    # @param hash [Hash] a hash
+    # @return [String] a yaml document as a string
+    # @api private
+    def serialize_hash(hash)
+      ::YAML.dump(hash)
+    end
+  end
+end

data/lib/kitchen/suite.rb

@@ -0,0 +1,48 @@
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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
+#
+#    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.
+
+module Kitchen
+  # A logical configuration representing a test case or fixture that will be
+  # executed on a platform.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class Suite
+    # @return [String] logical name of this suite
+    attr_reader :name
+
+    # @return [Array] Array of names of excluded platforms
+    attr_reader :excludes
+
+    # @return [Array] Array of names of only included platforms
+    attr_reader :includes
+
+    # Constructs a new suite.
+    #
+    # @param [Hash] options configuration for a new suite
+    # @option options [String] :name logical name of this suit (**Required**)
+    # @option options [String] :excludes Array of names of excluded platforms
+    # @option options [String] :includes Array of names of only included
+    #   platforms
+    def initialize(options = {})
+      @name = options.fetch(:name) do
+        raise ClientError, "Suite#new requires option :name"
+      end
+      @excludes = options.fetch(:excludes, [])
+      @includes = options.fetch(:includes, [])
+    end
+  end
+end

data/lib/kitchen/thor_tasks.rb

@@ -0,0 +1,63 @@
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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
+#
+#    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 "thor" unless defined?(Thor)
+
+require_relative "../kitchen"
+
+module Kitchen
+  # Kitchen Thor task generator.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class ThorTasks < Thor
+    namespace :kitchen
+
+    # Creates Kitchen Thor tasks and allows the callee to configure it.
+    #
+    # @yield [self] gives itself to the block
+    def initialize(*args)
+      super
+      @config = Kitchen::Config.new
+      Kitchen.logger = Kitchen.default_file_logger(nil, false)
+      yield self if block_given?
+      define
+    end
+
+    private
+
+    # @return [Config] a Kitchen::Config
+    attr_reader :config
+
+    # Generates a test Thor task for each instance and one to test all
+    # instances in serial.
+    #
+    # @api private
+    def define
+      config.instances.each do |instance|
+        self.class.desc instance.name, "Run #{instance.name} test instance"
+        self.class.send(:define_method, instance.name.tr("-", "_")) do
+          instance.test(:always)
+        end
+      end
+
+      self.class.desc "all", "Run all test instances"
+      self.class.send(:define_method, :all) do
+        config.instances.each { |i| invoke i.name.tr("-", "_") }
+      end
+    end
+  end
+end