Examples with StreamInput org.opensearch.common.io.stream.StreamInput used on opensource projects

Example 86 with StreamInput

use of org.opensearch.common.io.stream.StreamInput in project OpenSearch by opensearch-project.

the class GeoDistanceTests method testGeoDistanceSerialization.

public void testGeoDistanceSerialization() throws IOException {
    // make sure that ordinals don't change, because we rely on then in serialization
    assertThat(GeoDistance.PLANE.ordinal(), equalTo(0));
    assertThat(GeoDistance.ARC.ordinal(), equalTo(1));
    assertThat(GeoDistance.values().length, equalTo(2));
    GeoDistance geoDistance = randomFrom(GeoDistance.PLANE, GeoDistance.ARC);
    try (BytesStreamOutput out = new BytesStreamOutput()) {
        geoDistance.writeTo(out);
        try (StreamInput in = out.bytes().streamInput()) {
            GeoDistance copy = GeoDistance.readFromStream(in);
            assertEquals(copy.toString() + " vs. " + geoDistance.toString(), copy, geoDistance);
        }
    }
}

Example 87 with StreamInput

use of org.opensearch.common.io.stream.StreamInput in project OpenSearch by opensearch-project.

the class RetentionLeaseSyncAction method sync.

final void sync(ShardId shardId, String primaryAllocationId, long primaryTerm, RetentionLeases retentionLeases, ActionListener<ReplicationResponse> listener) {
    final ThreadContext threadContext = threadPool.getThreadContext();
    try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
        // we have to execute under the system context so that if security is enabled the sync is authorized
        threadContext.markAsSystemContext();
        final Request request = new Request(shardId, retentionLeases);
        final ReplicationTask task = (ReplicationTask) taskManager.register("transport", "retention_lease_sync", request);
        transportService.sendChildRequest(clusterService.localNode(), transportPrimaryAction, new ConcreteShardRequest<>(request, primaryAllocationId, primaryTerm), task, transportOptions, new TransportResponseHandler<ReplicationResponse>() {

            @Override
            public ReplicationResponse read(StreamInput in) throws IOException {
                return newResponseInstance(in);
            }

            @Override
            public String executor() {
                return ThreadPool.Names.SAME;
            }

            @Override
            public void handleResponse(ReplicationResponse response) {
                task.setPhase("finished");
                taskManager.unregister(task);
                listener.onResponse(response);
            }

            @Override
            public void handleException(TransportException e) {
                if (ExceptionsHelper.unwrap(e, IndexNotFoundException.class, AlreadyClosedException.class, IndexShardClosedException.class) == null) {
                    getLogger().warn(new ParameterizedMessage("{} retention lease sync failed", shardId), e);
                }
                task.setPhase("finished");
                taskManager.unregister(task);
                listener.onFailure(e);
            }
        });
    }
}

Example 88 with StreamInput

use of org.opensearch.common.io.stream.StreamInput in project OpenSearch by opensearch-project.

the class InboundHandler method messageReceived.

private void messageReceived(TcpChannel channel, InboundMessage message, long startTime) throws IOException {
    final InetSocketAddress remoteAddress = channel.getRemoteAddress();
    final Header header = message.getHeader();
    assert header.needsToReadVariableHeader() == false;
    ThreadContext threadContext = threadPool.getThreadContext();
    try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
        // Place the context with the headers from the message
        threadContext.setHeaders(header.getHeaders());
        threadContext.putTransient("_remote_address", remoteAddress);
        if (header.isRequest()) {
            handleRequest(channel, header, message);
        } else {
            // Responses do not support short circuiting currently
            assert message.isShortCircuit() == false;
            final TransportResponseHandler<?> handler;
            long requestId = header.getRequestId();
            if (header.isHandshake()) {
                handler = handshaker.removeHandlerForHandshake(requestId);
            } else {
                TransportResponseHandler<? extends TransportResponse> theHandler = responseHandlers.onResponseReceived(requestId, messageListener);
                if (theHandler == null && header.isError()) {
                    handler = handshaker.removeHandlerForHandshake(requestId);
                } else {
                    handler = theHandler;
                }
            }
            // ignore if its null, the service logs it
            if (handler != null) {
                final StreamInput streamInput;
                if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
                    streamInput = namedWriteableStream(message.openOrGetStreamInput());
                    assertRemoteVersion(streamInput, header.getVersion());
                    if (header.isError()) {
                        handlerResponseError(requestId, streamInput, handler);
                    } else {
                        handleResponse(requestId, remoteAddress, streamInput, handler);
                    }
                } else {
                    assert header.isError() == false;
                    handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
                }
            }
        }
    } finally {
        final long took = threadPool.relativeTimeInMillis() - startTime;
        final long logThreshold = slowLogThresholdMs;
        if (logThreshold > 0 && took > logThreshold) {
            logger.warn("handling inbound transport message [{}] took [{}ms] which is above the warn threshold of [{}ms]", message, took, logThreshold);
        }
    }
}

Example 89 with StreamInput

use of org.opensearch.common.io.stream.StreamInput 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 90 with StreamInput

use of org.opensearch.common.io.stream.StreamInput in project OpenSearch by opensearch-project.

the class TransportService method sendRequest.

/**
 * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
 *
 * @param connection the connection to send the request on
 * @param action     the name of the action
 * @param request    the request
 * @param options    the options for this request
 * @param handler    the response handler
 * @param <T>        the type of the transport response
 */
public final <T extends TransportResponse> void sendRequest(final Transport.Connection connection, final String action, final TransportRequest request, final TransportRequestOptions options, final TransportResponseHandler<T> handler) {
    try {
        final TransportResponseHandler<T> delegate;
        if (request.getParentTask().isSet()) {
            // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
            final Releasable unregisterChildNode = taskManager.registerChildNode(request.getParentTask().getId(), connection.getNode());
            delegate = new TransportResponseHandler<T>() {

                @Override
                public void handleResponse(T response) {
                    unregisterChildNode.close();
                    handler.handleResponse(response);
                }

                @Override
                public void handleException(TransportException exp) {
                    unregisterChildNode.close();
                    handler.handleException(exp);
                }

                @Override
                public String executor() {
                    return handler.executor();
                }

                @Override
                public T read(StreamInput in) throws IOException {
                    return handler.read(in);
                }

                @Override
                public String toString() {
                    return getClass().getName() + "/[" + action + "]:" + handler.toString();
                }
            };
        } else {
            delegate = handler;
        }
        asyncSender.sendRequest(connection, action, request, options, delegate);
    } catch (final Exception ex) {
        // the caller might not handle this so we invoke the handler
        final TransportException te;
        if (ex instanceof TransportException) {
            te = (TransportException) ex;
        } else {
            te = new TransportException("failure to send", ex);
        }
        handler.handleException(te);
    }
}