Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Rice Pastry API
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## rice.pastry.socket
Class SocketCollectionManager

    java.lang.Object
      rice.selector.SelectionKeyHandler
          rice.pastry.socket.SocketCollectionManager

    public class SocketCollectionManager

extends SelectionKeyHandler

Class which maintains all outgoing open sockets. It is responsible for keeping only MAX_OPEN_SOCKETS number of client sockets open at once. It also binds a ServerSocketChannel to the specified port and listens for incoming connections. Once a connections is established, it uses the interal SocketConnector to read the greeting message (HelloMessage) off of the stream, and hands the connection off to the appropriate node handle.

Version:
  $Id: SocketCollectionManager.java,v 1.3 2004/03/08 19:53:57 amislove Exp $
Author:
  Alan Mislove

Nested Class Summary
`protected class` | `SocketCollectionManager.DeadChecker` DESCRIBE THE CLASS
`protected class` | `SocketCollectionManager.MessageRetry` Internal class which represents a message which is currently delayed, waiting for an open socket.
`protected class` | `SocketCollectionManager.SocketAccepter` Internal class which reads the greeting message off of a newly-accepted socket.
`protected class` | `SocketCollectionManager.SourceRouteManager` Private class which is tasked with maintaining a source route which goes through this node.

Field Summary
`java.util.LinkedList` | `appSockets`
`long` | `BACKOFF_INITIAL`
`int` | `BACKOFF_LIMIT`
`static byte[]` | `HEADER_DIRECT`
`static int` | `HEADER_SIZE`
`protected static byte[]` | `HEADER_SOURCE_ROUTE`
`protected Logger` | `logger`
`int` | `MAX_OPEN_SOCKETS`
`int` | `MAX_OPEN_SOURCE_ROUTES`
`int` | `NUM_PING_TRIES`
`static byte[]` | `PASTRY_MAGIC_NUMBER`
`int` | `PING_DELAY`
`float` | `PING_JITTER`
`protected RandomSource` | `random`
`int` | `SOCKET_BUFFER_SIZE`
`java.util.Hashtable` | `sockets`
`static int` | `TOTAL_HEADER_SIZE`
`int` | `WRITE_WAIT_TIME`

Constructor Summary
`SocketCollectionManager(SocketPastryNode node, SocketSourceRouteManager manager, EpochInetSocketAddress bindAddress, EpochInetSocketAddress proxyAddress, RandomSource random)` Constructs a new SocketManager.

Method Summary
`void` | `accept(java.nio.channels.SelectionKey key)` Specified by the SelectionKeyHandler interface.
`protected void` | `appSocketClosed(SocketAppSocket sas)` Method which is designed to be called *ONCE THE SOCKET HAS BEEN CLOSED*.
`protected void` | `appSocketOpened(SocketAppSocket sas)`
`void` | `bootstrap(SourceRoute path, Message message)` Method which sends bootstraps a node by sending message across the wire, using a fake IP address in the header so that the local node is not marked alive, and then closes the connection.
`protected void` | `checkLiveness(SourceRoute path)` Initiates a liveness test on the given address, if the remote node does not respond, it is declared dead.
`protected void` | `closeOneSocket()` TODO: Add also checking the top of the AppSocketQueue
`protected void` | `closeSocket(SourceRoute path)` Method which cloeses a socket to a given remote node handle, and updates the bookkeeping to keep track of this closing.
`void` | `connect(SourceRoute path, int appId, AppSocketReceiver receiver, int timeout)` Method which sends a message across the wire.
`void` | `declaredDead(EpochInetSocketAddress address)` Method which should be called when a remote node is declared dead.
`void` | `destroy()` Makes this node resign from the network.
`int` | `getNumSockets()`
`int` | `getNumSourceRoutes()`
`PingManager` | `getPingManager()` Method which returns the internal PingManager
`protected SourceRoute` | `getSocketToClose()` Internal method which returns the next socket to be closed
`boolean` | `isOpen(SourceRoute route)` Returns whether or not a socket is currently open to the given route
`protected void` | `openAppSocket(SourceRoute path, int appId, AppSocketReceiver connector, int timeout)` Method which opens a socket to a given remote node handle, and updates the bookkeeping to keep track of this socket
`protected void` | `openSocket(SourceRoute path, boolean bootstrap)` Method which opens a socket to a given remote node handle, and updates the bookkeeping to keep track of this socket
`void` | `ping(SourceRoute route)` Method which suggests a ping to the remote node.
`void` | `send(SourceRoute path, SocketBuffer message, SocketSourceRouteManager.AddressManager am)` Method which sends a message across the wire.
`protected boolean` | `sendInternal(SourceRoute path, SocketBuffer message)` Method which sends a message across the wire.
`protected void` | `socketClosed(SourceRoute path, rice.pastry.socket.SocketManager manager)` Method which is designed to be called *ONCE THE SOCKET HAS BEEN CLOSED*.
`protected void` | `socketOpened(SourceRoute path, rice.pastry.socket.SocketManager manager)` Method which is designed to be called by node handles when they wish to open a socket to their remote node.
`protected void` | `socketUpdated(SourceRoute path)` Method which is designed to be called whenever a node has network activity.
`protected void` | `sourceRouteClosed(SocketCollectionManager.SourceRouteManager manager)` Method which is designed to be called *ONCE THE SOURCE ROUTE MANAGER HAS BEEN CLOSED*.
`protected void` | `sourceRouteOpened(SocketCollectionManager.SourceRouteManager manager)` Method which is designed to be called when a new source route manager is created.
`protected void` | `sourceRouteUpdated(SocketCollectionManager.SourceRouteManager manager)` Method which is designed to be called whenever a source route has network activity.
`void` | `stall()` Internal testing method which simulates a stall.

