chef 0.10.0.beta.6 → 0.10.0.beta.7

data/lib/chef/knife/core/subcommand_loader.rb

@@ -1,5 +1,3 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Christopher Brown (<cb@opscode.com>)
 # Author:: Daniel DeLeo (<dan@opscode.com>)
 # Copyright:: Copyright (c) 2009, 2011 Opscode, Inc.
@@ -19,7 +17,6 @@
 #
 
 require 'chef/version'
-
 class Chef
   class Knife
     class SubcommandLoader
@@ -32,11 +29,12 @@ class Chef
 
       def initialize(chef_config_dir, env=ENV)
         @chef_config_dir, @env = chef_config_dir, env
+        @forced_activate = {}
       end
 
       # Load all the sub-commands
       def load_commands
-        subcommand_files.each { |subcommand| require subcommand }
+        subcommand_files.each { |subcommand| Kernel.load subcommand }
         true
       end
 
@@ -52,12 +50,18 @@ class Chef
         # finally search ~/.chef/plugins/knife/*.rb
         user_specific_files.concat Dir.glob(File.join(env['HOME'], '.chef', 'plugins', 'knife', '*.rb'))
 
-        user_specific_files.map! { |path| path[/(.+).rb/, 1] }
         user_specific_files
       end
 
-      # Returns an Array of paths to knife commands built-in to chef, or installed via gem.
+      # Returns a Hash of paths to knife commands built-in to chef, or installed via gem.
       # If rubygems is not installed, falls back to globbing the knife directory.
+      # The Hash is of the form {"relative/path" => "/absolute/path"}
+      #--
+      # Note: the "right" way to load the plugins is to require the relative path, i.e.,
+      #   require 'chef/knife/command'
+      # but we're getting frustrated by bugs at every turn, and it's slow besides. So
+      # subcommand loader has been modified to load the plugins by using Kernel.load
+      # with the absolute path.
       def gem_and_builtin_subcommands
         # search all gems for chef/knife/*.rb
         require 'rubygems'
@@ -67,23 +71,30 @@ class Chef
       end
 
       def subcommand_files
-        @subcommand_files ||= (gem_and_builtin_subcommands + site_subcommands).flatten.uniq
+        @subcommand_files ||= (gem_and_builtin_subcommands.values + site_subcommands).flatten.uniq
       end
 
       def find_subcommands_via_dirglob
         # The "require paths" of the core knife subcommands bundled with chef
         files = Dir[File.expand_path('../../../knife/*.rb', __FILE__)]
-        files.map! { |knife_file| knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1] }
-        files
+        subcommand_files = {}
+        files.each do |knife_file|
+          rel_path = knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1]
+          subcommand_files[rel_path] = knife_file
+        end
+        subcommand_files
       end
 
       def find_subcommands_via_rubygems
         files = Gem.find_files 'chef/knife/*.rb'
         files.reject! {|f| from_old_gem?(f) }
