chef 0.7.10 → 0.7.12

data/lib/chef/couchdb.rb

@@ -153,12 +153,16 @@ class Chef
     end
     
     def view_uri(design, view)
-      Chef::Config[:couchdb_version] ||= @rest.run_request(:GET, URI.parse(@rest.url + "/"), false, 10, false)["version"].gsub(/-.+/,"").to_f
+      Chef::Config[:couchdb_version] ||= @rest.run_request(:GET,
+                                                           URI.parse(@rest.url + "/"),
+                                                           false,
+                                                           10,
+                                                           false)["version"].gsub(/-.+/,"").to_f
       case Chef::Config[:couchdb_version]
-      when 0.9, 0.10
-        "#{Chef::Config[:couchdb_database]}/_design/#{design}/_view/#{view}"
       when 0.8
         "#{Chef::Config[:couchdb_database]}/_view/#{design}/#{view}"
+      else
+        "#{Chef::Config[:couchdb_database]}/_design/#{design}/_view/#{view}"
       end
     end
     

data/lib/chef/mixin/command.rb

@@ -112,13 +112,22 @@ class Chef
           end
         end
         
+        status, stdout, stderr = output_of_command(args[:command], args)
+        command_output << "STDOUT: #{stdout}"
+        command_output << "STDERR: #{stderr}"
+        handle_command_failures(status, command_output, args)
+        
+        status
+      end
+      
+      module_function :run_command
+      
+      def output_of_command(command, args)
+        Chef::Log.debug("Executing #{command}")
+        stderr_string, stdout_string, status = "", "", nil
+        
         exec_processing_block = lambda do |pid, stdin, stdout, stderr|
-          Chef::Log.debug("---- Begin output of #{args[:command]} ----")
-          Chef::Log.debug("STDOUT: #{stdout.string.chomp}")
-          Chef::Log.debug("STDERR: #{stderr.string.chomp}")
-          command_output << "STDOUT: #{stdout.string.chomp}"
-          command_output << "STDERR: #{stderr.string.chomp}"
-          Chef::Log.debug("---- End output of #{args[:command]} ----")
+          stdout_string, stderr_string = stdout.string.chomp, stderr.string.chomp
         end
         
         args[:cwd] ||= Dir.tmpdir        
@@ -126,44 +135,65 @@ class Chef
           raise Chef::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory"
         end
         
-        Chef::Log.debug("Executing #{args[:command]}")
-        
-        status = nil
-        
         Dir.chdir(args[:cwd]) do
           if args[:timeout]
             begin
               Timeout.timeout(args[:timeout]) do
-                status = popen4(args[:command], args, &exec_processing_block)
+                status = popen4(command, args, &exec_processing_block)
               end
             rescue Timeout::Error => e
-              Chef::Log.error("#{args[:command]} exceeded timeout #{args[:timeout]}")
+              Chef::Log.error("#{command} exceeded timeout #{args[:timeout]}")
               raise(e)
             end
           else
-            status = popen4(args[:command], args, &exec_processing_block)
+            status = popen4(command, args, &exec_processing_block)
           end
           
-          unless args[:ignore_failure] 
-            args[:returns] ||= 0
-            if status.exitstatus != args[:returns]
-              # if the log level is not debug, through output of command when we fail
-              output = ""
-              if Chef::Log.logger.level > 0
-                output << "\n---- Begin output of #{args[:command]} ----\n"
-                output << "#{command_output}"
-                output << "---- End output of #{args[:command]} ----\n"
-              end
-              raise Chef::Exceptions::Exec, "#{args[:command]} returned #{status.exitstatus}, expected #{args[:returns]}#{output}"
+          Chef::Log.debug("---- Begin output of #{command} ----")
+          Chef::Log.debug("STDOUT: #{stdout_string}")
+          Chef::Log.debug("STDERR: #{stderr_string}")
+          Chef::Log.debug("---- End output of #{command} ----")
+          Chef::Log.debug("Ran #{command} returned #{status.exitstatus}")
+        end
+        
+        return status, stdout_string, stderr_string
+      end
+      
+      module_function :output_of_command
+      
+      def handle_command_failures(status, command_output, args={})
+        unless args[:ignore_failure] 
+          args[:returns] ||= 0
+          if status.exitstatus != args[:returns]
+            # if the log level is not debug, through output of command when we fail
+            output = ""
+            if Chef::Log.logger.level > 0
+              output << "\n---- Begin output of #{args[:command]} ----\n"
+              output << "#{command_output}"
+              output << "---- End output of #{args[:command]} ----\n"
             end
