chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/providers.rb

@@ -86,6 +86,7 @@ require 'chef/provider/group/aix'
 require 'chef/provider/group/dscl'
 require 'chef/provider/group/gpasswd'
 require 'chef/provider/group/groupadd'
+require 'chef/provider/group/groupmod'
 require 'chef/provider/group/pw'
 require 'chef/provider/group/suse'
 require 'chef/provider/group/usermod'

data/lib/chef/resource.rb

@@ -71,8 +71,8 @@ F
 
     end
 
-    FORBIDDEN_IVARS = [:@run_context, :@node, :@not_if, :@only_if]
-    HIDDEN_IVARS = [:@allowed_actions, :@resource_name, :@source_line, :@run_context, :@name, :@node]
+    FORBIDDEN_IVARS = [:@run_context, :@node, :@not_if, :@only_if, :@enclosing_provider]
+    HIDDEN_IVARS = [:@allowed_actions, :@resource_name, :@source_line, :@run_context, :@name, :@node, :@not_if, :@only_if, :@elapsed_time, :@enclosing_provider]
 
     include Chef::Mixin::CheckHelper
     include Chef::Mixin::ParamsValidate
@@ -80,6 +80,53 @@ F
     include Chef::Mixin::ConvertToClassName
     include Chef::Mixin::Deprecation
 
+
+    # Set or return the list of "state attributes" implemented by the Resource
+    # subclass. State attributes are attributes that describe the desired state
+    # of the system, such as file permissions or ownership. In general, state
+    # attributes are attributes that could be populated by examining the state
+    # of the system (e.g., File.stat can tell you the permissions on an
+    # existing file). Contrarily, attributes that are not "state attributes"
+    # usually modify the way Chef itself behaves, for example by providing
+    # additional options for a package manager to use when installing a
+    # package.
+    #
+    # This list is used by the Chef client auditing system to extract
+    # information from resources to describe changes made to the system.
+    def self.state_attrs(*attr_names)
+      @state_attrs ||= []
+      @state_attrs = attr_names unless attr_names.empty?
+
+      # Return *all* state_attrs that this class has, including inherited ones
+      if superclass.respond_to?(:state_attrs)
+        superclass.state_attrs + @state_attrs
+      else
+        @state_attrs
+      end
+    end
+
+    # Set or return the "identity attribute" for this resource class. This is
+    # generally going to be the "name attribute" for this resource. In other
+    # words, the resource type plus this attribute uniquely identify a given
+    # bit of state that chef manages. For a File resource, this would be the
+    # path, for a package resource, it will be the package name. This will show
+    # up in chef-client's audit records as a searchable field.
+    def self.identity_attr(attr_name=nil)
+      @identity_attr ||= nil
+      @identity_attr = attr_name if attr_name
+
+      # If this class doesn't have an identity attr, we'll defer to the superclass:
+      if @identity_attr || !superclass.respond_to?(:identity_attr)
+        @identity_attr
+      else
+        superclass.identity_attr
+      end
+    end
+
+    def self.dsl_name
+      convert_to_snake_case(name, 'Chef::Resource')
+    end
+
     attr_accessor :params
     attr_accessor :provider
     attr_accessor :allowed_actions
@@ -97,6 +144,8 @@ F
     attr_reader :not_if_args
     attr_reader :only_if_args
 
+    attr_reader :elapsed_time
+
     # Each notify entry is a resource/action pair, modeled as an
     # Struct with a #resource and #action member
     attr_reader :immediate_notifications
@@ -122,10 +171,31 @@ F
       @immediate_notifications = Array.new
       @delayed_notifications = Array.new
       @source_line = nil
+      @elapsed_time = 0
 
       @node = run_context ? deprecated_ivar(run_context.node, :node, :warn) : nil
     end
 
+    # Returns a Hash of attribute => value for the state attributes declared in
+    # the resource's class definition.
+    def state
+      self.class.state_attrs.inject({}) do |state_attrs, attr_name|
+        state_attrs[attr_name] = send(attr_name)
+        state_attrs
+      end
+    end
+
+    # Returns the value of the identity attribute, if declared. Falls back to
+    # #name if no identity attribute is declared.
+    def identity
+      if identity_attr = self.class.identity_attr
+        send(identity_attr)
+      else
+        name
+      end
+    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:")
@@ -329,13 +399,17 @@ F
 
     def to_text
       ivars = instance_variables.map { |ivar| ivar.to_sym } - HIDDEN_IVARS
