congrats Icon
New! Announcing our next generation AI code completions
Read here
Tabnine Logo
HttpClientResponse
Code IndexAdd Tabnine to your IDE (free)

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

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

Refine searchRefine arrow

  • HttpServer
  • HttpClient
  • HttpServerRequest
  • HttpServerResponse
  • HttpClientRequest
  • MultiMap
  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
List l =
  • Codota Iconnew ArrayList()
  • Codota Iconnew LinkedList()
  • Smart code suggestions by Tabnine
}
origin: eclipse-vertx/vert.x

private void testHttpProxyRequest2(Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> reqFact) throws Exception {
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = reqFact.apply(onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host"));
   testComplete();
  }));
  req.exceptionHandler(this::fail);
  req.end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testResponseEndHandlers2() {
 waitFor(2);
 AtomicInteger cnt = new AtomicInteger();
 String content = "blah";
 server.requestHandler(req -> {
  req.response().headersEndHandler(v -> {
   // Insert another header
   req.response().putHeader("extraheader", "wibble");
   assertEquals(0, cnt.getAndIncrement());
  });
  req.response().bodyEndHandler(v -> {
   assertEquals(content.length(), req.response().bytesWritten());
   assertEquals(1, cnt.getAndIncrement());
   complete();
  });
  req.response().end(content);
 }).listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
   assertEquals(200, res.statusCode());
   assertEquals("wibble", res.headers().get("extraheader"));
   res.bodyHandler(buff -> {
    assertEquals(Buffer.buffer(content), buff);
    complete();
   });
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

 assertEquals(2, req.headers().getAll("juu_request").size());
 assertEquals("juu_request_value_1", req.headers().getAll("juu_request").get(0));
 assertEquals("juu_request_value_2", req.headers().getAll("juu_request").get(1));
});
startServer();
client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath",
 onSuccess(resp -> {
  Context ctx = vertx.getOrCreateContext();
  assertOnIOContext(ctx);
  assertEquals(1, resp.request().streamId());
  assertEquals(1, reqCount.get());
  assertEquals(HttpVersion.HTTP_2, resp.version());
  assertEquals(200, resp.statusCode());
  assertEquals("OK", resp.statusMessage());
  assertEquals("text/plain", resp.getHeader("content-type"));
  assertEquals("200", resp.getHeader(":status"));
  assertEquals("foo_value", resp.getHeader("foo_response"));
  assertEquals("bar_value", resp.getHeader("bar_response"));
  assertEquals(2, resp.headers().getAll("juu_response").size());
  assertEquals("juu_value_1", resp.headers().getAll("juu_response").get(0));
  assertEquals("juu_value_2", resp.headers().getAll("juu_response").get(1));
  resp.endHandler(v -> {
   assertOnIOContext(ctx);
   testComplete();
  });
 })).putHeader("Foo_request", "foo_request_value")
  .putHeader("bar_request", "bar_request_value")
origin: eclipse-vertx/vert.x

@Test
public void testHttpClientResponsePauseIsIgnoredAtRequestEnd() throws Exception {
 testHttpClientResponsePause(resp -> {
  resp.endHandler(v -> {
   // Pausing the request in end handler should be a no-op
   resp.pause();
  });
 });
}
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 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 testContainsValueString() {
 server.requestHandler(req -> {
  assertTrue(req.headers().contains("Foo", "foo", false));
  assertFalse(req.headers().contains("Foo", "fOo", false));
  req.response().putHeader("quux", "quux");
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertTrue(resp.headers().contains("Quux", "quux", false));
   assertFalse(resp.headers().contains("Quux", "quUx", false));
   testComplete();
  }));
  req.putHeader("foo", "foo");
  req.end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHeadCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // Head never contains a body but it can contain a Content-Length header
  // Since headers from HEAD must correspond EXACTLY with corresponding headers for GET
  req.response().headers().set("Content-Length", String.valueOf(41));
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals("41", resp.headers().get("Content-Length"));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHttp11PersistentConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  assertNull(req.getHeader("Connection"));
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNull(resp.getHeader("Connection"));
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