Methods inherited from class rice.selector.SelectionKeyHandler
`connect, modifyKey, read, write`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### MAX_OPEN_SOCKETS

    public final int MAX_OPEN_SOCKETS

### MAX_OPEN_SOURCE_ROUTES

    public final int MAX_OPEN_SOURCE_ROUTES

### SOCKET_BUFFER_SIZE

    public final int SOCKET_BUFFER_SIZE

### PING_DELAY

    public final int PING_DELAY

### PING_JITTER

    public final float PING_JITTER

### NUM_PING_TRIES

    public final int NUM_PING_TRIES

### WRITE_WAIT_TIME

    public final int WRITE_WAIT_TIME

### BACKOFF_INITIAL

    public final long BACKOFF_INITIAL

### BACKOFF_LIMIT

    public final int BACKOFF_LIMIT

### HEADER_DIRECT

    public static final byte[] HEADER_DIRECT

### HEADER_SOURCE_ROUTE

    protected static final byte[] HEADER_SOURCE_ROUTE

### HEADER_SIZE

    public static final int HEADER_SIZE

### PASTRY_MAGIC_NUMBER

    public static final byte[] PASTRY_MAGIC_NUMBER

### TOTAL_HEADER_SIZE

    public static final int TOTAL_HEADER_SIZE

### sockets

    public java.util.Hashtable sockets

### appSockets

    public java.util.LinkedList appSockets

### logger

    protected Logger logger

### random

    protected RandomSource random

Constructor Detail

### SocketCollectionManager

    public SocketCollectionManager(SocketPastryNode node,
                                   SocketSourceRouteManager manager,
                                   EpochInetSocketAddress bindAddress,
                                   EpochInetSocketAddress proxyAddress,
                                   RandomSource random)
                            throws java.io.IOException

  Constructs a new SocketManager.

  Parameters:
    `node` - The pastry node this manager is serving
    `port` - The port number which this manager is listening on
    `pool` - DESCRIBE THE PARAMETER
    `address` - The address to claim the node is at (for proxying)
  Throws:
    `java.io.IOException`

Method Detail

### bootstrap

    public void bootstrap(SourceRoute path,
                          Message message)
                   throws java.io.IOException

  Method which sends bootstraps a node by sending message across the wire, using a fake IP address in the header so that the local node is not marked alive, and then closes the connection.

  Parameters:
    `message` - The message to send
    `address` - The address to send the message to
  Throws:
    `java.io.IOException`

### send

    public void send(SourceRoute path,
                     SocketBuffer message,
                     SocketSourceRouteManager.AddressManager am)

  Method which sends a message across the wire.

  Parameters:
    `message` - The message to send
    `address` - The address to send the message to

### connect

    public void connect(SourceRoute path,
                        int appId,
                        AppSocketReceiver receiver,
                        int timeout)

  Method which sends a message across the wire.

  Parameters:
    `message` - The message to send
    `address` - The address to send the message to

### ping

    public void ping(SourceRoute route)

  Method which suggests a ping to the remote node.

  Parameters:
    `route` - The route to use

### checkLiveness

    protected void checkLiveness(SourceRoute path)

  Initiates a liveness test on the given address, if the remote node does not respond, it is declared dead.

  Parameters:
    `address` - DESCRIBE THE PARAMETER

### isOpen

    public boolean isOpen(SourceRoute route)

  Returns whether or not a socket is currently open to the given route

  Parameters:
    `route` - The route
  Returns:
    Whether or not a socket is currently open to that route

### declaredDead

    public void declaredDead(EpochInetSocketAddress address)

  Method which should be called when a remote node is declared dead. This method will close any outstanding sockets, and will reroute any pending messages

  Parameters:
    `address` - The address which was declared dead