+            raise Chef::Exceptions::Exec, "#{args[:command]} returned #{status.exitstatus}, expected #{args[:returns]}#{output}"
           end
-          Chef::Log.debug("Ran #{args[:command]} returned #{status.exitstatus}")
         end
-        status
       end
       
-      module_function :run_command
+      module_function :handle_command_failures
            
+      # Call #run_command but set LC_ALL to the system's current environment so it doesn't get changed to C.
+      #
+      # === Parameters
+      # args<Hash>: A number of required and optional arguments that will be handed out to #run_command
+      #
+      # === Returns
+      # Returns the result of #run_command
+      def run_command_with_systems_locale(args={})
+        args[:environment] ||= {}
+        args[:environment]["LC_ALL"] = ENV["LC_ALL"]
+        run_command args
+      end
+
+      module_function :run_command_with_systems_locale
+
       # This is taken directly from Ara T Howard's Open4 library, and then 
       # modified to suit the needs of Chef.  Any bugs here are most likely
       # my own, and not Ara's.
@@ -189,7 +219,14 @@ class Chef
         unless args[:group].kind_of?(Integer)
           args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
         end
-        args[:environment] ||= nil
+        args[:environment] ||= {}
+
+        # Default on C locale so parsing commands output can be done
+        # independently of the node's default locale.
+        # "LC_ALL" could be set to nil, in which case we also must ignore it.
+        unless args[:environment].has_key?("LC_ALL")
+          args[:environment]["LC_ALL"] = "C"
+        end
         
         pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
 
@@ -223,10 +260,8 @@ class Chef
               Process.uid = args[:user]
             end
             
-            if args[:environment]
-              args[:environment].each do |key,value|
-                ENV[key] = value
-              end
+            args[:environment].each do |key,value|
+              ENV[key] = value
             end
 
             if args[:umask]

data/lib/chef/mixin/convert_to_class_name.rb

@@ -0,0 +1,48 @@
+#
+# 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.
+#
+
+class Chef
+  module Mixin
+    module ConvertToClassName
+
+      def convert_to_class_name(str)
+        rname = nil
+        regexp = %r{^(.+?)(_(.+))?$}
+        
+        mn = str.match(regexp)
+        if mn
+          rname = mn[1].capitalize
+
+          while mn && mn[3]
+            mn = mn[3].match(regexp)          
+            rname << mn[1].capitalize if mn
+          end
+        end
+
+        rname
+      end
+      
+      def filename_to_qualified_string(base, filename)
+        file_base = File.basename(filename, ".rb")
+        base.to_s + (file_base == 'default' ? '' : "_#{file_base}")
+      end
+      
+    end
+  end
+end

data/lib/chef/mixin/find_preferred_file.rb

@@ -72,26 +72,17 @@ class Chef
           File.join("#{platform}", "#{file_name}"),
           File.join("default", "#{file_name}")
         ]
-        to_send = nil
         
+        file_list_str = file_list.keys.join("\n")
         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
