vagrant-clone 0.0.1 → 0.0.3

data/cookbooks/compat_resource/files/lib/chef_compat/copied_from_chef.rb

@@ -0,0 +1,29 @@
+module ChefCompat
+  module CopiedFromChef
+    def self.extend_chef_module(chef_module, target)
+      target.instance_eval do
+        include chef_module
+        @chef_module = chef_module
+        def self.method_missing(name, *args, &block)
+          @chef_module.send(name, *args, &block)
+        end
+        def self.const_missing(name)
+          @chef_module.const_get(name)
+        end
+      end
+    end
+
+    # This patch to CopiedFromChef's ActionClass is necessary for the include to work
+    require 'chef/resource'
+    class Chef < ::Chef
+      class Resource < ::Chef::Resource
+        module ActionClass
+          def self.use_inline_resources
+          end
+          def self.include_resource_dsl(include_resource_dsl)
+          end
+        end
+      end
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/mixin/properties.rb

@@ -0,0 +1,8 @@
+require 'chef_compat/monkeypatches'
+require 'chef_compat/copied_from_chef/chef/mixin/properties'
+
+module ChefCompat
+  module Mixin
+    Properties = ChefCompat::CopiedFromChef::Chef::Mixin::Properties
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/exceptions.rb

@@ -0,0 +1,10 @@
+require 'chef/exceptions'
+
+class Chef
+  class Exceptions
+    # Used in Resource::ActionClass#load_current_resource to denote that
+    # the resource doesn't actually exist (for example, the file does not exist)
+    class CurrentValueDoesNotExist < RuntimeError; end unless defined?(CurrentValueDoesNotExist)
+    class CannotValidateStaticallyError < RuntimeError; end unless defined?(CannotValidateStaticallyError)
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/log.rb

@@ -0,0 +1,30 @@
+require 'chef/log'
+
+# for now we have to patch this in everything
+class Chef
+  class Log
+    def self.caller_location
+      # Pick the first caller that is *not* part of the Chef gem, that's the
+      # thing the user wrote.
+      compat_resource_path = File.expand_path("../../../../..", __FILE__)
+      chef_gem_path = Gem.loaded_specs['chef'].full_gem_path
+      caller(0..20).find { |c| !c.start_with?(compat_resource_path) && !c.start_with?(chef_gem_path) }
+    end
+  end
+end
+
+if Gem::Requirement.new('< 12.13.37').satisfied_by?(Gem::Version.new(Chef::VERSION))
+
+  # FIXME: why does this not match the implementation in Chef itself?
+  class Chef
+    class Log
+      module ChefCompatDeprecation
+        def deprecation(message, location=nil)
+          Chef.log_deprecation(message, location)
+        end
+      end
+      extend ChefCompatDeprecation
+    end
+  end
+
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/mixin/params_validate.rb

@@ -0,0 +1,17 @@
+if Chef::VERSION.to_f >= 12.5 && Chef::VERSION.to_f <= 12.8
+  require 'chef/mixin/params_validate'
+  class Chef
+    module Mixin
+      module ParamsValidate
+        class SetOrReturnProperty < Chef::Property
+          # 12.9 introduced a new optional parameter to `get()` to avoid a nil-set warning.
+          # When their method gets called with 2 args, we need to ignore and call with 1.
+          alias_method :_original_get2, :get
+          def get(resource, *args)
+            _original_get2(resource)
+          end
+        end
+      end
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/node.rb

@@ -0,0 +1,9 @@
+class Chef
+  class Node
+    unless method_defined?(:set_cookbook_attribute)
+      def set_cookbook_attribute
+        # this implementation deliberately left blank - we don't need to do anything we just need to not fail
+      end
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/property.rb

@@ -0,0 +1,15 @@
+# 12.9 introduced a new optional parameter to `get()` to avoid a nil-set warning.
+# We need to mimick it here.
+if Chef::VERSION.to_f >= 12.5 && Chef::VERSION.to_f <= 12.8
+  require 'chef/property'
+  class Chef
+    class Property
+      # 12.9 introduced a new optional parameter to `get()` to avoid a nil-set warning.
+      # When their method gets called with 2 args, we need to ignore and call with 1.
+      alias_method :_original_get, :get
+      def get(resource, *args)
+        _original_get(resource)
+      end
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/provider.rb

