/** MemcachedClient calls this method to handle IO over the connections. */
  @SuppressWarnings("unchecked")
  public void handleIO() throws IOException {
    if (shutDown) {
      throw new IOException("No IO while shut down");
    }

    // Deal with all of the stuff that's been added, but may not be marked
    // writable.
    handleInputQueue();
    getLogger().debug("Done dealing with queue.");

    long delay = 0;
    if (!reconnectQueue.isEmpty()) {
      long now = System.currentTimeMillis();
      long then = reconnectQueue.firstKey();
      delay = Math.max(then - now, 1);
    }
    getLogger().debug("Selecting with delay of %sms", delay);
    assert selectorsMakeSense() : "Selectors don't make sense.";
    int selected = selector.select(delay);
    Set<SelectionKey> selectedKeys = selector.selectedKeys();

    if (selectedKeys.isEmpty() && !shutDown) {
      getLogger().debug("No selectors ready, interrupted: " + Thread.interrupted());
      if (++emptySelects > DOUBLE_CHECK_EMPTY) {
        for (SelectionKey sk : selector.keys()) {
          getLogger().info("%s has %s, interested in %s", sk, sk.readyOps(), sk.interestOps());
          if (sk.readyOps() != 0) {
            getLogger().info("%s has a ready op, handling IO", sk);
            handleIO(sk);
          } else {
            queueReconnect((MemcachedNode) sk.attachment());
          }
        }
        assert emptySelects < EXCESSIVE_EMPTY : "Too many empty selects";
      }
    } else {
      getLogger().debug("Selected %d, selected %d keys", selected, selectedKeys.size());
      emptySelects = 0;
      for (SelectionKey sk : selectedKeys) {
        handleIO(sk);
      } // for each selector
      selectedKeys.clear();
    }

    if (!shutDown && !reconnectQueue.isEmpty()) {
      attemptReconnects();
    }
  }
示例#2
0
  /**
   * Serves the incoming connections.
   *
   * @throws IOException
   * @throws DirectoryException
   */
  private void serveIncomingConnections() throws IOException, DirectoryException {
    int selectorState = selector.select();

    // We can't rely on return value of select to determine if any keys
    // are ready.
    // see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4850373
    for (Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        iterator.hasNext(); ) {
      SelectionKey key = iterator.next();
      iterator.remove();
      if (key.isAcceptable()) {
        // Accept the new client connection.
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverChannel.accept();
        if (clientChannel != null) {
          acceptConnection(clientChannel);
        }
      }

      if (selectorState == 0 && enabled && !shutdownRequested && logger.isTraceEnabled()) {
        // Selected keys was non empty but select() returned 0.
        // Log warning and hope it blocks on the next select() call.
        logger.trace(
            "Selector.select() returned 0. "
                + "Selected Keys: %d, Interest Ops: %d, Ready Ops: %d ",
            selector.selectedKeys().size(), key.interestOps(), key.readyOps());
      }
    }
  }
示例#3
0
 @Override
 public void run() {
   final Selector selector = this.selector;
   for (; ; ) {
     ++reactCount;
     try {
       selector.select(1000L);
       register(selector);
       Set<SelectionKey> keys = selector.selectedKeys();
       try {
         for (SelectionKey key : keys) {
           Object att = key.attachment();
           System.out.println("attchment " + att);
           if (att != null && key.isValid()) {
             int readyOps = key.readyOps();
             if ((readyOps & SelectionKey.OP_READ) != 0) {
               read((NIOConnection) att);
             } else if ((readyOps & SelectionKey.OP_WRITE) != 0) {
               write((NIOConnection) att);
             } else {
               key.cancel();
             }
           } else {
             key.cancel();
           }
         }
       } finally {
         keys.clear();
       }
     } catch (Throwable e) {
       LOGGER.warn(name, e);
     }
   }
 }
