chef 0.9.8 → 0.9.10.rc.0

data/lib/chef/provider/ruby_block.rb

@@ -26,7 +26,7 @@ class Chef
 
       def action_create
         @new_resource.block.call
-        @new_resource.updated = true
+        @new_resource.updated_by_last_action(true)
       end
     end
   end

data/lib/chef/provider/service.rb

@@ -36,7 +36,7 @@ class Chef
         else
           Chef::Log.debug("#{@new_resource}: attempting to enable")
           if enable_service
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource}: enabled successfully")
           end
         end
@@ -46,7 +46,7 @@ class Chef
         if @current_resource.enabled
           Chef::Log.debug("#{@new_resource}: attempting to disable")
           if disable_service
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource}: disabled successfully")
           end
         else
@@ -58,7 +58,7 @@ class Chef
         unless @current_resource.running
           Chef::Log.debug("#{@new_resource}: attempting to start")
           if start_service
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("Started service #{@new_resource} successfully")
           end
         else
@@ -70,7 +70,7 @@ class Chef
         if @current_resource.running
           Chef::Log.debug("#{@new_resource}: attempting to stop")
           if stop_service
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource}: stopped successfully")
           end
         else
@@ -81,7 +81,7 @@ class Chef
       def action_restart
         Chef::Log.debug("#{@new_resource}: attempting to restart")
         if restart_service
-          @new_resource.updated = true
+          @new_resource.updated_by_last_action(true)
           Chef::Log.info("#{@new_resource}: restarted successfully")
         end
       end
@@ -93,7 +93,7 @@ class Chef
         if @current_resource.running
           Chef::Log.debug("#{@new_resource}: attempting to reload")
           if reload_service
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource}: reloaded successfully")
           end
         end

data/lib/chef/provider/subversion.rb

@@ -30,24 +30,27 @@ class Chef
       
       def load_current_resource
         @current_resource = Chef::Resource::Subversion.new(@new_resource.name)
-        if current_revision = find_current_revision
-          @current_resource.revision current_revision
+
+        unless [:export, :force_export].include?(@new_resource.action.first)
+          if current_revision = find_current_revision
+            @current_resource.revision current_revision
+          end
         end
       end
       
       def action_checkout
         run_command(run_options(:command => checkout_command))
-        @new_resource.updated = true
+        @new_resource.updated_by_last_action(true)
       end
       
       def action_export
         run_command(run_options(:command => export_command))
-        @new_resource.updated = true
+        @new_resource.updated_by_last_action(true)
       end
       
       def action_force_export
-        run_command(run_options(:command => export_command(:force => true)))
-        @new_resource.updated = true
+        run_command(run_options(:command => export_command))
+        @new_resource.updated_by_last_action(true)
       end
       
       def action_sync
@@ -56,7 +59,7 @@ class Chef
         else
           run_command(run_options(:command => sync_command))
         end
-        @new_resource.updated = true
+        @new_resource.updated_by_last_action(true)
       end
       
       def sync_command
@@ -70,9 +73,9 @@ class Chef
             "-r#{revision_int}", @new_resource.repository, @new_resource.destination
       end
       
-      def export_command(opts={})
+      def export_command
         Chef::Log.info "exporting #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
-        args = opts[:force] ? ["--force"] : []
+        args = ["--force"]
         args << @new_resource.svn_arguments << verbose << authentication <<
             "-r#{revision_int}" << @new_resource.repository << @new_resource.destination
         scm :export, *args

data/lib/chef/provider/template.rb

@@ -46,7 +46,7 @@ class Chef
             backup
             set_all_access_controls(rendered_template.path)
             FileUtils.mv(rendered_template.path, @new_resource.path)
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
           end
         end
       end
@@ -88,7 +88,7 @@ class Chef
       def set_all_access_controls(file)
         access_controls = Chef::FileAccessControl.new(@new_resource, file)
         access_controls.set_all
-        @new_resource.updated = access_controls.modified?
+        @new_resource.updated_by_last_action(access_controls.modified?)
       end
 
       private

data/lib/chef/provider/user.rb

@@ -98,18 +98,18 @@ class Chef
         if !@user_exists
           create_user
           Chef::Log.info("Created #{@new_resource}")
-          @new_resource.updated = true
+          @new_resource.updated_by_last_action(true)
         elsif compare_user
           manage_user
           Chef::Log.info("Altered #{@new_resource}")
-          @new_resource.updated = true
+          @new_resource.updated_by_last_action(true)
         end
       end
       
       def action_remove
         if @user_exists
           remove_user