+          matcher = /^(.+#{pref})$/
+          if match = matcher.match(file_list_str)
+            return match[1]
           end
-          break if to_send
         end
         
-        unless to_send
-          raise Chef::Exceptions::FileNotFound, "Cannot find a preferred file for #{file_name}!"
-        end
-        
-        to_send
+        raise Chef::Exceptions::FileNotFound, "Cannot find a preferred file for #{file_name}!"
       end
       
     end

data/lib/chef/mixin/from_file.rb

@@ -1,5 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -31,6 +32,19 @@ class Chef
           raise IOError, "Cannot open or read #{filename}!"
         end
       end
+
+      # Loads a given ruby file, and runs class_eval against it in the context of the current 
+      # object.
+      #
+      # Raises an IOError if the file cannot be found, or is not readable.
+      def class_from_file(filename)
+        if File.exists?(filename) && File.readable?(filename)
+          self.class_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

@@ -23,6 +23,7 @@ class Chef
     module GenerateURL
     
       def generate_cookbook_url(url, cookbook, type, node, args=nil)
+        Chef::Log.debug("generating cookbook url for url=#{url}, cookbook=#{cookbook.inspect}, type=#{type}, node=#{node}")
         new_url = nil
         if url =~ /^(http|https):\/\//
           new_url = url
@@ -39,7 +40,7 @@ class Chef
             end
           end
         end
-
+        Chef::Log.debug("generated cookbook url: #{new_url}")
         return new_url
       end
       

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -0,0 +1,77 @@
+#
+# 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'
+
+class Chef
+  module Mixin
+    module RecipeDefinitionDSLCore
+      
+      include Chef::Mixin::ConvertToClassName
+      
+      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/platform.rb

@@ -93,7 +93,7 @@ class Chef
         :bash => Chef::Provider::Script,
         :csh => Chef::Provider::Script,
         :user => Chef::Provider::User::Useradd,
-        :group => Chef::Provider::Group::Groupadd,
+        :group => Chef::Provider::Group::Gpasswd,
         :http_request => Chef::Provider::HttpRequest,
         :route => Chef::Provider::Route,
         :ifconfig => Chef::Provider::Ifconfig,

data/lib/chef/provider.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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");
@@ -16,15 +17,25 @@
 # limitations under the License.
 #
 
+require 'chef/mixin/from_file'
+require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/recipe_definition_dsl_core'
+
 class Chef
   class Provider
     
+    include Chef::Mixin::RecipeDefinitionDSLCore
+    
     attr_accessor :node, :new_resource, :current_resource
     
-    def initialize(node, new_resource)
+    def initialize(node, new_resource, collection=nil, definitions={}, cookbook_loader=nil)
       @node = node
       @new_resource = new_resource
       @current_resource = nil
+      @collection = collection
+      @definitions = definitions
+      @cookbook_loader = cookbook_loader
+      @cookbook_name = @new_resource.cookbook_name
     end
     
     def load_current_resource
@@ -36,5 +47,55 @@ class Chef
       true
     end
     
+    protected
+    
+    def recipe_eval(*args, &block)
+      provider_collection, @collection = @collection, Chef::ResourceCollection.new
+      
+      instance_eval(*args, &block)
+      Chef::Runner.new(@node, @collection).converge
+      
+      @collection = provider_collection
+    end
+    
+    public
+    
+    class << self
+      include Chef::Mixin::ConvertToClassName
+      
+      def build_from_file(cookbook_name, filename)
+        pname = filename_to_qualified_string(cookbook_name, filename)
+        
+        new_provider_class = Class.new self do |cls|
+          
+          def load_current_resource
+            # silence Chef::Exceptions::Override exception
+          end
+          
+          class << cls
+            include Chef::Mixin::FromFile
+            
+            # setup DSL's shortcut methods
+            def action(name, &block)
+              define_method("action_#{name.to_s}") do
+                instance_eval(&block)
+              end
+            end
+          end
+          
+          # load provider definition from file
+          cls.class_from_file(filename)
+        end
+        
+        # register new class as a Chef::Provider
+        pname = filename_to_qualified_string(cookbook_name, filename)
+        class_name = convert_to_class_name(pname)
+        Chef::Provider.const_set(class_name, new_provider_class)
+        Chef::Log.debug("Loaded contents of #{filename} into a provider named #{pname} defined in Chef::Provider::#{class_name}")
+        
+        new_provider_class
+      end
+    end
+
   end
 end