/usr/lib/ruby/vendor_ruby/net/ssh/multi/channel.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 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 | module Net; module SSH; module Multi
# Net::SSH::Multi::Channel encapsulates a collection of Net::SSH::Connection::Channel
# instances from multiple different connections. It allows for operations to
# be performed on all contained channels, simultaneously, using an interface
# mostly identical to Net::SSH::Connection::Channel itself.
#
# You typically obtain a Net::SSH::Multi::Channel instance via
# Net::SSH::Multi::Session#open_channel or Net::SSH::Multi::Session#exec,
# though there is nothing stopping you from instantiating one yourself with
# a handful of Net::SSH::Connection::Channel objects (though they should be
# associated with connections managed by a Net::SSH::Multi::Session object
# for consistent behavior).
#
# channel = session.open_channel do |ch|
# # ...
# end
#
# channel.wait
class Channel
include Enumerable
# The Net::SSH::Multi::Session instance that controls this channel collection.
attr_reader :connection
# The collection of Net::SSH::Connection::Channel instances that this multi-channel aggregates.
attr_reader :channels
# A Hash of custom properties that may be set and queried on this object.
attr_reader :properties
# Instantiate a new Net::SSH::Multi::Channel instance, controlled by the
# given +connection+ (a Net::SSH::Multi::Session object) and wrapping the
# given +channels+ (Net::SSH::Connection::Channel instances).
#
# You will typically never call this directly; rather, you'll get your
# multi-channel references via Net::SSH::Multi::Session#open_channel and
# friends.
def initialize(connection, channels)
@connection = connection
@channels = channels
@properties = {}
end
# Iterate over each component channel object, yielding each in order to the
# associated block.
def each
@channels.each { |channel| yield channel }
end
# Retrieve the property (see #properties) with the given +key+.
#
# host = channel[:host]
def [](key)
@properties[key]
end
# Set the property (see #properties) with the given +key+ to the given
# +value+.
#
# channel[:visited] = true
def []=(key, value)
@properties[key] = value
end
# Perform an +exec+ command on all component channels. The block, if given,
# is passed to each component channel, so it will (potentially) be invoked
# once for every channel in the collection. The block will receive two
# parameters: the specific channel object being operated on, and a boolean
# indicating whether the exec succeeded or not.
#
# channel.exec "ls -l" do |ch, success|
# # ...
# end
#
# See the documentation in Net::SSH for Net::SSH::Connection::Channel#exec
# for more information on how to work with the callback.
def exec(command, &block)
channels.each { |channel| channel.exec(command, &block) }
self
end
# Perform a +request_pty+ command on all component channels. The block, if
# given, is passed to each component channel, so it will (potentially) be
# invoked once for every channel in the collection. The block will
# receive two parameters: the specific channel object being operated on,
# and a boolean indicating whether the pty request succeeded or not.
#
# channel.request_pty do |ch, success|
# # ...
# end
#
# See the documentation in Net::SSH for
# Net::SSH::Connection::Channel#request_pty for more information on how to
# work with the callback.
def request_pty(opts={}, &block)
channels.each { |channel| channel.request_pty(opts, &block) }
self
end
# Send the given +data+ to each component channel. It will be sent to the
# remote process, typically being received on the process' +stdin+ stream.
#
# channel.send_data "password\n"
def send_data(data)
channels.each { |channel| channel.send_data(data) }
self
end
# Returns true as long as any of the component channels are active.
#
# connection.loop { channel.active? }
def active?
channels.any? { |channel| channel.active? }
end
# Runs the connection's event loop until the channel is no longer active
# (see #active?).
#
# channel.exec "something"
# channel.wait
def wait
connection.loop { active? }
self
end
# Closes all component channels.
def close
channels.each { |channel| channel.close }
self
end
# Tells the remote process for each component channel not to expect any
# further data from this end of the channel.
def eof!
channels.each { |channel| channel.eof! }
self
end
# Registers a callback on all component channels, to be invoked when the
# remote process emits data (usually on its +stdout+ stream). The block
# will be invoked with two arguments: the specific channel object, and the
# data that was received.
#
# channel.on_data do |ch, data|
# puts "got data: #{data}"
# end
def on_data(&block)
channels.each { |channel| channel.on_data(&block) }
self
end
# Registers a callback on all component channels, to be invoked when the
# remote process emits "extended" data (typically on its +stderr+ stream).
# The block will be invoked with three arguments: the specific channel
# object, an integer describing the data type (usually a 1 for +stderr+)
# and the data that was received.
#
# channel.on_extended_data do |ch, type, data|
# puts "got extended data: #{data}"
# end
def on_extended_data(&block)
channels.each { |channel| channel.on_extended_data(&block) }
self
end
# Registers a callback on all component channels, to be invoked during the
# idle portion of the connection event loop. The callback will be invoked
# with one argument: the specific channel object being processed.
#
# channel.on_process do |ch|
# # ...
# end
def on_process(&block)
channels.each { |channel| channel.on_process(&block) }
self
end
# Registers a callback on all component channels, to be invoked when the
# remote server terminates the channel. The callback will be invoked
# with one argument: the specific channel object being closed.
#
# channel.on_close do |ch|
# # ...
# end
def on_close(&block)
channels.each { |channel| channel.on_close(&block) }
self
end
# Registers a callback on all component channels, to be invoked when the
# remote server has no further data to send. The callback will be invoked
# with one argument: the specific channel object being marked EOF.
#
# channel.on_eof do |ch|
# # ...
# end
def on_eof(&block)
channels.each { |channel| channel.on_eof(&block) }
self
end
# Registers a callback on all component channels, to be invoked when the
# remote server is unable to open the channel. The callback will be
# invoked with three arguments: the channel object that couldn't be
# opened, a description of the error (as a string), and an integer code
# representing the error.
#
# channel.on_open_failed do |ch, description, code|
# # ...
# end
def on_open_failed(&block)
channels.each { |channel| channel.on_open_failed(&block) }
self
end
# Registers a callback on all component channels, to be invoked when the
# remote server sends a channel request of the given +type+. The callback
# will be invoked with two arguments: the specific channel object receiving
# the request, and a Net::SSH::Buffer instance containing the request-specific
# data.
#
# channel.on_request("exit-status") do |ch, data|
# puts "exited with #{data.read_long}"
# end
def on_request(type, &block)
channels.each { |channel| channel.on_request(type, &block) }
self
end
end
end; end; end
|