microwave 0.1004.1

data/lib/chef/mixin/get_source_from_package.rb

@@ -0,0 +1,42 @@
+# Author:: Lamont Granquist (<lamont@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.
+#
+
+
+#
+# mixin to make this syntax work without specifying a source:
+#
+# gem_pacakge "/tmp/foo-x.y.z.gem"
+# rpm_package "/tmp/foo-x.y-z.rpm"
+# dpkg_package "/tmp/foo-x.y.z.deb"
+#
+
+class Chef
+  module Mixin
+    module GetSourceFromPackage
+      def initialize(new_resource, run_context)
+        super
+        # if we're passed something that looks like a filesystem path, with no source, use it
+        #  - require at least one '/' in the path to avoid gem_package "foo" breaking if a file named 'foo' exists in the cwd
+        if new_resource.source.nil? && new_resource.package_name.match(/#{::File::SEPARATOR}/) && ::File.exists?(new_resource.package_name)
+          Chef::Log.debug("No package source specified, but #{new_resource.package_name} exists on the filesystem, copying to package source")
+          new_resource.source(@new_resource.package_name)
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/mixin/language.rb

@@ -0,0 +1,125 @@
+
+# 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
+  module Mixin
+    module Language
+
+      # Implementation class for determining platform dependent values
+      class PlatformDependentValue
+
+        # Create a platform dependent value object.
+        # === Arguments
+        # platform_hash (Hash) a hash of the same structure as Chef::Platform,
+        # like this:
+        #   {
+        #     :debian => {:default => 'the value for all debian'}
+        #     [:centos, :redhat, :fedora] => {:default => "value for all EL variants"}
+        #     :ubuntu => { :default => "default for ubuntu", '10.04' => "value for 10.04 only"},
+        #     :default => "the default when nothing else matches"
+        #   }
+        # * platforms can be specified as Symbols or Strings
+        # * multiple platforms can be grouped by using an Array as the key
+        # * values for platforms need to be Hashes of the form:
+        #   {platform_version => value_for_that_version}
+        # * the exception to the above is the default value, which is given as
+        #   :default => default_value
+        def initialize(platform_hash)
+          @values = {}
+          platform_hash.each { |platforms, value| set(platforms, value)}
+        end
+
+        def value_for_node(node)
+          platform, version = node[:platform].to_s, node[:platform_version].to_s
+          if @values.key?(platform) && @values[platform].key?(version)
+            @values[platform][version]
+          elsif @values.key?(platform) && @values[platform].key?("default")
+            @values[platform]["default"]
+          elsif @values.key?("default")
+            @values["default"]
+          else
+            nil
+          end
+        end
+
+        private
+
+        def set(platforms, value)
+          if platforms.to_s == 'default'
+            @values["default"] = value
+          else
+            assert_valid_platform_values!(platforms, value)
+            Array(platforms).each { |platform| @values[platform.to_s] = normalize_keys(value)}
+            value
+          end
+        end
+
+        def normalize_keys(hash)
+          hash.inject({}) do |h, key_value|
+            keys, value = *key_value
+            Array(keys).each do |key|
+              h[key.to_s] = value
+            end
+            h
+          end
+        end
+
+        def assert_valid_platform_values!(platforms, value)
+          unless value.kind_of?(Hash)
+            msg = "platform dependent values must be specified in the format :platform => {:version => value} "
+            msg << "you gave a value #{value.inspect} for platform(s) #{platforms}"
+            raise ArgumentError, msg
+          end
+        end
+      end
+
+      # Given a hash similar to the one we use for Platforms, select a value from the hash.  Supports
+      # per platform defaults, along with a single base default. Arrays may be passed as hash keys and
+      # will be expanded.
+      #
+      # === Parameters
+      # platform_hash:: A platform-style hash.
+      #
+      # === Returns
+      # value:: Whatever the most specific value of the hash is.
+      def value_for_platform(platform_hash)
+        PlatformDependentValue.new(platform_hash).value_for_node(node)
+      end
+
+      # Given a list of platforms, returns true if the current recipe is being run on a node with
+      # that platform, false otherwise.
+      #
+      # === Parameters
+      # args:: A list of platforms
+      #
+      # === Returns
+      # true:: If the current platform is in the list
+      # false:: If the current platform is not in the list
+      def platform?(*args)
+        has_platform = false
+
+        args.flatten.each do |platform|
+          has_platform = true if platform == node[:platform]
+        end
+
+        has_platform
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/language_include_attribute.rb

@@ -0,0 +1,61 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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
+  module Mixin
+    module LanguageIncludeAttribute
+
+      # Loads the attribute file specified by the short name of the
+      # file, e.g., loads specified cookbook's
+      #   "attributes/mailservers.rb"
+      # if passed
+      #   "mailservers"
+      def include_attribute(*fully_qualified_attribute_short_filenames)
+        if self.kind_of?(Chef::Node)
+          node = self
+        else
+          node = @node
+        end
+
+        fully_qualified_attribute_short_filenames.flatten.each do |fully_qualified_attribute_short_filename|
+          if node.run_state[:seen_attributes].has_key?(fully_qualified_attribute_short_filename)
+            Chef::Log.debug("I am not loading attribute file #{fully_qualified_attribute_short_filename}, because I have already seen it.")
+            next
+          end
+
+          Chef::Log.debug("Loading Attribute #{fully_qualified_attribute_short_filename}")
+          node.run_state[:seen_attributes][fully_qualified_attribute_short_filename] = true
+
+          if amatch = fully_qualified_attribute_short_filename.match(/(.+?)::(.+)/)
+            cookbook_name = amatch[1].to_sym
+            node.load_attribute_by_short_filename(amatch[2], cookbook_name)
+          else
+            cookbook_name = fully_qualified_attribute_short_filename.to_sym
+            node.load_attribute_by_short_filename("default", cookbook_name)
+          end
+        end
+        true
+      end
+
+    end
+  end
+end
+      
+

data/lib/chef/mixin/language_include_recipe.rb

@@ -0,0 +1,52 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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
+  module Mixin
+    module LanguageIncludeRecipe
+
+      def include_recipe(*recipe_names)
+        result_recipes = Array.new
+        recipe_names.flatten.each do |recipe_name|
+          if node.run_state[:seen_recipes].has_key?(recipe_name)
+            Chef::Log.debug("I am not loading #{recipe_name}, because I have already seen it.")
+            next
+          end
+
+          Chef::Log.debug("Loading Recipe #{recipe_name} via include_recipe")
+          node.run_state[:seen_recipes][recipe_name] = true
+
+          cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)
+
+          run_context = self.is_a?(Chef::RunContext) ? self : self.run_context
+          cookbook = run_context.cookbook_collection[cookbook_name]
+          result_recipes << cookbook.load_recipe(recipe_short_name, run_context)
+        end
+        result_recipes
+      end
+
+      def require_recipe(*args)
+        include_recipe(*args)
+      end
+
+    end
+  end
+end
+      

data/lib/chef/mixin/params_validate.rb

@@ -0,0 +1,225 @@
+#
+# 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
+
+  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 set_or_return(symbol, arg, validation)
+        iv_symbol = "@#{symbol.to_s}".to_sym
+        map = {
+          symbol => validation
+        }
+
+        if arg == nil && self.instance_variable_defined?(iv_symbol) == true
+          self.instance_variable_get(iv_symbol)
+        else
+          opts = validate({ symbol => arg }, { symbol => validation })
+          self.instance_variable_set(iv_symbol, opts[symbol])
+        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
+