synchronized void doReceiveData(Buffer data) { if (!pending.write(data)) { req.pause(); } }
@Override public void start() throws Exception { vertx.createHttpServer().requestHandler(req -> { req.pause(); String filename = UUID.randomUUID() + ".uploaded"; vertx.fileSystem().open(filename, new OpenOptions(), ares -> { AsyncFile file = ares.result(); Pump pump = Pump.pump(req, file); req.endHandler(v1 -> file.close(v2 -> { System.out.println("Uploaded to " + filename); req.response().end(); })); pump.start(); req.resume(); }); }).listen(8080); } }
private void pausingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); req.pause(); Context ctx = vertx.getOrCreateContext(); resumeFuture.setHandler(v1 -> { ctx.runOnContext(v2 -> { req.resume(); }); }); req.handler(buff -> { req.response().write(buff); }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }
@Override public Request pause() { httpServerRequest.pause(); return this; }
}); numPause.incrementAndGet(); req.pause(); paused.set(true); req.handler(content::appendBuffer);
@Override public HttpServerRequest pause() { return delegate.pause(); }
request.handler(b -> { readBuffer.appendBuffer(b); request.pause(); exec.execute(() -> { try {
Buffer expected = Buffer.buffer(); server.requestHandler(req -> { req.pause(); AtomicBoolean paused = new AtomicBoolean(true); Buffer body = Buffer.buffer();
int val = count.getAndIncrement(); assertEquals(val + 1, inflight.incrementAndGet()); req.pause(); req.response().end("" + val); req.bodyHandler(body -> {
@Test public void testPausedHttpServerRequestDuringLastChunkEndsTheRequest() throws Exception { server.requestHandler(req -> { req.handler(buff -> { assertEquals("small", buff.toString()); req.pause(); }); req.endHandler(v -> { req.response().end(); }); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1)); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> { complete(); }).end("small"); await(); }
switch (count.getAndIncrement()) { case 0: req.pause(); vertx.setTimer(500, id -> { req.resume();
@Test public void testDeferredRequestEnd() throws Exception { server.requestHandler(req -> { req.pause(); req.bodyHandler(body -> { assertTrue(req.isEnded()); req.response().end(body); }); vertx.setTimer(10, v -> { assertFalse(req.isEnded()); req.resume(); }); }); startServer(); Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(1024)); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> { resp.bodyHandler(body -> { assertEquals(expected, body); testComplete(); }); })).end(expected); await(); }
@Test public void testPausedHttpServerRequestUnpauseTheConnectionAtRequestEnd() throws Exception { int numRequests = 20; waitFor(numRequests); server.requestHandler(req -> { req.handler(buff -> { assertEquals("small", buff.toString()); req.pause(); }); req.endHandler(v -> { req.response().end(); }); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1)); for (int i = 0; i < numRequests; i++) { client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> { complete(); }).end("small"); } }
switch (req.path()) { case "/0": { req.pause(); resumeLatch.thenAccept(v -> { req.resume();
@Test public void testBeginPipelinedRequestByResponseSentBeforeRequestCompletion() throws Exception { server.requestHandler(req -> { if (req.method() == HttpMethod.POST) { req.pause(); vertx.setTimer(100, id1 -> { req.response().end(); vertx.setTimer(100, id2 -> { req.resume(); }); }); } else if (req.method() == HttpMethod.GET) { req.response().end(); } }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true)); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { }).end(TestUtils.randomAlphaString(1024)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { testComplete(); }); await(); }
@Test public void testBeginPipelinedRequestByResponseSentOnRequestCompletion() throws Exception { server.requestHandler(req -> { if (req.method() == HttpMethod.POST) { req.pause(); vertx.setTimer(100, id -> { req.resume(); }); } req.endHandler(v -> { req.response().end(); }); }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true)); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { }).end(TestUtils.randomAlphaString(1024)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { testComplete(); }); await(); }
synchronized void doReceiveData(Buffer data) { if (!pending.write(data)) { req.pause(); } }
@Test public void testEndServerResponseResumeTheConnection() throws Exception { server.requestHandler(req -> { req.endHandler(v -> { req.pause(); req.response().end(); }); }); startServer(); client.close(); waitFor(2); client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); await(); }
@Test public void testEndServerRequestResumeTheConnection() throws Exception { server.requestHandler(req -> { req.response().end(); req.endHandler(v -> { req.pause(); }); }); startServer(); client.close(); waitFor(2); client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1)); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })).end("1"); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })).end("2"); await(); }
private void pausingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); req.pause(); Context ctx = vertx.getOrCreateContext(); resumeFuture.setHandler(v1 -> { ctx.runOnContext(v2 -> { req.resume(); }); }); req.handler(buff -> { req.response().write(buff); }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }