test-kitchen-rsync 3.0.0.pre.1

data/lib/kitchen/plugin.rb

@@ -0,0 +1,76 @@
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, Fletcher Nichol
+# Copyright (C) 2018, Chef Software
+#
+# 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 "errors"
+require_relative "util"
+
+module Kitchen
+  module Plugin
+    # Returns an instance of a plugin given a type, name, and config.
+    #
+    # @param type [Module] a Kitchen::<Module> of one of the plugin types
+    #   (Driver, Provisioner, Transport, Verifier)
+    # @param plugin [String] a plugin name, which will be constantized
+    # @param config [Hash] a configuration hash to initialize the plugin
+    # @return [Kitchen::<Module>::Base] a plugin instance
+    # @raise [ClientError] if a plugin instance could not be created
+    # @raise [UserError] if the plugin's dependencies could not be met
+    def self.load(type, plugin, config)
+      type_name = Kitchen::Util.snake_case(type.name.split("::").last)
+      first_load = require("kitchen/#{type_name}/#{plugin}")
+
+      str_const = Kitchen::Util.camel_case(plugin)
+      klass = type.const_get(str_const)
+      object = klass.new(config)
+      object.verify_dependencies if first_load
+      object
+    rescue UserError
+      raise
+    rescue NameError => e
+      raise ClientError, "Could not load the '#{plugin}' #{type_name}. Error: #{e.message}"
+    rescue LoadError => e
+      available_plugins = plugins_available(type_name)
+      error_message = if available_plugins.include?(plugin)
+                        e.message
+                      else
+                        " Did you mean: #{available_plugins.join(", ")} ?" \
+                        " Please ensure that your #{type_name} is installed as a gem or included" \
+                        " in your Gemfile if using Bundler."
+                      end
+      raise ClientError, "Could not load the '#{plugin}' #{type_name} from the load path." + error_message
+    end
+
+    # given a type of plugin, searches the Ruby load path for plugins of that
+    # type based on the path+naming convention that plugin loading is based upon
+    #
+    # @param plugin_type [String] the name of a plugin type (e.g. driver,
+    #   provisioner, transport, verifier)
+    # @return [Array<String>] a collection of Ruby filenames that are probably
+    #   plugins of the given type
+    def self.plugins_available(plugin_type)
+      $LOAD_PATH.map { |load_path| Dir[File.expand_path("kitchen/#{plugin_type}/*.rb", load_path)] }
+        .reject(&:empty?)
+        .flatten
+        .uniq
+        .select { |plugin_path| File.readlines(plugin_path).grep(/^\s*class \w* </).any? }
+        .map { |plugin_path| File.basename(plugin_path).gsub(/\.rb$/, "") }
+        .reject { |plugin_name| plugin_name == "base" }
+        .sort
+    end
+  end
+end

data/lib/kitchen/plugin_base.rb

@@ -0,0 +1,60 @@
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 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
+  module Plugin
+    class Base
+      class << self
+        # @return [Array<Symbol>] an array of action method names that cannot
+        #   be run concurrently and must be run in serial via a shared mutex
+        attr_reader :serial_actions
+      end
+
+      # Registers certain driver actions that cannot be safely run concurrently
+      # in threads across multiple instances. Typically this might be used
+      # for create or destroy actions that use an underlying resource that
+      # cannot be used at the same time.
+      #
+      # A shared mutex for this driver object will be used to synchronize all
+      # registered methods.
+      #
+      # @example a single action method that cannot be run concurrently
+      #
+      #   no_parallel_for :create
+      #
+      # @example multiple action methods that cannot be run concurrently
+      #
+      #   no_parallel_for :create, :destroy
+      #
+      # @param methods [Array<Symbol>] one or more actions as symbols
+      # @raise [ClientError] if any method is not a valid action method name
+      def self.no_parallel_for(*methods)
+        action_methods = %i{create setup converge verify destroy}
+
+        Array(methods).each do |meth|
+          next if action_methods.include?(meth)
+
+          raise ClientError, "##{meth} is not a valid no_parallel_for method"
+        end
+
+        @serial_actions ||= []
+        @serial_actions += methods
+      end
+
+    end
+  end
+end

data/lib/kitchen/provisioner/base.rb

