@Test public void testUpgradeInvalidRequest() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(request -> { try { request.upgrade(); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } testComplete(); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", resp -> { }).end(); }); await(); }
private void testInvalidHandshake(Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> requestProvider, boolean expectEvent, boolean upgradeRequest, int expectedStatus) { if (upgradeRequest) { server = vertx.createHttpServer().websocketHandler(ws -> { // Check we can get notified // handshake fails after this method returns and does not reject the ws assertTrue(expectEvent); }); } else { server = vertx.createHttpServer().requestHandler(req -> { try { req.upgrade(); } catch (Exception e) { // Expected } }); } server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(ar -> { HttpClientRequest req = requestProvider.apply(onSuccess(resp -> { assertEquals(expectedStatus, resp.statusCode()); resp.endHandler(v1 -> { testComplete(); }); })); req.end(); })); }
server.requestHandler(request -> { Runnable runner = () -> { ServerWebSocket ws = request.upgrade(); ws.handler(buff -> { ws.write(Buffer.buffer("helloworld"));
@Override public ServerWebSocket upgrade() { return delegate.upgrade(); }
@Test public void testWebsocketAbs() { SelfSignedCertificate certificate = SelfSignedCertificate.create(); HttpServerOptions serverOptions = new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTPS_PORT) .setSsl(true) .setKeyCertOptions(certificate.keyCertOptions()); HttpClientOptions clientOptions = new HttpClientOptions() .setTrustAll(true) .setVerifyHost(false); client = vertx.createHttpClient(clientOptions); server = vertx.createHttpServer(serverOptions).requestHandler(request -> { if ("/test".equals(request.path())) { request.upgrade().close(); } else { request.response().end(); } }).listen(onSuccess(server -> { String url = "wss://" + clientOptions.getDefaultHost() + ":" + HttpTestBase.DEFAULT_HTTPS_PORT + "/test"; client.websocketAbs(url, null, null, null, ws -> { ws.closeHandler(v -> { testComplete(); }); }, null); })); await(); }
@Test public void testServerWebSocketUpgrade() { server = vertx.createHttpServer(); server.requestHandler(req -> { FakeHttpServerMetrics metrics = FakeMetricsBase.getMetrics(server); assertNotNull(metrics.getMetric(req)); ServerWebSocket ws = req.upgrade(); assertNull(metrics.getMetric(req)); WebSocketMetric metric = metrics.getMetric(ws); assertNotNull(metric); assertNotNull(metric.soMetric); ws.handler(buffer -> ws.write(buffer)); ws.closeHandler(closed -> { WebSocketMetric a = metrics.getMetric(ws); assertNull(a); testComplete(); }); }); server.listen(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, ar -> { assertTrue(ar.succeeded()); client = vertx.createHttpClient(); client.websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.write(Buffer.buffer("wibble")); ws.handler(buff -> { ws.close(); }); }); }); await(); }
RawWebSocketTransport(Vertx vertx, Router router, Handler<SockJSSocket> sockHandler) { String wsRE = "/websocket"; router.get(wsRE).handler(rc -> { ServerWebSocket ws = rc.request().upgrade(); SockJSSocket sock = new RawWSSockJSSocket(vertx, rc.session(), rc.user(), ws); sockHandler.handle(sock); }); router.get(wsRE).handler(rc -> rc.response().setStatusCode(400).end("Can \"Upgrade\" only to \"WebSocket\".")); router.get(wsRE).handler(rc -> rc.response().putHeader("Allow", "GET").setStatusCode(405).end()); }
@Override public ServerWebSocket upgrade() { return request.upgrade(); }
@Override public ServerWebSocket upgrade() { return delegate.upgrade(); }
@Override public ServerWebSocket upgrade() { return wrapped.upgrade(); }
@Override public ServerWebSocket upgrade() { return request.upgrade(); }
@Test public void testUpgradeInvalidRequest() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(request -> { try { request.upgrade(); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } testComplete(); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", resp -> { }).end(); }); await(); }
private void testInvalidHandshake(Function<Handler<HttpClientResponse>, HttpClientRequest> requestProvider, boolean expectEvent, boolean upgradeRequest, int expectedStatus) { if (upgradeRequest) { server = vertx.createHttpServer().websocketHandler(ws -> { // Check we can get notified // handshake fails after this method returns and does not reject the ws assertTrue(expectEvent); }); } else { server = vertx.createHttpServer().requestHandler(req -> { try { req.upgrade(); } catch (Exception e) { // Expected } }); } server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(ar -> { HttpClientRequest req = requestProvider.apply(resp -> { assertEquals(expectedStatus, resp.statusCode()); resp.endHandler(v1 -> { testComplete(); }); }); req.end(); })); }
server.requestHandler(request -> { Runnable runner = () -> { ServerWebSocket ws = request.upgrade(); ws.handler(buff -> { ws.write(Buffer.buffer("helloworld"));
WebSocketTransport(Vertx vertx, Router router, LocalMap<String, SockJSSession> sessions, SockJSHandlerOptions options, Handler<SockJSSocket> sockHandler) { super(vertx, sessions, options); String wsRE = COMMON_PATH_ELEMENT_RE + "websocket"; router.getWithRegex(wsRE).handler(rc -> { HttpServerRequest req = rc.request(); String connectionHeader = req.headers().get(io.vertx.core.http.HttpHeaders.CONNECTION); if (connectionHeader == null || !connectionHeader.toLowerCase().contains("upgrade")) { rc.response().setStatusCode(400); rc.response().end("Can \"Upgrade\" only to \"WebSocket\"."); } else { ServerWebSocket ws = rc.request().upgrade(); if (log.isTraceEnabled()) log.trace("WS, handler"); SockJSSession session = new SockJSSession(vertx, sessions, rc, options.getHeartbeatInterval(), sockHandler); session.register(req, new WebSocketListener(ws, session)); } }); router.getWithRegex(wsRE).handler(rc -> { if (log.isTraceEnabled()) log.trace("WS, get: " + rc.request().uri()); rc.response().setStatusCode(400); rc.response().end("Can \"Upgrade\" only to \"WebSocket\"."); }); router.routeWithRegex(wsRE).handler(rc -> { if (log.isTraceEnabled()) log.trace("WS, all: " + rc.request().uri()); rc.response().putHeader("Allow", "GET").setStatusCode(405).end(); }); }
@Test public void testWebsocketAbs() { SelfSignedCertificate certificate = SelfSignedCertificate.create(); HttpServerOptions serverOptions = new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTPS_PORT) .setSsl(true) .setKeyCertOptions(certificate.keyCertOptions()); HttpClientOptions clientOptions = new HttpClientOptions() .setTrustAll(true) .setVerifyHost(false); client = vertx.createHttpClient(clientOptions); server = vertx.createHttpServer(serverOptions).requestHandler(request -> { if ("/test".equals(request.path())) { request.upgrade().close(); } else { request.response().end(); } }).listen(onSuccess(server -> { String url = "wss://" + clientOptions.getDefaultHost() + ":" + HttpTestBase.DEFAULT_HTTPS_PORT + "/test"; client.websocketAbs(url, null, null, null, ws -> { ws.closeHandler(v -> { testComplete(); }); }, null); })); await(); }
/** * Upgrade the connection to a WebSocket connection. * <p> * This is an alternative way of handling WebSockets and can only be used if no websocket handlers are set on the * Http server, and can only be used during the upgrade request during the WebSocket handshake. * @return the WebSocket */ public io.vertx.rxjava.core.http.ServerWebSocket upgrade() { io.vertx.rxjava.core.http.ServerWebSocket ret = io.vertx.rxjava.core.http.ServerWebSocket.newInstance(delegate.upgrade()); return ret; }
/** * Upgrade the connection to a WebSocket connection. * <p> * This is an alternative way of handling WebSockets and can only be used if no websocket handlers are set on the * Http server, and can only be used during the upgrade request during the WebSocket handshake. * @return the WebSocket */ public io.vertx.rxjava.core.http.ServerWebSocket upgrade() { io.vertx.rxjava.core.http.ServerWebSocket ret = io.vertx.rxjava.core.http.ServerWebSocket.newInstance(delegate.upgrade()); return ret; }
@Test public void testServerWebSocketUpgrade() { server = vertx.createHttpServer(); server.requestHandler(req -> { FakeHttpServerMetrics metrics = FakeMetricsBase.getMetrics(server); assertNotNull(metrics.getMetric(req)); ServerWebSocket ws = req.upgrade(); assertNull(metrics.getMetric(req)); WebSocketMetric metric = metrics.getMetric(ws); assertNotNull(metric); assertNotNull(metric.soMetric); ws.handler(buffer -> ws.write(buffer)); ws.closeHandler(closed -> { WebSocketMetric a = metrics.getMetric(ws); assertNull(a); testComplete(); }); }); server.listen(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, ar -> { assertTrue(ar.succeeded()); client = vertx.createHttpClient(); client.websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.write(Buffer.buffer("wibble")); ws.handler(buff -> { ws.close(); }); }); }); await(); }
RawWebSocketTransport(Vertx vertx, Router router, Handler<SockJSSocket> sockHandler) { String wsRE = "/websocket"; router.get(wsRE).handler(rc -> { ServerWebSocket ws = rc.request().upgrade(); SockJSSocket sock = new RawWSSockJSSocket(vertx, rc.session(), rc.user(), ws); sockHandler.handle(sock); }); router.get(wsRE).handler(rc -> rc.response().setStatusCode(400).end("Can \"Upgrade\" only to \"WebSocket\".")); router.get(wsRE).handler(rc -> rc.response().putHeader("Allow", "GET").setStatusCode(405).end()); }