-        files.map! do |file|
-          file[/(#{Regexp.escape File.join('chef', 'knife', '')}.*)\.rb/, 1]
-        end.uniq!
-        files
+        subcommand_files = {}
+        files.each do |file|
+          rel_path = file[/(#{Regexp.escape File.join('chef', 'knife', '')}.*)\.rb/, 1]
+          subcommand_files[rel_path] = file
+        end
+
+        subcommand_files.merge(find_subcommands_via_dirglob)
       end
 
       private

data/lib/chef/knife/core/text_formatter.rb

@@ -72,7 +72,7 @@ class Chef
         # Ruby 1.8 Strings include enumberable, which is not what we want. So
         # we have this heuristic to detect hashes and arrays instead.
         def should_enumerate?(value)
-          ((value.respond_to?(:keys) && !value.empty? ) || ( value.kind_of?(Array) && value.size > 1 ))
+          ((value.respond_to?(:keys) && !value.empty? ) || ( value.kind_of?(Array) && (value.size > 1 || should_enumerate?(value.first) )))
         end
 
         def indent_line(string, indent)
@@ -90,7 +90,7 @@ class Chef
         end
 
         def stringify_value(data)
-          data.kind_of?(String) ? data : data.inspect
+          data.kind_of?(String) ? data : data.to_s
         end
 
       end

data/lib/chef/knife/core/ui.rb

@@ -93,7 +93,7 @@ class Chef
       # determined by the value of `config[:color]`. When output is not to a
       # terminal, colored output is never used
       def color?
-        config[:color] && stdout.tty?
+        Chef::Config[:color] && stdout.tty?
       end
 
       def ask(*args, &block)

data/lib/chef/knife/search.rb

@@ -17,6 +17,7 @@
 #
 
 require 'chef/knife'
+require 'chef/knife/core/node_presenter'
 
 class Chef
   class Knife
@@ -24,7 +25,6 @@ class Chef
 
       deps do
         require 'chef/search/query'
-        require 'chef/knife/core/node_presenter'
       end
 
       include Knife::Core::NodeFormattingOptions

data/lib/chef/knife/ssh.rb

@@ -25,6 +25,7 @@ class Chef
       deps do
         require 'net/ssh'
         require 'net/ssh/multi'
+        require 'readline'
         require 'chef/search/query'
       end
 

data/lib/chef/mixin/shell_out.rb

@@ -24,8 +24,8 @@ class Chef
 
       def shell_out(*command_args)
         cmd = Chef::ShellOut.new(*command_args)
-        if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.info?
-          cmd.live_stream ||= STDOUT
+        if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.debug?
+          cmd.live_stream = STDOUT
         end
         cmd.run_command
         cmd

data/lib/chef/node.rb

@@ -447,10 +447,13 @@ class Chef
     # Apply the default and overrides attributes from the expansion
     # passed in, which came from roles.
     def apply_expansion_attributes(expansion)
-      @default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, expansion.default_attrs)
-      environment_attrs = chef_environment == "_default" ? {} : Chef::Environment.load(chef_environment).attributes
+      load_chef_environment_object = (chef_environment == "_default" ? nil : Chef::Environment.load(chef_environment))
+      environment_default_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.default_attributes
+      default_before_roles = Chef::Mixin::DeepMerge.merge(default_attrs, environment_default_attrs)
+      @default_attrs = Chef::Mixin::DeepMerge.merge(default_before_roles, expansion.default_attrs)
+      environment_override_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.override_attributes
       overrides_before_environments = Chef::Mixin::DeepMerge.merge(override_attrs, expansion.override_attrs)
-      @override_attrs = Chef::Mixin::DeepMerge.merge(overrides_before_environments, environment_attrs)
+      @override_attrs = Chef::Mixin::DeepMerge.merge(overrides_before_environments, environment_override_attrs)
     end
 
     # Transform the node to a Hash
@@ -647,7 +650,7 @@ class Chef
     def load_attributes
       cookbook_collection.values.each do |cookbook|
         cookbook.segment_filenames(:attributes).each do |segment_filename|
-          Chef::Log.debug("node #{name} loading cookbook #{cookbook.name}'s attribute file #{segment_filename}")
+          Chef::Log.debug("Node #{name} loading cookbook #{cookbook.name}'s attribute file #{segment_filename}")
           self.from_file(segment_filename)
         end
       end

data/lib/chef/provider/cookbook_file.rb

@@ -31,18 +31,18 @@ class Chef
         @current_resource
       end
 
-
       def action_create
         assert_enclosing_directory_exists!
         if file_cache_location && content_stale?
-          Chef::Log.debug("content of file #{@new_resource.path} requires update")
+          Chef::Log.debug("#{@new_resource} has new contents")
           backup_new_resource
           Tempfile.open(::File.basename(@new_resource.name)) do |staging_file|
-            Chef::Log.debug("staging #{file_cache_location} to #{staging_file.path}")
+            Chef::Log.debug("#{@new_resource} staging #{file_cache_location} to #{staging_file.path}")
             staging_file.close
             stage_file_to_tmpdir(staging_file.path)
             FileUtils.mv(staging_file.path, @new_resource.path)
           end
+          Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
           @new_resource.updated_by_last_action(true)
         else
           set_all_access_controls(@new_resource.path)
@@ -52,7 +52,7 @@ class Chef
 
       def action_create_if_missing
         if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
+          Chef::Log.debug("#{@new_resource} exists at #{@new_resource.path} taking no action.")
         else
           action_create
         end
@@ -87,7 +87,6 @@ class Chef
 
       def backup_new_resource
         if ::File.exists?(@new_resource.path)
-          Chef::Log.info "Backing up current file at #{@new_resource.path}"
           backup @new_resource.path
         end
       end

data/lib/chef/provider/cron.rb

@@ -132,7 +132,7 @@ class Chef
           status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|
             crontab.each_line { |line| stdin.puts "#{line}" }
           end
-          Chef::Log.info("Updated cron '#{@new_resource.name}'")
+          Chef::Log.info("#{@new_resource} updated crontab entry")
           @new_resource.updated_by_last_action(true)
         else
           unless @cron_empty
@@ -146,7 +146,7 @@ class Chef
           status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|
             crontab.each_line { |line| stdin.puts "#{line}" }
           end
-          Chef::Log.info("Added cron '#{@new_resource.name}'")
+          Chef::Log.info("#{@new_resource} added crontab entry")
           @new_resource.updated_by_last_action(true)
         end
       end
@@ -176,7 +176,7 @@ class Chef
           status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|
             crontab.each_line { |line| stdin.puts "#{line}" }
           end
-          Chef::Log.debug("Deleted cron '#{@new_resource.name}'")
+          Chef::Log.info("#{@new_resource} deleted crontab entry")
           @new_resource.updated_by_last_action(true)
         end
       end

data/lib/chef/provider/cron/solaris.rb

@@ -51,7 +51,7 @@ class Chef
           crontab_lines.each do |line|
             case line.chomp
             when "# Chef Name: #{@new_resource.name}"
-              Chef::Log.debug("Found cron '#{@new_resource.name}'")
+              Chef::Log.debug("#{@new_resource} found cron '#{@new_resource.name}'")
               cron_found = true
               @cron_exists = true
               next
@@ -82,9 +82,9 @@ class Chef
               next
             end
           end
-          Chef::Log.debug("Cron '#{@new_resource.name}' not found") unless @cron_exists
+          Chef::Log.debug("#{@new_resource} cron '#{@new_resource.name}' not found") unless @cron_exists
         elsif status.exitstatus == 1
-          Chef::Log.debug("Cron empty for '#{@new_resource.user}'")
+          Chef::Log.debug("#{@new_resource} cron empty for '#{@new_resource.user}'")
           @cron_empty = true
         end
 
@@ -125,7 +125,7 @@ class Chef
 
         if @cron_exists
           unless compare_cron
-            Chef::Log.debug("Skipping existing cron entry '#{@new_resource.name}'")
+            Chef::Log.debug("#{@new_resource} skipping existing cron entry '#{@new_resource.name}'")
             return
           end
           status = popen4("crontab -l #{@new_resource.user}") do |pid, stdin, stdout, stderr|
@@ -148,7 +148,7 @@ class Chef
           end
 
           status = write_crontab(crontab)
-          Chef::Log.info("Updated cron '#{@new_resource.name}'")
+          Chef::Log.info("#{@new_resource} updated crontab entry")
         else
           unless @cron_empty
             status = popen4("crontab -l #{@new_resource.user}") do |pid, stdin, stdout, stderr|
@@ -158,7 +158,7 @@ class Chef
 
           crontab << newcron
           status = write_crontab(crontab)
-          Chef::Log.info("Added cron '#{@new_resource.name}'")
+          Chef::Log.info("#{@new_resource} added crontab entry")
         end
       end
 
@@ -185,7 +185,7 @@ class Chef
           end
 
           status = write_crontab(crontab)
-          Chef::Log.info("Deleted cron '#{@new_resource.name}'")
+          Chef::Log.info("#{@new_resource} deleted crontab entry")
         end
       end
 

data/lib/chef/provider/deploy.rb

@@ -61,9 +61,8 @@ class Chef
       def action_deploy
         if all_releases.include?(release_path)
           if all_releases[-1] == release_path
-            Chef::Log.debug("Already deployed app at #{release_path}, and it is the latest revision.  Use action :force_deploy to re-deploy this revision.")
+            Chef::Log.debug("#{@new_resource} is the latest version")
           else
-            Chef::Log.info("Already deployed app at #{release_path}.  Rolling back to it - use action :force_deploy to re-checkout this revision.")
             action_rollback
           end
         else
@@ -74,8 +73,8 @@ class Chef
 
       def action_force_deploy
         if all_releases.include?(release_path)
-          Chef::Log.info("Already deployed app at #{release_path}, forcing.")
           FileUtils.rm_rf(release_path)
+          Chef::Log.info("#{@new_resource} forcing deploy of already deployed app at #{release_path}")
         end
         deploy
         @new_resource.updated_by_last_action(true)
@@ -93,12 +92,12 @@ class Chef
           releases_to_nuke = [ all_releases.last ]
         end
 
-        Chef::Log.info "rolling back to previous release: #{release_path}"
+        Chef::Log.info "#{@new_resource} rolling back to previous release #{release_path}"
         symlink
-        Chef::Log.info "restarting with previous release"
+        Chef::Log.info "#{@new_resource} restarting with previous release"
         restart
         releases_to_nuke.each do |i|
-          Chef::Log.info "Removing release: #{i}"
+          Chef::Log.info "#{@new_resource} removing release: #{i}"
           FileUtils.rm_rf i
           release_deleted(i)
         end
@@ -106,7 +105,6 @@ class Chef
       end
 
       def deploy
-        Chef::Log.info "deploying branch: #{@new_resource.branch}"
         enforce_ownership
         update_cached_repo
         copy_cached_repo
@@ -120,13 +118,14 @@ class Chef
         restart
         callback(:after_restart, @new_resource.after_restart)
         cleanup!
+        Chef::Log.info "#{@new_resource} deployed to #{@new_resource.deploy_to}"
       end
 
       def callback(what, callback_code=nil)
         @collection = Chef::ResourceCollection.new
         case callback_code
         when Proc
-          Chef::Log.info "Running callback #{what} code block"
+          Chef::Log.info "#{@new_resource} running callback #{what}"
           recipe_eval(&callback_code)
         when String
           callback_file = "#{release_path}/#{callback_code}"
@@ -152,26 +151,25 @@ class Chef
             "#{key_and_val.first}='#{key_and_val.last}'"
           end.join(" ")
 
-          Chef::Log.info  "Migrating: running #{@new_resource.migration_command} as #{@new_resource.user} " +
-                          "with environment #{env_info}"
-          run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path))
+          Chef::Log.info "#{@new_resource} migrating #{@new_resource.user} with environment #{env_info}"
+          run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path, :command_log_level => :info))
         end
       end
 
       def symlink
