Java DefaultPartition类代码示例

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
private static Set<Partition> buildDefaultPartitions(Collection<ControllerNode> nodes) {
    List<ControllerNode> sorted = new ArrayList<>(nodes);
    Collections.sort(sorted, (o1, o2) -> o1.id().toString().compareTo(o2.id().toString()));
    Set<Partition> partitions = Sets.newHashSet();
    // add partitions
    int length = nodes.size();
    int count = Math.min(3, length);
    for (int i = 0; i < length; i++) {
        int index = i;
        Set<NodeId> set = new HashSet<>(count);
        for (int j = 0; j < count; j++) {
            set.add(sorted.get((i + j) % length).id());
        }
        partitions.add(new DefaultPartition(PartitionId.from((index + 1)), set));
    }
    return partitions;
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Activate
public void activate() {
    String localIp = getSiteLocalAddress();
    ControllerNode localNode =
            new DefaultControllerNode(new NodeId(localIp), IpAddress.valueOf(localIp), DEFAULT_ONOS_PORT);
    // partition 1
    Partition partition = new DefaultPartition(PartitionId.from(1), ImmutableSet.of(localNode.id()));
    ClusterMetadata metadata = new ClusterMetadata(PROVIDER_ID,
                                    "default",
                                    ImmutableSet.of(localNode),
                                    ImmutableSet.of(partition));
    long version = System.currentTimeMillis();
    cachedMetadata.set(new Versioned<>(metadata, version));
    providerRegistry.register(this);
    log.info("Started");
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
private Set<Partition> buildDefaultPartitions(Collection<ControllerNode> nodes, int partitionSize) {
    List<ControllerNode> sorted = new ArrayList<>(nodes);
    Collections.sort(sorted, (o1, o2) -> o1.id().toString().compareTo(o2.id().toString()));
    Set<Partition> partitions = Sets.newHashSet();
    // add partitions
    int length = nodes.size();
    int count = Math.min(partitionSize, length);
    for (int i = 0; i < length; i++) {
        int index = i;
        Set<NodeId> set = new HashSet<>(count);
        for (int j = 0; j < count; j++) {
            set.add(sorted.get((i + j) % length).id());
        }
        partitions.add(new DefaultPartition(PartitionId.from((index + 1)), versionService.version(), set));
    }
    return partitions;
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Activate
public void activate() {
    partition = new ActiveStoragePartition(
            new DefaultPartition(
                    PartitionId.SHARED,
                    null,
                    clusterService.getNodes()
                            .stream()
                            .map(ControllerNode::id)
                            .collect(Collectors.toSet())),
            clusterCommunicator,
            clusterService);
    partition.open().join();
    primitiveCreator = partition.client();
    log.info("Started");
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Test
public void testComputeInitialIncompletePartition() throws Exception {
    Partition sourcePartition = new DefaultPartition(
            PartitionId.from(1),
            Version.version("1.0.0"),
            Arrays.asList(
                    NodeId.nodeId("1"),
                    NodeId.nodeId("2"),
                    NodeId.nodeId("3")));
    Version targetVersion = Version.version("1.0.1");
    List<NodeId> members = Arrays.asList(
            NodeId.nodeId("1"),
            NodeId.nodeId("2"));
    Partition forkedPartition = PartitionManager.computeInitialPartition(sourcePartition, targetVersion, members);
    assertTrue(forkedPartition.getMembers().size() == 2);
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("1")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("2")));
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Test
public void testComputeInitialCompletePartition() throws Exception {
    Partition sourcePartition = new DefaultPartition(
            PartitionId.from(1),
            Version.version("1.0.0"),
            Arrays.asList(
                    NodeId.nodeId("3"),
                    NodeId.nodeId("4"),
                    NodeId.nodeId("5")));
    Version targetVersion = Version.version("1.0.1");
    List<NodeId> members = Arrays.asList(
            NodeId.nodeId("1"),
            NodeId.nodeId("2"),
            NodeId.nodeId("3"),
            NodeId.nodeId("4"),
            NodeId.nodeId("5"));
    Partition forkedPartition = PartitionManager.computeInitialPartition(sourcePartition, targetVersion, members);
    assertTrue(forkedPartition.getMembers().size() == 4);
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("1")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("3")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("4")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("5")));
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Test
public void testComputeFinalIncompletePartition() throws Exception {
    Partition sourcePartition = new DefaultPartition(
            PartitionId.from(1),
            Version.version("1.0.0"),
            Arrays.asList(
                    NodeId.nodeId("1"),
                    NodeId.nodeId("2"),
                    NodeId.nodeId("3")));
    Version targetVersion = Version.version("1.0.1");
    List<NodeId> members = Arrays.asList(
            NodeId.nodeId("1"),
            NodeId.nodeId("2"));
    Partition forkedPartition = PartitionManager.computeFinalPartition(sourcePartition, targetVersion, members);
    assertTrue(forkedPartition.getMembers().size() == 2);
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("1")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("2")));
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Test
public void testComputeFinalCompletePartition() throws Exception {
    Partition sourcePartition = new DefaultPartition(
            PartitionId.from(1),
            Version.version("1.0.0"),
            Arrays.asList(
                    NodeId.nodeId("3"),
                    NodeId.nodeId("4"),
                    NodeId.nodeId("5")));
    Version targetVersion = Version.version("1.0.1");
    List<NodeId> members = Arrays.asList(
            NodeId.nodeId("1"),
            NodeId.nodeId("2"),
            NodeId.nodeId("3"),
            NodeId.nodeId("4"),
            NodeId.nodeId("5"));
    Partition forkedPartition = PartitionManager.computeFinalPartition(sourcePartition, targetVersion, members);
    assertTrue(forkedPartition.getMembers().size() == 3);
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("3")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("4")));
    assertTrue(forkedPartition.getMembers().contains(NodeId.nodeId("5")));
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
/**
 * Computes a forked partition from the given source partition.
 *
 * @param sourcePartition the source partition from which to compute the partition
 * @param targetVersion the target partition version
 * @param members the set of members available to the partition
 * @param delta the number of additional members to preserve outside the partition
 * @return the computed forked partition
 */
private static Partition computePartition(
        Partition sourcePartition,
        Version targetVersion,
        List<NodeId> members,
        int delta) {
    // Create a collection of members of the forked/isolated partition. Initial membership
    // will include up to n upgraded nodes until all n nodes in the partition have been upgraded.
    List<NodeId> sortedMembers = members.stream()
            .sorted()
            .collect(Collectors.toList());

    // Create a list of members of the partition that have been upgraded according to the
    // version isolated cluster membership.
    List<NodeId> partitionMembers = sortedMembers.stream()
            .filter(nodeId -> sourcePartition.getMembers().contains(nodeId))
            .collect(Collectors.toList());

    // If additional members need to be added to the partition to make up a full member list,
    // add members in sorted order to create deterministic rebalancing of nodes.
    int totalMembers = sourcePartition.getMembers().size() + delta;
    if (partitionMembers.size() < totalMembers) {
        for (int i = partitionMembers.size(); i < totalMembers; i++) {
            Optional<NodeId> nextMember = sortedMembers.stream()
                    .filter(nodeId -> !partitionMembers.contains(nodeId))
                    .findFirst();
            if (nextMember.isPresent()) {
                partitionMembers.add(nextMember.get());
            } else {
                break;
            }
        }
    }

    return new DefaultPartition(
            sourcePartition.getId(),
            targetVersion,
            partitionMembers);
}
 

import org.onosproject.cluster.DefaultPartition; //导入依赖的package包/类
@Override
public Partition deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    return jp.readValueAs(DefaultPartition.class);
}