Example #1
0
  /**
   * @param args
   * @throws IOException
   */
  public static void main(String[] args) throws IOException {
    // Create a FilterChain using FilterChainBuilder
    FilterChainBuilder filterChainBuilder = FilterChainBuilder.stateless();

    // Add TransportFilter, which is responsible
    // for reading and writing data to the connection
    filterChainBuilder.add(new TransportFilter());

    // StringFilter is responsible for Buffer <-> String conversion
    filterChainBuilder.add(new StringFilter(Charset.forName("UTF-8")));

    // EchoFilter is responsible for echoing received messages
    filterChainBuilder.add(new EchoFilter());

    // Create TCP transport
    final TCPNIOTransport transport = TCPNIOTransportBuilder.newInstance().build();

    transport.setProcessor(filterChainBuilder.build());

    // binding transport to start listen on certain host and port
    transport.bind(HOST, PORT);

    // start the transport
    transport.start();
  }
    public void run() throws IOException {
      final FutureImpl<String> completeFuture = SafeFutureImpl.create();

      // Build HTTP client filter chain
      FilterChainBuilder clientFilterChainBuilder = FilterChainBuilder.newInstance();
      // Add transport filter
      clientFilterChainBuilder.add(new TransportFilter());

      // Add HttpClientFilter, which transforms Buffer <-> HttpContent
      clientFilterChainBuilder.add(new HttpClientFilter());
      // Add ClientFilter
      clientFilterChainBuilder.add(new ClientFilter(completeFuture));

      // Initialize Transport
      final TCPNIOTransport transport = TCPNIOTransportBuilder.newInstance().build();
      // Set filterchain as a Transport Processor
      transport.setFilterChain(clientFilterChainBuilder.build());

      try {
        // start the transport
        transport.start();

        Connection connection = null;

        // Connecting to a remote Web server
        Future<Connection> connectFuture = transport.connect(HOST, PORT);
        try {
          // Wait until the client connect operation will be completed
          // Once connection has been established, the POST will
          // be sent to the server.
          connection = connectFuture.get(10, TimeUnit.SECONDS);

          // Wait no longer than 30 seconds for the response from the
          // server to be complete.
          String result = completeFuture.get(30, TimeUnit.SECONDS);

          // Display the echoed content
          System.out.println("\nEchoed POST Data: " + result + '\n');
        } catch (Exception e) {
          if (connection == null) {
            LOGGER.log(Level.WARNING, "Connection failed.  Server is not listening.");
          } else {
            LOGGER.log(Level.WARNING, "Unexpected error communicating with the server.");
          }
        } finally {
          // Close the client connection
          if (connection != null) {
            connection.closeSilently();
          }
        }
      } finally {
        // shutdownNow the transport
        transport.shutdownNow();
      }
    }