@@ -0,0 +1,65 @@
+require 'chef/provider'
+require 'chef/provider/lwrp_base'
+
+class Chef::Provider
+  if !defined?(InlineResources)
+    InlineResources = Chef::Provider::LWRPBase::InlineResources
+  end
+  module InlineResources
+    require 'chef/dsl/recipe'
+    require 'chef/dsl/platform_introspection'
+    require 'chef/dsl/data_query'
+    require 'chef/dsl/include_recipe'
+    include Chef::DSL::Recipe
+    include Chef::DSL::PlatformIntrospection
+    include Chef::DSL::DataQuery
+    include Chef::DSL::IncludeRecipe
+
+    unless Chef::Provider::InlineResources::ClassMethods.instance_method(:action).source_location[0] =~ /chefspec/
+      # Don't override action if chefspec is doing its thing
+      module ::ChefCompat
+        module Monkeypatches
+          module InlineResources
+            module ClassMethods
+              def action(name, &block)
+                super(name) { send("compile_action_#{name}") }
+                # We put the action in its own method so that super() works.
+                define_method("compile_action_#{name}", &block)
+              end
+            end
+          end
+        end
+      end
+      module ClassMethods
+        prepend ChefCompat::Monkeypatches::InlineResources::ClassMethods
+      end
+    end
+  end
+end
+
+
+class Chef
+  class Provider
+    class LWRPBase < Provider
+      if defined?(InlineResources)
+        module InlineResources
+          # since we upgrade the Chef::Runner and Chef::RunContext globally to >= 12.14 style classes, we need to also
+          # fix the use_inline_resources LWRPBase wrapper that creates a sub-resource collection with the ugpraded code
+          # from the Chef::Provider subclasses that do similar things in post-12.5 chef.
+          def recipe_eval_with_update_check(&block)
+            old_run_context = run_context
+            @run_context = run_context.create_child
+            return_value = instance_eval(&block)
+            Chef::Runner.new(run_context).converge
+            return_value
+          ensure
+            if run_context.resource_collection.any? { |r| r.updated? }
+              new_resource.updated_by_last_action(true)
+            end
+            @run_context = old_run_context
+          end
+        end
+      end
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/recipe.rb

@@ -0,0 +1,118 @@
+#
+# NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE
+#
+# THIS IS A FILE AUTOGENERATED BY 'rake update' DO NOT EDIT!!!!
+#
+# NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE
+#
+
+if Gem::Requirement.new('< 12.16.42').satisfied_by?(Gem::Version.new(Chef::VERSION))
+#--
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software 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 "chef/dsl/recipe"
+require "chef/mixin/from_file"
+require "chef/mixin/deprecation"
+
+class Chef
+  # == Chef::Recipe
+  # A Recipe object is the context in which Chef recipes are evaluated.
+  class Recipe
+    attr_accessor :cookbook_name, :recipe_name, :recipe, :params, :run_context
+
+    include Chef::DSL::Recipe
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::Deprecation
+
+    # Parses a potentially fully-qualified recipe name into its
+    # cookbook name and recipe short name.
+    #
+    # For example:
+    #   "aws::elastic_ip" returns [:aws, "elastic_ip"]
+    #   "aws" returns [:aws, "default"]
+    #   "::elastic_ip" returns [ current_cookbook, "elastic_ip" ]
+    #--
+    # TODO: Duplicates functionality of RunListItem
+    def self.parse_recipe_name(recipe_name, current_cookbook: nil)
+      case recipe_name
+      when /(.+?)::(.+)/
+        [ $1.to_sym, $2 ]
+      when /^::(.+)/
+        raise "current_cookbook is nil, cannot resolve #{recipe_name}" if current_cookbook.nil?
+        [ current_cookbook.to_sym, $1 ]
+      else
+        [ recipe_name.to_sym, "default" ]
+      end
+    end
+
+    def initialize(cookbook_name, recipe_name, run_context)
+      @cookbook_name = cookbook_name
+      @recipe_name = recipe_name
+      @run_context = run_context
+      # TODO: 5/19/2010 cw/tim: determine whether this can be removed
+      @params = Hash.new
+    end
+
+    # Used in DSL mixins
+    def node
+      run_context.node
+    end
+
+    # Used by the DSL to look up resources when executing in the context of a
+    # recipe.
+    def resources(*args)
+      run_context.resource_collection.find(*args)
+    end
+
+    # This was moved to Chef::Node#tag, redirecting here for compatibility
+    def tag(*tags)
+      run_context.node.tag(*tags)
+    end
+
+    # Returns true if the node is tagged with *all* of the supplied +tags+.
+    #
+    # === Parameters
+    # tags<Array>:: A list of tags
+    #
+    # === Returns
+    # true<TrueClass>:: If all the parameters are present
+    # false<FalseClass>:: If any of the parameters are missing
+    def tagged?(*tags)
+      tags.each do |tag|
+        return false unless run_context.node.tags.include?(tag)
+      end
+      true
+    end
+
+    # Removes the list of tags from the node.
+    #
+    # === Parameters
+    # tags<Array>:: A list of tags
+    #
+    # === Returns
+    # tags<Array>:: The current list of run_context.node.tags
+    def untag(*tags)
+      tags.each do |tag|
+        run_context.node.tags.delete(tag)
+      end
+    end
+  end
+end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/recipe_hook.rb

