Skip to content
Navigation Menu
{{ message }}
forked from TooTallNate/Java-WebSocket
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathWebSocketClient.java
More file actions
407 lines (364 loc) · 10.6 KB
/
Copy pathWebSocketClient.java
File metadata and controls
407 lines (364 loc) · 10.6 KB
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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
package org.java_websocket;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.NotYetConnectedException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.UnresolvedAddressException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.java_websocket.drafts.Draft;
import org.java_websocket.drafts.Draft_10;
import org.java_websocket.exceptions.InvalidHandshakeException;
import org.java_websocket.framing.CloseFrame;
import org.java_websocket.handshake.HandshakeImpl1Client;
import org.java_websocket.handshake.Handshakedata;
import org.java_websocket.handshake.ServerHandshake;
/**
* The <tt>WebSocketClient</tt> is an abstract class that expects a valid
* "ws://" URI to connect to. When connected, an instance recieves important
* events related to the life of the connection. A subclass must implement
* <var>onOpen</var>, <var>onClose</var>, and <var>onMessage</var> to be
* useful. An instance can send messages to it's connected server via the
* <var>send</var> method.
*
* @author Nathan Rajlich
*/
public abstract class WebSocketClient extends WebSocketAdapter implements Runnable {
/**
* The URI this client is supposed to connect to.
*/
private URI uri = null;
/**
* The WebSocket instance this client object wraps.
*/
private WebSocketImpl conn = null;
/**
* The SocketChannel instance this client uses.
*/
private SocketChannel client = null;
/**
* The 'Selector' used to get event keys from the underlying socket.
*/
private Selector selector = null;
private Thread thread;
private Draft draft;
private final Lock closelock = new ReentrantLock();
private Map<String, String> headers;
WebSocketFactory wf = new WebSocketFactory() {
@Override
public WebSocket createWebSocket( WebSocketAdapter a, Draft d, SocketChannel c ) {
return new WebSocketImpl( WebSocketClient.this, d, c );
}
@Override
public WebSocket createWebSocket( WebSocketAdapter a, List<Draft> d, SocketChannel c ) {
return new WebSocketImpl( WebSocketClient.this, d, c );
}
};
public WebSocketClient( URI serverURI ) {
this( serverURI, new Draft_10() );
}
/**
* Constructs a WebSocketClient instance and sets it to the connect to the
* specified URI. The client does not attampt to connect automatically. You
* must call <var>connect</var> first to initiate the socket connection.
*/
public WebSocketClient( URI serverUri , Draft draft ) {
this(serverUri, draft, null);
}
public WebSocketClient( URI serverUri , Draft draft, Map<String, String> headers) {
if( serverUri == null ) {
throw new IllegalArgumentException();
}
if( draft == null ) {
throw new IllegalArgumentException( "null as draft is permitted for `WebSocketServer` only!" );
}
this.uri = serverUri;
this.draft = draft;
this.headers = headers;
}
/**
* Gets the URI that this WebSocketClient is connected to.
*
* @return The <tt>URI</tt> for this WebSocketClient.
*/
public URI getURI() {
return uri;
}
/** Returns the protocol version this client uses. */
public Draft getDraft() {
return draft;
}
/**
* Starts a background thread that attempts and maintains a WebSocket
* connection to the URI specified in the constructor or via <var>setURI</var>.
* <var>setURI</var>.
*/
public void connect() {
if( thread != null )
throw new IllegalStateException( "already/still connected" );
thread = new Thread( this );
thread.start();
}
public void close() {
if( thread != null ) {
thread.interrupt();
closelock.lock();
try {
if( selector != null )
selector.wakeup();
} finally {
closelock.unlock();
}
}
}
/**
* Sends <var>text</var> to the connected WebSocket server.
*
* @param text
* The String to send to the WebSocket server.
*/
public void send( String text ) throws NotYetConnectedException {
if( conn != null ) {
conn.send( text );
}
}
/**
* Sends <var>data</var> to the connected WebSocket server.
*
* @param data
* The Byte-Array of data to send to the WebSocket server.
*/
public void send( byte[] data ) throws NotYetConnectedException , InterruptedException {
if( conn != null ) {
conn.send( data );
}
}
private void tryToConnect( InetSocketAddress remote ) throws IOException {
client = SocketChannel.open();
client.configureBlocking( false );
client.connect( remote );
selector = Selector.open();
client.register( selector, SelectionKey.OP_CONNECT );
}
// Runnable IMPLEMENTATION /////////////////////////////////////////////////
public void run() {
if( thread == null )
thread = Thread.currentThread();
interruptableRun();
thread = null;
}
protected final void interruptableRun() {
try {
tryToConnect( new InetSocketAddress( uri.getHost(), getPort() ) );
} catch ( ClosedByInterruptException e ) {
onWebsocketError( null, e );
return;
} catch ( IOException e ) {//
onWebsocketError( conn, e );
return;
} catch ( SecurityException e ) {
onWebsocketError( conn, e );
return;
} catch ( UnresolvedAddressException e ) {
onWebsocketError( conn, e );
return;
}
conn = (WebSocketImpl) wf.createWebSocket( this, draft, client );
ByteBuffer buff = ByteBuffer.allocate( WebSocket.RCVBUF );
try/*IO*/{
while ( !conn.isClosed() ) {
if( Thread.interrupted() ) {
conn.close( CloseFrame.NORMAL );
}
SelectionKey key = null;
conn.flush();
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> i = keys.iterator();
while ( i.hasNext() ) {
key = i.next();
i.remove();
if( key.isReadable() && conn.read( buff ) ) {
conn.decode( buff );
}
if( !key.isValid() ) {
continue;
}
if( key.isWritable() ) {
conn.flush();
}
if( key.isConnectable() ) {
try {
finishConnect();
} catch ( InterruptedException e ) {
conn.close( CloseFrame.NEVERCONNECTED );// report error to only
break;
} catch ( InvalidHandshakeException e ) {
conn.close( e ); // http error
conn.flush();
}
}
}
}
} catch ( IOException e ) {
onError( e );
conn.close( CloseFrame.ABNORMAL_CLOSE );
return;
} catch ( RuntimeException e ) {
// this catch case covers internal errors only and indicates a bug in this websocket implementation
onError( e );
conn.closeConnection( CloseFrame.BUGGYCLOSE, e.toString(), false );
return;
}
try {
selector.close();
} catch ( IOException e ) {
onError( e );
}
closelock.lock();
selector = null;
closelock.unlock();
try {
client.close();
} catch ( IOException e ) {
onError( e );
}
client = null;
}
private int getPort() {
int port = uri.getPort();
return port == -1 ? WebSocket.DEFAULT_PORT : port;
}
private void finishConnect() throws IOException , InvalidHandshakeException , InterruptedException {
if( client.isConnectionPending() ) {
client.finishConnect();
}
// Now that we're connected, re-register for only 'READ' keys.
client.register( selector, SelectionKey.OP_READ );
sendHandshake();
}
public void flush() {
try {
conn.flush();
} catch ( IOException e ) {
onError( e );
conn.closeConnection( CloseFrame.ABNORMAL_CLOSE, true );
return;
}
}
private void sendHandshake() throws IOException , InvalidHandshakeException , InterruptedException {
String path;
String part1 = uri.getPath();
String part2 = uri.getQuery();
if( part1 == null || part1.length() == 0 )
path = "/";
else
path = part1;
if( part2 != null )
path += "?" + part2;
int port = getPort();
String host = uri.getHost() + ( port != WebSocket.DEFAULT_PORT ? ":" + port : "" );
HandshakeImpl1Client handshake = new HandshakeImpl1Client();
handshake.setResourceDescriptor( path );
handshake.put( "Host", host );
if (headers != null) {
for (Map.Entry<String, String> kv : headers.entrySet()) {
handshake.put(kv.getKey(), kv.getValue());
}
}
conn.startHandshake( handshake );
}
/**
* Retrieve the WebSocket 'readyState'.
* This represents the state of the connection.
* It returns a numerical value, as per W3C WebSockets specs.
*
* @return Returns '0 = CONNECTING', '1 = OPEN', '2 = CLOSING' or '3 = CLOSED'
*/
public int getReadyState() {
return conn.getReadyState();
}
/**
* Amount of data buffered/queued but not sent yet.
*
* In details, it returns the number of bytes of application data (UTF-8 text and binary data)
* that have been queued using send() but that, as of the last time the event loop
* started executing a task, had not yet been transmitted to the network.
*
* @return Amount still buffered/queued but not sent yet.
*/
public long getBufferedAmount() {
return conn.bufferedDataAmount();
}
/**
* Calls subclass' implementation of <var>onMessage</var>.
*
* @param conn
* @param message
*/
@Override
public final void onWebsocketMessage( WebSocket conn, String message ) {
onMessage( message );
}
@Override
public final void onWebsocketMessage( WebSocket conn, ByteBuffer blob ) {
onMessage( blob );
}
/**
* Calls subclass' implementation of <var>onOpen</var>.
*
* @param conn
*/
@Override
public final void onWebsocketOpen( WebSocket conn, Handshakedata handshake ) {
onOpen( (ServerHandshake) handshake );
}
/**
* Calls subclass' implementation of <var>onClose</var>.
*
* @param conn
*/
@Override
public final void onWebsocketClose( WebSocket conn, int code, String reason, boolean remote ) {
thread.interrupt();
onClose( code, reason, remote );
}
/**
* Calls subclass' implementation of <var>onIOError</var>.
*
* @param conn
*/
@Override
public final void onWebsocketError( WebSocket conn, Exception ex ) {
onError( ex );
}
@Override
public final void onWriteDemand( WebSocket conn ) {
selector.wakeup();
}
public WebSocket getConnection() {
return conn;
}
public final void setWebSocketFactory( WebSocketFactory wsf ) {
this.wf = wsf;
}
public final WebSocketFactory getWebSocketFactory() {
return wf;
}
// ABTRACT METHODS /////////////////////////////////////////////////////////
public abstract void onOpen( ServerHandshake handshakedata );
public abstract void onMessage( String message );
public abstract void onClose( int code, String reason, boolean remote );
public abstract void onError( Exception ex );
public void onMessage( ByteBuffer bytes ) {
};
}
You can’t perform that action at this time.