chef 0.7.10

data/lib/chef/mixin/create_path.rb

@@ -0,0 +1,56 @@
+#
+# 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 CreatePath
+      
+      # Creates a given path, including all directories that lead up to it.
+      # Like mkdir_p, but without the leaking.
+      #
+      # === Parameters
+      # file_path<String, Array>:: A string that represents the path to create, 
+      #   or an Array with the path-parts.
+      #
+      # === Returns
+      # The created file_path.
+      def create_path(file_path)
+        unless file_path.kind_of?(String) || file_path.kind_of?(Array)
+          raise ArgumentError, "file_path must be a string or an array!" 
+        end
+        
+        if file_path.kind_of?(String)
+          file_path = File.expand_path(file_path).split(File::SEPARATOR)
+          file_path.shift if file_path[0] = ''
+          unless file_path[0].match("^#{File::SEPARATOR}")
+            file_path[0] = "#{File::SEPARATOR}#{file_path[0]}"
+          end
+        end
+                
+        file_path.each_index do |i|
+          create_path = File.join(file_path[0, i + 1])
+          unless File.directory?(create_path)
+            Chef::Log.debug("Creating directory #{create_path}")
+            Dir.mkdir(create_path)
+          end 
+        end
+        File.expand_path(File.join(file_path))
+      end
+  
+    end
+  end
+end

data/lib/chef/mixin/deep_merge.rb

@@ -0,0 +1,36 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 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.
+
+class Chef
+  module Mixin
+    class DeepMerge
+      def self.merge(first, second)
+        first = Mash.new(first).to_hash unless second.kind_of?(Mash)
+        first = first.to_hash
+        second = Mash.new(second).to_hash unless second.kind_of?(Mash)
+        second = second.to_hash
+        # Originally From: http://www.ruby-forum.com/topic/142809
+        # Author: Stefan Rusterholz
+        merger = proc do |key,v1,v2| 
+            v1.respond_to?(:keys) && v2.respond_to?(:keys) ? v1.merge(v2, &merger) : v2 
+          end
+
+        Mash.new(first.merge(second, &merger))
+      end
+    end
+  end
+end

data/lib/chef/mixin/find_preferred_file.rb

@@ -0,0 +1,99 @@
+#
+# 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 'chef/cookbook_loader'
+
+class Chef
+  module Mixin
+    module FindPreferredFile
+
+      def load_cookbook_files(cookbook_id, file_type)
+        unless file_type == :remote_file || file_type == :template
+          raise ArgumentError, "You must supply :remote_file or :template as the file_type"
+        end
+        
+        cl = Chef::CookbookLoader.new
+        cookbook = cl[cookbook_id]
+        raise NotFound unless cookbook
+
+        files = Hash.new
+        
+        cookbook_method = nil
+        
+        case file_type
+        when :remote_file
+          cookbook_method = :remote_files
+        when :template
+          cookbook_method = :template_files
+        end
+                
+        cookbook.send(cookbook_method).each do |rf|
+          full = File.expand_path(rf)
+          name = File.basename(full)
+          case file_type
+          when :remote_file
+            rf =~ /^.+#{cookbook_id}[\\|\/]files[\\|\/](.+?)[\\|\/]#{name}/
+          when :template
+            rf =~ /^.+#{cookbook_id}[\\|\/]templates[\\|\/](.+?)[\\|\/]#{name}/
+          end
+          singlecopy = $1
+          files[full] = {
+            :name => name,
+            :singlecopy => singlecopy,
+            :file => full,
+          }
+        end
+        Chef::Log.debug("Preferred #{file_type} list: #{files.inspect}")
+        
+        files
+      end
+
+      def find_preferred_file(cookbook_id, file_type, file_name, fqdn, platform, version)
+        file_list = load_cookbook_files(cookbook_id, file_type)
+        
+        preferences = [
+          File.join("host-#{fqdn}", "#{file_name}"),
+          File.join("#{platform}-#{version}", "#{file_name}"),
+          File.join("#{platform}", "#{file_name}"),
+          File.join("default", "#{file_name}")
+        ]
+        to_send = nil
+        
+        preferences.each do |pref|
+          Chef::Log.debug("Looking for #{pref}")
+          file_list.each_key do |file|
+            Chef::Log.debug("Checking for #{pref} #{file} ")
+            if file =~ /#{pref}$/
+              Chef::Log.debug("Matched #{pref} for #{file}!")
+              to_send = file
+              break
+            end
+          end
+          break if to_send
+        end
+        
+        unless to_send
+          raise Chef::Exceptions::FileNotFound, "Cannot find a preferred file for #{file_name}!"
+        end
+        
+        to_send
+      end
+      
+    end
+  end
+end

data/lib/chef/mixin/from_file.rb

@@ -0,0 +1,36 @@
+#
+# 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 FromFile
+    
+      # Loads a given ruby file, and runs instance_eval against it in the context of the current 
+      # object.  
+      #
+      # Raises an IOError if the file cannot be found, or is not readable.
+      def from_file(filename)
+        if File.exists?(filename) && File.readable?(filename)
+          self.instance_eval(IO.read(filename), filename, 1)
+        else
+          raise IOError, "Cannot open or read #{filename}!"
+        end
+      end
+    end
+  end
+end

data/lib/chef/mixin/generate_url.rb

@@ -0,0 +1,48 @@
+#
+# 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 'chef/platform'
+
+class Chef
+  module Mixin
+    module GenerateURL
+    
+      def generate_cookbook_url(url, cookbook, type, node, args=nil)
+        new_url = nil
+        if url =~ /^(http|https):\/\//
+          new_url = url
+        else
+          new_url = "cookbooks/#{cookbook}/#{type}?"
+          new_url += "id=#{url}"
+          platform, version = Chef::Platform.find_platform_and_version(node)
+          if type == "files" || type == "templates"
+            new_url += "&platform=#{platform}&version=#{version}&fqdn=#{node[:fqdn]}&node_name=#{node.name}"
+          end
+          if args
+            args.each do |key, value|
+              new_url += "&#{key}=#{value}"
+            end
+          end
+        end
+
+        return new_url
+      end
+      
+    end
+  end
+end

data/lib/chef/mixin/language.rb

@@ -0,0 +1,79 @@
+#
+# 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
+
+      # 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)
+        result = nil
+        
+        platform_hash.each_pair do |key, value|
+          if key.is_a?(Array)
+            key.each { |array_key| platform_hash[array_key] = value }
+            platform_hash.delete(key)
+          end
+        end
+        if platform_hash.has_key?(@node[:platform])
+          if platform_hash[@node[:platform]].has_key?(@node[:platform_version])
+            result = platform_hash[@node[:platform]][@node[:platform_version]]
+          elsif platform_hash[@node[:platform]].has_key?("default")
+            result = platform_hash[@node[:platform]]["default"]
+          end
+        end
+  
+        unless result
+          if platform_hash.has_key?("default")
+            result = platform_hash["default"]
+          end
+        end  
+  
+        result
+      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/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
+