test-kitchen 1.3.1 → 1.4.0.beta.1

data/lib/kitchen/logger.rb

@@ -34,6 +34,10 @@ module Kitchen
     # @return [IO] the log device
     attr_reader :logdev
 
+    # @return [Boolean] whether logger is configured for
+    #   overwriting
+    attr_reader :log_overwrite
+
     # Constructs a new logger.
     #
     # @param options [Hash] configuration for a new logger
@@ -41,6 +45,9 @@ module Kitchen
     #   messages
     # @option options [Integer] :level the logging severity threshold
     #   (default: `Kitchen::DEFAULT_LOG_LEVEL`)
+    # @option options [Boolean] whether to overwrite the log
+    #   when Test Kitchen runs. Only applies if the :logdev is a String.
+    #   (default: `Kitchen::DEFAULT_LOG_OVERWRITE`)
     # @option options [String,IO] :logdev filepath String or IO object to be
     #   used for logging (default: `nil`)
     # @option options [String] :progname program name to include in log
@@ -49,16 +56,33 @@ module Kitchen
     #   (default: `$stdout`)
     def initialize(options = {})
       color = options[:color]
+      @log_overwrite = if options[:log_overwrite].nil?
+        default_log_overwrite
+      else
+        options[:log_overwrite]
+      end
 
-      @loggers = []
-      @loggers << @logdev = logdev_logger(options[:logdev]) if options[:logdev]
-      @loggers << stdout_logger(options[:stdout], color) if options[:stdout]
-      @loggers << stdout_logger($stdout, color) if @loggers.empty?
+      @logdev = logdev_logger(options[:logdev], log_overwrite) if options[:logdev]
+
+      populate_loggers(color, options)
 
+      # These setters cannot be called until @loggers are populated because
+      # they are delegated
       self.progname = options[:progname] || "Kitchen"
       self.level = options[:level] || default_log_level
     end
 
+    # Pulled out for Rubocop complexity issues
+    #
+    # @api private
+    def populate_loggers(color, options)
+      @loggers = []
+      @loggers << logdev unless logdev.nil?
+      @loggers << stdout_logger(options[:stdout], color) if options[:stdout]
+      @loggers << stdout_logger($stdout, color) if @loggers.empty?
+    end
+    private :populate_loggers
+
     class << self
 
       private
@@ -252,6 +276,12 @@ module Kitchen
       Util.to_logger_level(Kitchen::DEFAULT_LOG_LEVEL)
     end
 
+    # @return [Boolean] whether to overwrite logs by default
+    # @api private
+    def default_log_overwrite
+      Kitchen::DEFAULT_LOG_OVERWRITE
+    end
+
     # Construct a new standard out logger.
     #
     # @param stdout [IO] the IO object that represents stdout (or similar)
@@ -275,21 +305,26 @@ module Kitchen
     # Construct a new logdev logger.
     #
     # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @param log_overwrite [Boolean] apply log overwriting
+    #   if filepath_or_logdev is a file path
     # @return [LogdevLogger] a new logger
     # @api private
-    def logdev_logger(filepath_or_logdev)
-      LogdevLogger.new(resolve_logdev(filepath_or_logdev))
+    def logdev_logger(filepath_or_logdev, log_overwrite)
+      LogdevLogger.new(resolve_logdev(filepath_or_logdev, log_overwrite))
     end
 
     # Return an IO object from a filepath String or the IO object itself.
     #
     # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @param log_overwrite [Boolean] apply log overwriting
+    #   if filepath_or_logdev is a file path
     # @return [IO] an IO object
     # @api private
-    def resolve_logdev(filepath_or_logdev)
+    def resolve_logdev(filepath_or_logdev, log_overwrite)
       if filepath_or_logdev.is_a? String
+        mode = log_overwrite ? "wb" : "ab"
         FileUtils.mkdir_p(File.dirname(filepath_or_logdev))
-        file = File.open(File.expand_path(filepath_or_logdev), "ab")
+        file = File.open(File.expand_path(filepath_or_logdev), mode)
         file.sync = true
         file
       else

data/lib/kitchen/login_command.rb

@@ -24,20 +24,29 @@ module Kitchen
   # @author Fletcher Nichol <fnichol@nichol.ca>
   class LoginCommand
 