private void testResponseHeaders(boolean individually) {
 MultiMap headers = getHeaders(10);
 server.requestHandler(req -> {
  if (individually) {
   for (Map.Entry<String, String> header : headers) {
    req.response().headers().add(header.getKey(), header.getValue());
   }
  } else {
   req.response().headers().setAll(headers);
  }
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertTrue(headers.size() < resp.headers().size());
   for (Map.Entry<String, String> entry : headers) {
    assertEquals(entry.getValue(), resp.headers().get(entry.getKey()));
    assertEquals(entry.getValue(), resp.getHeader(entry.getKey()));
   }
   testComplete();
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

int numGets = 100;
int maxPoolSize = 10;
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(keepAlive).setPipelining(pipelining).setMaxPoolSize(maxPoolSize));
server.requestHandler(req -> {
 String cnt = req.headers().get("count");
 req.response().headers().set("count", cnt);
 req.response().end();
});
server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertEquals(theCount, Integer.parseInt(resp.headers().get("count")));
   if (cnt.incrementAndGet() == numGets) {
    testComplete();
  req.exceptionHandler(t -> {
   fail("Should not throw exception: " + t.getMessage());
  });
  req.headers().set("count", String.valueOf(i));
  req.end();
origin: eclipse-vertx/vert.x

private void testStatusCode(int code, String statusMessage) {
 server.requestHandler(req -> {
  if (code != -1) {
   req.response().setStatusCode(code);
  }
  if (statusMessage != null) {
   req.response().setStatusMessage(statusMessage);
  }
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   int theCode;
   if (code == -1) {
    // Default code - 200
    assertEquals(200, resp.statusCode());
    theCode = 200;
   } else {
    theCode = code;
   }
   if (statusMessage != null && resp.version() != HttpVersion.HTTP_2) {
    assertEquals(statusMessage, resp.statusMessage());
   } else {
    assertEquals(HttpResponseStatus.valueOf(theCode).reasonPhrase(), resp.statusMessage());
   }
   testComplete();
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testPutHeadersOnRequest() {
 server.requestHandler(req -> {
  assertEquals("bar", req.headers().get("foo"));
  assertEquals("bar", req.getHeader("foo"));
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   testComplete();
  })).putHeader("foo", "bar").end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testClientMaxHeaderSizeOption() {
 String longHeader = TestUtils.randomAlphaString(9000);
 // min 9023 = 9000 for longHeader and 23 for "Content-Length: 0 t: "
 vertx.createHttpServer(new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> {
  // Add longHeader
  req.response().putHeader("t", longHeader).end();
 }).listen(onSuccess(res -> {
  HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions().setMaxHeaderSize(10000))
    .request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
     assertEquals(200, resp.statusCode());
     assertEquals(resp.getHeader("t"), longHeader);
     testComplete();
    }));
  req.end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testServerResponseWriteBufferFromOtherThread() throws Exception {
 server.requestHandler(req -> {
  runAsync(() -> {
   req.response().write("hello ").end("world");
  });
 }).listen(onSuccess(v -> {
  client.get(8080, "localhost", "/somepath", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   resp.bodyHandler(buff -> {
    assertEquals(Buffer.buffer("hello world"), buff);
    testComplete();
   });
  })).exceptionHandler(this::fail).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testResponseBodyWriteFixedString() {
 String body = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
 Buffer bodyBuff = Buffer.buffer(body);
 server.requestHandler(req -> {
  req.response().setChunked(true);
  req.response().write(body);
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.bodyHandler(buff -> {
    assertEquals(bodyBuff, buff);
    testComplete();
   });
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testPutHeaderReplacesPreviousHeaders() throws Exception {
 server.requestHandler(req ->
  req.response()
   .putHeader("Location", "http://example1.org")
   .putHeader("location", "http://example2.org")
   .end());
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(singletonList("http://example2.org"), resp.headers().getAll("LocatioN"));
   testComplete();
   })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testSkipEncoding() throws Exception {
 serverWithMaxCompressionLevel.requestHandler(req -> {
  assertNotNull(req.headers().get("Accept-Encoding"));
  req.response()
   .putHeader(HttpHeaders.CONTENT_ENCODING, HttpHeaders.IDENTITY)
   .end(Buffer.buffer(COMPRESS_TEST_STRING).toString(CharsetUtil.UTF_8));
 });
 startServer(serverWithMaxCompressionLevel);
 clientraw.get(DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri",
  onSuccess(resp -> {
   resp.bodyHandler(responseBuffer -> {
    String responseBody = responseBuffer.toString(CharsetUtil.UTF_8);
    assertEquals(COMPRESS_TEST_STRING, responseBody);
    testComplete();
   });
  })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end();
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void test100ContinueHandledAutomatically() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end();
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> testComplete());
  }));
  req.headers().set("Expect", "100-continue");
  req.setChunked(true);
  req.continueHandler(v -> {
   req.write(toSend);
   req.end();
  });
  req.sendHead();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testFollowRedirectLimit() throws Exception {
 AtomicInteger redirects = new AtomicInteger();
 server.requestHandler(req -> {
  int val = redirects.incrementAndGet();
  if (val > 16) {
   fail();
  } else {
   String scheme = createBaseServerOptions().isSsl() ? "https" : "http";
   req.response().setStatusCode(301).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:8080/otherpath").end();
  }
 });
 startServer();
 client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  assertEquals(16, redirects.get());
  assertEquals(301, resp.statusCode());
  assertEquals("/otherpath", resp.request().path());
  testComplete();
 })).setFollowRedirects(true).end();
 await();
}
io.vertx.core.httpHttpClientResponse

Javadoc

Represents a client-side HTTP response.

Vert.x provides you with one of these via the handler that was provided when creating the io.vertx.core.http.HttpClientRequestor that was set on the io.vertx.core.http.HttpClientRequest instance.

It implements io.vertx.core.streams.ReadStream so it can be used with io.vertx.core.streams.Pump to pump data with flow control.

Most used methods

  • statusCode
  • bodyHandler
    Convenience method for receiving the entire request body in one piece. This saves you having to manu
  • statusMessage
  • headers
  • exceptionHandler
  • endHandler
  • getHeader
    Return the first header value with the specified name
  • handler
  • pause
  • resume
  • request
  • cookies
  • request,
  • cookies,
  • netSocket,
  • version,
  • customFrameHandler,
  • getTrailer,
  • streamPriorityHandler,
  • trailers,
  • fetch

Popular in Java

  • Creating JSON documents from java classes using gson
  • getExternalFilesDir (Context)
  • onRequestPermissionsResult (Fragment)
  • runOnUiThread (Activity)
  • GridLayout (java.awt)
    The GridLayout class is a layout manager that lays out a container's components in a rectangular gri
  • Format (java.text)
    The base class for all formats. This is an abstract base class which specifies the protocol for clas
  • MessageFormat (java.text)
    Produces concatenated messages in language-neutral way. New code should probably use java.util.Forma
  • Collectors (java.util.stream)
  • Cipher (javax.crypto)
    This class provides access to implementations of cryptographic ciphers for encryption and decryption
  • JOptionPane (javax.swing)
  • PhpStorm for WordPress
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

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