-      text = "# Declared in #{@source_line}\n"
-      text << convert_to_snake_case(self.class.name, 'Chef::Resource') + "(\"#{name}\") do\n"
+      text = "# Declared in #{@source_line}\n\n"
+      text << self.class.dsl_name + "(\"#{name}\") do\n"
       ivars.each do |ivar|
         if (value = instance_variable_get(ivar)) && !(value.respond_to?(:empty?) && value.empty?)
-          text << "  #{ivar.to_s.sub(/^@/,'')}(#{value.inspect})\n"
+          value_string = value.respond_to?(:to_text) ? value.to_text : value.inspect
+          text << "  #{ivar.to_s.sub(/^@/,'')} #{value_string}\n"
         end
       end
+      [@not_if, @only_if].flatten.each do |conditional|
+        text << "  #{conditional.to_text}\n"
+      end
       text << "end\n"
     end
 
@@ -430,7 +504,26 @@ F
       end
     end
 
-    def run_action(action)
+    def cookbook_version
+      if cookbook_name
+        run_context.cookbook_collection[cookbook_name]
+      end
+    end
+
+    def events
+      run_context.events
+    end
+
+    def run_action(action, notification_type=nil, notifying_resource=nil)
+      # reset state in case of multiple actions on the same resource.
+      @elapsed_time = 0
+      start_time = Time.now
+      events.resource_action_start(self, action, notification_type, notifying_resource)
+      # Try to resolve lazy/forward references in notifications again to handle
+      # the case where the resource was defined lazily (ie. in a ruby_block)
+      resolve_notification_references
+      validate_action(action)
+
       if Chef::Config[:verbose_logging] || Chef::Log.level == :debug
         # This can be noisy
         Chef::Log.info("Processing #{self} action #{action} (#{defined_at})")
@@ -441,29 +534,49 @@ F
       updated_by_last_action(false)
 
       begin
-        return if should_skip?
-        # leverage new platform => short_name => resource
-        # which requires explicitly setting provider in
-        # resource class
-        if self.provider
-          provider = self.provider.new(self, self.run_context)
-        else # fall back to old provider resolution
-          provider = Chef::Platform.provider_for_resource(self)
-        end
-        provider.load_current_resource
-        provider.send("action_#{action}")
-      rescue => e
+        return if should_skip?(action)
+        provider_for_action(action).run_action
+      rescue Exception => e
         if ignore_failure
-          Chef::Log.error("#{self} (#{defined_at}) had an error: #{e.message}")
+          Chef::Log.error("#{self} (#{defined_at}) had an error: #{e.message}; ignore_failure is set, continuing")
+          events.resource_failed(self, action, e)
+        elsif retries > 0
+          events.resource_failed_retriable(self, action, retries, e)
+          @retries -= 1
+          Chef::Log.info("Retrying execution of #{self}, #{retries} attempt(s) left")
+          sleep retry_delay
+          retry
         else
-          Chef::Log.error("#{self} (#{defined_at}) has had an error")
-          new_exception = e.exception("#{self} (#{defined_at}) had an error: #{e.class.name}: #{e.message}")
-          new_exception.set_backtrace(e.backtrace)
-          raise new_exception
+          events.resource_failed(self, action, e)
+          raise customize_exception(e)
         end
+      ensure
+        @elapsed_time = Time.now - start_time
       end
     end
 
+    def validate_action(action)
+      raise ArgumentError, "nil is not a valid action for resource #{self}" if action.nil?
+    end
+
+    def provider_for_action(action)
+      # leverage new platform => short_name => resource
+      # which requires explicitly setting provider in
+      # resource class
+      if self.provider
+        provider = self.provider.new(self, self.run_context)
+        provider.action = action
+        provider
+      else # fall back to old provider resolution
+        Chef::Platform.provider_for_resource(self, action)
+      end
+    end
+
+    def customize_exception(e)
+      new_exception = e.exception("#{self} (#{defined_at}) had an error: #{e.class.name}: #{e.message}")
+      new_exception.set_backtrace(e.backtrace)
+      new_exception
+    end
     # Evaluates not_if and only_if conditionals. Returns a falsey value if any
     # of the conditionals indicate that this resource should be skipped, i.e.,
     # if an only_if evaluates to false or a not_if evaluates to true.
@@ -472,7 +585,7 @@ F
     # "fails" its check. Subsequent conditionals are not evaluated, so in
     # general it's not a good idea to rely on side effects from not_if or
     # only_if commands/blocks being evaluated.
-    def should_skip?
+    def should_skip?(action)
       conditionals = only_if + not_if
       return false if conditionals.empty?
 
