capistrano 2.3.0 → 2.4.0

data/CHANGELOG

@@ -1,6 +1,54 @@
-*2.3.0* May 2, 2008
+*2.4.0* June 13, 2008
+
+* Added :normalize_asset_timestamps option to deployment, defaulting to true, which allows asset timestamping to be disabled [John Trupiano]
+
+
+*2.4.0 Preview Release #1* (2.3.101) June 5, 2008 
+
+* Only make deploy:start, deploy:stop, and deploy:restart try sudo as :runner. The other sudo-enabled tasks (deploy:setup, deploy:cleanup, etc.) will now use the :admin_runner user (which by default is unset). [Jamis Buck]
+
+* Make sure triggers defined as a block inherit the scope of the task they are attached to, instead of the task they were called from [Jamis Buck]
+
+* Make deploy:upload use the upload() helper for more efficient directory processing [Jamis Buck]
+
+* Make deploy:upload accept globs [Mark Imbriaco]
+
+* Make sure the host is reported with the output from scm_run [Jamis Buck]
+
+* Make git SCM honor the :scm_verbose option [Jamis Buck]
+
+* Don't follow symlinks when using :copy_cache [Jamis Buck]
+
+* If :mode is given to upload() helper, do a chmod after to set the mode [Jamis Buck]
+
+* Fix load_from_file method for windows users [Neil Wilson]
+
+* Display a deprecation error if a remote git branch is specified [Tim Harper]
 
-* Make sure git fetches include tags [Alex Arnell]
+* Fix deployment recipes to use the updated sudo helper [Jamis Buck]
+
+* Enhance the sudo helper so it can be used to return the command, instead of executing it [Jamis Buck]
+
+* Revert "make sudo helper play nicely with complex command chains", since it broke stuff [Jamis Buck]
+
+* Make set(:default_shell, false) work for not using a shell on a per-command basis [Ryan McGeary] 
+
+* Improved test coverage [Ryan McGeary]
+
+* Fixed "coverage" take task [Ryan McGeary]
+
+* Use upload() instead of put() with the copy strategy [Jamis Buck]
+
+* Revert the "git fetch --tags" change, since it didn't work as expected [Jamis Buck]
+
+* Fix deploy:pending when using git SCM [Ryan McGeary]
+
+* Make sure deploy:check works with :none scm (which has no default command) [Jamis Buck]
+
+* Add debug switch for enabling conditional execution of commands [Mark Imbriaco]
+
+
+*2.3.0* May 2, 2008
 
 * Make deploy:setup obey the :use_sudo and :runner directives, and generalize the :use_sudo and :runner options into a try_sudo() helper method [Jamis Buck]
 

data/lib/capistrano/cli/execute.rb

@@ -22,6 +22,7 @@ module Capistrano
       # Returns the Configuration instance used, if successful.
       def execute!
         config = instantiate_configuration
+        config.debug = options[:debug]
         config.logger.level = options[:verbose]
 
         set_pre_vars(config)

data/lib/capistrano/cli/options.rb

@@ -27,6 +27,10 @@ module Capistrano
         @option_parser ||= OptionParser.new do |opts|
           opts.banner = "Usage: #{File.basename($0)} [options] action ..."
 
+          opts.on("-d", "--debug",
+            "Prompts before each remote command execution."
+          ) { |value| options[:debug] = true }
+
           opts.on("-e", "--explain TASK",
             "Displays help (if available) for the task."
           ) { |value| options[:explain] = value }

data/lib/capistrano/cli/ui.rb

@@ -22,6 +22,19 @@ module Capistrano
         def password_prompt(prompt="Password: ")
           ui.ask(prompt) { |q| q.echo = false }
         end
+        
+        # Debug mode prompt
+        def debug_prompt(cmd)
+          ui.say("Preparing to execute command: #{cmd}")
+          prompt = "Execute ([Yes], No, Abort) "
+          ui.ask("#{prompt}?  ") do |q|
+            q.overwrite = false
+            q.character = true
+            q.default = 'y'
+            q.validate = /(y(es)?)|(no?)|(a(bort)?|\n)/i
+            q.responses[:not_valid] = prompt
+          end
+        end
       end
     end
   end

