test-kitchen-rsync 3.0.0.pre.1

data/lib/kitchen/diagnostic.rb

@@ -0,0 +1,138 @@
+#
+# 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_relative "util"
+require_relative "version"
+
+module Kitchen
+  # Combines and compiles diagnostic information about a Test Kitchen
+  # configuration suitable for support and troubleshooting.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class Diagnostic
+    # Constructs a new Diagnostic object with an optional loader and optional
+    # instances array.
+    #
+    # @param options [Hash] optional configuration
+    # @option options [#diagnose,Hash] :loader a loader instance that responds
+    #   to `#diagnose` or an error Hash
+    # @option options [Array<#diagnose>,Hash] :instances an Array of instances
+    #   that respond to `#diagnose` or an error Hash
+    # @option options [true,false] :plugins whether or not plugins should be
+    #   returned
+    def initialize(options = {})
+      @loader = options.fetch(:loader, nil)
+      @instances = options.fetch(:instances, [])
+      @plugins = options.fetch(:plugins, false)
+      @result = {}
+    end
+
+    # Returns a Hash with stringified keys containing diagnostic information.
+    #
+    # @return [Hash] a configuration Hash
+    def read
+      prepare_common
+      prepare_plugins
+      prepare_loader
+      prepare_instances
+
+      Util.stringified_hash(result)
+    end
+
+    private
+
+    # @return [Hash] a result hash
+    # @api private
+    attr_reader :result
+
+    # @return [#diagnose,Hash] a loader instance that responds to `#diagnose`
+    #   or an error Hash
+    # @api private
+    attr_reader :loader
+
+    # @return [Array<#diagnose>,Hash] an Array of instances that respond to
+    #   `#diagnose` or an error Hash
+    # @api private
+    attr_reader :instances
+
+    # Adds common information to the result Hash.
+    #
+    # @api private
+    def prepare_common
+      result[:timestamp] = Time.now.gmtime.to_s
+      result[:kitchen_version] = Kitchen::VERSION
+    end
+
+    # Adds loader information to the result Hash.
+    #
+    # @api private
+    def prepare_loader
+      if error_hash?(loader)
+        result[:loader] = loader
+      else
+        result[:loader] = loader.diagnose if loader
+      end
+    end
+
+    # Adds plugin information to the result Hash.
+    #
+    # @api private
+    def prepare_plugins
+      return unless @plugins
+
+      if error_hash?(instances)
+        result[:plugins] = { error: instances[:error] }
+      elsif instances.empty?
+        result[:plugins] = {}
+      else
+        plugins = {
+          driver: [], provisioner: [], transport: [], verifier: []
+        }
+        instances.map(&:diagnose_plugins).each do |plugin_hash|
+          plugin_hash.each { |type, plugin| plugins[type] << plugin }
+        end
+        plugins.each do |type, list|
+          plugins[type] =
+            Hash[list.uniq.map { |hash| [hash.delete(:name), hash] }]
+        end
+        result[:plugins] = plugins
+      end
+    end
+
+    # Adds instance information to the result Hash.
+    #
+    # @api private
+    def prepare_instances
+      result[:instances] = {}
+      if error_hash?(instances)
+        result[:instances][:error] = instances[:error]
+      else
+        Array(instances).each { |i| result[:instances][i.name] = i.diagnose }
+      end
+    end
+
+    # Determins whether or not the object is an error hash. An error hash is
+    # defined as a Hash containing an `:error` key.
+    #
+    # @param obj [Object] an object
+    # @return [true,false] whether or not the object is an error hash
+    # @api private
+    def error_hash?(obj)
+      obj.is_a?(Hash) && obj.key?(:error)
+    end
+  end
+end

data/lib/kitchen/driver/base.rb

