microwave 11.400.3 → 11.400.4

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,275 @@
+#
+# 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
+
+    # Backcompat with Chef::ShellOut code:
+    require 'mixlib/shellout/exceptions'
+
+    def self.const_missing(const_name)
+      if const_name == :ShellCommandFailed
+        Chef::Log.warn("Chef::Exceptions::ShellCommandFailed is deprecated, use Mixlib::ShellOut::ShellCommandFailed")
+        called_from = caller[0..3].inject("Called from:\n") {|msg, trace_line| msg << "  #{trace_line}\n" }
+        Chef::Log.warn(called_from)
+        Mixlib::ShellOut::ShellCommandFailed
+      else
+        super
+      end
+    end
+
+    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 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
+    # Attempting to run windows code on a not-windows node
+    class Win32NotWindows < RuntimeError; end
+    class WindowsNotAdmin < RuntimeError; 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
+
+    # Invalid "source" parameter to a remote_file resource
+    class InvalidRemoteFileURI < ArgumentError; end
+
+    # Node::Attribute computes the merged version of of attributes
+    # and makes it read-only. Attempting to modify a read-only
+    # attribute will cause this error.
+    class ImmutableAttributeModification < NoMethodError; end
+
+    # Merged node attributes are invalidated when the component
+    # attributes are updated. Attempting to read from a stale copy
+    # of merged attributes will trigger this error.
+    class StaleAttributeRead < StandardError; end
+
+    #Registry Helper throws the following errors
+    class Win32RegArchitectureIncorrect < RuntimeError; end
+    class Win32RegHiveMissing < ArgumentError; end
+    class Win32RegKeyMissing < RuntimeError; end
+    class Win32RegValueMissing < RuntimeError; end
+    class Win32RegDataMissing < RuntimeError; end
+    class Win32RegValueExists < RuntimeError; end
+    class Win32RegNoRecursive < ArgumentError; end
+    class Win32RegTypeDoesNotExist < ArgumentError; end
+    class Win32RegBadType < ArgumentError; end
+    class Win32RegBadValueSize < ArgumentError; end
+    class Win32RegTypesMismatch < ArgumentError; 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
+    # Exception class for collecting multiple failures. Used when running
+    # delayed notifications so that chef can process each delayed
+    # notification even if chef client or other notifications fail.
+    class MultipleFailures < StandardError
+      def initialize(*args)
+        super
+        @all_failures = []
+      end
+
+      def message
+        base = "Multiple failures occurred:\n"
+        @all_failures.inject(base) do |message, (location, error)|
+          message << "* #{error.class} occurred in #{location}: #{error.message}\n"
+        end
+      end
+
+      def client_run_failure(exception)
+        set_backtrace(exception.backtrace)
+        @all_failures << [ "chef run", exception ]
+      end
+
+      def notification_failure(exception)
+        @all_failures << [ "delayed notification", exception ]
+      end
+
+      def raise!
+        unless empty?
+          raise self.for_raise
+        end
+      end
+
+      def empty?
+        @all_failures.empty?
+      end
+
+      def for_raise
+        if @all_failures.size == 1
+          @all_failures[0][1]
+        else
+          self
+        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 # CookbookVersionSelection
+
+  end
+end

data/lib/chef/file_access_control.rb

@@ -0,0 +1,75 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 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.
+#
+
+require 'chef/log'
+
+class Chef
+
+  # == Chef::FileAccessControl
+  # FileAccessControl objects set the owner, group and mode of +file+ to
+  # the values specified by a value object, usually a Chef::Resource.
+  class FileAccessControl
+
+    if RUBY_PLATFORM =~ /mswin|mingw|windows/
+      require 'chef/file_access_control/windows'
+      include FileAccessControl::Windows
+    else
+      require 'chef/file_access_control/unix'
+      include FileAccessControl::Unix
+    end
+
+    attr_reader :current_resource
+    attr_reader :resource
+    attr_reader :provider
+    attr_reader :file
+
+    # FileAccessControl objects set the owner, group and mode of +file+ to
+    # the values specified by +resource+. +file+ is completely independent
+    # of any file or path attribute on +resource+, so it is possible to set
+    # access control settings on a tempfile (for example).
+    # === Arguments:
+    # resource:   probably a Chef::Resource::File object (or subclass), but
+    #             this is not required. Must respond to +owner+, +group+,
+    #             and +mode+
+    # file:       The file whose access control settings you wish to modify,
+    #             given as a String.
+    #
+    # TODO requiring current_resource will break cookbook_file template_file
+    def initialize(current_resource, new_resource, provider)
+      @current_resource, @resource, @provider = current_resource, new_resource, provider
+      @file = @current_resource.path
+      @modified = false
+    end
+
+    def modified?
+      @modified
+    end
+
+    private
+
+    def modified
+      @modified = true
+    end
+
+    def log_string
+      @resource || @file
+    end
+
+  end
+end

data/lib/chef/file_access_control/unix.rb

