Exemplo n.º 1
0
 @Test
 public void testMultipleServerClose() {
   this.server =
       vertx.createHttpServer(new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTP_PORT));
   AtomicInteger times = new AtomicInteger();
   // We assume the endHandler and the close completion handler are invoked in the same context
   // task
   ThreadLocal stack = new ThreadLocal();
   stack.set(true);
   server
       .websocketStream()
       .endHandler(
           v -> {
             assertNull(stack.get());
             assertTrue(Vertx.currentContext().isEventLoopContext());
             times.incrementAndGet();
           });
   server.close(
       ar1 -> {
         assertNull(stack.get());
         assertTrue(Vertx.currentContext().isEventLoopContext());
         server.close(
             ar2 -> {
               server.close(
                   ar3 -> {
                     assertEquals(1, times.get());
                     testComplete();
                   });
             });
       });
   await();
 }
Exemplo n.º 2
0
 @Test
 public void testWebsocketStreamCallbackAsynchronously() {
   this.server =
       vertx.createHttpServer(new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTP_PORT));
   AtomicInteger done = new AtomicInteger();
   ServerWebSocketStream stream = server.websocketStream();
   stream.handler(req -> {});
   ThreadLocal<Object> stack = new ThreadLocal<>();
   stack.set(true);
   stream.endHandler(
       v -> {
         assertTrue(Vertx.currentContext().isEventLoopContext());
         assertNull(stack.get());
         if (done.incrementAndGet() == 2) {
           testComplete();
         }
       });
   server.listen(
       ar -> {
         assertTrue(Vertx.currentContext().isEventLoopContext());
         assertNull(stack.get());
         ThreadLocal<Object> stack2 = new ThreadLocal<>();
         stack2.set(true);
         server.close(
             v -> {
               assertTrue(Vertx.currentContext().isEventLoopContext());
               assertNull(stack2.get());
               if (done.incrementAndGet() == 2) {
                 testComplete();
               }
             });
         stack2.set(null);
       });
   await();
 }
Exemplo n.º 3
0
 @Test
 public void testWebsocketPauseAndResume() {
   client.close();
   client = vertx.createHttpClient(new HttpClientOptions().setConnectTimeout(1000));
   String path = "/some/path";
   this.server =
       vertx.createHttpServer(
           new HttpServerOptions().setAcceptBacklog(1).setPort(HttpTestBase.DEFAULT_HTTP_PORT));
   AtomicBoolean paused = new AtomicBoolean();
   ReadStream<ServerWebSocket> stream = server.websocketStream();
   stream.handler(
       ws -> {
         assertFalse(paused.get());
         ws.writeMessage(Buffer.buffer("whatever"));
         ws.close();
       });
   server.listen(
       listenAR -> {
         assertTrue(listenAR.succeeded());
         stream.pause();
         paused.set(true);
         client
             .websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path)
             .exceptionHandler(
                 err -> {
                   assertTrue(paused.get());
                   assertTrue(err instanceof WebSocketHandshakeException);
                   paused.set(false);
                   stream.resume();
                   client.connectWebsocket(
                       HttpTestBase.DEFAULT_HTTP_PORT,
                       HttpTestBase.DEFAULT_HTTP_HOST,
                       path,
                       ws -> {
                         ws.handler(
                             buffer -> {
                               assertEquals("whatever", buffer.toString("UTF-8"));
                               ws.closeHandler(
                                   v2 -> {
                                     testComplete();
                                   });
                             });
                       });
                 })
             .handler(ws -> fail());
       });
   await();
 }
Exemplo n.º 4
0
 @Test
 public void testClosingServerClosesWebSocketStreamEndHandler() {
   this.server =
       vertx.createHttpServer(new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTP_PORT));
   ReadStream<ServerWebSocket> stream = server.websocketStream();
   AtomicBoolean closed = new AtomicBoolean();
   stream.endHandler(v -> closed.set(true));
   stream.handler(ws -> {});
   server.listen(
       ar -> {
         assertTrue(ar.succeeded());
         assertFalse(closed.get());
         server.close(
             v -> {
               assertTrue(ar.succeeded());
               assertTrue(closed.get());
               testComplete();
             });
       });
   await();
 }