@@ -0,0 +1,269 @@
+#
+# 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 "../configurable"
+require_relative "../errors"
+require_relative "../logging"
+require_relative "../plugin_base"
+
+module Kitchen
+  module Provisioner
+    # Base class for a provisioner.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Base < Kitchen::Plugin::Base
+      include Configurable
+      include Logging
+
+      default_config :http_proxy, nil
+      default_config :https_proxy, nil
+      default_config :ftp_proxy, nil
+
+      default_config :retry_on_exit_code, []
+      default_config :max_retries, 1
+      default_config :wait_for_retry, 30
+
+      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
+
+      default_config :sudo_command do |provisioner|
+        provisioner.windows_os? ? nil : "sudo -E"
+      end
+
+      default_config :command_prefix, nil
+
+      default_config :uploads, {}
+      default_config :downloads, {}
+
+      expand_path_for :test_base_path
+
+      # Constructs a new provisioner by providing a configuration hash.
+      #
+      # @param config [Hash] initial provided configuration
+      def initialize(config = {})
+        init_config(config)
+      end
+
+      # Runs the provisioner on the instance.
+      #
+      # @param state [Hash] mutable instance state
+      # @raise [ActionFailed] if the action could not be completed
+      # rubocop:disable Metrics/AbcSize
+      def call(state)
+        create_sandbox
+        sandbox_dirs = Util.list_directory(sandbox_path)
+
+        instance.transport.connection(state) do |conn|
+          config[:uploads].to_h.each do |locals, remote|
+            debug("Uploading #{Array(locals).join(", ")} to #{remote}")
+            conn.upload(locals.to_s, remote)
+          end
+          conn.execute(install_command)
+          conn.execute(init_command)
+          info("Transferring files to #{instance.to_str} using rsync")
+          conn.rsyn_chef_repo(sandbox_path, config[:root_path])
+          debug("Transfer complete")
+          conn.execute(prepare_command)
+          conn.execute_with_retry(
+            run_command,
+            config[:retry_on_exit_code],
+            config[:max_retries],
+            config[:wait_for_retry]
+          )
+          info("Downloading files from #{instance.to_str}")
+          config[:downloads].to_h.each do |remotes, local|
+            debug("Downloading #{Array(remotes).join(", ")} to #{local}")
+            conn.download(remotes, local)
+          end
+          debug("Download complete")
+        end
+      rescue Kitchen::Transport::TransportFailed => ex
+        raise ActionFailed, ex.message
+      ensure
+        cleanup_sandbox
+      end
+
+      # Check system and configuration for common errors.
+      #
+      # @param state [Hash] mutable instance state
+      # @returns [Boolean] Return true if a problem is found.
+      def doctor(state)
+        false
+      end
+
+      # Certain products that Test Kitchen uses to provision require accepting
+      # a license to use. Overwrite this method in the specific provisioner
+      # to implement this check.
+      def check_license; end
+
+      # Generates a command string which will install and configure the
+      # provisioner software on an instance. If no work is required, then `nil`
+      # will be returned.
+      #
+      # @return [String] a command string
+      def install_command; end
+
+      # Generates a command string which will perform any data initialization
+      # or configuration required after the provisioner software is installed
+      # but before the sandbox has been transferred to the instance. If no work
+      # is required, then `nil` will be returned.
+      #
+      # @return [String] a command string
+      def init_command; end
+
+      # Generates a command string which will perform any commands or
+      # configuration required just before the main provisioner run command but
+      # after the sandbox has been transferred to the instance. If no work is
+      # required, then `nil` will be returned.
+      #
+      # @return [String] a command string
+      def prepare_command; end
+
+      # Generates a command string which will invoke the main provisioner
+      # command on the prepared instance. If no work is required, then `nil`
+      # will be returned.
+      #
+      # @return [String] a command string
+      def run_command; end
+
+      # Creates a temporary directory on the local workstation into which
+      # provisioner related files and directories can be copied or created. The
+      # contents of this directory will be copied over to the instance before
+      # invoking the provisioner's run command. After this method completes, it
+      # is expected that the contents of the sandbox is complete and ready for
+      # copy to the remote instance.
+      #
+      # **Note:** any subclasses would be well advised to call super first when
+      # overriding this method, for example:
+      #
+      # @example overriding `#create_sandbox`
+      #
+      #   class MyProvisioner < Kitchen::Provisioner::Base
+      #     def create_sandbox
+      #       super
+      #       # any further file copies, preparations, etc.
+      #     end
+      #   end
+      def create_sandbox
+        @sandbox_path = Dir.mktmpdir("#{instance.name}-sandbox-")
+        File.chmod(0755, sandbox_path)
+        info("Preparing files for transfer")
+        debug("Creating local sandbox in #{sandbox_path}")
+      end
+
+      # Returns the absolute path to the sandbox directory or raises an
+      # exception if `#create_sandbox` has not yet been called.
+      #
+      # @return [String] the absolute path to the sandbox directory
+      # @raise [ClientError] if the sandbox directory has no yet been created
+      #   by calling `#create_sandbox`
+      def sandbox_path
+        @sandbox_path ||= raise ClientError, "Sandbox directory has not yet " \
+          "been created. Please run #{self.class}#create_sandox before " \
+          "trying to access the path."
+      end
+
+      # Deletes the sandbox path. Without calling this method, the sandbox path
+      # will persist after the process terminates. In other words, cleanup is
+      # explicit. This method is safe to call multiple times.
+      def cleanup_sandbox
+        return if sandbox_path.nil?
+
+        debug("Cleaning up local sandbox in #{sandbox_path}")
+        FileUtils.rmtree(sandbox_path)
+      end
+
+      # Sets the API version for this provisioner. If the provisioner does not
+      # set this value, then `nil` will be used and reported.
+      #
+      # Sets the API version for this provisioner
+      #
+      # @example setting an API version
+      #
+      #   module Kitchen
+      #     module Provisioner
+      #       class NewProvisioner < Kitchen::Provisioner::Base
+      #
+      #         kitchen_provisioner_api_version 2
+      #
+      #       end
+      #     end
+      #   end
+      #
+      # @param version [Integer,String] a version number
+      #
+      def self.kitchen_provisioner_api_version(version)
+        @api_version = version
+      end
+
+      private
+
+      # Builds a complete command given a variables String preamble and a file
+      # containing shell code.
+      #
+      # @param vars [String] shell variables, as a String
+      # @param file [String] file basename (without extension) containing
+      #   shell code
+      # @return [String] command
+      # @api private
+      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.
+      #
+      # @param command [String] command to be prefixed
+      # @return [String] the command, conditionally prefixed with sudo
+      # @api private
+      def sudo(script)
+        "#{sudo_command} #{script}".lstrip
+      end
+
+      # Returns the sudo command to use or empty string if sudo is not configured
+      #
+      # @return [String] the sudo command if sudo config is true
+      # @api private
+      def sudo_command
+        config[:sudo] ? config[:sudo_command].to_s : ""
+      end
+
+      # Conditionally prefixes a command with a command prefix.
+      # This should generally be done after a command has been
+      # conditionally prefixed by #sudo as certain platforms, such as
+      # Cisco Nexus, require all commands to be run with a prefix to
+      # obtain outbound network access.
+      #
+      # @param command [String] command to be prefixed
+      # @return [String] the command, conditionally prefixed with the configured prefix
+      # @api private
+      def prefix_command(script)
+        config[:command_prefix] ? "#{config[:command_prefix]} #{script}" : script
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+#
+# 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 "../../errors"
+require_relative "../../logging"
+
+module Kitchen
+  module Provisioner
+    module Chef
+      # Chef cookbook resolver that uses Berkshelf and a Berksfile to calculate
+      # dependencies.
+      #
+      # @author Fletcher Nichol <fnichol@nichol.ca>
+      class Berkshelf
+        include Logging
+
+        # Creates a new cookbook resolver.
+        #
+        # @param berksfile [String] path to a Berksfile
+        # @param path [String] path in which to vendor the resulting
+        #   cookbooks
+        # @param logger [Kitchen::Logger] a logger to use for output, defaults
+        #   to `Kitchen.logger`
+        def initialize(berksfile, path, logger: Kitchen.logger, always_update: false)
+          @berksfile  = berksfile
+          @path       = path
+          @logger     = logger
+          @always_update = always_update
+        end
+
+        # Loads the library code required to use the resolver.
+        #
+        # @param logger [Kitchen::Logger] a logger to use for output, defaults
+        #   to `Kitchen.logger`
+        def self.load!(logger: Kitchen.logger)
+          load_berkshelf!(logger)
+        end
+
+        # Performs the cookbook resolution and vendors the resulting cookbooks
+        # in the desired path.
+        def resolve
+          version = ::Berkshelf::VERSION
+          info("Resolving cookbook dependencies with Berkshelf #{version}...")
+          debug("Using Berksfile from #{berksfile}")
+
+          ::Berkshelf.ui.mute do
+            berksfile_obj = ::Berkshelf::Berksfile.from_file(berksfile)
+            berksfile_obj.update if always_update && berksfile_obj.lockfile.present?
+            # Berkshelf requires the directory to not exist
+            FileUtils.rm_rf(path)
+            berksfile_obj.vendor(path)
+          end
+        end
+
+        private
+
+        # @return [String] path to a Berksfile
+        # @api private
+        attr_reader :berksfile
+
+        # @return [String] path in which to vendor the resulting cookbooks
+        # @api private
+        attr_reader :path
+
+        # @return [Kitchen::Logger] a logger to use for output
+        # @api private
+        attr_reader :logger
+
+        # @return [Boolean] If true, always update cookbooks in Berkshelf.
+        # @api private
+        attr_reader :always_update
+
+        class << self
+          private
+
+          # Load the Berkshelf-specific libary code.
+          #
+          # @param logger [Kitchen::Logger] the logger to use
+          # @raise [UserError] if the library couldn't be loaded
+          # @api private
+          def load_berkshelf!(logger)
+            first_load = require "berkshelf"
+
+            version = ::Berkshelf::VERSION
+            if first_load
+              logger.debug("Berkshelf #{version} library loaded")
+            else
+              logger.debug("Berkshelf #{version} previously loaded")
+            end
+          rescue LoadError => e
+            logger.fatal("The `berkshelf' gem is missing and must be installed" \
+              " or cannot be properly activated. Run" \
+              " `gem install berkshelf` or add the following to your" \
+              " Gemfile if you are using Bundler: `gem 'berkshelf'`.")
+            raise UserError,
+              "Could not load or activate Berkshelf (#{e.message})"
+          end
+        end
+      end
+    end
+  end
+end