/usr/lib/ruby/vendor_ruby/net/ssh/multi/pending_connection.rb is in ruby-net-ssh-multi 1.2.1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | require 'net/ssh/multi/channel_proxy'
module Net; module SSH; module Multi
# A PendingConnection instance mimics a Net::SSH::Connection::Session instance,
# without actually being an open connection to a server. It is used by
# Net::SSH::Multi::Session when a concurrent connection limit is in effect,
# so that a server can hang on to a "connection" that isn't really a connection.
#
# Any requests against this connection (like #open_channel or #send_global_request)
# are not actually sent, but are added to a list of recordings. When the real
# session is opened and replaces this pending connection, all recorded actions
# will be replayed against that session.
#
# You'll never need to initialize one of these directly, and (if all goes well!)
# should never even notice that one of these is in use. Net::SSH::Multi::Session
# will instantiate these as needed, and only when there is a concurrent
# connection limit.
class PendingConnection
# Represents a #open_channel action.
class ChannelOpenRecording #:nodoc:
attr_reader :type, :extras, :channel
def initialize(type, extras, channel)
@type, @extras, @channel = type, extras, channel
end
def replay_on(session)
real_channel = session.open_channel(type, *extras, &channel.on_confirm)
channel.delegate_to(real_channel)
end
end
# Represents a #send_global_request action.
class SendGlobalRequestRecording #:nodoc:
attr_reader :type, :extra, :callback
def initialize(type, extra, callback)
@type, @extra, @callback = type, extra, callback
end
def replay_on(session)
session.send_global_request(type, *extra, &callback)
end
end
# The Net::SSH::Multi::Server object that "owns" this pending connection.
attr_reader :server
# Instantiates a new pending connection for the given Net::SSH::Multi::Server
# object.
def initialize(server)
@server = server
@recordings = []
end
# Instructs the pending session to replay all of its recordings against the
# given +session+, and to then replace itself with the given session.
def replace_with(session)
@recordings.each { |recording| recording.replay_on(session) }
@server.replace_session(session)
end
# Records that a channel open request has been made, and returns a new
# Net::SSH::Multi::ChannelProxy object to represent the (as yet unopened)
# channel.
def open_channel(type="session", *extras, &on_confirm)
channel = ChannelProxy.new(&on_confirm)
@recordings << ChannelOpenRecording.new(type, extras, channel)
return channel
end
# Records that a global request has been made. The request is not actually
# sent, and won't be until #replace_with is called.
def send_global_request(type, *extra, &callback)
@recordings << SendGlobalRequestRecording.new(type, extra, callback)
self
end
# Always returns +true+, so that the pending connection looks active until
# it can be truly opened and replaced with a real connection.
def busy?(include_invisible=false)
true
end
# Does nothing, except to make a pending connection quack like a real connection.
def close
self
end
# Returns an empty array, since a pending connection cannot have any real channels.
def channels
[]
end
# Returns +true+, and does nothing else.
def preprocess
true
end
# Returns +true+, and does nothing else.
def postprocess(readers, writers)
true
end
# Returns an empty hash, since a pending connection has no real listeners.
def listeners
{}
end
end
end; end; end
|