private void now(RoutingContext context) { logger.info("Time request from {}", context.request().remoteAddress()); JsonObject data = new JsonObject() .put("powered-by", "vertx") .put("current-time", System.currentTimeMillis()); context.response() .putHeader("Content-Type", "application/json") .end(data.encode()); } }
private void hello(RoutingContext context) { logger.info("Hello request from {}", context.request().remoteAddress()); context.response() .putHeader("Content-Type", "text/plain") .end("Hello from Vert.x!"); }
@Override public void start(Future<Void> startFuture) { vertx.createHttpServer() .requestHandler(req -> { req.response() .putHeader("Content-Type", "plain/text") .end("Yo!"); logger.info("Handled a request on path {} from {}", req.path(), req.remoteAddress().host()); }) .listen(11981, ar -> { if (ar.succeeded()) { startFuture.complete(); } else { startFuture.fail(ar.cause()); } }); } }
/** * This sets the client IP:port to the {@linkplain HttpServerRequest#remoteAddress() remote * address} if the {@link HttpServerAdapter#parseClientIpAndPort default parsing} fails. */ @Override public boolean parseClientIpAndPort(HttpServerRequest req, Span span) { if (parseClientIpFromXForwardedFor(req, span)) return true; SocketAddress addr = req.remoteAddress(); return span.remoteIpAndPort(addr.host(), addr.port()); }
@Test public void testRemoteAddress() { server.requestHandler(req -> { assertEquals("127.0.0.1", req.remoteAddress().host()); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end(); })); await(); }
@Override public SocketAddress remoteAddress() { return delegate.remoteAddress(); }
@Test public void testReuseConnection() throws Exception { List<SocketAddress> ports = new ArrayList<>(); server.requestHandler(req -> { SocketAddress address = req.remoteAddress(); assertNotNull(address); ports.add(address); req.response().end(); }); startServer(); CountDownLatch doReq = new CountDownLatch(1); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.endHandler(v -> { doReq.countDown(); }); })).exceptionHandler(err -> { fail(); }).end(); awaitLatch(doReq); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.endHandler(v -> { assertEquals(2, ports.size()); assertEquals(ports.get(0), ports.get(1)); testComplete(); }); })).exceptionHandler(err -> { fail(); }).end(); await(); }
@Test public void testClientLocalAddress() throws Exception { String expectedAddress = TestUtils.loopbackAddress(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setLocalAddress(expectedAddress)); server.requestHandler(req -> { assertEquals(expectedAddress, req.remoteAddress().host()); req.response().end(); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })); await(); }
@Override public String remoteAddress() { String xForwardedFor = httpServerRequest.getHeader(HttpHeaders.X_FORWARDED_FOR); String remoteAddress; if(xForwardedFor != null && xForwardedFor.length() > 0) { int idx = xForwardedFor.indexOf(','); remoteAddress = (idx != -1) ? xForwardedFor.substring(0, idx) : xForwardedFor; idx = remoteAddress.indexOf(':'); remoteAddress = (idx != -1) ? remoteAddress.substring(0, idx).trim() : remoteAddress.trim(); } else { SocketAddress address = httpServerRequest.remoteAddress(); remoteAddress = (address != null) ? address.host() : null; } return remoteAddress; }
@Override public String getFormattedItem(AccessLogParam<RoutingContext> accessLogParam) { HttpServerRequest request = accessLogParam.getContextData().request(); if (null == request) { return EMPTY_RESULT; } SocketAddress remoteAddress = request.remoteAddress(); if (null == remoteAddress) { return EMPTY_RESULT; } String remoteHost = remoteAddress.host(); if (StringUtils.isEmpty(remoteHost)) { return EMPTY_RESULT; } return remoteHost; } }
public VertxServerRequestToHttpServletRequest(RoutingContext context) { this.context = context; this.vertxRequest = context.request(); this.socketAddress = this.vertxRequest.remoteAddress(); super.setBodyBuffer(context.getBody()); }
@Override public void handle(RoutingContext context) { // common logging data long timestamp = System.currentTimeMillis(); String remoteClient = getClientAddress(context.request().remoteAddress()); HttpMethod method = context.request().method(); String uri = context.request().uri(); HttpVersion version = context.request().version(); if (immediate) { log(context, timestamp, remoteClient, version, method, uri); } else { context.addBodyEndHandler(v -> log(context, timestamp, remoteClient, version, method, uri)); } context.next(); } }
@Test public void testRemoteAddress() { server.requestHandler(req -> { assertEquals("127.0.0.1", req.remoteAddress().host()); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> resp.endHandler(v -> testComplete())).end(); })); await(); }
synchronized void register(HttpServerRequest req, TransportListener lst) { this.transportCtx = vertx.getOrCreateContext(); this.localAddress = req.localAddress(); this.remoteAddress = req.remoteAddress(); this.uri = req.uri(); this.headers = BaseTransport.removeCookieHeaders(req.headers());
@Test public void testReuseConnection() throws Exception { List<SocketAddress> ports = new ArrayList<>(); server.requestHandler(req -> { SocketAddress address = req.remoteAddress(); assertNotNull(address); ports.add(address); req.response().end(); }); startServer(); CountDownLatch doReq = new CountDownLatch(1); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> { resp.endHandler(v -> { doReq.countDown(); }); }).exceptionHandler(err -> { fail(); }).end(); awaitLatch(doReq); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> { resp.endHandler(v -> { assertEquals(2, ports.size()); assertEquals(ports.get(0), ports.get(1)); testComplete(); }); }).exceptionHandler(err -> { fail(); }).end(); await(); }
public HttpRequest createRequest(final HttpServerRequest request, final Supplier<Buffer> buffer, final Map<String, Object> data, final CopyOnWriteArrayList<HttpResponseDecorator> decorators, final HttpResponseCreator httpResponseCreator) { final MultiMap<String, String> headers = request.headers().size() == 0 ? MultiMap.empty() : new MultiMapWrapper(request.headers()); final String contentType = request.headers().get("Content-Type"); final String contentLengthHeaderValue = request.headers().get("Content-Length"); final int contentLength = contentLengthHeaderValue == null ? 0 : Integer.parseInt(contentLengthHeaderValue); final HttpRequestBuilder httpRequestBuilder = HttpRequestBuilder.httpRequestBuilder(); buildParams(httpRequestBuilder, request, contentType); final MultiMap<String, String> params = httpRequestBuilder.getParams(); final String requestPath = request.path(); httpRequestBuilder.setId(requestId.incrementAndGet()) .setContentLength(contentLength) .setData(data) .setUri(requestPath).setMethod(request.method().toString()) .setBodySupplier(() -> buffer == null ? null : buffer.get().getBytes()) .setRemoteAddress(request.remoteAddress().toString()) .setResponse(createResponse(requestPath, request.method().toString(), headers, params, request.response(), decorators, httpResponseCreator)) .setTimestamp(time == 0L ? Timer.timer().now() : time) .setHeaders(headers); return httpRequestBuilder.build(); }
@Test public void testClientLocalAddress() throws Exception { String expectedAddress = TestUtils.loopbackAddress(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setLocalAddress(expectedAddress)); server.requestHandler(req -> { assertEquals(expectedAddress, req.remoteAddress().host()); req.response().end(); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> { assertEquals(200, resp.statusCode()); testComplete(); }); await(); }
public static ApiRequest buildRequest(HttpServerRequest req, boolean isTransportSecure) { ApiRequest apimanRequest = new ApiRequest(); apimanRequest.setApiKey(parseApiKey(req)); apimanRequest.setRemoteAddr(req.remoteAddress().host()); apimanRequest.setType(req.method().toString()); apimanRequest.setTransportSecure(isTransportSecure); multimapToMap(apimanRequest.getHeaders(), req.headers(), IGNORESET); multimapToMap(apimanRequest.getQueryParams(), req.params(), Collections.<String>emptySet()); parsePath(req, apimanRequest); return apimanRequest; }
EventSourceTransport(Vertx vertx,RouteMatcher rm, String basePath, LocalMap<String, Session> sessions, SockJSServerOptions options, Handler<SockJSSocket> sockHandler) { super(vertx, sessions, options); String eventSourceRE = basePath + COMMON_PATH_ELEMENT_RE + "eventsource"; rm.matchMethodWithRegEx(HttpMethod.GET, eventSourceRE, req -> { if (log.isTraceEnabled()) log.trace("EventSource transport, get: " + req.uri()); String sessionID = req.params().get("param0"); Session session = getSession(options.getSessionTimeout(), options.getHeartbeatPeriod(), sessionID, sockHandler); session.setInfo(req.localAddress(), req.remoteAddress(), req.uri(), req.headers()); session.register(new EventSourceListener(options.getMaxBytesStreaming(), req, session)); }); }
private void registerHandler(RouteMatcher rm, Handler<SockJSSocket> sockHandler, String re, boolean streaming, SockJSServerOptions options) { rm.matchMethodWithRegEx(HttpMethod.POST, re, req -> { if (log.isTraceEnabled()) log.trace("XHR, post, " + req.uri()); setNoCacheHeaders(req); String sessionID = req.params().get("param0"); Session session = getSession(options.getSessionTimeout(), options.getHeartbeatPeriod(), sessionID, sockHandler); session.setInfo(req.localAddress(), req.remoteAddress(), req.uri(), req.headers()); session.register(streaming? new XhrStreamingListener(options.getMaxBytesStreaming(), req, session) : new XhrPollingListener(req, session)); }); }