@@ -480,6 +593,7 @@ F
         if conditional.continue?
           false
         else
+          events.resource_skipped(self, action, conditional)
           Chef::Log.debug("Skipping #{self} due to #{conditional.description}")
           true
         end

data/lib/chef/resource/conditional.rb

@@ -88,6 +88,14 @@ class Chef
         "#{@positivity} #{cmd_or_block}"
       end
 
+      def to_text
+        if @command
+          "#{positivity} \"#{@command}\""
+        else
+          "#{@positivity} { #code block }"
+        end
+      end
+
     end
   end
 end

data/lib/chef/resource/deploy.rb

@@ -75,6 +75,7 @@ class Chef
         @provider = Chef::Provider::Deploy::Timestamped
         @allowed_actions.push(:force_deploy, :deploy, :rollback)
         @additional_remotes = Hash[]
+        @keep_releases = 5
       end
 
       # where the checked out/cloned code goes
@@ -295,6 +296,14 @@ class Chef
         )
       end
 
+       # The number of old release directories to keep around after cleanup
+      def keep_releases(arg=nil)
+        [set_or_return(
+          :keep_releases,
+          arg,
+          :kind_of => [ Integer ]), 1].max
+      end
+
       # An array of paths, relative to your app's root, to be purged from a
       # SCM clone/checkout before symlinking. Use this to get rid of files and
       # directories you want to be shared between releases.

data/lib/chef/resource/execute.rb

@@ -52,7 +52,7 @@ class Chef
         set_or_return(
           :command,
           arg,
-          :kind_of => [ String ]
+          :kind_of => [ String, Array ]
         )
       end
 

data/lib/chef/resource/file.rb

@@ -18,6 +18,7 @@
 #
 
 require 'chef/resource'
+require 'chef/platform'
 require 'chef/provider/file'
 require 'chef/mixin/securable'
 
@@ -26,6 +27,15 @@ class Chef
     class File < Chef::Resource
       include Chef::Mixin::Securable
 
+      identity_attr :path
+
+      state_attrs :checksum, :owner, :group, :mode
+
+      # By default, windows gets `state_attrs :rights, :deny_rights`
+      if Platform.windows?
+        state_attrs :rights, :deny_rights
+      end
+
       provides :file, :on_platforms => :all
 
       def initialize(name, run_context=nil)
@@ -38,6 +48,7 @@ class Chef
         @provider = Chef::Provider::File
       end
 
+
       def content(arg=nil)
         set_or_return(
           :content,

data/lib/chef/resource/link.rb

@@ -62,6 +62,26 @@ class Chef
         )
       end
 
+      def group(arg=nil)
+        set_or_return(
+          :group,
+          arg,
+          :regex => Chef::Config[:group_valid_regex]
+        )
+      end
+
+      def owner(arg=nil)
+        set_or_return(
+          :owner,
+          arg,
+          :regex => Chef::Config[:user_valid_regex]
+        )
+      end
+
+      # make link quack like a file (XXX: not for public consumption)
+      def path
+        @target_file
+      end
     end
   end
 end

data/lib/chef/resource/package.rb

@@ -22,6 +22,10 @@ class Chef
   class Resource
     class Package < Chef::Resource
 
+      identity_attr :package_name
+
+      state_attrs :version
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :package

data/lib/chef/resource/template.rb

@@ -70,7 +70,6 @@ class Chef
           :kind_of => [ TrueClass, FalseClass ]
         )
       end
-
     end
   end
 end

data/lib/chef/resource_reporter.rb

