test-kitchen-rsync 3.0.0.pre.1

data/lib/kitchen/lazy_hash.rb

@@ -0,0 +1,148 @@
+#
+# 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 "delegate"
+
+module Kitchen
+  # A modifed Hash object that may contain callables as a value which must be
+  # executed in the context of another object. This allows for delayed
+  # evaluation of a hash value while still looking and largely feeling like a
+  # normal Ruby Hash.
+  #
+  # @example normal hash accessing with regular values
+  #
+  #   data = {
+  #     :symbol => true,
+  #     "string" => "stuff"
+  #   }
+  #   context = "any object"
+  #   lazy = Kitchen::Hash.new(data, context)
+  #
+  #   lazy[:symbol] # => true
+  #   lazy.fetch("string") # => "stuff"
+  #
+  # @example hash with callable blocks as values
+  #
+  #   data = {
+  #     :lambda => ->(c) { c.length },
+  #     :proc => Proc.new { |c| c.reverse },
+  #     :simple => "value"
+  #   }
+  #   context = "any object"
+  #   lazy = Kitchen::Hash.new(data, context)
+  #
+  #   lazy[:lambda] # => 10
+  #   lazy.fetch(:proc) # => "tcejbo yna"
+  #   lazy[:simple] # => "value"
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class LazyHash < SimpleDelegator
+    include Enumerable
+
+    # Creates a new LazyHash using a Hash-like object to populate itself and
+    # an object that can be used as context in value-callable blocks. The
+    # context object can be used to compute values for keys at the time of
+    # fetching the value.
+    #
+    # @param obj [Hash, Object] a hash-like object
+    # @param context [Object] an object that can be used to compute values
+    def initialize(obj, context)
+      @context = context
+      super(obj)
+    end
+
+    # Retrieves the rendered value object corresponding to the key object. If
+    # not found, returns the default value.
+    #
+    # @param key [Object] hash key
+    # @return [Object, nil] the value for key or the default value if key is
+    #   not found
+    def [](key)
+      proc_or_val(__getobj__[key])
+    end
+
+    # Returns a rendered value from the hash for the given key. If the key
+    # can't be found, there are several options: With no other arguments, it
+    # will raise an KeyError exception; if default is given, then that will be
+    # returned; if the optional code block is specified, then that will be run
+    # and its result returned.
+    #
+    # @param key [Object] hash key
+    # @param default [Object] default value if key is not set (optional)
+    # @return [Object, nil] the value for the key or the default value if key
+    #   is not found
+    # @raise [KeyError] if the key is not found
+    def fetch(key, default = :__undefined__, &block)
+      case default
+      when :__undefined__
+        proc_or_val(__getobj__.fetch(key, &block))
+      else
+        proc_or_val(__getobj__.fetch(key, default, &block))
+      end
+    end
+
+    # Returns a new Hash with all keys and rendered values of the LazyHash.
+    #
+    # @return [Hash] a new hash
+    def to_hash
+      hash = {}
+      __getobj__.each_key { |key| hash[key] = self[key] }
+      hash
+    end
+
+    # Yields each key/value pair to the provided block.  Returns a new
+    # Hash with only the keys and rendered values for which the block
+    # returns true.
+    #
+    # @return [Hash] a new hash
+    def select(&block)
+      to_hash.select(&block)
+    end
+
+    # If no block provided, returns an enumerator over the keys and
+    # rendered values in the underlying object.  If a block is
+    # provided, calls the block once for each [key, rendered_value]
+    # pair in the underlying object.
+    #
+    # @return [Enumerator, Array]
+    def each(&block)
+      to_hash.each(&block)
+    end
+
+    # Returns a new Hash after deleting the key-value pairs for which the block
+    # returns true.
+    #
+    # @return [Hash] a new hash
+    def delete_if(&block)
+      to_hash.delete_if(&block)
+    end
+
+    private
+
+    # Returns an object or invokes call with context if object is callable.
+    #
+    # @return [Object] an object
+    # @api private
+    def proc_or_val(thing)
+      if thing.respond_to?(:call)
+        thing.call(@context)
+      else
+        thing
+      end
+    end
+  end
+end

data/lib/kitchen/lifecycle_hook/base.rb

@@ -0,0 +1,78 @@
+module Kitchen
+  class LifecycleHook
+    class Base
+      # @return [Kitchen::LifecycleHooks]
+      attr_reader :lifecycle_hooks
+
+      # return [String]
+      attr_reader :phase
+
+      # return [Hash]
+      attr_reader :hook
+
+      # @param lifecycle_hooks [Kitchen::LifecycleHooks]
+      # @param phase [String]
+      # @param hook [Hash]
+      def initialize(lifecycle_hooks, phase, hook)
+        @lifecycle_hooks = lifecycle_hooks
+        @phase = phase
+        @hook = hook
+      end
+
+      # return [void]
+      def run
+        raise NotImplementedError
+      end
+
+      # @return [TrueClass, FalseClass]
+      def should_run?
+        if !includes.empty?
+          includes.include?(platform_name)
+        elsif !excludes.empty?
+          !excludes.include?(platform_name)
+        else
+          true
+        end
+      end
+
+      # @return [Logger] the lifecycle hooks's logger
+      #   otherwise
+      # @api private
+      def logger
+        lifecycle_hooks.send(:logger)
+      end
+
+      private
+
+      # @return [Kitchen::Instance]
+      def instance
+        lifecycle_hooks.instance
+      end
+
+      # @return [Hash]
+      def config
+        lifecycle_hooks.send(:config)
+      end
+
+      # @return [Kitchen::StateFile]
+      def state_file
+        lifecycle_hooks.state_file
+      end
+
+      # @return [Array<String>] names of excluded platforms
+      def excludes
+        @excludes ||= hook.fetch(:excludes, [])
+      end
+
+      # @return [Array<String>] names of only included platforms
+      def includes
+        @includes ||= hook.fetch(:includes, [])
+      end
+
+      # @return [String]
+      def platform_name
+        instance.platform.name
+      end
+    end
+  end
+end

