Examples with TransportAddress org.opensearch.common.transport.TransportAddress used on opensource projects

Example 11 with TransportAddress

use of org.opensearch.common.transport.TransportAddress in project OpenSearch by opensearch-project.

the class SeedHostsResolver method resolveHostsLists.

/**
 * Resolves a list of hosts to a list of transport addresses. Each host is resolved into a transport address (or a collection of
 * addresses if the number of ports is greater than one). Host lookups are done in parallel using specified executor service up
 * to the specified resolve timeout.
 *
 * @param executorService  the executor service used to parallelize hostname lookups
 * @param logger           logger used for logging messages regarding hostname lookups
 * @param hosts            the hosts to resolve
 * @param transportService the transport service
 * @param resolveTimeout   the timeout before returning from hostname lookups
 * @return a list of resolved transport addresses
 */
public static List<TransportAddress> resolveHostsLists(final CancellableThreads cancellableThreads, final ExecutorService executorService, final Logger logger, final List<String> hosts, final TransportService transportService, final TimeValue resolveTimeout) {
    Objects.requireNonNull(executorService);
    Objects.requireNonNull(logger);
    Objects.requireNonNull(hosts);
    Objects.requireNonNull(transportService);
    Objects.requireNonNull(resolveTimeout);
    if (resolveTimeout.nanos() < 0) {
        throw new IllegalArgumentException("resolve timeout must be non-negative but was [" + resolveTimeout + "]");
    }
    // create tasks to submit to the executor service; we will wait up to resolveTimeout for these tasks to complete
    final List<Callable<TransportAddress[]>> callables = hosts.stream().map(hn -> (Callable<TransportAddress[]>) () -> transportService.addressesFromString(hn)).collect(Collectors.toList());
    final SetOnce<List<Future<TransportAddress[]>>> futures = new SetOnce<>();
    try {
        cancellableThreads.execute(() -> futures.set(executorService.invokeAll(callables, resolveTimeout.nanos(), TimeUnit.NANOSECONDS)));
    } catch (CancellableThreads.ExecutionCancelledException e) {
        return Collections.emptyList();
    }
    final List<TransportAddress> transportAddresses = new ArrayList<>();
    final Set<TransportAddress> localAddresses = new HashSet<>();
    localAddresses.add(transportService.boundAddress().publishAddress());
    localAddresses.addAll(Arrays.asList(transportService.boundAddress().boundAddresses()));
    // ExecutorService#invokeAll guarantees that the futures are returned in the iteration order of the tasks so we can associate the
    // hostname with the corresponding task by iterating together
    final Iterator<String> it = hosts.iterator();
    for (final Future<TransportAddress[]> future : futures.get()) {
        assert future.isDone();
        final String hostname = it.next();
        if (!future.isCancelled()) {
            try {
                final TransportAddress[] addresses = future.get();
                logger.trace("resolved host [{}] to {}", hostname, addresses);
                for (int addressId = 0; addressId < addresses.length; addressId++) {
                    final TransportAddress address = addresses[addressId];
                    // no point in pinging ourselves
                    if (localAddresses.contains(address) == false) {
                        transportAddresses.add(address);
                    }
                }
            } catch (final ExecutionException e) {
                assert e.getCause() != null;
                final String message = "failed to resolve host [" + hostname + "]";
                logger.warn(message, e.getCause());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            // ignore
            }
        } else {
            logger.warn("timed out after [{}] resolving host [{}]", resolveTimeout, hostname);
        }
    }
    return Collections.unmodifiableList(transportAddresses);
}

Example 12 with TransportAddress

use of org.opensearch.common.transport.TransportAddress in project OpenSearch by opensearch-project.

the class AbstractHttpServerTransport method bindServer.

protected void bindServer() {
    // Bind and start to accept incoming connections.
    InetAddress[] hostAddresses;
    try {
        hostAddresses = networkService.resolveBindHostAddresses(bindHosts);
    } catch (IOException e) {
        throw new BindHttpException("Failed to resolve host [" + Arrays.toString(bindHosts) + "]", e);
    }
    List<TransportAddress> boundAddresses = new ArrayList<>(hostAddresses.length);
    for (InetAddress address : hostAddresses) {
        boundAddresses.add(bindAddress(address));
    }
    final InetAddress publishInetAddress;
    try {
        publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts);
    } catch (Exception e) {
        throw new BindTransportException("Failed to resolve publish address", e);
    }
    final int publishPort = resolvePublishPort(settings, boundAddresses, publishInetAddress);
    TransportAddress publishAddress = new TransportAddress(new InetSocketAddress(publishInetAddress, publishPort));
    this.boundAddress = new BoundTransportAddress(boundAddresses.toArray(new TransportAddress[0]), publishAddress);
    logger.info("{}", boundAddress);
}