Example #3
0
  private HttpServer createHttpServer() {
    final HttpServer server = new HttpServer();

    final int requestSize = (int) currentConfig.getMaxRequestSize();
    final ServerConfiguration serverConfig = server.getServerConfiguration();
    serverConfig.setMaxBufferedPostSize(requestSize);
    serverConfig.setMaxFormPostSize(requestSize);
    serverConfig.setDefaultQueryEncoding(Charsets.UTF8_CHARSET);

    if (keepStats()) {
      setHttpStatsProbe(server);
    }

    // Configure the network listener
    final NetworkListener listener =
        new NetworkListener(
            "Rest2LDAP", NetworkListener.DEFAULT_NETWORK_HOST, initConfig.getListenPort());
    server.addListener(listener);

    // Configure the network transport
    final TCPNIOTransport transport = listener.getTransport();
    transport.setReuseAddress(currentConfig.isAllowTCPReuseAddress());
    transport.setKeepAlive(currentConfig.isUseTCPKeepAlive());
    transport.setTcpNoDelay(currentConfig.isUseTCPNoDelay());
    transport.setWriteTimeout(currentConfig.getMaxBlockedWriteTimeLimit(), TimeUnit.MILLISECONDS);

    final int bufferSize = (int) currentConfig.getBufferSize();
    transport.setReadBufferSize(bufferSize);
    transport.setWriteBufferSize(bufferSize);
    transport.setIOStrategy(SameThreadIOStrategy.getInstance());

    final int numRequestHandlers =
        getNumRequestHandlers(currentConfig.getNumRequestHandlers(), friendlyName);
    transport.setSelectorRunnersCount(numRequestHandlers);
    transport.setServerConnectionBackLog(currentConfig.getAcceptBacklog());

    // Configure SSL
    if (sslEngineConfigurator != null) {
      listener.setSecure(true);
      listener.setSSLEngineConfig(sslEngineConfigurator);
    }

    return server;
  }
  @Test
  public void testCustomThreadPoolSameThreadStrategy() throws Exception {

    final int poolSize = Math.max(Runtime.getRuntime().availableProcessors() / 2, 1);
    final ThreadPoolConfig poolCfg = ThreadPoolConfig.defaultConfig();
    poolCfg.setCorePoolSize(poolSize).setMaxPoolSize(poolSize);

    final TCPNIOTransport tcpTransport =
        TCPNIOTransportBuilder.newInstance()
            .setReuseAddress(true)
            .setIOStrategy(SameThreadIOStrategy.getInstance())
            .setSelectorThreadPoolConfig(poolCfg)
            .setWorkerThreadPoolConfig(null)
            .build();
    try {
      tcpTransport.start();
    } finally {
      tcpTransport.shutdownNow();
    }
  }
  protected NIOTransport configureTCPTransport(final Transport transportConfig) {

    final TCPNIOTransport tcpTransport =
        configureDefaultThreadPoolConfigs(TCPNIOTransportBuilder.newInstance().build());
    tcpTransport.setTcpNoDelay(Boolean.parseBoolean(transportConfig.getTcpNoDelay()));
    tcpTransport.setLinger(Integer.parseInt(transportConfig.getLinger()));
    tcpTransport.setWriteTimeout(
        Long.parseLong(transportConfig.getWriteTimeoutMillis()), TimeUnit.MILLISECONDS);
    tcpTransport.setReadTimeout(
        Long.parseLong(transportConfig.getReadTimeoutMillis()), TimeUnit.MILLISECONDS);
    tcpTransport.setServerConnectionBackLog(
        Integer.parseInt(transportConfig.getMaxConnectionsCount()));
    return tcpTransport;
  }
  public static void main(String[] args) throws Exception {
    Connection connection = null;

    // Construct the client filter chain
    final FilterChainBuilder puFilterChainBuilder =
        FilterChainBuilder.stateless()
            // Add TransportFilter
            .add(new TransportFilter())
            // Add ADD-service message parser/serializer
            .add(new AddClientMessageFilter())
            // Add Result reporter Filter
            .add(new ResultFilter());

    // Construct TCPNIOTransport
    final TCPNIOTransport transport = TCPNIOTransportBuilder.newInstance().build();
    transport.setProcessor(puFilterChainBuilder.build());

    try {
      // Start
      transport.start();

      // Create the client connection
      final Future<Connection> connectFuture = transport.connect("localhost", PUServer.PORT);
      connection = connectFuture.get(10, TimeUnit.SECONDS);

      LOGGER.info("Enter 2 numbers separated by space (<value1> <value2>) end press <enter>.");
      LOGGER.info("Type q and enter to exit.");

      // Read user input and communicate the ADD-service
      String line;
      BufferedReader reader =
          new BufferedReader(new InputStreamReader(System.in, Charsets.ASCII_CHARSET));
      while ((line = reader.readLine()) != null) {
        if ("q".equals(line)) {
          break;
        }

        // Parse user input
        final int value1;
        final int value2;
        try {
          final String[] values = line.split(" ");

          value1 = Integer.parseInt(values[0].trim());
          value2 = Integer.parseInt(values[1].trim());
        } catch (Exception e) {
          LOGGER.warning("Bad format, repeat pls");
          continue;
        }

        // send the request to ADD-service
        final GrizzlyFuture<WriteResult> writeFuture =
            connection.write(new AddRequestMessage(value1, value2));

        final WriteResult result = writeFuture.get(10, TimeUnit.SECONDS);
        assert result != null;
      }

    } finally {
      // Close the client connection
      if (connection != null) {
        connection.closeSilently();
      }

      // Shutdown the transport
      transport.shutdownNow();
    }
  }
  public void testStandalone() throws Exception {
    TCPNIOTransport transport = TCPNIOTransportBuilder.newInstance().build();
    transport.getAsyncQueueIO().getWriter().setMaxPendingBytesPerConnection(-1);

    int messageSize = 166434;

    Connection connection = null;
    StreamReader reader = null;
    StreamWriter writer = null;

    try {
      // Enable standalone mode
      transport.configureStandalone(true);

      // Start listen on specific port
      final TCPNIOServerConnection serverConnection = transport.bind(PORT);
      // Start transport
      transport.start();

      // Start echo server thread
      final Thread serverThread = startEchoServerThread(transport, serverConnection, messageSize);

      // Connect to the server
      Future<Connection> connectFuture = transport.connect("localhost", PORT);
      connection = connectFuture.get(10, TimeUnit.SECONDS);
      assertTrue(connectFuture.isDone());

      // fill out buffer
      byte[] buffer = new byte[messageSize];
      for (int i = 0; i < messageSize; i++) {
        buffer[i] = (byte) (i % 128);
      }
      // write buffer
      writer = StandaloneProcessor.INSTANCE.getStreamWriter(connection);
      writer.writeByteArray(buffer);
      writer.flush();

      reader = StandaloneProcessor.INSTANCE.getStreamReader(connection);

      // prepare receiving buffer
      byte[] receiveBuffer = new byte[messageSize];

      Future readFuture = reader.notifyAvailable(messageSize);
      readFuture.get(20, TimeUnit.SECONDS);

      // Read the response.
      reader.readByteArray(receiveBuffer);

      assertTrue(readFuture.isDone());

      // Check the echo result
      assertTrue(Arrays.equals(buffer, receiveBuffer));

      serverThread.join(10 * 1000);
    } finally {
      if (connection != null) {
        connection.closeSilently();
      }

      transport.shutdownNow();
    }
  }
  public void testBlockingRead() throws Exception {
    final String[] clientMsgs = {"XXXXX", "Hello", "from", "client"};

    Connection connection = null;
    int messageNum = 3;

    final BlockingQueue<String> intermResultQueue = DataStructures.getLTQInstance(String.class);

    final PUFilter puFilter = new PUFilter();
    FilterChain subProtocolChain =
        puFilter
            .getPUFilterChainBuilder()
            .add(new MergeFilter(clientMsgs.length, intermResultQueue))
            .add(new EchoFilter())
            .build();

    puFilter.register(new SimpleProtocolFinder(clientMsgs[0]), subProtocolChain);

    FilterChainBuilder filterChainBuilder = FilterChainBuilder.newInstance();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new StringFilter());
    filterChainBuilder.add(puFilter);

    final TCPNIOTransport transport = TCPNIOTransportBuilder.newInstance().build();
    transport.setFilterChain(filterChainBuilder.build());

    try {
      transport.bind(PORT);
      transport.start();

      final BlockingQueue<String> resultQueue = DataStructures.getLTQInstance(String.class);

      Future<Connection> future = transport.connect("localhost", PORT);
      connection = future.get(10, TimeUnit.SECONDS);
      assertTrue(connection != null);

      FilterChainBuilder clientFilterChainBuilder = FilterChainBuilder.newInstance();
      clientFilterChainBuilder.add(new TransportFilter());
      clientFilterChainBuilder.add(new StringFilter());
      clientFilterChainBuilder.add(
          new BaseFilter() {

            @Override
            public NextAction handleRead(FilterChainContext ctx) throws IOException {
              resultQueue.add((String) ctx.getMessage());
              return ctx.getStopAction();
            }
          });
      final FilterChain clientFilterChain = clientFilterChainBuilder.build();

      connection.setFilterChain(clientFilterChain);

      for (int i = 0; i < messageNum; i++) {
        String clientMessage = "";

        for (int j = 0; j < clientMsgs.length; j++) {
          String msg = clientMsgs[j] + "-" + i;
          Future<WriteResult> writeFuture = connection.write(msg);

          assertTrue("Write timeout loop: " + i, writeFuture.get(10, TimeUnit.SECONDS) != null);

          final String srvInterm = intermResultQueue.poll(10, TimeUnit.SECONDS);

          assertEquals("Unexpected interm. response (" + i + ", " + j + ")", msg, srvInterm);

          clientMessage += msg;
        }

        final String message = resultQueue.poll(10, TimeUnit.SECONDS);

        assertEquals("Unexpected response (" + i + ")", clientMessage, message);
      }
    } finally {
      if (connection != null) {
        connection.closeSilently();
      }

      transport.shutdownNow();
    }
  }
  public void testBlockingReadError() throws Exception {
    final String[] clientMsgs = {"ZZZZZ", "Hello", "from", "client"};

    Connection connection = null;

    final BlockingQueue intermResultQueue = DataStructures.getLTQInstance();

    final PUFilter puFilter = new PUFilter();
    FilterChain subProtocolChain =
        puFilter
            .getPUFilterChainBuilder()
            .add(new MergeFilter(clientMsgs.length, intermResultQueue))
            .add(new EchoFilter())
            .build();

    puFilter.register(new SimpleProtocolFinder(clientMsgs[0]), subProtocolChain);

    FilterChainBuilder filterChainBuilder = FilterChainBuilder.newInstance();
    filterChainBuilder.add(new TransportFilter());
    filterChainBuilder.add(new StringFilter());
    filterChainBuilder.add(puFilter);

    TCPNIOTransport transport = TCPNIOTransportBuilder.newInstance().build();
    transport.setFilterChain(filterChainBuilder.build());

    try {
      transport.bind(PORT);
      transport.start();

      Future<Connection> future = transport.connect("localhost", PORT);
      connection = future.get(10, TimeUnit.SECONDS);
      assertTrue(connection != null);

      FilterChainBuilder clientFilterChainBuilder = FilterChainBuilder.newInstance();
      clientFilterChainBuilder.add(new TransportFilter());
      clientFilterChainBuilder.add(new StringFilter());
      final FilterChain clientFilterChain = clientFilterChainBuilder.build();

      connection.setFilterChain(clientFilterChain);

      String msg = clientMsgs[0];
      Future<WriteResult> writeFuture = connection.write(msg);

      assertTrue("Write timeout", writeFuture.get(10, TimeUnit.SECONDS) != null);

      final String srvInterm = (String) intermResultQueue.poll(10, TimeUnit.SECONDS);

      assertEquals("Unexpected interm. response", msg, srvInterm);

      connection.closeSilently();
      connection = null;

      final Exception e = (Exception) intermResultQueue.poll(10, TimeUnit.SECONDS);

      assertTrue(
          "Unexpected response. Exception: " + e.getClass() + ": " + e.getMessage(),
          e instanceof IOException);
    } finally {
      if (connection != null) {
        connection.closeSilently();
      }

      transport.shutdownNow();
    }
  }