capistrano 2.0.0 → 2.15.9

data/lib/capistrano/configuration/connections.rb

@@ -1,5 +1,7 @@
-require 'capistrano/gateway'
+require 'enumerator'
+require 'net/ssh/gateway'
 require 'capistrano/ssh'
+require 'capistrano/errors'
 
 module Capistrano
   class Configuration
@@ -9,8 +11,6 @@ module Capistrano
         base.send :alias_method, :initialize, :initialize_with_connections
       end
 
-      # An adaptor for making the SSH interface look and act like that of the
-      # Gateway class.
       class DefaultConnectionFactory #:nodoc:
         def initialize(options)
           @options = options
@@ -21,27 +21,76 @@ module Capistrano
         end
       end
 
+      class GatewayConnectionFactory #:nodoc:
+        def initialize(gateway, options)
+          @options = options
+          Thread.abort_on_exception = true
+          @gateways = {}
+          if gateway.is_a?(Hash)
+            @options[:logger].debug "Creating multiple gateways using #{gateway.inspect}" if @options[:logger]
+            gateway.each do |gw, hosts|
+              gateway_connection = add_gateway(gw)
+              [*hosts].each do |host|
+                @gateways[:default] ||= gateway_connection
+                @gateways[host] = gateway_connection
+              end
+            end
+          else
+            @options[:logger].debug "Creating gateway using #{[*gateway].join(', ')}" if @options[:logger]
+            @gateways[:default] = add_gateway(gateway)
+          end
+        end
+
+        def add_gateway(gateway)
+          gateways = [*gateway].collect { |g| ServerDefinition.new(g) }
+          tunnel = SSH.connection_strategy(gateways[0], @options) do |host, user, connect_options|
+            Net::SSH::Gateway.new(host, user, connect_options)
+          end
+          (gateways[1..-1]).inject(tunnel) do |tunnel, destination|
+            @options[:logger].debug "Creating tunnel to #{destination}" if @options[:logger]
+            local_host = ServerDefinition.new("127.0.0.1", :user => destination.user, :port => tunnel.open(destination.host, (destination.port || 22)))
+            SSH.connection_strategy(local_host, @options) do |host, user, connect_options|
+              Net::SSH::Gateway.new(host, user, connect_options)
+            end
+          end
+        end
+
+        def connect_to(server)
+          @options[:logger].debug "establishing connection to `#{server}' via gateway" if @options[:logger]
+          local_host = ServerDefinition.new("127.0.0.1", :user => server.user, :port => gateway_for(server).open(server.host, server.port || 22))
+          session = SSH.connect(local_host, @options)
+          session.xserver = server
+          session
+        end
+
+        def gateway_for(server)
+          @gateways[server.host] || @gateways[:default]
+        end
+      end
+
       # A hash of the SSH sessions that are currently open and available.
       # Because sessions are constructed lazily, this will only contain
       # connections to those servers that have been the targets of one or more
-      # executed tasks.
-      attr_reader :sessions
+      # executed tasks. Stored on a per-thread basis to improve thread-safety.
+      def sessions
+        Thread.current[:sessions] ||= {}
+      end
 
       def initialize_with_connections(*args) #:nodoc:
         initialize_without_connections(*args)
-        @sessions = {}
-        @failed_sessions = []
+        Thread.current[:sessions] = {}
+        Thread.current[:failed_sessions] = []
       end
 
       # Indicate that the given server could not be connected to.
       def failed!(server)
-        @failed_sessions << server
+        Thread.current[:failed_sessions] << server
       end
 
       # Query whether previous connection attempts to the given server have
       # failed.
       def has_failed?(server)
-        @failed_sessions.include?(server)
+        Thread.current[:failed_sessions].include?(server)
       end
 
       # Used to force connections to be made to the current task's servers.
@@ -57,9 +106,9 @@ module Capistrano
       # establish connections to servers defined via ServerDefinition objects.
       def connection_factory
         @connection_factory ||= begin