-          @new_resource.updated = true
+          @new_resource.updated_by_last_action(true)
           Chef::Log.info("Removed #{@new_resource}")
         end
       end
@@ -121,7 +121,7 @@ class Chef
       def action_manage
         if @user_exists && compare_user
           manage_user
-          @new_resource.updated = true
+          @new_resource.updated_by_last_action(true)
           Chef::Log.info("Managed #{@new_resource}")
         end
       end
@@ -134,7 +134,7 @@ class Chef
         if @user_exists
           if compare_user
             manage_user
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("Modified #{@new_resource}")
           end
         else
@@ -146,7 +146,7 @@ class Chef
         if @user_exists
           if check_lock() == false
             lock_user
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("Locked #{@new_resource}")
           else
             Chef::Log.debug("No need to lock #{@new_resource}")
@@ -168,7 +168,7 @@ class Chef
         if @user_exists
           if check_lock() == true
             unlock_user
-            @new_resource.updated = true
+            @new_resource.updated_by_last_action(true)
             Chef::Log.info("Unlocked #{@new_resource}")
           else
             Chef::Log.debug("No need to unlock #{@new_resource}")

data/lib/chef/provider/user/useradd.rb

@@ -55,7 +55,21 @@ class Chef
           end
 
           unless status.exitstatus == 0
-            raise Chef::Exceptions::User, "Cannot determine if #{@new_resource} is locked!"
+            raise_lock_error = false
+            # we can get an exit code of 1 even when it's successful on rhel/centos (redhat bug 578534)
+            if status.exitstatus == 1 && ['redhat', 'centos'].include?(node[:platform])
+              passwd_version_status = popen4('rpm -q passwd') do |pid, stdin, stdout, stderr|
+                passwd_version = stdout.gets.chomp
+
+                unless passwd_version == 'passwd-0.73-1'
+                  raise_lock_error = true
+                end
+              end
+            else
+              raise_lock_error = true
+            end
+
+            raise Chef::Exceptions::User, "Cannot determine if #{@new_resource} is locked!" if raise_lock_error
           end
 
           @locked

data/lib/chef/providers.rb

@@ -19,6 +19,7 @@
 require 'chef/provider/breakpoint'
 require 'chef/provider/cookbook_file'
 require 'chef/provider/cron'
+require 'chef/provider/cron/solaris'
 require 'chef/provider/deploy'
 require 'chef/provider/directory'
 require 'chef/provider/env'
@@ -31,6 +32,7 @@ require 'chef/provider/http_request'
 require 'chef/provider/ifconfig'
 require 'chef/provider/link'
 require 'chef/provider/log'
+require 'chef/provider/ohai'
 require 'chef/provider/mdadm'
 require 'chef/provider/mount'
 require 'chef/provider/package'

data/lib/chef/resource.rb

@@ -21,6 +21,7 @@ require 'chef/mixin/params_validate'
 require 'chef/mixin/check_helper'
 require 'chef/mixin/language'
 require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/command'
 require 'chef/resource_collection'
 require 'chef/node'
 
@@ -28,7 +29,45 @@ require 'chef/mixin/deprecation'
 
 class Chef
   class Resource
-    class Notification < Struct.new(:resource, :action)
+    class Notification < Struct.new(:resource, :action, :notifying_resource)
+
+      def duplicates?(other_notification)
+        unless other_notification.respond_to?(:resource) && other_notification.respond_to?(:action)
+          msg = "only duck-types of Chef::Resource::Notification can be checked for duplication "\
+                "you gave #{other_notification.inspect}"
+          raise ArgumentError, msg
+        end
+        other_notification.resource == resource && other_notification.action == action
+      end
+
+      def resolve_resource_reference(resource_collection)
+        return resource if resource.kind_of?(Chef::Resource)
+
+        matching_resource = resource_collection.find(resource)
+        if Array(matching_resource).size > 1
+          msg = "Notification #{self} from #{notifying_resource} was created with a reference to multiple resources, "\
+                "but can only notify one resource. Notifying resource was defined on #{notifying_resource.source_line}"
+          raise Chef::Exceptions::InvalidResourceReference, msg
+        end
+        self.resource = matching_resource
+      rescue Chef::Exceptions::ResourceNotFound => e
+        err = Chef::Exceptions::ResourceNotFound.new(<<-FAIL)
+Resource #{notifying_resource} is configured to notify resource #{resource} with action #{action}, \
+but #{resource} cannot be found in the resource collection. #{notifying_resource} is defined in \
+#{notifying_resource.source_line}
+FAIL
+        err.set_backtrace(e.backtrace)
+        raise err
+      rescue Chef::Exceptions::InvalidResourceSpecification => e
+          err = Chef::Exceptions::InvalidResourceSpecification.new(<<-F)
+Resource #{notifying_resource} is configured to notify resource #{resource} with action #{action}, \
+but #{resource.inspect} is not valid syntax to look up a resource in the resource collection. Notification \
+is defined near #{notifying_resource.source_line}
+F
+          err.set_backtrace(e.backtrace)
+        raise err
+      end
+
     end
 
     HIDDEN_IVARS = [:@allowed_actions, :@resource_name, :@source_line, :@run_context, :@name, :@node]
