Examples with Node io.atomix.cluster.Node used on opensource projects

Example 1 with Node

use of io.atomix.cluster.Node in project atomix by atomix.

the class RaftPartitionGroup method buildPartitions.

private Collection<PartitionMetadata> buildPartitions(ClusterService clusterService) {
    int partitionSize = this.partitionSize;
    if (partitionSize == 0) {
        partitionSize = clusterService.getNodes().size();
    }
    List<NodeId> sorted = new ArrayList<>(clusterService.getNodes().stream().filter(node -> node.type() == Node.Type.CORE).map(Node::id).collect(Collectors.toSet()));
    Collections.sort(sorted);
    int length = sorted.size();
    int count = Math.min(partitionSize, length);
    Set<PartitionMetadata> metadata = Sets.newHashSet();
    for (int i = 0; i < partitions.size(); i++) {
        PartitionId partitionId = sortedPartitionIds.get(i);
        Set<NodeId> set = new HashSet<>(count);
        for (int j = 0; j < count; j++) {
            set.add(sorted.get((i + j) % length));
        }
        metadata.add(new PartitionMetadata(partitionId, set));
    }
    return metadata;
}

Example 2 with Node

use of io.atomix.cluster.Node in project atomix by atomix.

the class DefaultClusterService method handleMetadataEvent.

/**
 * Handles a cluster metadata change event.
 */
private void handleMetadataEvent(ClusterMetadataEvent event) {
    // Iterate through all bootstrap nodes and add any missing data nodes, triggering NODE_ADDED events.
    // Collect the bootstrap node IDs into a set.
    Set<NodeId> bootstrapNodes = event.subject().bootstrapNodes().stream().map(node -> {
        StatefulNode existingNode = nodes.get(node.id());
        if (existingNode == null) {
            StatefulNode newNode = new StatefulNode(node.id(), node.type(), node.endpoint(), node.zone(), node.rack(), node.host());
            nodes.put(newNode.id(), newNode);
            post(new ClusterEvent(ClusterEvent.Type.NODE_ADDED, newNode));
        }
        return node.id();
    }).collect(Collectors.toSet());
    // Filter the set of data node IDs from the local node information.
    Set<NodeId> dataNodes = nodes.entrySet().stream().filter(entry -> entry.getValue().type() == Node.Type.CORE).map(entry -> entry.getKey()).collect(Collectors.toSet());
    // Compute the set of local data nodes missing in the set of bootstrap nodes.
    Set<NodeId> missingNodes = Sets.difference(dataNodes, bootstrapNodes);
    // For each missing data node, remove the node and trigger a NODE_REMOVED event.
    for (NodeId nodeId : missingNodes) {
        StatefulNode existingNode = nodes.remove(nodeId);
        if (existingNode != null) {
            post(new ClusterEvent(ClusterEvent.Type.NODE_REMOVED, existingNode));
        }
    }
}

Example 3 with Node

use of io.atomix.cluster.Node in project atomix by atomix.

the class DefaultClusterEventingService method broadcast.

@Override
public <M> void broadcast(String topic, M message, Function<M, byte[]> encoder) {
    byte[] payload = SERIALIZER.encode(new InternalMessage(InternalMessage.Type.ALL, encoder.apply(message)));
    getSubscriberNodes(topic).forEach(nodeId -> {
        Node node = clusterService.getNode(nodeId);
        if (node != null && node.getState() == Node.State.ACTIVE) {
            messagingService.sendAsync(node.endpoint(), topic, payload);
        }
    });
}

Example 4 with Node

use of io.atomix.cluster.Node in project atomix by atomix.

the class DefaultClusterServiceTest method testClusterService.

