Examples with TransportConnectionListener org.elasticsearch.transport.TransportConnectionListener used on opensource projects

Example 1 with TransportConnectionListener

use of org.elasticsearch.transport.TransportConnectionListener in project elasticsearch by elastic.

the class RemoteClusterConnectionTests method testNodeDisconnected.

public void testNodeDisconnected() throws Exception {
    List<DiscoveryNode> knownNodes = new CopyOnWriteArrayList<>();
    try (MockTransportService seedTransport = startTransport("seed_node", knownNodes, Version.CURRENT);
        MockTransportService discoverableTransport = startTransport("discoverable_node", knownNodes, Version.CURRENT);
        MockTransportService spareTransport = startTransport("spare_node", knownNodes, Version.CURRENT)) {
        DiscoveryNode seedNode = seedTransport.getLocalDiscoNode();
        DiscoveryNode discoverableNode = discoverableTransport.getLocalDiscoNode();
        DiscoveryNode spareNode = spareTransport.getLocalDiscoNode();
        knownNodes.add(seedTransport.getLocalDiscoNode());
        knownNodes.add(discoverableTransport.getLocalDiscoNode());
        Collections.shuffle(knownNodes, random());
        try (MockTransportService service = MockTransportService.createNewService(Settings.EMPTY, Version.CURRENT, threadPool, null)) {
            service.start();
            service.acceptIncomingRequests();
            try (RemoteClusterConnection connection = new RemoteClusterConnection(Settings.EMPTY, "test-cluster", Arrays.asList(seedNode), service, Integer.MAX_VALUE, n -> true)) {
                updateSeedNodes(connection, Arrays.asList(seedNode));
                assertTrue(service.nodeConnected(seedNode));
                assertTrue(service.nodeConnected(discoverableNode));
                assertFalse(service.nodeConnected(spareNode));
                knownNodes.add(spareNode);
                CountDownLatch latchDisconnect = new CountDownLatch(1);
                CountDownLatch latchConnected = new CountDownLatch(1);
                service.addConnectionListener(new TransportConnectionListener() {

                    @Override
                    public void onNodeDisconnected(DiscoveryNode node) {
                        if (node.equals(discoverableNode)) {
                            latchDisconnect.countDown();
                        }
                    }

                    @Override
                    public void onNodeConnected(DiscoveryNode node) {
                        if (node.equals(spareNode)) {
                            latchConnected.countDown();
                        }
                    }
                });
                discoverableTransport.close();
                // now make sure we try to connect again to other nodes once we got disconnected
                assertTrue(latchDisconnect.await(10, TimeUnit.SECONDS));
                assertTrue(latchConnected.await(10, TimeUnit.SECONDS));
                assertTrue(service.nodeConnected(spareNode));
            }
        }
    }
}

Example 2 with TransportConnectionListener

use of org.elasticsearch.transport.TransportConnectionListener in project elasticsearch by elastic.

the class UnicastZenPingTests method testResolveReuseExistingNodeConnections.

public void testResolveReuseExistingNodeConnections() throws ExecutionException, InterruptedException {
    final Settings settings = Settings.builder().put("cluster.name", "test").put(TransportSettings.PORT.getKey(), 0).build();
    NetworkService networkService = new NetworkService(settings, Collections.emptyList());
    final BiFunction<Settings, Version, Transport> supplier = (s, v) -> new MockTcpTransport(s, threadPool, BigArrays.NON_RECYCLING_INSTANCE, new NoneCircuitBreakerService(), new NamedWriteableRegistry(Collections.emptyList()), networkService, v);
    NetworkHandle handleA = startServices(settings, threadPool, "UZP_A", Version.CURRENT, supplier, EnumSet.allOf(Role.class));
    closeables.push(handleA.transportService);
    NetworkHandle handleB = startServices(settings, threadPool, "UZP_B", Version.CURRENT, supplier, EnumSet.allOf(Role.class));
    closeables.push(handleB.transportService);
    final boolean useHosts = randomBoolean();
    final Settings.Builder hostsSettingsBuilder = Settings.builder().put("cluster.name", "test");
    if (useHosts) {
        hostsSettingsBuilder.putArray("discovery.zen.ping.unicast.hosts", NetworkAddress.format(new InetSocketAddress(handleB.address.address().getAddress(), handleB.address.address().getPort())));
    } else {
        hostsSettingsBuilder.put("discovery.zen.ping.unicast.hosts", (String) null);
    }
    final Settings hostsSettings = hostsSettingsBuilder.build();
    final ClusterState state = ClusterState.builder(new ClusterName("test")).version(randomNonNegativeLong()).build();
    // connection to reuse
    handleA.transportService.connectToNode(handleB.node);
    // install a listener to check that no new connections are made
    handleA.transportService.addConnectionListener(new TransportConnectionListener() {

        @Override
        public void onConnectionOpened(DiscoveryNode node) {
            fail("should not open any connections. got [" + node + "]");
        }
    });
    final TestUnicastZenPing zenPingA = new TestUnicastZenPing(hostsSettings, threadPool, handleA, EMPTY_HOSTS_PROVIDER);
    zenPingA.start(new PingContextProvider() {

        @Override
        public DiscoveryNodes nodes() {
            return DiscoveryNodes.builder().add(handleA.node).add(handleB.node).localNodeId("UZP_A").build();
        }

        @Override
        public ClusterState clusterState() {
            return ClusterState.builder(state).blocks(ClusterBlocks.builder().addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)).build();
        }
    });
    closeables.push(zenPingA);
    TestUnicastZenPing zenPingB = new TestUnicastZenPing(hostsSettings, threadPool, handleB, EMPTY_HOSTS_PROVIDER);
    zenPingB.start(new PingContextProvider() {

        @Override
        public DiscoveryNodes nodes() {
            return DiscoveryNodes.builder().add(handleB.node).localNodeId("UZP_B").build();
        }

        @Override
        public ClusterState clusterState() {
            return state;
        }
    });
    closeables.push(zenPingB);
    Collection<ZenPing.PingResponse> pingResponses = zenPingA.pingAndWait().toList();
    assertThat(pingResponses.size(), equalTo(1));
    ZenPing.PingResponse ping = pingResponses.iterator().next();
    assertThat(ping.node().getId(), equalTo("UZP_B"));
    assertThat(ping.getClusterStateVersion(), equalTo(state.version()));
}