示例#4
0
  @Override
  public void run() {
    try {
      selector = Selector.open();

      while (true) {
        processSelectionQueue();

        int nKeys = selector.select(selectWaitTime); // blocking
        if (nKeys == 0) {
          continue;
        } else {
          logger.trace(String.format("Selector %d, keys num: %d", selectorNum, nKeys));
        }

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

        while (iter.hasNext()) {
          SelectionKey key = iter.next();
          iter.remove();

          logger.trace("Key operations: " + key.readyOps());

          if (key.isWritable()) {
            doWrite(key);
          }
        }
      }
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
示例#5
0
  public void run() {
    System.out.println("Server started ...");
    System.out.println("Server listening on port: " + port);
    // 监听
    while (true) {
      try {
        int num = 0;
        num = selector.select();

        if (num > 0) {
          Set selectedKeys = selector.selectedKeys();
          Iterator it = selectedKeys.iterator();
          while (it.hasNext()) {
            SelectionKey key = (SelectionKey) it.next();
            it.remove();
            // 处理IO事件
            if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
              // Accept the new connection
              ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
              notifier.fireOnAccept();

              SocketChannel sc = ssc.accept();
              sc.configureBlocking(false);

              // 触发接受连接事件
              Request request = new Request(sc);
              notifier.fireOnAccepted(request);

              // 注册读操作,以进行下一步的读操作
              sc.register(selector, SelectionKey.OP_READ, request);
            } else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
              Reader.processRequest(key); // 提交读服务线程读取客户端数据
              key.cancel();
            } else if ((key.readyOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
              Writer.processRequest(key); // 提交写服务线程向客户端发送回应数据
              key.cancel();
            }
          }
        } else {
          addRegister(); // 在Selector中注册新的写通道
        }
      } catch (Exception e) {
        notifier.fireOnError("Error occured in Server: " + e.getMessage());
        continue;
      }
    }
  }
示例#6
0
文件: Nio4r.java 项目: tpetchel/nio4r
    // Remove connect interest from connected sockets
    // See:
    // http://stackoverflow.com/questions/204186/java-nio-select-returns-without-selected-keys-why
    private void processKey(SelectionKey key) {
      if ((key.readyOps() & SelectionKey.OP_CONNECT) != 0) {
        int interestOps = key.interestOps();

        interestOps &= ~SelectionKey.OP_CONNECT;
        interestOps |= SelectionKey.OP_WRITE;

        key.interestOps(interestOps);
      }
    }
示例#7
0
 public void blockUntilReady(final int operationCode) throws IOException {
   key.interestOps(operationCode);
   int retryCount = 0;
   try {
     while (!((key.readyOps() & operationCode) != 0) && retryCount < numberOfRetries) {
       block();
       retryCount++;
     }
   } finally {
     resetKey();
   }
 }
示例#8
0
 @Override
 public void run() {
   try {
     while (isWork) {
       if (selector == null) {
         logger.trace("Selector is still null, stack is waiting for binding...");
         Thread.sleep(250);
         continue;
       }
       // without timeout when we kill socket, this causes errors, bug in VM ?
       int num = selector.select(100);
       if (num == 0) {
         continue;
       }
       Set<SelectionKey> keys = selector.selectedKeys();
       try {
         for (SelectionKey key : keys) {
           if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
             try {
               Socket s = serverSocket.accept();
               logger.info("Open incomming connection {}", s);
               TCPClientConnection client =
                   new TCPClientConnection(null, concurrentFactory, s, parser, null);
               // PCB added logging
               logger.debug("Finished initialising TCPClientConnection for {}", s);
               for (INetworkConnectionListener listener : listeners) {
                 listener.newNetworkConnection(client);
               }
             } catch (Exception e) {
               logger.warn("Can not create incoming connection", e);
             }
           }
         }
       } catch (Exception e) {
         logger.debug("Failed to accept connection,", e);
       } finally {
         keys.clear();
       }
     }
   } catch (Exception exc) {
     logger.warn("Server socket stopped", exc);
   }
 }
示例#9
0
 protected void processKey(SelectionKey sk, NioSocketWrapper attachment) {
   try {
     if (close) {
       cancelledKey(sk);
     } else if (sk.isValid() && attachment != null) {
       if (sk.isReadable() || sk.isWritable()) {
         if (attachment.getSendfileData() != null) {
           processSendfile(sk, attachment, false);
         } else {
           unreg(sk, attachment, sk.readyOps());
           boolean closeSocket = false;
           // Read goes before write
           if (sk.isReadable()) {
             if (!processSocket(attachment, SocketEvent.OPEN_READ, true)) {
               closeSocket = true;
             }
           }
           if (!closeSocket && sk.isWritable()) {
             if (!processSocket(attachment, SocketEvent.OPEN_WRITE, true)) {
               closeSocket = true;
             }
           }
           if (closeSocket) {
             cancelledKey(sk);
           }
         }
       }
     } else {
       // invalid key
       cancelledKey(sk);
     }
   } catch (CancelledKeyException ckx) {
     cancelledKey(sk);
   } catch (Throwable t) {
     ExceptionUtils.handleThrowable(t);
     log.error("", t);
   }
 }