@Test
public void testClusterService() throws Exception {
    TestMessagingServiceFactory messagingServiceFactory = new TestMessagingServiceFactory();
    ClusterMetadata clusterMetadata = buildClusterMetadata(1, 2, 3);
    Node localNode1 = buildNode(1, Node.Type.CORE);
    ManagedClusterService clusterService1 = new DefaultClusterService(localNode1, new TestClusterMetadataService(clusterMetadata), messagingServiceFactory.newMessagingService(localNode1.endpoint()).start().join());
    Node localNode2 = buildNode(2, Node.Type.CORE);
    ManagedClusterService clusterService2 = new DefaultClusterService(localNode2, new TestClusterMetadataService(clusterMetadata), messagingServiceFactory.newMessagingService(localNode2.endpoint()).start().join());
    Node localNode3 = buildNode(3, Node.Type.CORE);
    ManagedClusterService clusterService3 = new DefaultClusterService(localNode3, new TestClusterMetadataService(clusterMetadata), messagingServiceFactory.newMessagingService(localNode3.endpoint()).start().join());
    assertNull(clusterService1.getNode(NodeId.from("1")));
    assertNull(clusterService1.getNode(NodeId.from("2")));
    assertNull(clusterService1.getNode(NodeId.from("3")));
    CompletableFuture<ClusterService>[] futures = new CompletableFuture[3];
    futures[0] = clusterService1.start();
    futures[1] = clusterService2.start();
    futures[2] = clusterService3.start();
    CompletableFuture.allOf(futures).join();
    Thread.sleep(1000);
    assertEquals(3, clusterService1.getNodes().size());
    assertEquals(3, clusterService2.getNodes().size());
    assertEquals(3, clusterService3.getNodes().size());
    assertEquals(Node.Type.CORE, clusterService1.getLocalNode().type());
    assertEquals(Node.Type.CORE, clusterService1.getNode(NodeId.from("1")).type());
    assertEquals(Node.Type.CORE, clusterService1.getNode(NodeId.from("2")).type());
    assertEquals(Node.Type.CORE, clusterService1.getNode(NodeId.from("3")).type());
    assertEquals(State.ACTIVE, clusterService1.getLocalNode().getState());
    assertEquals(State.ACTIVE, clusterService1.getNode(NodeId.from("1")).getState());
    assertEquals(State.ACTIVE, clusterService1.getNode(NodeId.from("2")).getState());
    assertEquals(State.ACTIVE, clusterService1.getNode(NodeId.from("3")).getState());
    Node dataNode = buildNode(4, Node.Type.DATA);
    ManagedClusterService dataClusterService = new DefaultClusterService(dataNode, new TestClusterMetadataService(clusterMetadata), messagingServiceFactory.newMessagingService(dataNode.endpoint()).start().join());
    assertEquals(State.INACTIVE, dataClusterService.getLocalNode().getState());
    assertNull(dataClusterService.getNode(NodeId.from("1")));
    assertNull(dataClusterService.getNode(NodeId.from("2")));
    assertNull(dataClusterService.getNode(NodeId.from("3")));
    assertNull(dataClusterService.getNode(NodeId.from("4")));
    assertNull(dataClusterService.getNode(NodeId.from("5")));
    dataClusterService.start().join();
    Thread.sleep(1000);
    assertEquals(4, clusterService1.getNodes().size());
    assertEquals(4, clusterService2.getNodes().size());
    assertEquals(4, clusterService3.getNodes().size());
    assertEquals(4, dataClusterService.getNodes().size());
    Node clientNode = buildNode(5, Node.Type.CLIENT);
    ManagedClusterService clientClusterService = new DefaultClusterService(clientNode, new TestClusterMetadataService(clusterMetadata), messagingServiceFactory.newMessagingService(clientNode.endpoint()).start().join());
    assertEquals(State.INACTIVE, clientClusterService.getLocalNode().getState());
    assertNull(clientClusterService.getNode(NodeId.from("1")));
    assertNull(clientClusterService.getNode(NodeId.from("2")));
    assertNull(clientClusterService.getNode(NodeId.from("3")));
    assertNull(clientClusterService.getNode(NodeId.from("4")));
    assertNull(clientClusterService.getNode(NodeId.from("5")));
    clientClusterService.start().join();
    Thread.sleep(1000);
    assertEquals(5, clusterService1.getNodes().size());
    assertEquals(5, clusterService2.getNodes().size());
    assertEquals(5, clusterService3.getNodes().size());
    assertEquals(5, dataClusterService.getNodes().size());
    assertEquals(5, clientClusterService.getNodes().size());
    assertEquals(Node.Type.CLIENT, clientClusterService.getLocalNode().type());
    assertEquals(Node.Type.CORE, clientClusterService.getNode(NodeId.from("1")).type());
    assertEquals(Node.Type.CORE, clientClusterService.getNode(NodeId.from("2")).type());
    assertEquals(Node.Type.CORE, clientClusterService.getNode(NodeId.from("3")).type());
    assertEquals(Node.Type.DATA, clientClusterService.getNode(NodeId.from("4")).type());
    assertEquals(Node.Type.CLIENT, clientClusterService.getNode(NodeId.from("5")).type());
    assertEquals(State.ACTIVE, clientClusterService.getLocalNode().getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("1")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("2")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("3")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("4")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("5")).getState());
    Thread.sleep(2500);
    clusterService1.stop().join();
    Thread.sleep(2500);
    assertEquals(5, clusterService2.getNodes().size());
    assertEquals(Node.Type.CORE, clusterService2.getNode(NodeId.from("1")).type());
    assertEquals(State.INACTIVE, clusterService2.getNode(NodeId.from("1")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("2")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("3")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("4")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("5")).getState());
    assertEquals(State.INACTIVE, clientClusterService.getNode(NodeId.from("1")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("2")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("3")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("4")).getState());
    assertEquals(State.ACTIVE, clientClusterService.getNode(NodeId.from("5")).getState());
    dataClusterService.stop().join();
    Thread.sleep(2500);
    assertEquals(4, clusterService2.getNodes().size());
    assertEquals(State.INACTIVE, clusterService2.getNode(NodeId.from("1")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("2")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("3")).getState());
    assertNull(clusterService2.getNode(NodeId.from("4")));
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("5")).getState());
    clientClusterService.stop().join();
    Thread.sleep(2500);
    assertEquals(3, clusterService2.getNodes().size());
    assertEquals(State.INACTIVE, clusterService2.getNode(NodeId.from("1")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("2")).getState());
    assertEquals(State.ACTIVE, clusterService2.getNode(NodeId.from("3")).getState());
    assertNull(clusterService2.getNode(NodeId.from("4")));
    assertNull(clusterService2.getNode(NodeId.from("5")));
}

Example 5 with Node

use of io.atomix.cluster.Node in project atomix by atomix.

the class RaftPerformanceTest method createClient.

/**
 * Creates a Raft client.
 */
private RaftClient createClient() throws Exception {
    Node node = nextNode(Node.Type.CLIENT);
    RaftClientProtocol protocol;
    if (USE_NETTY) {
        MessagingService messagingService = NettyMessagingService.builder().withEndpoint(node.endpoint()).build().start().join();
        protocol = new RaftClientMessagingProtocol(messagingService, protocolSerializer, endpointMap::get);
    } else {
        protocol = protocolFactory.newClientProtocol(node.id());
    }
    RaftClient client = RaftClient.builder().withNodeId(node.id()).withProtocol(protocol).withThreadModel(ThreadModel.THREAD_PER_SERVICE).build();
    client.connect(members.stream().map(Node::id).collect(Collectors.toList())).join();
    clients.add(client);
    return client;
}