chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/lib/chef/resource/timestamped_deploy.rb

@@ -18,13 +18,12 @@
 
 class Chef
   class Resource
-
     # Convenience class for using the deploy resource with the timestamped
     # deployment strategy (provider)
     class TimestampedDeploy < Chef::Resource::Deploy
+      provides :timestamped_deploy
       def initialize(*args, &block)
         super(*args, &block)
-        @provider = Chef::Provider::Deploy::Timestamped
       end
     end
   end

data/lib/chef/resource/whyrun_safe_ruby_block.rb

@@ -23,7 +23,6 @@ class Chef
       def initialize(name, run_context=nil)
         super
         @resource_name = :whyrun_safe_ruby_block
-        @provider = Chef::Provider::WhyrunSafeRubyBlock
       end
 
     end

data/lib/chef/resource/windows_package.rb

@@ -24,12 +24,12 @@ class Chef
   class Resource
     class WindowsPackage < Chef::Resource::Package
 
-      provides :package, :on_platforms => ["windows"]
+      provides :package, os: "windows"
+      provides :windows_package, os: "windows"
 
       def initialize(name, run_context=nil)
         super
         @allowed_actions = [ :install, :remove ]
-        @provider = Chef::Provider::Package::Windows
         @resource_name = :windows_package
         @source ||= source(@package_name)
 
@@ -44,7 +44,7 @@ class Chef
         set_or_return(
           :installer_type,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ Symbol ]
         )
       end
 
@@ -76,4 +76,3 @@ class Chef
     end
   end
 end
-

data/lib/chef/resource/windows_script.rb

@@ -23,12 +23,15 @@ class Chef
   class Resource
     class WindowsScript < Chef::Resource::Script
 
+      set_guard_inherited_attributes(:architecture)
+
       protected
 
       def initialize(name, run_context, resource_name, interpreter_command)
         super(name, run_context)
         @interpreter = interpreter_command
         @resource_name = resource_name
+        @default_guard_interpreter = resource_name
       end
 
       include Chef::Mixin::WindowsArchitectureHelper

data/lib/chef/resource/windows_service.rb

@@ -25,7 +25,8 @@ class Chef
       # Until #1773 is resolved, you need to manually specify the windows_service resource
       # to use action :configure_startup and attribute startup_type
 
-      # provides :service, :on_platforms => ["windows"]
+      provides :service, os: "windows"
+      provides :windows_service, os: "windows"
 
       identity_attr :service_name
 
@@ -34,7 +35,6 @@ class Chef
       def initialize(name, run_context=nil)
         super
         @resource_name = :windows_service
-        @provider = Chef::Provider::Service::Windows
         @allowed_actions.push(:configure_startup)
         @startup_type = :automatic
       end

data/lib/chef/resource/yum_package.rb

@@ -23,10 +23,12 @@ class Chef
   class Resource
     class YumPackage < Chef::Resource::Package
 
+      provides :yum_package
+      provides :package, os: "linux", platform_family: [ "rhel", "fedora" ]
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :yum_package
-        @provider = Chef::Provider::Package::Yum
         @flush_cache = { :before => false, :after => false }
         @allow_downgrade = false
       end

data/lib/chef/resource_collection.rb

@@ -17,250 +17,73 @@
 # limitations under the License.
 #
 
-require 'chef/resource'
-require 'chef/resource_collection/stepable_iterator'
-
+require 'chef/resource_collection/resource_set'
+require 'chef/resource_collection/resource_list'
+require 'chef/resource_collection/resource_collection_serialization'
+require 'chef/log'
+require 'forwardable'
+
+##
+# ResourceCollection currently handles two tasks:
+# 1) Keeps an ordered list of resources to use when converging the node
+# 2) Keeps a unique list of resources (keyed as `type[name]`) used for notifications
 class Chef
   class ResourceCollection
-    include Enumerable
-
-    # Matches a multiple resource lookup specification,
-    # e.g., "service[nginx,unicorn]"
-    MULTIPLE_RESOURCE_MATCH = /^(.+)\[(.+?),(.+)\]$/
+    include ResourceCollectionSerialization
+    extend Forwardable
 
-    # Matches a single resource lookup specification,
-    # e.g., "service[nginx]"
-    SINGLE_RESOURCE_MATCH = /^(.+)\[(.+)\]$/
-
-    attr_reader :iterator
+    attr_reader :resource_set, :resource_list
+    private :resource_set, :resource_list
 
     def initialize