-    # @return [Array] array of login command arguments
-    attr_reader :cmd_array
+    # @return [String] login command
+    attr_reader :command
+
+    # @return [Array] array of arguments to the command
+    attr_reader :arguments
 
     # @return [Hash] options hash, passed to `Kernel#exec`
     attr_reader :options
 
     # Constructs a new LoginCommand instance.
     #
-    # @param cmd_array [Array] array of login command arguments
+    # @param command [String] command
+    # @param arguments [Array] array of arguments to the command
     # @param options [Hash] options hash, passed to `Kernel#exec`
     # @see http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-exec
-    def initialize(cmd_array, options = {})
-      @cmd_array = Array(cmd_array)
+    def initialize(command, arguments, options = {})
+      @command = command
+      @arguments = Array(arguments)
       @options = options
     end
+
+    def exec_args
+      [command, *arguments, options]
+    end
   end
 end

data/lib/kitchen/platform.rb

@@ -28,6 +28,12 @@ module Kitchen
     # @return [String] logical name of this platform
     attr_reader :name
 
+    # @return [String] operating system type hint (default: `"unix"`)
+    attr_reader :os_type
+
+    # @return [String] shell command flavor hint (default: `"bourne"`)
+    attr_reader :shell_type
+
     # Constructs a new platform.
     #
     # @param [Hash] options configuration for a new platform
@@ -37,6 +43,19 @@ module Kitchen
       @name = options.fetch(:name) do
         raise ClientError, "Platform#new requires option :name"
       end
+      @os_type = options.fetch(:os_type) do
+        @name.downcase =~ /^win/ ? "windows" : "unix"
+      end
+      @shell_type = options.fetch(:shell_type) do
+        @name.downcase =~ /^win/ ? "powershell" : "bourne"
+      end
+    end
+
+    # Returns a Hash of configuration and other useful diagnostic information.
+    #
+    # @return [Hash] a diagnostic hash
+    def diagnose
+      { :os_type => os_type, :shell_type => shell_type }
     end
   end
 end

data/lib/kitchen/provisioner.rb

@@ -34,14 +34,16 @@ module Kitchen
     #
     # @param plugin [String] a provisioner plugin type, to be constantized
     # @param config [Hash] a configuration hash to initialize the provisioner
-    # @return [Provisioner::Base] a driver instance
+    # @return [Provisioner::Base] a provisioner instance
     # @raise [ClientError] if a provisioner instance could not be created
     def self.for_plugin(plugin, config)
-      require("kitchen/provisioner/#{plugin}")
+      first_load = require("kitchen/provisioner/#{plugin}")
 
       str_const = Thor::Util.camel_case(plugin)
       klass = const_get(str_const)
-      klass.new(config)
+      object = klass.new(config)
+      object.verify_dependencies if first_load
+      object
     rescue LoadError, NameError
       raise ClientError,
         "Could not load the '#{plugin}' provisioner from the load path." \

data/lib/kitchen/provisioner/base.rb

@@ -28,8 +28,17 @@ module Kitchen
       include Configurable
       include Logging
 
-      default_config :root_path, "/tmp/kitchen"
-      default_config :sudo, true
+      default_config :http_proxy, nil
+
+      default_config :https_proxy, nil
+
+      default_config :root_path do |provisioner|
+        provisioner.windows_os? ? "$env:TEMP\\kitchen" : "/tmp/kitchen"
+      end
+
+      default_config :sudo do |provisioner|
+        provisioner.windows_os? ? nil : true
+      end
 
       expand_path_for :test_base_path
 
@@ -40,26 +49,27 @@ module Kitchen
         init_config(config)
       end
 
