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

Example 1 with TransportResponse

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

the class NodeJoinTests method handleFollowerCheckFrom.

private void handleFollowerCheckFrom(DiscoveryNode node, long term) throws Exception {
    final RequestHandlerRegistry<FollowersChecker.FollowerCheckRequest> followerCheckHandler = transport.getRequestHandlers().getHandler(FollowersChecker.FOLLOWER_CHECK_ACTION_NAME);
    final TestTransportChannel channel = new TestTransportChannel(new ActionListener<TransportResponse>() {

        @Override
        public void onResponse(TransportResponse transportResponse) {
        }

        @Override
        public void onFailure(Exception e) {
            fail();
        }
    });
    followerCheckHandler.processMessageReceived(new FollowersChecker.FollowerCheckRequest(term, node), channel);
    // Will throw exception if failed
    deterministicTaskQueue.runAllRunnableTasks();
    assertFalse(isLocalNodeElectedMaster());
    assertThat(coordinator.getMode(), equalTo(Coordinator.Mode.FOLLOWER));
}

Example 2 with TransportResponse

use of org.opensearch.transport.TransportResponse 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 3 with TransportResponse

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

the class ClearScrollController method cleanAllScrolls.

void cleanAllScrolls() {
    for (final DiscoveryNode node : nodes) {
        try {
            Transport.Connection connection = searchTransportService.getConnection(null, node);
            searchTransportService.sendClearAllScrollContexts(connection, new ActionListener<TransportResponse>() {

                @Override
                public void onResponse(TransportResponse response) {
                    onFreedContext(true);
                }

                @Override
                public void onFailure(Exception e) {
                    onFailedFreedContext(e, node);
                }
            });
        } catch (Exception e) {
            onFailedFreedContext(e, node);
        }
    }
}

Example 4 with TransportResponse

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

the class TransportReplicationActionTests method testRetryOnReplicaWithRealTransport.

public void testRetryOnReplicaWithRealTransport() throws Exception {
    final ShardId shardId = new ShardId("test", "_na_", 0);
    final ClusterState initialState = state(shardId.getIndexName(), true, ShardRoutingState.STARTED, ShardRoutingState.STARTED);
    final ShardRouting replica = initialState.getRoutingTable().shardRoutingTable(shardId).replicaShards().get(0);
    final long primaryTerm = initialState.metadata().index(shardId.getIndexName()).primaryTerm(shardId.id());
    // simulate execution of the node holding the replica
    final ClusterState stateWithNodes = ClusterState.builder(initialState).nodes(DiscoveryNodes.builder(initialState.nodes()).localNodeId(replica.currentNodeId())).build();
    setState(clusterService, stateWithNodes);
    AtomicBoolean throwException = new AtomicBoolean(true);
    final ReplicationTask task = maybeTask();
    NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(Collections.emptyList());
    final Transport transport = new MockNioTransport(Settings.EMPTY, Version.CURRENT, threadPool, new NetworkService(Collections.emptyList()), PageCacheRecycler.NON_RECYCLING_INSTANCE, namedWriteableRegistry, new NoneCircuitBreakerService());
    transportService = new MockTransportService(Settings.EMPTY, transport, threadPool, TransportService.NOOP_TRANSPORT_INTERCEPTOR, x -> clusterService.localNode(), null, Collections.emptySet());
    transportService.start();
    transportService.acceptIncomingRequests();
    AtomicBoolean calledSuccessfully = new AtomicBoolean(false);
    TestAction action = new TestAction(Settings.EMPTY, "internal:testActionWithExceptions", transportService, clusterService, shardStateAction, threadPool) {

        @Override
        protected void shardOperationOnReplica(Request shardRequest, IndexShard replica, ActionListener<ReplicaResult> listener) {
            ActionListener.completeWith(listener, () -> {
                assertPhase(task, "replica");
                if (throwException.get()) {
                    throw new RetryOnReplicaException(shardId, "simulation");
                }
                calledSuccessfully.set(true);
                return new ReplicaResult();
            });
        }
    };
    final PlainActionFuture<TransportResponse> listener = new PlainActionFuture<>();
    final Request request = new Request(shardId);
    final long checkpoint = randomNonNegativeLong();
    final long maxSeqNoOfUpdates = randomNonNegativeLong();
    action.handleReplicaRequest(new TransportReplicationAction.ConcreteReplicaRequest<>(request, replica.allocationId().getId(), primaryTerm, checkpoint, maxSeqNoOfUpdates), createTransportChannel(listener), task);
    if (listener.isDone()) {
        // fail with the exception if there
        listener.get();
        fail("listener shouldn't be done");
    }
    // release the waiting
    throwException.set(false);
    // publish a new state (same as the old state with the version incremented)
    setState(clusterService, stateWithNodes);
    // Assert that the request was retried, this time successful
    assertTrue("action should have been successfully called on retry but was not", calledSuccessfully.get());
    transportService.stop();
}

