Capistrano::Configuration::Connections

# File lib/capistrano/configuration/connections.rb, line 100
def connect!(options={})
  execute_on_servers(options) { }
end

# File lib/capistrano/configuration/connections.rb, line 107
def connection_factory
  @connection_factory ||= begin
    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
  end
end

# File lib/capistrano/configuration/connections.rb, line 119
def establish_connections_to(servers)
  failed_servers = []

  # 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 }

  if failed_servers.any?
    errors = failed_servers.map { |h| "#{h[:server]} (#{h[:error].class}: #{h[:error].message})" }
    error = ConnectionError.new("connection failed for: #{errors.join(', ')}")
    error.hosts = failed_servers.map { |h| h[:server] }
    raise error
  end
end

# File lib/capistrano/configuration/connections.rb, line 182
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}"

  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

    # 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

# File lib/capistrano/configuration/connections.rb, line 86
def failed!(server)
  Thread.current[:failed_sessions] << server
end

# File lib/capistrano/configuration/connections.rb, line 151
def filter_servers(options={})
  if task = current_task
    servers = find_servers_for_task(task, options)

    if servers.empty?
      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) }
    end
  else
    servers = find_servers(options)
    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

# File lib/capistrano/configuration/connections.rb, line 92
def has_failed?(server)
  Thread.current[:failed_sessions].include?(server)
end

# File lib/capistrano/configuration/connections.rb, line 75
def sessions
  Thread.current[:sessions] ||= {}
end

# File lib/capistrano/configuration/connections.rb, line 139
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