public void handle(SockJSSocket sock) { connections.add(sock.writeHandlerID()); sock.handler(buffer -> { for (String actorID : connections) { vertx.eventBus().publish(actorID, buffer); } }); sock.endHandler(v -> connections.remove(sock.writeHandlerID())); } }));
@Test public void testStream() throws Exception { AtomicReference<Context> sessionContext = new AtomicReference<>(); socketHandler = () -> { return socket -> { Context context = Vertx.currentContext(); assertNotNull(context); assertTrue(sessionContext.compareAndSet(null, context)); socket.setWriteQueueMaxSize(5); socket.write("Hello"); assertTrue(socket.writeQueueFull()); socket.drainHandler(v -> { assertEquals(sessionContext.get(), Vertx.currentContext()); socket.write("World"); }); }; }; startServers(); List<String> messages = Collections.synchronizedList(new ArrayList<>()); fetchMessages(messages); await(); }
public void handle(final SockJSSocket sock) { checkCallHook(() -> new BridgeEventImpl(BridgeEventType.SOCKET_CREATED, null, sock), () -> { Map<String, MessageConsumer> registrations = new HashMap<>(); sock.endHandler(v -> handleSocketClosed(sock, registrations)); sock.handler(data -> handleSocketData(sock, data, registrations)); // Start a checker to check for pings PingInfo pingInfo = new PingInfo(); pingInfo.timerID = vertx.setPeriodic(pingTimeout, id -> { if (System.currentTimeMillis() - pingInfo.lastPing >= pingTimeout) { // Trigger an event to allow custom behavior before disconnecting client. checkCallHook(() -> new BridgeEventImpl(BridgeEventType.SOCKET_IDLE, null, sock), // We didn't receive a ping in time so close the socket ((SockJSSocketBase) sock)::closeAfterSessionExpired, () -> replyError(sock, "rejected")); } }); SockInfo sockInfo = new SockInfo(); sockInfo.pingInfo = pingInfo; sockInfos.put(sock, sockInfo); }, sock::close); }
new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> sock.handler(sock::write))); router.route("/close/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> { vertx.setTimer(10, id -> sock.close(3000, "Go away!")); })); router.route("/disabled_websocket_echo/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions() .setMaxBytesStreaming(4096).addDisabledTransport("WEBSOCKET")).socketHandler(sock -> sock.handler(sock::write))); router.route("/ticker/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> { long timerID = vertx.setPeriodic(1000, tid -> sock.write(buffer("tick!"))); sock.endHandler(v -> vertx.cancelTimer(timerID)); })); router.route("/amplify/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> sock.handler(data -> { String str = data.toString(); int n = Integer.valueOf(str); buff.appendByte((byte) 'x'); sock.write(buff); }))); router.route("/broadcast/*").handler(SockJSHandler.create(vertx, setMaxBytesStreaming(4096).setInsertJSESSIONID(true)).socketHandler(sock -> sock.handler(sock::write)));
@Override public void handle(SockJSSocket socket) { if (termHandler != null) { SockJSTtyConnection conn = new SockJSTtyConnection(charset, vertx.getOrCreateContext(), socket); socket.handler(buf -> conn.writeToDecoder(buf.toString())); socket.endHandler(v -> { Consumer<Void> closeHandler = conn.getCloseHandler(); if (closeHandler != null) { closeHandler.accept(null); } }); termHandler.handle(new TermImpl(vertx, keymap, conn)); } else { socket.close(); } } }
socketHandler = () -> { return socket -> { socket.handler(msg -> serverReceived.addAndGet(msg.length())); socket.write("hello"); new Thread(() -> { while (!shallStop.getAsBoolean()) { LockSupport.parkNanos(50); try { socket.write(Buffer.buffer(TestUtils.randomAlphaString(256))); } catch (IllegalStateException e) {
/** * Write a {@link String} to the socket, encoded in UTF-8. * * @param data the string to write * @return a reference to this, so the API can be used fluently */ @Fluent default SockJSSocket write(String data) { return write(Buffer.buffer(data)); }
@Test public void testNoDeadlockWhenWritingFromAnotherThreadWithSseTransport() throws Exception { socketHandler = () -> { return socket -> { AtomicBoolean closed = new AtomicBoolean(); socket.endHandler(v -> { closed.set(true); testComplete(); }); new Thread(() -> { while (!closed.get()) { LockSupport.parkNanos(50); socket.write(Buffer.buffer(TestUtils.randomAlphaString(256))); } }).start(); }; }; startServers(); client.getNow("/test/400/8ne8e94a/eventsource", onSuccess(resp -> { AtomicInteger count = new AtomicInteger(); resp.handler(msg -> { if (count.incrementAndGet() == 400) { resp.request().connection().close(); } }); })); await(); }
/** * Close it giving a status code and reason. Only Applicable to RawWebSocket will downgrade to plain close for * other transports. */ default void close(int statusCode, String reason) { close(); }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket handler(Handler<io.vertx.rxjava.core.buffer.Buffer> handler) { delegate.handler(new Handler<io.vertx.core.buffer.Buffer>() { public void handle(io.vertx.core.buffer.Buffer event) { handler.handle(io.vertx.rxjava.core.buffer.Buffer.newInstance(event)); } }); return this; }
private void setupSockJsServer(String serverPath, BiConsumer<SockJSSocket, Buffer> serverBufferHandler) { String path = serverPath + "/*"; router.route(path).handler(SockJSHandler.create(vertx) .socketHandler(sock -> { sock.handler(buffer -> serverBufferHandler.accept(sock, buffer)); sock.exceptionHandler(this::fail); })); }
/** * Return the headers corresponding to the last request for this socket or the websocket handshake * Any cookie headers will be removed for security reasons * @return */ public io.vertx.rxjava.core.MultiMap headers() { io.vertx.rxjava.core.MultiMap ret = io.vertx.rxjava.core.MultiMap.newInstance(delegate.headers()); return ret; }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket endHandler(Handler<Void> endHandler) { delegate.endHandler(endHandler); return this; }
private void internalHandlePing(final SockJSSocket sock) { Session webSession = sock.webSession(); if (webSession != null) { webSession.setAccessed(); } SockInfo info = sockInfos.get(sock); if (info != null) { info.pingInfo.lastPing = System.currentTimeMillis(); // Trigger an event to allow custom behavior after updating lastPing checkCallHook(() -> new BridgeEventImpl(BridgeEventType.SOCKET_PING, null, sock), null, null); } }
/** * Return the URI corresponding to the last request for this socket or the websocket handshake * @return */ public String uri() { String ret = delegate.uri(); return ret; }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket setWriteQueueMaxSize(int maxSize) { delegate.setWriteQueueMaxSize(maxSize); return this; }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket drainHandler(Handler<Void> handler) { delegate.drainHandler(handler); return this; }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket exceptionHandler(Handler<Throwable> handler) { delegate.exceptionHandler(handler); return this; }
new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> sock.handler(sock::write))); router.route("/close/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> { vertx.setTimer(10, id -> sock.close(3000, "Go away!")); })); router.route("/disabled_websocket_echo/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions() .setMaxBytesStreaming(4096).addDisabledTransport("WEBSOCKET")).socketHandler(sock -> sock.handler(sock::write))); router.route("/ticker/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> { long timerID = vertx.setPeriodic(1000, tid -> sock.write(buffer("tick!"))); sock.endHandler(v -> vertx.cancelTimer(timerID)); })); router.route("/amplify/*").handler(SockJSHandler.create(vertx, new SockJSHandlerOptions().setMaxBytesStreaming(4096)).socketHandler(sock -> sock.handler(data -> { String str = data.toString(); int n = Integer.valueOf(str); buff.appendByte((byte) 'x'); sock.write(buff); }))); router.route("/broadcast/*").handler(SockJSHandler.create(vertx, setMaxBytesStreaming(4096).setInsertJSESSIONID(true)).socketHandler(sock -> sock.handler(sock::write)));