test-kitchen-rsync 3.0.0.pre.1

data/lib/kitchen/command.rb

@@ -0,0 +1,207 @@
+#
+# 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.
+
+module Kitchen
+  module Command
+    # Base class for CLI commands.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Base
+      include Logging
+
+      # Contstructs a new Command object.
+      #
+      # @param cmd_args [Array] remainder of the arguments from processed ARGV
+      # @param cmd_options [Hash] hash of Thor options
+      # @param options [Hash] configuration options
+      # @option options [String] :action action to take, usually corresponding
+      #   to the subcommand name (default: `nil`)
+      # @option options [proc] :help a callable that displays help for the
+      #   command
+      # @option options [Config] :config a Config object (default: `nil`)
+      # @option options [Loader] :loader a Loader object (default: `nil`)
+      # @option options [String] :shell a Thor shell object
+      def initialize(cmd_args, cmd_options, options = {})
+        @args = cmd_args
+        @options = cmd_options
+        @action = options.fetch(:action, nil)
+        @help = options.fetch(:help, -> { "No help provided" })
+        @config = options.fetch(:config, nil)
+        @loader = options.fetch(:loader, nil)
+        @shell = options.fetch(:shell)
+      end
+
+      private
+
+      # @return [Array] remainder of the arguments from processed ARGV
+      # @api private
+      attr_reader :args
+
+      # @return [Hash] hash of Thor options
+      # @api private
+      attr_reader :options
+
+      # @return [proc] a callable that displays help for the command
+      # @api private
+      attr_reader :help
+
+      # @return [Config] a Config object
+      # @api private
+      attr_reader :config
+
+      # @return [Thor::Shell] a Thor shell object
+      # @api private
+      attr_reader :shell
+
+      # @return [String] the action to perform
+      # @api private
+      attr_reader :action
+
+      # Emit an error message, display contextual help and then exit with a
+      # non-zero exit code.
+      #
+      # **Note** This method calls exit and will not return.
+      #
+      # @param msg [String] error message
+      # @api private
+      def die(msg)
+        error "\n#{msg}\n\n"
+        help.call
+        exit 1
+      end
+
+      # @return [Array<Instance>] an array of instances
+      # @raise [SystemExit] if no instances are returned
+      # @api private
+      def all_instances
+        result = @config.instances
+
+        if result.empty?
+          die "No instances defined"
+        else
+          result
+        end
+      end
+
+      # Return an array on instances whos name matches the regular expression.
+      #
+      # @param regexp [Regexp] a regular expression matching on instance names
+      # @return [Array<Instance>] an array of instances
+      # @raise [SystemExit] if no instances are returned or the regular
+      #   expression is invalid
+      # @api private
+      def filtered_instances(regexp)
+        result = begin
+          @config.instances.get(regexp) ||
+            @config.instances.get_all(/#{regexp}/)
+                 rescue RegexpError => e
+                   die "Invalid Ruby regular expression, " \
+                     "you may need to single quote the argument. " \
+                     "Please try again or consult http://rubular.com/ (#{e.message})"
+        end
+        result = Array(result)
+
+        if result.empty?
+          die "No instances for regex `#{regexp}', try running `kitchen list'"
+        else
+          result
+        end
+      end
+
+      # @return [Logger] the common logger
+      # @api private
+      def logger
+        Kitchen.logger
+      end
+
+      # Return an array on instances whos name matches the regular expression,
+      # the full instance name, or  the `"all"` literal.
+      #
+      # @param arg [String] an instance name, a regular expression, the literal
+      #   `"all"`, or `nil`
+      # @return [Array<Instance>] an array of instances
+      # @api private
+      def parse_subcommand(arg = nil)
+        arg == "all" ? all_instances : filtered_instances(arg)
+      end
+    end
+
+    # Common module to execute a Kitchen action such as create, converge, etc.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    module RunAction
+      # Run an instance action (create, converge, setup, verify, destroy) on
+      # a collection of instances. The instance actions will take place in a
+      # seperate thread of execution which may or may not be running
+      # concurrently.
+      #
+      # @param action [String] action to perform
+      # @param instances [Array<Instance>] an array of instances
+      def run_action(action, instances, *args)
+        concurrency = concurrency_setting(instances)
+
+        queue = Queue.new
+        instances.each { |i| queue << i }
+        concurrency.times { queue << nil }
+
+        threads = []
+        @action_errors = []
+        concurrency.times do
+          threads << Thread.new do
+            while (instance = queue.pop)
+              run_action_in_thread(action, instance, *args)
+            end
+          end
+        end
+        Thread.abort_on_exception = true if options[:fail_fast]
+        threads.map(&:join)
+        report_errors
+      end
+
+      # private
+
+      def report_errors
+        unless @action_errors.empty?
+          msg = ["#{@action_errors.length} actions failed.",
+                 @action_errors.map { |e| ">>>>>>     #{e.message}" }].join("\n")
+          raise ActionFailed.new(msg, @action_errors)
+        end
+      end
+
+      def concurrency_setting(instances)
+        concurrency = 1
+        if options[:concurrency]
+          concurrency = options[:concurrency] || instances.size
+          concurrency = instances.size if concurrency > instances.size
+        end
+        concurrency
+      end
+
+      def run_action_in_thread(action, instance, *args)
+        instance.public_send(action, *args)
+      rescue Kitchen::InstanceFailure => e
+        @action_errors << 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
+      ensure
+        instance.cleanup!
+      end
+    end
+  end
+end

data/lib/kitchen/config.rb

@@ -0,0 +1,344 @@
+#
+# 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.
+
+module Kitchen
+  # Base configuration class for Kitchen. This class exposes configuration such
+  # as the location of the Kitchen config file, instances, log_levels, etc.
+  # This object is a factory object, meaning that it is responsible for
+  # consuming the desired testing configuration in and returning Ruby objects
+  # which are used to perfom the work.
+  #
+  # Most internal objects are created with the expectation of being
+  # *immutable*, meaning that internal state cannot be modified after creation.
+  # Any data manipulation or thread-unsafe activity is performed in this object
+  # so that the subsequently created objects (such as Instances, Platforms,
+  # Drivers, etc.) can safely run in concurrent threads of execution. To
+  # prevent the re-creation of duplicate objects, most created objects are
+  # memoized. The consequence of this is that once the Instance Array has
+  # been requested (with the `#instances` message), you will always be returned
+  # the same Instance objects.
+  #
+  # @example fetching all instances
+  #
+  #   Kitchen::Config.new.instances
+  #
+  # @example fetching an instance by name
+  #
+  #   Kitchen::Config.new.instances.get("default-ubuntu-16.04")
+  #
+  # @example fetching all instances matching a regular expression
+  #
+  #   Kitchen::Config.new.instances.get_all(/ubuntu/)
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class Config
+    # @return [String] the absolute path to the root of a Test Kitchen project
+    # @api private
+    attr_reader :kitchen_root
+
+    # @return [String] the absolute path to the directory into which all Test
+    #   Kitchen log files will be written
+    # @api private
+    attr_reader :log_root
+
+    # @return [#read] the data loader that responds to a `#read` message,
+    #   returning a Hash data structure
+    # @api private
+    attr_reader :loader
+
+    # @return [Symbol] the logging verbosity level
+    # @api private
+    attr_accessor :log_level
+
+    # @return [Boolean] whether to overwrite the log file when
+    #   Test Kitchen runs
+    # @api private
+    attr_accessor :log_overwrite
+
+    # @return [String] an absolute path to the directory containing test suites
+    # @api private
+    attr_accessor :test_base_path
+
+    # @return [Boolean] whether to force color output or not in logger
+    # @api private
+    attr_accessor :colorize
+
+    # @return [Boolean] whether to enable debugging in the provisioner/verifier plugin or not
+    # @api private
+    attr_accessor :debug
+
+    # Creates a new configuration, representing a particular testing
+    # configuration for a project.
+    #
+    # @param [Hash] options configuration
+    # @option options [#read] :loader an object that responds to `#read` with
+    #   a Hash structure suitable for manipulating
+    #   (default: `Kitchen::Loader::YAML.new`)
+    # @option options [String] :kitchen_root an absolute path to the root of a
+    #   Test Kitchen project, usually containing a `.kitchen.yml` file
+    #   (default `Dir.pwd`)
+    # @option options [String] :log_root an absolute path to the directory
+    #   into which all Test Kitchen log files will be written
+    #   (default: `"#{kitchen_root}/.kitchen/logs"`)
+    # @option options [String] :test_base_path an absolute path to the
+    #   directory containing test suites and other testing-related files and
+    #   directories (default: `"#{kitchen_root}/test/integration"`)
+    # @option options [Symbol] :log_level the log level verbosity that the
+    #   loggers will use when outputing information (default: `:info`)
+    def initialize(options = {})
+      @loader         = options.fetch(:loader) { Kitchen::Loader::YAML.new }
+      @kitchen_root   = options.fetch(:kitchen_root) { Dir.pwd }
+      @log_level      = options.fetch(:log_level) { Kitchen::DEFAULT_LOG_LEVEL }
+      @log_overwrite  = options.fetch(:log_overwrite) { Kitchen::DEFAULT_LOG_OVERWRITE }
+      @colorize       = options.fetch(:colorize) { Kitchen.tty? }
+      @log_root       = options.fetch(:log_root) { default_log_root }
+      @test_base_path = options.fetch(:test_base_path) { default_test_base_path }
+      @debug          = options.fetch(:debug) { false }
+    end
+
+    # @return [Collection<Instance>] all instances, resulting from all
+    #   platform and suite combinations
+    def instances
+      @instances ||= Collection.new(build_instances)
+    end
+
+    # @return [Collection<Platform>] all defined platforms which will be used
+    #   in convergence integration
+    def platforms
+      @platforms ||= Collection.new(
+        data.platform_data.map { |pdata| Platform.new(pdata) }
+      )
+    end
+
+    # @return [Collection<Suite>] all defined suites which will be used in
+    #   convergence integration
+    def suites
+      @suites ||= Collection.new(
+        data.suite_data.map { |sdata| Suite.new(sdata) }
+      )
+    end
+
+    private
+
+    # Builds the filtered list of Instance objects.
+    #
+    # @return [Array<Instance] an array of Instances
+    # @api private
+    def build_instances
+      filter_instances.map.with_index do |(suite, platform), index|
+        new_instance(suite, platform, index)
+      end
+    end
+
+    # Returns an object which can generate configuration hashes for all the
+    # primary Test Kitchen objects such as Drivers, Provisioners, etc.
+    #
+    # @return [DataMunger] a data manipulator
+    # @api private
+    def data
+      @data ||= DataMunger.new(loader.read, kitchen_config)
+    end
+
+    # Determines the default absolute path to a log directory, based on the
+    # value of `#kitchen_root`.
+    #
+    # @return [String] an absolute path to the log directory
+    # @api private
+    def default_log_root
+      File.join(kitchen_root, Kitchen::DEFAULT_LOG_DIR)
+    end
+
+    # Determines the default absolute path to the testing files directory,
+    # based on the the value of `#kitchen_root`.
+    #
+    # @return [String] an absolute path to the testing files directory
+    # @api private
+    def default_test_base_path
+      File.join(kitchen_root, Kitchen::DEFAULT_TEST_DIR)
+    end
+
+    # Generates a filtered Array of tuples (Suite/Platform pairs) which is the
+    # cartesian product of suites and platforms. A Suite has two optional
+    # arrays (`#includes` and `#excludes`) which can be used to drop or
+    # select certain Platforms with which to join.
+    #
+    # @return [Array<Array<Suite, Platform>>] an Array of Suite/Platform
+    #   tuples
+    # @api private
+    def filter_instances
+      suites.product(platforms).select do |suite, platform|
+        if !suite.includes.empty?
+          suite.includes.include?(platform.name)
+        elsif !suite.excludes.empty?
+          !suite.excludes.include?(platform.name)
+        else
+          true
+        end
+      end
+    end
+
+    # Determines the String name for an Instance, given a Suite and a Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [String] an Instance name
+    # @api private
+    def instance_name(suite, platform)
+      Instance.name_for(suite, platform)
+    end
+
+    # Generates the immutable Test Kitchen configuration and reasonable
+    # defaults for Drivers, Provisioners and Transports.
+    #
+    # @return [Hash] a configuration Hash
+    # @api private
+    def kitchen_config
+      @kitchen_config ||= {
+        defaults: {
+          driver: Driver::DEFAULT_PLUGIN,
+          provisioner: Provisioner::DEFAULT_PLUGIN,
+          verifier: Verifier::DEFAULT_PLUGIN,
+          transport: lambda do |_suite, platform|
+            /^win/i.match?(platform) ? "winrm" : Transport::DEFAULT_PLUGIN
+          end,
+        },
+        kitchen_root: kitchen_root,
+        test_base_path: test_base_path,
+        log_level: log_level,
+        log_overwrite: log_overwrite,
+        debug: debug,
+      }
+    end
+
+    # Builds a newly configured Driver object, for a given Suite and Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [Driver] a new Driver object
+    # @api private
+    def new_driver(suite, platform)
+      ddata = data.driver_data_for(suite.name, platform.name)
+      Driver.for_plugin(ddata[:name], ddata)
+    end
+
+    # Builds a newly configured Instance object, for a given Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @param index [Integer] an index used for colorizing output
+    # @return [Instance] a new Instance object
+    # @api private
+    def new_instance(suite, platform, index)
+      sf = new_state_file(suite, platform)
+
+      Instance.new(
+        driver: new_driver(suite, platform),
+        lifecycle_hooks: new_lifecycle_hooks(suite, platform, sf),
+        logger: new_instance_logger(suite, platform, index),
+        suite: suite,
+        platform: platform,
+        provisioner: new_provisioner(suite, platform),
+        transport: new_transport(suite, platform),
+        verifier: new_verifier(suite, platform),
+        state_file: sf
+      )
+    end
+
+    # Builds a newly configured Logger object, for a given Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @param index [Integer] an index used for colorizing output
+    # @return [Logger] a new Logger object
+    # @api private
+    def new_instance_logger(suite, platform, index)
+      name = instance_name(suite, platform)
+      log_location = File.join(log_root, "#{name}.log").to_s
+      Logger.new(
+        stdout: STDOUT,
+        color: Color::COLORS[index % Color::COLORS.size].to_sym,
+        logdev: log_location,
+        level: Util.to_logger_level(log_level),
+        log_overwrite: log_overwrite,
+        progname: name,
+        colorize: @colorize
+      )
+    end
+
+    # Builds a newly configured LifecycleHooks object, for a given a Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @param state_file [Kitchen::StateFile] a SateFile
+    # @return [LifecycleHooks] a new LifecycleHooks object
+    # @api private
+    def new_lifecycle_hooks(suite, platform, state_file)
+      lhdata = data.lifecycle_hooks_data_for(suite.name, platform.name)
+      LifecycleHooks.new(lhdata, state_file)
+    end
+
+    # Builds a newly configured Provisioner object, for a given Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [Provisioner] a new Provisioner object
+    # @api private
+    def new_provisioner(suite, platform)
+      pdata = data.provisioner_data_for(suite.name, platform.name)
+      Provisioner.for_plugin(pdata[:name], pdata)
+    end
+
+    # Builds a newly configured StateFile object, for a given Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [StateFile] a new StateFile object
+    # @api private
+    def new_state_file(suite, platform)
+      StateFile.new(kitchen_root, instance_name(suite, platform))
+    end
+
+    # Builds a newly configured Transport object, for a given Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [Transport] a new Transport object
+    # @api private
+    def new_transport(suite, platform)
+      tdata = data.transport_data_for(suite.name, platform.name)
+      Transport.for_plugin(tdata[:name], tdata)
+    end
+
+    # Builds a newly configured Verifier object, for a given a Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [Verifier] a new Verifier object
+    # @api private
+    def new_verifier(suite, platform)
+      vdata = data.verifier_data_for(suite.name, platform.name)
+      Verifier.for_plugin(vdata[:name], vdata)
+    end
+  end
+end