@@ -0,0 +1,133 @@
+#
+# 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_relative "../configurable"
+require_relative "../errors"
+require_relative "../lazy_hash"
+require_relative "../logging"
+require_relative "../plugin_base"
+require_relative "../shell_out"
+
+module Kitchen
+  module Driver
+    # Base class for a driver.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Base < Kitchen::Plugin::Base
+      include Configurable
+      include Logging
+      include ShellOut
+
+      default_config :pre_create_command, nil
+
+      # Creates a new Driver object using the provided configuration data
+      # which will be merged with any default configuration.
+      #
+      # @param config [Hash] provided driver configuration
+      def initialize(config = {})
+        init_config(config)
+      end
+
+      # Creates an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def create(state) # rubocop:disable Lint/UnusedMethodArgument
+        pre_create_command
+      end
+
+      # Destroys an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def destroy(state); end
+
+      # Package an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def package(state); end
+
+      # Check system and configuration for common errors.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @returns [Boolean] Return true if a problem is found.
+      def doctor(state)
+        false
+      end
+
+      # Sets the API version for this driver. If the driver does not set this
+      # value, then `nil` will be used and reported.
+      #
+      # Sets the API version for this driver
+      #
+      # @example setting an API version
+      #
+      #   module Kitchen
+      #     module Driver
+      #       class NewDriver < Kitchen::Driver::Base
+      #
+      #         kitchen_driver_api_version 2
+      #
+      #       end
+      #     end
+      #   end
+      #
+      # @param version [Integer,String] a version number
+      #
+      def self.kitchen_driver_api_version(version)
+        @api_version = version
+      end
+
+      # Cache directory that a driver could implement to inform the provisioner
+      # that it can leverage it internally
+      #
+      # @return path [String] a path of the cache directory
+      def cache_directory; end
+
+      private
+
+      # Run command if config[:pre_create_command] is set
+      def pre_create_command
+        if config[:pre_create_command]
+          begin
+            run_command(config[:pre_create_command])
+          rescue ShellCommandFailed => error
+            raise ActionFailed,
+              "pre_create_command '#{config[:pre_create_command]}' failed to execute #{error}"
+          end
+        end
+      end
+
+      # Intercepts any bare #puts calls in subclasses and issues an INFO log
+      # event instead.
+      #
+      # @param msg [String] message string
+      def puts(msg)
+        info(msg)
+      end
+
+      # Intercepts any bare #print calls in subclasses and issues an INFO log
+      # event instead.
+      #
+      # @param msg [String] message string
+      def print(msg)
+        info(msg)
+      end
+    end
+  end
+end

data/lib/kitchen/driver/dummy.rb

@@ -0,0 +1,105 @@
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 2013, 2014 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_relative "../../kitchen"
+
+module Kitchen
+  module Driver
+    # Dummy driver for Kitchen. This driver does nothing but report what would
+    # happen if this driver did anything of consequence. As a result it may
+    # be a useful driver to use when debugging or developing new features or
+    # plugins.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Dummy < Kitchen::Driver::Base
+      kitchen_driver_api_version 2
+
+      plugin_version Kitchen::VERSION
+
+      default_config :sleep, 0
+      default_config :random_failure, false
+
+      # (see Base#create)
+      def create(state)
+        # Intentionally not calling `super` to avoid pre_create_command.
+        state[:my_id] = "#{instance.name}-#{Time.now.to_i}"
+        report(:create, state)
+      end
+
+      # (see Base#setup)
+      def setup(state)
+        report(:setup, state)
+      end
+
+      # (see Base#verify)
+      def verify(state)
+        report(:verify, state)
+      end
+
+      # (see Base#destroy)
+      def destroy(state)
+        report(:destroy, state)
+        state.delete(:my_id)
+      end
+
+      private
+
+      # Report what action is taking place, sleeping if so configured, and
+      # possibly fail randomly.
+      #
+      # @param action [Symbol] the action currently taking place
+      # @param state [Hash] the state hash
+      # @api private
+      def report(action, state)
+        what = action.capitalize
+        info("[Dummy] #{what} on instance=#{instance} with state=#{state}")
+        sleep_if_set
+        failure_if_set(action)
+        debug("[Dummy] #{what} completed (#{config[:sleep]}s).")
+      end
+
+      # Sleep for a period of time, if a value is set in the config.
+      #
+      # @api private
+      def sleep_if_set
+        sleep(config[:sleep].to_f) if config[:sleep].to_f > 0.0
+      end
+
+      # Simulate a failure in an action, if set in the config.
+      #
+      # @param action [Symbol] the action currently taking place
+      # @api private
+      def failure_if_set(action)
+        if config[:"fail_#{action}"]
+          debug("[Dummy] Failure for action ##{action}.")
+          raise ActionFailed, "Action ##{action} failed for #{instance.to_str}."
+        elsif config[:random_failure] && randomly_fail?
+          debug("[Dummy] Random failure for action ##{action}.")
+          raise ActionFailed, "Action ##{action} failed for #{instance.to_str}."
+        end
+      end
+
+      # Determine whether or not to randomly fail.
+      #
+      # @return [true, false]
+      # @api private
+      def randomly_fail?
+        [true, false].sample
+      end
+    end
+  end
+end

