runa-chef 0.8.0.1

data/lib/chef/mixin/language_include_attribute.rb

@@ -0,0 +1,56 @@
+#
+# 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
+
+      def include_attribute(*args)
+        if self.kind_of?(Chef::Node)
+          node = self
+        else
+          node = @node
+        end
+
+        args.flatten.each do |attrib|
+          if node.run_state[:seen_attributes].has_key?(attrib)
+            Chef::Log.debug("I am not loading attribute file #{attrib}, because I have already seen it.")
+            next
+          end
+
+          Chef::Log.debug("Loading Attribute #{attrib}")
+          node.run_state[:seen_attributes][attrib] = true
+
+          if amatch = attrib.match(/(.+?)::(.+)/)
+            cookbook = @cookbook_loader[amatch[1].to_sym]
+            cookbook.load_attribute(amatch[2], node)
+          else
+            cookbook = @cookbook_loader[amatch[1].to_sym]
+            cookbook.load_attribute("default", node)
+          end
+        end
+        true
+      end
+
+    end
+  end
+end
+      
+

data/lib/chef/mixin/language_include_recipe.rb

@@ -0,0 +1,53 @@
+#
+# 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(*args)
+        args.flatten.each do |recipe|
+          if @node.run_state[:seen_recipes].has_key?(recipe)
+            Chef::Log.debug("I am not loading #{recipe}, because I have already seen it.")
+            next
+          end        
+
+          Chef::Log.debug("Loading Recipe #{recipe} via include_recipe")
+          @node.run_state[:seen_recipes][recipe] = true
+
+          rmatch = recipe.match(/(.+?)::(.+)/)
+          if rmatch
+            cookbook = @cookbook_loader[rmatch[1]]
+            cookbook.load_recipe(rmatch[2], @node, @collection, @definitions, @cookbook_loader)
+          else
+            cookbook = @cookbook_loader[recipe]
+            cookbook.load_recipe("default", @node, @collection, @definitions, @cookbook_loader)
+          end
+        end
+      end
+
+      def require_recipe(*args)
+        include_recipe(*args)
+      end
+
+    end
+  end
+end
+      

data/lib/chef/mixin/params_validate.rb

@@ -0,0 +1,197 @@
+#
+# 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_get(iv_symbol)
+        else
+          validate({ symbol => arg }, { symbol => validation })
+          self.instance_variable_set(iv_symbol, arg)
+        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.has_key?(key.to_sym)
+              true
+            else
+              raise ArgumentError, "Required argument #{key} is missing!"
+            end
+          end
+        end
+        
+        def _pv_equal_to(opts, key, to_be)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            passes = false
+            [ to_be ].flatten.each do |tb|
+              if value == tb
+                passes = true
+              end
+            end
+            unless passes
+              raise ArgumentError, "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)
+          if value != nil
+            passes = false
+            [ to_be ].flatten.each do |tb|
+              if value.kind_of?(tb)
+                passes = true
+              end
+            end
+            unless passes
+              raise ArgumentError, "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)
+          if value != nil
+            [ method_name_list ].flatten.each do |method_name|
+              unless value.respond_to?(method_name)
+                raise ArgumentError, "Option #{key} must have a #{method_name} method!"
+              end
+            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)
+          passes = false
+          [ regex ].flatten.each do |r|
+            if value != nil
+              if r.match(value.to_s)
+                passes = true
+              end
+            end
+          end
+          unless passes
+            raise ArgumentError, "Option #{key}'s value #{value} does not match regular expression #{regex.to_s}"
+          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 ArgumentError, "Option #{key}'s value #{value} #{message}!"
+              end
+            end
+          end
+        end
+    end
+  end
+end
+

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -0,0 +1,79 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@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/recipe'
+require 'chef/resource'
+require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/language'
+
+class Chef
+  module Mixin
+    module RecipeDefinitionDSLCore
+      
+      include Chef::Mixin::ConvertToClassName
+      include Chef::Mixin::Language
+      
+      def method_missing(method_symbol, *args, &block)
+        # If we have a definition that matches, we want to use that instead.  This should
+        # let you do some really crazy over-riding of "native" types, if you really want
+        # to. 
+        if @definitions.has_key?(method_symbol)
+          # This dupes the high level object, but we still need to dup the params
+          new_def = @definitions[method_symbol].dup
+          new_def.params = new_def.params.dup
+          new_def.node = @node
+          # This sets up the parameter overrides
+          new_def.instance_eval(&block) if block
+          new_recipe = Chef::Recipe.new(@cookbook_name, @recipe_name, @node, @collection, @definitions, @cookbook_loader)
+          new_recipe.params = new_def.params
+          new_recipe.params[:name] = args[0]
+          new_recipe.instance_eval(&new_def.recipe)
+        else
+          # Otherwise, we're rocking the regular resource call route.
+          method_name = method_symbol.to_s
+          rname = convert_to_class_name(method_name)
+          
+          # If we have a resource like this one, we want to steal its state
+          resource = begin
+                       args << @collection
+                       args << @node
+                       Chef::Resource.const_get(rname).new(*args)
+                     rescue NameError => e
+                       if e.to_s =~ /Chef::Resource/
+                         raise NameError, "Cannot find #{rname} for #{method_name}\nOriginal exception: #{e.class}: #{e.message}"
+                       else
+                         raise e
+                       end
+                     end
+          resource.load_prior_resource
+          resource.cookbook_name = @cookbook_name
+          resource.recipe_name = @recipe_name
+          resource.params = @params
+          # Determine whether this resource is being created in the context of an enclosing Provider
+          resource.enclosing_provider = self.is_a?(Chef::Provider) ? self : nil
+          resource.instance_eval(&block) if block
+
+          @collection.insert(resource)
+          resource
+        end
+      end
+      
+    end
+  end
+end

