capistrano 2.0.0 → 2.15.2

data/lib/capistrano/cli/ui.rb

@@ -22,7 +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.default = 'y'
+            q.validate = /(y(es)?)|(no?)|(a(bort)?|\n)/i
+            q.responses[:not_valid] = prompt
+          end
+        end
       end
     end
   end
-end
+end

data/lib/capistrano/cli.rb

@@ -17,17 +17,16 @@ module Capistrano
     # different set of parameters (such as when embedded cap in a program):
     #
     #   require 'capistrano/cli'
-    #   Capistrano::CLI.parse(%w(-vvvv -r config/deploy update_code)).execute!
+    #   Capistrano::CLI.parse(%W(-vvvv -f config/deploy update_code)).execute!
     #
     # Note that you can also embed cap directly by creating a new Configuration
-    # instance and setting it up, but you'll often wind up duplicating logic
-    # defined in the CLI class. The above snippet, redone using the Configuration
-    # class directly, would look like:
+    # instance and setting it up, The above snippet, redone using the
+    # Configuration class directly, would look like:
     #
     #   require 'capistrano'
     #   require 'capistrano/cli'
     #   config = Capistrano::Configuration.new
-    #   config.logger_level = Capistrano::Logger::TRACE
+    #   config.logger.level = Capistrano::Logger::TRACE
     #   config.set(:password) { Capistrano::CLI.password_prompt }
     #   config.load "config/deploy"
     #   config.update_code
@@ -43,5 +42,6 @@ module Capistrano
     # Mix-in the actual behavior
     include Execute, Options, UI
     include Help # needs to be included last, because it overrides some methods
+
   end
 end

data/lib/capistrano/command.rb

@@ -1,14 +1,143 @@
+require 'benchmark'
 require 'capistrano/errors'
+require 'capistrano/processable'
 
 module Capistrano
 
   # This class encapsulates a single command to be executed on a set of remote
   # machines, in parallel.
   class Command
-    attr_reader :command, :sessions, :options
+    include Processable
 
-    def self.process(command, sessions, options={}, &block)
-      new(command, sessions, options, &block).process!
+    class Tree
+      attr_reader :configuration
+      attr_reader :branches
+      attr_reader :fallback
+
+      include Enumerable
+
+      class Branch
+        attr_accessor :command, :callback, :condition
+        attr_reader :options
+
+        def initialize(command, options, callback)
+          @command = command.strip.gsub(/\r?\n/, "\\\n")
+          @callback = callback || Capistrano::Configuration.default_io_proc
+          @options = options
+          @skip = false
+        end
+
+        def last?
+          options[:last]
+        end
+
+        def skip?
+          @skip
+        end
+
+        def skip!
+          @skip = true
+        end
+
+        def match(server)
+          true
+        end
+
+        def to_s(parallel=false)
+          if parallel && @condition
+            "#{condition.inspect} :: #{command.inspect}"
+          else
+            command.inspect
+          end
+        end
+      end
+
+      class ConditionBranch < Branch
+        attr_accessor :configuration
+
+        class Evaluator
+          attr_reader :configuration, :condition, :server
+
+          def initialize(config, condition, server)
+            @configuration = config
+            @condition = condition
+            @server = server
+          end
+
+          def in?(role)
+            configuration.roles[role].include?(server)
+          end
+
+          def result
+            eval(condition, binding)
+          end
+
+          def method_missing(sym, *args, &block)
+            if server.respond_to?(sym)
+              server.send(sym, *args, &block)
+            elsif configuration.respond_to?(sym)
+              configuration.send(sym, *args, &block)
+            else
+              super
+            end
+          end
+        end
+
+        def initialize(configuration, condition, command, options, callback)
+          @configuration = configuration
+          @condition = condition
+          super(command, options, callback)
+        end
+
+        def match(server)
+          Evaluator.new(configuration, condition, server).result
+        end
+      end
+
+      class ElseBranch < Branch
+        def initialize(command, options, callback)
+          @condition = "else"
+          super(command, options, callback)
+        end
+      end
+
+      def initialize(config)
+        @configuration = config
+        @branches = []
+        yield self if block_given?
+      end
+
+      def when(condition, command, options={}, &block)
+        branches << ConditionBranch.new(configuration, condition, command, options, block)
+      end
+
+      def else(command, &block)
+        @fallback = ElseBranch.new(command, {}, block)
+      end
+
+      def branches_for(server)
+        seen_last = false
+        matches = branches.select do |branch|
+          success = !seen_last && !branch.skip? && branch.match(server)
+          seen_last = success && branch.last?
+          success
+        end
+
+        matches << fallback if matches.empty? && fallback
+        return matches
+      end
+
+      def each
+        branches.each { |branch| yield branch }
+        yield fallback if fallback
+        return self
+      end
+    end
+
+    attr_reader :tree, :sessions, :options
+
+    def self.process(tree, sessions, options={})
+      new(tree, sessions, options).process!
     end
 
     # Instantiates a new command object. The +command+ must be a string