@@ -0,0 +1,216 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2008-2011 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 'chef/log'
+
+class Chef
+  class FileAccessControl
+    module Unix
+      UINT = (1 << 32)
+      UID_MAX = (1 << 32) - 10
+
+      def set_all!
+        set_owner!
+        set_group!
+        set_mode!
+      end
+
+      def set_all
+        set_owner
+        set_group
+        set_mode
+      end
+
+      # TODO factor this up
+      def requires_changes?
+        should_update_mode? || should_update_owner? || should_update_group?
+      end
+
+      def describe_changes
+        changes = []
+        changes << "change mode from '#{mode_to_s(current_mode)}' to '#{mode_to_s(target_mode)}'" if should_update_mode?
+        changes << "change owner from '#{current_resource.owner}' to '#{resource.owner}'" if should_update_owner?
+        changes << "change group from '#{current_resource.group}' to '#{resource.group}'" if should_update_group?
+        changes
+      end
+
+      def target_uid
+        uid_from_resource(resource)
+      end
+
+      def current_uid
+        uid_from_resource(current_resource)
+      end
+
+      def should_update_owner?
+        !target_uid.nil? && target_uid != current_uid
+      end
+
+      def set_owner!
+        unless target_uid.nil?
+          chown(target_uid, nil, file)
+          Chef::Log.info("#{log_string} owner changed to #{target_uid}")
+          modified
+        end
+      end
+
+      def set_owner
+        set_owner! if should_update_owner?
+      end
+
+      def target_gid
+        gid_from_resource(resource)
+      end
+
+      def current_gid
+        gid_from_resource(current_resource)
+      end
+
+      def gid_from_resource(resource)
+        return nil if resource == nil or resource.group.nil?
+        if resource.group.kind_of?(String)
+          diminished_radix_complement( Etc.getgrnam(resource.group).gid )
+        elsif resource.group.kind_of?(Integer)
+          resource.group
+        else
+          Chef::Log.error("The `group` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
+          raise ArgumentError, "cannot resolve #{resource.group.inspect} to gid, group must be a string or integer"
+        end
+      rescue ArgumentError
+        provider.requirements.assert(:create, :create_if_missing, :touch) do |a|
+          a.assertion { false }
+          a.failure_message(Chef::Exceptions::GroupIDNotFound, "cannot determine group id for '#{resource.group}', does the group exist on this system?")
+          a.whyrun("Assuming group #{resource.group} would have been created")
+        end
+        return nil
+      end
+
+      def should_update_group?
+        !target_gid.nil? && target_gid != current_gid
+      end
+
+      def set_group!
+        unless target_gid.nil?
+          chown(nil, target_gid, file)
+          Chef::Log.info("#{log_string} group changed to #{target_gid}")
+          modified
+        end
+      end
+
+      def set_group
+        set_group! if should_update_group?
+      end
+
+      def mode_from_resource(res)
+        return nil if res == nil or res.mode.nil?
+        (res.mode.respond_to?(:oct) ? res.mode.oct : res.mode.to_i) & 007777
+      end
+
+      def target_mode
+        mode_from_resource(resource)
+      end
+
+      def mode_to_s(mode)
+        mode.nil? ? "" : "0#{mode.to_s(8)}"
+      end
+
+      def current_mode
+        mode_from_resource(current_resource)
+      end
+
+      def should_update_mode?
+        !target_mode.nil? && current_mode != target_mode 
+      end
+
+      def set_mode!
+        unless target_mode.nil?
+          chmod(target_mode, file)
+          Chef::Log.info("#{log_string} mode changed to #{target_mode.to_s(8)}")
+          modified
+        end
+      end
+
+      def set_mode
+        set_mode! if should_update_mode?
+      end
+
+      def stat
+        if File.symlink?(file)
+          @stat ||= File.lstat(file)
+        else
+          @stat ||= File.stat(file)
+        end
+      end
+
+      private
+
+      def chmod(mode, file)
+        if File.symlink?(file)
+          begin
+            File.lchmod(mode, file)
+          rescue NotImplementedError
+            Chef::Log.warn("#{file} mode not changed: File.lchmod is unimplemented on this OS and Ruby version")
+          end
+        else
+          File.chmod(mode, file)
+        end
+      end
+
+      def chown(uid, gid, file)
+        if ::File.symlink?(file)
+          File.lchown(uid, gid, file)
+        else
+          File.chown(uid, gid, file)
+        end
+      end
+
+      # Workaround the fact that Ruby's Etc module doesn't believe in negative
+      # uids, so negative uids show up as the diminished radix complement of
+      # a uint. For example, a uid of -2 is reported as 4294967294
+      def diminished_radix_complement(int)
+        if int > UID_MAX
+          int - UINT
+        else
+          int
+        end
+      end
+
+      def uid_from_resource(resource) 
+        return nil if resource == nil or resource.owner.nil?
+        if resource.owner.kind_of?(String)
+          diminished_radix_complement( Etc.getpwnam(resource.owner).uid )
+        elsif resource.owner.kind_of?(Integer)
+          resource.owner
+        else
+          Chef::Log.error("The `owner` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
+          raise ArgumentError, "cannot resolve #{resource.owner.inspect} to uid, owner must be a string or integer"
+        end
+      rescue ArgumentError
+        provider.requirements.assert(:create, :create_if_missing, :touch) do |a|
+          a.assertion { false }
+          a.failure_message(Chef::Exceptions::UserIDNotFound, "cannot determine user id for '#{resource.owner}', does the user exist on this system?")
+          a.whyrun("Assuming user #{resource.owner} would have been created")
+        end
+        return nil
+      end
+
+    end
+  end
+end