-      # Performs any final configuration required for the provisioner to do its
-      # work. A reference to an Instance is required as configuration dependant
-      # data may need access through an Instance. This also acts as a hook
-      # point where the object may wish to perform other last minute checks,
-      # valiations, or configuration expansions.
-      #
-      # @param instance [Instance] an associated instance
-      # @return [self] itself, used for chaining
-      # @raise [ClientError] if instance parameter is nil
-      def finalize_config!(instance)
-        super
-        load_needed_dependencies!
-        self
-      end
-
-      # Returns the name of this driver, suitable for display in a CLI.
-      #
-      # @return [String] name of this driver
-      def name
-        self.class.name.split("::").last
+      # Runs the provisioner on the instance.
+      #
+      # @param state [Hash] mutable instance state
+      # @raise [ActionFailed] if the action could not be completed
+      def call(state)
+        create_sandbox
+        sandbox_dirs = Dir.glob(File.join(sandbox_path, "*"))
+
+        instance.transport.connection(state) do |conn|
+          conn.execute(install_command)
+          conn.execute(init_command)
+          info("Transferring files to #{instance.to_str}")
+          conn.upload(sandbox_dirs, config[:root_path])
+          debug("Transfer complete")
+          conn.execute(prepare_command)
+          conn.execute(run_command)
+        end
+      rescue Kitchen::Transport::TransportFailed => ex
+        raise ActionFailed, ex.message
+      ensure
+        cleanup_sandbox
       end
 
       # Generates a command string which will install and configure the
@@ -145,34 +155,22 @@ module Kitchen
 
       private
 
-      # Loads any required third party Ruby libraries or runs any shell out
-      # commands to prepare the provisioner. This method will be called in the
-      # context of the main thread of execution and so does not necessarily
-      # have to be thread safe.
-      #
-      # **Note:** any subclasses overriding this method would be well advised
-      # to call super when overriding this method, for example:
+      # Builds a complete command given a variables String preamble and a file
+      # containing shell code.
       #
-      # @example overriding `#load_needed_dependencies!`
-      #
-      #   class MyProvisioner < Kitchen::Provisioner::Base
-      #     def load_needed_dependencies!
-      #       super
-      #       # any further work
-      #     end
-      #   end
-      #
-      # @raise [ClientError] if any library loading fails or any of the
-      #   dependency requirements cannot be satisfied
-      # @api private
-      def load_needed_dependencies!
-      end
-
-      # @return [Logger] the instance's logger or Test Kitchen's common logger
-      #   otherwise
+      # @param vars [String] shell variables, as a String
+      # @param file [String] file basename (without extension) containing
+      #   shell code
+      # @return [String] command
       # @api private
-      def logger
-        instance ? instance.logger : Kitchen.logger
+      def shell_code_from_file(vars, file)
+        src_file = File.join(
+          File.dirname(__FILE__),
+          %w[.. .. .. support],
+          file + (powershell_shell? ? ".ps1" : ".sh")
+        )
+
+        wrap_shell_code([vars, "", IO.read(src_file)].join("\n"))
       end
 
       # Conditionally prefixes a command with a sudo command.

data/lib/kitchen/provisioner/chef/common_sandbox.rb