data/lib/capistrano/command.rb

@@ -82,12 +82,12 @@ module Capistrano
                 if options[:shell] == false
                   shell = nil
                 else
-                  shell = [options.fetch(:shell, "sh"), "-c"].join(" ")
+                  shell = "#{options[:shell] || "sh"} -c"
                   cmd = cmd.gsub(/[$\\`"]/) { |m| "\\#{m}" }
                   cmd = "\"#{cmd}\""
                 end
 
-                command_line = [environment, options[:command_prefix], shell, cmd].compact.join(" ")
+                command_line = [environment, shell, cmd].compact.join(" ")
 
                 ch.exec(command_line)
                 ch.send_data(options[:data]) if options[:data]

data/lib/capistrano/configuration.rb

@@ -19,9 +19,10 @@ module Capistrano
   # define roles, and set configuration variables.
   class Configuration
     # The logger instance defined for this configuration.
-    attr_accessor :logger
+    attr_accessor :debug, :logger
 
     def initialize #:nodoc:
+      @debug = false
       @logger = Logger.new
     end
 

data/lib/capistrano/configuration/actions/file_transfer.rb

@@ -10,7 +10,6 @@ module Capistrano
         # set the mode on the file.
         def put(data, path, options={})
           opts = options.dup
-          opts[:permissions] = opts.delete(:mode)
           upload(StringIO.new(data), path, opts)
         end
     
@@ -23,7 +22,12 @@ module Capistrano
         end
 
         def upload(from, to, options={}, &block)
+          mode = options.delete(:mode)
           transfer(:up, from, to, options, &block)
+          if mode
+            mode = mode.is_a?(Numeric) ? mode.to_s(8) : mode.to_s
+            run "chmod #{mode} #{to}"
+          end
         end
 
         def download(from, to, options={}, &block)

data/lib/capistrano/configuration/actions/invocation.rb

@@ -46,33 +46,49 @@ module Capistrano
           block ||= self.class.default_io_proc
           logger.debug "executing #{cmd.strip.inspect}"
 
+          return if debug && continue_execution(cmd) == false
+
           options = add_default_command_options(options)
 
+          if cmd.include?(sudo)
+            block = sudo_behavior_callback(block)
+          end
+
           execute_on_servers(options) do |servers|
             targets = servers.map { |s| sessions[s] }
             Command.process(cmd, targets, options.merge(:logger => logger), &block)
           end
         end
 
-        # Like #run, but executes the command via <tt>sudo</tt>. This assumes
-        # that the sudo password (if required) is the same as the password for
-        # logging in to the server.
+        # Returns the command string used by capistrano to invoke a comamnd via
+        # sudo.
+        #
+        #   run "#{sudo :as => 'bob'} mkdir /path/to/dir"
         #
-        # Also, this module accepts a <tt>:sudo</tt> configuration variable,
+        # It can also be invoked like #run, but executing the command via sudo.
+        # This assumes that the sudo password (if required) is the same as the
+        # password for logging in to the server.
+        #
+        #   sudo "mkdir /path/to/dir"
+        #
+        # Also, this method understands a <tt>:sudo</tt> configuration variable,
         # which (if specified) will be used as the full path to the sudo
         # executable on the remote machine:
         #
         #   set :sudo, "/opt/local/bin/sudo"
-        def sudo(command, options={}, &block)
-          block ||= self.class.default_io_proc
-
-          options = options.dup
-          as = options.delete(:as)
-
-          user = as && "-u #{as}"
-          options[:command_prefix] = [fetch(:sudo, "sudo"), "-p '#{sudo_prompt}'", user].compact.join(" ")
-
-          run(command, options, &sudo_behavior_callback(block))
+        def sudo(*parameters, &block)
+          options = parameters.last.is_a?(Hash) ? parameters.pop.dup : {}
+          command = parameters.first
+          user = options[:as] && "-u #{options.delete(:as)}"
+
+          sudo_command = [fetch(:sudo, "sudo"), "-p '#{sudo_prompt}'", user].compact.join(" ")
+
+          if command
+            command = sudo_command + " " + command
+            run(command, options, &block)
+          else
+            return sudo_command
+          end
         end
 
         # Returns a Proc object that defines the behavior of the sudo
@@ -88,13 +104,13 @@ module Capistrano
           Proc.new do |ch, stream, out|
             if out =~ /^#{Regexp.escape(sudo_prompt)}/
               ch.send_data "#{self[:password]}\n"
-            elsif out =~ /try again/
+            elsif out =~ /^Sorry, try again/
               if prompt_host.nil? || prompt_host == ch[:server]
                 prompt_host = ch[:server]
                 logger.important out, "#{stream} :: #{ch[:server]}"
                 reset! :password
               end
-            else
+            elsif fallback
               fallback.call(ch, stream, out)
             end
           end
@@ -119,7 +135,7 @@ module Capistrano
           options[:env] = env unless env.empty?
 
           shell = options[:shell] || self[:default_shell]
-          options[:shell] = shell if shell
+          options[:shell] = shell unless shell.nil?
 
           options
         end
@@ -128,7 +144,18 @@ module Capistrano
         def sudo_prompt
           fetch(:sudo_prompt, "sudo password: ")
         end
+        
+        def continue_execution(cmd)
+          case Capistrano::CLI.debug_prompt(cmd)
+            when "y"
+              true
+            when "n"
+              false
+            when "a"
+              exit(-1)
+          end
+        end
       end
     end
   end
-end
+end

data/lib/capistrano/configuration/callbacks.rb

@@ -4,7 +4,7 @@ module Capistrano
   class Configuration
     module Callbacks
       def self.included(base) #:nodoc:
-        %w(initialize execute_task).each do |method|
+        %w(initialize invoke_task_directly).each do |method|
           base.send :alias_method, "#{method}_without_callbacks", method
           base.send :alias_method, method, "#{method}_with_callbacks"
         end
@@ -18,13 +18,13 @@ module Capistrano
         @callbacks = {}
       end
 
-      def execute_task_with_callbacks(task) #:nodoc:
+      def invoke_task_directly_with_callbacks(task) #:nodoc:
         before = find_hook(task, :before)
         execute_task(before) if before
 
         trigger :before, task
 
-        result = execute_task_without_callbacks(task)
+        result = invoke_task_directly_without_callbacks(task)
 
         trigger :after, task
 

data/lib/capistrano/configuration/execution.rb

@@ -72,12 +72,12 @@ module Capistrano
         task_call_frames.last.task
       end
 
-      # Executes the task with the given name, including the before and after
-      # hooks.
+      # Executes the task with the given name, without invoking any associated
+      # callbacks.
       def execute_task(task)
         logger.debug "executing `#{task.fully_qualified_name}'"
         push_task_call_frame(task)
-        task.namespace.instance_eval(&task.body)
+        invoke_task_directly(task)
       ensure
         pop_task_call_frame
       end
@@ -121,6 +121,11 @@ module Capistrano
       def pop_task_call_frame
         task_call_frames.pop
       end
+
+      # Invokes the task's body directly, without setting up the call frame.
+      def invoke_task_directly(task)
+        task.namespace.instance_eval(&task.body)
+      end
     end
   end
 end

data/lib/capistrano/configuration/loading.rb

@@ -140,27 +140,26 @@ module Capistrano
       def require(*args) #:nodoc:
         # look to see if this specific configuration instance has ever seen
         # these arguments to require before
-        if !@loaded_features.include?(args)
-          @loaded_features << args
-
-          begin
-            original_instance, self.class.instance = self.class.instance, self
-            original_feature, self.class.current_feature = self.class.current_feature, args
-
-            result = super
-            if !result # file has been required previously, load up the remembered recipes
-              list = self.class.recipes_per_feature[args] || []
-              list.each { |options| load(options.merge(:reloading => true)) }
-            end
-
-            return result
-          ensure
-            # restore the original, so that require's can be nested
-            self.class.instance = original_instance
-            self.class.current_feature = original_feature
+        if @loaded_features.include?(args)
+          return false 
+        end
+        
+        @loaded_features << args
+        begin
+          original_instance, self.class.instance = self.class.instance, self
+          original_feature, self.class.current_feature = self.class.current_feature, args
+
+          result = super
+          if !result # file has been required previously, load up the remembered recipes
+            list = self.class.recipes_per_feature[args] || []
+            list.each { |options| load(options.merge(:reloading => true)) }
           end
-        else
-          return false
+
+          return result
+        ensure
+          # restore the original, so that require's can be nested
+          self.class.instance = original_instance
+          self.class.current_feature = original_feature
         end
       end
 
@@ -169,7 +168,7 @@ module Capistrano
         # Load a recipe from the named file. If +name+ is given, the file will
         # be reported using that name.
         def load_from_file(file, name=nil)
-          file = find_file_in_load_path(file) unless file[0] == ?/
+          file = find_file_in_load_path(file) unless File.file?(file)
           load :string => File.read(file), :name => name || file
         end
 

data/lib/capistrano/recipes/deploy.rb

@@ -89,13 +89,43 @@ ensure
   ENV[name] = saved
 end
 
+# If a command is given, this will try to execute the given command, as
+# described below. Otherwise, it will return a string for use in embedding in
+# another command, for executing that command as described below.
+#
 # If :run_method is :sudo (or :use_sudo is true), this executes the given command
-# via +sudo+. Otherwise is uses +run+. Further, if sudo is being used and :runner
-# is set, the command will be executed as the user given by :runner.
-def try_sudo(command)
-  as = fetch(:runner, "app")
+# via +sudo+. Otherwise is uses +run+. If :as is given as a key, it will be
+# passed as the user to sudo as, if using sudo. If the :as key is not given,
+# it will default to whatever the value of the :admin_runner variable is,
+# which (by default) is unset.
+#
+# THUS, if you want to try to run something via sudo, and what to use the
+# root user, you'd just to try_sudo('something'). If you wanted to try_sudo as
+# someone else, you'd just do try_sudo('something', :as => "bob"). If you
+# always wanted sudo to run as a particular user, you could do 
+# set(:admin_runner, "bob").
+def try_sudo(*args)
+  options = args.last.is_a?(Hash) ? args.pop : {}
+  command = args.shift
+  raise ArgumentError, "too many arguments" if args.any?
+
+  as = options.fetch(:as, fetch(:admin_runner, nil))
   via = fetch(:run_method, :sudo)
-  invoke_command(command, :via => via, :as => as)
+  if command
+    invoke_command(command, :via => via, :as => as)
+  elsif via == :sudo
+    sudo(:as => as)
+  else
+    ""
+  end
+end
+
+# Same as sudo, but tries sudo with :as set to the value of the :runner
+# variable (which defaults to "app").
+def try_runner(*args)
+  options = args.last.is_a?(Hash) ? args.pop : {}
+  args << options.merge(:as => fetch(:runner, "app"))
+  try_sudo(*args)
 end
 
 # =========================================================================
@@ -131,7 +161,7 @@ namespace :deploy do
   task :setup, :except => { :no_release => true } do
     dirs = [deploy_to, releases_path, shared_path]
     dirs += %w(system log pids).map { |d| File.join(shared_path, d) }
-    try_sudo "umask 02 && mkdir -p #{dirs.join(' ')}"
+    run "#{try_sudo} mkdir -p #{dirs.join(' ')} && #{try_sudo} chmod g+w #{dirs.join(' ')}"
   end
 
   desc <<-DESC
@@ -178,7 +208,9 @@ namespace :deploy do
     symlinks to the shared directory for the log, system, and tmp/pids \
     directories, and will lastly touch all assets in public/images, \
     public/stylesheets, and public/javascripts so that the times are \
-    consistent (so that asset timestamping works).
+    consistent (so that asset timestamping works).  This touch process \
+    is only carried out if the :normalize_asset_timestamps variable is \
+    set to true, which is the default.
   DESC
   task :finalize_update, :except => { :no_release => true } do
     run "chmod -R g+w #{latest_release}" if fetch(:group_writable, true)
@@ -194,9 +226,11 @@ namespace :deploy do
       ln -s #{shared_path}/pids #{latest_release}/tmp/pids
     CMD
 
-    stamp = Time.now.utc.strftime("%Y%m%d%H%M.%S")
-    asset_paths = %w(images stylesheets javascripts).map { |p| "#{latest_release}/public/#{p}" }.join(" ")
-    run "find #{asset_paths} -exec touch -t #{stamp} {} ';'; true", :env => { "TZ" => "UTC" }
+    if fetch(:normalize_asset_timestamps, true)
+      stamp = Time.now.utc.strftime("%Y%m%d%H%M.%S")
+      asset_paths = %w(images stylesheets javascripts).map { |p| "#{latest_release}/public/#{p}" }.join(" ")
+      run "find #{asset_paths} -exec touch -t #{stamp} {} ';'; true", :env => { "TZ" => "UTC" }
+    end
   end
 
   desc <<-DESC
@@ -223,24 +257,19 @@ namespace :deploy do
     To use this task, specify the files and directories you want to copy as a \
     comma-delimited list in the FILES environment variable. All directories \
     will be processed recursively, with all files being pushed to the \
-    deployment servers. Any file or directory starting with a '.' character \
-    will be ignored.
+    deployment servers.
 
       $ cap deploy:upload FILES=templates,controller.rb
+
+    Dir globs are also supported:
+
+      $ cap deploy:upload FILES='config/apache/*.conf'
   DESC
   task :upload, :except => { :no_release => true } do
-    files = (ENV["FILES"] || "").
-      split(",").
-      map { |f| f.strip!; File.directory?(f) ? Dir["#{f}/**/*"] : f }.
-      flatten.
-      reject { |f| File.directory?(f) || File.basename(f)[0] == ?. }
+    files = (ENV["FILES"] || "").split(",").map { |f| Dir[f.strip] }.flatten
+    abort "Please specify at least one file or directory to update (via the FILES environment variable)" if files.empty?
 
-    abort "Please specify at least one file to update (via the FILES environment variable)" if files.empty?
-
-    files.each do |file|
-      content = File.open(file, "rb") { |f| f.read }
-      put content, File.join(current_path, file)
-    end
+    files.each { |file| top.upload(file, File.join(current_path, file)) }
   end
 
   desc <<-DESC
@@ -255,7 +284,7 @@ namespace :deploy do
       set :use_sudo, false
   DESC
   task :restart, :roles => :app, :except => { :no_release => true } do
-    try_sudo "#{current_path}/script/process/reaper"
+    try_runner "#{current_path}/script/process/reaper"
   end
 
   desc <<-DESC
@@ -413,7 +442,7 @@ namespace :deploy do
     the :use_sudo variable to false.
   DESC
   task :start, :roles => :app do
-    try_sudo "sh -c 'cd #{current_path} && nohup script/spin'"
+    run "cd #{current_path} && #{try_runner} nohup script/spin"
   end
 
   desc <<-DESC
@@ -428,8 +457,8 @@ namespace :deploy do
     the :use_sudo variable to false.
   DESC
   task :stop, :roles => :app do
-    try_sudo "if [ -f #{current_path}/tmp/pids/dispatch.spawner.pid ]; then #{current_path}/script/process/reaper -a kill -r dispatch.spawner.pid; fi"
-    try_sudo "#{current_path}/script/process/reaper -a kill"
+    run "if [ -f #{current_path}/tmp/pids/dispatch.spawner.pid ]; then #{try_runner} #{current_path}/script/process/reaper -a kill -r dispatch.spawner.pid; fi"
+    try_runner "#{current_path}/script/process/reaper -a kill"
   end
 
   namespace :pending do