chef 0.9.12 → 0.9.14.beta.1

data/lib/chef/knife/status.rb

@@ -42,7 +42,7 @@ class Chef
         q.search(:node, query) do |node|
           all_nodes << node
         end
-        all_nodes.sort { |n1, n2| n1["ohai_time"] <=> n2["ohai_time"] }.each do |node|
+        all_nodes.sort { |n1, n2| (n1["ohai_time"] or 0) <=> (n2["ohai_time"] or 0) }.each do |node|
           if node.has_key?("ec2")
             fqdn = node['ec2']['public_hostname']
             ipaddress = node['ec2']['public_ipv4']

data/lib/chef/knife/terremark_server_create.rb

@@ -17,7 +17,7 @@
 #
 
 require 'chef/knife'
-require 'json'
+require 'chef/json'
 require 'tempfile'
 
 class Chef

data/lib/chef/knife/terremark_server_delete.rb

@@ -17,7 +17,7 @@
 #
 
 require 'chef/knife'
-require 'json'
+require 'chef/json'
 
 class Chef
   class Knife

data/lib/chef/knife/terremark_server_list.rb

@@ -17,7 +17,7 @@
 #
 
 require 'chef/knife'
-require 'json'
+require 'chef/json'
 require 'tempfile'
 
 class Chef

data/lib/chef/log.rb

@@ -43,13 +43,40 @@ class Chef
         end
         self.verbose
       end
-      
-      def method_missing(method_symbol, *args)
-        self.verbose_logger.send(method_symbol, *args) if self.verbose
-        logger.send(method_symbol, *args)
+
+      [:debug, :info, :warn, :error, :fatal].each do |method_name|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{method_name}(msg=nil, &block)
+            @logger.#{method_name}(msg, &block)
+          end
+        METHOD_DEFN
+      end
+
+      [:debug?, :info?, :warn?, :error?, :fatal?].each do |method_name|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{method_name}
+            @logger.#{method_name}
+          end
+        METHOD_DEFN
+      end
+
+      def <<(msg)
+        @logger << msg
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        @logger.add(severity, message = nil, progname = nil, &block)
       end
+
     end  
 
+    # NOTE: Mixlib::Log initially sets @logger to nil and depends on
+    # #init being called to initialize the logger. We don't want to
+    # incur extra method call overhead for every log message so we're
+    # accessing the logger by instance variable, which means we need to
+    # make Mixlib::Log initialize it.
+    init
+
     class Formatter
       def self.show_time=(*args)
         Mixlib::Log::Formatter.show_time = *args

data/lib/chef/mixin/command.rb

@@ -142,7 +142,7 @@ class Chef
         end
         
         args[:cwd] ||= Dir.tmpdir
-        unless File.directory?(args[:cwd])
+        unless ::File.directory?(args[:cwd])
           raise Chef::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory"
         end
         

data/lib/chef/mixin/create_path.rb

@@ -53,4 +53,4 @@ class Chef
   
     end
   end
-end
+end

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -78,4 +78,4 @@ class Chef
       
     end
   end
-end
+end

data/lib/chef/monkey_patches/numeric.rb

@@ -0,0 +1,7 @@
+unless 0.respond_to?(:fdiv)
+  class Numeric
+    def fdiv(other)
+      to_f / other
+    end
+  end
+end

data/lib/chef/node.rb

@@ -32,7 +32,7 @@ require 'chef/run_list'
 require 'chef/node/attribute'
 require 'chef/index_queue'
 require 'extlib'
-require 'json'
+require 'chef/json'
 
 class Chef
   class Node
@@ -326,12 +326,11 @@ class Chef
     # run_state[:seen_recipes], which is populated by include_recipe
     # statements in the DSL (and thus would not be in the run list).
     #
-    # NOTE: We believe this is dead code, but if it's not, please
-    # email chef-dev@opscode.com. [cw,timh]
-#     def recipe?(recipe_name)
-#       run_list.include?(recipe_name) || run_state[:seen_recipes].include?(recipe_name)
-#     end
-    
+    # NOTE: It's used by cookbook authors
+    def recipe?(recipe_name)
+      run_list.include?(recipe_name) || run_state[:seen_recipes].include?(recipe_name)
+    end
+ 
     # Returns true if this Node expects a given role, false if not.
     def role?(role_name)
       run_list.include?("role[#{role_name}]")
@@ -596,6 +595,5 @@ class Chef
       self.from_file(attribute_filename)
       self
     end
