/**
  * Closes all connected clients sockets, then closes the underlying ServerSocketChannel,
  * effectively killing the server socket thread and freeing the port the server was bound to.
  *
  * @throws IOException When socket related I/O errors occur.
  */
 public void stop() throws IOException {
   for (WebSocket ws : connections) {
     ws.close(CloseFrame.NORMAL);
   }
   thread.interrupt();
   this.server.close();
 }
예제 #2
0
 @Test(expected = IllegalArgumentException.class)
 public void closeWhileClosed() throws NoSuchAlgorithmException, URISyntaxException {
   TestMessageHandler handler = new TestMessageHandler();
   Configuration configuration =
       new Configuration(handler, "ws://echo.websocket.org", SSLContext.getDefault());
   WebSocket socket = new WebSocket(configuration);
   socket.close();
 }
  // Runnable IMPLEMENTATION /////////////////////////////////////////////////
  public void run() {
    if (thread != null)
      throw new IllegalStateException(
          "This instance of "
              + getClass().getSimpleName()
              + " can only be started once the same time.");
    thread = Thread.currentThread();
    try {
      server = ServerSocketChannel.open();
      server.configureBlocking(false);
      server.socket().bind(address);
      // InetAddress.getLocalHost()
      selector = Selector.open();
      server.register(selector, server.validOps());
    } catch (IOException ex) {
      onWebsocketError(null, ex);
      return;
    }

    while (!thread.isInterrupted()) {
      SelectionKey key = null;
      WebSocket conn = null;
      try {
        selector.select();
        Set<SelectionKey> keys = selector.selectedKeys();
        Iterator<SelectionKey> i = keys.iterator();

        while (i.hasNext()) {
          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(this, Collections.singletonList(draft), client);
            client.register(selector, SelectionKey.OP_READ, c);
          }

          // if isReadable == true
          // then the server is ready to read
          if (key.isReadable()) {
            conn = (WebSocket) key.attachment();
            conn.handleRead();
          }

          // if isWritable == true
          // then we need to send the rest of the data to the client
          if (key.isValid() && key.isWritable()) {
            conn = (WebSocket) key.attachment();
            conn.flush();
            key.channel().register(selector, SelectionKey.OP_READ, conn);
          }
        }
        Iterator<WebSocket> it = this.connections.iterator();
        while (it.hasNext()) {
          // 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.
          conn = it.next();
          if (conn.hasBufferedData()) {
            conn.flush();
            // key.channel().register( selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE, conn
            // );
          }
        }
      } catch (IOException ex) {
        if (key != null) key.cancel();
        onWebsocketError(conn, ex); // conn may be null here
        if (conn != null) {
          conn.close(CloseFrame.ABNROMAL_CLOSE);
        }
      }
    }
  }