io.vertx.core.http.HttpClientResponse.exceptionHandler java code examples

Common ways to obtain HttpClientResponse

private void myMethod () {
 HttpClientResponse h =HttpClientResponse httpClientResponse;httpClientResponse.resume()
HttpClientResponse httpClientResponse;httpClientResponse.pause()
Smart code suggestions by Tabnine
}

private void testHttpClientResponseDecodeError(Handler<Throwable> errorHandler) throws Exception {
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  resp.exceptionHandler(errorHandler);
 }));
 await();
}

@Test
public void testClientExceptionHandlerCalledWhenExceptionOnDataHandler() throws Exception {
 server.requestHandler(request -> {
  request.response().end("foo");
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  // Exception handler should be called for any exceptions in the data handler
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.handler(data -> {
    throw new RuntimeException("should be caught");
   });
   resp.exceptionHandler(t -> testComplete());
  })).exceptionHandler(error -> fail()).end();
 }));
 await();
}

@Test
public void testClientExceptionHandlerCalledWhenExceptionOnBodyHandler() throws Exception {
 server.requestHandler(request -> {
  request.response().end("foo");
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  // Exception handler should be called for any exceptions in the data handler
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.bodyHandler(data -> {
    throw new RuntimeException("should be caught");
   });
   resp.exceptionHandler(t -> testComplete());
  })).exceptionHandler(error -> fail()).end();
 }));
 await();
}

@Test
public void testClientResponseExceptionHandlerCalledWhenConnectionClosed() throws Exception {
 AtomicReference<HttpConnection> conn = new AtomicReference<>();
 server.requestHandler(req -> {
  conn.set(req.connection());
  req.response().setChunked(true).write("chunk");
 });
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  resp.handler(buff -> {
   conn.get().close();
  });
  resp.exceptionHandler(err -> {
   testComplete();
  });
 }));
 await();
}

protected MultiMap checkEmptyHttpResponse(HttpMethod method, int sc, MultiMap reqHeaders) throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.setStatusCode(sc);
  resp.headers().addAll(reqHeaders);
  resp.end();
 });
 startServer();
 try {
  CompletableFuture<MultiMap> result = new CompletableFuture<>();
  client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, "/", onSuccess(resp -> {
   Buffer body = Buffer.buffer();
   resp.exceptionHandler(result::completeExceptionally);
   resp.handler(body::appendBuffer);
   resp.endHandler(v -> {
    if (body.length() > 0) {
     result.completeExceptionally(new Exception());
    } else {
     result.complete(resp.headers());
    }
   });
  })).setFollowRedirects(false)
   .exceptionHandler(result::completeExceptionally)
   .end();
  return result.get(20, TimeUnit.SECONDS);
 } finally {
  client.close();
 }
}

@Test
public void testClientExceptionHandlerCalledWhenServerTerminatesConnectionAfterPartialResponse() throws Exception {
 server.requestHandler(request -> {
  //Write partial response then close connection before completing it
  request.response().setChunked(true).write("foo").close();
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  // Exception handler should be called for any requests in the pipeline if connection is closed
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp ->
    resp.exceptionHandler(t -> testComplete()))).exceptionHandler(error -> fail()).end();
 }));
 await();
}

@Test
public void testBodyEndHandler() throws Exception {
 // Large body so it will be fragmented in several HTTP2 data frames
 Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(128 * 1024));
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.end(expected);
 });
 startServer();
 client.getNow(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
  Context ctx = vertx.getOrCreateContext();
  resp.exceptionHandler(this::fail);
  resp.bodyHandler(body -> {
   assertOnIOContext(ctx);
   assertEquals(expected, body);
   testComplete();
  });
 }));
 await();
}

@Test
public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  req.exceptionHandler(this::fail);
  resp.exceptionHandler(err -> {
   err.printStackTrace();
  });
  resp.end();
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    vertx.setTimer(100, tid -> testComplete());
   });
   resp.exceptionHandler(t -> {
    fail("Should not be called");
   });
  })).exceptionHandler(t -> {
   fail("Should not be called");
  }).end();
 }));
 await();
}

