capistrano 2.0.0 → 2.15.2

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

@@ -23,6 +23,60 @@ module Capistrano
         def initialize_with_invocation(*args) #:nodoc:
           initialize_without_invocation(*args)
           set :default_environment, {}
+          set :default_run_options, {}
+        end
+
+        # Executes different commands in parallel. This is useful for commands
+        # that need to be different on different hosts, but which could be
+        # otherwise run in parallel.
+        #
+        # The +options+ parameter is currently unused.
+        #
+        # Example:
+        #
+        #   task :restart_everything do
+        #     parallel do |session|
+        #       session.when "in?(:app)", "/path/to/restart/mongrel"
+        #       session.when "in?(:web)", "/path/to/restart/apache"
+        #       session.when "in?(:db)", "/path/to/restart/mysql"
+        #     end
+        #   end
+        #
+        # Each command may have its own callback block, for capturing and
+        # responding to output, with semantics identical to #run:
+        #
+        #   session.when "in?(:app)", "/path/to/restart/mongrel" do |ch, stream, data|
+        #     # ch is the SSH channel for this command, used to send data
+        #     #    back to the command (e.g. ch.send_data("password\n"))
+        #     # stream is either :out or :err, for which stream the data arrived on
+        #     # data is a string containing data sent from the remote command
+        #   end
+        #
+        # Also, you can specify a fallback command, to use when none of the
+        # conditions match a server:
+        #
+        #   session.else "/execute/something/else"
+        #
+        # The string specified as the first argument to +when+ may be any valid
+        # Ruby code. It has access to the following variables and methods:
+        #
+        # * +in?(role)+ returns true if the server participates in the given role
+        # * +server+ is the ServerDefinition object for the server. This can be
+        #   used to get the host-name, etc.
+        # * +configuration+ is the current Capistrano::Configuration object, which
+        #   you can use to get the value of variables, etc.
+        #
+        # For example:
+        #
+        #   session.when "server.host =~ /app/", "/some/command"
+        #   session.when "server.host == configuration[:some_var]", "/another/command"
+        #   session.when "in?(:web) || in?(:app)", "/more/commands"
+        #
+        # See #run for a description of the valid +options+.
+        def parallel(options={})
+          raise ArgumentError, "parallel() requires a block" unless block_given?
+          tree = Command::Tree.new(self) { |t| yield t }
+          run_tree(tree, options)
         end
 
         # Invokes the given command. If a +via+ key is given, it will be used
@@ -41,37 +95,145 @@ module Capistrano
         # channel (which may be used to send data back to the remote process),
         # the stream identifier (<tt>:err</tt> for stderr, and <tt>:out</tt> for
         # stdout), and the data that was received.
+        #
+        # The +options+ hash may include any of the following keys:
+        #
+        # * :hosts - this is either a string (for a single target host) or an array
+        #   of strings, indicating which hosts the command should run on. By default,
+        #   the hosts are determined from the task definition.
+        # * :roles - this is either a string or symbol (for a single target role) or
+        #   an array of strings or symbols, indicating which roles the command should
+        #   run on. If :hosts is specified, :roles will be ignored.
+        # * :only - specifies a condition limiting which hosts will be selected to
+        #   run the command. This should refer to values set in the role definition.
+        #   For example, if a role is defined with :primary => true, then you could
+        #   select only hosts with :primary true by setting :only => { :primary => true }.
+        # * :except - specifies a condition limiting which hosts will be selected to
+        #   run the command. This is the inverse of :only (hosts that do _not_ match
+        #   the condition will be selected).
+        # * :on_no_matching_servers - if :continue, will continue to execute tasks if
+        #   no matching servers are found for the host criteria. The default is to raise
+        #   a NoMatchingServersError exception.
+        # * :once - if true, only the first matching server will be selected. The default
+        #   is false (all matching servers will be selected).
+        # * :max_hosts - specifies the maximum number of hosts that should be selected
+        #   at a time. If this value is less than the number of hosts that are selected
+        #   to run, then the hosts will be run in groups of max_hosts. The default is nil,
+        #   which indicates that there is no maximum host limit. Please note this does not
+        #   limit the number of SSH channels that can be open, only the number of hosts upon
+        #   which this will be called.
+        # * :shell - says which shell should be used to invoke commands. This
+        #   defaults to "sh". Setting this to false causes Capistrano to invoke
+        #   the commands directly, without wrapping them in a shell invocation.
+        # * :data - if not nil (the default), this should be a string that will
+        #   be passed to the command's stdin stream.
+        # * :pty - if true, a pseudo-tty will be allocated for each command. The
+        #   default is false. Note that there are benefits and drawbacks both ways.
+        #   Empirically, it appears that if a pty is allocated, the SSH server daemon
+        #   will _not_ read user shell start-up scripts (e.g. bashrc, etc.). However,
+        #   if a pty is _not_ allocated, some commands will refuse to run in
+        #   interactive mode and will not prompt for (e.g.) passwords.
+        # * :env - a hash of environment variable mappings that should be made
+        #   available to the command. The keys should be environment variable names,
+        #   and the values should be their corresponding values. The default is
+        #   empty, but may be modified by changing the +default_environment+
+        #   Capistrano variable.
+        # * :eof - if true, the standard input stream will be closed after sending
+        #   any data specified in the :data option. If false, the input stream is
+        #   left open. The default is to close the input stream only if no block is
+        #   passed.
+        #
+        # Note that if you set these keys in the +default_run_options+ Capistrano
+        # variable, they will apply for all invocations of #run, #invoke_command,
+        # and #parallel.
         def run(cmd, options={}, &block)
