Refine search
@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(); }
public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean resolved) { if (address.path() != null) { throw new IllegalArgumentException("Domain socket not supported by JDK transport"); } else { if (resolved) { return new InetSocketAddress(address.host(), address.port()); } else { return InetSocketAddress.createUnresolved(address.host(), address.port()); } } }
@Test public void testListenSocketAddress() { NetClient netClient = vertx.createNetClient(); server = vertx.createHttpServer().requestHandler(req -> req.response().end()); SocketAddress sockAddress = SocketAddress.inetSocketAddress(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST); server.listen(sockAddress, onSuccess(server -> { netClient.connect(sockAddress, onSuccess(sock -> { sock.handler(buf -> { assertTrue("Response is not an http 200", buf.toString("UTF-8").startsWith("HTTP/1.1 200 OK")); testComplete(); }); sock.write("GET / HTTP/1.1\r\n\r\n"); })); })); try { await(); } finally { netClient.close(); } }
/** * 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()); }
private DatagramSocket listen(SocketAddress local, Handler<AsyncResult<DatagramSocket>> handler) { Objects.requireNonNull(handler, "no null handler accepted"); context.owner().resolveAddress(local.host(), res -> { if (res.succeeded()) { ChannelFuture future = channel.bind(new InetSocketAddress(res.result(), local.port())); addListener(future, ar -> { if (metrics != null && ar.succeeded()) { metrics.listening(local.host(), localAddress()); } handler.handle(ar); }); } else { handler.handle(Future.failedFuture(res.cause())); } }); return this; }
private Request<byte[]> buildRequest(RoutingContext routingContext) { HttpServerRequest vertxRequest = routingContext.request(); return new Request<>( vertxRequest.method().name(), vertxRequest.uri(), VertxTypeConverter.toGuavaMultimap(vertxRequest.params()), VertxTypeConverter.toGuavaMultimap(vertxRequest.headers()), routingContext.getBody().getBytes(), vertxRequest.remoteAddress().host(), vertxRequest.version().name()); } }
@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()); } }); } }
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; }
HttpServerMetric serverMetric = metrics.getMetric(req); assertNotNull(serverMetric); req.response().setStatusCode(200); req.response().setStatusMessage("Connection established"); NetSocket so = req.netSocket(); so.handler(so::write); so.closeHandler(v -> { assertEquals(5, serverMetric.socket.bytesRead.get()); assertEquals(5, serverMetric.socket.bytesWritten.get()); assertEquals(serverMetric.socket.remoteAddress.host(), serverMetric.socket.remoteName); assertFalse(clientMetric.get().socket.connected.get()); assertEquals(5, clientMetric.get().socket.bytesRead.get());
public ProxyRequestImpl(HttpClient client, SocketAddress target, HttpServerRequest request) { this(req -> { HttpMethod method = req.method(); HttpClientRequest backRequest = client.request(method, target.port(), target.host(), req.uri()); if (method == HttpMethod.OTHER) { backRequest.setRawMethod(req.rawMethod()); } return backRequest; }, request); }
@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; } }
@Test public void testListenDomainSocketAddress() throws Exception { Vertx vx = Vertx.vertx(new VertxOptions().setPreferNativeTransport(true)); Assume.assumeTrue("Native transport must be enabled", vx.isNativeTransportEnabled()); NetClient netClient = vx.createNetClient(); HttpServer httpserver = vx.createHttpServer().requestHandler(req -> req.response().end()); File sockFile = TestUtils.tmpFile(".sock"); SocketAddress sockAddress = SocketAddress.domainSocketAddress(sockFile.getAbsolutePath()); httpserver.listen(sockAddress, onSuccess(server -> { netClient.connect(sockAddress, onSuccess(sock -> { sock.handler(buf -> { assertTrue("Response is not an http 200", buf.toString("UTF-8").startsWith("HTTP/1.1 200 OK")); testComplete(); }); sock.write("GET / HTTP/1.1\r\n\r\n"); })); })); try { await(); } finally { vx.close(); } }
@Override public String localAddress() { SocketAddress address = httpServerRequest.localAddress(); return (address != null) ? address.host() : null; }
@Test public void testHttpConnect2() { testHttpConnect(TestUtils.loopbackAddress(), socketMetric -> assertEquals(socketMetric.remoteAddress.host(), socketMetric.remoteName)); }
@Override public int getLocalPort() { return this.vertxRequest.localAddress().port(); }
@Override public synchronized void onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding) throws Http2Exception { Http2ClientStream stream = (Http2ClientStream) streams.get(streamId); if (stream != null) { Handler<HttpClientRequest> pushHandler = stream.pushHandler(); if (pushHandler != null) { context.executeFromIO(v -> { String rawMethod = headers.method().toString(); HttpMethod method = HttpUtils.toVertxMethod(rawMethod); String uri = headers.path().toString(); String host = headers.authority() != null ? headers.authority().toString() : null; MultiMap headersMap = new Http2HeadersAdaptor(headers); Http2Stream promisedStream = handler.connection().stream(promisedStreamId); int port = remoteAddress().port(); HttpClientRequestPushPromise pushReq = new HttpClientRequestPushPromise(this, promisedStream, client, isSsl(), method, rawMethod, uri, host, port, headersMap); if (metrics != null) { pushReq.metric(metrics.responsePushed(queueMetric, metric(), localAddress(), remoteAddress(), pushReq)); } streams.put(promisedStreamId, pushReq.getStream()); pushHandler.handle(pushReq); }); return; } } handler.writeReset(promisedStreamId, Http2Error.CANCEL.code()); }
@Override public NetServer listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler) { return listen(SocketAddress.inetSocketAddress(port, host), listenHandler); }
public void setUp() throws Exception { super.setUp(); if (USE_DOMAIN_SOCKETS) { assertTrue("Native transport not enabled", USE_NATIVE_TRANSPORT); tmp = TestUtils.tmpFile(".sock"); testAddress = SocketAddress.domainSocketAddress(tmp.getAbsolutePath()); } else { testAddress = SocketAddress.inetSocketAddress(1234, "localhost"); } client = vertx.createNetClient(new NetClientOptions().setConnectTimeout(1000)); server = vertx.createNetServer(); }
@Test public void testDomainSocketClient() throws Exception { File sock = TestUtils.tmpFile(".sock"); vertx = Vertx.vertx(); NetClient client = vertx.createNetClient(); client.connect(SocketAddress.domainSocketAddress(sock.getAbsolutePath()), onFailure(err -> { assertEquals(err.getClass(), IllegalArgumentException.class); testComplete(); })); await(); } }