-        Chef::Log.info "Symlinking"
         purge_tempfiles_from_current_release
         link_tempfiles_to_current_release
         link_current_release_to_production
+        Chef::Log.info "#{@new_resource} updated symlinks"
       end
 
       def restart
         if restart_cmd = @new_resource.restart_command
           if restart_cmd.kind_of?(Proc)
-            Chef::Log.info("Restarting app with embedded recipe")
+            Chef::Log.info("#{@new_resource} restarting app with embedded recipe")
             recipe_eval(&restart_cmd)
           else
-            Chef::Log.info("Restarting app with #{@new_resource.restart_command} in #{@new_resource.current_path}")
+            Chef::Log.info("#{@new_resource} restarting app")
             run_command(run_options(:command => @new_resource.restart_command, :cwd => @new_resource.current_path))
           end
         end
@@ -179,7 +177,7 @@ class Chef
 
       def cleanup!
         all_releases[0..-6].each do |old_release|
-          Chef::Log.info "Removing old release #{old_release}"
+          Chef::Log.info "#{@new_resource} removing old release #{old_release}"
           FileUtils.rm_rf(old_release)
           release_deleted(old_release)
         end
@@ -199,52 +197,70 @@ class Chef
       end
 
       def run_scm_sync
-        Chef::Log.info "updating the cached checkout"
         @scm_provider.action_sync
       end
 
       def svn_force_export
