chef 10.28.2-x86-mingw32

data/lib/chef/event_dispatch/base.rb

@@ -0,0 +1,311 @@
+class Chef
+
+  # ==EventDispatch
+  # Classes in EventDispatch deal with collecting, distributing, and handling
+  # information in response to events that occur during a chef-client run.
+  #
+  # EventDispatch uses a simple publishing system where data from all events
+  # are forwarded to all subscribers unconditionally.
+  #
+  # EventDispatch is used to implement custom console output formatters so that
+  # users may have more control over the formatting and verbosity of Chef
+  # client output and client-side data collection for server-side client
+  # history storage and reporting.
+  #
+  # === API Stability Status
+  # The EventDispatch API is intended to become a stable, public API upon which
+  # end-users can implement their own custom output formatters, reporting
+  # integration libraries, and more. This is a new feature, however, so
+  # breaking changes may be required as it "bakes" in order to provide a clean,
+  # coherent and supportable API in the long term. Therefore, developers should
+  # consider the feature "beta" for now and be prepared for possible breaking
+  # changes in point releases.
+  module EventDispatch
+
+    # == EventDispatch::Base
+    # EventDispatch::Base is a completely abstract base class that defines the
+    # API used by both the classes that collect event information and those
+    # that process them.
+    class Base
+
+      # Called at the very start of a Chef Run
+      def run_start(version)
+      end
+
+      # Called at the end a successful Chef run.
+      def run_completed(node)
+      end
+
+      # Called at the end of a failed Chef run.
+      def run_failed(exception)
+      end
+
+      # Called right after ohai runs.
+      def ohai_completed(node)
+      end
+
+      # Already have a client key, assuming this node has registered.
+      def skipping_registration(node_name, config)
+      end
+
+      # About to attempt to register as +node_name+
+      def registration_start(node_name, config)
+      end
+
+      def registration_completed
+      end
+
+      # Failed to register this client with the server.
+      def registration_failed(node_name, exception, config)
+      end
+
+      # Called before Chef client loads the node data from the server
+      def node_load_start(node_name, config)
+      end
+
+      # TODO: def node_run_list_overridden(*args)
+
+      # Failed to load node data from the server
+      def node_load_failed(node_name, exception, config)
+      end
+
+      # Error expanding the run list
+      def run_list_expand_failed(node, exception)
+      end
+
+      # Called after Chef client has loaded the node data.
+      # Default and override attrs from roles have been computed, but not yet applied.
+      # Normal attrs from JSON have been added to the node.
+      def node_load_completed(node, expanded_run_list, config)
+      end
+
+      # Called before the cookbook collection is fetched from the server.
+      def cookbook_resolution_start(expanded_run_list)
+      end
+
+      # Called when there is an error getting the cookbook collection from the
+      # server.
+      def cookbook_resolution_failed(expanded_run_list, exception)
+      end
+
+      # Called when the cookbook collection is returned from the server.
+      def cookbook_resolution_complete(cookbook_collection)
+      end
+
+      # Called before unneeded cookbooks are removed
+      def cookbook_clean_start
+      end
+
+      # Called after the file at +path+ is removed. It may be removed if the
+      # cookbook containing it was removed from the run list, or if the file was
+      # removed from the cookbook.
+      def removed_cookbook_file(path)
+      end
+
+      # Called when cookbook cleaning is finished.
+      def cookbook_clean_complete
+      end
+
+      # Called before cookbook sync starts
+      def cookbook_sync_start(cookbook_count)
+      end
+
+      # Called when cookbook +cookbook_name+ has been sync'd
+      def synchronized_cookbook(cookbook_name)
+      end
+
+      # Called when an individual file in a cookbook has been updated
+      def updated_cookbook_file(cookbook_name, path)
+      end
+
+      # Called when an error occurs during cookbook sync
+      def cookbook_sync_failed(cookbooks, exception)
+      end
+
+      # Called after all cookbooks have been sync'd.
+      def cookbook_sync_complete
+      end
+
+      ## TODO: add cookbook name to the API for file load callbacks
+
+      ## TODO: add callbacks for overall cookbook eval start and complete.
+
+      # Called when library file loading starts
+      def library_load_start(file_count)
+      end
+
+      # Called when library file has been loaded
+      def library_file_loaded(path)
+      end
+
+      # Called when a library file has an error on load.
+      def library_file_load_failed(path, exception)
+      end
+
+      # Called when library file loading has finished
+      def library_load_complete
+      end
+
+      # Called when LWRP loading starts
+      def lwrp_load_start(lwrp_file_count)
+      end
+
+      # Called after a LWR or LWP has been loaded
+      def lwrp_file_loaded(path)
+      end
+
+      # Called after a LWR or LWP file errors on load
+      def lwrp_file_load_failed(path, exception)
+      end
+
+      # Called when LWRPs are finished loading
+      def lwrp_load_complete
+      end
+
+      # Called before attribute files are loaded
+      def attribute_load_start(attribute_file_count)
+      end
+
+      # Called after the attribute file is loaded
+      def attribute_file_loaded(path)
+      end
+
+      # Called when an attribute file fails to load.
+      def attribute_file_load_failed(path, exception)
+      end
+
+      # Called when attribute file loading is finished
+      def attribute_load_complete
+      end
+
+      # Called before resource definitions are loaded
+      def definition_load_start(definition_file_count)
+      end
+
+      # Called when a resource definition has been loaded
+      def definition_file_loaded(path)
+      end
+
+      # Called when a resource definition file fails to load
+      def definition_file_load_failed(path, exception)
+      end
+
+      # Called when resource defintions are done loading
+      def definition_load_complete
+      end
+
+      # Called before recipes are loaded
+      def recipe_load_start(recipe_count)
+      end
+
+      # Called after the recipe has been loaded
+      def recipe_file_loaded(path)
+      end
+
+      # Called after a recipe file fails to load
+      def recipe_file_load_failed(path, exception)
+      end
+
+      # Called when a recipe cannot be resolved
+      def recipe_not_found(exception)
+      end
+
+      # Called when recipes have been loaded.
+      def recipe_load_complete
+      end
+
+      # Called before convergence starts
+      def converge_start(run_context)
+      end
+
+      # Called when the converge phase is finished.
+      def converge_complete
+      end
+
+      # TODO: need events for notification resolve?
+      # def notifications_resolved
+      # end
+
+      # Called before action is executed on a resource.
+      def resource_action_start(resource, action, notification_type=nil, notifier=nil)
+      end
+
+      # Called when a resource fails, but will retry.
+      def resource_failed_retriable(resource, action, retry_count, exception)
+      end
+
+      # Called when a resource fails and will not be retried.
+      def resource_failed(resource, action, exception)
+      end
+
+      # Called when a resource action has been skipped b/c of a conditional
+      def resource_skipped(resource, action, conditional)
+      end
+
+      # Called when a resource action has been completed
+      def resource_completed(resource)
+      end
+
+      # Called after #load_current_resource has run.
+      def resource_current_state_loaded(resource, action, current_resource)
+      end
+
+      # Called when resource current state load is skipped due to the provider
+      # not supporting whyrun mode.
+      def resource_current_state_load_bypassed(resource, action, current_resource)
+      end
+
+      # Called when evaluating a resource that does not support whyrun in whyrun mode
+      def resource_bypassed(resource, action, current_resource)
+      end
+
+      # Called when a resource has no converge actions, e.g., it was already correct.
+      def resource_up_to_date(resource, action)
+      end
+
+      # Called when a change has been made to a resource. May be called multiple
+      # times per resource, e.g., a file may have its content updated, and then
+      # its permissions updated.
+      def resource_update_applied(resource, action, update)
+      end
+
+      # Called after a resource has been completely converged, but only if
+      # modifications were made.
+      def resource_updated(resource, action)
+      end
+
+      # Called before handlers run
+      def handlers_start(handler_count)
+      end
+
+      # Called after an individual handler has run
+      def handler_executed(handler)
+      end
+
+      # Called after all handlers have executed
+      def handlers_completed
+      end
+
+      # Called when an assertion declared by a provider fails
+      def provider_requirement_failed(action, resource, exception, message)
+      end
+
+      # Called when a provider makes an assumption after a failed assertion
+      # in whyrun mode, in order to allow execution to continue
+      def whyrun_assumption(action, resource, message) 
+      end
+
+      ## TODO: deprecation warning. this way we can queue them up and present
+      #  them all at once.
+
+      # An uncategorized message. This supports the case that a user needs to
+      # pass output that doesn't fit into one of the callbacks above. Note that
+      # there's no semantic information about the content or importance of the
+      # message. That means that if you're using this too often, you should add a
+      # callback for it.
+      def msg(message)
+      end
+
+    end
+  end
+end