data/lib/chef/mixin/template.rb

@@ -0,0 +1,94 @@
+#
+# 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.
+#
+
+require 'tempfile'
+require 'erubis'
+
+class Chef
+  module Mixin
+    module Template
+      
+      module ChefContext
+        def node
+          return @node if @node
+          raise "Could not find a value for node. If you are explicitly setting variables in a template, " +
+                "include a node variable if you plan to use it."
+        end
+      end
+      
+      ::Erubis::Context.send(:include, ChefContext)
+      
+      # Render a template with Erubis.  Takes a template as a string, and a 
+      # context hash.  
+      def render_template(template, context)
+        begin
+          eruby = Erubis::Eruby.new(template)
+          output = eruby.evaluate(context)
+        rescue Object => e
+          raise TemplateError.new(e, template, context)
+        end
+        final_tempfile = Tempfile.new("chef-rendered-template")
+        final_tempfile.print(output)
+        final_tempfile.close
+        final_tempfile
+      end
+      
+      class TemplateError < RuntimeError
+        attr_reader :original_exception, :context
+        SOURCE_CONTEXT_WINDOW = 2 unless defined? SOURCE_CONTEXT_WINDOW
+        
+        def initialize(original_exception, template, context)
+          @original_exception, @template, @context = original_exception, template, context
+        end
+        
+        def message
+          @original_exception.message
+        end
+        
+        def line_number
+          @line_number ||= $1.to_i if original_exception.backtrace.find {|line| line =~ /\(erubis\):(\d+)/ }
+        end
+        
+        def source_location
+          "on line ##{line_number}"
+        end
+        
+        def source_listing
+          @source_listing ||= begin
+            line_index = line_number - 1
+            beginning_line = line_index <= SOURCE_CONTEXT_WINDOW ? 0 : line_index - SOURCE_CONTEXT_WINDOW
+            source_size = SOURCE_CONTEXT_WINDOW * 2 + 1
+            lines = @template.split(/\n/)
+            contextual_lines = lines[beginning_line, source_size]
+            output = []
+            contextual_lines.each_with_index do |line, index|
+              line_number = (index+beginning_line+1).to_s.rjust(3)
+              output << "#{line_number}: #{line}"
+            end
+            output.join("\n")
+          end
+        end
+        
+        def to_s
+          "\n\n#{self.class} (#{message}) #{source_location}:\n\n" +
+            "#{source_listing}\n\n  #{original_exception.backtrace.join("\n  ")}\n\n"
+        end
+      end
+    end
+  end
+end