@@ -39,13 +78,25 @@ class Chef
     include Chef::Mixin::ConvertToClassName
     include Chef::Mixin::Deprecation
     
-    attr_accessor :params, :provider, :updated, :allowed_actions, :run_context, :cookbook_name, :recipe_name, :enclosing_provider
+    attr_accessor :params
+    attr_accessor :provider
+    attr_accessor :allowed_actions
+    attr_accessor :run_context
+    attr_accessor :cookbook_name
+    attr_accessor :recipe_name
+    attr_accessor :enclosing_provider
     attr_accessor :source_line
-    attr_reader :resource_name, :not_if_args, :only_if_args
+
+    attr_reader :updated
+
+    attr_reader :resource_name
+    attr_reader :not_if_args
+    attr_reader :only_if_args
 
     # Each notify entry is a resource/action pair, modeled as an
-    # OpenStruct with a .resource and .action member
-    attr_reader :notifies_immediate, :notifies_delayed
+    # Struct with a #resource and #action member
+    attr_reader :immediate_notifications
+    attr_reader :delayed_notifications
     
     def initialize(name, run_context=nil)
       @name = name
@@ -57,19 +108,28 @@ class Chef
       @allowed_actions = [ :nothing ]
       @action = :nothing
       @updated = false
+      @updated_by_last_action = false
       @supports = {}
       @ignore_failure = false
       @not_if = nil
       @not_if_args = {}
       @only_if = nil
       @only_if_args = {}
-      @notifies_immediate = Array.new
-      @notifies_delayed = Array.new
+      @immediate_notifications = Array.new
+      @delayed_notifications = Array.new
       @source_line = nil
 
       @node = run_context ? deprecated_ivar(run_context.node, :node, :warn) : nil
     end
-    
+
+    def updated=(true_or_false)
+      Chef::Log.warn("Chef::Resource#updated=(true|false) is deprecated. Please call #updated_by_last_action(true|false) instead.")
+      Chef::Log.warn("Called from:")
+      caller[0..3].each {|line| Chef::Log.warn(line)}
+      updated_by_last_action(true_or_false)
+      @updated = true_or_false
+    end
+
     def node
       run_context && run_context.node
     end
@@ -95,7 +155,7 @@ class Chef
           end
         end
         true
-      rescue ArgumentError => e
+      rescue Chef::Exceptions::ResourceNotFound => e
         true
       end
     end
@@ -166,31 +226,65 @@ class Chef
     def epic_fail(arg=nil)
       ignore_failure(arg)
     end
-    
+
     def notifies(*args)
-      raise ArgumentError, "Wrong number of arguments (should be 1, 2, or 3)" unless ( args.size > 0 && args.size < 4)
-      if args.size > 1
-        notifies_helper(*args)
+      unless ( args.size > 0 && args.size < 4)
+        raise ArgumentError, "Wrong number of arguments for notifies: should be 1-3 arguments, you gave #{args.inspect}"
+      end
+
+      if args.size > 1 # notifies(:action, resource) OR notifies(:action, resource, :immediately)
+        add_notification(*args)
       else
         # This syntax is so weird. surely people will just give us one hash?
         notifications = args.flatten
         notifications.each do |resources_notifications|
-          begin
-            resources_notifications.each do |resource, notification|
-              Chef::Log.error "resource KV: `#{resource.inspect}' => `#{notification.inspect}'"
-              notifies_helper(notification[0], resource, notification[1])    
-            end
-          rescue NoMethodError
-            Chef::Log.fatal("encountered NME processing resource #{resources_notifications.inspect}")
-            Chef::Log.fatal("incoming args: #{args.inspect}")
-            raise
+          resources_notifications.each do |resource, notification|
+            action, timing = notification[0], notification[1]
+            Chef::Log.debug "adding notification from resource #{self} to `#{resource.inspect}' => `#{notification.inspect}'"
+            add_notification(action, resource, timing)
           end
         end 
       end
