Examples with Empty org.elasticsearch.transport.TransportResponse.Empty used on opensource projects

Example 1 with Empty

use of org.elasticsearch.transport.TransportResponse.Empty in project elasticsearch by elastic.

the class RestBuilderListenerTests method testXContentBuilderClosedInBuildResponse.

public void testXContentBuilderClosedInBuildResponse() throws Exception {
    AtomicReference<XContentBuilder> builderAtomicReference = new AtomicReference<>();
    RestBuilderListener<TransportResponse.Empty> builderListener = new RestBuilderListener<Empty>(new FakeRestChannel(new FakeRestRequest(), randomBoolean(), 1)) {

        @Override
        public RestResponse buildResponse(Empty empty, XContentBuilder builder) throws Exception {
            builderAtomicReference.set(builder);
            builder.close();
            return new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, BytesArray.EMPTY);
        }
    };
    builderListener.buildResponse(Empty.INSTANCE);
    assertNotNull(builderAtomicReference.get());
    assertTrue(builderAtomicReference.get().generator().isClosed());
}

Example 2 with Empty

use of org.elasticsearch.transport.TransportResponse.Empty in project elasticsearch by elastic.

the class RestBuilderListenerTests method testXContentBuilderNotClosedInBuildResponseAssertionsEnabled.

public void testXContentBuilderNotClosedInBuildResponseAssertionsEnabled() throws Exception {
    assumeTrue("tests are not being run with assertions", RestBuilderListener.class.desiredAssertionStatus());
    RestBuilderListener<TransportResponse.Empty> builderListener = new RestBuilderListener<Empty>(new FakeRestChannel(new FakeRestRequest(), randomBoolean(), 1)) {

        @Override
        public RestResponse buildResponse(Empty empty, XContentBuilder builder) throws Exception {
            return new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, BytesArray.EMPTY);
        }
    };
    AssertionError error = expectThrows(AssertionError.class, () -> builderListener.buildResponse(Empty.INSTANCE));
    assertEquals("callers should ensure the XContentBuilder is closed themselves", error.getMessage());
}

Example 3 with Empty

use of org.elasticsearch.transport.TransportResponse.Empty in project crate by crate.

the class FollowersCheckerTests method testFailureCounterResetsOnSuccess.

public void testFailureCounterResetsOnSuccess() {
    final Builder settingsBuilder = Settings.builder();
    if (randomBoolean()) {
        settingsBuilder.put(FOLLOWER_CHECK_RETRY_COUNT_SETTING.getKey(), randomIntBetween(2, 10));
    }
    if (randomBoolean()) {
        settingsBuilder.put(FOLLOWER_CHECK_INTERVAL_SETTING.getKey(), randomIntBetween(100, 100000) + "ms");
    }
    final Settings settings = settingsBuilder.build();
    final int retryCount = FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings);
    final int maxRecoveries = randomIntBetween(3, 10);
    // passes just enough checks to keep it alive, up to maxRecoveries, and then fails completely
    testBehaviourOfFailingNode(settings, new Supplier<Empty>() {

        private int checkIndex;

        private int recoveries;

        @Override
        public Empty get() {
            checkIndex++;
            if (checkIndex % retryCount == 0 && recoveries < maxRecoveries) {
                recoveries++;
                return Empty.INSTANCE;
            }
            throw new ElasticsearchException("simulated exception");
        }
    }, "followers check retry count exceeded", (FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings) * (maxRecoveries + 1) - 1) * FOLLOWER_CHECK_INTERVAL_SETTING.get(settings).millis());
}

Example 4 with Empty

use of org.elasticsearch.transport.TransportResponse.Empty in project elasticsearch by elastic.

the class RestBuilderListenerTests method testXContentBuilderNotClosedInBuildResponseAssertionsDisabled.

public void testXContentBuilderNotClosedInBuildResponseAssertionsDisabled() throws Exception {
    AtomicReference<XContentBuilder> builderAtomicReference = new AtomicReference<>();
    RestBuilderListener<TransportResponse.Empty> builderListener = new RestBuilderListener<Empty>(new FakeRestChannel(new FakeRestRequest(), randomBoolean(), 1)) {

        @Override
        public RestResponse buildResponse(Empty empty, XContentBuilder builder) throws Exception {
            builderAtomicReference.set(builder);
            return new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, BytesArray.EMPTY);
        }

        @Override
        boolean assertBuilderClosed(XContentBuilder xContentBuilder) {
            // don't check the actual builder being closed so we can test auto close
            return true;
        }
    };
    builderListener.buildResponse(Empty.INSTANCE);
    assertNotNull(builderAtomicReference.get());
    assertTrue(builderAtomicReference.get().generator().isClosed());
}

Example 5 with Empty

