chef 12.5.0.alpha.1 → 12.5.1

data/lib/chef/property.rb

@@ -86,12 +86,32 @@ class Chef
     #
     def initialize(**options)
       options.each { |k,v| options[k.to_sym] = v if k.is_a?(String) }
-      options[:name_property] = options.delete(:name_attribute) unless options.has_key?(:name_property)
-      @options = options
 
-      if options.has_key?(:default)
-        options[:default] = options[:default].freeze
+      # Replace name_attribute with name_property
+      if options.has_key?(:name_attribute)
+        # If we have both name_attribute and name_property and they differ, raise an error
+        if options.has_key?(:name_property)
+          raise ArgumentError, "Cannot specify both name_property and name_attribute together on property #{options[:name]}#{options[:declared_in] ? " of resource #{options[:declared_in].resource_name}" : ""}."
+        end
+        # replace name_property with name_attribute in place
+        options = Hash[options.map { |k,v| k == :name_attribute ? [ :name_property, v ] : [ k,v ] }]
+      end
+
+      # Only pick the first of :default, :name_property and :name_attribute if
+      # more than one is specified.
+      if options.has_key?(:default) && options[:name_property]
+        if options[:default].nil? || options.keys.index(:name_property) < options.keys.index(:default)
+          options.delete(:default)
+          preferred_default = :name_property
+        else
+          options.delete(:name_property)
+          preferred_default = :default
+        end
+        Chef.log_deprecation("Cannot specify both default and name_property together on property #{options[:name]}#{options[:declared_in] ? " of resource #{options[:declared_in].resource_name}" : ""}. Only one (#{preferred_default}) will be obeyed. In Chef 13, this will become an error.")
       end
+
+      @options = options
+
       options[:name] = options[:name].to_sym if options[:name]
       options[:instance_variable_name] = options[:instance_variable_name].to_sym if options[:instance_variable_name]
     end
@@ -231,7 +251,7 @@ class Chef
       if value.nil? && !explicitly_accepts_nil?(resource)
         # If you say "my_property nil" and the property explicitly accepts
         # nil values, we consider this a get.
-        Chef::Log.deprecation("#{name} nil currently does not overwrite the value of #{name}. This will change in Chef 13, and the value will be set to nil instead. Please change your code to explicitly accept nil using \"property :#{name}, [MyType, nil]\", or stop setting this value to nil.")
+        Chef.log_deprecation("#{name} nil currently does not overwrite the value of #{name}. This will change in Chef 13, and the value will be set to nil instead. Please change your code to explicitly accept nil using \"property :#{name}, [MyType, nil]\", or stop setting this value to nil.")
         return get(resource)
       end
 
@@ -285,7 +305,7 @@ class Chef
           # If the value is mutable (non-frozen), we set it on the instance
           # so that people can mutate it.  (All constant default values are
           # frozen.)
-          if !value.frozen?
+          if !value.frozen? && !value.nil?
             set_value(resource, value)
           end
 
@@ -402,7 +422,16 @@ class Chef
     # @return [Property] The new property type.
     #
     def derive(**modified_options)
-      Property.new(**options.merge(**modified_options))
+      # Since name_property, name_attribute and default override each other,
+      # if you specify one of them in modified_options it overrides anything in
+      # the original options.
+      options = self.options
+      if modified_options.has_key?(:name_property) ||
+         modified_options.has_key?(:name_attribute) ||
+         modified_options.has_key?(:default)
+        options = options.reject { |k,v| k == :name_attribute || k == :name_property || k == :default }
+      end
+      Property.new(options.merge(modified_options))
     end
 
     #
@@ -427,10 +456,10 @@ class Chef
       EOM
     rescue SyntaxError
       # If the name is not a valid ruby name, we use define_method.
-      resource_class.define_method(name) do |value=NOT_PASSED|
+      declared_in.define_method(name) do |value=NOT_PASSED|
         self.class.properties[name].call(self, value)
       end
-      resource_class.define_method("#{name}=") do |value|
+      declared_in.define_method("#{name}=") do |value|
         self.class.properties[name].set(self, value)
       end
     end

data/lib/chef/provider.rb

@@ -175,6 +175,62 @@ class Chef
       converge_actions.add_action(descriptions, &block)
     end
 
+    #
+    # Handle patchy convergence safely.
+    #
+    # - Does *not* call the block if the current_resource's properties match
+    #   the properties the user specified on the resource.
+    # - Calls the block if current_resource does not exist
+    # - Calls the block if the user has specified any properties in the resource
+    #   whose values are *different* from current_resource.
+    # - Does *not* call the block if why-run is enabled (just prints out text).
+    # - Prints out automatic green text saying what properties have changed.
+    #
+    # @param properties An optional list of property names (symbols). If not
+    #   specified, `new_resource.class.state_properties` will be used.
+    # @param converge_block The block to do the converging in.
+    #
+    # @return [Boolean] whether the block was executed.
+    #
+    def converge_if_changed(*properties, &converge_block)
+      if !converge_block
+        raise ArgumentError, "converge_if_changed must be passed a block!"
+      end
+
+      properties = new_resource.class.state_properties.map { |p| p.name } if properties.empty?
+      properties = properties.map { |p| p.to_sym }
+      if current_resource
+        # Collect the list of modified properties
+        specified_properties = properties.select { |property| new_resource.property_is_set?(property) }
+        modified = specified_properties.select { |p| new_resource.send(p) != current_resource.send(p) }
+        if modified.empty?
+          Chef::Log.debug("Skipping update of #{new_resource.to_s}: has not changed any of the specified properties #{specified_properties.map { |p| "#{p}=#{new_resource.send(p).inspect}" }.join(", ")}.")
+          return false
+        end
+
+        # Print the pretty green text and run the block
+        property_size = modified.map { |p| p.size }.max
+        modified = modified.map { |p| "  set #{p.to_s.ljust(property_size)} to #{new_resource.send(p).inspect} (was #{current_resource.send(p).inspect})" }
+        converge_by([ "update #{current_resource.identity}" ] + modified, &converge_block)
+
+      else
+        # The resource doesn't exist. Mark that we are *creating* this, and
+        # write down any properties we are setting.
+        property_size = properties.map { |p| p.size }.max
+        created = []
+        properties.each do |property|
+          if new_resource.property_is_set?(property)
+            created << "  set #{property.to_s.ljust(property_size)} to #{new_resource.send(property).inspect}"
+          else
+            created << "  set #{property.to_s.ljust(property_size)} to #{new_resource.send(property).inspect} (default value)"
+          end
+        end
+
+        converge_by([ "create #{new_resource.identity}" ] + created, &converge_block)
+      end
+      true
+    end
+
     def self.provides(short_name, opts={}, &block)
       Chef.provider_handler_map.set(short_name, self, opts, &block)
     end
@@ -209,12 +265,31 @@ class Chef
         provider_class = self
         @included_resource_dsl_module = Module.new do
           extend Forwardable
-          define_singleton_method(:to_s) { "#{resource_class} forwarder module" }
+          define_singleton_method(:to_s) { "forwarder module for #{provider_class}" }
           define_singleton_method(:inspect) { to_s }
+          # Add a delegator for each explicit property that will get the *current* value
+          # of the property by default instead of the *actual* value.
+          resource.class.properties.each do |name, property|
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{name}(*args, &block)
+                # If no arguments were passed, we process "get" by defaulting
+                # the value to current_resource, not new_resource. This helps
+                # avoid issues where resources accidentally overwrite perfectly
+                # valid stuff with default values.
+                if args.empty? && !block
+                  if !new_resource.property_is_set?(__method__) && current_resource
+                    return current_resource.public_send(__method__)
+                  end
+                end
+                new_resource.public_send(__method__, *args, &block)
+              end
+            EOM
+          end
           dsl_methods =
              resource.class.public_instance_methods +
              resource.class.protected_instance_methods -
-             provider_class.instance_methods
+             provider_class.instance_methods -
+             resource.class.properties.keys
           def_delegators(:new_resource, *dsl_methods)
         end
         include @included_resource_dsl_module
@@ -278,17 +353,34 @@ class Chef
         # compile the resources, converging them, and then checking if any
         # were updated (and updating new-resource if so)
         def action(name, &block)
-          class_eval <<-EOM, __FILE__, __LINE__+1
-            def action_#{name}
-              return_value = compile_action_#{name}
-              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)
+          # We first try to create the method using "def method_name", which is
+          # preferred because it actually shows up in stack traces. If that
+          # fails, we try define_method.
+          begin
+            class_eval <<-EOM, __FILE__, __LINE__+1
+              def action_#{name}
+                return_value = compile_action_#{name}
+                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
+              end
+            EOM
+          rescue SyntaxError
+            define_method("action_#{name}") do
+              begin
+                return_value = send("compile_action_#{name}")
+                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
               end
             end
-          EOM
+          end
           # We put the action in its own method so that super() works.
           define_method("compile_action_#{name}", &block)
         end
@@ -329,7 +421,7 @@ class Chef
     module DeprecatedLWRPClass
       def const_missing(class_name)
         if deprecated_constants[class_name.to_sym]
-          Chef::Log.deprecation("Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
+          Chef.log_deprecation("Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
           deprecated_constants[class_name.to_sym]
         else
           raise NameError, "uninitialized constant Chef::Provider::#{class_name}"

data/lib/chef/provider/batch.rb

@@ -28,6 +28,14 @@ class Chef
         super(new_resource, run_context, '.bat')
       end
 
+      def command
+        basepath = is_forced_32bit ? wow64_directory : run_context.node.kernel.os_info.system_directory
+
+        interpreter_path = Chef::Util::PathHelper.join(basepath, interpreter)
+
+        "\"#{interpreter_path}\" #{flags} \"#{script_file.path}\""
+      end
+
       def flags
         @new_resource.flags.nil? ? '/c' : new_resource.flags + ' /c'
       end

data/lib/chef/provider/deploy.rb

@@ -201,7 +201,7 @@ class Chef
 
           converge_by("execute migration command #{@new_resource.migration_command}") do
             Chef::Log.info "#{@new_resource} migrating #{@new_resource.user} with environment #{env_info}"
-            run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path, :log_level => :info))
+            shell_out!(@new_resource.migration_command,run_options(:cwd=>release_path, :log_level => :info))
           end
         end
       end
@@ -221,7 +221,7 @@ class Chef
           else
             converge_by("restart app using command #{@new_resource.restart_command}") do
               Chef::Log.info("#{@new_resource} restarting app")
-              run_command(run_options(:command => @new_resource.restart_command, :cwd => @new_resource.current_path))
+              shell_out!(@new_resource.restart_command,run_options(:cwd=>@new_resource.current_path))
             end
           end
         end

data/lib/chef/provider/directory.rb

@@ -64,7 +64,13 @@ class Chef
               is_parent_writable = lambda do |base_dir|
                 base_dir = ::File.dirname(base_dir)
                 if ::File.exists?(base_dir)
-                  Chef::FileAccessControl.writable?(base_dir)
+                  if Chef::FileAccessControl.writable?(base_dir)
+                    true
+                  elsif Chef::Util::PathHelper.is_sip_path?(base_dir, node)
+                    Chef::Util::PathHelper.writable_sip_path?(base_dir)
+                  else
+                    false
+                  end
                 else
                   is_parent_writable.call(base_dir)
                 end
@@ -74,7 +80,13 @@ class Chef
               # in why run mode & parent directory does not exist no permissions check is required
               # If not in why run, permissions must be valid and we rely on prior assertion that dir exists
               if !whyrun_mode? || ::File.exists?(parent_directory)
-                Chef::FileAccessControl.writable?(parent_directory)
+                if Chef::FileAccessControl.writable?(parent_directory)
+                  true
+                elsif Chef::Util::PathHelper.is_sip_path?(parent_directory, node)
+                  Chef::Util::PathHelper.writable_sip_path?(@new_resource.path)
+                else
+                  false
+                end
               else
                 true
               end

data/lib/chef/provider/dsc_resource.rb

@@ -59,9 +59,7 @@ class Chef
           a.block_action!
         end
         requirements.assert(:run) do |a|
-          a.assertion {
-            meta_configuration['RefreshMode'] == 'Disabled'
-          }
+          a.assertion { dsc_refresh_mode_disabled? }
           err = ["The LCM must have its RefreshMode set to Disabled. "]
           a.failure_message Chef::Exceptions::ProviderNotFound, err.join(' ')
           a.whyrun err + ["Assuming a previous resource sets the RefreshMode."]
@@ -85,6 +83,10 @@ class Chef
       def supports_dsc_invoke_resource?
         run_context && Chef::Platform.supports_dsc_invoke_resource?(node)
       end
+      
+      def dsc_refresh_mode_disabled?
+        Chef::Platform.dsc_refresh_mode_disabled?(node)
+      end
 
       def generate_description
         @converge_description
@@ -153,12 +155,6 @@ class Chef
         cmdlet.run!
       end
 
-      def meta_configuration
-        cmdlet = Chef::Util::Powershell::Cmdlet.new(node, "Get-DscLocalConfigurationManager", :object)
-        result = cmdlet.run!
-        result.return_value
-      end
-
     end
   end
 end

data/lib/chef/provider/group/pw.rb

@@ -109,7 +109,7 @@ class Chef
           else
             # Append is not set so we're resetting the membership of
             # the group to the given members.
-            members_to_be_added = @new_resource.members
+            members_to_be_added = @new_resource.members.dup
             @current_resource.members.each do |member|
               # No need to re-add a member if it's present in the new
               # list of members

data/lib/chef/provider/ifconfig.rb

@@ -194,7 +194,7 @@ class Chef
 
       private
       def add_command
-        command = "ifconfig #{@new_resource.device} #{@new_resource.name}"
+        command = "ifconfig #{@new_resource.device} #{@new_resource.target}"
         command << " netmask #{@new_resource.mask}" if @new_resource.mask
         command << " metric #{@new_resource.metric}" if @new_resource.metric
         command << " mtu #{@new_resource.mtu}" if @new_resource.mtu
@@ -202,7 +202,7 @@ class Chef
       end
 
       def enable_command
-        command = "ifconfig #{@new_resource.device} #{@new_resource.name}"
+        command = "ifconfig #{@new_resource.device} #{@new_resource.target}"
         command << " netmask #{@new_resource.mask}" if @new_resource.mask
         command << " metric #{@new_resource.metric}" if @new_resource.metric
         command << " mtu #{@new_resource.mtu}" if @new_resource.mtu

data/lib/chef/provider/mount.rb

@@ -42,13 +42,17 @@ class Chef
       end
 
       def action_mount
-        unless current_resource.mounted
+        if current_resource.mounted
+          if mount_options_unchanged?
+            Chef::Log.debug("#{new_resource} is already mounted")
+          else
+            action_remount
+          end
+        else
           converge_by("mount #{current_resource.device} to #{current_resource.mount_point}") do
             mount_fs
             Chef::Log.info("#{new_resource} mounted")
           end
-        else
-          Chef::Log.debug("#{new_resource} is already mounted")
         end
       end
 

data/lib/chef/provider/package/dpkg.rb

@@ -25,8 +25,6 @@ class Chef
   class Provider
     class Package
       class Dpkg < Chef::Provider::Package
-        # http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Version
-        DPKG_INFO = /([a-z\d\-\+\.]+)\t([\w\d.~:-]+)/
         DPKG_INSTALLED = /^Status: install ok installed/
         DPKG_VERSION = /^Version: (.+)$/
 
@@ -54,26 +52,22 @@ class Chef
           @source_exists = true
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
-          @new_resource.version(nil)
 
           if @new_resource.source
             @source_exists = ::File.exists?(@new_resource.source)
             if @source_exists
               # Get information from the package if supplied
               Chef::Log.debug("#{@new_resource} checking dpkg status")
-
-              shell_out_with_timeout("dpkg-deb -W #{@new_resource.source}").stdout.each_line do |line|
-                if pkginfo = DPKG_INFO.match(line)
-                  @current_resource.package_name(pkginfo[1])
-                  @new_resource.version(pkginfo[2])
-                  @candidate_version = pkginfo[2]
-                end
+              status = shell_out_with_timeout("dpkg-deb -W #{@new_resource.source}")
+              pkginfo = status.stdout.split("\t")
+              unless pkginfo.empty?
+                @current_resource.package_name(pkginfo[0])
+                @candidate_version = pkginfo[1].strip
               end
             else
               # Source provided but not valid means we can't safely do further processing
               return
             end
-
           end
 
           # Check to see if it is installed

data/lib/chef/provider/package/rpm.rb

@@ -61,7 +61,7 @@ class Chef
             Chef::Log.debug("#{@new_resource} checking rpm status")
             shell_out_with_timeout!("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@new_resource.source}").stdout.each_line do |line|
               case line
-              when /^([\w\d+_.-]+)\s([\w\d~_.-]+)$/
+              when /^(\S+)\s(\S+)$/
                 @current_resource.package_name($1)
                 @new_resource.version($2)
                 @candidate_version = $2
@@ -78,7 +78,7 @@ class Chef
           @rpm_status = shell_out_with_timeout("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@current_resource.package_name}")
           @rpm_status.stdout.each_line do |line|
             case line
-            when /^([\w\d+_.-]+)\s([\w\d~_.-]+)$/
+            when /^(\S+)\s(\S+)$/
               Chef::Log.debug("#{@new_resource} current version is #{$2}")
               @current_resource.version($2)
             end

data/lib/chef/provider/package/rubygems.rb

@@ -394,7 +394,7 @@ class Chef
         end
 
         def is_omnibus?
-          if RbConfig::CONFIG['bindir'] =~ %r!/opt/(opscode|chef)/embedded/bin!
+          if RbConfig::CONFIG['bindir'] =~ %r!/(opscode|chef|chefdk)/embedded/bin!
             Chef::Log.debug("#{@new_resource} detected omnibus installation in #{RbConfig::CONFIG['bindir']}")
             # Omnibus installs to a static path because of linking on unix, find it.
             true