@@ -0,0 +1,322 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2015, 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 Provisioner
+
+    module Chef
+
+      # Internal object to manage common sandbox preparation for
+      # Chef-related provisioners.
+      #
+      # @author Fletcher Nichol <fnichol@nichol.ca>
+      # @api private
+      class CommonSandbox
+
+        include Logging
+
+        # Constructs a new object, taking config, a sandbox path, and an
+        # instance.
+        #
+        # @param config [Hash] configuration hash
+        # @param sandbox_path [String] path to local sandbox directory
+        # @param instance [Instance] an instance
+        def initialize(config, sandbox_path, instance)
+          @config = config
+          @sandbox_path = sandbox_path
+          @instance = instance
+        end
+
+        # Populate the sandbox.
+        def populate
+          prepare_json
+          prepare_cache
+          prepare_cookbooks
+          prepare(:data)
+          prepare(:data_bags)
+          prepare(:environments)
+          prepare(:nodes)
+          prepare(:roles)
+          prepare(:clients)
+          prepare(
+            :secret,
+            :type => :file,
+            :dest_name => "encrypted_data_bag_secret",
+            :key_name => :encrypted_data_bag_secret_key_path
+          )
+        end
+
+        private
+
+        # @return [Hash] configuration hash
+        # @api private
+        attr_reader :config
+
+        # @return [Instance] an instance
+        # @api private
+        attr_reader :instance
+
+        # @return [String] path to local sandbox directory
+        # @api private
+        attr_reader :sandbox_path
+
+        # Generates a list of all files in the cookbooks directory in the
+        # sandbox path.
+        #
+        # @return [Array<String>] an array of absolute paths to files
+        # @api private
+        def all_files_in_cookbooks
+          Dir.glob(File.join(tmpbooks_dir, "**/*"), File::FNM_DOTMATCH).
+            select { |fn| File.file?(fn) && ! %w[. ..].include?(fn) }
+        end
+
+        # @return [String] an absolute path to a Berksfile, relative to the
+        #   kitchen root
+        # @api private
+        def berksfile
+          File.join(config[:kitchen_root], "Berksfile")
+        end
+
+        # @return [String] an absolute path to a Cheffile, relative to the
+        #   kitchen root
+        # @api private
+        def cheffile
+          File.join(config[:kitchen_root], "Cheffile")
+        end
+
+        # @return [String] an absolute path to a cookbooks/ directory, relative
+        #   to the kitchen root
+        # @api private
+        def cookbooks_dir
+          File.join(config[:kitchen_root], "cookbooks")
+        end
+
+        # Copies a cookbooks/ directory into the sandbox path.
+        #
+        # @api private
+        def cp_cookbooks
+          info("Preparing cookbooks from project directory")
+          debug("Using cookbooks from #{cookbooks_dir}")
+
+          FileUtils.mkdir_p(tmpbooks_dir)
+          FileUtils.cp_r(File.join(cookbooks_dir, "."), tmpbooks_dir)
+
+          cp_site_cookbooks if File.directory?(site_cookbooks_dir)
+          cp_this_cookbook if File.exist?(metadata_rb)
+        end
+
+        # Copies a site-cookbooks/ directory into the sandbox path.
+        #
+        # @api private
+        def cp_site_cookbooks
+          info("Preparing site-cookbooks from project directory")
+          debug("Using cookbooks from #{site_cookbooks_dir}")
+
+          FileUtils.mkdir_p(tmpsitebooks_dir)
+          FileUtils.cp_r(File.join(site_cookbooks_dir, "."), tmpsitebooks_dir)
+        end
+
+        # Copies the current project, assumed to be a Chef cookbook into the
+        # sandbox path.
+        #
+        # @api private
+        def cp_this_cookbook
+          info("Preparing current project directory as a cookbook")
+          debug("Using metadata.rb from #{metadata_rb}")
+
+          cb_name = MetadataChopper.extract(metadata_rb).first || raise(UserError,
+            "The metadata.rb does not define the 'name' key." \
+              " Please add: `name '<cookbook_name>'` to metadata.rb and retry")
+
+          cb_path = File.join(tmpbooks_dir, cb_name)
+
+          glob = Dir.glob("#{config[:kitchen_root]}/**")
+
+          FileUtils.mkdir_p(cb_path)
+          FileUtils.cp_r(glob, cb_path)
+        end
+
+        # Removes all non-cookbook files in the sandbox path.
+        #
+        # @api private
+        def filter_only_cookbook_files
+          info("Removing non-cookbook files before transfer")
+          FileUtils.rm(all_files_in_cookbooks - only_cookbook_files)
+          Dir.glob(File.join(tmpbooks_dir, "**/"), File::FNM_PATHNAME).
+            reverse_each { |fn| FileUtils.rmdir(fn) if Dir.entries(fn).size == 2 }
+        end
+
+        # @return [Logger] the instance's logger or Test Kitchen's common
+        #   logger otherwise
+        # @api private
+        def logger
+          instance ? instance.logger : Kitchen.logger
+        end
+
+        # Creates a minimal, no-op cookbook in the sandbox path.
+        #
+        # @api private
+        def make_fake_cookbook
+          info("Berksfile, Cheffile, cookbooks/, or metadata.rb not found " \
+            "so Chef will run with effectively no cookbooks. Is this intended?")
+          name = File.basename(config[:kitchen_root])
+          fake_cb = File.join(tmpbooks_dir, name)
+          FileUtils.mkdir_p(fake_cb)
+          File.open(File.join(fake_cb, "metadata.rb"), "wb") do |file|
+            file.write(%{name "#{name}"\n})
+          end
+        end
+
+        # @return [String] an absolute path to a metadata.rb, relative to the
+        #   kitchen root
+        # @api private
+        def metadata_rb
+          File.join(config[:kitchen_root], "metadata.rb")
+        end
+
+        # Generates a list of all typical cookbook files needed in a Chef run,
+        # located in the cookbooks directory in the sandbox path.
+        #
+        # @return [Array<String>] an array of absolute paths to files
+        # @api private
+        def only_cookbook_files
+          glob = File.join(tmpbooks_dir, "*", "{#{config[:cookbook_files_glob]}}")
+
+          Dir.glob(glob, File::FNM_DOTMATCH).
+            select { |fn| File.file?(fn) && ! %w[. ..].include?(fn) }
+        end
+
+        # Prepares a generic Chef component source directory or file for
+        # inclusion in the sandbox path. These components might includes nodes,
+        # roles, etc.
+        #
+        # @param component [Symbol,String] a component name such as `:node`
+        # @param opts [Hash] optional configuration
+        # @option opts [Symbol] :type whether the component is a directory or
+        #   file (default: `:directory`)
+        # @option opts [Symbol] :key_name the key name in the config hash from
+        #   which to pull the source path (default: `"#{component}_path"`)
+        # @option opts [String] :dest_name the destination file or directory
+        #   basename in the sandbox path (default: `component.to_s`)
+        # @api private
+        def prepare(component, opts = {})
+          opts = { :type => :directory }.merge(opts)
+          key_name = opts.fetch(:key_name, "#{component}_path")
+          src = config[key_name.to_sym]
+          return if src.nil?
+
+          info("Preparing #{component}")
+          debug("Using #{component} from #{src}")
+
+          dest = File.join(sandbox_path, opts.fetch(:dest_name, component.to_s))
+
+          case opts[:type]
+          when :directory
+            FileUtils.mkdir_p(dest)
+            FileUtils.cp_r(Dir.glob("#{src}/*"), dest)
+          when :file
+            FileUtils.mkdir_p(File.dirname(dest))
+            FileUtils.cp_r(src, dest)
+          end
+        end
+
+        # Prepares a cache directory for inclusion in the sandbox path.
+        #
+        # @api private
+        def prepare_cache
+          FileUtils.mkdir_p(File.join(sandbox_path, "cache"))
+        end
+
+        # Prepares Chef cookbooks for inclusion in the sandbox path.
+        #
+        # @api private
+        def prepare_cookbooks
+          if File.exist?(berksfile)
+            resolve_with_berkshelf
+          elsif File.exist?(cheffile)
+            resolve_with_librarian
+            cp_site_cookbooks if File.directory?(site_cookbooks_dir)
+          elsif File.directory?(cookbooks_dir)
+            cp_cookbooks
+          elsif File.exist?(metadata_rb)
+            cp_this_cookbook
+          else
+            make_fake_cookbook
+          end
+
+          filter_only_cookbook_files
+        end
+
+        # Prepares a Chef JSON file, sometimes called a dna.json or
+        # first-boot.json, for inclusion in the sandbox path.
+        #
+        # @api private
+        def prepare_json
+          dna = config[:attributes].merge(:run_list => config[:run_list])
+
+          info("Preparing dna.json")
+          debug("Creating dna.json from #{dna.inspect}")
+
+          File.open(File.join(sandbox_path, "dna.json"), "wb") do |file|
+            file.write(dna.to_json)
+          end
+        end
+
+        # Performs a Berkshelf cookbook resolution inside a common mutex.
+        #
+        # @api private
+        def resolve_with_berkshelf
+          Kitchen.mutex.synchronize do
+            Chef::Berkshelf.new(berksfile, tmpbooks_dir, logger).resolve
+          end
+        end
+
+        # Performs a Librarin-Chef cookbook resolution inside a common mutex.
+        #
+        # @api private
+        def resolve_with_librarian
+          Kitchen.mutex.synchronize do
+            Chef::Librarian.new(cheffile, tmpbooks_dir, logger).resolve
+          end
+        end
+
+        # @return [String] an absolute path to a site-cookbooks/ directory,
+        #   relative to the kitchen root
+        # @api private
+        def site_cookbooks_dir
+          File.join(config[:kitchen_root], "site-cookbooks")
+        end
+
+        # @return [String] an absolute path to a cookbooks/ directory in the
+        #   sandbox path
+        # @api private
+        def tmpbooks_dir
+          File.join(sandbox_path, "cookbooks")
+        end
+
+        # @return [String] an absolute path to a site cookbooks directory in the
+        #   sandbox path
+        # @api private
+        def tmpsitebooks_dir
+          File.join(sandbox_path, "cookbooks")
+        end
+      end
+    end
+  end
+end