From 4c86dae04f4e5115cc4372dbad649bdd3f314990 Mon Sep 17 00:00:00 2001 From: leventov Date: Mon, 3 Nov 2014 20:31:12 +0300 Subject: [PATCH] Made TcpConfig back immutable; Draw the borderline: Builders are mutable, Configs are immutable (hence ChronicleHashInstanceBuilder and StatelessClientBuilder renamed to Configs; improved TcpConfig static factory naming --- README.md | 2 +- .../chronicle/hash/ChronicleHashBuilder.java | 10 +- ....java => ChronicleHashInstanceConfig.java} | 10 +- .../chronicle/hash/ReplicationConfig.java | 27 ---- ...uilder.java => StatelessClientConfig.java} | 4 +- .../hash/replication/ReplicationHub.java | 2 - .../hash/replication/SimpleReplication.java | 1 + .../chronicle/hash/replication/TcpConfig.java | 152 +++++++++--------- .../hash/replication/ThrottlingConfig.java | 3 +- .../chronicle/hash/replication/UdpConfig.java | 4 +- .../map/AbstractChronicleMapBuilder.java | 12 +- ...stanceBuilder.java => InstanceConfig.java} | 28 ++-- .../openhft/chronicle/map/NodeDiscovery.java | 22 +-- .../chronicle/map/StatelessChronicleMap.java | 4 +- ...apBuilder.java => StatelessMapConfig.java} | 10 +- .../chronicle/set/ChronicleSetBuilder.java | 8 +- ...stanceBuilder.java => InstanceConfig.java} | 28 ++-- ...etBuilder.java => StatelessSetConfig.java} | 12 +- .../net/openhft/chronicle/map/Builder.java | 3 +- .../chronicle/map/ChannelReplicationTest.java | 4 +- ...tListenerTestWithTCPSocketReplication.java | 14 +- .../map/PostChannelCreationTest.java | 4 +- .../chronicle/map/SingleMapChannelTest.java | 4 +- .../chronicle/map/StatelessClientTest.java | 22 +-- ...cketReplicationTest3wayPutReturnsNull.java | 3 +- .../map/TwoMapOnDifferentServers.java | 6 +- .../chronicle/map/example/ChannelExample.java | 4 +- .../jrs166/map/StatelessChronicleMapTest.java | 4 +- .../SetForTCPSocketReplicationTest3way.java | 6 +- 29 files changed, 198 insertions(+), 215 deletions(-) rename src/main/java/net/openhft/chronicle/hash/{ChronicleHashInstanceBuilder.java => ChronicleHashInstanceConfig.java} (83%) delete mode 100644 src/main/java/net/openhft/chronicle/hash/ReplicationConfig.java rename src/main/java/net/openhft/chronicle/hash/{StatelessClientBuilder.java => StatelessClientConfig.java} (93%) rename src/main/java/net/openhft/chronicle/map/{InstanceBuilder.java => InstanceConfig.java} (65%) rename src/main/java/net/openhft/chronicle/map/{StatelessMapBuilder.java => StatelessMapConfig.java} (80%) rename src/main/java/net/openhft/chronicle/set/{InstanceBuilder.java => InstanceConfig.java} (53%) rename src/main/java/net/openhft/chronicle/set/{StatelessSetBuilder.java => StatelessSetConfig.java} (66%) diff --git a/README.md b/README.md index 286fc0b6e..72c1946fe 100644 --- a/README.md +++ b/README.md @@ -1023,7 +1023,7 @@ but in your example you should choose the host of the state-full server and the .statelessClient(new InetSocketAddress(, )) ``` -the ".statelessClient(..)" returns an instance of `StatelessClientBuilder`, which has only a few +the ".statelessClient(..)" returns an instance of `StatelessClientConfig`, which has only a few own configurations and `create()` method to create a new stateless client. method tells `ChronicleMap` that its going to build a stateless client. If you don’t add this line a normal state-full `ChronicleMap` will be created. For this example diff --git a/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java b/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java index 59828e6b8..4f86d0980 100644 --- a/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java +++ b/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java @@ -340,7 +340,7 @@ public interface ChronicleHashBuilder statelessClient(InetSocketAddress remoteAddress); + StatelessClientConfig statelessClient(InetSocketAddress remoteAddress); - ChronicleHashInstanceBuilder instance(); + ChronicleHashInstanceConfig instance(); /** * Creates a new hash container, storing it's data in off-heap memory, not mapped to any file. @@ -401,7 +401,7 @@ public interface ChronicleHashBuilder { +public interface ChronicleHashInstanceConfig { - ChronicleHashInstanceBuilder replicated(byte identifier, TcpConfig tcpTransportAndNetwork); + ChronicleHashInstanceConfig replicated(byte identifier, TcpConfig tcpTransportAndNetwork); - ChronicleHashInstanceBuilder replicated(SimpleReplication replication); + ChronicleHashInstanceConfig replicated(SimpleReplication replication); /** * Configures replication of the hash containers, created by this builder, via so called @@ -49,9 +49,9 @@ public interface ChronicleHashInstanceBuilder { * @return this builder object back * @see #replicated(SimpleReplication) */ - ChronicleHashInstanceBuilder replicatedViaChannel(ReplicationChannel channel); + ChronicleHashInstanceConfig replicatedViaChannel(ReplicationChannel channel); - ChronicleHashInstanceBuilder persistedTo(File file); + ChronicleHashInstanceConfig persistedTo(File file); C create() throws IOException; } diff --git a/src/main/java/net/openhft/chronicle/hash/ReplicationConfig.java b/src/main/java/net/openhft/chronicle/hash/ReplicationConfig.java deleted file mode 100644 index edb7e9269..000000000 --- a/src/main/java/net/openhft/chronicle/hash/ReplicationConfig.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2014 Higher Frequency Trading - * - * http://www.higherfrequencytrading.com - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package net.openhft.chronicle.hash; - -/** - * @author Rob Austin. - */ -public interface ReplicationConfig { - - -} diff --git a/src/main/java/net/openhft/chronicle/hash/StatelessClientBuilder.java b/src/main/java/net/openhft/chronicle/hash/StatelessClientConfig.java similarity index 93% rename from src/main/java/net/openhft/chronicle/hash/StatelessClientBuilder.java rename to src/main/java/net/openhft/chronicle/hash/StatelessClientConfig.java index 0906fb72c..01836241e 100644 --- a/src/main/java/net/openhft/chronicle/hash/StatelessClientBuilder.java +++ b/src/main/java/net/openhft/chronicle/hash/StatelessClientConfig.java @@ -38,8 +38,8 @@ import java.util.concurrent.TimeUnit; * @param the type of {@code ChronicleHash} accessed remotely, {@code ChronicleMap} or * {@code ChronicleSet} */ -public interface StatelessClientBuilder { - StatelessClientBuilder timeout(long timeout, TimeUnit units); +public interface StatelessClientConfig { + StatelessClientConfig timeout(long timeout, TimeUnit units); C create() throws IOException; } diff --git a/src/main/java/net/openhft/chronicle/hash/replication/ReplicationHub.java b/src/main/java/net/openhft/chronicle/hash/replication/ReplicationHub.java index 5e24837fe..6c833c8f1 100644 --- a/src/main/java/net/openhft/chronicle/hash/replication/ReplicationHub.java +++ b/src/main/java/net/openhft/chronicle/hash/replication/ReplicationHub.java @@ -16,8 +16,6 @@ package net.openhft.chronicle.hash.replication; -import net.openhft.chronicle.hash.ReplicationConfig; - import java.io.IOException; public final class ReplicationHub extends AbstractReplication { diff --git a/src/main/java/net/openhft/chronicle/hash/replication/SimpleReplication.java b/src/main/java/net/openhft/chronicle/hash/replication/SimpleReplication.java index 4e1031bee..0f716083f 100644 --- a/src/main/java/net/openhft/chronicle/hash/replication/SimpleReplication.java +++ b/src/main/java/net/openhft/chronicle/hash/replication/SimpleReplication.java @@ -16,6 +16,7 @@ package net.openhft.chronicle.hash.replication; +//TODO better name public final class SimpleReplication extends AbstractReplication { public static Builder builder() { diff --git a/src/main/java/net/openhft/chronicle/hash/replication/TcpConfig.java b/src/main/java/net/openhft/chronicle/hash/replication/TcpConfig.java index 824cd606c..66332f21e 100644 --- a/src/main/java/net/openhft/chronicle/hash/replication/TcpConfig.java +++ b/src/main/java/net/openhft/chronicle/hash/replication/TcpConfig.java @@ -18,48 +18,84 @@ package net.openhft.chronicle.hash.replication; -import net.openhft.chronicle.hash.ReplicationConfig; - -import org.jetbrains.annotations.NotNull; - import java.net.InetSocketAddress; -import java.util.Arrays; -import java.util.Collection; -import java.util.HashSet; -import java.util.Set; +import java.util.*; import java.util.concurrent.TimeUnit; import static java.util.Collections.unmodifiableSet; import static java.util.concurrent.TimeUnit.SECONDS; -public class TcpConfig implements ReplicationConfig { +public final class TcpConfig { private static final int DEFAULT_PACKET_SIZE = 1024 * 8; private static final long DEFAULT_HEART_BEAT_INTERVAL = 20; private static final TimeUnit DEFAULT_HEART_BEAT_INTERVAL_UNIT = SECONDS; - private int serverPort = DEFAULT_PACKET_SIZE; - private Set endpoints; - private int packetSize = DEFAULT_PACKET_SIZE; - private boolean autoReconnectedUponDroppedConnection = true; - private ThrottlingConfig throttlingConfig = ThrottlingConfig.noThrottling(); - private long heartBeatInterval = DEFAULT_HEART_BEAT_INTERVAL; - private TimeUnit heartBeatIntervalUnit = DEFAULT_HEART_BEAT_INTERVAL_UNIT; - private IdentifierListener identifierListener; + private final int serverPort; + private final Set endpoints; + private final int packetSize; + private final boolean autoReconnectedUponDroppedConnection; + private final ThrottlingConfig throttlingConfig; + private final long heartBeatInterval; + private final TimeUnit heartBeatIntervalUnit; + private final IdentifierListener identifierListener; - TcpConfig() { + private TcpConfig(int serverPort, Set endpoints, int packetSize, + boolean autoReconnectedUponDroppedConnection, + ThrottlingConfig throttlingConfig, long heartBeatInterval, + TimeUnit heartBeatIntervalUnit, IdentifierListener identifierListener) { + this.serverPort = serverPort; + this.endpoints = endpoints; + this.packetSize = packetSize; + this.autoReconnectedUponDroppedConnection = autoReconnectedUponDroppedConnection; + this.throttlingConfig = throttlingConfig; + this.heartBeatInterval = heartBeatInterval; + this.heartBeatIntervalUnit = heartBeatIntervalUnit; + this.identifierListener = identifierListener; + } + + public static TcpConfig forSendingNode(int serverPort, InetSocketAddress... endpoints) { + return forSendingNode(serverPort, Arrays.asList(endpoints)); + } + + public static TcpConfig forSendingNode(int serverPort, + Collection endpoints) { + if (endpoints.isEmpty()) + throw new IllegalArgumentException("There should be some endpoints"); + return unknownTopology(serverPort, endpoints); + } + + public static TcpConfig forReceivingOnlyNode(int serverPort) { + return unknownTopology(serverPort, Collections.emptyList()); + } + + public static TcpConfig unknownTopology(int serverPort, + Collection endpoints) { + for (final InetSocketAddress endpoint : endpoints) { + if (endpoint.getPort() == serverPort && "localhost".equals(endpoint.getHostName())) + throw new IllegalArgumentException("endpoint=" + endpoint + + " can not point to the same port as the server"); + } + return new TcpConfig( + serverPort, unmodifiableSet(new HashSet(endpoints)), + DEFAULT_PACKET_SIZE, + true, // autoReconnectedUponDroppedConnection + ThrottlingConfig.noThrottling(), + DEFAULT_HEART_BEAT_INTERVAL, + DEFAULT_HEART_BEAT_INTERVAL_UNIT, + null); // identifierListener } public IdentifierListener nonUniqueIdentifierListener() { return identifierListener; } - public TcpConfig nonUniqueIdentifierListener(@NotNull final IdentifierListener - identifierListener) { - this.identifierListener = identifierListener; - return this; + public TcpConfig nonUniqueIdentifierListener(final IdentifierListener identifierListener) { + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } public boolean autoReconnectedUponDroppedConnection() { @@ -67,17 +103,20 @@ public class TcpConfig implements ReplicationConfig { } public TcpConfig autoReconnectedUponDroppedConnection(boolean autoReconnectedUponDroppedConnection) { - this.autoReconnectedUponDroppedConnection = autoReconnectedUponDroppedConnection; - return this; + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } - public ThrottlingConfig throttlingConfig() { + public ThrottlingConfig throttlingConfig() { return throttlingConfig; } public TcpConfig throttlingConfig(ThrottlingConfig throttlingConfig) { - this.throttlingConfig = throttlingConfig; - return this; + ThrottlingConfig.checkMillisecondBucketInterval(throttlingConfig, "TCP"); + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } public long heartBeatInterval(TimeUnit unit) { @@ -89,8 +128,9 @@ public class TcpConfig implements ReplicationConfig { } public TcpConfig serverPort(int serverPort) { - this.serverPort = serverPort; - return this; + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } public Set endpoints() { @@ -98,58 +138,32 @@ public class TcpConfig implements ReplicationConfig { } public TcpConfig endpoints(Set endpoints) { - for (final InetSocketAddress endpoint : endpoints) { if (endpoint.getPort() == serverPort && "localhost".equals(endpoint.getHostName())) throw new IllegalArgumentException("endpoint=" + endpoint + " can not point to the same port as the server"); } - - this.endpoints = endpoints; - return this; + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } public int packetSize() { return packetSize; } - public static TcpConfig of(int serverPort, InetSocketAddress... endpoints) { - return of(serverPort, Arrays.asList(endpoints)); - } - - public static TcpConfig of(int serverPort, Collection endpoints) { - // at least in tests, we configure "receive-only" replication without endpoints. - // TODO decide what to do with this case -// if (endpoints.isEmpty()) -// throw new IllegalArgumentException("There should be some endpoints"); - for (final InetSocketAddress endpoint : endpoints) { - if (endpoint.getPort() == serverPort && "localhost".equals(endpoint.getHostName())) - throw new IllegalArgumentException("endpoint=" + endpoint - + " can not point to the same port as the server"); - } - - TcpConfig tcpConfig = new TcpConfig(); - - tcpConfig.serverPort(serverPort); - tcpConfig.endpoints = unmodifiableSet(new HashSet(endpoints)); - - return tcpConfig; - - - } - - public TcpConfig packetSize(int packetSize) { if (packetSize <= 0) throw new IllegalArgumentException(); - this.packetSize = packetSize; - return this; + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } - public TcpConfig throttlingConfig(long heartBeatInterval, TimeUnit heartBeatIntervalUnit) { - this.heartBeatInterval = heartBeatInterval; - this.heartBeatIntervalUnit = heartBeatIntervalUnit; - return this; + public TcpConfig heartBeatInterval(long heartBeatInterval, TimeUnit heartBeatIntervalUnit) { + return new TcpConfig(serverPort, endpoints, packetSize, + autoReconnectedUponDroppedConnection, throttlingConfig, heartBeatInterval, + heartBeatIntervalUnit, identifierListener); } @@ -196,12 +210,4 @@ public class TcpConfig implements ReplicationConfig { ", heartBeatIntervalUnit=" + heartBeatIntervalUnit + '}'; } - - public TcpConfig heartBeatInterval(long time, TimeUnit unit) { - this.heartBeatInterval = time; - this.heartBeatIntervalUnit = unit; - return this; - } - - } diff --git a/src/main/java/net/openhft/chronicle/hash/replication/ThrottlingConfig.java b/src/main/java/net/openhft/chronicle/hash/replication/ThrottlingConfig.java index 99aaf5903..c9c410d45 100644 --- a/src/main/java/net/openhft/chronicle/hash/replication/ThrottlingConfig.java +++ b/src/main/java/net/openhft/chronicle/hash/replication/ThrottlingConfig.java @@ -23,7 +23,6 @@ import java.util.concurrent.TimeUnit; import static java.util.concurrent.TimeUnit.MILLISECONDS; - public class ThrottlingConfig { private static final long DEFAULT_BUCKET_INTERVAL = 100L; @@ -79,7 +78,7 @@ public class ThrottlingConfig { return create(maxBits, perUnit, DEFAULT_BUCKET_INTERVAL, DEFAULT_BUCKET_INTERVAL_UNIT); } - public static void checkMillisecondBucketInterval(ThrottlingConfig config, String replicator) { + static void checkMillisecondBucketInterval(ThrottlingConfig config, String replicator) { if (config.bucketInterval(MILLISECONDS) < 1) { throw new IllegalArgumentException( "Minimum throttle bucketing interval of 1 millisecond is supported by " + diff --git a/src/main/java/net/openhft/chronicle/hash/replication/UdpConfig.java b/src/main/java/net/openhft/chronicle/hash/replication/UdpConfig.java index a46237c49..e8a44433c 100644 --- a/src/main/java/net/openhft/chronicle/hash/replication/UdpConfig.java +++ b/src/main/java/net/openhft/chronicle/hash/replication/UdpConfig.java @@ -18,7 +18,6 @@ package net.openhft.chronicle.hash.replication; -import net.openhft.chronicle.hash.ReplicationConfig; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -26,7 +25,7 @@ import java.net.InetAddress; import java.net.NetworkInterface; -public final class UdpConfig implements ReplicationConfig { +public final class UdpConfig { private final InetAddress address; private final int port; private final NetworkInterface networkInterface; @@ -50,6 +49,7 @@ public final class UdpConfig implements ReplicationConfig { this.throttlingConfig = throttlingConfig; } + // TODO better name public static UdpConfig simple(@NotNull InetAddress address, int port) { if (address.isMulticastAddress()) throw new IllegalArgumentException(); diff --git a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java index 9087dbf9e..1fd906ff7 100644 --- a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java +++ b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java @@ -619,9 +619,9 @@ public abstract class AbstractChronicleMapBuilder> statelessClient( + public StatelessClientConfig> statelessClient( InetSocketAddress remoteAddress) { - return new StatelessMapBuilder<>(this.clone(), remoteAddress); + return new StatelessMapConfig<>(this.clone(), remoteAddress); } /** @@ -736,8 +736,8 @@ public abstract class AbstractChronicleMapBuilder> instance() { - return new InstanceBuilder<>(this.clone(), simpleReplication, null, null); + public ChronicleHashInstanceConfig> instance() { + return new InstanceConfig<>(this.clone(), simpleReplication, null, null); } @Override @@ -750,7 +750,7 @@ public abstract class AbstractChronicleMapBuilder create(InstanceBuilder ib) throws IOException { + ChronicleMap create(InstanceConfig ib) throws IOException { if (ib.file != null) { return createWithFile(ib.file, ib.simpleReplication, ib.channel); } else { @@ -830,7 +830,7 @@ public abstract class AbstractChronicleMapBuilder createStatelessMap(StatelessMapBuilder statelessBuilder) + ChronicleMap createStatelessMap(StatelessMapConfig statelessBuilder) throws IOException { preMapConstruction(false); return new StatelessChronicleMap( diff --git a/src/main/java/net/openhft/chronicle/map/InstanceBuilder.java b/src/main/java/net/openhft/chronicle/map/InstanceConfig.java similarity index 65% rename from src/main/java/net/openhft/chronicle/map/InstanceBuilder.java rename to src/main/java/net/openhft/chronicle/map/InstanceConfig.java index 02c2c1b23..014bf491e 100644 --- a/src/main/java/net/openhft/chronicle/map/InstanceBuilder.java +++ b/src/main/java/net/openhft/chronicle/map/InstanceConfig.java @@ -16,7 +16,7 @@ package net.openhft.chronicle.map; -import net.openhft.chronicle.hash.ChronicleHashInstanceBuilder; +import net.openhft.chronicle.hash.ChronicleHashInstanceConfig; import net.openhft.chronicle.hash.replication.ReplicationChannel; import net.openhft.chronicle.hash.replication.SimpleReplication; import net.openhft.chronicle.hash.replication.TcpConfig; @@ -24,18 +24,18 @@ import net.openhft.chronicle.hash.replication.TcpConfig; import java.io.File; import java.io.IOException; -final class InstanceBuilder - implements ChronicleHashInstanceBuilder> { +final class InstanceConfig + implements ChronicleHashInstanceConfig> { final AbstractChronicleMapBuilder mapBuilder; final SimpleReplication simpleReplication; final ReplicationChannel channel; final File file; - InstanceBuilder(AbstractChronicleMapBuilder mapBuilder, - SimpleReplication simpleReplication, - ReplicationChannel channel, - File file) { + InstanceConfig(AbstractChronicleMapBuilder mapBuilder, + SimpleReplication simpleReplication, + ReplicationChannel channel, + File file) { this.mapBuilder = mapBuilder; this.simpleReplication = simpleReplication; this.channel = channel; @@ -43,27 +43,27 @@ final class InstanceBuilder } @Override - public ChronicleHashInstanceBuilder> replicated( + public ChronicleHashInstanceConfig> replicated( byte identifier, TcpConfig tcpTransportAndNetwork) { return replicated(SimpleReplication.builder() .tcpTransportAndNetwork(tcpTransportAndNetwork).create(identifier)); } @Override - public ChronicleHashInstanceBuilder> replicated( + public ChronicleHashInstanceConfig> replicated( SimpleReplication replication) { - return new InstanceBuilder<>(mapBuilder, replication, null, file); + return new InstanceConfig<>(mapBuilder, replication, null, file); } @Override - public ChronicleHashInstanceBuilder> replicatedViaChannel( + public ChronicleHashInstanceConfig> replicatedViaChannel( ReplicationChannel channel) { - return new InstanceBuilder<>(mapBuilder, null, channel, file); + return new InstanceConfig<>(mapBuilder, null, channel, file); } @Override - public ChronicleHashInstanceBuilder> persistedTo(File file) { - return new InstanceBuilder<>(mapBuilder, simpleReplication, channel, file); + public ChronicleHashInstanceConfig> persistedTo(File file) { + return new InstanceConfig<>(mapBuilder, simpleReplication, channel, file); } @Override diff --git a/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java b/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java index 2a73a8c5c..97eca2983 100644 --- a/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java +++ b/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java @@ -222,8 +222,10 @@ public class NodeDiscovery { knownNodes.add(ourAddressAndPort, identifier); final TcpConfig tcpConfig = TcpConfig - .of(ourAddressAndPort.getPort(), toInetSocketArray(knownHostPorts)) - .heartBeatInterval(1, SECONDS).nonUniqueIdentifierListener(identifierListener); + .unknownTopology(ourAddressAndPort.getPort(), + toInetSocketCollection(knownHostPorts)) + .heartBeatInterval(1, SECONDS) + .nonUniqueIdentifierListener(identifierListener); LOG.info("Using Remote identifier=" + identifier); @@ -236,24 +238,22 @@ public class NodeDiscovery { } - private InetSocketAddress[] toInetSocketArray(Set source) throws - UnknownHostException { + private static Collection toInetSocketCollection(Set source) + throws UnknownHostException { // make a safe copy final HashSet addressAndPorts = new HashSet(source); if (addressAndPorts.isEmpty()) - return new InetSocketAddress[0]; + return Collections.emptyList(); - final InetSocketAddress[] addresses = new InetSocketAddress[addressAndPorts.size()]; - - int i = 0; + ArrayList addresses = + new ArrayList(addressAndPorts.size()); for (final AddressAndPort addressAndPort : addressAndPorts) { - addresses[i++] = new InetSocketAddress(InetAddress.getByAddress(addressAndPort.address()) - .getHostAddress(), addressAndPort.port()); + addresses.add(new InetSocketAddress(InetAddress.getByAddress(addressAndPort.address()) + .getHostAddress(), addressAndPort.port())); } - return addresses; } diff --git a/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java b/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java index 9866be621..77784449a 100644 --- a/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java +++ b/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java @@ -60,7 +60,7 @@ class StatelessChronicleMap implements ChronicleMap, Closeable { private volatile SocketChannel clientChannel; private CloseablesManager closeables; - private final StatelessMapBuilder builder; + private final StatelessMapConfig builder; private int maxEntrySize; private final Class kClass; private final Class vClass; @@ -96,7 +96,7 @@ class StatelessChronicleMap implements ChronicleMap, Closeable { private long transactionID; - StatelessChronicleMap(final StatelessMapBuilder builder, + StatelessChronicleMap(final StatelessMapConfig builder, final AbstractChronicleMapBuilder chronicleMapBuilder) throws IOException { this.builder = builder; this.keyValueSerializer = new KeyValueSerializer(chronicleMapBuilder.keyBuilder, diff --git a/src/main/java/net/openhft/chronicle/map/StatelessMapBuilder.java b/src/main/java/net/openhft/chronicle/map/StatelessMapConfig.java similarity index 80% rename from src/main/java/net/openhft/chronicle/map/StatelessMapBuilder.java rename to src/main/java/net/openhft/chronicle/map/StatelessMapConfig.java index 7d3b28ce8..2a06b045f 100644 --- a/src/main/java/net/openhft/chronicle/map/StatelessMapBuilder.java +++ b/src/main/java/net/openhft/chronicle/map/StatelessMapConfig.java @@ -18,7 +18,7 @@ package net.openhft.chronicle.map; -import net.openhft.chronicle.hash.StatelessClientBuilder; +import net.openhft.chronicle.hash.StatelessClientConfig; import java.io.IOException; import java.net.InetSocketAddress; @@ -27,14 +27,14 @@ import java.util.concurrent.TimeUnit; /** * @author Rob Austin. */ -class StatelessMapBuilder implements StatelessClientBuilder> { +class StatelessMapConfig implements StatelessClientConfig> { private final AbstractChronicleMapBuilder mapBuilder; private final InetSocketAddress remoteAddress; private long timeoutMs = TimeUnit.SECONDS.toMillis(10); - StatelessMapBuilder(AbstractChronicleMapBuilder mapBuilder, - InetSocketAddress remoteAddress) { + StatelessMapConfig(AbstractChronicleMapBuilder mapBuilder, + InetSocketAddress remoteAddress) { this.mapBuilder = mapBuilder; this.remoteAddress = remoteAddress; } @@ -48,7 +48,7 @@ class StatelessMapBuilder implements StatelessClientBuilder timeout(long timeout, TimeUnit units) { + public StatelessMapConfig timeout(long timeout, TimeUnit units) { this.timeoutMs = units.toMillis(timeout); return this; } diff --git a/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java b/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java index 4d85e83bf..d317a8f98 100644 --- a/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java +++ b/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java @@ -261,14 +261,14 @@ public class ChronicleSetBuilder } @Override - public StatelessClientBuilder> statelessClient( + public StatelessClientConfig> statelessClient( InetSocketAddress remoteAddress) { - return new StatelessSetBuilder<>(chronicleMapBuilder.statelessClient(remoteAddress)); + return new StatelessSetConfig<>(chronicleMapBuilder.statelessClient(remoteAddress)); } @Override - public ChronicleHashInstanceBuilder> instance() { - return new InstanceBuilder<>(chronicleMapBuilder.instance()); + public ChronicleHashInstanceConfig> instance() { + return new InstanceConfig<>(chronicleMapBuilder.instance()); } @Override diff --git a/src/main/java/net/openhft/chronicle/set/InstanceBuilder.java b/src/main/java/net/openhft/chronicle/set/InstanceConfig.java similarity index 53% rename from src/main/java/net/openhft/chronicle/set/InstanceBuilder.java rename to src/main/java/net/openhft/chronicle/set/InstanceConfig.java index d12f582a2..5b03265f7 100644 --- a/src/main/java/net/openhft/chronicle/set/InstanceBuilder.java +++ b/src/main/java/net/openhft/chronicle/set/InstanceConfig.java @@ -16,7 +16,7 @@ package net.openhft.chronicle.set; -import net.openhft.chronicle.hash.ChronicleHashInstanceBuilder; +import net.openhft.chronicle.hash.ChronicleHashInstanceConfig; import net.openhft.chronicle.hash.replication.ReplicationChannel; import net.openhft.chronicle.hash.replication.SimpleReplication; import net.openhft.chronicle.hash.replication.TcpConfig; @@ -25,38 +25,38 @@ import net.openhft.chronicle.map.ChronicleMap; import java.io.File; import java.io.IOException; -final class InstanceBuilder implements ChronicleHashInstanceBuilder> { +final class InstanceConfig implements ChronicleHashInstanceConfig> { - private final ChronicleHashInstanceBuilder> mapBuilder; + private final ChronicleHashInstanceConfig> mapConfig; - InstanceBuilder(ChronicleHashInstanceBuilder> mapBuilder) { - this.mapBuilder = mapBuilder; + InstanceConfig(ChronicleHashInstanceConfig> mapConfig) { + this.mapConfig = mapConfig; } @Override - public ChronicleHashInstanceBuilder> replicated( + public ChronicleHashInstanceConfig> replicated( byte identifier, TcpConfig tcpTransportAndNetwork) { - return new InstanceBuilder<>(mapBuilder.replicated(identifier, tcpTransportAndNetwork)); + return new InstanceConfig<>(mapConfig.replicated(identifier, tcpTransportAndNetwork)); } @Override - public ChronicleHashInstanceBuilder> replicated(SimpleReplication replication) { - return new InstanceBuilder<>(mapBuilder.replicated(replication)); + public ChronicleHashInstanceConfig> replicated(SimpleReplication replication) { + return new InstanceConfig<>(mapConfig.replicated(replication)); } @Override - public ChronicleHashInstanceBuilder> replicatedViaChannel( + public ChronicleHashInstanceConfig> replicatedViaChannel( ReplicationChannel channel) { - return new InstanceBuilder<>(mapBuilder.replicatedViaChannel(channel)); + return new InstanceConfig<>(mapConfig.replicatedViaChannel(channel)); } @Override - public ChronicleHashInstanceBuilder> persistedTo(File file) { - return new InstanceBuilder<>(mapBuilder.persistedTo(file)); + public ChronicleHashInstanceConfig> persistedTo(File file) { + return new InstanceConfig<>(mapConfig.persistedTo(file)); } @Override public ChronicleSet create() throws IOException { - return new SetFromMap<>(mapBuilder.create()); + return new SetFromMap<>(mapConfig.create()); } } diff --git a/src/main/java/net/openhft/chronicle/set/StatelessSetBuilder.java b/src/main/java/net/openhft/chronicle/set/StatelessSetConfig.java similarity index 66% rename from src/main/java/net/openhft/chronicle/set/StatelessSetBuilder.java rename to src/main/java/net/openhft/chronicle/set/StatelessSetConfig.java index d67829fda..983d68604 100644 --- a/src/main/java/net/openhft/chronicle/set/StatelessSetBuilder.java +++ b/src/main/java/net/openhft/chronicle/set/StatelessSetConfig.java @@ -16,23 +16,23 @@ package net.openhft.chronicle.set; -import net.openhft.chronicle.hash.StatelessClientBuilder; +import net.openhft.chronicle.hash.StatelessClientConfig; import net.openhft.chronicle.map.ChronicleMap; import java.io.IOException; import java.util.concurrent.TimeUnit; -final class StatelessSetBuilder implements StatelessClientBuilder> { +final class StatelessSetConfig implements StatelessClientConfig> { - private final StatelessClientBuilder> mapClientBuilder; + private final StatelessClientConfig> mapClientBuilder; - StatelessSetBuilder(StatelessClientBuilder> mapClientBuilder) { + StatelessSetConfig(StatelessClientConfig> mapClientBuilder) { this.mapClientBuilder = mapClientBuilder; } @Override - public StatelessClientBuilder> timeout(long timeout, TimeUnit units) { - return new StatelessSetBuilder<>(mapClientBuilder.timeout(timeout, units)); + public StatelessClientConfig> timeout(long timeout, TimeUnit units) { + return new StatelessSetConfig<>(mapClientBuilder.timeout(timeout, units)); } @Override diff --git a/src/test/java/net/openhft/chronicle/map/Builder.java b/src/test/java/net/openhft/chronicle/map/Builder.java index a7e700f76..41db8cced 100644 --- a/src/test/java/net/openhft/chronicle/map/Builder.java +++ b/src/test/java/net/openhft/chronicle/map/Builder.java @@ -25,6 +25,7 @@ import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import java.net.InetSocketAddress; +import java.util.Arrays; import java.util.concurrent.TimeUnit; /** @@ -71,7 +72,7 @@ public class Builder { final byte identifier, final int serverPort, final InetSocketAddress... endpoints) throws IOException { - TcpConfig tcpConfig = TcpConfig.of(serverPort, endpoints) + TcpConfig tcpConfig = TcpConfig.unknownTopology(serverPort, Arrays.asList(endpoints)) .heartBeatInterval(1L, TimeUnit.SECONDS); return ChronicleMapBuilder.of(kClass, vClass) .replication(identifier, tcpConfig); diff --git a/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java b/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java index 2214fab56..452f53657 100644 --- a/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java +++ b/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java @@ -54,7 +54,7 @@ public class ChannelReplicationTest { public void setup() throws IOException { { TcpConfig tcpConfig = TcpConfig - .of(8086, new InetSocketAddress("localhost", 8087)) + .forSendingNode(8086, new InetSocketAddress("localhost", 8087)) .heartBeatInterval(1, SECONDS); hubA = ReplicationHub.builder() @@ -68,7 +68,7 @@ public class ChannelReplicationTest { { TcpConfig tcpConfig = - TcpConfig.of(8087).heartBeatInterval(1, SECONDS); + TcpConfig.forReceivingOnlyNode(8087).heartBeatInterval(1, SECONDS); hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig) .create((byte) 2); diff --git a/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java b/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java index 9b0afb3d8..f7782a1d0 100644 --- a/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java +++ b/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java @@ -30,6 +30,8 @@ import java.net.InetSocketAddress; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; +import static net.openhft.chronicle.hash.replication.TcpConfig.forSendingNode; + /** * Test ReplicatedChronicleMap where the Replicated is over a TCP Socket * @@ -85,7 +87,7 @@ public class EventListenerTestWithTCPSocketReplication { // we connect the maps via a TCP socket connection on port 8077 - TcpConfig tcpConfig = TcpConfig.of(8076, new InetSocketAddress("localhost", 8077)); + TcpConfig tcpConfig = forSendingNode(8076, new InetSocketAddress("localhost", 8077)); ChronicleMapBuilder map1Builder = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000L) @@ -96,7 +98,7 @@ public class EventListenerTestWithTCPSocketReplication { // ---------- SERVER2 2 on the same server as ---------- { - TcpConfig tcpConfig = TcpConfig.of(8077); + TcpConfig tcpConfig = TcpConfig.forReceivingOnlyNode(8077); ChronicleMapBuilder map2Builder = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000L) @@ -158,7 +160,7 @@ public class EventListenerTestWithTCPSocketReplication { // we connect the maps via a TCP socket connection on port 8077 - TcpConfig tcpConfig = TcpConfig.of(8076, new InetSocketAddress("localhost", 8077)); + TcpConfig tcpConfig = forSendingNode(8076, new InetSocketAddress("localhost", 8077)); ChronicleMapBuilder map1Builder = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000L) @@ -170,7 +172,7 @@ public class EventListenerTestWithTCPSocketReplication { // ---------- SERVER2 2 on the same server as ---------- { - TcpConfig tcpConfig = TcpConfig.of(8077); + TcpConfig tcpConfig = TcpConfig.forReceivingOnlyNode(8077); ChronicleMapBuilder map2Builder = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000L) @@ -233,7 +235,7 @@ public class EventListenerTestWithTCPSocketReplication { // we connect the maps via a TCP socket connection on port 8077 - TcpConfig tcpConfig = TcpConfig.of(8076, new InetSocketAddress("localhost", 8077)); + TcpConfig tcpConfig = forSendingNode(8076, new InetSocketAddress("localhost", 8077)); ChronicleMapBuilder map1Builder = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000L) @@ -245,7 +247,7 @@ public class EventListenerTestWithTCPSocketReplication { // ---------- SERVER2 2 on the same server as ---------- { - TcpConfig tcpConfig = TcpConfig.of(8077); + TcpConfig tcpConfig = TcpConfig.forReceivingOnlyNode(8077); ChronicleMapBuilder map2Builder = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000L) diff --git a/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java b/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java index f56d70eb1..f555addca 100644 --- a/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java +++ b/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java @@ -63,7 +63,7 @@ public class PostChannelCreationTest { { final TcpConfig tcpConfig = TcpConfig - .of(8086, new InetSocketAddress("localhost", 8087)) + .forSendingNode(8086, new InetSocketAddress("localhost", 8087)) .heartBeatInterval(1, SECONDS); hubA = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig) @@ -82,7 +82,7 @@ public class PostChannelCreationTest { { final TcpConfig tcpConfig = TcpConfig - .of(8087, new InetSocketAddress("localhost", 8086)) + .forSendingNode(8087, new InetSocketAddress("localhost", 8086)) .heartBeatInterval(1, SECONDS); hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig) diff --git a/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java b/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java index 00ee14308..9d1af470e 100644 --- a/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java +++ b/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java @@ -61,7 +61,7 @@ public class SingleMapChannelTest { { final TcpConfig tcpConfig = TcpConfig - .of(8086, new InetSocketAddress("localhost", 8087)) + .forSendingNode(8086, new InetSocketAddress("localhost", 8087)) .heartBeatInterval(1, SECONDS); int maxEntrySize = 1024; byte identifier= 1; @@ -78,7 +78,7 @@ public class SingleMapChannelTest { { final TcpConfig tcpConfig = TcpConfig - .of(8087, new InetSocketAddress("localhost", 8086)) + .forSendingNode(8087, new InetSocketAddress("localhost", 8086)) .heartBeatInterval(1, SECONDS); hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig).create((byte) 2); diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java index fae9889f9..9806aa7c7 100644 --- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java +++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java @@ -56,7 +56,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); } @@ -99,7 +99,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); } @@ -140,7 +140,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); } @@ -173,7 +173,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); serverMap.put(10, "EXAMPLE-10"); } @@ -212,7 +212,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); serverMap.put(10, "EXAMPLE-10"); } @@ -244,7 +244,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); } @@ -287,7 +287,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)) + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)) .putReturnsNull(true) .create(); } @@ -333,7 +333,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)) + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)) .putReturnsNull(true) .removeReturnsNull(true) .create(); @@ -372,7 +372,7 @@ public class StatelessClientTest { // server { serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)) + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)) .putReturnsNull(true) .removeReturnsNull(true) .create(); @@ -415,9 +415,9 @@ public class StatelessClientTest { // server { serverMap1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8086)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8086)).create(); serverMap2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(8077)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8077)).create(); } diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest3wayPutReturnsNull.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest3wayPutReturnsNull.java index ce022aefd..98636a26b 100644 --- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest3wayPutReturnsNull.java +++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest3wayPutReturnsNull.java @@ -26,6 +26,7 @@ import org.junit.Test; import java.io.Closeable; import java.io.IOException; import java.net.InetSocketAddress; +import java.util.Arrays; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -47,7 +48,7 @@ public class TCPSocketReplicationTest3wayPutReturnsNull { final byte identifier, final int serverPort, final InetSocketAddress... endpoints) throws IOException { - TcpConfig tcpConfig = TcpConfig.of(serverPort, endpoints); + TcpConfig tcpConfig = TcpConfig.unknownTopology(serverPort, Arrays.asList(endpoints)); return (T) ChronicleMapBuilder.of(Integer.class, CharSequence.class) .putReturnsNull(true) diff --git a/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServers.java b/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServers.java index 3c238584d..4fa82b1ad 100644 --- a/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServers.java +++ b/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServers.java @@ -30,7 +30,6 @@ import java.net.InetSocketAddress; import static java.util.concurrent.TimeUnit.SECONDS; import static net.openhft.chronicle.map.Builder.getPersistenceFile; -import static net.openhft.chronicle.hash.replication.TcpConfig.of; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -47,7 +46,7 @@ public class TwoMapOnDifferentServers { public void setup() throws IOException { final TcpConfig tcpConfig = - of(8076, new InetSocketAddress("localhost", 8077)) + TcpConfig.forSendingNode(8076, new InetSocketAddress("localhost", 8077)) .heartBeatInterval(1, SECONDS); @@ -57,7 +56,8 @@ public class TwoMapOnDifferentServers { map2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class) .entries(20000) - .replication((byte) 2, of(8077).heartBeatInterval(1, SECONDS)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(8077) + .heartBeatInterval(1, SECONDS)).create(); } @After diff --git a/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java b/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java index 645b7defd..96d30bb89 100644 --- a/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java +++ b/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java @@ -70,7 +70,7 @@ public class ChannelExample { byte identifier = (byte) 1; TcpConfig tcpConfig = TcpConfig - .of(8086, new InetSocketAddress("localhost", 8087)) + .forSendingNode(8086, new InetSocketAddress("localhost", 8087)) .heartBeatInterval(1, SECONDS); @@ -105,7 +105,7 @@ public class ChannelExample { byte identifier = (byte) 2; TcpConfig tcpConfig = - TcpConfig.of(8087).heartBeatInterval(1, SECONDS); + TcpConfig.forReceivingOnlyNode(8087).heartBeatInterval(1, SECONDS); hubOnServer2 = ReplicationHub.builder() .tcpTransportAndNetwork(tcpConfig) diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java index 8a9191fa5..447bc7494 100644 --- a/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java +++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java @@ -192,7 +192,7 @@ public class StatelessChronicleMapTest extends JSR166TestCase { final ChronicleMap serverMap = ChronicleMapBuilder.of(Integer.class, String.class) - .replication((byte) 1, TcpConfig.of(port)).create(); + .replication((byte) 1, TcpConfig.forReceivingOnlyNode(port)).create(); final ChronicleMap statelessMap = ChronicleMapBuilder.of(Integer .class, String.class) @@ -206,7 +206,7 @@ public class StatelessChronicleMapTest extends JSR166TestCase { IOException { final ChronicleMap serverMap = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class) - .replication((byte) 2, TcpConfig.of(port)).create(); + .replication((byte) 2, TcpConfig.forReceivingOnlyNode(port)).create(); final ChronicleMap statelessMap = ChronicleMapBuilder.of(CharSequence diff --git a/src/test/java/net/openhft/chronicle/set/SetForTCPSocketReplicationTest3way.java b/src/test/java/net/openhft/chronicle/set/SetForTCPSocketReplicationTest3way.java index ce38b7ff4..89325d86e 100644 --- a/src/test/java/net/openhft/chronicle/set/SetForTCPSocketReplicationTest3way.java +++ b/src/test/java/net/openhft/chronicle/set/SetForTCPSocketReplicationTest3way.java @@ -18,6 +18,7 @@ package net.openhft.chronicle.set; +import net.openhft.chronicle.hash.replication.TcpConfig; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -25,10 +26,11 @@ import org.junit.Test; import java.io.Closeable; import java.io.IOException; import java.net.InetSocketAddress; +import java.util.Arrays; +import static java.util.Arrays.asList; import static java.util.concurrent.TimeUnit.SECONDS; import static net.openhft.chronicle.map.Builder.getPersistenceFile; -import static net.openhft.chronicle.hash.replication.TcpConfig.of; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -51,7 +53,7 @@ public class SetForTCPSocketReplicationTest3way { final int serverPort, final InetSocketAddress... endpoints) throws IOException { return (T) ChronicleSetBuilder.of(Integer.class) - .replication(identifier, of(serverPort, endpoints) + .replication(identifier, TcpConfig.unknownTopology(serverPort, asList(endpoints)) .heartBeatInterval(1L, SECONDS)) .createPersistedTo(getPersistenceFile()); }