chef 12.4.0-universal-mingw32 → 12.4.1-universal-mingw32

data/lib/chef/resource/dsc_script.rb

@@ -22,7 +22,7 @@ class Chef
   class Resource
     class DscScript < Chef::Resource
 
-      provides :dsc_script, platform: "windows"
+      provides :dsc_script, os: "windows"
 
       default_action :run
 

data/lib/chef/resource/ips_package.rb

@@ -23,6 +23,7 @@ class Chef
   class Resource
     class IpsPackage < ::Chef::Resource::Package
 
+      provides :package, os: "solaris2"
       provides :ips_package, os: "solaris2"
 
       allowed_actions :install, :remove, :upgrade

data/lib/chef/resource/mount.rb

@@ -174,6 +174,14 @@ class Chef
         )
       end
 
+      private
+
+      # Used by the AIX provider to set fstype to nil.
+      # TODO use property to make nil a valid value for fstype
+      def clear_fstype
+        @fstype = nil
+      end
+
     end
   end
 end

data/lib/chef/resource/openbsd_package.rb

@@ -29,17 +29,6 @@ class Chef
       include Chef::Mixin::ShellOut
 
       provides :package, os: "openbsd"
-
-      def after_created
-        assign_provider
-      end
-
-      private
-
-      def assign_provider
-        @provider = Chef::Provider::Package::Openbsd
-      end
-
     end
   end
 end

data/lib/chef/resource/solaris_package.rb

@@ -24,10 +24,7 @@ class Chef
   class Resource
     class SolarisPackage < Chef::Resource::Package
       provides :package, os: "solaris2", platform_family: "nexentacore"
-      provides :package, os: "solaris2", platform_family: "solaris2" do |node|
-        # on >= Solaris 11 we default to IPS packages instead
-        node[:platform_version].to_f <= 5.10
-      end
+      provides :package, os: "solaris2", platform_family: "solaris2", platform_version: "<= 5.10"
     end
   end
 end

data/lib/chef/resource_resolver.rb

@@ -105,52 +105,80 @@ class Chef
     #
     # Whether this DSL is provided by the given resource_class.
     #
+    # Does NOT call provides? on the resource (it is assumed this is being
+    # called *from* provides?).
+    #
     # @api private
     def provided_by?(resource_class)
-      !prioritized_handlers.include?(resource_class)
+      potential_handlers.include?(resource_class)
+    end
+
+    #
+    # Whether the given handler attempts to provide the resource class at all.
+    #
+    # @api private
+    def self.includes_handler?(resource_name, resource_class)
+      handler_map.list(nil, resource_name).include?(resource_class)
     end
 
     protected
 
+    def self.priority_map
+      Chef.resource_priority_map
+    end
+
+    def self.handler_map
+      Chef.resource_handler_map
+    end
+
     def priority_map
-      Chef::Platform::ResourcePriorityMap.instance
+      Chef.resource_priority_map
+    end
+
+    def handler_map
+      Chef.resource_handler_map
+    end
+
+    # @api private
+    def potential_handlers
+      handler_map.list(node, resource_name, canonical: canonical).uniq
+    end
+
+    def enabled_handlers
+      potential_handlers.select { |handler| !overrode_provides?(handler) || handler.provides?(node, resource_name) }
     end
 
     def prioritized_handlers
-      @prioritized_handlers ||=
-        priority_map.list_handlers(node, resource_name, canonical: canonical)
+      @prioritized_handlers ||= begin
+        enabled_handlers = self.enabled_handlers
+
+        prioritized = priority_map.list(node, resource_name, canonical: canonical).flatten(1)
+        prioritized &= enabled_handlers # Filter the priority map by the actual enabled handlers
+        prioritized |= enabled_handlers # Bring back any handlers that aren't in the priority map, at the *end* (ordered set)
+        prioritized
+      end
+    end
+
+    def overrode_provides?(handler)
+      handler.method(:provides?).owner != Chef::Resource.method(:provides?).owner
     end
 
     module Deprecated
       # return a deterministically sorted list of Chef::Resource subclasses
-      # @deprecated Now prioritized_handlers does its own work (more efficiently)
       def resources
         Chef::Resource.sorted_descendants
       end
 
-      # A list of all handlers
-      # @deprecated Now prioritized_handlers does its own work
       def enabled_handlers