Example 3 with TransportConnectionListener

use of org.elasticsearch.transport.TransportConnectionListener in project elasticsearch by elastic.

the class ZenFaultDetectionTests method setUp.

@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    Settings settings = Settings.builder().put(HierarchyCircuitBreakerService.IN_FLIGHT_REQUESTS_CIRCUIT_BREAKER_LIMIT_SETTING.getKey(), new ByteSizeValue(0)).build();
    ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    threadPool = new TestThreadPool(getClass().getName());
    circuitBreakerService = new HierarchyCircuitBreakerService(settings, clusterSettings);
    settingsA = Settings.builder().put("node.name", "TS_A").put(settings).build();
    serviceA = build(settingsA, version0);
    nodeA = serviceA.getLocalDiscoNode();
    settingsB = Settings.builder().put("node.name", "TS_B").put(settings).build();
    serviceB = build(settingsB, version1);
    nodeB = serviceB.getLocalDiscoNode();
    clusterServiceA = createClusterService(settingsA, threadPool, nodeA);
    clusterServiceB = createClusterService(settingsB, threadPool, nodeB);
    // wait till all nodes are properly connected and the event has been sent, so tests in this class
    // will not get this callback called on the connections done in this setup
    final CountDownLatch latch = new CountDownLatch(2);
    TransportConnectionListener waitForConnection = new TransportConnectionListener() {

        @Override
        public void onNodeConnected(DiscoveryNode node) {
            latch.countDown();
        }

        @Override
        public void onNodeDisconnected(DiscoveryNode node) {
            fail("disconnect should not be called " + node);
        }
    };
    serviceA.addConnectionListener(waitForConnection);
    serviceB.addConnectionListener(waitForConnection);
    serviceA.connectToNode(nodeB);
    serviceA.connectToNode(nodeA);
    serviceB.connectToNode(nodeA);
    serviceB.connectToNode(nodeB);
    assertThat("failed to wait for all nodes to connect", latch.await(5, TimeUnit.SECONDS), equalTo(true));
    serviceA.removeConnectionListener(waitForConnection);
    serviceB.removeConnectionListener(waitForConnection);
}

Example 4 with TransportConnectionListener

use of org.elasticsearch.transport.TransportConnectionListener in project elasticsearch by elastic.

the class PublishClusterStateActionTests method createMockNode.

public static MockNode createMockNode(String name, final Settings basSettings, @Nullable ClusterStateListener listener, ThreadPool threadPool, Logger logger, Map<String, MockNode> nodes) throws Exception {
    final Settings settings = Settings.builder().put("name", name).put(TransportService.TRACE_LOG_INCLUDE_SETTING.getKey(), "", TransportService.TRACE_LOG_EXCLUDE_SETTING.getKey(), "NOTHING").put(basSettings).build();
    MockTransportService service = buildTransportService(settings, threadPool);
    DiscoveryNode discoveryNode = service.getLocalDiscoNode();
    MockNode node = new MockNode(discoveryNode, service, listener, logger);
    node.action = buildPublishClusterStateAction(settings, service, () -> node.clusterState, node);
    final CountDownLatch latch = new CountDownLatch(nodes.size() * 2);
    TransportConnectionListener waitForConnection = new TransportConnectionListener() {

        @Override
        public void onNodeConnected(DiscoveryNode node) {
            latch.countDown();
        }

        @Override
        public void onNodeDisconnected(DiscoveryNode node) {
            fail("disconnect should not be called " + node);
        }
    };
    node.service.addConnectionListener(waitForConnection);
    for (MockNode curNode : nodes.values()) {
        curNode.service.addConnectionListener(waitForConnection);
        curNode.connectTo(node.discoveryNode);
        node.connectTo(curNode.discoveryNode);
    }
    assertThat("failed to wait for all nodes to connect", latch.await(5, TimeUnit.SECONDS), equalTo(true));
    for (MockNode curNode : nodes.values()) {
        curNode.service.removeConnectionListener(waitForConnection);
    }
    node.service.removeConnectionListener(waitForConnection);
    if (nodes.put(name, node) != null) {
        fail("Node with the name " + name + " already exist");
    }
    return node;
}