Examples with Endpoint org.neo4j.causalclustering.load_balancing.Endpoint used on opensource projects

Example 1 with Endpoint

use of org.neo4j.causalclustering.load_balancing.Endpoint in project neo4j by neo4j.

the class ResultFormatV1Test method shouldSerializeToAndFromRecordFormat.

@Test
public void shouldSerializeToAndFromRecordFormat() throws Exception {
    // given
    List<Endpoint> writers = asList(Endpoint.write(new AdvertisedSocketAddress("write", 1)), Endpoint.write(new AdvertisedSocketAddress("write", 2)), Endpoint.write(new AdvertisedSocketAddress("write", 3)));
    List<Endpoint> readers = asList(Endpoint.read(new AdvertisedSocketAddress("read", 4)), Endpoint.read(new AdvertisedSocketAddress("read", 5)), Endpoint.read(new AdvertisedSocketAddress("read", 6)), Endpoint.read(new AdvertisedSocketAddress("read", 7)));
    List<Endpoint> routers = singletonList(Endpoint.route(new AdvertisedSocketAddress("route", 8)));
    long ttlSeconds = 5;
    LoadBalancingResult original = new LoadBalancingResult(routers, writers, readers, ttlSeconds * 1000);
    // when
    Object[] record = ResultFormatV1.build(original);
    // then
    LoadBalancingResult parsed = ResultFormatV1.parse(record);
    assertEquals(original, parsed);
}

Example 2 with Endpoint

use of org.neo4j.causalclustering.load_balancing.Endpoint in project neo4j by neo4j.

the class ServerPoliciesPlugin method writeEndpoints.

private List<Endpoint> writeEndpoints(CoreTopology cores) {
    MemberId leader;
    try {
        leader = leaderLocator.getLeader();
    } catch (NoLeaderFoundException e) {
        return emptyList();
    }
    Optional<Endpoint> endPoint = cores.find(leader).map(extractBoltAddress()).map(Endpoint::write);
    return asList(endPoint);
}

Example 3 with Endpoint

use of org.neo4j.causalclustering.load_balancing.Endpoint in project neo4j by neo4j.

the class ServerPoliciesPlugin method readEndpoints.

private List<Endpoint> readEndpoints(CoreTopology coreTopology, ReadReplicaTopology rrTopology, Policy policy) {
    Set<ServerInfo> possibleReaders = rrTopology.members().entrySet().stream().map(entry -> new ServerInfo(entry.getValue().connectors().boltAddress(), entry.getKey(), entry.getValue().groups())).collect(Collectors.toSet());
    if (allowReadsOnFollowers || possibleReaders.size() == 0) {
        Set<MemberId> validCores = coreTopology.members().keySet();
        try {
            MemberId leader = leaderLocator.getLeader();
            validCores = validCores.stream().filter(memberId -> !memberId.equals(leader)).collect(Collectors.toSet());
        } catch (NoLeaderFoundException ignored) {
        // we might end up using the leader for reading during this ttl, should be fine in general
        }
        for (MemberId validCore : validCores) {
            Optional<CoreServerInfo> coreServerInfo = coreTopology.find(validCore);
            if (coreServerInfo.isPresent()) {
                CoreServerInfo serverInfo = coreServerInfo.get();
                possibleReaders.add(new ServerInfo(serverInfo.connectors().boltAddress(), validCore, serverInfo.groups()));
            }
        }
    }
    Set<ServerInfo> readers = policy.apply(possibleReaders);
    return readers.stream().map(r -> Endpoint.read(r.boltAddress())).collect(Collectors.toList());
}

Example 4 with Endpoint

use of org.neo4j.causalclustering.load_balancing.Endpoint in project neo4j by neo4j.

the class ResultFormatV1 method parse.

private static Map<Role, List<Endpoint>> parse(List<Map<String, Object>> result) {
    Map<Role, List<Endpoint>> endpoints = new HashMap<>();
    for (Map<String, Object> single : result) {
        Role role = Role.valueOf((String) single.get("role"));
        List<Endpoint> addresses = parse((Object[]) single.get("addresses"), role);
        endpoints.put(role, addresses);
    }
    Arrays.stream(Role.values()).forEach(r -> endpoints.putIfAbsent(r, Collections.emptyList()));
    return endpoints;
}

Example 5 with Endpoint

use of org.neo4j.causalclustering.load_balancing.Endpoint in project neo4j by neo4j.

the class ServerShufflingProcessorTest method shouldShuffleServers.

@Test
public void shouldShuffleServers() throws Exception {
    // given
    LoadBalancingProcessor delegate = mock(LoadBalancingPlugin.class);
    List<Endpoint> routers = asList(Endpoint.route(new AdvertisedSocketAddress("route", 1)), Endpoint.route(new AdvertisedSocketAddress("route", 2)));
    List<Endpoint> writers = asList(Endpoint.write(new AdvertisedSocketAddress("write", 3)), Endpoint.write(new AdvertisedSocketAddress("write", 4)), Endpoint.write(new AdvertisedSocketAddress("write", 5)));
    List<Endpoint> readers = asList(Endpoint.read(new AdvertisedSocketAddress("read", 6)), Endpoint.read(new AdvertisedSocketAddress("read", 7)), Endpoint.read(new AdvertisedSocketAddress("read", 8)), Endpoint.read(new AdvertisedSocketAddress("read", 9)));
    long ttl = 1000;
    LoadBalancingProcessor.Result result = new LoadBalancingResult(new ArrayList<>(routers), new ArrayList<>(writers), new ArrayList<>(readers), ttl);
    when(delegate.run(any())).thenReturn(result);
    ServerShufflingProcessor plugin = new ServerShufflingProcessor(delegate);
    boolean completeShuffle = false;
    for (// we try many times to make false negatives extremely unlikely
    int i = 0; // we try many times to make false negatives extremely unlikely
    i < 1000; // we try many times to make false negatives extremely unlikely
    i++) {
        // when
        LoadBalancingProcessor.Result shuffledResult = plugin.run(Collections.emptyMap());
        // then: should still contain the same endpoints
        assertThat(shuffledResult.routeEndpoints(), containsInAnyOrder(routers.toArray()));
        assertThat(shuffledResult.writeEndpoints(), containsInAnyOrder(writers.toArray()));
        assertThat(shuffledResult.readEndpoints(), containsInAnyOrder(readers.toArray()));
        assertEquals(shuffledResult.getTimeToLiveMillis(), ttl);
        // but possibly in a different order
        boolean readersEqual = shuffledResult.readEndpoints().equals(readers);
        boolean writersEqual = shuffledResult.writeEndpoints().equals(writers);
        boolean routersEqual = shuffledResult.routeEndpoints().equals(routers);
        if (!readersEqual && !writersEqual && !routersEqual) {
            // we don't stop until it is completely different
            completeShuffle = true;
            break;
        }
    }
    assertTrue(completeShuffle);
}