Class: Net::SSH::Multi::PendingConnection

### Home Classes Methods

### In Files

- lib/net/ssh/multi/pending_connection.rb

### Parent

Object

### Methods

- ::new
- #busy?
- #channels
- #close
- #listeners
- #open_channel
- #postprocess
- #preprocess
- #replace_with
- #send_global_request

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- Net
- Net::SSH
- Net::SSH::Multi
- Net::SSH::Multi::Channel
- Net::SSH::Multi::ChannelProxy
- Net::SSH::Multi::DynamicServer
- Net::SSH::Multi::PendingConnection
- Net::SSH::Multi::Server
- Net::SSH::Multi::ServerList
- Net::SSH::Multi::Session
- Net::SSH::Multi::SessionActions
- Net::SSH::Multi::Subsession
- Net::SSH::Multi::Version

No matching classes.

# Net::SSH::Multi::PendingConnection

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.

### Attributes

server[R]

The Net::SSH::Multi::Server object that "owns" this pending connection.

### Public Class Methods

new(server) click to toggle source

Instantiates a new pending connection for the given Net::SSH::Multi::Server object.

    # File lib/net/ssh/multi/pending_connection.rb, line 52
    def initialize(server)
      @server = server
      @recordings = []
    end

### Public Instance Methods

busy?(include_invisible=false) click to toggle source

Always returns `true`, so that the pending connection looks active until it can be truly opened and replaced with a real connection.

    # File lib/net/ssh/multi/pending_connection.rb, line 82
    def busy?(include_invisible=false)
      true
    end

channels() click to toggle source

Returns an empty array, since a pending connection cannot have any real channels.

    # File lib/net/ssh/multi/pending_connection.rb, line 92
    def channels
      []
    end

close() click to toggle source

Does nothing, except to make a pending connection quack like a real connection.

    # File lib/net/ssh/multi/pending_connection.rb, line 87
    def close
      self
    end

listeners() click to toggle source

Returns an empty hash, since a pending connection has no real listeners.

    # File lib/net/ssh/multi/pending_connection.rb, line 107
    def listeners
      {}
    end

open_channel(type="session", *extras, &on_confirm) click to toggle source

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.

    # File lib/net/ssh/multi/pending_connection.rb, line 67
    def open_channel(type="session", *extras, &on_confirm)
      channel = ChannelProxy.new(&on_confirm)
      @recordings << ChannelOpenRecording.new(type, extras, channel)
      return channel
    end

postprocess(readers, writers) click to toggle source

Returns `true`, and does nothing else.

    # File lib/net/ssh/multi/pending_connection.rb, line 102
    def postprocess(readers, writers)
      true
    end

preprocess() click to toggle source

Returns `true`, and does nothing else.

    # File lib/net/ssh/multi/pending_connection.rb, line 97
    def preprocess
      true
    end

replace_with(session) click to toggle source

Instructs the pending session to replay all of its recordings against the given `session`, and to then replace itself with the given session.

    # File lib/net/ssh/multi/pending_connection.rb, line 59
    def replace_with(session)
      @recordings.each { |recording| recording.replay_on(session) }
      @server.replace_session(session)
    end

send_global_request(type, *extra, &callback) click to toggle source

Records that a global request has been made. The request is not actually sent, and won't be until replace_with is called.

    # File lib/net/ssh/multi/pending_connection.rb, line 75
    def send_global_request(type, *extra, &callback)
      @recordings << SendGlobalRequestRecording.new(type, extra, callback)
      self
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.