omnijack 0.1.0

data/vendor/chef/lib/chef/exceptions.rb

@@ -0,0 +1,353 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Author:: Kyle Goodwin (<kgoodwin@primerevenue.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
+      def initialize
+        super "Unable to determine node name: configure node_name or configure the system's hostname and fqdn"
+      end
+    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 DuplicateRole < 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 MissingCookbookDependency < StandardError; end # CHEF-5120
+    class InvalidCommandOption < RuntimeError; end
+    class CommandTimeout < RuntimeError; end
+    class RequestedUIDUnavailable < RuntimeError; end
+    class InvalidHomeDirectory < ArgumentError; end
+    class DsclCommandFailed < RuntimeError; end
+    class PlistUtilCommandFailed < RuntimeError; end
+    class UserIDNotFound < ArgumentError; end
+    class GroupIDNotFound < ArgumentError; end
+    class ConflictingMembersInGroup < ArgumentError; end
+    class InvalidResourceReference < RuntimeError; end
+    class ResourceNotFound < RuntimeError; end
+
+    # Can't find a Resource of this type that is valid on this platform.
+    class NoSuchResourceType < NameError; 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
+    # Attempting to access a 64-bit only resource on a 32-bit Windows system
+    class Win32ArchitectureIncorrect < RuntimeError; end
+    class ObsoleteDependencySyntax < ArgumentError; end
+    class InvalidDataBagPath < ArgumentError; end
+    class DuplicateDataBagItem < RuntimeError; 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 InvalidPlatformVersion < ArgumentError; end
+    class InvalidCookbookVersion < ArgumentError; end
+
+    # version constraint should be a string or array, or it doesn't
+    # match OP VERSION. ArgumentError?
+    class InvalidVersionConstraint < ArgumentError; end
+
+    # Version constraints are not allowed in chef-solo
+    class IllegalVersionConstraint < NotImplementedError; end
+
+    class MetadataNotValid < StandardError; 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 < Win32ArchitectureIncorrect; 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 InvalidEnvironmentPath < ArgumentError; end
+    class EnvironmentNotFound < RuntimeError; end
+
+    # File-like resource found a non-file (socket, pipe, directory, etc) at its destination
+    class FileTypeMismatch < RuntimeError; end
+
+    # File (or descendent) resource configured to manage symlink source, but
+    # the symlink that is there either loops or points to a nonexistent file
+    class InvalidSymlink < RuntimeError; end
+
+    class ChildConvergeError < RuntimeError; 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
+          }
+          Chef::JSONCompat.to_json(result, *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
+          }
+          Chef::JSONCompat.to_json(result, *a)
+        end
+      end
+
+    end # CookbookVersionSelection
+
+    # When the server sends a redirect, RFC 2616 states a user-agent should
+    # not follow it with a method other than GET or HEAD, unless a specific
+    # action is taken by the user. A redirect received as response to a
+    # non-GET and non-HEAD request will thus raise an InvalidRedirect.
+    class InvalidRedirect < StandardError; end
+
+    # Raised when the content length of a download does not match the content
+    # length declared in the http response.
+    class ContentLengthMismatch < RuntimeError
+      def initialize(response_length, content_length)
+        super "Response body length #{response_length} does not match HTTP Content-Length header #{content_length}."
+      end
+    end
+
+    class UnsupportedPlatform < RuntimeError
+      def initialize(platform)
+        super "This functionality is not supported on platform #{platform}."
+      end
+    end
+
+    # Raised when Chef::Config[:run_lock_timeout] is set and some other client run fails
+    # to release the run lock becure Chef::Config[:run_lock_timeout] seconds pass.
+    class RunLockTimeout < RuntimeError
+      def initialize(duration, blocking_pid)
+        super "Unable to acquire lock. Waited #{duration} seconds for #{blocking_pid} to release."
+      end
+    end
+
+    class ChecksumMismatch < RuntimeError
+      def initialize(res_cksum, cont_cksum)
+        super "Checksum on resource (#{res_cksum}) does not match checksum on content (#{cont_cksum})"
+      end
+    end
+
+    class BadProxyURI < RuntimeError; end
+
+    # Raised by Chef::JSONCompat
+    class JSON
+      class EncodeError < RuntimeError; end
+      class ParseError < RuntimeError; end
+    end
+
+    class InvalidSearchQuery < ArgumentError; end
+  end
+end