data/lib/kitchen/driver/exec.rb

@@ -0,0 +1,70 @@
+#
+# 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_relative "base"
+require_relative "../shell_out"
+require_relative "../transport/exec"
+require_relative "../version"
+
+module Kitchen
+  module Driver
+    # Simple driver that runs commands locally. As with the proxy driver, this
+    # has no isolation in general.
+    class Exec < Kitchen::Driver::Base
+      include ShellOut
+
+      plugin_version Kitchen::VERSION
+
+      default_config :reset_command, nil
+
+      no_parallel_for :create, :converge, :destroy
+
+      # Hack to force using the exec transport when using this driver.
+      # If someone comes up with a use case for using the driver with a different
+      # transport, please let us know.
+      #
+      # @api private
+      def finalize_config!(instance)
+        super.tap do
+          instance.transport = Kitchen::Transport::Exec.new
+        end
+      end
+
+      # (see Base#create)
+      def create(state)
+        super
+        reset_instance(state)
+      end
+
+      # (see Base#destroy)
+      def destroy(state)
+        reset_instance(state)
+      end
+
+      private
+
+      # Resets the non-Kitchen managed instance using by issuing a command
+      # over SSH.
+      #
+      # @param state [Hash] the state hash
+      # @api private
+      def reset_instance(state)
+        if (cmd = config[:reset_command])
+          info("Resetting instance state with command: #{cmd}")
+          run_command(cmd)
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/proxy.rb

@@ -0,0 +1,70 @@
+#
+# Author:: Seth Chisamore <schisamo@opscode.com>
+#
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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_relative "ssh_base"
+require_relative "../version"
+
+module Kitchen
+  module Driver
+    # Simple driver that proxies commands through to a test instance whose
+    # lifecycle is not managed by Test Kitchen. This driver is useful for long-
+    # lived non-ephemeral test instances that are simply "reset" between test
+    # runs. Think executing against devices like network switches--this is why
+    # the driver was created.
+    #
+    # @author Seth Chisamore <schisamo@opscode.com>
+    class Proxy < Kitchen::Driver::SSHBase
+      plugin_version Kitchen::VERSION
+
+      required_config :host
+      default_config :reset_command, nil
+
+      no_parallel_for :create, :destroy
+
+      # (see Base#create)
+      def create(state)
+        # TODO: Once this isn't using SSHBase, it should call `super` to support pre_create_command.
+        state[:hostname] = config[:host]
+        reset_instance(state)
+      end
+
+      # (see Base#destroy)
+      def destroy(state)
+        return if state[:hostname].nil?
+
+        reset_instance(state)
+        state.delete(:hostname)
+      end
+
+      private
+
+      # Resets the non-Kitchen managed instance using by issuing a command
+      # over SSH.
+      #
+      # @param state [Hash] the state hash
+      # @api private
+      def reset_instance(state)
+        if (cmd = config[:reset_command])
+          info("Resetting instance state with command: #{cmd}")
+          ssh(build_ssh_args(state), cmd)
+        end
+      end
+    end
+  end
+end