chef 12.0.3 → 12.1.0.rc.0

data/lib/chef/resource/remote_file.rb

@@ -17,6 +17,7 @@
 # limitations under the License.
 #
 
+require 'uri'
 require 'chef/resource/file'
 require 'chef/provider/remote_file'
 require 'chef/mixin/securable'

data/lib/chef/resource/rpm_package.rb

@@ -28,6 +28,15 @@ class Chef
       def initialize(name, run_context=nil)
         super
         @resource_name = :rpm_package
+        @allow_downgrade = false
+      end
+
+      def allow_downgrade(arg=nil)
+        set_or_return(
+          :allow_downgrade,
+          arg,
+          :kind_of => [ TrueClass, FalseClass ]
+        )
       end
 
     end

data/lib/chef/resource/script.rb

@@ -24,11 +24,13 @@ class Chef
   class Resource
     class Script < Chef::Resource::Execute
 
+      # Chef-13: go back to using :name as the identity attr
       identity_attr :command
 
       def initialize(name, run_context=nil)
         super
         @resource_name = :script
+        # Chef-13: the command variable should be initialized to nil
         @command = name
         @code = nil
         @interpreter = nil
@@ -36,6 +38,15 @@ class Chef
         @default_guard_interpreter = :default
       end
 
+      def command(arg=nil)
+        unless arg.nil?
+          # Chef-13: change this to raise if the user is trying to set a value here
+          Chef::Log.warn "Specifying command attribute on a script resource is a coding error, use the 'code' attribute, or the execute resource"
+          Chef::Log.warn "This attribute is deprecated and must be fixed or this code will fail on Chef-13"
+        end
+        super
+      end
+
       def code(arg=nil)
         set_or_return(
           :code,

data/lib/chef/resource/template.rb

@@ -102,9 +102,8 @@ class Chef
       #
       # ==== Method Arguments:
       # Helper methods can also take arguments. The syntax available for
-      # argument specification will be dependent on ruby version. Ruby 1.8 only
-      # supports a subset of the argument specification syntax available for
-      # method definition, whereas 1.9 supports the full syntax.
+      # argument specification supports full syntax available for method
+      # definition.
       #
       # Continuing the above example of simplifying attribute access, we can
       # define a helper to look up app-specific attributes like this:

data/lib/chef/resource/windows_package.rb

@@ -29,7 +29,7 @@ class Chef
 
       def initialize(name, run_context=nil)
         super
-        @allowed_actions = [ :install, :remove ]
+        @allowed_actions.push(:install, :remove)
         @resource_name = :windows_package
         @source ||= source(@package_name)
 

data/lib/chef/resource/windows_service.rb

@@ -37,6 +37,8 @@ class Chef
         @resource_name = :windows_service
         @allowed_actions.push(:configure_startup)
         @startup_type = :automatic
+        @run_as_user = ""
+        @run_as_password = ""
       end
 
       def startup_type(arg=nil)
@@ -48,6 +50,22 @@ class Chef
           :equal_to => [ :automatic, :manual, :disabled ]
         )
       end