-          if exists?(:gateway)
-            logger.debug "establishing connection to gateway `#{fetch(:gateway)}'"
-            Gateway.new(ServerDefinition.new(fetch(:gateway)), self)
+          if exists?(:gateway) && !fetch(:gateway).nil? && !fetch(:gateway).empty?
+            logger.debug "establishing connection to gateway `#{fetch(:gateway).inspect}'"
+            GatewayConnectionFactory.new(fetch(:gateway), self)
           else
             DefaultConnectionFactory.new(self)
           end
@@ -70,22 +119,13 @@ module Capistrano
       def establish_connections_to(servers)
         failed_servers = []
 
-        # This attemps to work around the problem where SFTP uploads hang
-        # for some people. A bit of investigating seemed to reveal that the
-        # hang only occurred when the SSH connections were established async,
-        # so this setting allows people to at least work around the problem.
-        if fetch(:synchronous_connect, false)
-          logger.trace "synchronous_connect: true"
-          Array(servers).each { |server| safely_establish_connection_to(server, failed_servers) }
-        else
-          # force the connection factory to be instantiated synchronously,
-          # otherwise we wind up with multiple gateway instances, because
-          # each connection is done in parallel.
-          connection_factory
+        # force the connection factory to be instantiated synchronously,
+        # otherwise we wind up with multiple gateway instances, because
+        # each connection is done in parallel.
+        connection_factory
 
-          threads = Array(servers).map { |server| establish_connection_to(server, failed_servers) }
-          threads.each { |t| t.join }
-        end
+        threads = Array(servers).map { |server| establish_connection_to(server, failed_servers) }
+        threads.each { |t| t.join }
 
         if failed_servers.any?
           errors = failed_servers.map { |h| "#{h[:server]} (#{h[:error].class}: #{h[:error].message})" }
@@ -95,47 +135,83 @@ module Capistrano
         end
       end
 
-      # Determines the set of servers within the current task's scope and
-      # establishes connections to them, and then yields that list of
-      # servers.
-      def execute_on_servers(options={})
-        raise ArgumentError, "expected a block" unless block_given?
+      # Destroys sessions for each server in the list.
+      def teardown_connections_to(servers)
+        servers.each do |server|
+          begin
+            session = sessions.delete(server)
+            session.close if session
+          rescue IOError, Net::SSH::Disconnect
+            # the TCP connection is already dead
+          end
+        end
+      end
 
+      # Determines the set of servers within the current task's scope
+      def filter_servers(options={})
         if task = current_task
           servers = find_servers_for_task(task, options)
 
           if servers.empty?
-            raise Capistrano::NoMatchingServersError, "`#{task.fully_qualified_name}' is only run for servers matching #{task.options.inspect}, but no servers matched"
+            if ENV['HOSTFILTER'] || ENV['HOSTROLEFILTER'] || task.options.merge(options)[:on_no_matching_servers] == :continue
+              logger.info "skipping `#{task.fully_qualified_name}' because no servers matched"
+            else
+              unless dry_run
+                raise Capistrano::NoMatchingServersError, "`#{task.fully_qualified_name}' is only run for servers matching #{task.options.inspect}, but no servers matched"
+              end
+            end
           end
 
           if task.continue_on_error?
             servers.delete_if { |s| has_failed?(s) }
-            return if servers.empty?
           end
         else
           servers = find_servers(options)
-          raise Capistrano::NoMatchingServersError, "no servers found to match #{options.inspect}" if servers.empty?
+          if servers.empty? && !dry_run
+            raise Capistrano::NoMatchingServersError, "no servers found to match #{options.inspect}" if options[:on_no_matching_servers] != :continue
+          end
         end
 
         servers = [servers.first] if options[:once]