data/vendor/chef/lib/chef/mixin/params_validate.rb

@@ -0,0 +1,242 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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
+  class DelayedEvaluator < Proc
+  end
+  module Mixin
+    module ParamsValidate
+
+      # Takes a hash of options, along with a map to validate them.  Returns the original
+      # options hash, plus any changes that might have been made (through things like setting
+      # default values in the validation map)
+      #
+      # For example:
+      #
+      #   validate({ :one => "neat" }, { :one => { :kind_of => String }})
+      #
+      # Would raise an exception if the value of :one above is not a kind_of? string.  Valid
+      # map options are:
+      #
+      # :default:: Sets the default value for this parameter.
+      # :callbacks:: Takes a hash of Procs, which should return true if the argument is valid.
+      #              The key will be inserted into the error message if the Proc does not return true:
+      #                 "Option #{key}'s value #{value} #{message}!"
+      # :kind_of:: Ensure that the value is a kind_of?(Whatever).  If passed an array, it will ensure
+      #            that the value is one of those types.
+      # :respond_to:: Ensure that the value has a given method.  Takes one method name or an array of
+      #               method names.
+      # :required:: Raise an exception if this parameter is missing. Valid values are true or false,
+      #             by default, options are not required.
+      # :regex:: Match the value of the paramater against a regular expression.
+      # :equal_to:: Match the value of the paramater with ==.  An array means it can be equal to any
+      #             of the values.
+      def validate(opts, map)
+        #--
+        # validate works by taking the keys in the validation map, assuming it's a hash, and
+        # looking for _pv_:symbol as methods.  Assuming it find them, it calls the right
+        # one.
+        #++
+        raise ArgumentError, "Options must be a hash" unless opts.kind_of?(Hash)
+        raise ArgumentError, "Validation Map must be a hash" unless map.kind_of?(Hash)
+
+        map.each do |key, validation|
+          unless key.kind_of?(Symbol) || key.kind_of?(String)
+            raise ArgumentError, "Validation map keys must be symbols or strings!"
+          end
+          case validation
+          when true
+            _pv_required(opts, key)
+          when false
+            true
+          when Hash
+            validation.each do |check, carg|
+              check_method = "_pv_#{check.to_s}"
+              if self.respond_to?(check_method, true)
+                self.send(check_method, opts, key, carg)
+              else
+                raise ArgumentError, "Validation map has unknown check: #{check}"
+              end
+            end
+          end
+        end
+        opts
+      end
+
+      def lazy(&block)
+        DelayedEvaluator.new(&block)
+      end
+
+      def set_or_return(symbol, arg, validation)
+        iv_symbol = "@#{symbol.to_s}".to_sym
+        if arg == nil && self.instance_variable_defined?(iv_symbol) == true
+          ivar = self.instance_variable_get(iv_symbol)
+          if(ivar.is_a?(DelayedEvaluator))
+            validate({ symbol => ivar.call }, { symbol => validation })[symbol]
+          else
+            ivar
+          end
+        else
+          if(arg.is_a?(DelayedEvaluator))
+            val = arg
+          else
+            val = validate({ symbol => arg }, { symbol => validation })[symbol]
+
+            # Handle the case where the "default" was a DelayedEvaluator. In
+            # this case, the block yields an optional parameter of +self+,
+            # which is the equivalent of "new_resource"
+            if val.is_a?(DelayedEvaluator)
+              val = val.call(self)
+            end
+          end
+          self.instance_variable_set(iv_symbol, val)
+        end
+      end
+
+      private
+
+        # Return the value of a parameter, or nil if it doesn't exist.
+        def _pv_opts_lookup(opts, key)
+          if opts.has_key?(key.to_s)
+            opts[key.to_s]
+          elsif opts.has_key?(key.to_sym)
+            opts[key.to_sym]
+          else
+            nil
+          end
+        end
+
+        # Raise an exception if the parameter is not found.
+        def _pv_required(opts, key, is_required=true)
+          if is_required
+            if (opts.has_key?(key.to_s) && !opts[key.to_s].nil?) ||
+                (opts.has_key?(key.to_sym) && !opts[key.to_sym].nil?)
+              true
+            else
+              raise Exceptions::ValidationFailed, "Required argument #{key} is missing!"
+            end
+          end
+        end
+
+        def _pv_equal_to(opts, key, to_be)
+          value = _pv_opts_lookup(opts, key)
+          unless value.nil?
+            passes = false
+            Array(to_be).each do |tb|
+              passes = true if value == tb
+            end
+            unless passes
+              raise Exceptions::ValidationFailed, "Option #{key} must be equal to one of: #{to_be.join(", ")}!  You passed #{value.inspect}."
+            end
+          end
+        end
+
+        # Raise an exception if the parameter is not a kind_of?(to_be)
+        def _pv_kind_of(opts, key, to_be)
+          value = _pv_opts_lookup(opts, key)
+          unless value.nil?
+            passes = false
+            Array(to_be).each do |tb|
+              passes = true if value.kind_of?(tb)
+            end
+            unless passes
+              raise Exceptions::ValidationFailed, "Option #{key} must be a kind of #{to_be}!  You passed #{value.inspect}."
+            end
+          end
+        end
+
+        # Raise an exception if the parameter does not respond to a given set of methods.
+        def _pv_respond_to(opts, key, method_name_list)
+          value = _pv_opts_lookup(opts, key)
+          unless value.nil?
+            Array(method_name_list).each do |method_name|
+              unless value.respond_to?(method_name)
+                raise Exceptions::ValidationFailed, "Option #{key} must have a #{method_name} method!"
+              end
+            end
+          end
+        end
+
+        # Assert that parameter returns false when passed a predicate method.
+        # For example, :cannot_be => :blank will raise a Exceptions::ValidationFailed
+        # error value.blank? returns a 'truthy' (not nil or false) value.
+        #
+        # Note, this will *PASS* if the object doesn't respond to the method.
+        # So, to make sure a value is not nil and not blank, you need to do
+        # both :cannot_be => :blank *and* :cannot_be => :nil (or :required => true)
+        def _pv_cannot_be(opts, key, predicate_method_base_name)
+          value = _pv_opts_lookup(opts, key)
+          predicate_method = (predicate_method_base_name.to_s + "?").to_sym
+
+          if value.respond_to?(predicate_method)
+            if value.send(predicate_method)
+              raise Exceptions::ValidationFailed, "Option #{key} cannot be #{predicate_method_base_name}"
+            end
+          end
+        end
+
+        # Assign a default value to a parameter.
+        def _pv_default(opts, key, default_value)
+          value = _pv_opts_lookup(opts, key)
+          if value == nil
+            opts[key] = default_value
+          end
+        end
+
+        # Check a parameter against a regular expression.
+        def _pv_regex(opts, key, regex)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            passes = false
+            [ regex ].flatten.each do |r|
+              if value != nil
+                if r.match(value.to_s)
+                  passes = true
+                end
+              end
+            end
+            unless passes
+              raise Exceptions::ValidationFailed, "Option #{key}'s value #{value} does not match regular expression #{regex.inspect}"
+            end
+          end
+        end
+
+        # Check a parameter against a hash of proc's.
+        def _pv_callbacks(opts, key, callbacks)
+          raise ArgumentError, "Callback list must be a hash!" unless callbacks.kind_of?(Hash)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            callbacks.each do |message, zeproc|
+              if zeproc.call(value) != true
+                raise Exceptions::ValidationFailed, "Option #{key}'s value #{value} #{message}!"
+              end
+            end
+          end
+        end
+
+        # Allow a parameter to default to @name
+        def _pv_name_attribute(opts, key, is_name_attribute=true)
+          if is_name_attribute
+            if opts[key] == nil
+              opts[key] = self.instance_variable_get("@name")
+            end
+          end
+        end
+    end
+  end
+end
+