@@ -0,0 +1,20 @@
+require 'chef/recipe'
+require 'chef_compat/recipe'
+
+class Chef::Recipe
+  # If the cookbook depends on compat_resource, create a ChefCompat::Recipe object
+  # instead of Chef::Recipe, for the extra goodies.
+  def self.new(cookbook_name, recipe_name, run_context)
+    if run_context &&
+        cookbook_name &&
+        recipe_name &&
+        run_context.cookbook_collection &&
+        run_context.cookbook_collection[cookbook_name] &&
+        run_context.cookbook_collection[cookbook_name].metadata.dependencies.has_key?('compat_resource') &&
+        self != ::ChefCompat::Recipe
+      ::ChefCompat::Recipe.new(cookbook_name, recipe_name, run_context)
+    else
+      super
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/resource/lwrp_base.rb

@@ -0,0 +1,60 @@
+require 'chef_compat/resource/lwrp_base'
+require 'chef/resource/lwrp_base'
+
+module ChefCompat
+  module Monkeypatches
+    #
+    # NOTE: LOTS OF METAPROGRAMMING HERE. NOT FOR FAINT OF HEART.
+    #
+
+    # Add an empty module to Class so we can temporarily override it in build_from_file
+    module Class
+    end
+    class<<::Class
+      prepend(ChefCompat::Monkeypatches::Class)
+    end
+
+    module Chef
+      module Resource
+        module LWRPBase
+          def build_from_file(cookbook_name, filename, run_context)
+            # If the cookbook this LWRP is from depends on compat_resource, fix its LWRPs up real good
+            if run_context.cookbook_collection[cookbook_name].metadata.dependencies.has_key?('compat_resource')
+              # All cookbooks do Class.new(Chef::Resource::LWRPBase). Change Class.new
+              # temporarily to translate Chef::Resource::LWRPBase to ChefCompat::Resource
+              ChefCompat::Monkeypatches::Class.module_eval do
+                def new(*args, &block)
+                  # Trick it! Use ChefCompat::Resource instead of Chef::Resource::LWRPBase
+                  if args == [ ::Chef::Resource::LWRPBase ]
+                    ChefCompat::Monkeypatches::Class.module_eval do
+                      remove_method(:new) if method_defined?(:new)
+                    end
+                    args = [ ChefCompat::Resource::LWRPBase ]
+                  end
+                  super(*args, &block)
+                end
+              end
+
+              begin
+
+                # Call the actual build_from_file
+                super
+
+              ensure
+                class<<ChefCompat::Monkeypatches::Class
+                  remove_method(:new) if method_defined?(:new)
+                end
+              end
+            else
+              # Call the actual build_from_file
+              super
+            end
+          end
+        end
+        class <<::Chef::Resource::LWRPBase
+          prepend(LWRPBase)
+        end
+      end
+    end
+  end
+end

data/cookbooks/compat_resource/files/lib/chef_compat/monkeypatches/chef/resource.rb