-        Chef::Log.info "exporting source repository to #{@new_resource.destination}"
+        Chef::Log.info "#{@new_resource} exporting source repository"
         @scm_provider.action_force_export
       end
 
       def copy_cached_repo
-        Chef::Log.info "copying the cached checkout to #{release_path}"
         FileUtils.mkdir_p(@new_resource.deploy_to + "/releases")
         run_command(:command => "cp -RPp #{::File.join(@new_resource.destination, ".")} #{release_path}")
+        Chef::Log.info "#{@new_resource} copied the cached checkout to #{release_path}"
         release_created(release_path)
       end
 
       def enforce_ownership
-        Chef::Log.info "ensuring proper ownership"
         FileUtils.chown_R(@new_resource.user, @new_resource.group, @new_resource.deploy_to)
+        Chef::Log.info("#{@new_resource} set user to #{@new_resource.user}") if @new_resource.user
+        Chef::Log.info("#{@new_resource} set group to #{@new_resource.group}") if @new_resource.group
       end
 
       def link_current_release_to_production
-        Chef::Log.info "Linking release #{release_path} into production at #{@new_resource.current_path}"
         FileUtils.rm_f(@new_resource.current_path)
-        FileUtils.ln_sf(release_path, @new_resource.current_path)
+        begin
+          FileUtils.ln_sf(release_path, @new_resource.current_path)
+        rescue => e
+          raise Chef::Exceptions::FileNotFound.new("Cannot symlink current release to production: #{e.message}")
+        end
+        Chef::Log.info "#{@new_resource} linked release #{release_path} into production at #{@new_resource.current_path}"
         enforce_ownership
       end
 
       def run_symlinks_before_migrate
         links_info = @new_resource.symlink_before_migrate.map { |src, dst| "#{src} => #{dst}" }.join(", ")