+          if options[:eof].nil? && !cmd.include?(sudo)
+            options = options.merge(:eof => !block_given?)
+          end
           block ||= self.class.default_io_proc
-          logger.debug "executing #{cmd.strip.inspect}"
+          tree = Command::Tree.new(self) { |t| t.else(cmd, &block) }
+          run_tree(tree, options)
+        end
 
+        # Executes a Capistrano::Command::Tree object. This is not for direct
+        # use, but should instead be called indirectly, via #run or #parallel,
+        # or #invoke_command.
+        def run_tree(tree, options={}) #:nodoc:
           options = add_default_command_options(options)
 
+          if tree.branches.any? || tree.fallback
+            _, servers = filter_servers(options)
+            branches = servers.map{|server| tree.branches_for(server)}.compact
+            case branches.size
+            when 0
+              branches = tree.branches.dup + [tree.fallback]
+              case branches.size
+              when 1
+                logger.debug "no servers for #{branches.first}"
+              else
+                logger.debug "no servers for commands"
+                branches.each{ |branch| logger.trace "-> #{branch.to_s(true)}" }
+              end
+            when 1
+              logger.debug "executing #{branches.first}" unless options[:silent]
+            else
+              logger.debug "executing multiple commands in parallel"
+              branches.each{ |branch| logger.trace "-> #{branch.to_s(true)}" }
+            end
+          else
+            raise ArgumentError, "attempt to execute without specifying a command"
+          end
+
+          return if dry_run || (debug && continue_execution(tree) == false)
+
+          tree.each do |branch|
+            if branch.command.include?(sudo)
+              branch.callback = sudo_behavior_callback(branch.callback)
+            end
+          end
+
           execute_on_servers(options) do |servers|
             targets = servers.map { |s| sessions[s] }
-            Command.process(cmd, targets, options.merge(:logger => logger), &block)
+            Command.process(tree, targets, options.merge(:logger => logger))
           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"
+        #
+        # 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.
         #
-        # Also, this module accepts a <tt>:sudo</tt> configuration variable,
+        #   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)
+        #
+        # If you know what you're doing, you can also set <tt>:sudo_prompt</tt>,
+        # which tells capistrano which prompt sudo should use when asking for
+        # a password. (This is so that capistrano knows what prompt to look for
+        # in the output.) If you set :sudo_prompt to an empty string, Capistrano
+        # will not send a preferred prompt.
+        def sudo(*parameters, &block)
+          options = parameters.last.is_a?(Hash) ? parameters.pop.dup : {}
+          command = parameters.first
+          user = options[:as] && "-u #{options.delete(:as)}"
 
-          user = as && "-u #{as}"
-          command = [fetch(:sudo, "sudo"), user, command].compact.join(" ")
+          sudo_prompt_option = "-p '#{sudo_prompt}'" unless sudo_prompt.empty?
+          sudo_command = [fetch(:sudo, "sudo"), sudo_prompt_option, user].compact.join(" ")
 
-          run(command, options, &sudo_behavior_callback(block))
+          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
@@ -83,17 +245,19 @@ module Capistrano
           # was wrong, let's track which host prompted first and only allow
           # subsequent prompts from that host.
           prompt_host = nil
-          
+
           Proc.new do |ch, stream, out|
-            if out =~ /password:/i
-              ch.send_data "#{self[:password]}\n"
-            elsif out =~ /try again/
+            if 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
+            end
+
+            if out =~ /^#{Regexp.escape(sudo_prompt)}/
+              ch.send_data "#{self[:password]}\n"
+            elsif fallback
               fallback.call(ch, stream, out)
             end
           end
@@ -110,18 +274,44 @@ module Capistrano
         #   Otherwise, if the :default_shell key exists in the configuration,
         #   it will be used. Otherwise, no :shell key is added.
         def add_default_command_options(options)
