@@ -9,17 +9,27 @@ module Capistrano include Processable class Tree + attr_reader :configuration attr_reader :branches + attr_reader :fallback + + include Enumerable class Branch attr_accessor :command, :callback + attr_reader :options - def initialize(command, callback) + 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 @@ -37,38 +47,83 @@ module Capistrano end end - class PatternBranch < Branch - attr_accessor :pattern + class ConditionBranch < Branch + attr_accessor :configuration + attr_accessor :condition + + 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(pattern, command, callback) - @pattern = pattern - super(command, callback) + def initialize(configuration, condition, command, options, callback) + @configuration = configuration + @condition = condition + super(command, options, callback) end def match(server) - pattern === server.host + Evaluator.new(configuration, condition, server).result end def to_s - "#{pattern.inspect} :: #{command.inspect}" + "#{condition.inspect} :: #{command.inspect}" end end - def initialize + def initialize(config) + @configuration = config @branches = [] yield self if block_given? end - def if(pattern, command, &block) - branches << PatternBranch.new(pattern, command, block) + def when(condition, command, options={}, &block) + branches << ConditionBranch.new(configuration, condition, command, options, block) end def else(command, &block) - branches << Branch.new(command, block) + @fallback = Branch.new(command, {}, block) end - def branch_for(server) - branches.detect { |branch| branch.match(server) } + 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 @@ -131,58 +186,57 @@ module Capistrano def open_channels sessions.map do |session| server = session.xserver - branch = tree.branch_for(server) - next if branch.skip? - - session.open_channel do |channel| - channel[:server] = server - channel[:host] = server.host - channel[:options] = options - channel[:branch] = branch - - 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) - - if options[:shell] == false - shell = nil + 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 + + 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) + + if options[:shell] == false + shell = nil + else + shell = "#{options[:shell] || "sh"} -c" + cmd = cmd.gsub(/[$\\`"]/) { |m| "\\#{m}" } + cmd = "\"#{cmd}\"" + end + + command_line = [environment, shell, cmd].compact.join(" ") + + ch.exec(command_line) + ch.send_data(options[:data]) if options[:data] else - shell = "#{options[:shell] || "sh"} -c" - cmd = cmd.gsub(/[$\\`"]/) { |m| "\\#{m}" } - cmd = "\"#{cmd}\"" + # 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 - - command_line = [environment, shell, cmd].compact.join(" ") - - ch.exec(command_line) - ch.send_data(options[:data]) if options[:data] - 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_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_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_request("exit-status") do |ch, data| + ch[:status] = data.read_long + end - channel.on_close do |ch| - ch[:closed] = true + channel.on_close do |ch| + ch[:closed] = true + end end end - end.compact + end.flatten end def request_pty_if_necessary(channel) lib/capistrano/command.rb @@ -28,7 +28,7 @@ module Capistrano def parallel(options={}) raise ArgumentError, "parallel() requires a block" unless block_given? - tree = Command::Tree.new { |t| yield t } + tree = Command::Tree.new(self) { |t| yield t } run_tree(tree) end @@ -50,7 +50,7 @@ module Capistrano # stdout), and the data that was received. def run(cmd, options={}, &block) block ||= self.class.default_io_proc - tree = Command::Tree.new { |t| t.else(cmd, block) } + tree = Command::Tree.new(self) { |t| t.else(cmd, block) } run_tree(tree, options) end @@ -59,7 +59,7 @@ module Capistrano logger.debug "executing #{tree.branches.first}" else logger.debug "executing multiple commands in parallel" - tree.branches.each do |branch| + tree.each do |branch| logger.trace "-> #{branch}" end end @@ -169,8 +169,8 @@ module Capistrano if tree.branches.length == 1 continue_execution_for_branch(tree.branches.first) else - tree.branches.each { |branch| branch.skip! unless continue_execution_for_branch(branch) } - tree.branches.any? { |branch| !branch.skip? } + tree.each { |branch| branch.skip! unless continue_execution_for_branch(branch) } + tree.any? { |branch| !branch.skip? } end end lib/capistrano/configuration/actions/invocation.rb @@ -38,6 +38,10 @@ module Capistrano @static_servers.clear end + def include?(server) + servers.include?(server) + end + protected # This is the combination of a block, a hash of options, and a cached value. lib/capistrano/role.rb c70fcd595e68f576002ba0b7d75e49872fba2447 Jamis Buck jamis@37signals.com http://github.com/jamis/capistrano/commit/c70e595c36ae7cd3f63c1212ddf566efe50e2b5d c70e595c36ae7cd3f63c1212ddf566efe50e2b5d 2008-08-21T09:59:35-07:00 2008-08-21T09:59:35-07:00 replace condition#if with when and made it support multiple matches by default. 37ae7ee59ba204ea8466f711c2071a58442adf67 Jamis Buck jamis@37signals.com