Exemplo n.º 1
0
 @Override
 public void run() {
   WebSocketImpl ws = null;
   try {
     while (true) {
       ByteBuffer buf = null;
       ws = iqueue.take();
       buf = ws.in.poll();
       assert (buf != null);
       try {
         ws.decode(buf);
         // ws.flush();
       } catch (IOException e) {
         handleIOException(ws, e);
       } finally {
         pushBuffer(buf);
       }
     }
   } catch (RuntimeException e) {
     handleFatal(ws, e);
   } catch (InterruptedException e) {
   } catch (Throwable e) {
     e.printStackTrace();
   }
 }
Exemplo n.º 2
0
 private void registerWrite() {
   int size = oqueue.size();
   for (int i = 0; i < size; i++) {
     WebSocketImpl conn = oqueue.remove();
     try {
       conn.key.channel().register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE, conn);
     } catch (ClosedChannelException ex) {
       onWebsocketError(null, ex);
       conn.eot(null);
       return;
     }
   }
 }
Exemplo n.º 3
0
 private void queue(WebSocketImpl ws) throws InterruptedException {
   if (ws.workerThread == null) {
     ws.workerThread = decoders.get(queueinvokes % decoders.size());
     queueinvokes++;
   }
   ws.workerThread.put(ws);
 }
Exemplo n.º 4
0
 @Override
 public void run() {
   WebSocketImpl ws = null;
   try {
     while (true) {
       ByteBuffer buf = null;
       ws = iqueue.take();
       buf = ws.inQueue.poll();
       assert (buf != null);
       try {
         ws.decode(buf);
       } catch (Exception e) {
         System.err.println("Error while reading from remote connection: " + e);
       } finally {
         pushBuffer(buf);
       }
     }
   } catch (InterruptedException e) {
   } catch (RuntimeException e) {
     handleFatal(ws, e);
   }
 }
Exemplo n.º 5
0
  // Runnable IMPLEMENTATION /////////////////////////////////////////////////
  public void run() {
    synchronized (this) {
      if (selectorthread != null)
        throw new IllegalStateException(getClass().getName() + " can only be started once.");
      selectorthread = Thread.currentThread();
      if (isclosed.get()) {
        return;
      }
    }
    selectorthread.setName("WebsocketSelector" + selectorthread.getId());
    try {
      server = ServerSocketChannel.open();
      server.configureBlocking(false);
      ServerSocket socket = server.socket();
      socket.setReceiveBufferSize(WebSocket.RCVBUF);
      socket.bind(address);
      selector = Selector.open();
      server.register(selector, server.validOps());
    } catch (IOException ex) {
      handleFatal(null, ex);
      return;
    }
    try {
      while (!selectorthread.isInterrupted()) {
        SelectionKey key = null;
        WebSocketImpl conn = null;
        try {
          selector.select();
          registerWrite();

          Set<SelectionKey> keys = selector.selectedKeys();
          Iterator<SelectionKey> i = keys.iterator();

          while (i.hasNext()) {
            key = i.next();

            if (!key.isValid()) {
              // Object o = key.attachment();
              continue;
            }

            if (key.isAcceptable()) {
              if (!onConnect(key)) {
                key.cancel();
                continue;
              }

              SocketChannel channel = server.accept();
              channel.configureBlocking(false);
              WebSocketImpl w = wsf.createWebSocket(this, drafts, channel.socket());
              w.key = channel.register(selector, SelectionKey.OP_READ, w);
              w.channel = wsf.wrapChannel(channel, w.key);
              i.remove();
              allocateBuffers(w);
              continue;
            }

            if (key.isReadable()) {
              conn = (WebSocketImpl) key.attachment();
              ByteBuffer buf = takeBuffer();
              try {
                if (SocketChannelIOHelper.read(buf, conn, (ByteChannel) conn.channel)) {
                  conn.inQueue.put(buf);
                  queue(conn);
                  i.remove();
                  if (conn.channel instanceof WrappedByteChannel) {
                    if (((WrappedByteChannel) conn.channel).isNeedRead()) {
                      iqueue.add(conn);
                    }
                  }
                } else {
                  pushBuffer(buf);
                }
              } catch (IOException e) {
                pushBuffer(buf);
                throw e;
              } catch (RuntimeException e) {
                pushBuffer(buf);
                throw e;
              }
            }
            if (key.isWritable()) {
              conn = (WebSocketImpl) key.attachment();
              if (SocketChannelIOHelper.batch(conn, (ByteChannel) conn.channel)) {
                if (key.isValid()) key.interestOps(SelectionKey.OP_READ);
              }
            }
          }
          while (!iqueue.isEmpty()) {
            conn = iqueue.remove(0);
            WrappedByteChannel c = ((WrappedByteChannel) conn.channel);
            ByteBuffer buf = takeBuffer();
            try {
              if (SocketChannelIOHelper.readMore(buf, conn, c)) iqueue.add(conn);
              conn.inQueue.put(buf);
              queue(conn);
            } finally {
              pushBuffer(buf);
            }
          }
        } catch (CancelledKeyException e) {
          // an other thread may cancel the key
        } catch (IOException ex) {
          if (key != null) key.cancel();
          handleIOException(conn, ex);
        } catch (InterruptedException e) {
          return; // FIXME controlled shutdown
        }
      }

    } catch (RuntimeException e) {
      // should hopefully never occur
      handleFatal(null, e);
    }
  }