+
+      def run_as_user(arg=nil)
+        set_or_return(
+          :run_as_user,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      def run_as_password(arg=nil)
+        set_or_return(
+          :run_as_password,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
     end
   end
 end

data/lib/chef/resource_builder.rb

@@ -0,0 +1,137 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright (c) 2015 Opscode, 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.
+#
+
+# NOTE: this was extracted from the Recipe DSL mixin, relevant specs are in spec/unit/recipe_spec.rb
+
+class Chef
+  class ResourceBuilder
+    attr_reader :type
+    attr_reader :name
+    attr_reader :created_at
+    attr_reader :params
+    attr_reader :run_context
+    attr_reader :cookbook_name
+    attr_reader :recipe_name
+    attr_reader :enclosing_provider
+    attr_reader :resource
+
+    # FIXME (ruby-2.1 syntax): most of these are mandatory
+    def initialize(type:nil, name:nil, created_at: nil, params: nil, run_context: nil, cookbook_name: nil, recipe_name: nil, enclosing_provider: nil)
+      @type               = type
+      @name               = name
+      @created_at         = created_at
+      @params             = params
+      @run_context        = run_context
+      @cookbook_name      = cookbook_name
+      @recipe_name        = recipe_name
+      @enclosing_provider = enclosing_provider
+    end
+
+    def build(&block)
+      raise ArgumentError, "You must supply a name when declaring a #{type} resource" if name.nil?
+
+      @resource = resource_class.new(name, run_context)
+      resource.source_line = created_at
+      resource.declared_type = type
+
+      # If we have a resource like this one, we want to steal its state
+      # This behavior is very counter-intuitive and should be removed.
+      # See CHEF-3694, https://tickets.opscode.com/browse/CHEF-3694
+      # Moved to this location to resolve CHEF-5052, https://tickets.opscode.com/browse/CHEF-5052
+      if prior_resource
+        resource.load_from(prior_resource)
+      end
+
+      resource.cookbook_name = cookbook_name
+      resource.recipe_name = recipe_name
+      # Determine whether this resource is being created in the context of an enclosing Provider
+      resource.enclosing_provider = enclosing_provider
+
+      # XXX: this is required for definition params inside of the scope of a
+      # subresource to work correctly.
+      resource.params = params
+
+      # Evaluate resource attribute DSL
+      resource.instance_eval(&block) if block_given?
+
+      # emit a cloned resource warning if it is warranted
+      if prior_resource
+        if is_trivial_resource?(prior_resource) && identicalish_resources?(prior_resource, resource)
+          emit_harmless_cloning_debug
+        else
+          emit_cloned_resource_warning
+        end
+      end
+
+      # Run optional resource hook
+      resource.after_created
+
+      resource
+    end
+
+    private
+
+    def resource_class
+      # Checks the new platform => short_name => resource mapping initially
+      # then fall back to the older approach (Chef::Resource.const_get) for
+      # backward compatibility
+      @resource_class ||= Chef::Resource.resource_for_node(type, run_context.node)
+    end
+
+    def is_trivial_resource?(resource)
+      identicalish_resources?(resource_class.new(name, run_context), resource)
+    end
+
+    # this is an equality test specific to checking for 3694 cloning warnings
+    def identicalish_resources?(first, second)
+      skipped_ivars = [ :@source_line, :@cookbook_name, :@recipe_name, :@params, :@elapsed_time, :@declared_type ]
+      checked_ivars = ( first.instance_variables | second.instance_variables ) - skipped_ivars
+      non_matching_ivars = checked_ivars.reject do |iv|
+        if iv == :@action && ( [first.instance_variable_get(iv)].flatten == [:nothing] || [second.instance_variable_get(iv)].flatten == [:nothing] )
+          # :nothing action on either side of the comparison always matches
+          true
+        else
+          first.instance_variable_get(iv) == second.instance_variable_get(iv)
+        end
+      end
+      Chef::Log.debug("ivars which did not match with the prior resource: #{non_matching_ivars}")
+      non_matching_ivars.empty?
+    end
+
+    def emit_cloned_resource_warning
+      Chef::Log.warn("Cloning resource attributes for #{resource} from prior resource (CHEF-3694)")
+      Chef::Log.warn("Previous #{prior_resource}: #{prior_resource.source_line}") if prior_resource.source_line
+      Chef::Log.warn("Current  #{resource}: #{resource.source_line}") if resource.source_line
+    end
+
+    def emit_harmless_cloning_debug
+      Chef::Log.debug("Harmless resource cloning from #{prior_resource}:#{prior_resource.source_line} to #{resource}:#{resource.source_line}")
+    end
+
+    def prior_resource
+      @prior_resource ||=
+        begin
+          key = "#{type}[#{name}]"
+          prior_resource = run_context.resource_collection.lookup(key)
+        rescue Chef::Exceptions::ResourceNotFound
+          nil
+        end
+    end
+
+  end
+end

data/lib/chef/resource_definition.rb

@@ -54,7 +54,7 @@ class Chef
     end
 
     # When we do the resource definition, we're really just setting new values for
-    # the paramaters we prototyped at the top.  This method missing is as simple as
+    # the parameters we prototyped at the top.  This method missing is as simple as
     # it gets.
     def method_missing(symbol, *args)
       @params[symbol] = args.length == 1 ? args[0] : args

data/lib/chef/resource_reporter.rb

@@ -20,7 +20,7 @@
 #
 
 require 'uri'
-require 'chef/monkey_patches/securerandom'
+require 'securerandom'
 require 'chef/event_dispatch/base'
 
 class Chef

data/lib/chef/resources.rb

@@ -48,6 +48,7 @@ require 'chef/resource/macports_package'
 require 'chef/resource/mdadm'
 require 'chef/resource/mount'
 require 'chef/resource/ohai'
+require 'chef/resource/openbsd_package'
 require 'chef/resource/package'
 require 'chef/resource/pacman_package'
 require 'chef/resource/paludis_package'

data/lib/chef/role.rb

@@ -32,17 +32,20 @@ class Chef
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
 
+    attr_accessor :chef_server_rest
+
     # Create a new Chef::Role object.
-    def initialize
+    def initialize(chef_server_rest: nil)
       @name = ''
       @description = ''
       @default_attributes = Mash.new
       @override_attributes = Mash.new
       @env_run_lists = {"_default" => Chef::RunList.new}
+      @chef_server_rest = chef_server_rest
     end
 
     def chef_server_rest
-      Chef::REST.new(Chef::Config[:chef_server_url])
+      @chef_server_rest ||= Chef::REST.new(Chef::Config[:chef_server_url])
     end
 
     def self.chef_server_rest
@@ -103,6 +106,16 @@ class Chef
 
     alias :env_run_list :env_run_lists
 
+    def env_run_lists_add(env_run_lists=nil)
+      if (!env_run_lists.nil?)
+        env_run_lists.each { |k,v| @env_run_lists[k] = Chef::RunList.new(*Array(v))}
+      end
+      @env_run_lists
+    end
+
+    alias :env_run_list_add :env_run_lists_add
+
+
     def default_attributes(arg=nil)
       set_or_return(
         :default_attributes,
@@ -236,8 +249,8 @@ class Chef
       paths = Array(Chef::Config[:role_path])
       paths.each do |path|
         roles_files = Dir.glob(File.join(Chef::Util::PathHelper.escape_glob(path), "**", "**"))
-        js_files = roles_files.select { |file| file.match /\/#{name}\.json$/ }
-        rb_files = roles_files.select { |file| file.match /\/#{name}\.rb$/ }
+        js_files = roles_files.select { |file| file.match(/\/#{name}\.json$/) }
+        rb_files = roles_files.select { |file| file.match(/\/#{name}\.rb$/) }
         if js_files.count > 1 or rb_files.count > 1
           raise Chef::Exceptions::DuplicateRole, "Multiple roles of same type found named #{name}"
         end

data/lib/chef/run_context.rb

@@ -50,6 +50,9 @@ class Chef
     # recipes, which is triggered by #load. (See also: CookbookCompiler)
     attr_accessor :resource_collection
 
+    # The list of audits (control groups) to execute during the audit phase
+    attr_accessor :audits
+
     # A Hash containing the immediate notifications triggered by resources
     # during the converge phase of the chef run.
     attr_accessor :immediate_notification_collection
@@ -73,6 +76,7 @@ class Chef
       @node = node
       @cookbook_collection = cookbook_collection
       @resource_collection = Chef::ResourceCollection.new
+      @audits = {}
       @immediate_notification_collection = Hash.new {|h,k| h[k] = []}
       @delayed_notification_collection = Hash.new {|h,k| h[k] = []}
       @definitions = Hash.new
@@ -132,10 +136,10 @@ class Chef
     end
 
     # Evaluates the recipes +recipe_names+. Used by DSL::IncludeRecipe
-    def include_recipe(*recipe_names)
+    def include_recipe(*recipe_names, current_cookbook: nil)
       result_recipes = Array.new
       recipe_names.flatten.each do |recipe_name|
-        if result = load_recipe(recipe_name)
+        if result = load_recipe(recipe_name, current_cookbook: current_cookbook)
           result_recipes << result
         end
       end
@@ -143,10 +147,10 @@ class Chef
     end
 
     # Evaluates the recipe +recipe_name+. Used by DSL::IncludeRecipe
-    def load_recipe(recipe_name)
+    def load_recipe(recipe_name, current_cookbook: nil)
       Chef::Log.debug("Loading Recipe #{recipe_name} via include_recipe")
 
-      cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)
+      cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name, current_cookbook: current_cookbook)
 
       if unreachable_cookbook?(cookbook_name) # CHEF-4367
         Chef::Log.warn(<<-ERROR_MESSAGE)
@@ -194,7 +198,7 @@ ERROR_MESSAGE
     end
 
     # An Array of all recipes that have been loaded. This is stored internally
-    # as a Hash, so ordering is not preserved when using ruby 1.8.
+    # as a Hash, so ordering is predictable.
     #
     # Recipe names are given in fully qualified form, e.g., the recipe "nginx"
     # will be given as "nginx::default"
@@ -205,7 +209,7 @@ ERROR_MESSAGE
     end
 
     # An Array of all attributes files that have been loaded. Stored internally
-    # using a Hash, so order is not preserved on ruby 1.8.
+    # using a Hash, so order is predictable.
     #
     # Attribute file names are given in fully qualified form, e.g.,
     # "nginx::default" instead of "nginx".

data/lib/chef/search/query.rb

@@ -17,52 +17,47 @@
 #
 
 require 'chef/config'
-require 'uri'
-require 'chef/rest'
-require 'chef/node'
-require 'chef/role'
-require 'chef/data_bag'
-require 'chef/data_bag_item'
 require 'chef/exceptions'
+require 'chef/rest'
+
+require 'uri'
 
 class Chef
   class Search
     class Query
 
       attr_accessor :rest
+      attr_reader :config
 
-      def initialize(url=nil)
-        @rest = Chef::REST.new(url ||Chef::Config[:chef_server_url])
+      def initialize(url=nil, config:Chef::Config)
+        @config = config
+        @url = url
       end
 
+      def rest
+        @rest ||= Chef::REST.new(@url || @config[:chef_server_url])
+      end
 
-      # This search is only kept for backwards compatibility, since the results of the
-      # new filtered search method will be in a slightly different format
+      # Backwards compatability for cookbooks.
+      # This can be removed in Chef > 12.
       def partial_search(type, query='*:*', *args, &block)
-        Chef::Log.warn("DEPRECATED: The 'partial_search' api is deprecated, please use the search api with 'filter_result'")
-        # accept both types of args
-        if args.length == 1 && args[0].is_a?(Hash)
-          args_hash = args[0].dup
-          # partial_search implemented in the partial search cookbook uses the
-          # arg hash :keys instead of :filter_result to filter returned data
-          args_hash[:filter_result] = args_hash[:keys]
+        Chef::Log.warn(<<-WARNDEP)
+DEPRECATED: The 'partial_search' API is deprecated and will be removed in
+future releases. Please use 'search' with a :filter_result argument to get
+partial search data.
+WARNDEP
+
+        if !args.empty? && args.first.is_a?(Hash)
+          # partial_search uses :keys instead of :filter_result for
+          # result filtering.
+          args_h = args.first.dup
+          args_h[:filter_result] = args_h[:keys]
+          args_h.delete(:keys)
+
+          search(type, query, args_h, &block)
         else
-          args_hash = {}
-          args_hash[:sort] = args[0] if args.length >= 1
-          args_hash[:start] = args[1] if args.length >= 2
-          args_hash[:rows] = args[2] if args.length >= 3
+          search(type, query, *args, &block)
         end
-
-        unless block.nil?
-          raw_results = search(type,query,args_hash)
-        else
-          raw_results = search(type,query,args_hash,&block)
-        end
-        results = Array.new
-        raw_results[0].each do |r|
-          results << r["data"]
-        end
-        return results
       end
 
       #
@@ -87,87 +82,71 @@ class Chef
       #
       def search(type, query='*:*', *args, &block)
         validate_type(type)
-        validate_args(args)
 
-        scrubbed_args = Hash.new
+        args_h = hashify_args(*args)
+        response = call_rest_service(type, query: query, **args_h)
 
-        # argify everything
-        if args[0].kind_of?(Hash)
-          scrubbed_args = args[0]
+        if block
+          response["rows"].each { |row| block.call(row) if row }
+          unless (response["start"] + response["rows"].length) >= response["total"]
+            args_h[:start] = response["start"] + (args_h[:rows] || 0)
+            search(type, query, args_h, &block)
+          end
+          true
         else
-          # This api will be deprecated in a future release
-          scrubbed_args = { :sort => args[0], :start => args[1], :rows => args[2] }
+          [ response["rows"], response["start"], response["total"] ]
         end
-
-        # set defaults, if they haven't been set yet.
-        scrubbed_args[:sort] ||= 'X_CHEF_id_CHEF_X asc'
-        scrubbed_args[:start] ||= 0
-        scrubbed_args[:rows] ||= 1000
-
-        do_search(type, query, scrubbed_args, &block)
-      end
-
-      def list_indexes
-        @rest.get_rest("search")
       end
 
       private
       def validate_type(t)
         unless t.kind_of?(String) || t.kind_of?(Symbol)
           msg = "Invalid search object type #{t.inspect} (#{t.class}), must be a String or Symbol." +
-            "Useage: search(:node, QUERY, [OPTIONAL_ARGS])" +
-            "        `knife search environment QUERY (options)`"
+          "Usage: search(:node, QUERY[, OPTIONAL_ARGS])" +
+          "        `knife search environment QUERY (options)`"
           raise Chef::Exceptions::InvalidSearchQuery, msg
         end
       end
 
-      def validate_args(a)
-        max_args = 3
-        raise Chef::Exceptions::InvalidSearchQuery, "Too many arguments! (#{a.size} for <= #{max_args})" if a.size > max_args
+      def hashify_args(*args)
+        return Hash.new if args.empty?
+        return args.first if args.first.is_a?(Hash)
+
+        args_h = Hash.new
+        args_h[:sort] = args[0] if args[0]
+        args_h[:start] = args[1] if args[1]
+        args_h[:rows] = args[2]
+        args_h[:filter_result] = args[3]
+        args_h
       end
 
       def escape(s)
         s && URI.escape(s.to_s)
       end
 
-      # new search api that allows for a cleaner implementation of things like return filters
-      # (formerly known as 'partial search').
-      # Also args should never be nil, but that is required for Ruby 1.8 compatibility
-      def do_search(type, query="*:*", args=nil, &block)
-        query_string = create_query_string(type, query, args)
-        response = call_rest_service(query_string, args)
-        unless block.nil?
-          response["rows"].each { |rowset| block.call(rowset) unless rowset.nil?}
-          unless (response["start"] + response["rows"].length) >= response["total"]
-            args[:start] = response["start"] + args[:rows]
-            do_search(type, query, args, &block)
-          end
-          true
-        else
-          [ response["rows"], response["start"], response["total"] ]
-        end
+      def create_query_string(type, query, rows, start, sort)
+        qstr = "search/#{type}?q=#{escape(query)}"
+        qstr += "&sort=#{escape(sort)}" if sort
+        qstr += "&start=#{escape(start)}" if start
+        qstr += "&rows=#{escape(rows)}" if rows
+        qstr
       end
 
-      # create the full rest url string
-      def create_query_string(type, query, args)
-        # create some default variables just so we don't break backwards compatibility
-        sort = args[:sort]
-        start = args[:start]
-        rows = args[:rows]
+      def call_rest_service(type, query:'*:*', rows:nil, start:0, sort:'X_CHEF_id_CHEF_X asc', filter_result:nil)
+        query_string = create_query_string(type, query, rows, start, sort)
 
-        return "search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}"
-      end
-
-      def call_rest_service(query_string, args)
-        if args.key?(:filter_result)
-          response = @rest.post_rest(query_string, args[:filter_result])
-          response_rows = response['rows'].map { |row| row['data'] }
+        if filter_result
+          response = rest.post_rest(query_string, filter_result)
+          # response returns rows in the format of
+          # { "url" => url_to_node, "data" => filter_result_hash }
+          response['rows'].map! { |row| row['data'] }
         else
-          response = @rest.get_rest(query_string)
-          response_rows = response['rows']
+          response = rest.get_rest(query_string)
         end
-        return response
+
+        response
       end
+
     end
   end
 end