/** * 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 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(); }
private static void replyError(SockJSSocket sock, String err) { JsonObject envelope = new JsonObject().put("type", "err").put("body", err); sock.write(buffer(envelope.encode())); }
private void deliverMessage(SockJSSocket sock, String address, Message message) { JsonObject envelope = new JsonObject().put("type", "rec").put("address", address).put("body", message.body()); if (message.replyAddress() != null) { envelope.put("replyAddress", message.replyAddress()); } if (message.headers() != null && !message.headers().isEmpty()) { JsonObject headersCopy = new JsonObject(); for (String name : message.headers().names()) { List<String> values = message.headers().getAll(name); if (values.size() == 1) { headersCopy.put(name, values.get(0)); } else { headersCopy.put(name, values); } } envelope.put("headers", headersCopy); } checkCallHook(() -> new BridgeEventImpl(BridgeEventType.RECEIVE, envelope, sock), () -> sock.write(buffer(envelope.encode())), () -> log.debug("outbound message rejected by bridge event handler")); }
private void echoRequest(SockJSSocket sock, Buffer requestBuffer) { log.debug("Server received " + requestBuffer); log.debug("Server sending " + requestBuffer); sock.write(requestBuffer); sock.close(); }
.put("failureType", cause.failureType().name()) .put("message", cause.getMessage()); sock.write(buffer(envelope.encode()));
/** * Write a {@link java.lang.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 */ public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket write(String data) { delegate.write(data); return this; }
/** * Write a {@link java.lang.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 */ public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket write(String data) { delegate.write(data); return this; }
@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(); }
@Test public void testSplitLargeReplySockJs() throws InterruptedException { String serverPath = "/large-reply-sockjs"; String largeMessage = TestUtils.randomAlphaString(65536 * 2); Buffer largeReplyBuffer = Buffer.buffer(largeMessage); setupSockJsServer(serverPath, (sock, requestBuffer) -> { sock.write(largeReplyBuffer); sock.close(); }); List<Buffer> receivedMessages = new ArrayList<>(); WebSocket openedWebSocket = setupSockJsClient(serverPath, receivedMessages); String messageToSend = "[\"hello\"]"; openedWebSocket.writeFrame(WebSocketFrame.textFrame(messageToSend, true)); await(5, TimeUnit.SECONDS); int receivedReplyCount = receivedMessages.size(); assertTrue("Should have received > 2 reply frame, actually received " + receivedReplyCount, receivedReplyCount > 2); Buffer expectedReplyBuffer = Buffer.buffer("a[\"").appendBuffer(largeReplyBuffer).appendBuffer(Buffer.buffer("\"]")); Buffer clientReplyBuffer = combineReplies(receivedMessages.subList(0, receivedMessages.size() - 1)); assertEquals(String.format("Combined reply on client (length %s) should equal message from server (%s)", clientReplyBuffer.length(), expectedReplyBuffer.length()), expectedReplyBuffer, clientReplyBuffer); Buffer finalMessage = receivedMessages.get(receivedMessages.size() - 1); assertEquals("Final message should have been a close", SOCKJS_CLOSE_REPLY, finalMessage); }
@Test public void testSplitLargeReplyRawWebSocket() throws InterruptedException { String serverPath = "/split"; String largeReply = TestUtils.randomAlphaString(65536 * 5); Buffer largeReplyBuffer = Buffer.buffer(largeReply); setupSockJsServer(serverPath, (sock, requestBuffer) -> { sock.write(largeReplyBuffer); sock.close(); }); Buffer totalReplyBuffer = Buffer.buffer(largeReplyBuffer.length()); AtomicInteger receivedReplies = new AtomicInteger(0); WebSocket ws = setupRawWebsocketClient(serverPath); ws.handler(replyBuffer -> { totalReplyBuffer.appendBuffer(replyBuffer); receivedReplies.incrementAndGet(); }); ws.writeFrame(WebSocketFrame.binaryFrame(Buffer.buffer("hello"), true)); await(5, TimeUnit.SECONDS); int receivedReplyCount = receivedReplies.get(); assertEquals("Combined reply on client should equal message from server", largeReplyBuffer, totalReplyBuffer); assertTrue("Should have received > 1 reply frame, actually received " + receivedReplyCount, receivedReplyCount > 1); }
/** * Writing multiple continuation frames from the client side should result in a single message on the server side * after the frames are re-combined */ @Test public void testCombineBinaryContinuationFramesRawWebSocket() throws InterruptedException { String serverPath = "/combine"; AtomicReference<Buffer> serverReceivedMessage = new AtomicReference<>(); setupSockJsServer(serverPath, (sock, requestBuffer) -> { serverReceivedMessage.set(requestBuffer); sock.write(Buffer.buffer("reply")); sock.close(); }); Buffer largeMessage = Buffer.buffer(TestUtils.randomAlphaString(30)); WebSocketFrame frame1 = WebSocketFrame.binaryFrame(largeMessage.slice(0, 10), false); WebSocketFrame frame2 = WebSocketFrame.continuationFrame(largeMessage.slice(10, 20), false); WebSocketFrame frame3 = WebSocketFrame.continuationFrame(largeMessage.slice(20, largeMessage.length()), true); WebSocket ws = setupRawWebsocketClient(serverPath); ws.writeFrame(frame1); ws.writeFrame(frame2); ws.writeFrame(frame3); await(5, TimeUnit.SECONDS); assertEquals("Server did not combine continuation frames correctly", largeMessage, serverReceivedMessage.get()); }
/** * 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)); }
private static void replyError(SockJSSocket sock, String err) { JsonObject envelope = new JsonObject().put("type", "err").put("body", err); sock.write(buffer(envelope.encode())); }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket write(io.vertx.rxjava.core.buffer.Buffer data) { delegate.write(data.getDelegate()); return this; }
public io.vertx.rxjava.ext.web.handler.sockjs.SockJSSocket write(io.vertx.rxjava.core.buffer.Buffer data) { delegate.write(data.getDelegate()); return this; }
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)); })); buff.appendByte((byte) 'x'); sock.write(buff); }))); router.route("/broadcast/*").handler(SockJSHandler.create(vertx,
socket.handler(buffer -> { assertEquals(msg, buffer.toString()); socket.write(buffer); }); };
private void echoRequest(SockJSSocket sock, Buffer requestBuffer) { log.debug("Server received " + requestBuffer); log.debug("Server sending " + requestBuffer); sock.write(requestBuffer); sock.close(); }