data/lib/kitchen/lifecycle_hook/local.rb

@@ -0,0 +1,53 @@
+require_relative "base"
+require_relative "../shell_out"
+require_relative "../logging"
+
+module Kitchen
+  class LifecycleHook
+    class Local < Base
+      include ShellOut
+      include Logging
+
+      # Execute a specific local command hook.
+      #
+      # @return [void]
+      def run
+        state = state_file.read
+        # set up empty user variable
+        user = {}
+        # Set up some environment variables with instance info.
+        environment = {
+          "KITCHEN_INSTANCE_NAME" => instance.name,
+          "KITCHEN_SUITE_NAME" => instance.suite.name,
+          "KITCHEN_PLATFORM_NAME" => instance.platform.name,
+          "KITCHEN_INSTANCE_HOSTNAME" => state[:hostname].to_s,
+        }
+        # If the user specified env vars too, fix them up because symbol keys
+        # make mixlib-shellout sad.
+        hook[:environment]&.each do |k, v|
+          environment[k.to_s] = v.to_s
+        end
+
+        # add user to user hash for later merging
+        user[:user] = hook[:user] if hook[:user]
+
+        # Default the cwd to the kitchen root and resolve a relative input cwd against that.
+        cwd = if hook[:cwd]
+                File.expand_path(hook[:cwd], config[:kitchen_root])
+              else
+                config[:kitchen_root]
+              end
+        # Build the options for mixlib-shellout.
+        opts = {}.merge(user).merge(cwd: cwd, environment: environment)
+        run_command(command, opts)
+      end
+
+      private
+
+      # @return [String]
+      def command
+        hook.fetch(:local)
+      end
+    end
+  end
+end

data/lib/kitchen/lifecycle_hook/remote.rb

@@ -0,0 +1,39 @@
+require_relative "base"
+require_relative "../errors"
+
+module Kitchen
+  class LifecycleHook
+    class Remote < Base
+      # Execute a specific remote command hook.
+      #
+      # @return [void]
+      def run
+        # Check if we're in a state that makes sense to even try.
+        unless instance.last_action
+          if hook[:skippable]
+            # Just not even trying.
+            return
+          else
+            raise UserError, "Cannot use remote lifecycle hooks during phases when the instance is not available"
+          end
+        end
+
+        begin
+          conn = instance.transport.connection(state_file.read)
+          conn.execute(command)
+        rescue Kitchen::Transport::SshFailed => e
+          return if hook[:skippable] && e.message.match(/^SSH exited \(\d{1,3}\) for command: \[.+\]$/)
+
+          raise
+        end
+      end
+
+      private
+
+      # return [String]
+      def command
+        hook.fetch(:remote)
+      end
+    end
+  end
+end

data/lib/kitchen/lifecycle_hooks.rb

@@ -0,0 +1,92 @@
+#
+# Author:: Noah Kantrowitz <noah@coderanger.net>
+#
+# Copyright (C) 2018, Noah Kantrowitz
+#
+# 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 "lifecycle_hook/local"
+require_relative "lifecycle_hook/remote"
+require_relative "logging"
+
+module Kitchen
+  # A helper object used by {Instance} to coordinate lifecycle hook calls from
+  # the `lifecycle:` configuration section.
+  #
+  # @api internal
+  # @since 1.22
+  class LifecycleHooks
+    include Configurable
+    include Logging
+
+    def initialize(config, state_file)
+      init_config(config)
+      @state_file = state_file
+    end
+
+    # Run a lifecycle phase with the pre and post hooks.
+    #
+    # @param phase [String] Lifecycle phase which is being executed.
+    # @param state_file [StateFile] Instance state file object.
+    # @param block [Proc] Block of code implementing the lifecycle phase.
+    # @return [void]
+    def run_with_hooks(phase, state_file, &block)
+      run(phase, :pre)
+      yield
+      run(phase, :post)
+    end
+
+    # @return [Kitchen::StateFile]
+    attr_reader :state_file
+
+    private
+
+    # Execute a specific lifecycle hook.
+    #
+    # @param phase [String] Lifecycle phase which is being executed.
+    # @param hook_timing [Symbol] `:pre` or `:post` to indicate which hook to run.
+    # @return [void]
+    def run(phase, hook_timing)
+      # Yes this has to be a symbol because of how data munger works.
+      hook_key = :"#{hook_timing}_#{phase}"
+      # No hooks? We're outta here.
+      hook_data = Array(config[hook_key])
+      return if hook_data.empty?
+
+      hook_data.each do |hook|
+        # Coerce the common case of a bare string to be a local command. This
+        # is to match the behavior of the old `pre_create_command` semi-hook.
+        hook = { local: hook } if hook.is_a?(String)
+        hook = generate_hook(phase, hook)
+        hook.run if hook.should_run?
+      end
+    end
+
+    # @param phase [String]
+    # @param hook [Hash]
+    # @return [Kitchen::LifecycleHook::Local, Kitchen::LifecycleHook::Remote]
+    def generate_hook(phase, hook)
+      if hook.include?(:local)
+        # Local command execution on the workstation.
+        Kitchen::LifecycleHook::Local.new(self, phase, hook)
+      elsif hook.include?(:remote)
+        # Remote command execution on the test instance.
+        Kitchen::LifecycleHook::Remote.new(self, phase, hook)
+      else
+        raise UserError, "Unknown lifecycle hook target #{hook.inspect}"
+      end
+    end
+  end
+end