chef 10.14.0.beta.1 → 10.14.0.beta.2

data/lib/chef/formatters/error_descriptor.rb

@@ -0,0 +1,66 @@
+#
+# Author:: Tyler Cloke (<tyler@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.
+#
+
+class Chef
+  module Formatters
+    # == Formatters::ErrorDescription
+    # Class for displaying errors on STDOUT.
+    class ErrorDescription
+
+      attr_reader :sections
+
+      def initialize(title)
+        @title = title
+        @sections = []
+      end
+
+      def section(heading, text)
+        @sections << [heading, text]
+      end
+
+      def display(out)
+        out.puts "=" * 80
+        out.puts @title, :red
+        out.puts "=" * 80
+        out.puts "\n"
+        sections.each do |section|
+          display_section(section, out)
+        end
+      end
+
+      def for_json()
+        {
+          'title' => @title,
+          'sections' => @sections
+        }
+      end
+
+      private
+
+      def display_section(section, out)
+        heading, text = section
+        out.puts heading
+        out.puts "-" * heading.size
+        out.puts text
+        out.puts "\n"
+      end
+
+    end
+  end
+end

data/lib/chef/formatters/error_inspectors/resource_failure_inspector.rb

@@ -1,5 +1,6 @@
 #--
 # Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Tyler Cloke (<tyler@opscode.com>)
 # Copyright:: Copyright (c) 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -84,7 +85,7 @@ class Chef
         end
 
         def filtered_bt