@@ -0,0 +1,195 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Prajakta Purohit (prajakta@opscode.com>)
+#
+# Copyright:: Copyright (c) 2012 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.
+#
+
+require 'uri'
+require 'chef/event_dispatch/base'
+
+class Chef
+  class ResourceReporter < EventDispatch::Base
+
+    class ResourceReport < Struct.new(:new_resource,
+                                      :current_resource,
+                                      :action,
+                                      :exception,
+                                      :elapsed_time)
+
+      def self.new_with_current_state(new_resource, action, current_resource)
+        report = new
+        report.new_resource = new_resource
+        report.action = action
+        report.current_resource = current_resource
+        report
+      end
+
+      def self.new_for_exception(new_resource, action)
+        report = new
+        report.new_resource = new_resource
+        report.action = action
+        report
+      end
+
+      def for_json
+        as_hash = {}
+        as_hash["type"]   = new_resource.class.dsl_name
+        as_hash["name"]   = new_resource.name
+        as_hash["id"]     = new_resource.identity
+        as_hash["after"]  = new_resource.state
+        as_hash["before"] = current_resource.state if current_resource
+        as_hash["duration"] = (elapsed_time * 1000).to_i.to_s
+        # TODO: include diffs, etc. here:
+        as_hash["delta"] = ""
+        # TODO: rename as "action"
+        as_hash["result"] = action.to_s
+        if success?
+        else
+          #as_hash["result"] = "failed"
+        end
+        as_hash["cookbook_name"] = new_resource.cookbook_name
+        as_hash["cookbook_version"] = new_resource.cookbook_version.version
+        as_hash
+
+      end
+
+      def finish
+        self.elapsed_time = new_resource.elapsed_time
+      end
+
+      def success?
+        !self.exception
+      end
+    end
+
+    attr_reader :updated_resources
+    attr_reader :status
+    attr_reader :exception
+    attr_reader :run_id
+
+    def initialize(rest_client)
+      @reporting_enabled = true
+      @updated_resources = []
+      @total_res_count = 0
+      @pending_update  = nil
+      @status = "success"
+      @exception = nil
+      @run_id = nil
+      @rest_client = rest_client
+      @node = nil
+    end
+
+    def node_load_completed(node, expanded_run_list_with_versions, config)
+      @node = node
+      resource_history_url = "nodes/#{@node.name}/runs"
+      server_response = @rest_client.post_rest(resource_history_url, {:action => :begin})
+      run_uri = URI.parse(server_response["uri"])
+      @run_id = ::File.basename(run_uri.path)
+    rescue Net::HTTPServerException => e
+      raise unless e.response.code.to_s == "404"
+      Chef::Log.debug("Received 404 attempting to generate run history id (URL Path: #{resource_history_url}), assuming feature is not supported.")
+      @reporting_enabled = false
+    end
+
+    def resource_current_state_loaded(new_resource, action, current_resource)
+      unless nested_resource?(new_resource)
+        @pending_update = ResourceReport.new_with_current_state(new_resource, action, current_resource)
+      end
+    end
+
+    def resource_up_to_date(new_resource, action)
+      @total_res_count += 1
+      @pending_update = nil unless nested_resource?(new_resource)
+    end
+
+    def resource_skipped(resource, action, conditional)
+      @total_res_count += 1
+    end
+
+    def resource_updated(new_resource, action)
+      @total_res_count += 1
+      resource_completed unless nested_resource?(new_resource)
+    end
+
+    def resource_failed(new_resource, action, exception)
+      @total_res_count += 1
+      unless nested_resource?(new_resource)
+        @pending_update ||= ResourceReport.new_for_exception(new_resource, action)
+        @pending_update.exception = exception
+        resource_completed
+      end
+    end
+
+    def run_completed(node)
+      if reporting_enabled?
+        resource_history_url = "nodes/#{@node.name}/runs/#{run_id}"
+        run_data = report(node)
+        run_data["action"] = "end"
+        Chef::Log.info("Sending resource update report (run-id: #{run_id})")
+        Chef::Log.debug run_data.inspect
+        @rest_client.post_rest(resource_history_url, run_data)
+      else
+        Chef::Log.debug("Server doesn't support resource history, skipping resource report.")
+      end
+    end
+
+    def run_failed(exception)
+      @exception = exception
+      @status = "failed"
+    end
+
+    def report(node)
+      run_data = {}
+      run_data["resources"] = updated_resources.map do |resource_record|
+        resource_record.for_json
+      end
+      run_data["status"] = status
+      run_data["run_list"] = node.run_list.to_json
+      run_data["total_res_count"] = @total_res_count.to_s
+      if exception
+        run_data["exception"] = {}
+        run_data["exception"]["class"] = exception.inspect
+        run_data["exception"]["message"] = exception.message
+        run_data["exception"]["backtrace"] = exception.backtrace
+        run_data["exception"]["description"] = "FIXME: error inspection stuff should go here"
+      end
+      run_data["data"] = {}
+      run_data
+    end
+
+    def reporting_enabled?
+      @reporting_enabled
+    end
+
+    private
+
+    # If we are getting messages about a resource while we are in the middle of
+    # another resource's update, we assume that the nested resource is just the
+    # implementation of a provider, and we want to hide it from the reporting
+    # output.
+    def nested_resource?(new_resource)
+      @pending_update && @pending_update.new_resource != new_resource
+    end
+
+    def resource_completed
+      @pending_update.finish
+      @updated_resources << @pending_update
+      @pending_update = nil
+    end
+
+  end
+end