use of org.elasticsearch.transport.TransportResponse.Empty in project crate by crate.

the class FollowersCheckerTests method testBehaviourOfFailingNode.

private void testBehaviourOfFailingNode(Settings testSettings, Supplier<TransportResponse.Empty> responder, String failureReason, long expectedFailureTime) {
    final DiscoveryNode localNode = new DiscoveryNode("local-node", buildNewFakeTransportAddress(), Version.CURRENT);
    final DiscoveryNode otherNode = new DiscoveryNode("other-node", buildNewFakeTransportAddress(), Version.CURRENT);
    final Settings settings = Settings.builder().put(NODE_NAME_SETTING.getKey(), localNode.getName()).put(testSettings).build();
    final DeterministicTaskQueue deterministicTaskQueue = new DeterministicTaskQueue(settings, random());
    final MockTransport mockTransport = new MockTransport() {

        @Override
        protected void onSendRequest(long requestId, String action, TransportRequest request, DiscoveryNode node) {
            assertFalse(node.equals(localNode));
            deterministicTaskQueue.scheduleNow(new Runnable() {

                @Override
                public void run() {
                    if (node.equals(otherNode) == false) {
                        // other nodes are ok
                        handleResponse(requestId, Empty.INSTANCE);
                        return;
                    }
                    try {
                        final Empty response = responder.get();
                        if (response != null) {
                            handleResponse(requestId, response);
                        }
                    } catch (Exception e) {
                        handleRemoteError(requestId, e);
                    }
                }

                @Override
                public String toString() {
                    return "sending response to [" + action + "][" + requestId + "] from " + node;
                }
            });
        }
    };
    final TransportService transportService = mockTransport.createTransportService(settings, deterministicTaskQueue.getThreadPool(), boundTransportAddress -> localNode, null);
    transportService.start();
    transportService.acceptIncomingRequests();
    final AtomicBoolean nodeFailed = new AtomicBoolean();
    final FollowersChecker followersChecker = new FollowersChecker(settings, transportService, fcr -> {
        assert false : fcr;
    }, (node, reason) -> {
        assertTrue(nodeFailed.compareAndSet(false, true));
        assertThat(reason, equalTo(failureReason));
    });
    DiscoveryNodes discoveryNodes = DiscoveryNodes.builder().add(localNode).add(otherNode).localNodeId(localNode.getId()).build();
    followersChecker.setCurrentNodes(discoveryNodes);
    while (nodeFailed.get() == false) {
        if (deterministicTaskQueue.hasRunnableTasks() == false) {
            deterministicTaskQueue.advanceTime();
        }
        deterministicTaskQueue.runAllRunnableTasks();
    }
    assertThat(deterministicTaskQueue.getCurrentTimeMillis(), equalTo(expectedFailureTime));
    assertThat(followersChecker.getFaultyNodes(), contains(otherNode));
    deterministicTaskQueue.runAllTasks();
    // add another node and see that it schedules checks for this new node but keeps on considering the old one faulty
    final DiscoveryNode otherNode2 = new DiscoveryNode("other-node-2", buildNewFakeTransportAddress(), Version.CURRENT);
    discoveryNodes = DiscoveryNodes.builder(discoveryNodes).add(otherNode2).build();
    followersChecker.setCurrentNodes(discoveryNodes);
    deterministicTaskQueue.runAllRunnableTasks();
    deterministicTaskQueue.advanceTime();
    deterministicTaskQueue.runAllRunnableTasks();
    assertThat(followersChecker.getFaultyNodes(), contains(otherNode));
    // remove the faulty node and see that it is removed
    discoveryNodes = DiscoveryNodes.builder(discoveryNodes).remove(otherNode).build();
    followersChecker.setCurrentNodes(discoveryNodes);
    assertThat(followersChecker.getFaultyNodes(), empty());
    deterministicTaskQueue.runAllRunnableTasks();
    deterministicTaskQueue.advanceTime();
    deterministicTaskQueue.runAllRunnableTasks();
    // remove the working node and see that everything eventually stops
    discoveryNodes = DiscoveryNodes.builder(discoveryNodes).remove(otherNode2).build();
    followersChecker.setCurrentNodes(discoveryNodes);
    deterministicTaskQueue.runAllTasks();
    // add back the faulty node afresh and see that it fails again
    discoveryNodes = DiscoveryNodes.builder(discoveryNodes).add(otherNode).build();
    followersChecker.setCurrentNodes(discoveryNodes);
    nodeFailed.set(false);
    assertThat(followersChecker.getFaultyNodes(), empty());
    deterministicTaskQueue.runAllTasksInTimeOrder();
    assertTrue(nodeFailed.get());
    assertThat(followersChecker.getFaultyNodes(), contains(otherNode));
}