-          exception.backtrace.select {|l| l =~ /^#{Chef::Config.file_cache_path}/ }
+          Array( exception.backtrace ).select {|l| l =~ /^#{Chef::Config.file_cache_path}/ }
         end
 
         private

data/lib/chef/formatters/error_inspectors/run_list_expansion_error_inspector.rb

@@ -1,14 +1,15 @@
 #--
 # Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Tyler Cloke (<tyler@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.

data/lib/chef/formatters/error_mapper.rb

@@ -0,0 +1,78 @@
+#--
+# Author:: Tyler Cloke (<tyler@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.
+#
+
+class Chef
+  module Formatters
+    # == Formatters::ErrorMapper
+    # Collection of methods for creating and returning
+    # Formatters::ErrorDescription objects based on node,
+    # exception, and configuration information.
+    module ErrorMapper
+
+      # Failed to register this client with the server.
+      def self.registration_failed_helper(node_name, exception, config)
+        error_inspector = ErrorInspectors::RegistrationErrorInspector.new(node_name, exception, config)
+        headline = "Chef encountered an error attempting to create the client \"#{node_name}\""
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        return description
+      end
+
+      def self.node_load_failed_helper(node_name, exception, config)
+        error_inspector = ErrorInspectors::NodeLoadErrorInspector.new(node_name, exception, config)
+        headline = "Chef encountered an error attempting to load the node data for \"#{node_name}\""
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        return description
+      end
+
+      def self.run_list_expand_failed_helper(node, exception)
+        error_inspector = ErrorInspectors::RunListExpansionErrorInspector.new(node, exception)
+        headline = "Error expanding the run_list:"
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        return description
+      end
+
+      def self.cookbook_resolution_failed_helper(expanded_run_list, exception)
+        error_inspector = ErrorInspectors::CookbookResolveErrorInspector.new(expanded_run_list, exception)
+        headline = "Error Resolving Cookbooks for Run List:"
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        return description
+      end
+
+      def self.cookbook_sync_failed_helper(cookbooks, exception)
+        error_inspector = ErrorInspectors::CookbookSyncErrorInspector.new(cookbooks, exception)
+        headline = "Error Syncing Cookbooks:"
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        return description
+      end
+
+      def self.resource_failed_helper(resource, action, exception)
+        error_inspector = ErrorInspectors::ResourceFailureInspector.new(resource, action, exception)
+        headline = "Error executing action `#{action}` on resource '#{resource}'"
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        return description
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/language_include_recipe.rb

@@ -48,6 +48,7 @@ class Chef
 
 
       def require_recipe(*args)
+        Chef::Log.warn("require_recipe is deprecated and will be removed in a future release, please use include_recipe")
         include_recipe(*args)
       end
 

data/lib/chef/provider.rb

@@ -79,6 +79,9 @@ class Chef
     def define_resource_requirements
     end
 
+    def cleanup_after_converge
+    end
+
     def action_nothing
       Chef::Log.debug("Doing nothing for #{@new_resource.to_s}")
       true
@@ -120,6 +123,8 @@ class Chef
         send("action_#{@action}")
       end
       converge
+
+      cleanup_after_converge
     end
 
     def process_resource_requirements

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

@@ -323,6 +323,7 @@ class Chef
         include Chef::Mixin::ShellOut
 
         attr_reader :gem_env
+        attr_reader :cleanup_gem_env
 
         def logger
           Chef::Log.logger
@@ -332,6 +333,7 @@ class Chef
 
         def initialize(new_resource, run_context=nil)
           super
+          @cleanup_gem_env = true
           if new_resource.gem_binary
             if new_resource.options && new_resource.options.kind_of?(Hash)
               msg =  "options cannot be given as a hash when using an explicit gem_binary\n"
@@ -349,6 +351,7 @@ class Chef
             Chef::Log.debug("#{@new_resource} using gem '#{gem_location}'")
           else
             @gem_env = CurrentGemEnvironment.new
+            @cleanup_gem_env = false
             Chef::Log.debug("#{@new_resource} using gem from running ruby environment")
           end
         end
@@ -430,6 +433,13 @@ class Chef
           @current_resource
         end
 
+        def cleanup_after_converge
+          if @cleanup_gem_env
+            logger.debug { "#{@new_resource} resetting gem environment to default" }
+            Gem.clear_paths
+          end
+        end
+
         def candidate_version
           @candidate_version ||= begin
             if target_version_already_installed?

data/lib/chef/resource.rb

@@ -41,19 +41,34 @@ class Chef
         other_notification.resource == resource && other_notification.action == action
       end
 
+      # If resource and/or notifying_resource is not a resource object, this will look them up in the resource collection
+      # and fix the references from strings to actual Resource objects.
       def resolve_resource_reference(resource_collection)
-        return resource if resource.kind_of?(Chef::Resource)
+        return resource if resource.kind_of?(Chef::Resource) && notifying_resource.kind_of?(Chef::Resource)
 
+        if not(resource.kind_of?(Chef::Resource))
+          fix_resource_reference(resource_collection)
+        end
+
+        if not(notifying_resource.kind_of?(Chef::Resource))
+          fix_notifier_reference(resource_collection)
+        end
+      end
+
+      # This will look up the resource if it is not a Resource Object.  It will complain if it finds multiple
+      # resources, can't find a resource, or gets invalid syntax.
+      def fix_resource_reference(resource_collection)
         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}"
+          "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}, \
+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
@@ -64,6 +79,36 @@ FAIL
 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
+
+      # This will look up the notifying_resource if it is not a Resource Object.  It will complain if it finds multiple
+      # resources, can't find a resource, or gets invalid syntax.
+      def fix_notifier_reference(resource_collection)
+        matching_notifier = resource_collection.find(notifying_resource)
+        if Array(matching_notifier).size > 1
+          msg = "Notification #{self} from #{notifying_resource} was created with a reference to multiple notifying "\
+          "resources, but can only originate from one resource.  Destination resource was defined "\
+          "on #{resource.source_line}"
+          raise Chef::Exceptions::InvalidResourceReference, msg
+        end
+        self.notifying_resource = matching_notifier
+
+      rescue Chef::Exceptions::ResourceNotFound => e
+        err = Chef::Exceptions::ResourceNotFound.new(<<-FAIL)
+Resource #{resource} is configured to receive notifications from #{notifying_resource} with action #{action}, \
+but #{notifying_resource} cannot be found in the resource collection. #{resource} is defined in \
+#{resource.source_line}
+FAIL
+        err.set_backtrace(e.backtrace)
+        raise err
+      rescue Chef::Exceptions::InvalidResourceSpecification => e
+          err = Chef::Exceptions::InvalidResourceSpecification.new(<<-F)
+Resource #{resource} is configured to receive notifications from  #{notifying_resource} with action #{action}, \
+but #{notifying_resource.inspect} is not valid syntax to look up a resource in the resource collection. Notification \
+is defined near #{resource.source_line}
 F
           err.set_backtrace(e.backtrace)
         raise err
@@ -148,8 +193,6 @@ F
 
     # Each notify entry is a resource/action pair, modeled as an
     # Struct with a #resource and #action member
-    attr_reader :immediate_notifications
-    attr_reader :delayed_notifications
 
     def initialize(name, run_context=nil)
       @name = name
@@ -168,8 +211,6 @@ F
       @retry_delay = 2
       @not_if = []
       @only_if = []
-      @immediate_notifications = Array.new
-      @delayed_notifications = Array.new
       @source_line = nil
       @elapsed_time = 0
 
@@ -361,16 +402,24 @@ F
     # 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) }
+      run_context.immediate_notifications(self).each { |n| n.resolve_resource_reference(run_context.resource_collection) }
+      run_context.delayed_notifications(self).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)
+      run_context.notifies_immediately(Notification.new(resource_spec, action, self))
     end
 
     def notifies_delayed(action, resource_spec)