-      @resources = Array.new
-      @resources_by_name = Hash.new
-      @insert_after_idx = nil
-    end
-
-    def all_resources
-      @resources
-    end
-
-    def [](index)
-      @resources[index]
-    end
-
-    def []=(index, arg)
-      is_chef_resource(arg)
-      @resources[index] = arg
-      @resources_by_name[arg.to_s] = index
-    end
-
-    def <<(*args)
-      args.flatten.each do |a|
-        is_chef_resource(a)
-        @resources << a
-        @resources_by_name[a.to_s] = @resources.length - 1
-      end
-      self
-    end
-
-    # 'push' is an alias method to <<
-    alias_method :push, :<<
-
-    def insert(resource)
-      if @insert_after_idx
-        # in the middle of executing a run, so any resources inserted now should
-        # be placed after the most recent addition done by the currently executing
-        # resource
-        insert_at(@insert_after_idx + 1, resource)
-        @insert_after_idx += 1
+      @resource_set = ResourceSet.new
+      @resource_list = ResourceList.new
+    end
+
+    # @param resource [Chef::Resource] The resource to insert
+    # @param resource_type [String,Symbol] If known, the resource type used in the recipe, Eg `package`, `execute`
+    # @param instance_name [String] If known, the recource name as used in the recipe, IE `vim` in `package 'vim'`
+    # This method is meant to be the 1 insert method necessary in the future.  It should support all known use cases
+    #   for writing into the ResourceCollection.
+    def insert(resource, opts={})
+      resource_type ||= opts[:resource_type] # Would rather use Ruby 2.x syntax, but oh well
+      instance_name ||= opts[:instance_name]
+      resource_list.insert(resource)
+      if !(resource_type.nil? && instance_name.nil?)
+        resource_set.insert_as(resource, resource_type, instance_name)
       else
-        is_chef_resource(resource)
-        @resources << resource
-        @resources_by_name[resource.to_s] = @resources.length - 1
+        resource_set.insert_as(resource)
       end
     end
 
-    def insert_at(insert_at_index, *resources)
-      resources.each do |resource|
-        is_chef_resource(resource)
-      end
-      @resources.insert(insert_at_index, *resources)
-      # update name -> location mappings and register new resource
-      @resources_by_name.each_key do |key|
-        @resources_by_name[key] += resources.size if @resources_by_name[key] >= insert_at_index
-      end
-      resources.each_with_index do |resource, i|
-        @resources_by_name[resource.to_s] = insert_at_index + i
-      end
+    # @deprecated
+    def []=(index, resource)
+      Chef::Log.warn("`[]=` is deprecated, use `insert` (which only inserts at the end)")
+      resource_list[index] = resource
+      resource_set.insert_as(resource)
     end
 
-    def each
-      @resources.each do |resource|
-        yield resource
+    # @deprecated
+    def push(*resources)
+      Chef::Log.warn("`push` is deprecated, use `insert`")
+      resources.flatten.each do |res|
+        insert(res)
       end
+      self
     end
 
-    def execute_each_resource(&resource_exec_block)
-      @iterator = StepableIterator.for_collection(@resources)
-      @iterator.each_with_index do |resource, idx|
-        @insert_after_idx = idx
-        yield resource
-      end
-    end
-
-    def each_index
-      @resources.each_index do |i|
-        yield i
-      end
-    end
-
-    def empty?
-      @resources.empty?
-    end
-
-    def lookup(resource)
-      lookup_by = nil
-      if resource.kind_of?(Chef::Resource)
-        lookup_by = resource.to_s
-      elsif resource.kind_of?(String)
-        lookup_by = resource
-      else
-        raise ArgumentError, "Must pass a Chef::Resource or String to lookup"
-      end
-      res = @resources_by_name[lookup_by]
-      unless res
-        raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{lookup_by} (did you define it first?)"
-      end
-      @resources[res]
-    end
-
-    # Find existing resources by searching the list of existing resources.  Possible
-    # forms are:
-    #
-    # find(:file => "foobar")
-    # find(:file => [ "foobar", "baz" ])
-    # find("file[foobar]", "file[baz]")
-    # find("file[foobar,baz]")
-    #
-    # Returns the matching resource, or an Array of matching resources.
-    #
-    # Raises an ArgumentError if you feed it bad lookup information
-    # Raises a Runtime Error if it can't find the resources you are looking for.
-    def find(*args)
-      results = Array.new
-      args.each do |arg|
-        case arg
-        when Hash
-          results << find_resource_by_hash(arg)
-        when String
-          results << find_resource_by_string(arg)
-        else
-          msg = "arguments to #{self.class.name}#find should be of the form :resource => 'name' or resource[name]"
-          raise Chef::Exceptions::InvalidResourceSpecification, msg
-        end
-      end
-      flat_results = results.flatten
-      flat_results.length == 1 ? flat_results[0] : flat_results
-    end
-
-    # resources is a poorly named, but we have to maintain it for back
-    # compat.
-    alias_method :resources, :find
-
-    # Returns true if +query_object+ is a valid string for looking up a
-    # resource, or raises InvalidResourceSpecification if not.
-    # === Arguments
-    # * query_object should be a string of the form
-    # "resource_type[resource_name]", a single element Hash (e.g., :service =>
-    # "apache2"), or a Chef::Resource (this is the happy path). Other arguments
-    # will raise an exception.
-    # === Returns
-    # * true returns true for all valid input.
-    # === Raises
-    # * Chef::Exceptions::InvalidResourceSpecification for all invalid input.
-    def validate_lookup_spec!(query_object)
-      case query_object
-      when Chef::Resource
-        true
-      when SINGLE_RESOURCE_MATCH, MULTIPLE_RESOURCE_MATCH
-        true
-      when Hash
-        true
-      when String
-        raise Chef::Exceptions::InvalidResourceSpecification,
-          "The string `#{query_object}' is not valid for resource collection lookup. Correct syntax is `resource_type[resource_name]'"
-      else
-        raise Chef::Exceptions::InvalidResourceSpecification,
-          "The object `#{query_object.inspect}' is not valid for resource collection lookup. " +
-          "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
-      end
-    end
-
-    # Serialize this object as a hash
-    def to_hash
-      instance_vars = Hash.new
-      self.instance_variables.each do |iv|
-        instance_vars[iv] = self.instance_variable_get(iv)
-      end
-      {
-        'json_class' => self.class.name,
-        'instance_vars' => instance_vars
-      }
-    end
-
-    def to_json(*a)
-      Chef::JSONCompat.to_json(to_hash, *a)
-    end
-
-    def self.json_create(o)
-      collection = self.new()
-      o["instance_vars"].each do |k,v|
-        collection.instance_variable_set(k.to_sym, v)
-      end
-      collection
-    end
+    # @deprecated
+    alias_method :<<, :insert
 
