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()); } } }
@Override public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean resolved) { if (address.path() != null) { return new DomainSocketAddress(address.path()); } else { if (resolved) { return new InetSocketAddress(address.host(), address.port()); } else { return InetSocketAddress.createUnresolved(address.host(), address.port()); } } }
@Override public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean resolved) { if (address.path() != null) { return new DomainSocketAddress(address.path()); } else { if (resolved) { return new InetSocketAddress(address.host(), address.port()); } else { return InetSocketAddress.createUnresolved(address.host(), address.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; }
/** * 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()); }
public SSLEngine createEngine(VertxInternal vertx, SocketAddress socketAddress, String serverName) { SslContext context = getContext(vertx, null); SSLEngine engine; if (socketAddress.path() != null) { engine = context.newEngine(ByteBufAllocator.DEFAULT); } else { engine = context.newEngine(ByteBufAllocator.DEFAULT, socketAddress.host(), socketAddress.port()); } configureEngine(engine, serverName); return engine; }
listening = true; String host = address.host() != null ? address.host() : "localhost"; int port = address.port(); serverOrigin = (options.isSsl() ? "https" : "http") + "://" + host + ":" + port; List<HttpVersion> applicationProtocols = options.getAlpnVersions(); HttpServerImpl.this.actualPort = ((InetSocketAddress)serverChannel.localAddress()).getPort(); } else { HttpServerImpl.this.actualPort = address.port();
this.actualPort = socketAddress.port(); // Will be updated on bind for a wildcard port String hostOrPath = socketAddress.host() != null ? socketAddress.host() : socketAddress.path(); id = new ServerID(actualPort, hostOrPath);
@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()); }
@Test public void testDatagram2() throws Exception { testDatagram("localhost", packet -> { assertEquals("localhost", packet.remoteAddress.host()); assertEquals(1234, packet.remoteAddress.port()); assertEquals(5, packet.numberOfBytes); }); }
@Test public void testDatagram1() throws Exception { testDatagram("127.0.0.1", packet -> { assertEquals("127.0.0.1", packet.remoteAddress.host()); assertEquals(1234, packet.remoteAddress.port()); assertEquals(5, packet.numberOfBytes); }); }
@Override public int getRemotePort() { return this.sockerAddress == null ? 0 : this.sockerAddress.port(); }
@Test public void testEcho() { peer1 = vertx.createDatagramSocket(new DatagramSocketOptions()); peer2 = vertx.createDatagramSocket(new DatagramSocketOptions()); peer1.exceptionHandler(t -> fail(t.getMessage())); peer2.exceptionHandler(t -> fail(t.getMessage())); peer2.listen(1234, "127.0.0.1", ar -> { assertTrue(ar.succeeded()); Buffer buffer = TestUtils.randomBuffer(128); peer2.handler(packet -> { assertEquals("127.0.0.1", packet.sender().host()); assertEquals(1235, packet.sender().port()); assertEquals(buffer, packet.data()); peer2.send(packet.data(), 1235, "127.0.0.1", ar2 -> assertTrue(ar2.succeeded())); }); peer1.listen(1235, "127.0.0.1", ar2 -> { peer1.handler(packet -> { assertEquals(buffer, packet.data()); assertEquals("127.0.0.1", packet.sender().host()); assertEquals(1234, packet.sender().port()); testComplete(); }); peer1.send(buffer, 1234, "127.0.0.1", ar3 -> assertTrue(ar3.succeeded())); }); }); await(); }
@Test public void testRemoteAddress() { server.connectHandler(socket -> { SocketAddress addr = socket.remoteAddress(); assertEquals("127.0.0.1", addr.host()); socket.close(); }).listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); vertx.createNetClient(new NetClientOptions()).connect(1234, "localhost", onSuccess(socket -> { SocketAddress addr = socket.remoteAddress(); assertEquals("127.0.0.1", addr.host()); assertEquals(addr.port(), 1234); socket.closeHandler(v -> testComplete()); })); }); 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()); } } }
@Override public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean resolved) { if (address.path() != null) { return new DomainSocketAddress(address.path()); } else { if (resolved) { return new InetSocketAddress(address.host(), address.port()); } else { return InetSocketAddress.createUnresolved(address.host(), address.port()); } } }
@Override public String getFormattedItem(AccessLogParam<RoutingContext> accessLogParam) { HttpServerRequest request = accessLogParam.getContextData().request(); if (null == request) { return EMPTY_RESULT; } SocketAddress localAddress = request.localAddress(); if (null == localAddress) { return EMPTY_RESULT; } return String.valueOf(localAddress.port()); } }
public SSLEngine createEngine(VertxInternal vertx, SocketAddress socketAddress, String serverName) { SslContext context = getContext(vertx, null); SSLEngine engine; if (socketAddress.path() != null) { engine = context.newEngine(ByteBufAllocator.DEFAULT); } else { engine = context.newEngine(ByteBufAllocator.DEFAULT, socketAddress.host(), socketAddress.port()); } configureEngine(engine, serverName); return engine; }
@Test public void testDatagram2() throws Exception { testDatagram("localhost", packet -> { assertEquals("localhost", packet.remoteAddress.host()); assertEquals(1234, packet.remoteAddress.port()); assertEquals(5, packet.numberOfBytes); }); }