@Test
public void testClientResetServerStreamDuringResponse() throws Exception {
 server.requestHandler(req -> {
  req.exceptionHandler(err -> {
   assertEquals(err.getClass(), StreamResetException.class);
  });
  AtomicLong reset = new AtomicLong();
  req.response().exceptionHandler(err -> {
   if (err instanceof StreamResetException) {
    reset.set(((StreamResetException) err).getCode());
   }
  });
  req.response().closeHandler(v -> {
   assertEquals(10L, reset.get());
   testComplete();
  });
  req.response().setChunked(true).write(Buffer.buffer("some-data"));
 });
 startServer();
 client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath",
  onSuccess(resp -> {
   resp.exceptionHandler(this::fail);
   resp.request().reset(10);
   assertIllegalStateException(() -> resp.request().write(Buffer.buffer()));
   assertIllegalStateException(resp.request()::end);
  })).end(Buffer.buffer("hello"));
 await();
}

 });
});
resp.exceptionHandler(this::fail);
resp.endHandler(v -> {
 assertEquals(expected, length[0]);

private void sendFile(String fileName, String contentExpected, boolean useHandler, Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> requestFact) throws Exception {
 waitFor(2);
 File fileToSend = setupFile(fileName, contentExpected);
 server.requestHandler(req -> {
  if (useHandler) {
   Handler<AsyncResult<Void>> completionHandler = onSuccess(v -> complete());
   req.response().sendFile(fileToSend.getAbsolutePath(), completionHandler);
  } else {
   req.response().sendFile(fileToSend.getAbsolutePath());
   complete();
  }
 });
 startServer();
 requestFact.apply(onSuccess(resp -> {
  assertEquals(200, resp.statusCode());
  assertEquals("text/html", resp.headers().get("Content-Type"));
  resp.exceptionHandler(this::fail);
  resp.bodyHandler(buff -> {
   assertEquals(contentExpected, buff.toString());
   assertEquals(fileToSend.length(), Long.parseLong(resp.headers().get("content-length")));
   complete();
  });
 })).end();
 await();
}

client = vertx.createHttpClient(clientOptions.setHttp2KeepAliveTimeout(5).setIdleTimeout(2));
HttpClientRequest req = client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
 resp.exceptionHandler(err -> {
  fail();
 });

@Test
public void testClientConnectionClosed() throws Exception {
 server.requestHandler(req -> {
  req.response().setChunked(true).write(Buffer.buffer("some-data"));
 });
 startServer();
 client = vertx.createHttpClient(createBaseClientOptions().setIdleTimeout(2));
 FakeHttpClientMetrics metrics = FakeMetricsBase.getMetrics(client);
 HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath",
  onSuccess(resp -> {
   HttpClientMetric metric = metrics.getMetric(resp.request());
   assertNotNull(metric);
   assertFalse(metric.failed.get());
   resp.exceptionHandler(err -> {
    assertNull(metrics.getMetric(resp.request()));
    assertTrue(metric.failed.get());
    testComplete();
   });
  }));
 req.end();
 await();
}

resp.exceptionHandler(th -> {
 fail();
});

 @Test
 public void testSendFilePipelined() throws Exception {
  int n = 4;
  waitFor(n);
  File sent = TestUtils.tmpFile(".dat", 16 * 1024);
  server.requestHandler(
   req -> {
    req.response().sendFile(sent.getAbsolutePath());
   });
  startServer();
  client.close();
  client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1));
  for (int i = 0;i < n;i++) {
   client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
    resp.exceptionHandler(this::fail);
    resp.bodyHandler(body -> {
     complete();
    });
   }));
  }
  await();
 }
}