-    private
+    # Read-only methods are simple to delegate - doing that below
 
-      def find_resource_by_hash(arg)
-        results = Array.new
-        arg.each do |resource_name, name_list|
-          names = name_list.kind_of?(Array) ? name_list : [ name_list ]
-          names.each do |name|
-            res_name = "#{resource_name.to_s}[#{name}]"
-            results << lookup(res_name)
-          end
-        end
-        return results
-      end
+    resource_list_methods = Enumerable.instance_methods +
+        [:iterator, :all_resources, :[], :each, :execute_each_resource, :each_index, :empty?] -
+        [:find] # find needs to run on the set
+    resource_set_methods = [:lookup, :find, :resources, :keys, :validate_lookup_spec!]
 
-      def find_resource_by_string(arg)
-        results = Array.new
-        case arg
-        when MULTIPLE_RESOURCE_MATCH
-          resource_type = $1
-          arg =~ /^.+\[(.+)\]$/
-          resource_list = $1
-          resource_list.split(",").each do |name|
-            resource_name = "#{resource_type}[#{name}]"
-            results << lookup(resource_name)
-          end
-        when SINGLE_RESOURCE_MATCH
-          resource_type = $1
-          name = $2
-          resource_name = "#{resource_type}[#{name}]"
-          results << lookup(resource_name)
-        else
-          raise ArgumentError, "Bad string format #{arg}, you must have a string like resource_type[name]!"
-        end
-        return results
-      end
+    def_delegators :resource_list, *resource_list_methods
+    def_delegators :resource_set, *resource_set_methods
 
-      def is_chef_resource(arg)
-        unless arg.kind_of?(Chef::Resource)
-          raise ArgumentError, "Cannot insert a #{arg.class} into a resource collection: must be a subclass of Chef::Resource"
-        end
-        true
-      end
   end
 end

data/lib/chef/resource_collection/resource_collection_serialization.rb

@@ -0,0 +1,59 @@
+#
+# Author:: Tyler Ball (<tball@getchef.com>)
+# Copyright:: Copyright (c) 2014 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.
+#
+class Chef
+  class ResourceCollection
+    module ResourceCollectionSerialization
+      # Serialize this object as a hash
+      def to_hash
+        instance_vars = Hash.new
+        self.instance_variables.each do |iv|
+          instance_vars[iv] = self.instance_variable_get(iv)
+        end
+        {
+            'json_class' => self.class.name,
+            'instance_vars' => instance_vars
+        }
+      end
+
+      def to_json(*a)
+        Chef::JSONCompat.to_json(to_hash, *a)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def json_create(o)
+          collection = self.new()
+          o["instance_vars"].each do |k,v|
+            collection.instance_variable_set(k.to_sym, v)
+          end
+          collection
+        end
+      end
+
+      def is_chef_resource!(arg)
+        unless arg.kind_of?(Chef::Resource)
+          raise ArgumentError, "Cannot insert a #{arg.class} into a resource collection: must be a subclass of Chef::Resource"
+        end
+        true
+      end
+    end
+  end
+end