Example 5 with TransportResponse

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

the class TransportReplicationActionTests method testRetryOnReplica.

/**
 * test throwing a {@link org.opensearch.action.support.replication.TransportReplicationAction.RetryOnReplicaException}
 * causes a retry
 */
public void testRetryOnReplica() throws Exception {
    final ShardId shardId = new ShardId("test", "_na_", 0);
    ClusterState state = state(shardId.getIndexName(), true, ShardRoutingState.STARTED, ShardRoutingState.STARTED);
    final ShardRouting replica = state.getRoutingTable().shardRoutingTable(shardId).replicaShards().get(0);
    final long primaryTerm = state.metadata().index(shardId.getIndexName()).primaryTerm(shardId.id());
    // simulate execution of the node holding the replica
    state = ClusterState.builder(state).nodes(DiscoveryNodes.builder(state.nodes()).localNodeId(replica.currentNodeId())).build();
    setState(clusterService, state);
    AtomicBoolean throwException = new AtomicBoolean(true);
    final ReplicationTask task = maybeTask();
    TestAction action = new TestAction(Settings.EMPTY, "internal:testActionWithExceptions", transportService, clusterService, shardStateAction, threadPool) {

        @Override
        protected void shardOperationOnReplica(Request shardRequest, IndexShard replica, ActionListener<ReplicaResult> listener) {
            ActionListener.completeWith(listener, () -> {
                assertPhase(task, "replica");
                if (throwException.get()) {
                    throw new RetryOnReplicaException(shardId, "simulation");
                }
                return new ReplicaResult();
            });
        }
    };
    final PlainActionFuture<TransportResponse> listener = new PlainActionFuture<>();
    final Request request = new Request(shardId);
    final long checkpoint = randomNonNegativeLong();
    final long maxSeqNoOfUpdatesOrDeletes = randomNonNegativeLong();
    action.handleReplicaRequest(new TransportReplicationAction.ConcreteReplicaRequest<>(request, replica.allocationId().getId(), primaryTerm, checkpoint, maxSeqNoOfUpdatesOrDeletes), createTransportChannel(listener), task);
    if (listener.isDone()) {
        // fail with the exception if there
        listener.get();
        fail("listener shouldn't be done");
    }
    // no retry yet
    List<CapturingTransport.CapturedRequest> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear().get(replica.currentNodeId());
    assertThat(capturedRequests, nullValue());
    // release the waiting
    throwException.set(false);
    setState(clusterService, state);
    capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear().get(replica.currentNodeId());
    assertThat(capturedRequests, notNullValue());
    assertThat(capturedRequests.size(), equalTo(1));
    final CapturingTransport.CapturedRequest capturedRequest = capturedRequests.get(0);
    assertThat(capturedRequest.action, equalTo("internal:testActionWithExceptions[r]"));
    assertThat(capturedRequest.request, instanceOf(TransportReplicationAction.ConcreteReplicaRequest.class));
    assertThat(((TransportReplicationAction.ConcreteReplicaRequest) capturedRequest.request).getGlobalCheckpoint(), equalTo(checkpoint));
    assertThat(((TransportReplicationAction.ConcreteReplicaRequest) capturedRequest.request).getMaxSeqNoOfUpdatesOrDeletes(), equalTo(maxSeqNoOfUpdatesOrDeletes));
    assertConcreteShardRequest(capturedRequest.request, request, replica.allocationId());
}