@@ -0,0 +1,156 @@
+# this is NOT an AUTOGENERATED file
+
+require 'chef/resource'
+
+class Chef
+  class Resource
+
+    class UnresolvedSubscribes < self
+      # The full key ise given as the name in {Resource#subscribes}
+      alias_method :to_s, :name
+      alias_method :declared_key, :name
+    end
+
+    #
+    # Force a delayed notification into this resource's run_context.
+    #
+    # This should most likely be paired with action :nothing
+    #
+    # @param arg [Array[Symbol], Symbol] A list of actions (e.g. `:create`)
+    #
+    def delayed_action(arg)
+      arg = Array(arg).map(&:to_sym)
+      arg.map do |action|
+        validate(
+          { action: action },
+          { action: { kind_of: Symbol, equal_to: allowed_actions } }
+        )
+        # the resource effectively sends a delayed notification to itself
+        run_context.add_delayed_action(Notification.new(self, action, self))
+      end
+    end
+
+    def subscribes(action, resources, timing = :delayed)
+      resources = [resources].flatten
+      resources.each do |resource|
+        if resource.is_a?(String)
+          resource = UnresolvedSubscribes.new(resource, run_context)
+        end
+        if resource.run_context.nil?
+          resource.run_context = run_context
+        end
+        resource.notifies(action, self, timing)
+      end
+      true
+    end
+
+    def notifies(action, resource_spec, timing = :delayed)
+      # when using old-style resources(:template => "/foo.txt") style, you
+      # could end up with multiple resources.
+      validate_resource_spec!(resource_spec)
+
+      resources = [ resource_spec ].flatten
+      resources.each do |resource|
+
+        case timing.to_s
+        when "delayed"
+          notifies_delayed(action, resource)
+        when "immediate", "immediately"
+          notifies_immediately(action, resource)
+        when "before"
+          notifies_before(action, resource)
+        else
+          raise ArgumentError,  "invalid timing: #{timing} for notifies(#{action}, #{resources.inspect}, #{timing}) resource #{self} "\
+            "Valid timings are: :delayed, :immediate, :immediately, :before"
+        end
+      end
+
+      true
+    end
+
+    #
+    # Iterates over all immediate and delayed notifications, calling
+    # resolve_resource_reference on each in turn, causing them to
+    # resolve lazy/forward references.
+    def resolve_notification_references
+      run_context.before_notifications(self).each { |n|
+        n.resolve_resource_reference(run_context.resource_collection)
+      }
+      run_context.immediate_notifications(self).each { |n|
+        n.resolve_resource_reference(run_context.resource_collection)
+      }
+      run_context.delayed_notifications(self).each {|n|
+        n.resolve_resource_reference(run_context.resource_collection)
+      }
+    end
+
+    # Helper for #notifies
+    def notifies_before(action, resource_spec)
+      run_context.notifies_before(Notification.new(resource_spec, action, self))
+    end
+
+    # Helper for #notifies
+    def notifies_immediately(action, resource_spec)
+      run_context.notifies_immediately(Notification.new(resource_spec, action, self))
+    end
+
+    # Helper for #notifies
+    def notifies_delayed(action, resource_spec)
+      run_context.notifies_delayed(Notification.new(resource_spec, action, self))
+    end
+
+    #
+    # Get the current actual value of this resource.
+    #
+    # This does not cache--a new value will be returned each time.
+    #
+    # @return A new copy of the resource, with values filled in from the actual
+    #   current value.
+    #
+    def current_value
+      provider = provider_for_action(Array(action).first)
+      if provider.whyrun_mode? && !provider.whyrun_supported?
+        raise "Cannot retrieve #{self.class.current_resource} in why-run mode: #{provider} does not support why-run"
+      end
+      provider.load_current_resource
+      provider.current_resource
+    end
+
+    # These methods are necessary for new resources to initialize old ones properly
+    attr_reader :resource_initializing
+    def resource_initializing=(value)
+      if value
+        @resource_initializing = value
+      else
+        remove_instance_variable(:@resource_initializing)
+      end
+    end
+
+    if !respond_to?(:resource_name)
+      def self.resource_name(name=Chef::NOT_PASSED)
+        # Setter
+        if name != Chef::NOT_PASSED
+  #        remove_canonical_dsl
+
+          # Set the resource_name and call provides
+          if name
+            name = name.to_sym
+            # If our class is not already providing this name, provide it.
+            # Commented out: use of resource_name and provides will need to be
+            # mutually exclusive in this world, generally.
+            # if !Chef::ResourceResolver.includes_handler?(name, self)
+              provides name#, canonical: true
+            # end
+            @resource_name = name
+          else
+            @resource_name = nil
+          end
+        end
+        @resource_name
+      end
+      def self.resource_name=(name)
+        resource_name(name)
+      end
+    end
+  end
+end