-
   end
 end

data/lib/chef/node/attribute.rb

@@ -450,14 +450,36 @@ class Chef
         end
       end
 
+      def delete(key)
+        [@automatic, @override, @normal, @default].inject(nil) do |return_value, attrs|
+          deleted_value = delete_from_component(attrs, key)
+          return_value || deleted_value
+        end
+      end
+
+      def delete_from_component(component_attrs, key)
+        # get the Hash-like object at the current nesting level:
+        nested_attrs = value_at_current_nesting(component_attrs, key)
+
+        if nested_attrs.respond_to?(:delete)
+          nested_attrs.delete(key)
+        else
+          nil
+        end
+      end
+
       def component_has_key?(component_attrs,key)
         # get the Hash-like object at the current nesting level:
-        nested_attrs = @current_nesting_level.inject(component_attrs) do |subtree, intermediate_key|
+        nested_attrs = value_at_current_nesting(component_attrs, key)
+        nested_attrs.respond_to?(:key?) && nested_attrs.key?(key)
+      end
+
+      def value_at_current_nesting(component_attrs, key)
+        @current_nesting_level.inject(component_attrs) do |subtree, intermediate_key|
           # if the intermediate value isn't a hash or doesn't have the intermediate key,
           # it can't have the bottom-level key we're looking for.
           (subtree.respond_to?(:key?) && subtree[intermediate_key]) or (return false)
         end
-        nested_attrs.respond_to?(:key?) && nested_attrs.key?(key)
       end
 
     end

data/lib/chef/openid_registration.rb

@@ -21,7 +21,7 @@ require 'chef/mixin/params_validate'
 require 'chef/couchdb'
 require 'chef/index_queue'
 require 'digest/sha1'
-require 'json'
+require 'chef/json'
 
 class Chef
   class OpenIDRegistration

data/lib/chef/platform.rb

@@ -70,6 +70,17 @@ class Chef
               :service => Chef::Provider::Service::Debian,
               :cron => Chef::Provider::Cron,
               :mdadm => Chef::Provider::Mdadm
+            },
+            "6.0" => {
+              :service => Chef::Provider::Service::Insserv
+            }
+          },
+          :xenserver   => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Yum,
+              :mdadm => Chef::Provider::Mdadm
             }
           },
           :centos   => {

data/lib/chef/provider/breakpoint.rb

@@ -33,4 +33,4 @@ class Chef
       
     end
   end
-end
+end

data/lib/chef/provider/cookbook_file.rb

@@ -97,4 +97,4 @@ class Chef
 
     end
   end
-end
+end

data/lib/chef/provider/deploy/revision.rb

@@ -56,7 +56,7 @@ class Chef
 
         def load_cache
           begin
-            JSON.parse(Chef::FileCache.load("revision-deploys/#{new_resource.name}"))
+            Chef::JSON.from_json(Chef::FileCache.load("revision-deploys/#{new_resource.name}"))
           rescue Chef::Exceptions::FileNotFound
             sorted_releases_from_filesystem
           end

data/lib/chef/provider/deploy/timestamped.rb

@@ -30,4 +30,4 @@ class Chef
       end
     end
   end
-end
+end

data/lib/chef/provider/erl_call.rb

@@ -55,16 +55,28 @@ class Chef
 
         command = "erl_call -e #{distributed} #{node} #{cookie}"
 
-        status = popen4(command, :waitlast => true) do |pid, stdin, stdout, stderr|
+        begin
+          pid, stdin, stdout, stderr = popen4(command, :waitlast => true)
+
           Chef::Log.debug("Running erl_call[#{@new_resource.name}]")
           Chef::Log.debug("erl_call[#{@new_resource.name}] command: #{command}")
           Chef::Log.debug("erl_call[#{@new_resource.name}] code: #{@new_resource.code}")
-          @new_resource.code.each_line { |line| stdin.puts "#{line.chomp!}" }
+
+          @new_resource.code.each_line { |line| stdin.puts(line.chomp) }
+
           stdin.close
+
           Chef::Log.info("Ran erl_call[#{@new_resource.name}] successfully")
           Chef::Log.debug("erl_call[#{@new_resource.name}] output: ")
+
           stdout.each_line { |line| Chef::Log.debug("#{line}")}
+          stderr.each_line { |line| Chef::Log.debug("#{line}")}
+          stdout.close
+          stderr.close
+        ensure
+          Process.wait(pid) if pid
         end
+
       end
 
     end

data/lib/chef/provider/git.rb

@@ -36,7 +36,9 @@ class Chef
       end
       
       def action_checkout
-        if !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination) == ['.','..']
+        assert_target_directory_valid!
+
+        if target_dir_non_existant_or_empty?
           clone
           checkout
           enable_submodules