### sendInternal

    protected boolean sendInternal(SourceRoute path,
                                   SocketBuffer message)

  Method which sends a message across the wire.

  Parameters:
    `message` - The message to send
    `path` - The path to send the message along

### accept

    public void accept(java.nio.channels.SelectionKey key)

  Specified by the SelectionKeyHandler interface. Is called whenever a key has become acceptable, representing an incoming connection. This method will accept the connection, and attach a SocketConnector in order to read the greeting off of the channel. Once the greeting has been read, the connector will hand the channel off to the appropriate node handle.

  Overrides:
    `accept` in class `SelectionKeyHandler`
  Parameters:
    `key` - The key which is acceptable.

### openSocket

    protected void openSocket(SourceRoute path,
                              boolean bootstrap)

  Method which opens a socket to a given remote node handle, and updates the bookkeeping to keep track of this socket

  Parameters:
    `address` - The address of the remote node

### openAppSocket

    protected void openAppSocket(SourceRoute path,
                                 int appId,
                                 AppSocketReceiver connector,
                                 int timeout)

  Method which opens a socket to a given remote node handle, and updates the bookkeeping to keep track of this socket

  Parameters:
    `address` - The address of the remote node

### closeSocket

    protected void closeSocket(SourceRoute path)

  Method which cloeses a socket to a given remote node handle, and updates the bookkeeping to keep track of this closing. Note that this method does not completely close the socket, rather, it simply calls shutdown(), which starts the shutdown process.

  Parameters:
    `address` - The address of the remote node

### getSocketToClose

    protected SourceRoute getSocketToClose()

  Internal method which returns the next socket to be closed

  Returns:
    The next socket to be closed

### socketOpened

    protected void socketOpened(SourceRoute path,
                                rice.pastry.socket.SocketManager manager)

  Method which is designed to be called by node handles when they wish to open a socket to their remote node. This method will determine if another node handle needs to disconnect, and will disconnect the ejected node handle if necessary.

  Parameters:
    `address` - The address of the remote node
    `manager` - The manager for the remote address

### appSocketOpened

    protected void appSocketOpened(SocketAppSocket sas)

### closeOneSocket

    protected void closeOneSocket()

  TODO: Add also checking the top of the AppSocketQueue

### socketClosed

    protected void socketClosed(SourceRoute path,
                                rice.pastry.socket.SocketManager manager)

  Method which is designed to be called *ONCE THE SOCKET HAS BEEN CLOSED*. This method simply updates the bookeeping, but does not actually close the socket.

  Parameters:
    `address` - The address of the remote node
    `manager` - The manager for the remote address

### appSocketClosed

    protected void appSocketClosed(SocketAppSocket sas)

  Method which is designed to be called *ONCE THE SOCKET HAS BEEN CLOSED*. This method simply updates the bookeeping, but does not actually close the socket.

  Parameters:
    `address` - The address of the remote node
    `manager` - The manager for the remote address

### socketUpdated

    protected void socketUpdated(SourceRoute path)

  Method which is designed to be called whenever a node has network activity. This is used to determine which nodes should be disconnected, should it be necessary (implementation of a LRU stack).

  Parameters:
    `address` - The address of the remote node

### sourceRouteOpened

    protected void sourceRouteOpened(SocketCollectionManager.SourceRouteManager manager)

  Method which is designed to be called when a new source route manager is created. This method will close another source route, if there are too many source routes already open through this node.

  Parameters:
    `address` - The address of the remote node
    `manager` - The manager for the remote address

### sourceRouteClosed

    protected void sourceRouteClosed(SocketCollectionManager.SourceRouteManager manager)

  Method which is designed to be called *ONCE THE SOURCE ROUTE MANAGER HAS BEEN CLOSED*. This method simply updates the bookeeping, but does not actually close the source route.

  Parameters:
    `address` - The address of the remote node
    `manager` - The manager for the remote address

### sourceRouteUpdated

    protected void sourceRouteUpdated(SocketCollectionManager.SourceRouteManager manager)

  Method which is designed to be called whenever a source route has network activity. This is used to determine which source routes should be disconnected, should it be necessary (implementation of a LRU stack).

  Parameters:
    `manager` - The manager with activity

### destroy

    public void destroy()
                 throws java.io.IOException

  Makes this node resign from the network. Is designed to be used for debugging and testing.

  Throws:
    `java.io.IOException`

### getNumSourceRoutes

    public int getNumSourceRoutes()

### getNumSockets

    public int getNumSockets()

### stall

    public void stall()

  Internal testing method which simulates a stall. DO NOT USE!!!!!

### getPingManager

    public PingManager getPingManager()

  Method which returns the internal PingManager

  Parameters:
    `route` - The route to use
    `prl` - The listener

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Rice Pastry API
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2001-2005 - Rice Pastry.