-        Chef::Log.info "Making pre-migration symlinks: #{links_info}"
         @new_resource.symlink_before_migrate.each do |src, dest|
-          FileUtils.ln_sf(@new_resource.shared_path + "/#{src}", release_path + "/#{dest}")
+          begin
+            FileUtils.ln_sf(@new_resource.shared_path + "/#{src}", release_path + "/#{dest}")
+          rescue => e
+            raise Chef::Exceptions::FileNotFound.new("Cannot symlink #{@new_resource.shared_path}/#{src} to #{release_path}/#{dest} before migrate: #{e.message}")
+          end
         end
+        Chef::Log.info "#{@new_resource} made pre-migration symlinks"
       end
 
       def link_tempfiles_to_current_release
         dirs_info = @new_resource.create_dirs_before_symlink.join(",")
-        Chef::Log.info("creating directories before symlink: #{dirs_info}")
-        @new_resource.create_dirs_before_symlink.each { |dir| FileUtils.mkdir_p(release_path + "/#{dir}") }
+        @new_resource.create_dirs_before_symlink.each do |dir| 
+          begin
+            FileUtils.mkdir_p(release_path + "/#{dir}")
+          rescue => e
+            raise Chef::Exceptions::FileNotFound.new("Cannot create directory #{dir}: #{e.message}")
+          end
+        end
+        Chef::Log.info("#{@new_resource} created directories before symlinking #{dirs_info}")
 
         links_info = @new_resource.symlinks.map { |src, dst| "#{src} => #{dst}" }.join(", ")
-        Chef::Log.info("Linking shared paths into current release: #{links_info}")
         @new_resource.symlinks.each do |src, dest|
-          FileUtils.ln_sf(@new_resource.shared_path + "/#{src}",  release_path + "/#{dest}")
+          begin
+            FileUtils.ln_sf(@new_resource.shared_path + "/#{src}",  release_path + "/#{dest}")
+          rescue => e
+            raise Chef::Exceptions::FileNotFound.new("Cannot symlink shared data #{@new_resource.shared_path}/#{src} to #{release_path}/#{dest}: #{e.message}")
+          end
         end
+        Chef::Log.info("#{@new_resource} linked shared paths into current release: #{links_info}")
         run_symlinks_before_migrate
         enforce_ownership
       end
@@ -254,8 +270,8 @@ class Chef
 
       def purge_tempfiles_from_current_release
         log_info = @new_resource.purge_before_symlink.join(", ")
-        Chef::Log.info("Purging directories in checkout #{log_info}")
         @new_resource.purge_before_symlink.each { |dir| FileUtils.rm_rf(release_path + "/#{dir}") }
+        Chef::Log.info("#{@new_resource} purged directories in checkout #{log_info}")
       end
 
       protected
@@ -303,13 +319,20 @@ class Chef
         run_opts[:user] = @new_resource.user if @new_resource.user
         run_opts[:group] = @new_resource.group if @new_resource.group
         run_opts[:environment] = @new_resource.environment if @new_resource.environment
+        run_opts[:command_log_prepend] = @new_resource.to_s
+        run_opts[:command_log_level] ||= :debug
+        if run_opts[:command_log_level] == :info
+          if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.info?
+            run_opts[:live_stream] = STDOUT
+          end
+        end
         run_opts
       end
 
       def run_callback_from_file(callback_file)
         if ::File.exist?(callback_file)
           Dir.chdir(release_path) do
-            Chef::Log.info "running deploy hook: #{callback_file}"
+            Chef::Log.info "#{@new_resource} running deploy hook #{callback_file}"
             recipe_eval { from_file(callback_file) }
           end
         end