-          options = options.dup
+          defaults = self[:default_run_options]
+          options = defaults.merge(options)
 
           env = self[:default_environment]
           env = env.merge(options[:env]) if options[:env]
           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
+
+        # Returns the prompt text to use with sudo
+        def sudo_prompt
+          fetch(:sudo_prompt, "sudo password: ")
+        end
+
+        def continue_execution(tree)
+          if tree.branches.length == 1
+            continue_execution_for_branch(tree.branches.first)
+          else
+            tree.each { |branch| branch.skip! unless continue_execution_for_branch(branch) }
+            tree.any? { |branch| !branch.skip? }
+          end
+        end
+
+        def continue_execution_for_branch(branch)
+          case Capistrano::CLI.debug_prompt(branch)
+            when "y"
+              true
+            when "n"
+              false
+            when "a"
+              exit(-1)
+          end
+        end
       end
     end
   end
-end
+end

data/lib/capistrano/configuration/alias_task.rb

@@ -0,0 +1,26 @@
+module Capistrano
+  class Configuration
+    module AliasTask
+      # Attempts to find the task at the given fully-qualified path, and
+      # alias it. If arguments don't have correct task names, an ArgumentError
+      # wil be raised. If no such task exists, a Capistrano::NoSuchTaskError
+      # will be raised.
+      #
+      # Usage:
+      #
+      #   alias_task :original_deploy, :deploy
+      #
+      def alias_task(new_name, old_name)
+        if !new_name.respond_to?(:to_sym) or !old_name.respond_to?(:to_sym)
+          raise ArgumentError, "expected a valid task name"
+        end
+
+        original_task = find_task(old_name) or raise NoSuchTaskError, "the task `#{old_name}' does not exist"
+        task = original_task.dup # Dup. task to avoid modify original task
+        task.name = new_name
+
+        define_task(task)
+      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,19 +18,14 @@ module Capistrano
         @callbacks = {}
       end
 
-      def execute_task_with_callbacks(task) #:nodoc:
-        before = find_hook(task, :before)
-        execute_task(before) if before
+      def invoke_task_directly_with_callbacks(task) #:nodoc:
 
         trigger :before, task
 
-        result = execute_task_without_callbacks(task)
+        result = invoke_task_directly_without_callbacks(task)
 
         trigger :after, task
 
-        after = find_hook(task, :after)
-        execute_task(after) if after
-
         return result
       end
 
@@ -95,7 +90,7 @@ module Capistrano
       # Usage:
       #
       #  on :before, "some:hook", "another:hook", :only => "deploy:update"
-      #  on :after, "some:hook", :except => "deploy:symlink"
+      #  on :after, "some:hook", :except => "deploy:create_symlink"
       #  on :before, "global:hook"
       #  on :after, :only => :deploy do
       #    puts "after deploy here"
@@ -111,10 +106,28 @@ module Capistrano
         elsif block
           callbacks[event] << ProcCallback.new(block, options)
         else
-          args.each do |name|
-            callbacks[event] << TaskCallback.new(self, name, options)
-          end
+          args = filter_deprecated_tasks(args)
+          options[:only] = filter_deprecated_tasks(options[:only])
+          options[:except] = filter_deprecated_tasks(options[:except])
+
+          callbacks[event].concat(args.map { |name| TaskCallback.new(self, name, options) })
+        end
+      end
+
+      # Filters the given task name or names and attempts to replace deprecated tasks with their equivalents.
+      def filter_deprecated_tasks(names)
+        deprecation_msg = "[Deprecation Warning] This API has changed, please hook `deploy:create_symlink` instead of" \
+          " `deploy:symlink`."
+
+        if names == "deploy:symlink"
+          warn deprecation_msg
+          names = "deploy:create_symlink"
+        elsif names.is_a?(Array) && names.include?("deploy:symlink")
+          warn deprecation_msg
+          names = names.map { |name| name == "deploy:symlink" ? "deploy:create_symlink" : name }
         end
+
+        names
       end
 
       # Trigger the named event for the named task. All associated callbacks
@@ -129,20 +142,6 @@ module Capistrano
         end
       end
 
-      private
-
-        # Looks for before_foo or after_foo tasks. This method of extending tasks
-        # is now discouraged (though not formally deprecated). You should use the
-        # before and after methods to declare hooks for such callbacks.
-        def find_hook(task, hook)
-          if task == task.namespace.default_task
-            result = task.namespace.search_task("#{hook}_#{task.namespace.name}")
-            return result if result
-          end
-
-          task.namespace.search_task("#{hook}_#{task.name}")
-        end
-
     end
   end
-end
+end

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'] || 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 }