Example 13 with TransportAddress

use of org.opensearch.common.transport.TransportAddress in project OpenSearch by opensearch-project.

the class AbstractHttpServerTransport method bindAddress.

private TransportAddress bindAddress(final InetAddress hostAddress) {
    final AtomicReference<Exception> lastException = new AtomicReference<>();
    final AtomicReference<InetSocketAddress> boundSocket = new AtomicReference<>();
    boolean success = port.iterate(portNumber -> {
        try {
            synchronized (httpServerChannels) {
                HttpServerChannel httpServerChannel = bind(new InetSocketAddress(hostAddress, portNumber));
                httpServerChannels.add(httpServerChannel);
                boundSocket.set(httpServerChannel.getLocalAddress());
            }
        } catch (Exception e) {
            lastException.set(e);
            return false;
        }
        return true;
    });
    if (!success) {
        throw new BindHttpException("Failed to bind to " + NetworkAddress.format(hostAddress, port), lastException.get());
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Bound http to address {{}}", NetworkAddress.format(boundSocket.get()));
    }
    return new TransportAddress(boundSocket.get());
}

Example 14 with TransportAddress

use of org.opensearch.common.transport.TransportAddress in project OpenSearch by opensearch-project.

the class InboundHandler method handleRequest.

private <T extends TransportRequest> void handleRequest(TcpChannel channel, Header header, InboundMessage message) throws IOException {
    final String action = header.getActionName();
    final long requestId = header.getRequestId();
    final Version version = header.getVersion();
    if (header.isHandshake()) {
        messageListener.onRequestReceived(requestId, action);
        // Cannot short circuit handshakes
        assert message.isShortCircuit() == false;
        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
        assertRemoteVersion(stream, header.getVersion());
        final TransportChannel transportChannel = new TcpTransportChannel(outboundHandler, channel, action, requestId, version, header.getFeatures(), header.isCompressed(), header.isHandshake(), message.takeBreakerReleaseControl());
        try {
            handshaker.handleHandshake(transportChannel, requestId, stream);
        } catch (Exception e) {
            if (Version.CURRENT.isCompatible(header.getVersion())) {
                sendErrorResponse(action, transportChannel, e);
            } else {
                logger.warn(new ParameterizedMessage("could not send error response to handshake received on [{}] using wire format version [{}], closing channel", channel, header.getVersion()), e);
                channel.close();
            }
        }
    } else {
        final TransportChannel transportChannel = new TcpTransportChannel(outboundHandler, channel, action, requestId, version, header.getFeatures(), header.isCompressed(), header.isHandshake(), message.takeBreakerReleaseControl());
        try {
            messageListener.onRequestReceived(requestId, action);
            if (message.isShortCircuit()) {
                sendErrorResponse(action, transportChannel, message.getException());
            } else {
                final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
                assertRemoteVersion(stream, header.getVersion());
                final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
                assert reg != null;
                final T request = newRequest(requestId, action, stream, reg);
                request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                checkStreamIsFullyConsumed(requestId, action, stream);
                final String executor = reg.getExecutor();
                if (ThreadPool.Names.SAME.equals(executor)) {
                    try {
                        reg.processMessageReceived(request, transportChannel);
                    } catch (Exception e) {
                        sendErrorResponse(reg.getAction(), transportChannel, e);
                    }
                } else {
                    threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
                }
            }
        } catch (Exception e) {
            sendErrorResponse(action, transportChannel, e);
        }
    }
}

Example 15 with TransportAddress

use of org.opensearch.common.transport.TransportAddress in project OpenSearch by opensearch-project.

the class InboundHandler method handleResponse.

private <T extends TransportResponse> void handleResponse(final long requestId, InetSocketAddress remoteAddress, final StreamInput stream, final TransportResponseHandler<T> handler) {
    final T response;
    try {
        response = handler.read(stream);
        response.remoteAddress(new TransportAddress(remoteAddress));
        checkStreamIsFullyConsumed(requestId, handler, stream, false);
    } catch (Exception e) {
        final Exception serializationException = new TransportSerializationException("Failed to deserialize response from handler [" + handler + "]", e);
        logger.warn(new ParameterizedMessage("Failed to deserialize response from [{}]", remoteAddress), serializationException);
        handleException(handler, serializationException);
        return;
    }
    final String executor = handler.executor();
    if (ThreadPool.Names.SAME.equals(executor)) {
        doHandleResponse(handler, response);
    } else {
        threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
    }
}