+        [task, servers.compact]
+      end
+
+      # Determines the set of servers within the current task's scope and
+      # establishes connections to them, and then yields that list of
+      # servers.
+      def execute_on_servers(options={})
+        raise ArgumentError, "expected a block" unless block_given?
+
+        task, servers = filter_servers(options)
+        return if servers.empty?
         logger.trace "servers: #{servers.map { |s| s.host }.inspect}"
 
-        # establish connections to those servers, as necessary
-        begin
-          establish_connections_to(servers)
-        rescue ConnectionError => error
-          raise error unless task && task.continue_on_error?
-          error.hosts.each do |h|
-            servers.delete(h)
-            failed!(h)
+        max_hosts = (options[:max_hosts] || (task && task.max_hosts) || servers.size).to_i
+        is_subset = max_hosts < servers.size
+
+        # establish connections to those servers in groups of max_hosts, as necessary
+        servers.each_slice(max_hosts) do |servers_slice|
+          begin
+            establish_connections_to(servers_slice)
+          rescue ConnectionError => error
+            raise error unless task && task.continue_on_error?
+            error.hosts.each do |h|
+              servers_slice.delete(h)
+              failed!(h)
+            end
+          end
+
+          begin
+            yield servers_slice
+          rescue RemoteError => error
+            raise error unless task && task.continue_on_error?
+            error.hosts.each { |h| failed!(h) }
           end
-        end
 
-        begin
-          yield servers
-        rescue RemoteError => error
-          raise error unless task && task.continue_on_error?
-          error.hosts.each { |h| failed!(h) }
+          # if dealing with a subset (e.g., :max_hosts is less than the
+          # number of servers available) teardown the subset of connections
+          # that were just made, so that we can make room for the next subset.
+          teardown_connections_to(servers_slice) if is_subset
         end
       end
 
@@ -145,11 +221,13 @@ module Capistrano
         # prevents problems with the thread's scope seeing the wrong 'server'
         # variable if the thread just happens to take too long to start up.
         def establish_connection_to(server, failures=nil)
-          Thread.new { safely_establish_connection_to(server, failures) }
+          current_thread = Thread.current
+          Thread.new { safely_establish_connection_to(server, current_thread, failures) }
         end
 
-        def safely_establish_connection_to(server, failures=nil)
-          sessions[server] ||= connection_factory.connect_to(server)
+        def safely_establish_connection_to(server, thread, failures=nil)
+          thread[:sessions] ||= {}
+          thread[:sessions][server] ||= connection_factory.connect_to(server)
         rescue Exception => err
           raise unless failures
           failures << { :server => server, :error => err }

data/lib/capistrano/configuration/execution.rb

@@ -8,22 +8,11 @@ module Capistrano
         base.send :alias_method, :initialize, :initialize_with_execution
       end
 
-      # The call stack of the tasks. The currently executing task may inspect
-      # this to see who its caller was. The current task is always the last
-      # element of this stack.
-      attr_reader :task_call_frames
-
-      # The stack of tasks that have registered rollback handlers within the
-      # current transaction. If this is nil, then there is no transaction
-      # that is currently active.
-      attr_reader :rollback_requests
-
       # A struct for representing a single instance of an invoked task.
       TaskCallFrame = Struct.new(:task, :rollback)
 
       def initialize_with_execution(*args) #:nodoc:
         initialize_without_execution(*args)
-        @task_call_frames = []
       end
       private :initialize_with_execution
 
@@ -32,6 +21,25 @@ module Capistrano
         !rollback_requests.nil?
       end
 
+      # The call stack of the tasks. The currently executing task may inspect
+      # this to see who its caller was. The current task is always the last
+      # element of this stack.
+      def task_call_frames
+        Thread.current[:task_call_frames] ||= []
+      end
+
+
+      # The stack of tasks that have registered rollback handlers within the
+      # current transaction. If this is nil, then there is no transaction
+      # that is currently active.
+      def rollback_requests
+        Thread.current[:rollback_requests]
+      end
+
+      def rollback_requests=(rollback_requests)
+        Thread.current[:rollback_requests] = rollback_requests
+      end
+
       # Invoke a set of tasks in a transaction. If any task fails (raises an
       # exception), all tasks executed within the transaction are inspected to
       # see if they have an associated on_rollback hook, and if so, that hook
