Whitespace fixes, mostly. Also turned a few variable into private instance variables. Also removed 1 layer of try/catching inside the WebSocketServer's 'run()' loop.

TooTallNate · TooTallNate · commit 97c7080dbfdb · 2010-10-03T13:22:33.000-07:00
diff --git a/src/net/tootallnate/websocket/WebSocket.java b/src/net/tootallnate/websocket/WebSocket.java
@@ -85,7 +85,7 @@ public final class WebSocket {
   private BlockingQueue<ByteBuffer> bufferQueue;
   /**
    * Lock object to ensure that data is sent from the bufferQueue in
-   * the proper order
+   * the proper order.
    */
   private Object bufferQueueMutex = new Object();
 
@@ -101,9 +101,7 @@ public final class WebSocket {
    * @param listener The {@link WebSocketListener} to notify of events when
    *                 they occur.
    */
-  WebSocket(SocketChannel socketChannel, BlockingQueue<ByteBuffer> bufferQueue,
-      WebSocketListener listener)
-  {
+  WebSocket(SocketChannel socketChannel, BlockingQueue<ByteBuffer> bufferQueue, WebSocketListener listener) {
     this.socketChannel = socketChannel;
     this.bufferQueue = bufferQueue;
     this.handshakeComplete = false;
@@ -223,8 +221,9 @@ private void recieveFrame() {
       String textFrame = null;
       // currentFrame will be null if END_OF_FRAME was send directly after
       // START_OF_FRAME, thus we will send 'null' as the sent message.
-      if (this.currentFrame != null)
+      if (this.currentFrame != null) {
         textFrame = new String(this.currentFrame.array(), UTF8_CHARSET);
+      }
       this.wsl.onMessage(this, textFrame);
 
     } else { // Regular frame data, add to current frame buffer
@@ -299,7 +298,6 @@ else if ((h.length>=12 && h[h.length-12] == CR
         && h[h.length-2] == CR
         && h[h.length-1] == LF) && !(new String(this.remoteHandshake.array(), UTF8_CHARSET).contains("Sec")) ||
         (h.length==23 && h[h.length-1] == 0) ) {
-        
       completeHandshake(null);
     }    
   }
diff --git a/src/net/tootallnate/websocket/WebSocketServer.java b/src/net/tootallnate/websocket/WebSocketServer.java
@@ -47,6 +47,10 @@ public abstract class WebSocketServer implements Runnable, WebSocketListener {
    * The socket channel for this WebSocket server.
    */
   private ServerSocketChannel server;
+  /**
+   * The 'Selector' used to get event keys from the underlying socket.
+   */
+  private Selector selector;
   /**
    * The Draft of the WebSocket protocol the Server is running adhering to.
    */
@@ -169,18 +173,6 @@ public Draft getDraft() {
     return draft;
   }
 
-  /**
-   * @return A BlockingQueue that should be used by a WebSocket
-   *    to hold data that is waiting to be sent to the client.
-   *    The default implementation returns an unbounded
-   *    LinkedBlockingQueue, but you may choose to override
-   *    this to return a bounded queue to protect against
-   *    running out of memory.
-   */
-  protected BlockingQueue<ByteBuffer> newBufferQueue() {
-    return new LinkedBlockingQueue<ByteBuffer>();
-  }
-
 
   // Runnable IMPLEMENTATION /////////////////////////////////////////////////
   public void run() {
@@ -189,71 +181,72 @@ public void run() {
       server.configureBlocking(false);
       server.socket().bind(new java.net.InetSocketAddress(port));
 
-      Selector selector = Selector.open();
+      selector = Selector.open();
       server.register(selector, server.validOps());
+    } catch (IOException ex) {
+      ex.printStackTrace();
+      return;
+    }
 
-      while(true) {
-        try {
-          selector.select(100L);
-          Set<SelectionKey> keys = selector.selectedKeys();
-          Iterator<SelectionKey> i = keys.iterator();
-
-          while(i.hasNext()) {
-            SelectionKey key = i.next();
-
-            // Remove the current key
-            i.remove();
-
-            // if isAcceptable == true
-            // then a client required a connection
-            if (key.isAcceptable()) {
-              SocketChannel client = server.accept();
-              client.configureBlocking(false);
-              WebSocket c = new WebSocket(client, newBufferQueue(), this);
-              client.register(selector, SelectionKey.OP_READ, c);
-            }
-
-            // if isReadable == true
-            // then the server is ready to read
-            if (key.isReadable()) {
-              WebSocket conn = (WebSocket)key.attachment();
-              conn.handleRead();
-            }
+    while(true) {
+      try {
+        selector.select();
+        Set<SelectionKey> keys = selector.selectedKeys();
+        Iterator<SelectionKey> i = keys.iterator();
+
+        while(i.hasNext()) {
+          SelectionKey key = i.next();
+
+          // Remove the current key
+          i.remove();
+
+          // if isAcceptable == true
+          // then a client required a connection
+          if (key.isAcceptable()) {
+            SocketChannel client = server.accept();
+            client.configureBlocking(false);
+            WebSocket c = new WebSocket(client, new LinkedBlockingQueue<ByteBuffer>(), this);
+            client.register(selector, SelectionKey.OP_READ, c);
+          }
 
-            // if isWritable == true
-            // then we need to send the rest of the data to the client
-            if (key.isWritable()) {
-              WebSocket conn = (WebSocket)key.attachment();
-              if (conn.handleWrite()) {
-                conn.socketChannel().register(selector,
-                    SelectionKey.OP_READ, conn);
-              }
-            }
+          // if isReadable == true
+          // then the server is ready to read
+          if (key.isReadable()) {
+            WebSocket conn = (WebSocket)key.attachment();
+            conn.handleRead();
           }
 
-          for (WebSocket conn : this.connections) {
-            // We have to do this check here, and not in the thread that
-            // adds the buffered data to the WebSocket, because the
-            // Selector is not thread-safe, and can only be accessed
-            // by this thread.
-            if (conn.hasBufferedData()) {
+          // if isWritable == true
+          // then we need to send the rest of the data to the client
+          if (key.isWritable()) {
+            WebSocket conn = (WebSocket)key.attachment();
+            if (conn.handleWrite()) {
               conn.socketChannel().register(selector,
-                  SelectionKey.OP_READ | SelectionKey.OP_WRITE, conn);
+                  SelectionKey.OP_READ, conn);
             }
           }
+        }
 
-        } catch (IOException e) {
-          e.printStackTrace();
-        } catch (RuntimeException e) {
-          e.printStackTrace();
+        for (WebSocket conn : this.connections) {
+          // We have to do this check here, and not in the thread that
+          // adds the buffered data to the WebSocket, because the
+          // Selector is not thread-safe, and can only be accessed
+          // by this thread.
+          if (conn.hasBufferedData()) {
+            conn.socketChannel().register(selector,
+                SelectionKey.OP_READ | SelectionKey.OP_WRITE, conn);
+          }
         }
+      } catch (IOException ex) {
+        ex.printStackTrace();
+      } catch (RuntimeException ex) {
+        ex.printStackTrace();
+      } catch (NoSuchAlgorithmException ex) {
+        ex.printStackTrace();
       }
-    } catch (IOException ex) {
-      ex.printStackTrace();
-    } catch (NoSuchAlgorithmException e) {
-      // TODO Auto-generated catch block
-      e.printStackTrace();
     }
+    
+    //System.err.println("WebSocketServer thread ended!");
   }
 
   /**
