congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
HttpClientResponse.exceptionHandler
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: eclipse-vertx/vert.x

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

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

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();
 }
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

 });
});
resp.exceptionHandler(this::fail);
resp.endHandler(v -> {
 assertEquals(expected, length[0]);
origin: eclipse-vertx/vert.x

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();
}
origin: eclipse-vertx/vert.x

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();
 });
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

resp.exceptionHandler(th -> {
 fail();
});
origin: eclipse-vertx/vert.x

 @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();
 }
}
origin: eclipse-vertx/vert.x

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) {
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

 .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();
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

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

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
  • cookies,
  • netSocket,
  • version,
  • customFrameHandler,
  • getTrailer,
  • streamPriorityHandler,
  • trailers,
  • fetch

Popular in Java

  • Creating JSON documents from java classes using gson
  • setContentView (Activity)
  • setRequestProperty (URLConnection)
  • getContentResolver (Context)
  • Window (java.awt)
    A Window object is a top-level window with no borders and no menubar. The default layout for a windo
  • URL (java.net)
    A Uniform Resource Locator that identifies the location of an Internet resource as specified by RFC
  • LinkedHashMap (java.util)
    LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
  • Modifier (javassist)
    The Modifier class provides static methods and constants to decode class and member access modifiers
  • JCheckBox (javax.swing)
  • JLabel (javax.swing)
  • Top plugins for WebStorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now