@@ -44,14 +52,14 @@ module Capistrano
 
         logger.info "transaction: start"
         begin
-          @rollback_requests = []
+          self.rollback_requests = []
           yield
           logger.info "transaction: commit"
         rescue Object => e
           rollback!
           raise
         ensure
-          @rollback_requests = nil
+          self.rollback_requests = nil
         end
       end
 
@@ -60,8 +68,9 @@ module Capistrano
       # hook will be executed.
       def on_rollback(&block)
         if transaction?
+          # don't note a new rollback request if one has already been set
+          rollback_requests << task_call_frames.last unless task_call_frames.last.rollback
           task_call_frames.last.rollback = block
-          rollback_requests << task_call_frames.last
         end
       end
 
@@ -72,12 +81,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
@@ -98,6 +107,8 @@ module Capistrano
     protected
 
       def rollback!
+        return if Thread.current[:rollback_requests].nil?
+
         # throw the task back on the stack so that roles are properly
         # interpreted in the scope of the task in question.
         rollback_requests.reverse.each do |frame|
@@ -121,6 +132,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
+end

data/lib/capistrano/configuration/loading.rb

@@ -25,6 +25,28 @@ module Capistrano
         def instance=(config)
           Thread.current[:capistrano_configuration] = config
         end
+
+        # Used internally by Capistrano to track which recipes have been loaded
+        # via require, so that they may be successfully reloaded when require
+        # is called again.
+        def recipes_per_feature
+          @recipes_per_feature ||= {}
+        end
+
+        # Used internally to determine what the current "feature" being
+        # required is. This is used to track which files load which recipes
+        # via require.
+        def current_feature
+          Thread.current[:capistrano_current_feature]
+        end
+
+        # Used internally to specify the current file being required, so that
+        # any recipes loaded by that file can be remembered. This allows
+        # recipes loaded via require to be correctly reloaded in different
+        # Configuration instances in the same Ruby instance.
+        def current_feature=(feature)
+          Thread.current[:capistrano_current_feature] = feature
+        end
       end
 
       # The load paths used for locating recipe files.
@@ -33,6 +55,7 @@ module Capistrano
       def initialize_with_loading(*args) #:nodoc:
         initialize_without_loading(*args)
         @load_paths = [".", File.expand_path(File.join(File.dirname(__FILE__), "../recipes"))]
+        @loaded_features = []
       end
       private :initialize_with_loading
 
@@ -66,9 +89,11 @@ module Capistrano
           load_from_file(options[:file], options[:name])
 
         elsif options[:string]
+          remember_load(options) unless options[:reloading]
           instance_eval(options[:string], options[:name] || "<eval>")
 
         elsif options[:proc]
+          remember_load(options) unless options[:reloading]
           instance_eval(&options[:proc])
 
         else
@@ -80,12 +105,70 @@ module Capistrano
       # with the exception that it sets the receiver as the "current" configuration
       # so that third-party task bundles can include themselves relative to
       # that configuration.
