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
|