client = vertx.createHttpClient(createBaseClientOptions().setTryUseCompression(true));
client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
 resp.exceptionHandler(err -> {
  if (exceptionCount.incrementAndGet() == 1) {
   if (err instanceof Http2Exception) {

@Test
public void testTrailers() throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.setChunked(true);
  resp.write("some-content");
  resp.putTrailer("Foo", "foo_value");
  resp.putTrailer("bar", "bar_value");
  resp.putTrailer("juu", (List<String>)Arrays.asList("juu_value_1", "juu_value_2"));
  resp.end();
 });
 startServer();
 client.getNow(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepeth", onSuccess(resp -> {
  assertEquals(null, resp.getTrailer("foo"));
  resp.exceptionHandler(this::fail);
  resp.endHandler(v -> {
   assertEquals("foo_value", resp.getTrailer("foo"));
   assertEquals("foo_value", resp.getTrailer("Foo"));
   assertEquals("bar_value", resp.getTrailer("bar"));
   assertEquals(2, resp.trailers().getAll("juu").size());
   assertEquals("juu_value_1", resp.trailers().getAll("juu").get(0));
   assertEquals("juu_value_2", resp.trailers().getAll("juu").get(1));
   testComplete();
  });
 }));
 await();
}

 .setDefaultHost("localhost"));
client.get("/somepath", onSuccess(resp1 -> {
 resp1.exceptionHandler(this::fail);
 resp1.endHandler(v1 -> {
  vertx.setTimer(10, id1 -> {
   client.get("/somepath", onSuccess(resp2 -> {
    resp2.exceptionHandler(this::fail);
    resp2.endHandler(v2 -> {
     testComplete();

@Test
public void testServerResetClientStreamDuringResponse() throws Exception {
 waitFor(2);
 String chunk = TestUtils.randomAlphaString(1024);
 Future<Void> doReset = Future.future();
 server.requestHandler(req -> {
  doReset.setHandler(onSuccess(v -> {
   req.response().reset(8);
  }));
  req.response().setChunked(true).write(Buffer.buffer(chunk));
 });
 startServer();
 Context ctx = vertx.getOrCreateContext();
 Handler<Throwable> resetHandler = err -> {
  assertOnIOContext(ctx);
  assertTrue(err instanceof StreamResetException);
  StreamResetException reset = (StreamResetException) err;
  assertEquals(8, reset.getCode());
  complete();
 };
 ctx.runOnContext(v -> {
  client.post(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
   resp.exceptionHandler(resetHandler);
   resp.handler(buff -> {
    doReset.complete();
   });
  })).exceptionHandler(resetHandler).setChunked(true).write(chunk);
 });
 await();
}

ctx.runOnContext(v1 -> {
 HttpClientRequest req = client.get("/somepath", onSuccess(resp -> {
  resp.exceptionHandler(err -> {
   assertSame(ctx, Vertx.currentContext());
   assertOnIOContext(ctx);

Popular methods of HttpClientResponse

statusCode
bodyHandler
Convenience method for receiving the entire request body in one piece. This saves you having to manu
statusMessage
headers
endHandler
getHeader
Return the first header value with the specified name
handler
pause
resume
request
cookies
netSocket
Get a net socket for the underlying connection of this request. USE THIS WITH CAUTION! Writing to th

Popular in Java

Running tasks concurrently on multiple threads
onRequestPermissionsResult (Fragment)
setRequestProperty (URLConnection)
setContentView (Activity)
HttpServer (com.sun.net.httpserver)
This class implements a simple HTTP server. A HttpServer is bound to an IP address and port number a
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
Callable (java.util.concurrent)
A task that returns a result and may throw an exception. Implementors define a single method with no
JFileChooser (javax.swing)
JLabel (javax.swing)
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid

How to use exceptionHandlermethodin io.vertx.core.http.HttpClientResponse

Best Java code snippets using io.vertx.core.http.HttpClientResponse.exceptionHandler (Showing top 20 results out of 315)

How to use
exceptionHandler
method
in
io.vertx.core.http.HttpClientResponse