@@ -53,24 +55,40 @@ class Chef
       end
       
       def action_sync
-        if !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination) == ['.','..']
-          action_checkout
-          @new_resource.updated_by_last_action(true)
-        else
+        assert_target_directory_valid!
+
+        if existing_git_clone?
           current_rev = find_current_revision
-          Chef::Log.debug "#{@new_resource} revision: #{current_rev}"
-          sync
-          enable_submodules
-          new_rev = find_current_revision
-          if current_rev == new_rev
-            @new_resource.updated_by_last_action(false)
-          else
-            Chef::Log.info "#{@new_resource} updated revision is: #{new_rev}"
+          Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{target_revision}"
+          unless current_revision_matches_target_revision?
+            fetch_updates
+            enable_submodules
+            Chef::Log.info "#{@new_resource} updated to revision: #{target_revision}"
             @new_resource.updated_by_last_action(true)
           end
+
+        else
+          action_checkout
+          @new_resource.updated_by_last_action(true)
         end
       end
-      
+
+      def assert_target_directory_valid!
+        target_parent_directory = ::File.dirname(@new_resource.destination)
+        unless ::File.directory?(target_parent_directory)
+          msg = "Cannot clone #{@new_resource} to #{@new_resource.destination}, the enclosing directory #{target_parent_directory} does not exist"
+          raise Chef::Exceptions::MissingParentDirectory, msg
+        end
+      end
+
+      def existing_git_clone?
+        ::File.exist?(::File.join(@new_resource.destination, ".git"))
+      end
+
+      def target_dir_non_existant_or_empty?
+        !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination).sort == ['.','..']
+      end
+
       def find_current_revision
         if ::File.exist?(::File.join(cwd, ".git"))
           status, result, error_message = output_of_command("git rev-parse HEAD", run_options(:cwd=>cwd))
@@ -92,73 +110,80 @@ class Chef
         
         Chef::Log.info "Cloning repo #{@new_resource.repository} to #{@new_resource.destination}"
         
-        clone_cmd = "#{git} clone #{args.join(' ')} #{@new_resource.repository} #{@new_resource.destination}"
+        clone_cmd = "git clone #{args.join(' ')} #{@new_resource.repository} #{@new_resource.destination}"
         run_command(run_options(:command => clone_cmd))
       end
       
       def checkout
-        sha_ref = revision_sha
+        sha_ref = target_revision
         Chef::Log.info "Checking out branch: #{@new_resource.revision} reference: #{sha_ref}"
         # checkout into a local branch rather than a detached HEAD
-        run_command(run_options(:command => "#{git} checkout -b deploy #{sha_ref}", :cwd => @new_resource.destination))
+        run_command(run_options(:command => "git checkout -b deploy #{sha_ref}", :cwd => @new_resource.destination))
       end
       
       def enable_submodules
         if @new_resource.enable_submodules
           Chef::Log.info "Enabling git submodules"
-          command = "#{git} submodule init && #{git} submodule update"
+          command = "git submodule init && git submodule update"
           run_command(run_options(:command => command, :cwd => @new_resource.destination))
         end
       end
       
-      def sync
-        revision = revision_sha
-        sync_command = []
-
-        # Use git-config to setup a remote tracking branches. Could use
-        # git-remote but it complains when a remote of the same name already
-        # exists, git-config will just silenty overwrite the setting every
-        # time. This could cause wierd-ness in the remote cache if the url
-        # changes between calls, but as long as the repositories are all
-        # based from each other it should still work fine.
-        if @new_resource.remote != 'origin'
-          Chef::Log.info  "Configuring remote tracking branches for repository #{@new_resource.repository} "+
-                          "at remote #{@new_resource.remote}"
-          sync_command << "#{git} config remote.#{@new_resource.remote}.url #{@new_resource.repository}"
-          sync_command << "#{git} config remote.#{@new_resource.remote}.fetch +refs/heads/*:refs/remotes/#{@new_resource.remote}/*"
-        end
+      def fetch_updates
+        setup_remote_tracking_branches if @new_resource.remote != 'origin'
 
         # since we're in a local branch already, just reset to specified revision rather than merge
-        sync_command << "#{git} fetch #{@new_resource.remote} && #{git} fetch #{@new_resource.remote} --tags && #{git} reset --hard #{revision}"
-        Chef::Log.info "Fetching updates from #{new_resource.remote} and resetting to revison #{revision}"
-        run_command(run_options(:command => sync_command.join(" && "), :cwd => @new_resource.destination))
+        fetch_command = "git fetch #{@new_resource.remote} && git fetch #{@new_resource.remote} --tags && git reset --hard #{target_revision}"
+        Chef::Log.debug "Fetching updates from #{new_resource.remote} and resetting to revison #{target_revision}"
+        run_command(run_options(:command => fetch_command, :cwd => @new_resource.destination))
       end
-      
-      def revision_sha
-        @revision_sha ||= begin
+
+      # Use git-config to setup a remote tracking branches. Could use
+      # git-remote but it complains when a remote of the same name already
+      # exists, git-config will just silenty overwrite the setting every
+      # time. This could cause wierd-ness in the remote cache if the url
+      # changes between calls, but as long as the repositories are all
+      # based from each other it should still work fine.
+      def setup_remote_tracking_branches
+        command = []
+
+        Chef::Log.info  "Configuring remote tracking branches for repository #{@new_resource.repository} "+
+                        "at remote #{@new_resource.remote}"
+        command << "git config remote.#{@new_resource.remote}.url #{@new_resource.repository}"
+        command << "git config remote.#{@new_resource.remote}.fetch +refs/heads/*:refs/remotes/#{@new_resource.remote}/*"
+        run_command(run_options(:command => command.join(" && "), :cwd => @new_resource.destination))
+      end
+
+      def current_revision_matches_target_revision?
+        (!@current_resource.revision.nil?) && (target_revision.strip.to_i(16) == @current_resource.revision.strip.to_i(16))
+      end
+
+      def target_revision
+        @target_revision ||= begin
           assert_revision_not_remote
           
           if sha_hash?(@new_resource.revision)
-            @revision_sha = @new_resource.revision 
+            @target_revision = @new_resource.revision 
           else
             resolved_reference = remote_resolve_reference
-            @revision_sha = extract_revision(resolved_reference)
+            @target_revision = extract_revision(resolved_reference)
           end
         end
       end
       
-      alias :revision_slug :revision_sha
+      alias :revision_slug :target_revision
       
       def remote_resolve_reference
-        command = scm('ls-remote', @new_resource.repository, @new_resource.revision)
+        command = git('ls-remote', @new_resource.repository, @new_resource.revision)
         Chef::Log.debug("Executing #{command}")
         begin
           status, result, error_message = output_of_command(command, run_options)
           handle_command_failures(status, "STDOUT: #{result}\nSTDERR: #{error_message}")
-        rescue RuntimeError => e
-          raise RuntimeError, e.message + "\n" + "Could not access the remote Git repository. "+
-                "If this is a private repository, please verify that the deploy key for your application " +
-                "has been added to your remote Git account."
+        rescue Chef::Exceptions::Exec => e
+          msg =  "Could not access the remote Git repository. If this is a private repository, "
+          msg << "verify that the deploy key for your application has been added to your remote Git account.\n"
+          msg << e.message
+          raise Chef::Exceptions::Exec, msg
         end
         result
       end
@@ -176,14 +201,10 @@ class Chef
         @new_resource.destination
       end
       
-      def scm(*args)
-        [git, *args].compact.join(" ")
+      def git(*args)
+        ["git", *args].compact.join(" ")
       end
 
-      def git
-        'git'
-      end
-      
       def sha_hash?(string)
         string =~ /^[0-9a-f]{40}$/
       end
@@ -201,7 +222,10 @@ class Chef
       
       def extract_revision(resolved_reference)
         unless resolved_reference =~ /^([0-9a-f]{40})\s+(\S+)/
-          raise "Unable to resolve reference for '#{resolved_reference}' on repository '#{@new_resource.repository}'."
+          msg = "Unable to parse SHA reference for '#{@new_resource.revision}' in repository '#{@new_resource.repository}'. "
+          msg << "Verify your (case-sensitive) repository URL and revision.\n"
+          msg << "`git ls-remote` output: #{resolved_reference}"
+          raise Chef::Exceptions::UnresolvableGitReference, msg
         end
         $1
       end