-        Chef::Log.deprecation("enabled_handlers is deprecated.  If you are implementing a ResourceResolver, use provided_handlers.  If you are not, use Chef::ResourceResolver.list(#{resource_name.inspect}, node: <node>)")
-        resources.select { |klass| klass.provides?(node, resource_name) }
-      end
-
-      protected
-
-      # A list of all handlers for the given DSL.  If there are no handlers in
-      # the map, we still check all descendants of Chef::Resource for backwards
-      # compatibility purposes.
-      def prioritized_handlers
-        @prioritized_handlers ||= super ||
-          resources.select do |klass|
-            # Don't bother calling provides? unless it's overridden. We already
-            # know prioritized_handlers
-            if klass.method(:provides?).owner != Chef::Resource && klass.provides?(node, resource_name)
-              Chef::Log.deprecation("Resources #{provided.join(", ")} are marked as providing DSL #{resource_name}, but provides #{resource_name.inspect} was never called!")
-              Chef::Log.deprecation("In Chef 13, this will break: you must call provides to mark the names you provide, even if you also override provides? yourself.")
-              true
-            end
+        handlers = super
+        if handlers.empty?
+          handlers = resources.select { |handler| overrode_provides?(handler) && handler.provides?(node, resource_name) }
+          handlers.each do |handler|
+            Chef::Log.deprecation("#{handler}.provides? returned true when asked if it provides DSL #{resource_name}, but provides #{resource_name.inspect} was never called!")
+            Chef::Log.deprecation("In Chef 13, this will break: you must call provides to mark the names you provide, even if you also override provides? yourself.")
           end
+        end
+        handlers
       end
     end
     prepend Deprecated

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -70,15 +70,16 @@ class Chef
       # @return [Array] Array of strings with fully-qualified recipe names
       def with_fully_qualified_names_and_version_constraints
         self.map do |recipe_name|
-          ret = if recipe_name.include?('::')
+          qualified_recipe = if recipe_name.include?('::')
             recipe_name
           else
             "#{recipe_name}::default"
           end
-          if @versions[recipe_name]
-            ret << "@#{@versions[recipe_name]}"
-          end
-          ret
+
+          version = @versions[recipe_name]
+          qualified_recipe = "#{qualified_recipe}@#{version}" if version
+
+          qualified_recipe
         end
       end
     end

data/lib/chef/user.rb

@@ -21,85 +21,45 @@ require 'chef/mixin/from_file'
 require 'chef/mash'
 require 'chef/json_compat'
 require 'chef/search/query'
-require 'chef/mixin/api_version_request_handling'
-require 'chef/exceptions'
 require 'chef/server_api'
 
-# OSC 11 BACKWARDS COMPATIBILITY NOTE (remove after OSC 11 support ends)
+# TODO
+# DEPRECATION NOTE
+# This class will be replaced by Chef::UserV1 in Chef 13. It is the code to support the User object
+# corrosponding to the Open Source Chef Server 11 and only still exists to support
+# users still on OSC 11.
 #
-# In general, Chef::User is no longer expected to support Open Source Chef 11 Server requests.
-# The object that handles those requests has been moved to the Chef::OscUser namespace.
+# Chef::UserV1 now supports Chef Server 12 and will be moved to this namespace in Chef 13.
 #
-# Exception: self.list is backwards compatible with OSC 11
+# New development should occur in Chef::UserV1.
+# This file and corrosponding osc_user knife files
+# should be removed once client support for Open Source Chef Server 11 expires.
 class Chef
   class User
 
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
-    include Chef::Mixin::ApiVersionRequestHandling
-
-    SUPPORTED_API_VERSIONS = [0,1]
 
     def initialize
-      @username = nil
-      @display_name = nil
-      @first_name = nil
-      @middle_name = nil
-      @last_name = nil
-      @email = nil
-      @password = nil
+      @name = ''
       @public_key = nil
       @private_key = nil
-      @create_key = nil
       @password = nil
+      @admin = false
     end
 
-    def chef_root_rest_v0
-      @chef_root_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], {:api_version => "0"})
-    end
-
-    def chef_root_rest_v1
-      @chef_root_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_root], {:api_version => "1"})
+    def chef_rest_v0
+      @chef_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], {:api_version => "0"})
     end
 