@@ -20,11 +149,16 @@ module Capistrano
     # * +data+: (optional), a string to be sent to the command via it's stdin
     # * +env+: (optional), a string or hash to be interpreted as environment
     #   variables that should be defined for this command invocation.
-    def initialize(command, sessions, options={}, &block)
-      @command = command.strip.gsub(/\r?\n/, "\\\n")
+    def initialize(tree, sessions, options={}, &block)
+      if String === tree
+        tree = Tree.new(nil) { |t| t.else(tree, &block) }
+      elsif block
+        raise ArgumentError, "block given with tree argument"
+      end
+
+      @tree = tree
       @sessions = sessions
       @options = options
-      @callback = block
       @channels = open_channels
     end
 
@@ -32,29 +166,19 @@ module Capistrano
     # fails (non-zero return code) on any of the hosts, this will raise a
     # Capistrano::CommandError.
     def process!
-      since = Time.now
-      loop do
-        active = 0
-        @channels.each do |ch|
-          next if ch[:closed]
-          active += 1
-          ch.connection.process(true)
-        end
-
-        break if active == 0
-        if Time.now - since >= 1
-          since = Time.now
-          @channels.each { |ch| ch.connection.ping! }
+      elapsed = Benchmark.realtime do
+        loop do
+          break unless process_iteration { @channels.any? { |ch| !ch[:closed] } }
         end
-        sleep 0.01 # a brief respite, to keep the CPU from going crazy
       end
 
-      logger.trace "command finished" if logger
+      logger.trace "command finished in #{(elapsed * 1000).round}ms" if logger
 
       if (failed = @channels.select { |ch| ch[:status] != 0 }).any?
-        hosts = failed.map { |ch| ch[:server] }
-        error = CommandError.new("command #{command.inspect} failed on #{hosts.join(',')}")
-        error.hosts = hosts
+        commands = failed.inject({}) { |map, ch| (map[ch[:command]] ||= []) << ch[:server]; map }
+        message = commands.map { |command, list| "#{command.inspect} on #{list.join(',')}" }.join("; ")
+        error = CommandError.new("failed: #{message}")
+        error.hosts = commands.values.flatten
         raise error
       end
 
@@ -77,51 +201,84 @@ module Capistrano
 
       def open_channels
         sessions.map do |session|
