How to use

exceptionHandler

method

in

io.vertx.core.http.HttpClientResponse

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);