Examples with TransportChannel org.opensearch.transport.TransportChannel used on opensource projects

Example 1 with TransportChannel

use of org.opensearch.transport.TransportChannel in project OpenSearch by opensearch-project.

the class DisruptableMockTransport method onConnectedDuringSend.

protected void onConnectedDuringSend(long requestId, String action, TransportRequest request, DisruptableMockTransport destinationTransport) {
    final RequestHandlerRegistry<TransportRequest> requestHandler = destinationTransport.getRequestHandlers().getHandler(action);
    final DiscoveryNode destination = destinationTransport.getLocalNode();
    final String requestDescription = getRequestDescription(requestId, action, destination);
    final TransportChannel transportChannel = new TransportChannel() {

        @Override
        public String getProfileName() {
            return "default";
        }

        @Override
        public String getChannelType() {
            return "disruptable-mock-transport-channel";
        }

        @Override
        public void sendResponse(final TransportResponse response) {
            execute(new Runnable() {

                @Override
                public void run() {
                    final ConnectionStatus connectionStatus = destinationTransport.getConnectionStatus(getLocalNode());
                    switch(connectionStatus) {
                        case CONNECTED:
                        case BLACK_HOLE_REQUESTS_ONLY:
                            handleResponse(requestId, response);
                            break;
                        case BLACK_HOLE:
                        case DISCONNECTED:
                            logger.trace("delaying response to {}: channel is {}", requestDescription, connectionStatus);
                            onBlackholedDuringSend(requestId, action, destinationTransport);
                            break;
                        default:
                            throw new AssertionError("unexpected status: " + connectionStatus);
                    }
                }

                @Override
                public String toString() {
                    return "response to " + requestDescription;
                }
            });
        }

        @Override
        public void sendResponse(Exception exception) {
            execute(new Runnable() {

                @Override
                public void run() {
                    final ConnectionStatus connectionStatus = destinationTransport.getConnectionStatus(getLocalNode());
                    switch(connectionStatus) {
                        case CONNECTED:
                        case BLACK_HOLE_REQUESTS_ONLY:
                            handleRemoteError(requestId, exception);
                            break;
                        case BLACK_HOLE:
                        case DISCONNECTED:
                            logger.trace("delaying exception response to {}: channel is {}", requestDescription, connectionStatus);
                            onBlackholedDuringSend(requestId, action, destinationTransport);
                            break;
                        default:
                            throw new AssertionError("unexpected status: " + connectionStatus);
                    }
                }

                @Override
                public String toString() {
                    return "error response to " + requestDescription;
                }
            });
        }
    };
    final TransportRequest copiedRequest;
    try {
        copiedRequest = copyWriteable(request, writeableRegistry(), requestHandler::newRequest);
    } catch (IOException e) {
        throw new AssertionError("exception de/serializing request", e);
    }
    try {
        requestHandler.processMessageReceived(copiedRequest, transportChannel);
    } catch (Exception e) {
        try {
            transportChannel.sendResponse(e);
        } catch (Exception ee) {
            logger.warn("failed to send failure", e);
        }
    }
}

Example 2 with TransportChannel

use of org.opensearch.transport.TransportChannel in project OpenSearch by opensearch-project.

the class DisruptableMockTransportTests method testUnavailableOnExceptionalResponse.

public void testUnavailableOnExceptionalResponse() throws IOException {
    registerRequestHandler(service1, requestHandlerShouldNotBeCalled());
    AtomicReference<TransportChannel> responseHandlerChannel = new AtomicReference<>();
    registerRequestHandler(service2, requestHandlerCaptures(responseHandlerChannel::set));
    send(service1, node2, responseHandlerShouldNotBeCalled());
    deterministicTaskQueue.runAllRunnableTasks();
    assertNotNull(responseHandlerChannel.get());
    blackholedLinks.add(Tuple.tuple(node2, node1));
    responseHandlerChannel.get().sendResponse(new Exception());
    deterministicTaskQueue.runAllRunnableTasks();
}

Example 3 with TransportChannel

use of org.opensearch.transport.TransportChannel in project OpenSearch by opensearch-project.

the class DisruptableMockTransportTests method testUnavailableOnRequestOnlyReceivesExceptionalResponse.

public void testUnavailableOnRequestOnlyReceivesExceptionalResponse() throws IOException {
    registerRequestHandler(service1, requestHandlerShouldNotBeCalled());
    AtomicReference<TransportChannel> responseHandlerChannel = new AtomicReference<>();
    registerRequestHandler(service2, requestHandlerCaptures(responseHandlerChannel::set));
    AtomicBoolean responseHandlerCalled = new AtomicBoolean();
    send(service1, node2, responseHandlerShouldBeCalledExceptionally(e -> responseHandlerCalled.set(true)));
    deterministicTaskQueue.runAllTasks();
    assertNotNull(responseHandlerChannel.get());
    assertFalse(responseHandlerCalled.get());
    blackholedRequestLinks.add(Tuple.tuple(node1, node2));
    blackholedRequestLinks.add(Tuple.tuple(node2, node1));
    responseHandlerChannel.get().sendResponse(new Exception());
    deterministicTaskQueue.runAllRunnableTasks();
    assertTrue(responseHandlerCalled.get());
}

Example 4 with TransportChannel

use of org.opensearch.transport.TransportChannel in project OpenSearch by opensearch-project.

the class DisruptableMockTransportTests method testDisconnectedOnExceptionalResponse.

public void testDisconnectedOnExceptionalResponse() throws IOException {
    registerRequestHandler(service1, requestHandlerShouldNotBeCalled());
    AtomicReference<TransportChannel> responseHandlerChannel = new AtomicReference<>();
    registerRequestHandler(service2, requestHandlerCaptures(responseHandlerChannel::set));
    AtomicReference<TransportException> responseHandlerException = new AtomicReference<>();
    send(service1, node2, responseHandlerShouldBeCalledExceptionally(responseHandlerException::set));
    deterministicTaskQueue.runAllRunnableTasks();
    assertNotNull(responseHandlerChannel.get());
    assertNull(responseHandlerException.get());
    disconnectedLinks.add(Tuple.tuple(node2, node1));
    responseHandlerChannel.get().sendResponse(new Exception());
    deterministicTaskQueue.runAllTasks();
    assertThat(responseHandlerException.get(), instanceOf(ConnectTransportException.class));
}

Example 5 with TransportChannel

use of org.opensearch.transport.TransportChannel in project OpenSearch by opensearch-project.

the class DisruptableMockTransportTests method testUnavailableOnRequestOnlyReceivesSuccessfulResponse.

public void testUnavailableOnRequestOnlyReceivesSuccessfulResponse() throws IOException {
    registerRequestHandler(service1, requestHandlerShouldNotBeCalled());
    AtomicReference<TransportChannel> responseHandlerChannel = new AtomicReference<>();
    registerRequestHandler(service2, requestHandlerCaptures(responseHandlerChannel::set));
    AtomicBoolean responseHandlerCalled = new AtomicBoolean();
    send(service1, node2, responseHandlerShouldBeCalledNormally(() -> responseHandlerCalled.set(true)));
    deterministicTaskQueue.runAllTasks();
    assertNotNull(responseHandlerChannel.get());
    assertFalse(responseHandlerCalled.get());
    blackholedRequestLinks.add(Tuple.tuple(node1, node2));
    blackholedRequestLinks.add(Tuple.tuple(node2, node1));
    responseHandlerChannel.get().sendResponse(TransportResponse.Empty.INSTANCE);
    deterministicTaskQueue.runAllRunnableTasks();
    assertTrue(responseHandlerCalled.get());
}