Exemplo n.º 6
0
  // Runnable IMPLEMENTATION /////////////////////////////////////////////////
  public void run() {
    if (selectorthread != null)
      throw new IllegalStateException(
          "This instance of "
              + getClass().getSimpleName()
              + " can only be started once the same time.");
    selectorthread = Thread.currentThread();
    selectorthread.setName("WebsocketSelector" + selectorthread.getId());
    try {
      server = ServerSocketChannel.open();
      server.configureBlocking(false);
      ServerSocket socket = server.socket();
      socket.setReceiveBufferSize(WebSocket.RCVBUF);
      socket.bind(address);
      selector = Selector.open();
      server.register(selector, server.validOps());
    } catch (IOException ex) {
      onWebsocketError(null, ex);
      return;
    }
    try {
      while (!selectorthread.isInterrupted()) {
        SelectionKey key = null;
        WebSocketImpl conn = null;
        try {
          selector.select();
          registerWrite();

          Set<SelectionKey> keys = selector.selectedKeys();
          Iterator<SelectionKey> i = keys.iterator();

          while (i.hasNext()) {
            key = i.next();

            if (!key.isValid()) {
              // Object o = key.attachment();
              continue;
            }

            if (key.isAcceptable()) {
              SocketChannel channel = server.accept();
              channel.configureBlocking(false);
              WebSocketImpl c = wsf.createWebSocket(this, drafts, channel.socket());
              c.key = channel.register(selector, SelectionKey.OP_READ, c);
              c.ioobject = wsf.wrapChannel(channel);
              i.remove();
              allocateBuffers(c);
              continue;
            }

            if (key.isReadable()) {
              conn = (WebSocketImpl) key.attachment();
              ByteBuffer buf = takeBuffer();
              try {
                if (SocketChannelIOHelper.read(buf, conn, (ByteChannel) conn.ioobject)) {
                  conn.in.put(buf);
                  queue(conn);
                  i.remove();
                } else {
                  pushBuffer(buf);
                }
              } catch (IOException e) {
                pushBuffer(buf);
                throw e;
              } catch (RuntimeException e) {
                pushBuffer(buf);
                throw e;
              }
            }
            if (key.isWritable()) {
              conn = (WebSocketImpl) key.attachment();
              if (SocketChannelIOHelper.batch(conn, (ByteChannel) conn.ioobject)) {
                if (key.isValid())
                  key.channel().register(selector, SelectionKey.OP_READ, key.attachment());
              }
            }
          }
        } catch (CancelledKeyException e) {
          // an other thread may cancel the key
        } catch (IOException ex) {
          if (key != null) key.cancel();
          handleIOException(conn, ex);
        } catch (InterruptedException e) {
          return;
        }
      }
    } catch (RuntimeException e) {
      // should hopefully never occur
      handleFatal(null, e);
    }
  }