-    def username(arg=nil)
-      set_or_return(:username, arg,
+    def name(arg=nil)
+      set_or_return(:name, arg,
                     :regex => /^[a-z0-9\-_]+$/)
     end
 
-    def display_name(arg=nil)
-      set_or_return(:display_name,
-                    arg, :kind_of => String)
-    end
-
-    def first_name(arg=nil)
-      set_or_return(:first_name,
-                    arg, :kind_of => String)
-    end
-
-    def middle_name(arg=nil)
-      set_or_return(:middle_name,
-                    arg, :kind_of => String)
-    end
-
-    def last_name(arg=nil)
-      set_or_return(:last_name,
-                    arg, :kind_of => String)
-    end
-
-    def email(arg=nil)
-      set_or_return(:email,
-                    arg, :kind_of => String)
-    end
-
-    def password(arg=nil)
-      set_or_return(:password,
-                    arg, :kind_of => String)
-    end
-
-    def create_key(arg=nil)
-      set_or_return(:create_key, arg,
-                    :kind_of => [TrueClass, FalseClass])
+    def admin(arg=nil)
+      set_or_return(:admin,
+                    arg, :kind_of => [TrueClass, FalseClass])
     end
 
     def public_key(arg=nil)
@@ -119,17 +79,12 @@ class Chef
 
     def to_hash
       result = {
-        "username" => @username
+        "name" => @name,
+        "public_key" => @public_key,
+        "admin" => @admin
       }
-      result["display_name"] = @display_name unless @display_name.nil?
-      result["first_name"] = @first_name unless @first_name.nil?
-      result["middle_name"] = @middle_name unless @middle_name.nil?
-      result["last_name"] = @last_name unless @last_name.nil?
-      result["email"] = @email unless @email.nil?
-      result["password"] = @password unless @password.nil?
-      result["public_key"] = @public_key unless @public_key.nil?
-      result["private_key"] = @private_key unless @private_key.nil?
-      result["create_key"] = @create_key unless @create_key.nil?
+      result["private_key"] = @private_key if @private_key
+      result["password"] = @password if @password
       result
     end
 
@@ -138,86 +93,21 @@ class Chef
     end
 
     def destroy
-      # will default to the current API version (Chef::Authenticator::DEFAULT_SERVER_API_VERSION)
-      Chef::REST.new(Chef::Config[:chef_server_url]).delete("users/#{@username}")
+      chef_rest_v0.delete("users/#{@name}")
     end
 
     def create
-      # try v1, fail back to v0 if v1 not supported
-      begin
-        payload = {
-          :username => @username,
-          :display_name => @display_name,
-          :first_name => @first_name,
-          :last_name => @last_name,
-          :email => @email,
-          :password => @password
-        }
-        payload[:public_key] = @public_key unless @public_key.nil?
-        payload[:create_key] = @create_key unless @create_key.nil?
-        payload[:middle_name] = @middle_name unless @middle_name.nil?
-        raise Chef::Exceptions::InvalidUserAttribute, "You cannot set both public_key and create_key for create." if !@create_key.nil? && !@public_key.nil?
-        new_user = chef_root_rest_v1.post("users", payload)
-
-        # get the private_key out of the chef_key hash if it exists
-        if new_user['chef_key']
-          if new_user['chef_key']['private_key']
-            new_user['private_key'] = new_user['chef_key']['private_key']
-          end
-          new_user['public_key'] = new_user['chef_key']['public_key']
-          new_user.delete('chef_key')
-        end
-      rescue Net::HTTPServerException => e
-        # rescue API V0 if 406 and the server supports V0
-        supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
-        raise e unless supported_versions && supported_versions.include?(0)
-        payload = {
-          :username => @username,
-          :display_name => @display_name,
-          :first_name => @first_name,
-          :last_name => @last_name,
-          :email => @email,
-          :password => @password
-        }
-        payload[:middle_name] = @middle_name unless @middle_name.nil?
-        payload[:public_key] = @public_key unless @public_key.nil?
-        # under API V0, the server will create a key pair if public_key isn't passed
-        new_user = chef_root_rest_v0.post("users", payload)
-      end
-
+      payload = {:name => self.name, :admin => self.admin, :password => self.password }
+      payload[:public_key] = public_key if public_key
+      new_user = chef_rest_v0.post("users", payload)
       Chef::User.from_hash(self.to_hash.merge(new_user))
     end
 
     def update(new_key=false)
-      begin
-        payload = {:username => username}
-        payload[:display_name] = display_name unless display_name.nil?
-        payload[:first_name] = first_name unless first_name.nil?
-        payload[:middle_name] = middle_name unless middle_name.nil?
-        payload[:last_name] = last_name unless last_name.nil?
-        payload[:email] = email unless email.nil?
-        payload[:password] = password unless password.nil?
-
-        # API V1 will fail if these key fields are defined, and try V0 below if relevant 400 is returned
-        payload[:public_key] = public_key unless public_key.nil?
-        payload[:private_key] = new_key if new_key
-
-        updated_user = chef_root_rest_v1.put("users/#{username}", payload)
-      rescue Net::HTTPServerException => e
-        if e.response.code == "400"
-          # if a 400 is returned but the error message matches the error related to private / public key fields, try V0
-          # else, raise the 400
-          error = Chef::JSONCompat.from_json(e.response.body)["error"].first
-          error_match = /Since Server API v1, all keys must be updated via the keys endpoint/.match(error)
-          if error_match.nil?
-            raise e
-          end
-        else # for other types of errors, test for API versioning errors right away
-          supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
-          raise e unless supported_versions && supported_versions.include?(0)
-        end
-        updated_user = chef_root_rest_v0.put("users/#{username}", payload)
-      end
+      payload = {:name => name, :admin => admin}
+      payload[:private_key] = new_key if new_key
+      payload[:password] = password if password
+      updated_user = chef_rest_v0.put("users/#{name}", payload)
       Chef::User.from_hash(self.to_hash.merge(updated_user))
     end
 
@@ -233,47 +123,30 @@ class Chef
       end
     end
 
-    # Note: remove after API v0 no longer supported by client (and knife command).
     def reregister
-      begin
-        payload = self.to_hash.merge({"private_key" => true})
-        reregistered_self = chef_root_rest_v0.put("users/#{username}", payload)
-        private_key(reregistered_self["private_key"])
-      # only V0 supported for reregister
-      rescue Net::HTTPServerException => e
-        # if there was a 406 related to versioning, give error explaining that
-        # only API version 0 is supported for reregister command
-        if e.response.code == "406" && e.response["x-ops-server-api-version"]
-          version_header = Chef::JSONCompat.from_json(e.response["x-ops-server-api-version"])
-          min_version = version_header["min_version"]
-          max_version = version_header["max_version"]
-          error_msg = reregister_only_v0_supported_error_msg(max_version, min_version)
-          raise Chef::Exceptions::OnlyApiVersion0SupportedForAction.new(error_msg)
-        else
-          raise e
-        end
-      end
+      reregistered_self = chef_rest_v0.put("users/#{name}", { :name => name, :admin => admin, :private_key => true })
+      private_key(reregistered_self["private_key"])
       self
     end
 
     def to_s
-      "user[#{@username}]"
+      "user[#{@name}]"
+    end
+
+    def inspect
+      "Chef::User name:'#{name}' admin:'#{admin.inspect}'" +
+      "public_key:'#{public_key}' private_key:#{private_key}"
     end
 
     # Class Methods
 
     def self.from_hash(user_hash)
       user = Chef::User.new
-      user.username user_hash['username']
-      user.display_name user_hash['display_name'] if user_hash.key?('display_name')
-      user.first_name user_hash['first_name'] if user_hash.key?('first_name')
-      user.middle_name user_hash['middle_name'] if user_hash.key?('middle_name')
-      user.last_name user_hash['last_name'] if user_hash.key?('last_name')
-      user.email user_hash['email'] if user_hash.key?('email')
-      user.password user_hash['password'] if user_hash.key?('password')
-      user.public_key user_hash['public_key'] if user_hash.key?('public_key')
+      user.name user_hash['name']
       user.private_key user_hash['private_key'] if user_hash.key?('private_key')
-      user.create_key user_hash['create_key'] if user_hash.key?('create_key')
+      user.password user_hash['password'] if user_hash.key?('password')
+      user.public_key user_hash['public_key']
+      user.admin user_hash['admin']
       user
     end
 
@@ -286,19 +159,12 @@ class Chef
     end
 
     def self.list(inflate=false)
-      response = Chef::REST.new(Chef::Config[:chef_server_url]).get('users')
+      response =  Chef::ServerAPI.new(Chef::Config[:chef_server_url], {:api_version => "0"}).get('users')
       users = if response.is_a?(Array)
-                # EC 11 / CS 12 V0, V1
-                #   GET /organizations/<org>/users
-                transform_list_response(response)
-              else
-                # OSC 11
-                #  GET /users
-                # EC 11 / CS 12 V0, V1
-                #  GET /users
-                response # OSC
-              end
-
+        transform_ohc_list_response(response) # OHC/OPC
+      else
+        response # OSC
+      end
       if inflate
         users.inject({}) do |user_map, (name, _url)|
           user_map[name] = Chef::User.load(name)
@@ -309,9 +175,8 @@ class Chef
       end
     end
 
-    def self.load(username)
-      # will default to the current API version (Chef::Authenticator::DEFAULT_SERVER_API_VERSION)
-      response = Chef::REST.new(Chef::Config[:chef_server_url]).get("users/#{username}")
+    def self.load(name)
+      response =  Chef::ServerAPI.new(Chef::Config[:chef_server_url], {:api_version => "0"}).get("users/#{name}")
       Chef::User.from_hash(response)
     end
 
@@ -319,7 +184,7 @@ class Chef
     # [ { "user" => { "username" => USERNAME }}, ...]
     # into the form
     # { "USERNAME" => "URI" }
-    def self.transform_list_response(response)
+    def self.transform_ohc_list_response(response)
       new_response = Hash.new
       response.each do |u|
         name = u['user']['username']
@@ -328,7 +193,6 @@ class Chef
       new_response
     end
 
-    private_class_method :transform_list_response
-
+    private_class_method :transform_ohc_list_response
   end
 end