-          session.open_channel do |channel|
-            server = session.xserver
-
-            channel[:server] = server
-            channel[:host] = server.host
-            channel[:options] = options
-            channel.request_pty :want_reply => true
-
-            channel.on_success do |ch|
-              logger.trace "executing command", ch[:server] if logger
-              escaped = replace_placeholders(command, ch).gsub(/[$\\`"]/) { |m| "\\#{m}" }
-              command_line = [environment, options[:shell] || "sh", "-c", "\"#{escaped}\""].compact.join(" ")
-              ch.exec(command_line)
-              ch.send_data(options[:data]) if options[:data]
-            end
+          server = session.xserver
+          tree.branches_for(server).map do |branch|
+            session.open_channel do |channel|
+              channel[:server] = server
+              channel[:host] = server.host
+              channel[:options] = options
+              channel[:branch] = branch
 
-            channel.on_failure do |ch|
-              # just log it, don't actually raise an exception, since the
-              # process method will see that the status is not zero and will
-              # raise an exception then.
-              logger.important "could not open channel", ch[:server] if logger
-              ch.close
-            end
+              request_pty_if_necessary(channel) do |ch, success|
+                if success
+                  logger.trace "executing command", ch[:server] if logger
+                  cmd = replace_placeholders(channel[:branch].command, ch)
 
-            channel.on_data do |ch, data|
-              @callback[ch, :out, data] if @callback
-            end
+                  if options[:shell] == false
+                    shell = nil
+                  else
+                    shell = "#{options[:shell] || "sh"} -c"
+                    cmd = cmd.gsub(/'/) { |m| "'\\''" }
+                    cmd = "'#{cmd}'"
+                  end
 
-            channel.on_extended_data do |ch, type, data|
-              @callback[ch, :err, data] if @callback
-            end
+                  command_line = [environment, shell, cmd].compact.join(" ")
+                  ch[:command] = command_line
 
-            channel.on_request do |ch, request, reply, data|
-              ch[:status] = data.read_long if request == "exit-status"
-            end
+                  ch.exec(command_line)
+                  ch.send_data(options[:data]) if options[:data]
+                  ch.eof! if options[:eof]
+                else
+                  # just log it, don't actually raise an exception, since the
+                  # process method will see that the status is not zero and will
+                  # raise an exception then.
+                  logger.important "could not open channel", ch[:server] if logger
+                  ch.close
+                end
+              end
+
+              channel.on_data do |ch, data|
+                ch[:branch].callback[ch, :out, data]
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                ch[:branch].callback[ch, :err, data]
+              end
+
+              channel.on_request("exit-status") do |ch, data|
+                ch[:status] = data.read_long
+              end
 
-            channel.on_close do |ch|
-              ch[:closed] = true
+              channel.on_request("exit-signal") do |ch, data|
+                if logger
+                  exit_signal = data.read_string
+                  logger.important "command received signal #{exit_signal}", ch[:server]
+                end
+              end
+
+              channel.on_close do |ch|
+                ch[:closed] = true
+              end
             end
           end
+        end.flatten
+      end
+
+      def request_pty_if_necessary(channel)
+        if options[:pty]
+          channel.request_pty do |ch, success|
+            yield ch, success
+          end
+        else
+          yield channel, true
         end
       end
 
       def replace_placeholders(command, channel)
-        command.gsub(/\$CAPISTRANO:HOST\$/, channel[:host])
+        roles = @tree.configuration && @tree.configuration.role_names_for_host(channel[:server])
+        command = command.gsub(/\$CAPISTRANO:HOST\$/, channel[:host])
+        command.gsub!(/\$CAPISTRANO:HOSTROLES\$/, roles.join(',')) if roles
+        command
       end
 
       # prepare a space-separated sequence of variables assignments

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

@@ -1,4 +1,4 @@
-require 'capistrano/upload'
+require 'capistrano/transfer'
 
 module Capistrano
   class Configuration
@@ -9,23 +9,38 @@ module Capistrano
         # by the current task. If <tt>:mode</tt> is specified it is used to
         # set the mode on the file.
         def put(data, path, options={})
-          execute_on_servers(options) do |servers|
-            targets = servers.map { |s| sessions[s] }
-            Upload.process(targets, path, :data => data, :mode => options[:mode], :logger => logger)
-          end
+          opts = options.dup
+          upload(StringIO.new(data), path, opts)
         end
-    
-        # Get file remote_path from FIRST server targetted by
+
+        # Get file remote_path from FIRST server targeted by
         # the current task and transfer it to local machine as path.
         #
         # get "#{deploy_to}/current/log/production.log", "log/production.log.web"
-        def get(remote_path, path, options = {})
-          execute_on_servers(options.merge(:once => true)) do |servers|
-            logger.info "downloading `#{servers.first.host}:#{remote_path}' to `#{path}'"
-            sftp = sessions[servers.first].sftp
-            sftp.connect unless sftp.state == :open
-            sftp.get_file remote_path, path
-            logger.debug "download finished" 
+        def get(remote_path, path, options={}, &block)
+          download(remote_path, path, options.merge(:once => true), &block)
+        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}", options
+          end
+        end
+
+        def download(from, to, options={}, &block)
+          transfer(:down, from, to, options, &block)
+        end
+
+        def transfer(direction, from, to, options={}, &block)
+          if dry_run
+            return logger.debug "transfering: #{[direction, from, to] * ', '}"
+          end
+          execute_on_servers(options) do |servers|
+            targets = servers.map { |s| sessions[s] }
+              Transfer.process(direction, from, to, targets, options.merge(:logger => logger), &block)
           end
         end
 

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

@@ -20,7 +20,7 @@ module Capistrano
         #     stream "tail -f #{shared_path}/log/fastcgi.crash.log"
         #   end
         def stream(command, options={})
-          invoke_command(command, options) do |ch, stream, out|
+          invoke_command(command, options.merge(:eof => !command.include?(sudo))) do |ch, stream, out|
             puts out if stream == :out
             warn "[err :: #{ch[:server]}] #{out}" if stream == :err
           end
@@ -31,10 +31,10 @@ module Capistrano
         # string. The command is invoked via #invoke_command.
         def capture(command, options={})
           output = ""
-          invoke_command(command, options.merge(:once => true)) do |ch, stream, data|
+          invoke_command(command, options.merge(:once => true, :eof => !command.include?(sudo))) do |ch, stream, data|
             case stream
             when :out then output << data
-            when :err then raise CaptureError, "error processing #{command.inspect}: #{data.inspect}"
+            when :err then warn "[err :: #{ch[:server]}] #{data}"
             end
           end
           output