示例#10
0
  private void processSelectedKeys(final Set<SelectionKey> selectedKeys) throws IOException {
    for (Iterator<SelectionKey> i = selectedKeys.iterator(); i.hasNext(); ) {
      SelectionKey k = i.next();
      i.remove();
      try {
        int readyOps = k.readyOps();
        if ((readyOps & SelectionKey.OP_READ) != 0 || readyOps == 0) {
          if (!read(k)) {
            // Connection already closed - no need to handle write.
            continue;
          }
        }
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {
          writeFromSelectorLoop(k);
        }
      } catch (CancelledKeyException e) {
        close(k);
      }

      if (cleanUpCancelledKeys()) {
        break; // break the loop to avoid ConcurrentModificationException
      }
    }
  }
示例#11
0
    public SendfileState processSendfile(
        SelectionKey sk, NioSocketWrapper socketWrapper, boolean calledByProcessor) {
      NioChannel sc = null;
      try {
        unreg(sk, socketWrapper, sk.readyOps());
        SendfileData sd = socketWrapper.getSendfileData();

        if (log.isTraceEnabled()) {
          log.trace("Processing send file for: " + sd.fileName);
        }

        if (sd.fchannel == null) {
          // Setup the file channel
          File f = new File(sd.fileName);
          if (!f.exists()) {
            cancelledKey(sk);
            return SendfileState.ERROR;
          }
          @SuppressWarnings("resource") // Closed when channel is closed
          FileInputStream fis = new FileInputStream(f);
          sd.fchannel = fis.getChannel();
        }

        // Configure output channel
        sc = socketWrapper.getSocket();
        // TLS/SSL channel is slightly different
        WritableByteChannel wc = ((sc instanceof SecureNioChannel) ? sc : sc.getIOChannel());

        // We still have data in the buffer
        if (sc.getOutboundRemaining() > 0) {
          if (sc.flushOutbound()) {
            socketWrapper.updateLastWrite();
          }
        } else {
          long written = sd.fchannel.transferTo(sd.pos, sd.length, wc);
          if (written > 0) {
            sd.pos += written;
            sd.length -= written;
            socketWrapper.updateLastWrite();
          } else {
            // Unusual not to be able to transfer any bytes
            // Check the length was set correctly
            if (sd.fchannel.size() <= sd.pos) {
              throw new IOException(
                  "Sendfile configured to " + "send more data than was available");
            }
          }
        }
        if (sd.length <= 0 && sc.getOutboundRemaining() <= 0) {
          if (log.isDebugEnabled()) {
            log.debug("Send file complete for: " + sd.fileName);
          }
          socketWrapper.setSendfileData(null);
          try {
            sd.fchannel.close();
          } catch (Exception ignore) {
          }
          // For calls from outside the Poller, the caller is
          // responsible for registering the socket for the
          // appropriate event(s) if sendfile completes.
          if (!calledByProcessor) {
            if (sd.keepAlive) {
              if (log.isDebugEnabled()) {
                log.debug("Connection is keep alive, registering back for OP_READ");
              }
              reg(sk, socketWrapper, SelectionKey.OP_READ);
            } else {
              if (log.isDebugEnabled()) {
                log.debug("Send file connection is being closed");
              }
              close(sc, sk);
            }
          }
          return SendfileState.DONE;
        } else {
          if (log.isDebugEnabled()) {
            log.debug("OP_WRITE for sendfile: " + sd.fileName);
          }
          if (calledByProcessor) {
            add(socketWrapper.getSocket(), SelectionKey.OP_WRITE);
          } else {
            reg(sk, socketWrapper, SelectionKey.OP_WRITE);
          }
          return SendfileState.PENDING;
        }
      } catch (IOException x) {
        if (log.isDebugEnabled()) log.debug("Unable to complete sendfile request:", x);
        if (!calledByProcessor && sc != null) {
          close(sc, sk);
        } else {
          cancelledKey(sk);
        }
        return SendfileState.ERROR;
      } catch (Throwable t) {
        log.error("", t);
        if (!calledByProcessor && sc != null) {
          close(sc, sk);
        } else {
          cancelledKey(sk);
        }
        return SendfileState.ERROR;
      }
    }
  /**
   * logic performed on the selected keys
   *
   * @param readyKeys
   * @param selectorHandler
   * @param serverCtx
   */
  private void handleSelectedKeys(
      Set<SelectionKey> readyKeys, SelectorHandler selectorHandler, NIOContext serverCtx) {
    for (SelectionKey key : readyKeys) {
      try {
        if (!key.isValid()) {
          selectorHandler.getSelectionKeyHandler().close(key);
          continue;
        }
        final int readyOps = key.readyOps();
        if ((readyOps & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
          if (readThreadsCount > 0
              && multiReadThreadSelectorHandler.supportsProtocol(selectorHandler.protocol())) {
            if (logger.isLoggable(Level.FINE)) {
              logger.log(
                  Level.FINE,
                  "OP_ACCEPT on "
                      + key
                      + " passed to multi readthread handler. Attachment: "
                      + key.attachment());
            }
            multiReadThreadSelectorHandler.onAcceptInterest(key, serverCtx);
          } else {
            if (logger.isLoggable(Level.FINE)) {
              logger.log(Level.FINE, "OP_ACCEPT on " + key + " attachment: " + key.attachment());
            }
            selectorHandler.onAcceptInterest(key, serverCtx);
          }
          continue;
        }
        if ((readyOps & SelectionKey.OP_CONNECT) == SelectionKey.OP_CONNECT) {
          if (logger.isLoggable(Level.FINE)) {
            logger.log(Level.FINE, "OP_CONNECT on " + key + " attachment: " + key.attachment());
          }
          selectorHandler.onConnectInterest(key, serverCtx);
          continue;
        }

        boolean delegateToWorker = false;
        OpType opType = null;
        boolean skipOpWrite = false;
        // OP_READ will always be processed first, then
        // based on the handleReadWriteConcurrently, the OP_WRITE
        // might be processed just after or during the next
        // Selector.select() invocation.
        if ((readyOps & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
          if (logger.isLoggable(Level.FINE)) {
            logger.log(Level.FINE, "OP_READ on " + key + " attachment: " + key.attachment());
          }
          delegateToWorker = selectorHandler.onReadInterest(key, serverCtx);
          if (delegateToWorker) {
            opType = OpType.OP_READ;
          }
          if (!handleReadWriteConcurrently) {
            skipOpWrite = true;
          }
        }
        // The OP_READ processing might have closed the
        // Selection, hence we must make sure the
        // SelectionKey is still valid.
        if (!skipOpWrite
            && key.isValid()
            && (readyOps & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
          if (logger.isLoggable(Level.FINE)) {
            logger.log(Level.FINE, "OP_WRITE on " + key + " attachment: " + key.attachment());
          }
          boolean opWriteDelegate = selectorHandler.onWriteInterest(key, serverCtx);
          delegateToWorker |= opWriteDelegate;
          if (opWriteDelegate) {
            if (opType == OpType.OP_READ) {
              opType = OpType.OP_READ_WRITE;
            } else {
              opType = OpType.OP_WRITE;
            }
          }
        }

        if (delegateToWorker) {
          NIOContext context = pollContext(key, opType);
          configureContext(context, selectorHandler);
          context.execute(ProtocolChainContextTask.poll());
        }
      } catch (Throwable e) {
        handleSelectException(e, selectorHandler, key);
      }
    }
  }
示例#13
0
  public static void checkClients(List<SocketChannel> anonymousClients) {
    try {

      if (selector.selectNow() == 0) {
        return;
      }

      Set<SelectionKey> keys = selector.selectedKeys();
      for (SelectionKey key : keys) {

        if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
          SocketChannel clientSocket = serverSocket.accept();
          if (clientSocket == null) {
            System.err.println("Error: can not accept");
            continue;
          }
          anonymousClients.add(clientSocket);
          clientSocket.configureBlocking(false);
          clientSocket.register(selector, SelectionKey.OP_READ);
        } else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
          SocketChannel clientSocket = (SocketChannel) key.channel();
          ByteBuffer bytes = ByteBuffer.allocate(4096);

          if (clientSocket.read(bytes) != -1) {
            byte[] message = bytes.array();
            switch (message[0]) {
              case 1:
                {
                  String nick = MessageUtils.parseMessage(message).first;
                  if (!checkMessage(nick, "", clientSocket)) {
                    continue;
                  }

                  if (clients.containsKey(nick) || nick.length() > 32) {
                    if (nick.length() > 32) {
                      sendMessage(
                          clientSocket, MessageUtils.error("<server>: your nick is too long"));
                    } else {
                      sendMessage(
                          clientSocket,
                          MessageUtils.error("<server>: another user is using this nick"));
                    }
                    sendMessage(clientSocket, MessageUtils.bye());
                    anonymousClients.remove(clientSocket);
                    Utils.tryClose(clientSocket);
                  } else {
                    System.out.println(nick + " enter this chatroom");
                    notifyAllClients(nick + " enter this chatroom");

                    sendMessage(
                        clientSocket,
                        MessageUtils.message("<server>", "Wellcome, your nick is " + nick));
                    anonymousClients.remove(clientSocket);
                    clients.put(nick, clientSocket);
                  }
                  break;
                }

              case 2:
                {
                  String nick = getNickFromSocket(clientSocket);
                  if (nick == null) {
                    Utils.printErrorAndExit("Error: it could not happen");
                  }

                  Utils.Pair<String, String> pair = MessageUtils.parseMessage(message);
                  if (!checkMessage(pair.first, pair.second, clientSocket)) {
                    continue;
                  }

                  if (!pair.first.equals(nick)) {
                    System.out.println("Cheater: " + nick);
                    sendMessage(clientSocket, MessageUtils.message("<server>", "do not cheat"));
                  }

                  for (Entry<String, SocketChannel> client : clients.entrySet()) {
                    if (!clientSocket.equals(client.getValue())) {
                      sendMessage(client.getValue(), MessageUtils.message(nick, pair.second));
                    }
                  }
                  break;
                }

              case 3:
                disconnectClient(clientSocket);
                break;

              case 127:
                {
                  String nick = getNickFromSocket(clientSocket);

                  Utils.Pair<String, String> pair = MessageUtils.parseMessage(message);
                  if (!checkMessage(pair.first, pair.second, clientSocket)) {
                    continue;
                  }

                  if (!pair.first.equals(nick)) {
                    System.out.println("Cheater: " + nick);
                    sendMessage(clientSocket, MessageUtils.message("<server>", "do not cheat"));
                  }
                  System.out.println(nick + ": " + pair.second);
                  break;
                }

              default:
                System.out.println("Bad message from " + getNickFromSocket(clientSocket));
                sendMessage(clientSocket, MessageUtils.message("<server>", "bad message"));
                break;
            }
          } else {
            disconnectClient(clientSocket);
          }
        }
      }
      keys.clear();
    } catch (Exception expt) {
      expt.printStackTrace();
      Utils.printErrorAndExit(expt.getMessage());
    }
  }
示例#14
0
  @Test
  public void testSelector() throws Exception {
    ServerSocket acceptor = new ServerSocket(0);

    Selector selector = Selector.open();

    // Create client server socket pair
    SocketChannel client = SocketChannel.open(acceptor.getLocalSocketAddress());
    Socket server = acceptor.accept();
    server.setTcpNoDelay(true);

    // Make the client non blocking and register it with selector for reads
    client.configureBlocking(false);
    SelectionKey key = client.register(selector, SelectionKey.OP_READ);

    // assert it is not selected
    assertTrue(key.isValid());
    assertFalse(key.isReadable());
    assertEquals(0, key.readyOps());

    // try selecting and assert nothing selected
    int selected = selector.selectNow();
    assertEquals(0, selected);
    assertEquals(0, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertFalse(key.isReadable());
    assertEquals(0, key.readyOps());

    // Write a byte from server to client
    server.getOutputStream().write(42);
    server.getOutputStream().flush();

    // select again and assert selection found for read
    selected = selector.select(1000);
    assertEquals(1, selected);
    assertEquals(1, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertTrue(key.isReadable());
    assertEquals(1, key.readyOps());

    // select again and see that it is not reselect, but stays selected
    selected = selector.select(100);
    assertEquals(0, selected);
    assertEquals(1, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertTrue(key.isReadable());
    assertEquals(1, key.readyOps());

    // read the byte
    ByteBuffer buf = ByteBuffer.allocate(1024);
    int len = client.read(buf);
    assertEquals(1, len);
    buf.flip();
    assertEquals(42, buf.get());
    buf.clear();

    // But this does not change the key
    assertTrue(key.isValid());
    assertTrue(key.isReadable());
    assertEquals(1, key.readyOps());

    // Even if we select again ?
    selected = selector.select(100);
    assertEquals(0, selected);
    assertEquals(1, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertTrue(key.isReadable());
    assertEquals(1, key.readyOps());

    // Unless we remove the key from the select set
    // and then it is still flagged as isReadable()
    selector.selectedKeys().clear();
    assertEquals(0, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertTrue(key.isReadable());
    assertEquals(1, key.readyOps());

    // Now if we select again - it is still flagged as readable!!!
    selected = selector.select(100);
    assertEquals(0, selected);
    assertEquals(0, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertTrue(key.isReadable());
    assertEquals(1, key.readyOps());

    // Only when it is selected for something else does that state change.
    key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
    selected = selector.select(1000);
    assertEquals(1, selected);
    assertEquals(1, selector.selectedKeys().size());
    assertTrue(key.isValid());
    assertTrue(key.isWritable());
    assertFalse(key.isReadable());
    assertEquals(SelectionKey.OP_WRITE, key.readyOps());
  }
示例#15
0
  public static void main(String[] args) throws Exception {
    Selector selector = Selector.open();
    Member mbr = new MemberImpl("localhost", 9999, 0);
    ChannelData data = new ChannelData();
    data.setOptions(Channel.SEND_OPTIONS_BYTE_MESSAGE);
    data.setAddress(mbr);
    byte[] buf = new byte[8192 * 4];
    data.setMessage(new XByteBuffer(buf, false));
    buf = XByteBuffer.createDataPackage(data);
    int len = buf.length;
    BigDecimal total = new BigDecimal((double) 0);
    BigDecimal bytes = new BigDecimal((double) len);
    NioSender sender = new NioSender();
    sender.setDestination(mbr);
    sender.setDirectBuffer(true);
    sender.setSelector(selector);
    sender.setTxBufSize(1024 * 1024);
    sender.connect();
    sender.setMessage(buf);
    System.out.println("Writing to 9999");
    long start = 0;
    double mb = 0;
    boolean first = true;
    int count = 0;
    DecimalFormat df = new DecimalFormat("##.00");
    while (count < 100000) {
      if (first) {
        first = false;
        start = System.currentTimeMillis();
      }
      sender.setMessage(buf);
      int selectedKeys = 0;
      try {
        selectedKeys = selector.select(0);
      } catch (Exception e) {
        e.printStackTrace();
        continue;
      }

      if (selectedKeys == 0) {
        continue;
      }

      Iterator it = selector.selectedKeys().iterator();
      while (it.hasNext()) {
        SelectionKey sk = (SelectionKey) it.next();
        it.remove();
        try {
          int readyOps = sk.readyOps();
          sk.interestOps(sk.interestOps() & ~readyOps);
          if (sender.process(sk, false)) {
            total = total.add(bytes);
            sender.reset();
            sender.setMessage(buf);
            mb += ((double) len) / 1024 / 1024;
            if (((++count) % 10000) == 0) {
              long time = System.currentTimeMillis();
              double seconds = ((double) (time - start)) / 1000;
              System.out.println(
                  "Throughput "
                      + df.format(mb / seconds)
                      + " MB/seconds, total "
                      + mb
                      + " MB, total "
                      + total
                      + " bytes.");
            }
          }

        } catch (Throwable t) {
          t.printStackTrace();
          return;
        }
      }
      selector.selectedKeys().clear();
    }
    System.out.println("Complete, sleeping 15 seconds");
    Thread.sleep(15000);
  }
示例#16
0
文件: Nio4r.java 项目: tpetchel/nio4r
 @JRubyMethod
 public IRubyObject readiness(ThreadContext context) {
   return Nio4r.interestOpsToSymbol(context.getRuntime(), key.readyOps());
 }
示例#17
0
文件: Reactor.java 项目: checkes/hs4j
  /**
   * Dispatch selected event
   *
   * @param selectedKeySet
   */
  public final void dispatchEvent(Set<SelectionKey> selectedKeySet) {
    Iterator<SelectionKey> it = selectedKeySet.iterator();
    boolean skipOpRead = false;
    while (it.hasNext()) {
      SelectionKey key = it.next();
      it.remove();
      if (!key.isValid()) {
        if (key.attachment() != null) {
          controller.closeSelectionKey(key);
        } else {
          key.cancel();
        }
        continue;
      }
      try {
        if (key.isValid() && key.isAcceptable()) {
          controller.onAccept(key);
          continue;
        }
        if (key.isValid() && (key.readyOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
          // Remove write interest
          key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
          controller.onWrite(key);
          if (!controller.isHandleReadWriteConcurrently()) {
            skipOpRead = true;
          }
        }
        if (!skipOpRead
            && key.isValid()
            && (key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
          key.interestOps(key.interestOps() & ~SelectionKey.OP_READ);
          if (!controller.getStatistics().isReceiveOverFlow()) {
            // Remove read interest
            controller.onRead(key);
          } else {
            key.interestOps(key.interestOps() | SelectionKey.OP_READ);
          }
        }
        if ((key.readyOps() & SelectionKey.OP_CONNECT) == SelectionKey.OP_CONNECT) {
          controller.onConnect(key);
        }

      } catch (CancelledKeyException e) {
        // ignore
      } catch (RejectedExecutionException e) {

        if (key.attachment() instanceof AbstractNioSession) {
          ((AbstractNioSession) key.attachment()).onException(e);
        }
        controller.notifyException(e);
        if (selector.isOpen()) {
          continue;
        } else {
          break;
        }
      } catch (Exception e) {
        if (key.attachment() instanceof AbstractNioSession) {
          ((AbstractNioSession) key.attachment()).onException(e);
        }
        controller.closeSelectionKey(key);
        controller.notifyException(e);
        log.error("Reactor dispatch events error", e);
        if (selector.isOpen()) {
          continue;
        } else {
          break;
        }
      }
    }
  }
示例#18
0
  private void go() throws IOException {
    // Create a new selector
    Selector selector = Selector.open();

    // Open a listener on each port, and register each one
    // with the selector
    for (int i = 0; i < ports.length; ++i) {
      ServerSocketChannel ssc = ServerSocketChannel.open();
      ssc.configureBlocking(false);
      ServerSocket ss = ssc.socket();
      InetSocketAddress address = new InetSocketAddress(ports[i]);
      ss.bind(address);

      SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);

      System.out.println("Going to listen on " + ports[i]);
    }

    while (true) {
      int num = selector.select();

      Set selectedKeys = selector.selectedKeys();
      Iterator it = selectedKeys.iterator();

      while (it.hasNext()) {
        SelectionKey key = (SelectionKey) it.next();

        if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
          // Accept the new connection
          ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
          SocketChannel sc = ssc.accept();
          sc.configureBlocking(false);

          // Add the new connection to the selector
          SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
          it.remove();

          System.out.println("Got connection from " + sc);
        } else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
          // Read the data
          SocketChannel sc = (SocketChannel) key.channel();

          // Echo data
          int bytesEchoed = 0;
          while (true) {
            echoBuffer.clear();

            int r = sc.read(echoBuffer);

            if (r <= 0) {
              break;
            }

            echoBuffer.flip();

            sc.write(echoBuffer);
            bytesEchoed += r;
          }

          System.out.println("Echoed " + bytesEchoed + " from " + sc);

          it.remove();
        }
      }

      // System.out.println( "going to clear" );
      //      selectedKeys.clear();
      // System.out.println( "cleared" );
    }
  }
示例#19
0
  public void run() {

    Selector selector = null;
    try {
      curSocketChannel = SocketChannel.open();
      InetSocketAddress isa = new InetSocketAddress(curHost, curPort);
      curSocketChannel.connect(isa);
      curSocketChannel.configureBlocking(false);
      selector = Selector.open();
      curSocketChannel.register(selector, SelectionKey.OP_READ);
      servers.put(curHost, curSocketChannel);
      send(curSocketChannel, MessageUtils.hello(clientName));
    } catch (Exception ex) {
      System.err.println("Error in getting connection: " + ex.getMessage());
      System.exit(1);
    }

    try {
      while (true) {
        int num = selector.select();
        if (num == 0) {
          continue;
        }
        Set keys = selector.selectedKeys();
        Iterator it = keys.iterator();
        while (it.hasNext()) {
          SelectionKey key = (SelectionKey) it.next();
          if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
            SocketChannel sc = null;
            try {
              sc = (SocketChannel) key.channel();
              if (sc.equals(curSocketChannel)) {
                boolean ok = processInput(sc);
                if (!ok) {
                  key.cancel();
                  Socket s = null;
                  try {
                    s = sc.socket();
                    s.close();
                  } catch (IOException ie) {
                    System.err.println("Error closing socket " + s + ": " + ie);
                    System.exit(1);
                  }
                }
              }
            } catch (IOException ie) {
              key.cancel();
              String serverToQuitFrom = getKey(sc);
              if (serverToQuitFrom != null) {
                IOUtils.closeFile(serverToQuitFrom, sc);
                servers.remove(serverToQuitFrom);
                System.out.println(serverToQuitFrom + " was closed.");
              }
            }
          }
        }
        keys.clear();
      }
    } catch (Exception ex) {
      System.err.println(ex.getMessage());
      System.exit(1);
    }
  }
  public int doLoop(long selectTimeOut, int maxAttempts, boolean waitForAck, ChannelMessage msg)
      throws IOException, ChannelException, RemoteException {
    try {
      int completed = 0;
      int selectedKeys = selector.select(selectTimeOut);

      if (selectedKeys == 0) {
        return 0;
      }

      Iterator<SelectionKey> it = selector.selectedKeys().iterator();
      while (it.hasNext()) {
        SelectionKey sk = it.next();
        it.remove();
        int readyOps = sk.readyOps();
        sk.interestOps(sk.interestOps() & ~readyOps);
        org.apache.catalina.tribes.transport.nio.NioSenderRemoteInterface sender =
            (org.apache.catalina.tribes.transport.nio.NioSenderRemoteInterface) sk.attachment();
        try {
          if (sender.process(sk, waitForAck)) {
            completed++;
            sender.setComplete(true);
            if (Logs.getMessages().isTraceEnabled()) {
              Logs.getMessages()
                  .trace(
                      "ParallelNioSender - Sent msg:"
                          + new UniqueId(msg.getUniqueId())
                          + " at "
                          + new java.sql.Timestamp(System.currentTimeMillis())
                          + " to "
                          + sender.getDestination().getName());
            }
            SenderState.getSenderState(sender.getDestination()).setReady();
          } // end if
        } catch (Exception x) {
          if (log.isTraceEnabled()) {
            log.trace("Error while processing send to " + sender.getDestination().getName(), x);
          }
          org.apache.catalina.tribes.transport.SenderStateRemoteInterface state =
              gerenciadornuvem0.SenderStategetSenderState(sender.getDestination());
          int attempt = sender.getAttempt() + 1;
          boolean retry = (sender.getAttempt() <= maxAttempts && maxAttempts > 0);
          synchronized (state) {

            // sk.cancel();
            if (state.isSuspect()) state.setFailing();
            if (state.isReady()) {
              state.setSuspect();
              if (retry)
                log.warn(
                    "Member send is failing for:"
                        + sender.getDestination().getName()
                        + " ; Setting to suspect and retrying.");
              else
                log.warn(
                    "Member send is failing for:"
                        + sender.getDestination().getName()
                        + " ; Setting to suspect.",
                    x);
            }
          }
          if (!isConnected()) {
            log.warn(
                "Not retrying send for:"
                    + sender.getDestination().getName()
                    + "; Sender is disconnected.");
            ChannelException cx =
                gerenciadornuvem1.getChannelException(
                    "Send failed, and sender is disconnected. Not retrying.", x);
            cx.addFaultyMember(sender.getDestination(), x);
            throw cx;
          }

          byte[] data = sender.getMessage();
          if (retry) {
            try {
              sender.disconnect();
              sender.connect();
              sender.setAttempt(attempt);
              sender.setMessage(data);
            } catch (Exception ignore) {
              state.setFailing();
            }
          } else {
            ChannelException cx =
                gerenciadornuvem1.getChannelException(
                    "Send failed, attempt:" + sender.getAttempt() + " max:" + maxAttempts, x);
            cx.addFaultyMember(sender.getDestination(), x);
            throw cx;
          } // end if
        }
      }
      return completed;

    } catch (Exception excp) {
      excp.printStackTrace();
    }
    return 0;
  }