data/lib/chef/event_dispatch/dispatcher.rb

@@ -0,0 +1,42 @@
+require 'chef/event_dispatch/base'
+
+class Chef
+  module EventDispatch
+
+    # == EventDispatch::Dispatcher
+    # The Dispatcher handles receiving event data from the sources
+    # (Chef::Client, Resources and Providers, etc.) and publishing the data to
+    # the registered subscribers.
+    class Dispatcher < Base
+
+      def initialize(*subscribers)
+        @subscribers = subscribers
+      end
+
+      # Add a new subscriber to the list of registered subscribers
+      def register(subscriber)
+        @subscribers << subscriber
+      end
+
+      ####
+      # All messages are unconditionally forwarded to all subscribers, so just
+      # define the forwarding in one go:
+      #
+
+      # Define a method that will be forwarded to all 
+      def self.def_forwarding_method(method_name)
+        class_eval(<<-END_OF_METHOD, __FILE__, __LINE__)
+          def #{method_name}(*args)
+            @subscribers.each {|s| s.#{method_name}(*args)}
+          end
+        END_OF_METHOD
+      end
+
+      (Base.instance_methods - Object.instance_methods).each do |method_name|
+        def_forwarding_method(method_name)
+      end
+
+    end
+  end
+end
+

data/lib/chef/exceptions.rb

@@ -0,0 +1,192 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 2008-2010 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
+  # == Chef::Exceptions
+  # Chef's custom exceptions are all contained within the Chef::Exceptions
+  # namespace.
+  class Exceptions
+    class Application < RuntimeError; end
+    class Cron < RuntimeError; end
+    class Env < RuntimeError; end
+    class Exec < RuntimeError; end
+    class ErlCall < RuntimeError; end
+    class FileNotFound < RuntimeError; end
+    class Package < RuntimeError; end
+    class Service < RuntimeError; end
+    class Route < RuntimeError; end
+    class SearchIndex < RuntimeError; end
+    class Override < RuntimeError; end
+    class UnsupportedAction < RuntimeError; end
+    class MissingLibrary < RuntimeError; end
+    class CannotDetermineNodeName < RuntimeError; end
+    class User < RuntimeError; end
+    class Group < RuntimeError; end
+    class Link < RuntimeError; end
+    class Mount < RuntimeError; end
+    class CouchDBNotFound < RuntimeError; end
+    class PrivateKeyMissing < RuntimeError; end
+    class CannotWritePrivateKey < RuntimeError; end
+    class RoleNotFound < RuntimeError; end
+    class ValidationFailed < ArgumentError; end
+    class InvalidPrivateKey < ArgumentError; end
+    class ConfigurationError < ArgumentError; end
+    class RedirectLimitExceeded < RuntimeError; end
+    class AmbiguousRunlistSpecification < ArgumentError; end
+    class CookbookFrozen < ArgumentError; end
+    class CookbookNotFound < RuntimeError; end
+    # Cookbook loader used to raise an argument error when cookbook not found.
+    # for back compat, need to raise an error that inherits from ArgumentError
+    class CookbookNotFoundInRepo < ArgumentError; end
+    class RecipeNotFound < ArgumentError; end
+    class AttributeNotFound < RuntimeError; end
+    class InvalidCommandOption < RuntimeError; end
+    class CommandTimeout < RuntimeError; end
+    class RequestedUIDUnavailable < RuntimeError; end
+    class InvalidHomeDirectory < ArgumentError; end
+    class DsclCommandFailed < RuntimeError; end
+    class UserIDNotFound < ArgumentError; end
+    class GroupIDNotFound < ArgumentError; end
+    class InvalidResourceReference < RuntimeError; end
+    class ResourceNotFound < RuntimeError; end
+    class InvalidResourceSpecification < ArgumentError; end
+    class SolrConnectionError < RuntimeError; end
+    class IllegalChecksumRevert < RuntimeError; end
+    class CookbookVersionNameMismatch < ArgumentError; end
+    class MissingParentDirectory < RuntimeError; end
+    class UnresolvableGitReference < RuntimeError; end
+    class InvalidRemoteGitReference < RuntimeError; end
+    class InvalidEnvironmentRunListSpecification < ArgumentError; end
+    class InvalidDataBagItemID < ArgumentError; end
+    class InvalidDataBagName < ArgumentError; end
+    class EnclosingDirectoryDoesNotExist < ArgumentError; end
+    # Errors originating from calls to the Win32 API
+    class Win32APIError < RuntimeError; end
+    # Thrown when Win32 API layer binds to non-existent Win32 function.  Occurs
+    # when older versions of Windows don't support newer Win32 API functions.
+    class Win32APIFunctionNotImplemented < NotImplementedError; end
+
+    class ObsoleteDependencySyntax < ArgumentError; end
+    class InvalidDataBagPath < ArgumentError; end
+
+    # A different version of a cookbook was added to a
+    # VersionedRecipeList than the one already there.
+    class CookbookVersionConflict < ArgumentError ; end
+
+    # does not follow X.Y.Z format. ArgumentError?
+    class InvalidCookbookVersion < ArgumentError; end
+
+    # version constraint should be a string or array, or it doesn't
+    # match OP VERSION. ArgumentError?
+    class InvalidVersionConstraint < ArgumentError; end
+
+    # File operation attempted but no permissions to perform it
+    class InsufficientPermissions < RuntimeError; end
+   
+    # Ifconfig failed
+    class Ifconfig < RuntimeError; end
+
+    # Backcompat with Chef::ShellOut code:
+    require 'mixlib/shellout/exceptions'
+    class ShellCommandFailed < Mixlib::ShellOut::ShellCommandFailed; end
+
+    class MissingRole < RuntimeError
+      NULL = Object.new
+
+      attr_reader :expansion
+
+      def initialize(message_or_expansion=NULL)
+        @expansion = nil
+        case message_or_expansion
+        when NULL
+          super()
+        when String
+          super
+        when RunList::RunListExpansion
+          @expansion = message_or_expansion
+          missing_roles = @expansion.errors.join(', ')
+          super("The expanded run list includes nonexistent roles: #{missing_roles}")
+        end
+      end
+
+
+    end
+
+    class CookbookVersionSelection
+
+      # Compound exception: In run_list expansion and resolution,
+      # run_list items referred to cookbooks that don't exist and/or
+      # have no versions available.
+      class InvalidRunListItems < StandardError
+        attr_reader :non_existent_cookbooks
+        attr_reader :cookbooks_with_no_matching_versions
+
+        def initialize(message, non_existent_cookbooks, cookbooks_with_no_matching_versions)
+          super(message)
+
+          @non_existent_cookbooks = non_existent_cookbooks
+          @cookbooks_with_no_matching_versions = cookbooks_with_no_matching_versions
+        end
+
+        def to_json(*a)
+          result = {
+            "message" => message,
+            "non_existent_cookbooks" => non_existent_cookbooks,
+            "cookbooks_with_no_versions" => cookbooks_with_no_matching_versions
+          }
+          result.to_json(*a)
+        end
+      end
+
+      # In run_list expansion and resolution, a constraint was
+      # unsatisfiable.
+      #
+      # This exception may not be the complete error report. If you
+      # resolve the misconfiguration represented by this exception and
+      # re-solve, you may get another exception
+      class UnsatisfiableRunListItem < StandardError
+        attr_reader :run_list_item
+        attr_reader :non_existent_cookbooks, :most_constrained_cookbooks
+
+        # most_constrained_cookbooks: if I were to remove constraints
+        # regarding these cookbooks, I would get a solution or move on
+        # to the next error (deeper in the graph). An item in this list
+        # may be unsatisfiable, but when resolved may also reveal
+        # further unsatisfiable constraints; this condition would not be
+        # reported.
+        def initialize(message, run_list_item, non_existent_cookbooks, most_constrained_cookbooks)
+          super(message)
+
+          @run_list_item = run_list_item
+          @non_existent_cookbooks = non_existent_cookbooks
+          @most_constrained_cookbooks = most_constrained_cookbooks
+        end
+
+        def to_json(*a)
+          result = {
+            "message" => message,
+            "unsatisfiable_run_list_item" => run_list_item,
+            "non_existent_cookbooks" => non_existent_cookbooks,
+            "most_constrained_cookbooks" => most_constrained_cookbooks
+          }
+          result.to_json(*a)
+        end
+      end
+    end
+  end
+end