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
|
/* Glazed Lists (c) 2003-2006 */
/* http://publicobject.com/glazedlists/ publicobject.com,*/
/* O'Dell Engineering Ltd.*/
package ca.odell.glazedlists.impl.ctp;
// NIO is used for CTP
import ca.odell.glazedlists.impl.nio.NIODaemon;
import ca.odell.glazedlists.impl.nio.NIOServer;
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
/**
* The CTPConnectionManager provides managed access to multiple CTP connections
* for both incoming and outgoing data.
*
* <p>Each instance of this class owns a single thread which is used to perform
* all read and write operations on all connections. A pool of other threads are
* used to notify the handlers of the data and status of a connection.
*
* @author <a href="mailto:jesse@swank.ca">Jesse Wilson</a>
*/
public final class CTPConnectionManager implements NIOServer {
/** default port to bind to */
private static final int DEFAULT_PORT = 5309;
/** port to listen for incoming connections */
private int listenPort = -1;
/** factory for handlers of incoming connections */
private CTPHandlerFactory handlerFactory;
/** the I/O event queue daemon */
private NIODaemon nioDaemon = null;
/**
* Creates a connection manager that handles incoming connections using the
* specified connect handler. This binds to the default port.
*/
public CTPConnectionManager(CTPHandlerFactory handlerFactory) {
this(handlerFactory, DEFAULT_PORT);
}
/**
* Creates a connection manager that handles incoming connections using the
* specified connect handler. This binds to the specified port.
*/
public CTPConnectionManager(CTPHandlerFactory handlerFactory, int listenPort) {
this.handlerFactory = handlerFactory;
this.listenPort = listenPort;
}
/**
* Starts the CTPConnectionManager listening to incoming connections and
* managing outgoing connections.
*
* @return true if the server successfully binds to the listen port.
*/
public synchronized boolean start() throws IOException {
// verify we haven't already started
if(nioDaemon != null) throw new IllegalStateException();
// start the nio daemon
nioDaemon = new NIODaemon();
nioDaemon.start();
// start the server
try {
nioDaemon.invokeAndWait(new StartServer(this, listenPort));
} catch(RuntimeException e) {
nioDaemon.stop();
if(e.getCause() instanceof IOException) throw (IOException)e.getCause();
else throw e;
}
// success
return true;
}
/**
* Stops the CTPConnectionManager and closes all connections.
*/
public void stop() {
nioDaemon.stop();
}
/**
* Get the daemon that does all the threading and selection.
*/
public NIODaemon getNIODaemon() {
return nioDaemon;
}
/**
* Handle an incoming connection.
*
* <p>This creates a CTPServerProtocol to handle the connection.
*
* @return the SelectionKey that is attached to the created connection.
*/
public void handleAccept(SelectionKey key, Selector selector) {
// construct the channels and selectors
SocketChannel channel = null;
SelectionKey channelKey = null;
try {
// peel the connection from the SocketChannel
ServerSocketChannel server = (ServerSocketChannel)key.channel();
channel = server.accept();
// configure the channel for no-blocking and selection
if(channel == null) return;
channel.configureBlocking(false);
channelKey = channel.register(selector, 0);
} catch(IOException e) {
// the accept failed, there's nothing to clean up
return;
}
// construct handlers for this connection
CTPHandler handler = handlerFactory.constructHandler();
CTPConnection server = CTPConnection.server(channelKey, handler, this);
channelKey.attach(server);
server.handleConnect();
}
/**
* Connect to the specified host.
*/
public void connect(CTPHandler handler, String host, int port) {
nioDaemon.invokeLater(new OpenConnection(this, handler, host, port));
}
public void connect(CTPHandler handler, String host) {
connect(handler, host, DEFAULT_PORT);
}
}
|