-      @delayed_notifications << Notification.new(resource_spec, action, self)
+      run_context.notifies_delayed(Notification.new(resource_spec, action, self))
+    end
+
+    def immediate_notifications
+      run_context.immediate_notifications(self)
+    end
+
+    def delayed_notifications
+      run_context.delayed_notifications(self)
     end
 
     def resources(*args)
@@ -380,7 +429,13 @@ F
     def subscribes(action, resources, timing=:delayed)
       resources = [resources].flatten
       resources.each do |resource|
-        resource.notifies(action, self, timing)
+        if resource.is_a?(String)
+          resource = Chef::Resource.new(resource, run_context)
+        end
+        if resource.run_context.nil?
+          resource.run_context = run_context
+        end
+        resource.add_notification(action, self, timing)
       end
       true
     end
@@ -551,6 +606,7 @@ F
           raise customize_exception(e)
         end
       ensure
+        events.resource_completed(self)
         @elapsed_time = Time.now - start_time
       end
     end

data/lib/chef/resource_reporter.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Daniel DeLeo (<dan@opscode.com>)
 # Author:: Prajakta Purohit (prajakta@opscode.com>)
+# Auther:: Tyler Cloke (<tyler@opscode.com>)
 #
 # Copyright:: Copyright (c) 2012 Opscode, Inc.
 # License:: Apache License, Version 2.0
@@ -24,6 +25,8 @@ require 'chef/event_dispatch/base'
 class Chef
   class ResourceReporter < EventDispatch::Base
 
+
+
     class ResourceReport < Struct.new(:new_resource,
                                       :current_resource,
                                       :action,
@@ -51,7 +54,7 @@ class Chef
         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["before"] = current_resource ? current_resource.state : {}
         as_hash["duration"] = (elapsed_time * 1000).to_i.to_s
         # TODO: include diffs, etc. here:
         as_hash["delta"] = ""
@@ -80,6 +83,7 @@ class Chef
     attr_reader :status
     attr_reader :exception
     attr_reader :run_id
+    attr_reader :error_descriptions
 
     def initialize(rest_client)
       @reporting_enabled = true
@@ -91,6 +95,7 @@ class Chef
       @run_id = nil
       @rest_client = rest_client
       @node = nil
+      @error_descriptions = nil
     end
 
     def node_load_completed(node, expanded_run_list_with_versions, config)
@@ -99,6 +104,7 @@ class Chef
       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)
+      Chef::Log.info("Chef server generated run history id: #{@run_id}")
     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.")
@@ -118,11 +124,11 @@ class Chef
 
     def resource_skipped(resource, action, conditional)
       @total_res_count += 1
+      @pending_update = nil unless nested_resource?(resource)
     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)
@@ -130,7 +136,16 @@ class Chef
       unless nested_resource?(new_resource)
         @pending_update ||= ResourceReport.new_for_exception(new_resource, action)
         @pending_update.exception = exception
-        resource_completed
+      end
+      description = Formatters::ErrorMapper.resource_failed_helper(new_resource, action, exception)
+      @error_descriptions = description.for_json
+    end
+
+    def resource_completed(new_resource)
+      if @pending_update && !nested_resource?(new_resource)
+        @pending_update.finish
+        @updated_resources << @pending_update
+        @pending_update = nil
       end
     end
 
@@ -149,7 +164,7 @@ class Chef
 
     def run_failed(exception)
       @exception = exception
-      @status = "failed"
+      @status = "failure"
     end
 
     def report(node)
@@ -160,17 +175,32 @@ class Chef
       run_data["status"] = status
       run_data["run_list"] = node.run_list.to_json
       run_data["total_res_count"] = @total_res_count.to_s
+      run_data["data"] = {}
       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"
+        run_data["data"]["exception"] = {}
+        run_data["data"]["exception"]["class"] = exception.inspect
+        run_data["data"]["exception"]["message"] = exception.message
+        run_data["data"]["exception"]["backtrace"] = exception.backtrace
+        run_data["data"]["exception"]["description"] = @error_descriptions
       end
-      run_data["data"] = {}
       run_data
     end
 
+    def run_list_expand_failed(node, exception)
+      description = Formatters::ErrorMapper.run_list_expand_failed_helper(node, exception)
+      @error_descriptions = description.for_json
+    end
+
+    def cookbook_resolution_failed(expanded_run_list, exception)
+      description = Formatters::ErrorMapper.cookbook_resolution_failed_helper(expanded_run_list, exception)
+      @error_descriptions = description.for_json
+    end
+
+    def cookbook_sync_failed(cookbooks, exception)
+      description = Formatters::ErrorMapper.cookbook_sync_failed_helper(cookbooks, exception)
+      @error_descriptions = description.for_json
+    end
+
     def reporting_enabled?
       @reporting_enabled
     end
@@ -185,11 +215,5 @@ class Chef
       @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