+      #
+      # This is a bit more complicated than an initial review would seem to
+      # necessitate, but the use case that complicates things is this: An
+      # advanced user wants to embed capistrano, and needs to instantiate
+      # more than one capistrano configuration at a time. They also want each
+      # configuration to require a third-party capistrano extension. Using a
+      # naive require implementation, this would allow the first configuration
+      # to successfully load the third-party extension, but the require would
+      # fail for the second configuration because the extension has already
+      # been loaded.
+      #
+      # To work around this, we do a few things:
+      #
+      # 1. Each time a 'require' is invoked inside of a capistrano recipe,
+      #    we remember the arguments (see "current_feature").
+      # 2. Each time a 'load' is invoked inside of a capistrano recipe, and
+      #    "current_feature" is not nil (meaning we are inside of a pending
+      #    require) we remember the options (see "remember_load" and
+      #    "recipes_per_feature").
+      # 3. Each time a 'require' is invoked inside of a capistrano recipe,
+      #    we check to see if this particular configuration has ever seen these
+      #    arguments to require (see @loaded_features), and if not, we proceed
+      #    as if the file had never been required. If the superclass' require
+      #    returns false (meaning, potentially, that the file has already been
+      #    required), then we look in the recipes_per_feature collection and
+      #    load any remembered recipes from there.
+      #
+      # It's kind of a bear, but it works, and works transparently. Note that
+      # a simpler implementation would just muck with $", allowing files to be
+      # required multiple times, but that will cause warnings (and possibly
+      # errors) if the file to be required contains constant definitions and
+      # such, alongside (or instead of) capistrano recipe definitions.
       def require(*args) #:nodoc:
-        original, self.class.instance = self.class.instance, self
-        super
-      ensure
-        # restore the original, so that require's can be nested
-        self.class.instance = original
+        # look to see if this specific configuration instance has ever seen
+        # these arguments to require before
+        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
+
+          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
+
+      def file_in_load_path?(file)
+        begin
+          !!find_file_in_load_path(file)
+        rescue LoadError
+          false
+        end
       end
 
       private
@@ -93,7 +176,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
 
@@ -107,6 +190,16 @@ module Capistrano
 
           raise LoadError, "no such file to load -- #{file}"
         end
+
+        # If a file is being required, the options associated with loading a
+        # recipe are remembered in the recipes_per_feature archive under the
+        # name of the file currently being required.
+        def remember_load(options)
+          if self.class.current_feature
+            list = (self.class.recipes_per_feature[self.class.current_feature] ||= [])
+            list << options
+          end
+        end
     end
   end
 end

data/lib/capistrano/configuration/log_formatters.rb

@@ -0,0 +1,75 @@
+# Add custom log formatters
+#
+# Passing a hash or a array of hashes with custom log formatters.
+#
+# Add the following to your deploy.rb or in your ~/.caprc
+#
+# == Example:
+#
+#   capistrano_log_formatters = [
+#     { :match => /command finished/,       :color => :hide,      :priority => 10, :prepend => "$$$" },
+#     { :match => /executing command/,      :color => :blue,      :priority => 10, :style => :underscore, :timestamp => true },
+#     { :match => /^transaction: commit$/,  :color => :magenta,   :priority => 10, :style => :blink },
+#     { :match => /git/,                    :color => :white,     :priority => 20, :style => :reverse }
+#   ]
+#
+#   log_formatter capistrano_log_formatters
+#
+# You can call log_formatter multiple times, with either a hash or an array of hashes.
+#
+# == Colors:
+#
+# :color can have the following values:
+#
+# * :hide  (hides the row completely)
+# * :none
+# * :black
+# * :red
+# * :green
+# * :yellow
+# * :blue
+# * :magenta
+# * :cyan
+# * :white
+#
+# == Styles:
+#
+# :style can have the following values:
+#
+# * :bright
+# * :dim
+# * :underscore
+# * :blink
+# * :reverse
+# * :hidden
+#
+#
+#  == Text alterations
+#
+# :prepend gives static text to be prepended to the output
+# :replace replaces the matched text in the output
+# :timestamp adds the current time before the output
+
+module Capistrano
+  class Configuration
+    module LogFormatters
+      def log_formatter(options)
+        if options.class == Array
+          options.each do |option|
+            Capistrano::Logger.add_formatter(option)
+          end
+        else
+          Capistrano::Logger.add_formatter(options)
+        end
+      end
+
+      def default_log_formatters(formatters)
+        default_formatters = [*formatters]
+      end
+
+      def disable_log_formatters
+        @logger.disable_formatters = true
+      end
+    end
+  end
+end