+    rescue NoMethodError
+      Chef::Log.fatal("Error processing notifies(#{args.inspect}) on #{self}")
+      raise
     end
-    
+
+    def add_notification(action, resources, timing=:delayed)
+      resources = [resources].flatten
+      resources.each do |resource|
+        case timing.to_s
+        when 'delayed'
+          notifies_delayed(action, resource)
+        when 'immediate', 'immediately'
+          notifies_immediately(action, resource)
+        else
+          raise ArgumentError,  "invalid timing: #{timing} for notifies(#{action}, #{resources.inspect}, #{timing}) resource #{self} "\
+                                "Valid timings are: :delayed, :immediate, :immediately"
+        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
+      @immediate_notifications.each { |n| n.resolve_resource_reference(run_context.resource_collection) }
+      @delayed_notifications.each {|n| n.resolve_resource_reference(run_context.resource_collection) }
+    end
+
+    def notifies_immediately(action, resource_spec)
+      @immediate_notifications << Notification.new(resource_spec, action, self)
+    end
+
+    def notifies_delayed(action, resource_spec)
+      @delayed_notifications << Notification.new(resource_spec, action, self)
+    end
+
     def resources(*args)
-      run_context.resource_collection.resources(*args)
+      run_context.resource_collection.find(*args)
     end
     
     def subscribes(action, resources, timing=:delayed)
@@ -200,7 +294,7 @@ class Chef
       end
       true
     end
-    
+
     def is(*args)
       if args.size == 1
         args.first
@@ -272,10 +366,43 @@ class Chef
     end
     
     def run_action(action)
+      # ensure that we don't leave @updated_by_last_action set to true
+      # on accident
+      updated_by_last_action(false)
+
+      # Check if this resource has an only_if block -- if it does,
+      # evaluate the only_if block and skip the resource if
+      # appropriate.
+      if only_if
+        unless Chef::Mixin::Command.only_if(only_if, only_if_args)
+          Chef::Log.debug("Skipping #{self} due to only_if")
+          return
+        end
+      end
+
+      # Check if this resource has a not_if block -- if it does,
+      # evaluate the not_if block and skip the resource if
+      # appropriate.
+      if not_if
+        unless Chef::Mixin::Command.not_if(not_if, not_if_args)
+          Chef::Log.debug("Skipping #{self} due to not_if")
+          return
+        end
+      end
+
       provider = Chef::Platform.provider_for_resource(self)
       provider.load_current_resource
       provider.send("action_#{action}")
     end
+
+    def updated_by_last_action(true_or_false)
+      @updated ||= true_or_false
+      @updated_by_last_action = true_or_false
+    end
+
+    def updated_by_last_action?
+      @updated_by_last_action
+    end
     
     def updated?
       updated
@@ -377,41 +504,20 @@ class Chef
       end
       
     end
-    
+
     private
-    
-      def lookup_provider_constant(name)
-        begin
-          self.class.provider_base.const_get(convert_to_class_name(name.to_s))
-        rescue NameError => e
-          if e.to_s =~ /#{Regexp.escape(self.class.provider_base.to_s)}/
-            raise ArgumentError, "No provider found to match '#{name}'"
-          else
-            raise e
-          end
-        end
-      end
-      
-      def validate_timing(timing)
-        timing = timing.to_sym
-        raise ArgumentError, "invalid timing: #{timing}; must be one of: :delayed, :immediate, :immediately" unless (timing == :delayed || timing == :immediate || timing == :immediately)
-        timing == :immediately ? :immediate : timing
-      end
-      
-      def notifies_helper(action, resources, timing=:delayed)
-        timing = validate_timing(timing)
-        
-        resource_array = [resources].flatten
-        resource_array.each do |resource|
-          new_notify = Notification.new(resource, action)
-          if timing == :delayed
-            notifies_delayed << new_notify
-          else
-            notifies_immediate << new_notify
-          end
+
+    def lookup_provider_constant(name)
+      begin
+        self.class.provider_base.const_get(convert_to_class_name(name.to_s))
+      rescue NameError => e
+        if e.to_s =~ /#{Regexp.escape(self.class.provider_base.to_s)}/
+          raise ArgumentError, "No provider found to match '#{name}'"
+        else
+          raise e
         end
-        
-        true
       end
     end
+
+  end
 end