Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
ArgAssert { public static <T> T notNull(T obj, String argName) { doCheck(obj != null, argName, " must be not null."); return obj; } private ArgAssert(); static void check(boolean that, String msg); static T notNull(T obj, String argName); static String notEmpty(String str, String argName); static void isFalse(boolean condition, String msg); static void isTrue(boolean condition, String msg); static void positive(long val, String argName); static void powerOfTwo(int val, String argName); }
@Test public void testNotNull() throws Exception { expectExactMessage(IAE, "something must be not null.", () -> ArgAssert.notNull(null, "something") ); ArgAssert.notNull(new Object(), "Success"); }
ArgAssert { public static String notEmpty(String str, String argName) { String trimmed = notNull(str, argName).trim(); doCheck(!trimmed.isEmpty(), argName, " must have non-whitespace characters."); return trimmed; } private ArgAssert(); static void check(boolean that, String msg); static T notNull(T obj, String argName); static String notEmpty(String str, String argName); static void isFalse(boolean condition, String msg); static void isTrue(boolean condition, String msg); static void positive(long val, String argName); static void powerOfTwo(int val, String argName); }
@Test public void testNotEmpty() throws Exception { expectExactMessage(IAE, "something must be not null.", () -> ArgAssert.notEmpty(null, "something") ); expectExactMessage(IAE, "something must have non-whitespace characters.", () -> ArgAssert.notEmpty("", "something") ); expectExactMessage(IAE, "something must have non-whitespace characters.", () -> ArgAssert.notEmpty(" ", "something") ); expectExactMessage(IAE, "something must have non-whitespace characters.", () -> ArgAssert.notEmpty("\n", "something") ); expectExactMessage(IAE, "something must have non-whitespace characters.", () -> ArgAssert.notEmpty(System.lineSeparator(), "something") ); assertEquals("not empty", ArgAssert.notEmpty("not empty", "Success")); assertEquals("not empty", ArgAssert.notEmpty(" not empty\n", "Success")); }
ArgAssert { public static void isFalse(boolean condition, String msg) { isTrue(!condition, msg); } private ArgAssert(); static void check(boolean that, String msg); static T notNull(T obj, String argName); static String notEmpty(String str, String argName); static void isFalse(boolean condition, String msg); static void isTrue(boolean condition, String msg); static void positive(long val, String argName); static void powerOfTwo(int val, String argName); }
@Test public void testIsFalse() throws Exception { expectExactMessage(IAE, "test message", () -> ArgAssert.isFalse(true, "test message") ); ArgAssert.isFalse(false, "Success"); }
ArgAssert { public static void isTrue(boolean condition, String msg) { check(condition, msg); } private ArgAssert(); static void check(boolean that, String msg); static T notNull(T obj, String argName); static String notEmpty(String str, String argName); static void isFalse(boolean condition, String msg); static void isTrue(boolean condition, String msg); static void positive(long val, String argName); static void powerOfTwo(int val, String argName); }
@Test public void testIsTrue() throws Exception { expectExactMessage(IAE, "test message", () -> ArgAssert.isTrue(false, "test message") ); ArgAssert.isTrue(true, "Success"); }
ArgAssert { public static void positive(long val, String argName) { doCheck(val > 0, argName, " must be > 0."); } private ArgAssert(); static void check(boolean that, String msg); static T notNull(T obj, String argName); static String notEmpty(String str, String argName); static void isFalse(boolean condition, String msg); static void isTrue(boolean condition, String msg); static void positive(long val, String argName); static void powerOfTwo(int val, String argName); }
@Test public void testPositive() { expectExactMessage(IAE, "testArg must be > 0.", () -> ArgAssert.positive(-1, "testArg") ); expectExactMessage(IAE, "testArg must be > 0.", () -> ArgAssert.positive(0, "testArg") ); ArgAssert.positive(10, "testArg"); }
ArgAssert { public static void powerOfTwo(int val, String argName) { doCheck(Utils.isPowerOfTwo(val), argName, " must be a power of two."); } private ArgAssert(); static void check(boolean that, String msg); static T notNull(T obj, String argName); static String notEmpty(String str, String argName); static void isFalse(boolean condition, String msg); static void isTrue(boolean condition, String msg); static void positive(long val, String argName); static void powerOfTwo(int val, String argName); }
@Test public void testPowerOfTwo() { expectExactMessage(IAE, "testArg must be a power of two.", () -> ArgAssert.powerOfTwo(13, "testArg") ); expectExactMessage(IAE, "testArg must be a power of two.", () -> ArgAssert.powerOfTwo(0, "testArg") ); expectExactMessage(IAE, "testArg must be a power of two.", () -> ArgAssert.powerOfTwo(-2, "testArg") ); ArgAssert.powerOfTwo(8, "testArg"); }
Utils { public static int mod(int hash, int size) { if (hash < 0) { return -hash % size; } else { return hash % size; } } private Utils(); static String numberFormat(String pattern, Number number); static String byteSizeFormat(long bytes); static int mod(int hash, int size); static boolean isPowerOfTwo(int n); static String toString(Collection<T> collection, Function<? super T, String> mapper); static String nullOrTrim(String str); static String nullOrTrim(String str, String defaultVal); static String camelCase(CharSequence str); static List<T> nullSafeImmutableCopy(List<T> source); static final String NL; static final Charset UTF_8; static final int MAGIC_BYTES; }
@Test public void testMod() { assertEquals(1, Utils.mod(6, 5)); assertEquals(1, Utils.mod(-6, 5)); }
Utils { public static String camelCase(CharSequence str) { StringBuilder buf = new StringBuilder(); boolean capitalize = true; for (int i = 0, len = str.length(); i < len; ++i) { char c = str.charAt(i); switch (c) { case '-': case '.': case '_': { capitalize = true; break; } default: { if (capitalize) { buf.append(Character.toUpperCase(c)); capitalize = false; } else { buf.append(c); } } } } return buf.toString(); } private Utils(); static String numberFormat(String pattern, Number number); static String byteSizeFormat(long bytes); static int mod(int hash, int size); static boolean isPowerOfTwo(int n); static String toString(Collection<T> collection, Function<? super T, String> mapper); static String nullOrTrim(String str); static String nullOrTrim(String str, String defaultVal); static String camelCase(CharSequence str); static List<T> nullSafeImmutableCopy(List<T> source); static final String NL; static final Charset UTF_8; static final int MAGIC_BYTES; }
@Test public void testCamelCase() { assertEquals("TEST", camelCase("TEST")); assertEquals("Test", camelCase("Test")); assertEquals("TeSt", camelCase("Te.st")); assertEquals("TeSt", camelCase("Te..st")); assertEquals("TeSt", camelCase("Te.-st")); assertEquals("TeSt", camelCase("Te-st")); assertEquals("TeSt", camelCase("Te--st")); assertEquals("TeSt", camelCase("Te-_st")); assertEquals("TeSt", camelCase("Te_st")); assertEquals("TeST", camelCase("Te_s_t_")); assertEquals("TeST", camelCase("te_s_t_")); }
Utils { public static <T> List<T> nullSafeImmutableCopy(List<T> source) { if (source == null || source.isEmpty()) { return emptyList(); } else { return unmodifiableList(source.stream().filter(Objects::nonNull).collect(toList())); } } private Utils(); static String numberFormat(String pattern, Number number); static String byteSizeFormat(long bytes); static int mod(int hash, int size); static boolean isPowerOfTwo(int n); static String toString(Collection<T> collection, Function<? super T, String> mapper); static String nullOrTrim(String str); static String nullOrTrim(String str, String defaultVal); static String camelCase(CharSequence str); static List<T> nullSafeImmutableCopy(List<T> source); static final String NL; static final Charset UTF_8; static final int MAGIC_BYTES; }
@Test public void nullSafeImmutableCopy() { assertTrue(Utils.nullSafeImmutableCopy(null).isEmpty()); assertTrue(Utils.nullSafeImmutableCopy(emptyList()).isEmpty()); assertTrue(Utils.nullSafeImmutableCopy(asList(null, null, null)).isEmpty()); assertEquals(3, Utils.nullSafeImmutableCopy(asList(1, 2, 3)).size()); expect(UnsupportedOperationException.class, () -> { Utils.nullSafeImmutableCopy(asList(1, 2, 3)).add(4); }); }
Jvm { public static String pid() { return PID; } private Jvm(); static String pid(); static void exit(int code); static void setExitHandler(ExitHandler handler); static Optional<ExitHandler> exitHandler(); }
@Test public void testPid() { String pid1 = Jvm.pid(); String pid2 = Jvm.pid(); assertNotNull(pid1); assertEquals(pid1, pid2); }
Jvm { public static Optional<ExitHandler> exitHandler() { return Optional.ofNullable(exitHandler); } private Jvm(); static String pid(); static void exit(int code); static void setExitHandler(ExitHandler handler); static Optional<ExitHandler> exitHandler(); }
@Test public void testExitHandler() { assertFalse(Jvm.exitHandler().isPresent()); try { Jvm.ExitHandler handler = mock(Jvm.ExitHandler.class); Jvm.setExitHandler(handler); assertTrue(Jvm.exitHandler().isPresent()); Jvm.exit(100500); verify(handler).exit(100500); verifyNoMoreInteractions(handler); } finally { Jvm.setExitHandler(null); assertNotNull(Jvm.exitHandler()); assertFalse(Jvm.exitHandler().isPresent()); } }
HekateNodeFactory { public static Hekate create(HekateBootstrap bootstrap) { return new HekateNode(bootstrap); } private HekateNodeFactory(); static Hekate create(HekateBootstrap bootstrap); }
@Test public void test() throws Exception { assertValidUtilityClass(HekateNodeFactory.class); assertNotNull(HekateNodeFactory.create(new HekateBootstrap())); }
HekateBootstrap { public Hekate join() throws HekateConfigurationException, InterruptedException, HekateFutureException { return create().join(); } JoinFuture joinAsync(); Hekate join(); Hekate initialize(); String getNodeName(); void setNodeName(String nodeName); HekateBootstrap withNodeName(String nodeName); String getClusterName(); void setClusterName(String clusterName); HekateBootstrap withClusterName(String clusterName); List<String> getRoles(); void setRoles(List<String> roles); HekateBootstrap withRole(String role); Map<String, String> getProperties(); void setProperties(Map<String, String> properties); HekateBootstrap withProperty(String key, String value); List<PropertyProvider> getPropertyProviders(); void setPropertyProviders(List<PropertyProvider> propertyProviders); HekateBootstrap withPropertyProvider(PropertyProvider propertyProvider); List<ServiceFactory<? extends Service>> getServices(); void setServices(List<ServiceFactory<? extends Service>> services); HekateBootstrap withService(ServiceFactory<? extends Service> service); HekateBootstrap withService(Class<T> factoryType, Consumer<T> configurer); T withService(Class<T> factoryType); Optional<T> service(Class<T> factoryType); List<Plugin> getPlugins(); void setPlugins(List<Plugin> plugins); HekateBootstrap withPlugin(Plugin plugin); CodecFactory<Object> getDefaultCodec(); void setDefaultCodec(CodecFactory<Object> defaultCodec); HekateBootstrap withDefaultCodec(CodecFactory<Object> defaultCodec); MeterRegistry getMetrics(); void setMetrics(MeterRegistry metrics); HekateBootstrap withMetrics(MeterRegistry metrics); List<Hekate.LifecycleListener> getLifecycleListeners(); void setLifecycleListeners(List<Hekate.LifecycleListener> lifecycleListeners); HekateBootstrap withLifecycleListener(Hekate.LifecycleListener listener); boolean isConfigReport(); void setConfigReport(boolean configReport); HekateBootstrap withConfigReport(boolean configReport); @Override String toString(); static final String DEFAULT_CLUSTER_NAME; }
@Test public void testJoinWithDefaults() throws Exception { List<Hekate> nodes = new ArrayList<>(); try { repeat(3, i -> { Hekate node = new HekateBootstrap().join(); assertNotNull(node.cluster()); assertNotNull(node.network()); assertNotNull(node.messaging()); assertNotNull(node.locks()); assertNotNull(node.coordination()); assertNotNull(node.election()); assertNotNull(node.codec()); nodes.add(node); }); } finally { for (Hekate node : nodes) { try { node.leave(); } catch (InterruptedException e) { } } } }
HekateBootstrap { public JoinFuture joinAsync() throws HekateConfigurationException { return create().joinAsync(); } JoinFuture joinAsync(); Hekate join(); Hekate initialize(); String getNodeName(); void setNodeName(String nodeName); HekateBootstrap withNodeName(String nodeName); String getClusterName(); void setClusterName(String clusterName); HekateBootstrap withClusterName(String clusterName); List<String> getRoles(); void setRoles(List<String> roles); HekateBootstrap withRole(String role); Map<String, String> getProperties(); void setProperties(Map<String, String> properties); HekateBootstrap withProperty(String key, String value); List<PropertyProvider> getPropertyProviders(); void setPropertyProviders(List<PropertyProvider> propertyProviders); HekateBootstrap withPropertyProvider(PropertyProvider propertyProvider); List<ServiceFactory<? extends Service>> getServices(); void setServices(List<ServiceFactory<? extends Service>> services); HekateBootstrap withService(ServiceFactory<? extends Service> service); HekateBootstrap withService(Class<T> factoryType, Consumer<T> configurer); T withService(Class<T> factoryType); Optional<T> service(Class<T> factoryType); List<Plugin> getPlugins(); void setPlugins(List<Plugin> plugins); HekateBootstrap withPlugin(Plugin plugin); CodecFactory<Object> getDefaultCodec(); void setDefaultCodec(CodecFactory<Object> defaultCodec); HekateBootstrap withDefaultCodec(CodecFactory<Object> defaultCodec); MeterRegistry getMetrics(); void setMetrics(MeterRegistry metrics); HekateBootstrap withMetrics(MeterRegistry metrics); List<Hekate.LifecycleListener> getLifecycleListeners(); void setLifecycleListeners(List<Hekate.LifecycleListener> lifecycleListeners); HekateBootstrap withLifecycleListener(Hekate.LifecycleListener listener); boolean isConfigReport(); void setConfigReport(boolean configReport); HekateBootstrap withConfigReport(boolean configReport); @Override String toString(); static final String DEFAULT_CLUSTER_NAME; }
@Test public void testJoinWithDefaultsAsync() throws Exception { List<LeaveFuture> leave = new ArrayList<>(); try { List<JoinFuture> joins = new ArrayList<>(); repeat(3, i -> { HekateBootstrap boot = new HekateBootstrap(); joins.add(boot.joinAsync()); }); for (JoinFuture future : joins) { leave.add(future.get().leaveAsync()); } } finally { for (LeaveFuture future : leave) { try { get(future); } catch (InterruptedException e) { } } } }
HekateBootstrap { @Override public String toString() { return ToString.format(this); } JoinFuture joinAsync(); Hekate join(); Hekate initialize(); String getNodeName(); void setNodeName(String nodeName); HekateBootstrap withNodeName(String nodeName); String getClusterName(); void setClusterName(String clusterName); HekateBootstrap withClusterName(String clusterName); List<String> getRoles(); void setRoles(List<String> roles); HekateBootstrap withRole(String role); Map<String, String> getProperties(); void setProperties(Map<String, String> properties); HekateBootstrap withProperty(String key, String value); List<PropertyProvider> getPropertyProviders(); void setPropertyProviders(List<PropertyProvider> propertyProviders); HekateBootstrap withPropertyProvider(PropertyProvider propertyProvider); List<ServiceFactory<? extends Service>> getServices(); void setServices(List<ServiceFactory<? extends Service>> services); HekateBootstrap withService(ServiceFactory<? extends Service> service); HekateBootstrap withService(Class<T> factoryType, Consumer<T> configurer); T withService(Class<T> factoryType); Optional<T> service(Class<T> factoryType); List<Plugin> getPlugins(); void setPlugins(List<Plugin> plugins); HekateBootstrap withPlugin(Plugin plugin); CodecFactory<Object> getDefaultCodec(); void setDefaultCodec(CodecFactory<Object> defaultCodec); HekateBootstrap withDefaultCodec(CodecFactory<Object> defaultCodec); MeterRegistry getMetrics(); void setMetrics(MeterRegistry metrics); HekateBootstrap withMetrics(MeterRegistry metrics); List<Hekate.LifecycleListener> getLifecycleListeners(); void setLifecycleListeners(List<Hekate.LifecycleListener> lifecycleListeners); HekateBootstrap withLifecycleListener(Hekate.LifecycleListener listener); boolean isConfigReport(); void setConfigReport(boolean configReport); HekateBootstrap withConfigReport(boolean configReport); @Override String toString(); static final String DEFAULT_CLUSTER_NAME; }
@Test public void testToString() { assertTrue(bootstrap.toString(), bootstrap.toString().startsWith(HekateBootstrap.class.getSimpleName())); }
LeaveFuture extends HekateFuture<Hekate, LeaveFuture> { public static LeaveFuture completed(Hekate node) { LeaveFuture future = new LeaveFuture(); future.complete(node); return future; } static LeaveFuture completed(Hekate node); @Override Hekate get(); @Override Hekate get(long timeout, TimeUnit unit); }
@Test public void testCompleted() { assertTrue(LeaveFuture.completed(mock(Hekate.class)).isSuccess()); }
TerminateFuture extends HekateFuture<Hekate, TerminateFuture> { public static TerminateFuture completed(Hekate node) { TerminateFuture future = new TerminateFuture(); future.complete(node); return future; } static TerminateFuture completed(Hekate node); @Override Hekate get(); @Override Hekate get(long timeout, TimeUnit unit); }
@Test public void testCompleted() { assertTrue(TerminateFuture.completed(mock(Hekate.class)).isSuccess()); }
LockServiceFactory implements ServiceFactory<LockService> { @Override public LockService createService() { return new DefaultLockService(this); } List<LockRegionConfig> getRegions(); void setRegions(List<LockRegionConfig> regions); LockServiceFactory withRegion(LockRegionConfig region); List<LockConfigProvider> getConfigProviders(); void setConfigProviders(List<LockConfigProvider> configProviders); LockServiceFactory withConfigProvider(LockConfigProvider configProvider); long getRetryInterval(); void setRetryInterval(long retryInterval); LockServiceFactory withRetryInterval(long retryInterval); int getWorkerThreads(); void setWorkerThreads(int workerThreads); LockServiceFactory withWorkerThreads(int workerThreads); int getNioThreads(); void setNioThreads(int nioThreads); LockServiceFactory withNioThreads(int nioThreads); @Override LockService createService(); @Override String toString(); static final int DEFAULT_RETRY_INTERVAL; static final int DEFAULT_WORKER_THREADS; }
@Test public void testCreateService() { assertNotNull(factory.createService()); }
DefaultFailureDetector implements FailureDetector, JmxSupport<DefaultFailureDetectorJmx>, ConfigReportSupport { public boolean isMonitored(ClusterAddress node) { ArgAssert.notNull(node, "Node"); readLock.lock(); try { return monitors.containsKey(node); } finally { readLock.unlock(); } } DefaultFailureDetector(); DefaultFailureDetector(DefaultFailureDetectorConfig cfg); @Override void report(ConfigReporter report); @Override void initialize(FailureDetectorContext context); @Override long heartbeatInterval(); @Override int failureQuorum(); @Override void terminate(); @Override boolean isAlive(ClusterAddress node); @Override Collection<ClusterAddress> heartbeatTick(); @Override boolean onHeartbeatRequest(ClusterAddress from); @Override void onHeartbeatReply(ClusterAddress node); @Override void onConnectFailure(ClusterAddress node); @Override void update(Set<ClusterAddress> nodes); int heartbeatLossThreshold(); List<ClusterAddress> monitored(); boolean isMonitored(ClusterAddress node); @Override DefaultFailureDetectorJmx jmx(); @Override String toString(); }
@Test public void testIsMonitored() throws Exception { assertFalse(mgr.isMonitored(n1)); assertTrue(mgr.isMonitored(n2)); assertTrue(mgr.isMonitored(n3)); assertFalse(mgr.isMonitored(n4)); assertFalse(mgr.isMonitored(newNode(100).address())); }
DefaultFailureDetector implements FailureDetector, JmxSupport<DefaultFailureDetectorJmx>, ConfigReportSupport { @Override public void update(Set<ClusterAddress> nodes) { ArgAssert.notNull(nodes, "Node list"); ArgAssert.isTrue(nodes.contains(localNode), "Node list doesn't contain the local node."); writeLock.lock(); try { if (!nodes.equals(allNodes)) { allNodes = new HashSet<>(nodes); for (Iterator<ClusterAddress> it = monitors.keySet().iterator(); it.hasNext(); ) { ClusterAddress node = it.next(); if (!allNodes.contains(node)) { it.remove(); if (DEBUG) { log.debug("Stopped monitoring [node={}]", node); } } } updateMonitors(); } } finally { writeLock.unlock(); } } DefaultFailureDetector(); DefaultFailureDetector(DefaultFailureDetectorConfig cfg); @Override void report(ConfigReporter report); @Override void initialize(FailureDetectorContext context); @Override long heartbeatInterval(); @Override int failureQuorum(); @Override void terminate(); @Override boolean isAlive(ClusterAddress node); @Override Collection<ClusterAddress> heartbeatTick(); @Override boolean onHeartbeatRequest(ClusterAddress from); @Override void onHeartbeatReply(ClusterAddress node); @Override void onConnectFailure(ClusterAddress node); @Override void update(Set<ClusterAddress> nodes); int heartbeatLossThreshold(); List<ClusterAddress> monitored(); boolean isMonitored(ClusterAddress node); @Override DefaultFailureDetectorJmx jmx(); @Override String toString(); }
@Test public void testUpdate() throws Exception { mgr.update(toSet(n1, n3, n4)); assertFalse(mgr.isMonitored(n1)); assertFalse(mgr.isMonitored(n2)); assertTrue(mgr.isMonitored(n3)); assertTrue(mgr.isMonitored(n4)); assertFalse(mgr.isMonitored(newNode(100).address())); assertTrue(mgr.isAlive(n1)); assertTrue(mgr.isAlive(n2)); assertTrue(mgr.isAlive(n3)); assertTrue(mgr.isAlive(n4)); mgr.update(toSet(n1, n2, n3, n4)); assertFalse(mgr.isMonitored(n1)); assertTrue(mgr.isMonitored(n2)); assertTrue(mgr.isMonitored(n3)); assertFalse(mgr.isMonitored(n4)); assertFalse(mgr.isMonitored(newNode(100).address())); assertTrue(mgr.isAlive(n1)); assertTrue(mgr.isAlive(n2)); assertTrue(mgr.isAlive(n3)); assertTrue(mgr.isAlive(n4)); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public long cleanupInterval() { return allProviders.stream() .mapToLong(SeedNodeProvider::cleanupInterval) .filter(i -> i > 0) .min() .orElse(0); } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testCleanupInterval() { SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withPolicy(SeedNodeProviderGroupPolicy.IGNORE_PARTIAL_ERRORS) .withProvider(p1) .withProvider(p2) ); when(p1.cleanupInterval()).thenReturn(0L); when(p2.cleanupInterval()).thenReturn(0L); assertEquals(0, group.cleanupInterval()); verify(p1).cleanupInterval(); verify(p2).cleanupInterval(); verifyNoMoreInteractions(p1, p2); reset(p1, p2); when(p1.cleanupInterval()).thenReturn(100500L); when(p2.cleanupInterval()).thenReturn(0L); assertEquals(100500, group.cleanupInterval()); verify(p1).cleanupInterval(); verify(p2).cleanupInterval(); verifyNoMoreInteractions(p1, p2); reset(p1, p2); when(p1.cleanupInterval()).thenReturn(0L); when(p2.cleanupInterval()).thenReturn(100500L); assertEquals(100500, group.cleanupInterval()); verify(p1).cleanupInterval(); verify(p2).cleanupInterval(); verifyNoMoreInteractions(p1, p2); reset(p1, p2); when(p1.cleanupInterval()).thenReturn(100500L); when(p2.cleanupInterval()).thenReturn(100500L); assertEquals(100500, group.cleanupInterval()); verify(p1).cleanupInterval(); verify(p2).cleanupInterval(); verifyNoMoreInteractions(p1, p2); reset(p1, p2); when(p1.cleanupInterval()).thenReturn(1050L); when(p2.cleanupInterval()).thenReturn(100500L); assertEquals(1050, group.cleanupInterval()); verify(p1).cleanupInterval(); verify(p2).cleanupInterval(); verifyNoMoreInteractions(p1, p2); reset(p1, p2); when(p1.cleanupInterval()).thenReturn(100500L); when(p2.cleanupInterval()).thenReturn(1050L); assertEquals(1050, group.cleanupInterval()); verify(p1).cleanupInterval(); verify(p2).cleanupInterval(); verifyNoMoreInteractions(p1, p2); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public List<InetSocketAddress> findSeedNodes(String cluster) throws HekateException { List<InetSocketAddress> seedNodes = new ArrayList<>(); withPolicy("find seed nodes", liveProviders, provider -> seedNodes.addAll(provider.findSeedNodes(cluster)) ); return seedNodes; } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testFindSeedNodes() throws Exception { InetSocketAddress addr1 = newSocketAddress(); InetSocketAddress addr2 = newSocketAddress(); when(p1.findSeedNodes(anyString())).thenReturn(singletonList(addr1)); when(p2.findSeedNodes(anyString())).thenReturn(singletonList(addr2)); SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withProvider(p1) .withProvider(p2) ); group.startDiscovery(CLUSTER, selfAddr); List<InetSocketAddress> found = group.findSeedNodes(CLUSTER); assertEquals(asList(addr1, addr2), found); verify(p1).startDiscovery(CLUSTER, selfAddr); verify(p2).startDiscovery(CLUSTER, selfAddr); verify(p1).findSeedNodes(CLUSTER); verify(p2).findSeedNodes(CLUSTER); verifyNoMoreInteractions(p1, p2); }
RpcTypeAnalyzer { public <T> RpcInterfaceInfo<T> analyzeType(Class<T> type) { @SuppressWarnings("unchecked") RpcInterfaceInfo<T> info = (RpcInterfaceInfo<T>)cached(type).stream() .filter(t -> t.javaType() == type) .findFirst() .orElseThrow(() -> new IllegalArgumentException(type.getName() + " must be a public interface " + "and must be annotated with @" + Rpc.class.getSimpleName() + '.') ); return info; } RpcTypeAnalyzer(PlaceholderResolver resolver); RpcInterfaceInfo<T> analyzeType(Class<T> type); List<RpcInterface<?>> analyze(Object target); }
@Test public void testAnalyzeType() { expect(IllegalArgumentException.class, () -> analyzer.analyzeType(Runnable.class)); RpcInterfaceInfo<TypeA> info = analyzer.analyzeType(TypeA.class); verifyTypeA(info); } @Test public void testAnalyzeTypeCache() { RpcInterfaceInfo<TypeA> info1 = analyzer.analyzeType(TypeA.class); RpcInterfaceInfo<TypeA> info2 = analyzer.analyzeType(TypeA.class); RpcInterfaceInfo<TypeA> info3 = analyzer.analyzeType(TypeA.class); verifyTypeA(info1); assertSame(info1, info2); assertSame(info1, info3); } @Test public void testAffinityKey() { RpcInterfaceInfo<RpcWithAffinity> type = analyzer.analyzeType(RpcWithAffinity.class); assertEquals(3, type.methods().size()); RpcMethodInfo m1 = findMethod("key1", type); RpcMethodInfo m2 = findMethod("key2", type); RpcMethodInfo m3 = findMethod("key3", type); assertEquals(m1.toString(), 0, m1.affinityArg().getAsInt()); assertEquals(m2.toString(), 1, m2.affinityArg().getAsInt()); assertEquals(m3.toString(), 1, m3.affinityArg().getAsInt()); } @Test public void testDuplicatedAffinityKey() { RpcInterfaceInfo<RpcWithDuplicatedAffinity> type = analyzer.analyzeType(RpcWithDuplicatedAffinity.class); assertEquals(1, type.methods().size()); RpcMethodInfo m1 = type.methods().get(0); assertEquals(m1.toString(), 0, m1.affinityArg().getAsInt()); } @Test public void testInvalidMinClientVersion() { expectExactMessage(IllegalArgumentException.class, '@' + Rpc.class.getSimpleName() + " version must be greater than or equals to the minimum client version " + "[type=" + InvalidMinClientVersion.class.getName() + ", version=1, min-client-version=3]", () -> analyzer.analyzeType(InvalidMinClientVersion.class)); } @Test public void testBroadcastType() { RpcInterfaceInfo<BroadcastType> type = analyzer.analyzeType(BroadcastType.class); RpcMethodInfo call = findMethod("call", type); assertTrue(call.broadcast().isPresent()); assertSame(Void.class, call.realReturnType()); } @Test public void testBroadcastAsyncType() { RpcInterfaceInfo<BroadcastAsyncType> type = analyzer.analyzeType(BroadcastAsyncType.class); RpcMethodInfo call = findMethod("call", type); assertTrue(call.broadcast().isPresent()); assertTrue(call.isAsync()); assertSame(Void.class, call.realReturnType()); } @Test public void testAggregateType() { RpcInterfaceInfo<AggregateType> type = analyzer.analyzeType(AggregateType.class); RpcMethodInfo col = findMethod("collection", type); RpcMethodInfo lst = findMethod("list", type); RpcMethodInfo set = findMethod("set", type); RpcMethodInfo map = findMethod("map", type); assertTrue(col.aggregate().isPresent()); assertTrue(lst.aggregate().isPresent()); assertTrue(set.aggregate().isPresent()); assertTrue(map.aggregate().isPresent()); assertFalse(col.isAsync()); assertFalse(lst.isAsync()); assertFalse(set.isAsync()); assertFalse(map.isAsync()); assertSame(Collection.class, col.realReturnType()); assertSame(List.class, lst.realReturnType()); assertSame(Set.class, set.realReturnType()); assertSame(Map.class, map.realReturnType()); } @Test public void testAggregateAsyncType() { RpcInterfaceInfo<AggregateAsyncType> type = analyzer.analyzeType(AggregateAsyncType.class); RpcMethodInfo col = findMethod("collection", type); RpcMethodInfo lst = findMethod("list", type); RpcMethodInfo set = findMethod("set", type); RpcMethodInfo map = findMethod("map", type); assertTrue(col.aggregate().isPresent()); assertTrue(lst.aggregate().isPresent()); assertTrue(set.aggregate().isPresent()); assertTrue(map.aggregate().isPresent()); assertTrue(col.isAsync()); assertTrue(lst.isAsync()); assertTrue(set.isAsync()); assertTrue(map.isAsync()); assertSame(Collection.class, col.realReturnType()); assertSame(List.class, lst.realReturnType()); assertSame(Set.class, set.realReturnType()); assertSame(Map.class, map.realReturnType()); } @Test public void testAggregateReturnVoidType() { expectExactMessage(IllegalArgumentException.class, "Method annotated with @RpcAggregate has unsupported return type [" + "supported-types={Collection, List, Set, Map, CompletableFuture<Collection|List|Set|Map>}, " + "method=public abstract void " + InvalidAggregateTypeA.class.getName() + ".someMethod()]", () -> analyzer.analyzeType(InvalidAggregateTypeA.class)); } @Test public void testAggregateReturnConcreteType() { expectExactMessage(IllegalArgumentException.class, "Method annotated with @RpcAggregate has unsupported return type [" + "supported-types={Collection, List, Set, Map, CompletableFuture<Collection|List|Set|Map>}, " + "method=public abstract java.util.ArrayList " + InvalidAggregateTypeB.class.getName() + ".someMethod()]", () -> analyzer.analyzeType(InvalidAggregateTypeB.class)); } @Test public void testMultipleSplit() { expectExactMessage(IllegalArgumentException.class, "Only one argument can be annotated with @RpcSplit [method=" + "public abstract java.util.List " + RpcWithDuplicatedSplit.class.getName() + ".method(java.util.List,java.util.List)]", () -> analyzer.analyzeType(RpcWithDuplicatedSplit.class)); } @Test public void testInvalidSplitType() { expectExactMessage(IllegalArgumentException.class, "Parameter annotated with @RpcSplit has unsupported type [" + "supported-types={Collection, List, Set, Map}, " + "method=public abstract java.util.List " + RpcWithInvalidSplitType.class.getName() + ".method(java.lang.Object)]", () -> analyzer.analyzeType(RpcWithInvalidSplitType.class)); } @Test public void testSplitWithAffinity() { expectExactMessage(IllegalArgumentException.class, "@RpcSplit can't be used together with @RpcAffinityKey [method=" + "public abstract java.util.List " + RpcWithAffinityAndSplit.class.getName() + ".method(java.lang.Object,java.util.List)]", () -> analyzer.analyzeType(RpcWithAffinityAndSplit.class)); } @Test public void testSplitWithoutAggregate() { expectExactMessage(IllegalArgumentException.class, "@RpcSplit can be used only in @RpcAggregate-annotated methods " + "[method=public abstract java.util.List " + RpcSplitWithoutAggregate.class.getName() + ".method(java.util.List)]", () -> analyzer.analyzeType(RpcSplitWithoutAggregate.class)); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public void startDiscovery(String cluster, InetSocketAddress node) throws HekateException { try { withPolicy("start discovery", allProviders, provider -> { try { provider.startDiscovery(cluster, node); liveProviders.add(provider); } catch (HekateException | RuntimeException | Error e) { failSafeStop(provider, cluster, node); throw e; } } ); } catch (RuntimeException | Error | HekateException e) { stopDiscovery(cluster, node); throw e; } } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testStartDiscovery() throws Exception { SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withProvider(p1) .withProvider(p2) ); InetSocketAddress addr = newSocketAddress(); group.startDiscovery(CLUSTER, addr); assertEquals(2, group.liveProviders().size()); assertTrue(group.liveProviders().contains(p1)); assertTrue(group.liveProviders().contains(p2)); verify(p1).startDiscovery(CLUSTER, addr); verify(p2).startDiscovery(CLUSTER, addr); verifyNoMoreInteractions(p1, p2); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public void stopDiscovery(String cluster, InetSocketAddress node) throws HekateException { try { for (SeedNodeProvider provider : liveProviders) { failSafeStop(provider, cluster, node); } } finally { liveProviders.clear(); } } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testStopDiscovery() throws Exception { SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withProvider(p1) .withProvider(p2) ); group.startDiscovery(CLUSTER, selfAddr); assertEquals(2, group.liveProviders().size()); group.stopDiscovery(CLUSTER, selfAddr); assertTrue(group.liveProviders().isEmpty()); verify(p1).startDiscovery(CLUSTER, selfAddr); verify(p2).startDiscovery(CLUSTER, selfAddr); verify(p1).stopDiscovery(CLUSTER, selfAddr); verify(p2).stopDiscovery(CLUSTER, selfAddr); verifyNoMoreInteractions(p1, p2); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public void suspendDiscovery() throws HekateException { liveProviders.forEach(provider -> { try { provider.suspendDiscovery(); } catch (Throwable e) { if (log.isWarnEnabled()) { log.warn("Failed to suspend discovery [provider={}]", provider, e); } } }); } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testSuspendDiscovery() throws Exception { SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withProvider(p1) .withProvider(p2) ); group.startDiscovery(CLUSTER, selfAddr); group.suspendDiscovery(); verify(p1).startDiscovery(CLUSTER, selfAddr); verify(p2).startDiscovery(CLUSTER, selfAddr); verify(p1).suspendDiscovery(); verify(p2).suspendDiscovery(); verifyNoMoreInteractions(p1, p2); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public void registerRemote(String cluster, InetSocketAddress node) throws HekateException { withPolicy("register a remote seed node", liveProviders, provider -> provider.registerRemote(cluster, node) ); } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testRegisterRemote() throws Exception { SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withProvider(p1) .withProvider(p2) ); group.startDiscovery(CLUSTER, selfAddr); InetSocketAddress addr = newSocketAddress(); group.registerRemote(CLUSTER, addr); verify(p1).startDiscovery(CLUSTER, selfAddr); verify(p2).startDiscovery(CLUSTER, selfAddr); verify(p1).registerRemote(CLUSTER, addr); verify(p2).registerRemote(CLUSTER, addr); verifyNoMoreInteractions(p1, p2); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public void unregisterRemote(String cluster, InetSocketAddress node) throws HekateException { withPolicy("unregister a remote seed node", liveProviders, provider -> provider.unregisterRemote(cluster, node) ); } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testUnregisterRemote() throws Exception { SeedNodeProviderGroup group = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withProvider(p1) .withProvider(p2) ); group.startDiscovery(CLUSTER, selfAddr); InetSocketAddress addr = newSocketAddress(); group.unregisterRemote(CLUSTER, addr); verify(p1).startDiscovery(CLUSTER, selfAddr); verify(p2).startDiscovery(CLUSTER, selfAddr); verify(p1).unregisterRemote(CLUSTER, addr); verify(p2).unregisterRemote(CLUSTER, addr); verifyNoMoreInteractions(p1, p2); }
SeedNodeProviderGroup implements SeedNodeProvider, JmxSupport<Collection<? extends SeedNodeProvider>>, ConfigReportSupport { @Override public String toString() { return ToString.format(this); } SeedNodeProviderGroup(SeedNodeProviderGroupConfig cfg); @Override void report(ConfigReporter report); List<SeedNodeProvider> allProviders(); List<SeedNodeProvider> liveProviders(); Optional<T> findProvider(Class<T> type); SeedNodeProviderGroupPolicy policy(); @Override long cleanupInterval(); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override Collection<? extends SeedNodeProvider> jmx(); @Override String toString(); }
@Test public void testToString() { SeedNodeProvider provider = new SeedNodeProviderGroup(new SeedNodeProviderGroupConfig() .withPolicy(SeedNodeProviderGroupPolicy.IGNORE_PARTIAL_ERRORS) .withProvider(p1) .withProvider(p2) ); assertEquals(ToString.format(provider), provider.toString()); }
StaticSeedNodeProvider implements SeedNodeProvider, ConfigReportSupport { @Override public List<InetSocketAddress> findSeedNodes(String cluster) throws HekateException { return addresses; } StaticSeedNodeProvider(StaticSeedNodeProviderConfig cfg); @Override void report(ConfigReporter report); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override long cleanupInterval(); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); List<InetSocketAddress> getAddresses(); @Override String toString(); }
@Test public void testValidIAddressV4() throws Exception { StaticSeedNodeProvider provider = get(ADDRESS_V4 + ":10001"); List<InetSocketAddress> nodes = provider.findSeedNodes("test"); assertFalse(nodes.isEmpty()); assertEquals(new InetSocketAddress(ADDRESS_V4, 10001), nodes.get(0)); } @Test public void testValidAddressV6() throws Exception { StaticSeedNodeProvider provider = get("[" + ADDRESS_V6 + "]:10001"); List<InetSocketAddress> nodes = provider.findSeedNodes("test"); assertFalse(nodes.isEmpty()); assertEquals(new InetSocketAddress(ADDRESS_V6, 10001), nodes.get(0)); }
SeedNodeProviderGroupConfig { @Override public String toString() { return ToString.format(this); } SeedNodeProviderGroupPolicy getPolicy(); void setPolicy(SeedNodeProviderGroupPolicy policy); SeedNodeProviderGroupConfig withPolicy(SeedNodeProviderGroupPolicy policy); List<SeedNodeProvider> getProviders(); void setProviders(List<SeedNodeProvider> providers); SeedNodeProviderGroupConfig withProvider(SeedNodeProvider provider); SeedNodeProviderGroupConfig withProviders(List<SeedNodeProvider> providers); boolean hasProviders(); @Override String toString(); }
@Test public void testToString() { assertEquals(ToString.format(cfg), cfg.toString()); }
MulticastSeedNodeProvider implements SeedNodeProvider, JmxSupport<MulticastSeedNodeProviderJmx>, ConfigReportSupport { @Override public void suspendDiscovery() { suspendDiscoveryAsync().awaitUninterruptedly(); } MulticastSeedNodeProvider(); MulticastSeedNodeProvider(MulticastSeedNodeProviderConfig cfg); @Override void report(ConfigReporter report); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress address); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress address); @Override long cleanupInterval(); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); InetSocketAddress group(); int ttl(); long interval(); long waitTime(); boolean isLoopBackDisabled(); @Override MulticastSeedNodeProviderJmx jmx(); @Override String toString(); }
@Test public void testSuspendDiscovery() throws Exception { Map<InetSocketAddress, TestProvider> providers = new HashMap<>(); try { for (int i = 0; i < 3; i++) { TestProvider provider = createProvider(); InetSocketAddress address = newSocketAddress(10000 + i); providers.put(address, provider); provider.startDiscovery(CLUSTER_1, address); } for (Map.Entry<InetSocketAddress, TestProvider> e : providers.entrySet()) { TestProvider provider = e.getValue(); assertTrue(e.getKey().toString(), provider.getRequests() > 0); provider.suspendDiscovery(); } sleep(DISCOVERY_INTERVAL * 4); providers.values().forEach(TestProvider::clearRequests); sleep(DISCOVERY_INTERVAL * 2); providers.values().forEach(p -> assertEquals(0, p.getRequests())); } finally { for (Map.Entry<InetSocketAddress, TestProvider> e : providers.entrySet()) { e.getValue().stopDiscovery(CLUSTER_1, e.getKey()); assertTrue(e.getValue().findSeedNodes(CLUSTER_1).isEmpty()); } } }
MulticastSeedNodeProvider implements SeedNodeProvider, JmxSupport<MulticastSeedNodeProviderJmx>, ConfigReportSupport { @Override public void startDiscovery(String cluster, InetSocketAddress address) throws HekateException { log.info("Starting seed node discovery [cluster={}, {}]", cluster, ToString.formatProperties(this)); SeedNode self = new SeedNode(address, cluster); try { NetworkInterface nif = selectMulticastInterface(address); try { synchronized (mux) { if (isRegistered()) { String err = format("Multicast seed node provider is already registered with another address [existing=%s]", self); throw new IllegalStateException(err); } localNode = self; discovered = new HashSet<>(); eventLoop = new NioEventLoopGroup(1, new HekateThreadFactory("SeedNodeMulticast")); Bootstrap boot = new Bootstrap(); boot.group(eventLoop); boot.channelFactory(() -> new NioDatagramChannel(ipVer) ); boot.option(SO_REUSEADDR, true); boot.option(IP_MULTICAST_TTL, ttl); boot.option(IP_MULTICAST_IF, nif); if (loopBackDisabled) { boot.option(IP_MULTICAST_LOOP_DISABLED, true); if (DEBUG) { log.debug("Setting {} option to true", IP_MULTICAST_LOOP_DISABLED); } } boot.localAddress(0); boot.handler(createSenderHandler(self)); DatagramChannel sender = bindSender(boot); boot.localAddress(group.getPort()); boot.handler(createReceiveHandler(self)); bindReceiver(boot); log.info( "Joining multicast group [address={}, port={}, interface={}, ttl={}]", AddressUtils.host(group), group.getPort(), nif.getName(), ttl ); receiver.joinGroup(group, nif).get(); discoveryFuture = eventLoop.scheduleWithFixedDelay(() -> { if (DEBUG) { log.debug("Sending discovery message [from={}]", self); } sender.writeAndFlush(discoveryRequest(self)); }, 0, interval, TimeUnit.MILLISECONDS); } } catch (ExecutionException e) { cleanup(); throw new HekateException("Failed to start a multicast seed nodes discovery [node=" + self + ']', e.getCause()); } log.info("Will wait for seed nodes [timeout={}(ms)]", waitTime); Thread.sleep(waitTime); } catch (InterruptedException e) { cleanup(); Thread.currentThread().interrupt(); throw new HekateException("Thread was interrupted while awaiting for multicast discovery [node=" + self + ']', e); } log.info("Done waiting for seed nodes."); } MulticastSeedNodeProvider(); MulticastSeedNodeProvider(MulticastSeedNodeProviderConfig cfg); @Override void report(ConfigReporter report); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void startDiscovery(String cluster, InetSocketAddress address); @Override void suspendDiscovery(); @Override void stopDiscovery(String cluster, InetSocketAddress address); @Override long cleanupInterval(); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); InetSocketAddress group(); int ttl(); long interval(); long waitTime(); boolean isLoopBackDisabled(); @Override MulticastSeedNodeProviderJmx jmx(); @Override String toString(); }
@Test public void testThreadInterruptionOnStart() throws Exception { TestProvider provider = createProvider(cfg -> cfg.withWaitTime(3000)); Thread.currentThread().interrupt(); try { provider.startDiscovery(CLUSTER_1, newSocketAddress()); fail("Error was expected."); } catch (HekateException e) { try { assertTrue(getStacktrace(e), e.isCausedBy(InterruptedException.class)); assertTrue(Thread.currentThread().isInterrupted()); } finally { Thread.interrupted(); } } }
ClusterFilters { public static ClusterFilter forNode(ClusterNodeId nodeId) { ArgAssert.notNull(nodeId, "Node"); return nodes -> { if (!nodes.isEmpty()) { for (ClusterNode node : nodes) { if (node.id().equals(nodeId)) { return singletonList(node); } } } return emptyList(); }; } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForId() throws Exception { List<ClusterNode> nodes = asList(newNode(), newNode(), newNode(), newNode()); for (ClusterNode n : nodes) { assertEquals(singletonList(n), ClusterFilters.forNode(n.id()).apply(nodes)); } ClusterNodeId nonExisting = newNodeId(); assertEquals(emptyList(), ClusterFilters.forNode(nonExisting).apply(nodes)); } @Test public void testForNode() throws Exception { List<ClusterNode> nodes = asList(newNode(), newNode(), newNode(), newNode()); for (ClusterNode n : nodes) { assertEquals(singletonList(n), ClusterFilters.forNode(n).apply(nodes)); } ClusterNode nonExisting = newNode(); assertEquals(emptyList(), ClusterFilters.forNode(nonExisting).apply(nodes)); }
ClusterFilters { public static ClusterFilter forNext() { return NEXT; } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForNext() throws Exception { repeat(5, i -> { List<ClusterNode> nodes = new ArrayList<>(); repeat(5, j -> nodes.add(newNode(newNodeId(j), i == j , null, null))); ClusterNode expected; if (i == 4) { expected = nodes.get(0); } else { expected = nodes.get(i + 1); } assertEquals(singletonList(expected), ClusterFilters.forNext().apply(nodes)); }); } @Test public void testForNextWithSingleLocal() throws Exception { ClusterNode node = newLocalNode(); assertEquals(singletonList(node), ClusterFilters.forNext().apply(singletonList(node))); } @Test public void testForNextWithNoLocal() throws Exception { List<ClusterNode> nodes = asList(newNode(), newNode(), newNode(), newNode()); assertEquals(emptyList(), ClusterFilters.forNext().apply(nodes)); }
ClusterFilters { public static ClusterFilter forNextInJoinOrder() { return NEXT_IN_JOIN_ORDER; } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForJoinOrderNext() throws Exception { repeat(5, i -> { List<ClusterNode> nodesList = new ArrayList<>(); repeat(5, j -> nodesList.add(newNode(newNodeId(), i == j , null, null, j))); ClusterNode expected; if (i == 4) { expected = nodesList.get(0); } else { expected = nodesList.get(i + 1); } assertEquals(singletonList(expected), ClusterFilters.forNextInJoinOrder().apply(nodesList)); }); } @Test public void testForJoinOrderNextWithSingleLocal() throws Exception { ClusterNode node = newLocalNode(); assertEquals(singletonList(node), ClusterFilters.forNextInJoinOrder().apply(singletonList(node))); } @Test public void testForJoinOrderNextWithNoLocal() throws Exception { List<ClusterNode> nodes = asList(newNode(), newNode(), newNode(), newNode()); assertEquals(emptyList(), ClusterFilters.forNextInJoinOrder().apply(nodes)); }
ClusterFilters { public static ClusterFilter forOldest() { return OLDEST; } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForOldest() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withJoinOrder(1)); ClusterNode node2 = newLocalNode(n -> n.withJoinOrder(2)); ClusterNode node3 = newLocalNode(n -> n.withJoinOrder(3)); assertEquals(singletonList(node1), ClusterFilters.forOldest().apply(asList(node1, node2, node3))); }
ClusterFilters { public static ClusterFilter forYoungest() { return YOUNGEST; } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForYoungest() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withJoinOrder(1)); ClusterNode node2 = newLocalNode(n -> n.withJoinOrder(2)); ClusterNode node3 = newLocalNode(n -> n.withJoinOrder(3)); assertEquals(singletonList(node3), ClusterFilters.forYoungest().apply(asList(node1, node2, node3))); }
ClusterFilters { public static ClusterFilter forRole(String role) { ArgAssert.notNull(role, "Role"); return forFilter(n -> n.hasRole(role)); } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForRole() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withRoles(singleton("role1"))); ClusterNode node2 = newLocalNode(n -> n.withRoles(singleton("role2"))); ClusterNode node3 = newLocalNode(n -> n.withRoles(singleton("role3"))); assertEquals(singletonList(node3), ClusterFilters.forRole("role3").apply(asList(node1, node2, node3))); assertEquals(emptyList(), ClusterFilters.forRole("INVALID").apply(asList(node1, node2, node3))); }
ClusterFilters { public static ClusterFilter forProperty(String name) { ArgAssert.notNull(name, "Property name"); return forFilter(n -> n.hasProperty(name)); } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForProperty() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withProperties(singletonMap("prop1", "val1"))); ClusterNode node2 = newLocalNode(n -> n.withProperties(singletonMap("prop2", "val2"))); ClusterNode node3 = newLocalNode(n -> n.withProperties(singletonMap("prop3", "val3"))); assertEquals(singletonList(node3), ClusterFilters.forProperty("prop3").apply(asList(node1, node2, node3))); assertEquals(emptyList(), ClusterFilters.forProperty("INVALID").apply(asList(node1, node2, node3))); } @Test public void testForPropertyValue() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withProperties(singletonMap("prop1", "val1"))); ClusterNode node2 = newLocalNode(n -> n.withProperties(singletonMap("prop2", "val2"))); ClusterNode node3 = newLocalNode(n -> n.withProperties(singletonMap("prop3", "val3"))); assertEquals(singletonList(node3), ClusterFilters.forProperty("prop3", "val3").apply(asList(node1, node2, node3))); assertEquals(emptyList(), ClusterFilters.forProperty("prop3", "INVALID").apply(asList(node1, node2, node3))); assertEquals(emptyList(), ClusterFilters.forProperty("INVALID", "INVALID").apply(asList(node1, node2, node3))); }
ClusterFilters { public static ClusterFilter forService(Class<? extends Service> type) { ArgAssert.notNull(type, "Service type"); return forFilter(n -> n.hasService(type)); } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForService() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withServices(singletonMap(NetworkService.class.getName(), null))); ClusterNode node2 = newLocalNode(n -> n.withServices(singletonMap(ClusterService.class.getName(), null))); ClusterNode node3 = newLocalNode(n -> n.withServices(singletonMap(MessagingService.class.getName(), null))); assertEquals(singletonList(node3), ClusterFilters.forService(MessagingService.class).apply(asList(node1, node2, node3))); assertEquals(emptyList(), ClusterFilters.forService(CoordinationService.class).apply(asList(node1, node2, node3))); }
ClusterFilters { public static ClusterFilter forRemotes() { return REMOTES; } private ClusterFilters(); static ClusterFilter forNext(); static ClusterFilter forNextInJoinOrder(); static ClusterFilter forNode(ClusterNodeId nodeId); static ClusterFilter forNode(ClusterNode node); static ClusterFilter forOldest(); static ClusterFilter forYoungest(); static ClusterFilter forFilter(ClusterNodeFilter filter); static ClusterFilter forRole(String role); static ClusterFilter forProperty(String name); static ClusterFilter forProperty(String name, String value); static ClusterFilter forService(Class<? extends Service> type); static ClusterFilter forRemotes(); }
@Test public void testForRemotes() throws Exception { ClusterNode node1 = newLocalNode(n -> n.withLocalNode(false)); ClusterNode node2 = newLocalNode(n -> n.withLocalNode(false)); ClusterNode node3 = newLocalNode(n -> n.withLocalNode(true)); assertEquals(asList(node1, node2), ClusterFilters.forRemotes().apply(asList(node1, node2, node3))); assertEquals(emptyList(), ClusterFilters.forService(CoordinationService.class).apply(asList(node1, node2))); }
DefaultClusterTopology implements ClusterTopology, Serializable { public DefaultClusterTopology update(Set<ClusterNode> newNodes) { return new DefaultClusterTopology(version + 1, newNodes); } private DefaultClusterTopology(long version, Set<ClusterNode> nodes); private DefaultClusterTopology(long version, List<ClusterNode> nodes, boolean safe); static DefaultClusterTopology of(long version, Set<ClusterNode> nodes); static DefaultClusterTopology empty(); DefaultClusterTopology updateIfModified(Set<ClusterNode> newNodes); DefaultClusterTopology update(Set<ClusterNode> newNodes); @Override long version(); @Override ClusterHash hash(); @Override ClusterNode localNode(); @Override List<ClusterNode> nodes(); @Override ClusterNode first(); @Override ClusterNode last(); @Override Set<ClusterNode> nodeSet(); @Override NavigableSet<ClusterNode> joinOrder(); @Override Stream<ClusterNode> stream(); @Override Iterator<ClusterNode> iterator(); @Override void forEach(Consumer<? super ClusterNode> action); @Override Spliterator<ClusterNode> spliterator(); @Override List<ClusterNode> remoteNodes(); @Override boolean contains(ClusterNode node); @Override boolean contains(ClusterNodeId id); @Override ClusterNode get(ClusterNodeId id); @Override int size(); @Override boolean isEmpty(); @Override ClusterNode oldest(); @Override ClusterNode youngest(); @Override ClusterNode random(); @Override ClusterTopology filterAll(ClusterFilter filter); @Override ClusterTopology filter(ClusterNodeFilter filter); @Override ClusterTopology topology(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testUpdate() throws Exception { ClusterNode n1 = newNode(n -> n.withJoinOrder(1)); ClusterNode n2 = newNode(n -> n.withJoinOrder(2)); ClusterNode n3 = newNode(n -> n.withJoinOrder(3)); DefaultClusterTopology t1 = newTopology(1, singleton(n1)); assertSame(t1, t1.updateIfModified(singleton(n1))); DefaultClusterTopology t2 = t1.updateIfModified(toSet(n1, n2, n3)); assertEquals(2, t2.version()); assertNotEquals(t1.hash(), t2.hash()); assertTrue(t2.contains(n1)); assertTrue(t2.contains(n2)); assertTrue(t2.contains(n3)); assertSame(t2, t2.updateIfModified(toSet(n1, n2, n3))); DefaultClusterTopology t3 = t2.updateIfModified(toSet(n1, n2)); assertEquals(3, t3.version()); assertNotEquals(t2.hash(), t3.hash()); assertTrue(t3.contains(n1)); assertTrue(t3.contains(n2)); assertFalse(t3.contains(n3)); DefaultClusterTopology t4 = t3.update(toSet(n1, n2)); assertEquals(4, t4.version()); assertEquals(t3.hash(), t4.hash()); assertTrue(t4.contains(n1)); assertTrue(t4.contains(n2)); assertFalse(t4.contains(n3)); DefaultClusterTopology t5 = t4.update(toSet(n1, n2, n3)); assertEquals(5, t5.version()); assertTrue(t5.contains(n1)); assertTrue(t5.contains(n2)); assertTrue(t5.contains(n3)); }
DefaultClusterTopology implements ClusterTopology, Serializable { @Override public int hashCode() { return nodes.hashCode(); } private DefaultClusterTopology(long version, Set<ClusterNode> nodes); private DefaultClusterTopology(long version, List<ClusterNode> nodes, boolean safe); static DefaultClusterTopology of(long version, Set<ClusterNode> nodes); static DefaultClusterTopology empty(); DefaultClusterTopology updateIfModified(Set<ClusterNode> newNodes); DefaultClusterTopology update(Set<ClusterNode> newNodes); @Override long version(); @Override ClusterHash hash(); @Override ClusterNode localNode(); @Override List<ClusterNode> nodes(); @Override ClusterNode first(); @Override ClusterNode last(); @Override Set<ClusterNode> nodeSet(); @Override NavigableSet<ClusterNode> joinOrder(); @Override Stream<ClusterNode> stream(); @Override Iterator<ClusterNode> iterator(); @Override void forEach(Consumer<? super ClusterNode> action); @Override Spliterator<ClusterNode> spliterator(); @Override List<ClusterNode> remoteNodes(); @Override boolean contains(ClusterNode node); @Override boolean contains(ClusterNodeId id); @Override ClusterNode get(ClusterNodeId id); @Override int size(); @Override boolean isEmpty(); @Override ClusterNode oldest(); @Override ClusterNode youngest(); @Override ClusterNode random(); @Override ClusterTopology filterAll(ClusterFilter filter); @Override ClusterTopology filter(ClusterNodeFilter filter); @Override ClusterTopology topology(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testEqualsAndHashCode() throws Exception { ClusterNode n1 = newNode(n -> n.withJoinOrder(1)); ClusterNode n2 = newNode(n -> n.withJoinOrder(2)); ClusterNode n3 = newNode(n -> n.withJoinOrder(3)); DefaultClusterTopology t1 = newTopology(1, toSet(n1, n2, n3)); DefaultClusterTopology t2 = newTopology(1, toSet(n1, n2, n3)); DefaultClusterTopology t3 = newTopology(2, toSet(n1, n2, n3)); DefaultClusterTopology t4 = newTopology(1, toSet(n1, n2)); DefaultClusterTopology t5 = newTopology(1, emptySet()); assertEquals(t1, t1); assertEquals(t1, t2); assertEquals(t1, t3); assertEquals(t1.hashCode(), t2.hashCode()); assertEquals(t1.hashCode(), t3.hashCode()); assertNotEquals(t1, t4); assertNotEquals(t1, t5); }
TopologyContextCache { @SuppressWarnings("unchecked") public <C> C get(ClusterTopology topology, Function<ClusterTopology, C> supplier) { CacheEntry ctx = this.ctx; if (ctx == null || ctx.version() != topology.version()) { this.ctx = ctx = new CacheEntry( topology.version(), supplier.apply(topology) ); } return (C)ctx.value(); } @SuppressWarnings("unchecked") C get(ClusterTopology topology, Function<ClusterTopology, C> supplier); }
@Test public void test() throws Exception { Function<ClusterTopology, Object> supplier = topology -> new Object(); ClusterTopology t1 = ClusterTopology.of(1, toSet(newNode())); ClusterTopology t2 = ClusterTopology.of(2, toSet(newNode(), newNode())); ClusterTopology t3 = ClusterTopology.of(3, toSet(newNode(), newNode(), newNode())); Object o1 = cache.get(t1, supplier); assertSame(o1, cache.get(t1, supplier)); Object o2 = cache.get(t2, supplier); assertNotSame(o2, o1); assertSame(o2, cache.get(t2, supplier)); Object o3 = cache.get(t3, supplier); assertNotSame(o1, o3); assertNotSame(o2, o3); assertSame(o3, cache.get(t3, supplier)); } @Test public void testConcurrent() throws Exception { ClusterTopology[] topologies = { ClusterTopology.of(1, toSet(newNode())), ClusterTopology.of(2, toSet(newNode(), newNode())), ClusterTopology.of(3, toSet(newNode(), newNode(), newNode())) }; runParallel(4, 1_000_000, status -> { ClusterTopology top = topologies[ThreadLocalRandom.current().nextInt(topologies.length)]; assertEquals(top.hash(), cache.get(top, ClusterTopology::hash)); }); }
SeedNodeManager { public List<InetSocketAddress> getSeedNodes() throws HekateException { if (DEBUG) { log.debug("Getting seed nodes to join...."); } List<InetSocketAddress> nodes = provider.findSeedNodes(cluster); nodes = nodes != null ? nodes : emptyList(); if (DEBUG) { log.debug("Got a seed nodes list [seed-nodes={}]", nodes); } return nodes; } SeedNodeManager(String cluster, SeedNodeProvider provider); List<InetSocketAddress> getSeedNodes(); void startDiscovery(InetSocketAddress address); void suspendDiscovery(); void stopDiscovery(InetSocketAddress address); void startCleaning(NetworkService net, AliveAddressProvider aliveAddressProvider); Waiting stopCleaning(); @Override String toString(); }
@Test public void testNeverReturnsNull() throws Exception { when(provider.findSeedNodes(any(String.class))).thenReturn(null); List<InetSocketAddress> nodes = manager.getSeedNodes(); assertNotNull(nodes); assertTrue(nodes.isEmpty()); verify(provider).findSeedNodes(any(String.class)); verifyNoMoreInteractions(provider); } @Test public void testErrorOnGetSeedNodes() throws Exception { when(provider.findSeedNodes(any(String.class))).thenThrow(TEST_ERROR); try { manager.getSeedNodes(); fail("Error was expected."); } catch (AssertionError e) { assertEquals(HekateTestError.MESSAGE, e.getMessage()); } verify(provider).findSeedNodes(any(String.class)); verifyNoMoreInteractions(provider); }
SeedNodeManager { public void startDiscovery(InetSocketAddress address) throws HekateException { if (DEBUG) { log.debug("Starting seed nodes discovery [cluster={}, address={}]", cluster, address); } started.set(true); provider.startDiscovery(cluster, address); if (DEBUG) { log.debug("Started seed nodes discovery [cluster={}, address={}]", cluster, address); } } SeedNodeManager(String cluster, SeedNodeProvider provider); List<InetSocketAddress> getSeedNodes(); void startDiscovery(InetSocketAddress address); void suspendDiscovery(); void stopDiscovery(InetSocketAddress address); void startCleaning(NetworkService net, AliveAddressProvider aliveAddressProvider); Waiting stopCleaning(); @Override String toString(); }
@Test public void testErrorOnStartDiscovery() throws Exception { doThrow(TEST_ERROR).when(provider).startDiscovery(any(String.class), any(InetSocketAddress.class)); try { manager.startDiscovery(newSocketAddress()); fail("Error was expected."); } catch (AssertionError e) { assertEquals(HekateTestError.MESSAGE, e.getMessage()); } verify(provider).startDiscovery(any(String.class), any(InetSocketAddress.class)); verifyNoMoreInteractions(provider); }
SeedNodeManager { public void suspendDiscovery() { if (DEBUG) { log.debug("Suspending seed nodes discovery..."); } try { provider.suspendDiscovery(); if (DEBUG) { log.debug("Suspended seed nodes discovery."); } } catch (Throwable t) { log.error("Failed to suspend seed nodes discovery.", t); } } SeedNodeManager(String cluster, SeedNodeProvider provider); List<InetSocketAddress> getSeedNodes(); void startDiscovery(InetSocketAddress address); void suspendDiscovery(); void stopDiscovery(InetSocketAddress address); void startCleaning(NetworkService net, AliveAddressProvider aliveAddressProvider); Waiting stopCleaning(); @Override String toString(); }
@Test public void testNoErrorOnSuspendDiscovery() throws Exception { doThrow(TEST_ERROR).when(provider).suspendDiscovery(); manager.suspendDiscovery(); verify(provider).suspendDiscovery(); verifyNoMoreInteractions(provider); }
SeedNodeManager { public void stopDiscovery(InetSocketAddress address) { if (started.compareAndSet(true, false)) { try { if (DEBUG) { log.debug("Stopping seed nodes discovery [cluster={}, address={}]", cluster, address); } provider.stopDiscovery(cluster, address); if (DEBUG) { log.debug("Done stopping seed nodes discovery [cluster={}, address={}]", cluster, address); } } catch (Throwable t) { log.error("Failed to stop seed nodes discovery [cluster={}, address={}]", cluster, address, t); } } } SeedNodeManager(String cluster, SeedNodeProvider provider); List<InetSocketAddress> getSeedNodes(); void startDiscovery(InetSocketAddress address); void suspendDiscovery(); void stopDiscovery(InetSocketAddress address); void startCleaning(NetworkService net, AliveAddressProvider aliveAddressProvider); Waiting stopCleaning(); @Override String toString(); }
@Test public void testStopDiscoveryWithoutStartDiscovery() throws Exception { manager.stopDiscovery(newSocketAddress()); verifyNoMoreInteractions(provider); }
SeedNodeManager { public Waiting stopCleaning() { ExecutorService cleaner; synchronized (cleanupMux) { cleaner = this.cleaner; if (cleaner != null) { if (DEBUG) { log.debug("Canceling seed nodes cleanup task [cluster={}]", cluster); } this.cleaner = null; this.net = null; this.aliveAddressProvider = null; } } return AsyncUtils.shutdown(cleaner); } SeedNodeManager(String cluster, SeedNodeProvider provider); List<InetSocketAddress> getSeedNodes(); void startDiscovery(InetSocketAddress address); void suspendDiscovery(); void stopDiscovery(InetSocketAddress address); void startCleaning(NetworkService net, AliveAddressProvider aliveAddressProvider); Waiting stopCleaning(); @Override String toString(); }
@Test public void testStopCleaningWithoutStarting() throws Exception { manager.stopCleaning(); manager.stopCleaning(); manager.stopCleaning(); }
SeedNodeManager { @Override public String toString() { return provider.toString(); } SeedNodeManager(String cluster, SeedNodeProvider provider); List<InetSocketAddress> getSeedNodes(); void startDiscovery(InetSocketAddress address); void suspendDiscovery(); void stopDiscovery(InetSocketAddress address); void startCleaning(NetworkService net, AliveAddressProvider aliveAddressProvider); Waiting stopCleaning(); @Override String toString(); }
@Test public void testToString() throws Exception { assertEquals(provider.toString(), manager.toString()); }
GossipSeedNodesSate { public InetSocketAddress nextSeed() { if (lastTried != null) { lastTried = seeds.stream() .filter(s -> s.status() != Status.BAN && !s.address().equals(localAddress) && compare(s.address(), lastTried) > 0) .findFirst() .map(SeedNodeState::address) .orElse(null); } if (lastTried == null) { lastTried = seeds.stream() .filter(s -> s.status() != Status.BAN && !s.address().equals(localAddress)) .findFirst() .map(SeedNodeState::address) .orElse(null); } return lastTried; } GossipSeedNodesSate(InetSocketAddress localAddress, List<InetSocketAddress> seeds); boolean isSelfJoin(); InetSocketAddress nextSeed(); void update(List<InetSocketAddress> newSeeds); void onReject(InetSocketAddress seed); void onFailure(InetSocketAddress seed, Throwable cause); void onBan(InetSocketAddress seed); @Override String toString(); }
@Test public void testNextSeed() throws Exception { List<InetSocketAddress> seeds = new ArrayList<>(); seeds.add(newSocketAddress(1)); seeds.add(newSocketAddress(2)); seeds.add(newSocketAddress(3)); GossipSeedNodesSate s = new GossipSeedNodesSate(newSocketAddress(1000), seeds); assertFalse(s.isSelfJoin()); repeat(3, i -> { for (InetSocketAddress addr : seeds) { assertEquals(addr, s.nextSeed()); } }); }
GossipManager { public UpdateBase leave() { if (status == LEAVING || status.isTerminated()) { if (DEBUG) { log.debug("Skipped leaving since local node is in {} state [gossip={}]", status, localGossip); } } else { leaveScheduled = true; if (localGossip.isConvergent()) { GossipNodeState newState = localGossip.member(id).status(LEAVING); updateLocalGossip(localGossip.update(id, newState)); if (DEBUG) { log.debug("Leaving cluster [gossip={}]", localGossip); } updateLocalSate(); if (tryCoordinate()) { updateLocalSate(); } } else { if (DEBUG) { log.debug("Scheduled leave operation to be executed once gossip reaches its convergent sate [gossip={}]", localGossip); } } return gossip(); } return null; } GossipManager( String cluster, ClusterNode localNode, int speedUpSize, FailureDetector failureDetector, GossipListener gossipListener ); Gossip localGossip(); JoinRequest join(List<InetSocketAddress> seedNodes); JoinRequest processJoinReject(JoinReject msg); JoinRequest processJoinFailure(JoinRequest msg, Throwable cause); Update processJoinAccept(JoinAccept msg); JoinReject acceptJoinRequest(JoinRequest msg); JoinReply processJoinRequest(JoinRequest msg); JoinReject reject(JoinRequest msg, String reason); Collection<UpdateBase> batchGossip(GossipPolicy policy); UpdateBase gossip(); UpdateBase processUpdate(UpdateBase msg); boolean checkAliveness(); UpdateBase leave(); ClusterNode node(); ClusterAddress address(); ClusterNodeId id(); GossipNodeStatus status(); static final int GOSSIP_FANOUT_SIZE; }
@Test public void testLeave() throws Exception { List<GossipManager> nodes = startNodes(2); GossipManager m1 = nodes.get(0); GossipManager m2 = nodes.get(1); assertSame(GossipNodeStatus.UP, m1.status()); assertSame(GossipNodeStatus.UP, m2.status()); m2.leave(); say("Sorry Bro, I have to go..."); Update gos = m2.gossip().asUpdate(); assertNotNull(gos); assertEquals(m2.address(), gos.from()); assertEquals(m1.address(), gos.to()); assertEquals(2, gos.gossip().members().size()); assertTrue(gos.gossip().members().containsKey(m1.id())); assertTrue(gos.gossip().members().containsKey(m2.id())); assertSame(GossipNodeStatus.UP, gos.gossip().members().get(m1.id()).status()); assertSame(GossipNodeStatus.LEAVING, gos.gossip().members().get(m2.id()).status()); assertEquals(1, gos.gossip().seen().size()); assertTrue(gos.gossip().seen().contains(m2.id())); say("Well, ok, let me set you to DOWN state."); gos = m1.processUpdate(gos).asUpdate(); assertNotNull(gos); assertEquals(m1.address(), gos.from()); assertEquals(m2.address(), gos.to()); assertEquals(2, gos.gossip().members().size()); assertTrue(gos.gossip().members().containsKey(m1.id())); assertTrue(gos.gossip().members().containsKey(m2.id())); assertSame(GossipNodeStatus.UP, gos.gossip().members().get(m1.id()).status()); assertSame(GossipNodeStatus.DOWN, gos.gossip().members().get(m2.id()).status()); assertEquals(1, gos.gossip().seen().size()); assertTrue(gos.gossip().seen().contains(m1.id())); say("Ok, I'm in DOWN state."); gos = m2.processUpdate(gos).asUpdate(); assertNotNull(gos); assertEquals(m2.address(), gos.from()); assertEquals(m1.address(), gos.to()); assertEquals(2, gos.gossip().members().size()); assertTrue(gos.gossip().members().containsKey(m1.id())); assertTrue(gos.gossip().members().containsKey(m2.id())); assertSame(GossipNodeStatus.UP, gos.gossip().members().get(m1.id()).status()); assertSame(GossipNodeStatus.DOWN, gos.gossip().members().get(m2.id()).status()); assertEquals(2, gos.gossip().seen().size()); assertTrue(gos.gossip().seen().contains(m1.id())); assertTrue(gos.gossip().seen().contains(m2.id())); say("Before going, I'll confirm that I've seen it."); gos = m1.processUpdate(gos).asUpdate(); assertNotNull(gos); assertEquals(m1.address(), gos.from()); assertEquals(m2.address(), gos.to()); assertEquals(1, gos.gossip().members().size()); assertTrue(gos.gossip().members().containsKey(m1.id())); assertSame(GossipNodeStatus.UP, gos.gossip().members().get(m1.id()).status()); assertEquals(1, gos.gossip().seen().size()); assertTrue(gos.gossip().seen().contains(m1.id())); assertSame(GossipNodeStatus.UP, m1.status()); assertSame(GossipNodeStatus.DOWN, m2.status()); m2.leave(); assertSame(GossipNodeStatus.DOWN, m2.status()); UpdateBase dig = m2.gossip(); assertNotNull(dig); assertEquals(m2.address(), dig.from()); assertEquals(m1.address(), dig.to()); assertEquals(2, dig.gossipBase().membersInfo().size()); assertTrue(dig.gossipBase().membersInfo().containsKey(m1.id())); assertTrue(dig.gossipBase().membersInfo().containsKey(m2.id())); assertSame(GossipNodeStatus.UP, dig.gossipBase().membersInfo().get(m1.id()).status()); assertSame(GossipNodeStatus.DOWN, dig.gossipBase().membersInfo().get(m2.id()).status()); }
Gossip extends GossipBase { @Override public Set<ClusterNodeId> seen() { return seen; } Gossip(); Gossip( long epoch, Map<ClusterNodeId, GossipNodeState> members, Set<ClusterNodeId> removed, Set<ClusterNodeId> seen, int maxJoinOrder ); int maxJoinOrder(); Gossip maxJoinOrder(int maxJoinOrder); GossipNodeState member(ClusterNodeId id); Map<ClusterNodeId, GossipNodeState> members(); boolean hasMembers(); @Override Map<ClusterNodeId, ? extends GossipNodeInfoBase> membersInfo(); Stream<GossipNodeState> stream(); @Override long epoch(); @Override Set<ClusterNodeId> removed(); boolean isDown(ClusterNodeId id); Gossip merge(ClusterNodeId localNodeId, Gossip other); Gossip update(ClusterNodeId localNodeId, GossipNodeState modified); Gossip update(ClusterNodeId localNodeId, List<GossipNodeState> modified); Gossip purge(ClusterNodeId localNodeId, Set<ClusterNodeId> removed); @Override Set<ClusterNodeId> seen(); Gossip seen(ClusterNodeId localNodeId); Gossip seen(Collection<ClusterNodeId> newSeen); Gossip inheritSeen(ClusterNodeId localNodeId, GossipBase other); boolean isConvergent(); Set<ClusterNodeId> allSuspected(); boolean isCoordinator(ClusterNodeId localNode); ClusterNode coordinator(ClusterNodeId localNode); GossipSuspectView suspectView(); boolean isSuspected(ClusterNodeId id); @Override String toString(); }
@Test public void testSeen() throws Exception { GossipNodeState s1 = newState(GossipNodeStatus.UP); GossipNodeState s2 = newState(GossipNodeStatus.UP); GossipNodeState s3 = newState(GossipNodeStatus.UP); Gossip g1 = new Gossip() .update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); assertEquals(1, g1.seen().size()); assertTrue(g1.hasSeen(s1.id())); assertFalse(g1.hasSeen(s2.id())); assertFalse(g1.hasSeen(s3.id())); assertSame(g1, g1.seen(s1.id())); Gossip g2 = g1.seen(s2.id()); assertNotSame(g1, g2); assertEquals(2, g2.seen().size()); assertTrue(g2.hasSeen(s1.id())); assertTrue(g2.hasSeen(s2.id())); assertFalse(g1.hasSeen(s3.id())); Gossip g3 = g2.seen(toSet(s1.id(), s2.id(), s3.id())); assertNotSame(g2, g3); assertEquals(3, g3.seen().size()); assertTrue(g3.hasSeen(s1.id())); assertTrue(g3.hasSeen(s2.id())); assertTrue(g3.hasSeen(s3.id())); assertTrue(g3.hasSeenAll(toSet(s1.id(), s2.id(), s3.id()))); assertFalse(g3.hasSeenAll(toSet(s1.id(), s2.id(), s3.id(), newNodeId()))); assertSame(g3, g3.seen(toSet(s1.id(), s2.id(), s3.id()))); }
Gossip extends GossipBase { public Gossip update(ClusterNodeId localNodeId, GossipNodeState modified) { return update(localNodeId, singletonList(modified)); } Gossip(); Gossip( long epoch, Map<ClusterNodeId, GossipNodeState> members, Set<ClusterNodeId> removed, Set<ClusterNodeId> seen, int maxJoinOrder ); int maxJoinOrder(); Gossip maxJoinOrder(int maxJoinOrder); GossipNodeState member(ClusterNodeId id); Map<ClusterNodeId, GossipNodeState> members(); boolean hasMembers(); @Override Map<ClusterNodeId, ? extends GossipNodeInfoBase> membersInfo(); Stream<GossipNodeState> stream(); @Override long epoch(); @Override Set<ClusterNodeId> removed(); boolean isDown(ClusterNodeId id); Gossip merge(ClusterNodeId localNodeId, Gossip other); Gossip update(ClusterNodeId localNodeId, GossipNodeState modified); Gossip update(ClusterNodeId localNodeId, List<GossipNodeState> modified); Gossip purge(ClusterNodeId localNodeId, Set<ClusterNodeId> removed); @Override Set<ClusterNodeId> seen(); Gossip seen(ClusterNodeId localNodeId); Gossip seen(Collection<ClusterNodeId> newSeen); Gossip inheritSeen(ClusterNodeId localNodeId, GossipBase other); boolean isConvergent(); Set<ClusterNodeId> allSuspected(); boolean isCoordinator(ClusterNodeId localNode); ClusterNode coordinator(ClusterNodeId localNode); GossipSuspectView suspectView(); boolean isSuspected(ClusterNodeId id); @Override String toString(); }
@Test public void testCompareByState() throws Exception { Gossip g1 = new Gossip(); Gossip g2 = new Gossip(); GossipNodeState s1 = newState(GossipNodeStatus.JOINING); GossipNodeState s2 = newState(GossipNodeStatus.JOINING); GossipNodeState s3 = newState(GossipNodeStatus.JOINING); assertSame(GossipPrecedence.SAME, g1.compare(g2)); g1 = g1.update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); g2 = g2.update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); assertSame(GossipPrecedence.SAME, g1.compare(g2)); g2 = g2.update(s1.id(), s1.status(GossipNodeStatus.UP)); assertSame(GossipPrecedence.BEFORE, g1.compare(g2)); assertSame(GossipPrecedence.AFTER, g2.compare(g1)); assertSame(GossipPrecedence.CONCURRENT, g1.update(s1.id(), s2.status(GossipNodeStatus.UP)).compare(g2)); assertSame(GossipPrecedence.CONCURRENT, g2.compare(g1.update(s1.id(), s2.status(GossipNodeStatus.UP)))); g1 = g1.update(s1.id(), s1.status(GossipNodeStatus.UP)); assertSame(GossipPrecedence.SAME, g1.compare(g2)); assertSame(GossipPrecedence.SAME, g2.compare(g1)); } @Test public void testCompareByMembers() throws Exception { Gossip g1 = new Gossip(); Gossip g2 = new Gossip(); GossipNodeState s1 = newState(GossipNodeStatus.JOINING); GossipNodeState s2 = newState(GossipNodeStatus.JOINING); GossipNodeState s3 = newState(GossipNodeStatus.JOINING); GossipNodeState s4 = newState(GossipNodeStatus.JOINING); assertSame(GossipPrecedence.SAME, g1.compare(g2)); g1 = g1.update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); g2 = g2.update(s1.id(), s1) .update(s1.id(), s2); assertSame(GossipPrecedence.AFTER, g1.compare(g2)); assertSame(GossipPrecedence.BEFORE, g2.compare(g1)); g2 = g2.update(s1.id(), s4); assertSame(GossipPrecedence.CONCURRENT, g1.compare(g2)); assertSame(GossipPrecedence.CONCURRENT, g2.compare(g1)); } @Test public void testCompareBySuspected() throws Exception { Gossip g1 = new Gossip(); Gossip g2 = new Gossip(); GossipNodeState s1 = newState(GossipNodeStatus.JOINING); GossipNodeState s2 = newState(GossipNodeStatus.JOINING); GossipNodeState s3 = newState(GossipNodeStatus.JOINING); g1 = g1.update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); g2 = g2.update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); assertSame(GossipPrecedence.SAME, g1.compare(g2)); g2 = g2.update(s1.id(), s1.suspect(s2.id())); assertSame(GossipPrecedence.BEFORE, g1.compare(g2)); assertSame(GossipPrecedence.AFTER, g2.compare(g1)); assertSame(GossipPrecedence.CONCURRENT, g1.update(s1.id(), s2.suspect(s1.id())).compare(g2)); assertSame(GossipPrecedence.CONCURRENT, g2.compare(g1.update(s1.id(), s2.suspect(s1.id())))); }
Gossip extends GossipBase { public Gossip purge(ClusterNodeId localNodeId, Set<ClusterNodeId> removed) { Set<ClusterNodeId> newSeen = new HashSet<>(); newSeen.add(localNodeId); members.values().forEach(m -> { if (m.status().isTerminated() && !removed.contains(m.id()) && hasSeen(m.id())) { newSeen.add(m.id()); } }); Map<ClusterNodeId, GossipNodeState> newMembers = new HashMap<>(members); GossipNodeState localNodeState = newMembers.get(localNodeId); localNodeState = localNodeState.unsuspect(removed); newMembers.put(localNodeId, localNodeState); newMembers.keySet().removeAll(removed); Set<ClusterNodeId> newRemoved = new HashSet<>(removed); newRemoved = unmodifiableSet(newRemoved); newMembers = unmodifiableMap(newMembers); return new Gossip(epoch + 1, newMembers, newRemoved, newSeen, maxJoinOrder); } Gossip(); Gossip( long epoch, Map<ClusterNodeId, GossipNodeState> members, Set<ClusterNodeId> removed, Set<ClusterNodeId> seen, int maxJoinOrder ); int maxJoinOrder(); Gossip maxJoinOrder(int maxJoinOrder); GossipNodeState member(ClusterNodeId id); Map<ClusterNodeId, GossipNodeState> members(); boolean hasMembers(); @Override Map<ClusterNodeId, ? extends GossipNodeInfoBase> membersInfo(); Stream<GossipNodeState> stream(); @Override long epoch(); @Override Set<ClusterNodeId> removed(); boolean isDown(ClusterNodeId id); Gossip merge(ClusterNodeId localNodeId, Gossip other); Gossip update(ClusterNodeId localNodeId, GossipNodeState modified); Gossip update(ClusterNodeId localNodeId, List<GossipNodeState> modified); Gossip purge(ClusterNodeId localNodeId, Set<ClusterNodeId> removed); @Override Set<ClusterNodeId> seen(); Gossip seen(ClusterNodeId localNodeId); Gossip seen(Collection<ClusterNodeId> newSeen); Gossip inheritSeen(ClusterNodeId localNodeId, GossipBase other); boolean isConvergent(); Set<ClusterNodeId> allSuspected(); boolean isCoordinator(ClusterNodeId localNode); ClusterNode coordinator(ClusterNodeId localNode); GossipSuspectView suspectView(); boolean isSuspected(ClusterNodeId id); @Override String toString(); }
@Test public void testPurge() throws Exception { GossipNodeState s1 = newState(GossipNodeStatus.UP); GossipNodeState s2 = newState(GossipNodeStatus.UP); GossipNodeState s3 = newState(GossipNodeStatus.UP); Gossip g1 = new Gossip() .update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3) .seen(s2.id()) .seen(s3.id()); long epoch1 = g1.epoch(); g1 = g1.purge(s1.id(), toSet(s2.id())); assertEquals(epoch1 + 1, g1.epoch()); assertEquals(2, g1.members().size()); assertFalse(g1.hasMember(s2.id())); assertFalse(g1.hasSeen(s2.id())); assertTrue(g1.removed().contains(s2.id())); long epoch2 = g1.epoch(); g1 = g1.purge(s1.id(), toSet(s3.id())); assertEquals(epoch2 + 1, g1.epoch()); assertEquals(1, g1.members().size()); assertFalse(g1.hasMember(s3.id())); assertFalse(g1.hasSeen(s3.id())); assertTrue(g1.removed().contains(s3.id())); assertFalse(g1.removed().contains(s2.id())); }
Gossip extends GossipBase { public boolean isDown(ClusterNodeId id) { GossipNodeState member = member(id); return (member != null && member.status().isTerminated()) || removed.contains(id); } Gossip(); Gossip( long epoch, Map<ClusterNodeId, GossipNodeState> members, Set<ClusterNodeId> removed, Set<ClusterNodeId> seen, int maxJoinOrder ); int maxJoinOrder(); Gossip maxJoinOrder(int maxJoinOrder); GossipNodeState member(ClusterNodeId id); Map<ClusterNodeId, GossipNodeState> members(); boolean hasMembers(); @Override Map<ClusterNodeId, ? extends GossipNodeInfoBase> membersInfo(); Stream<GossipNodeState> stream(); @Override long epoch(); @Override Set<ClusterNodeId> removed(); boolean isDown(ClusterNodeId id); Gossip merge(ClusterNodeId localNodeId, Gossip other); Gossip update(ClusterNodeId localNodeId, GossipNodeState modified); Gossip update(ClusterNodeId localNodeId, List<GossipNodeState> modified); Gossip purge(ClusterNodeId localNodeId, Set<ClusterNodeId> removed); @Override Set<ClusterNodeId> seen(); Gossip seen(ClusterNodeId localNodeId); Gossip seen(Collection<ClusterNodeId> newSeen); Gossip inheritSeen(ClusterNodeId localNodeId, GossipBase other); boolean isConvergent(); Set<ClusterNodeId> allSuspected(); boolean isCoordinator(ClusterNodeId localNode); ClusterNode coordinator(ClusterNodeId localNode); GossipSuspectView suspectView(); boolean isSuspected(ClusterNodeId id); @Override String toString(); }
@Test public void testIsDown() throws Exception { GossipNodeState s1 = newState(GossipNodeStatus.UP); GossipNodeState s2 = newState(GossipNodeStatus.UP); GossipNodeState s3 = newState(GossipNodeStatus.DOWN); Gossip g = new Gossip() .update(s1.id(), s1) .update(s1.id(), s2) .update(s1.id(), s3); assertFalse(g.isDown(s1.id())); assertFalse(g.isDown(s2.id())); assertTrue(g.isDown(s3.id())); g = g.purge(s1.id(), singleton(s3.id())); assertFalse(g.members().containsKey(s3.id())); assertFalse(g.isDown(s1.id())); assertFalse(g.isDown(s2.id())); assertTrue(g.isDown(s3.id())); }
GossipNodeState extends GossipNodeInfoBase implements Comparable<GossipNodeState> { public GossipNodeState merge(GossipNodeState other) { if (status != other.status || version != other.version) { GossipNodeStatus newStatus; long newVersion; Set<ClusterNodeId> newSuspected; ClusterNode newNode; if (status.compareTo(other.status) >= 0) { newStatus = status; newNode = node; } else { newStatus = other.status; newNode = other.node; } if (version >= other.version) { newVersion = version; newSuspected = suspected; } else { newVersion = other.version; newSuspected = other.suspected; } return new GossipNodeState(newNode, newStatus, newVersion, newSuspected); } else { return this; } } GossipNodeState(ClusterNode node, GossipNodeStatus status); GossipNodeState(ClusterNode node, GossipNodeStatus status, long version, Set<ClusterNodeId> suspected); @Override ClusterNodeId id(); @Override long version(); ClusterNode node(); ClusterAddress address(); GossipNodeState merge(GossipNodeState other); @Override GossipNodeStatus status(); GossipNodeState status(GossipNodeStatus newStatus); int order(); GossipNodeState order(int order); Set<ClusterNodeId> suspected(); GossipNodeState suspect(ClusterNodeId suspected); GossipNodeState suspect(Set<ClusterNodeId> suspected); GossipNodeState unsuspect(ClusterNodeId removed); GossipNodeState unsuspect(Set<ClusterNodeId> unsuspected); boolean isSuspected(ClusterNodeId id); boolean hasSuspected(); @Override int compareTo(GossipNodeState o); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testMerge() throws Exception { GossipNodeState s1 = new GossipNodeState(newNode(), GossipNodeStatus.JOINING); GossipNodeState s2 = new GossipNodeState(newNode(), GossipNodeStatus.UP); s1 = s1.suspect(newNodeId()); assertSame(GossipPrecedence.CONCURRENT, s1.compare(s2)); assertSame(GossipPrecedence.CONCURRENT, s2.compare(s1)); GossipNodeState s3 = s1.merge(s2); assertSame(GossipPrecedence.BEFORE, s1.compare(s3)); assertSame(GossipPrecedence.BEFORE, s2.compare(s3)); assertSame(GossipPrecedence.AFTER, s3.compare(s1)); assertSame(GossipPrecedence.AFTER, s3.compare(s2)); assertSame(GossipNodeStatus.UP, s3.status()); assertEquals(s1.suspected(), s3.suspected()); GossipNodeState s4 = s2.merge(s3); assertSame(GossipPrecedence.BEFORE, s1.compare(s4)); assertSame(GossipPrecedence.BEFORE, s2.compare(s4)); assertSame(GossipPrecedence.AFTER, s4.compare(s1)); assertSame(GossipPrecedence.AFTER, s4.compare(s2)); assertSame(GossipNodeStatus.UP, s4.status()); assertEquals(s1.suspected(), s4.suspected()); }
GossipNodeState extends GossipNodeInfoBase implements Comparable<GossipNodeState> { @Override public GossipNodeStatus status() { return status; } GossipNodeState(ClusterNode node, GossipNodeStatus status); GossipNodeState(ClusterNode node, GossipNodeStatus status, long version, Set<ClusterNodeId> suspected); @Override ClusterNodeId id(); @Override long version(); ClusterNode node(); ClusterAddress address(); GossipNodeState merge(GossipNodeState other); @Override GossipNodeStatus status(); GossipNodeState status(GossipNodeStatus newStatus); int order(); GossipNodeState order(int order); Set<ClusterNodeId> suspected(); GossipNodeState suspect(ClusterNodeId suspected); GossipNodeState suspect(Set<ClusterNodeId> suspected); GossipNodeState unsuspect(ClusterNodeId removed); GossipNodeState unsuspect(Set<ClusterNodeId> unsuspected); boolean isSuspected(ClusterNodeId id); boolean hasSuspected(); @Override int compareTo(GossipNodeState o); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testUpdateState() throws Exception { GossipNodeState s1 = new GossipNodeState(newNode(), GossipNodeStatus.JOINING); assertSame(GossipNodeStatus.JOINING, s1.status()); GossipNodeState s2 = s1.status(GossipNodeStatus.JOINING); assertSame(s1, s2); assertSame(GossipNodeStatus.JOINING, s1.status()); GossipNodeState s3 = s1.status(GossipNodeStatus.UP); assertNotSame(s1, s3); assertSame(GossipNodeStatus.UP, s3.status()); }
SplitBrainManager implements ConfigReportSupport { public void checkAsync() { if (hasDetector()) { guard.withReadLockIfInitialized(() -> { if (active.compareAndSet(false, true)) { runAsync(() -> { try { guard.withReadLockIfInitialized(() -> { if (!actionApplied.get()) { if (DEBUG) { log.debug("Checking for cluster split-brain [detector={}]", detector); } if (!detector.isValid(localNode)) { if (actionApplied.compareAndSet(false, true)) { if (log.isWarnEnabled()) { log.warn("Split-brain detected."); } applyAction(); } } } }); } finally { active.compareAndSet(true, false); } }); } }); } } SplitBrainManager(SplitBrainAction action, long checkInterval, SplitBrainDetector detector); @Override void report(ConfigReporter report); long checkInterval(); boolean hasDetector(); SplitBrainDetector detector(); SplitBrainAction action(); void initialize(ClusterNode localNode, Executor async, Callback callback); void terminate(); boolean check(); void checkAsync(); void applyAction(); @Override String toString(); }
@Test public void testCheckAsync() throws Exception { SplitBrainDetector detector = mock(SplitBrainDetector.class); Callback callback = mock(Callback.class); SplitBrainManager mgr = new SplitBrainManager(SplitBrainAction.TERMINATE, 0, detector); mgr.initialize(newNode(), Runnable::run, callback); when(detector.isValid(any())).thenReturn(false); mgr.checkAsync(); verify(callback).terminate(); }
SplitBrainManager implements ConfigReportSupport { @Override public String toString() { return ToString.format(this); } SplitBrainManager(SplitBrainAction action, long checkInterval, SplitBrainDetector detector); @Override void report(ConfigReporter report); long checkInterval(); boolean hasDetector(); SplitBrainDetector detector(); SplitBrainAction action(); void initialize(ClusterNode localNode, Executor async, Callback callback); void terminate(); boolean check(); void checkAsync(); void applyAction(); @Override String toString(); }
@Test public void testToString() { SplitBrainManager mgr = new SplitBrainManager(SplitBrainAction.TERMINATE, 0, mock(SplitBrainDetector.class)); assertEquals(ToString.format(mgr), mgr.toString()); }
UpdatableClusterView implements ClusterView { public static UpdatableClusterView empty() { return new UpdatableClusterView(ClusterTopology.empty()); } protected UpdatableClusterView(ClusterTopology topology); static UpdatableClusterView of(ClusterTopology topology); static UpdatableClusterView of(int version, ClusterNode node); static UpdatableClusterView of(int version, Set<ClusterNode> nodes); static UpdatableClusterView empty(); void update(ClusterTopology topology); @Override ClusterView filterAll(ClusterFilter filter); @Override ClusterTopology topology(); @Override void addListener(ClusterEventListener listener); @Override void addListener(ClusterEventListener listener, ClusterEventType... eventTypes); @Override void removeListener(ClusterEventListener listener); @Override T topologyContext(Function<ClusterTopology, T> supplier); @Override CompletableFuture<ClusterTopology> futureOf(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate, long timeout, TimeUnit timeUnit); @Override String toString(); }
@Test public void testEmpty() { UpdatableClusterView view = UpdatableClusterView.empty(); assertTrue(view.topology().isEmpty()); assertEquals(0, view.topology().version()); }
UpdatableClusterView implements ClusterView { public void update(ClusterTopology topology) { ArgAssert.notNull(topology, "Topology"); TOPOLOGY.accumulateAndGet(this, topology, (oldTopology, newTopology) -> newTopology.version() > oldTopology.version() ? newTopology : oldTopology ); } protected UpdatableClusterView(ClusterTopology topology); static UpdatableClusterView of(ClusterTopology topology); static UpdatableClusterView of(int version, ClusterNode node); static UpdatableClusterView of(int version, Set<ClusterNode> nodes); static UpdatableClusterView empty(); void update(ClusterTopology topology); @Override ClusterView filterAll(ClusterFilter filter); @Override ClusterTopology topology(); @Override void addListener(ClusterEventListener listener); @Override void addListener(ClusterEventListener listener, ClusterEventType... eventTypes); @Override void removeListener(ClusterEventListener listener); @Override T topologyContext(Function<ClusterTopology, T> supplier); @Override CompletableFuture<ClusterTopology> futureOf(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate, long timeout, TimeUnit timeUnit); @Override String toString(); }
@Test public void testUpdate() throws Exception { UpdatableClusterView view = UpdatableClusterView.empty(); ClusterTopology t1 = ClusterTopology.of(1, toSet(newNode(), newNode())); ClusterTopology t1SameVer = ClusterTopology.of(1, toSet(newNode(), newNode())); ClusterTopology t2 = ClusterTopology.of(2, toSet(newNode(), newNode())); view.update(t1); assertSame(t1, view.topology()); view.update(t1SameVer); assertSame(t1, view.topology()); view.update(t2); assertSame(t2, view.topology()); view.update(t1); assertSame(t2, view.topology()); }
UpdatableClusterView implements ClusterView { @Override public <T> T topologyContext(Function<ClusterTopology, T> supplier) { return ctxCache.get(topology(), supplier); } protected UpdatableClusterView(ClusterTopology topology); static UpdatableClusterView of(ClusterTopology topology); static UpdatableClusterView of(int version, ClusterNode node); static UpdatableClusterView of(int version, Set<ClusterNode> nodes); static UpdatableClusterView empty(); void update(ClusterTopology topology); @Override ClusterView filterAll(ClusterFilter filter); @Override ClusterTopology topology(); @Override void addListener(ClusterEventListener listener); @Override void addListener(ClusterEventListener listener, ClusterEventType... eventTypes); @Override void removeListener(ClusterEventListener listener); @Override T topologyContext(Function<ClusterTopology, T> supplier); @Override CompletableFuture<ClusterTopology> futureOf(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate, long timeout, TimeUnit timeUnit); @Override String toString(); }
@Test public void testTopologyContext() throws Exception { ClusterTopology t1 = ClusterTopology.of(1, toSet(newNode())); ClusterTopology t2 = ClusterTopology.of(2, toSet(newNode())); ClusterTopology t3 = ClusterTopology.of(3, toSet(newNode())); UpdatableClusterView view = UpdatableClusterView.of(t1); Function<ClusterTopology, Object> supplier = top -> new Object(); Object o1 = view.topologyContext(supplier); assertSame(o1, view.topologyContext(supplier)); view.update(t2); Object o2 = view.topologyContext(supplier); assertSame(o2, view.topologyContext(supplier)); assertNotSame(o1, o2); view.update(t3); Object o3 = view.topologyContext(supplier); assertSame(o3, view.topologyContext(supplier)); assertNotSame(o1, o3); assertNotSame(o2, o3); }
UpdatableClusterView implements ClusterView { @Override public String toString() { return ToString.format(this); } protected UpdatableClusterView(ClusterTopology topology); static UpdatableClusterView of(ClusterTopology topology); static UpdatableClusterView of(int version, ClusterNode node); static UpdatableClusterView of(int version, Set<ClusterNode> nodes); static UpdatableClusterView empty(); void update(ClusterTopology topology); @Override ClusterView filterAll(ClusterFilter filter); @Override ClusterTopology topology(); @Override void addListener(ClusterEventListener listener); @Override void addListener(ClusterEventListener listener, ClusterEventType... eventTypes); @Override void removeListener(ClusterEventListener listener); @Override T topologyContext(Function<ClusterTopology, T> supplier); @Override CompletableFuture<ClusterTopology> futureOf(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate); @Override boolean awaitFor(Predicate<ClusterTopology> predicate, long timeout, TimeUnit timeUnit); @Override String toString(); }
@Test public void testToString() { UpdatableClusterView view = UpdatableClusterView.empty(); assertEquals(ToString.format(view), view.toString()); }
JdbcConnectivityDetector implements SplitBrainDetector, ConfigReportSupport { @Override public boolean isValid(ClusterNode localNode) { try (Connection conn = ds.getConnection()) { boolean valid = conn.isValid(timeout); if (valid) { if (DEBUG) { log.debug("JDBC reachability check successful [datasource={}]", ds); } } else { if (log.isWarnEnabled()) { log.warn("JDBC reachability check failed [datasource={}, timeout={}]", ds, timeout); } } return valid; } catch (SQLException e) { if (log.isWarnEnabled()) { log.warn("JDBC reachability check failed [datasource={}, timeout={}, cause={}]", ds, timeout, e.toString()); } return false; } } JdbcConnectivityDetector(DataSource ds, int timeout); @Override void report(ConfigReporter report); DataSource datasource(); int timeout(); @Override boolean isValid(ClusterNode localNode); @Override String toString(); }
@Test public void testIsValidTrue() throws Exception { DataSource ds = mock(DataSource.class); Connection conn = mock(Connection.class); when(ds.getConnection()).thenReturn(conn); when(conn.isValid(100500)).thenReturn(true); JdbcConnectivityDetector detector = new JdbcConnectivityDetector(ds, 100500); assertTrue(detector.isValid(newNode())); InOrder order = inOrder(ds, conn); order.verify(ds).getConnection(); order.verify(conn).isValid(100500); order.verify(conn).close(); verifyNoMoreInteractions(ds, conn); } @Test public void testIsValidFalse() throws Exception { DataSource ds = mock(DataSource.class); Connection conn = mock(Connection.class); when(ds.getConnection()).thenReturn(conn); when(conn.isValid(100500)).thenReturn(false); JdbcConnectivityDetector detector = new JdbcConnectivityDetector(ds, 100500); assertFalse(detector.isValid(newNode())); InOrder order = inOrder(ds, conn); order.verify(ds).getConnection(); order.verify(conn).isValid(100500); order.verify(conn).close(); verifyNoMoreInteractions(ds, conn); } @Test public void testIsValidError() throws Exception { DataSource ds = mock(DataSource.class); Connection conn = mock(Connection.class); when(ds.getConnection()).thenReturn(conn); when(conn.isValid(100500)).thenThrow(new SQLException(HekateTestError.MESSAGE)); JdbcConnectivityDetector detector = new JdbcConnectivityDetector(ds, 100500); assertFalse(detector.isValid(newNode())); InOrder order = inOrder(ds, conn); order.verify(ds).getConnection(); order.verify(conn).isValid(100500); order.verify(conn).close(); verifyNoMoreInteractions(ds, conn); } @Test public void testGetConnectionError() throws Exception { DataSource ds = mock(DataSource.class); when(ds.getConnection()).thenThrow(SQLException.class); JdbcConnectivityDetector detector = new JdbcConnectivityDetector(ds, 1); assertFalse(detector.isValid(newNode())); InOrder order = inOrder(ds); order.verify(ds).getConnection(); verifyNoMoreInteractions(ds); }
JdbcConnectivityDetector implements SplitBrainDetector, ConfigReportSupport { @Override public String toString() { return ToString.format(this); } JdbcConnectivityDetector(DataSource ds, int timeout); @Override void report(ConfigReporter report); DataSource datasource(); int timeout(); @Override boolean isValid(ClusterNode localNode); @Override String toString(); }
@Test public void testToString() { JdbcConnectivityDetector detector = new JdbcConnectivityDetector(mock(DataSource.class), 1); assertEquals(ToString.format(detector), detector.toString()); }
SplitBrainDetectorGroup implements SplitBrainDetector, ConfigReportSupport { public void setDetectors(List<SplitBrainDetector> detectors) { this.detectors = detectors; } @Override boolean isValid(ClusterNode localNode); @Override void report(ConfigReporter report); List<SplitBrainDetector> getDetectors(); void setDetectors(List<SplitBrainDetector> detectors); SplitBrainDetectorGroup withDetector(SplitBrainDetector detector); GroupPolicy getGroupPolicy(); void setGroupPolicy(GroupPolicy groupPolicy); SplitBrainDetectorGroup withGroupPolicy(GroupPolicy groupPolicy); @Override String toString(); }
@Test public void testSetDetectors() { assertNull(group.getDetectors()); SplitBrainDetectorMock d1 = new SplitBrainDetectorMock(true); SplitBrainDetectorMock d2 = new SplitBrainDetectorMock(true); group.setDetectors(asList(d1, d2)); assertEquals(2, group.getDetectors().size()); assertTrue(group.getDetectors().contains(d1)); assertTrue(group.getDetectors().contains(d2)); group.setDetectors(null); assertNull(group.getDetectors()); assertSame(group, group.withDetector(d1)); assertEquals(1, group.getDetectors().size()); assertTrue(group.getDetectors().contains(d1)); }
AddressReachabilityDetector implements SplitBrainDetector, ConfigReportSupport { @Override public boolean isValid(ClusterNode localNode) { try (Socket socket = new Socket()) { InetAddress resolvedHost = InetAddress.getByName(address.getHostString()); InetSocketAddress resolvedAddress = new InetSocketAddress(resolvedHost, address.getPort()); socket.connect(resolvedAddress, timeout); if (DEBUG) { log.debug("Address reachability check success [host={}, timeout={}]", address, timeout); } return true; } catch (IOException e) { if (log.isWarnEnabled()) { log.warn("Address reachability check failed [host={}, timeout={}, error={}]", address, timeout, e.toString()); } } return false; } AddressReachabilityDetector(String address); AddressReachabilityDetector(String address, int timeout); AddressReachabilityDetector(InetSocketAddress address, int timeout); @Override void report(ConfigReporter report); InetSocketAddress address(); int timeout(); @Override boolean isValid(ClusterNode localNode); @Override String toString(); static final int DEFAULT_TIMEOUT; }
@Test public void testValid() throws Exception { HekateTestNode node = createNode().join(); InetSocketAddress address = node.localNode().socket(); AddressReachabilityDetector detector = new AddressReachabilityDetector(address, 2000); assertTrue(detector.isValid(node.localNode())); detector = new AddressReachabilityDetector(address.getHostString() + ':' + address.getPort()); assertTrue(detector.isValid(node.localNode())); } @Test public void testInvalid() throws Exception { AddressReachabilityDetector detector = new AddressReachabilityDetector("localhost:12345", 2000); assertFalse(detector.isValid(newNode())); }
HostReachabilityDetector implements SplitBrainDetector, ConfigReportSupport { @Override public boolean isValid(ClusterNode localNode) { try { InetAddress address = InetAddress.getByName(host); boolean reachable = address.isReachable(timeout); if (reachable) { if (DEBUG) { log.debug("Address reachability check success [host={}, timeout={}]", host, timeout); } } else { if (log.isWarnEnabled()) { log.warn("Address reachability check failed [host={}, timeout={}]", host, timeout); } } return reachable; } catch (IOException e) { if (log.isWarnEnabled()) { log.warn("Address reachability check failed with an error [host={}, timeout={}, cause={}]", host, timeout, e.toString()); } } return false; } HostReachabilityDetector(String host); HostReachabilityDetector(String host, int timeout); @Override void report(ConfigReporter report); String host(); int timeout(); @Override boolean isValid(ClusterNode localNode); @Override String toString(); static final int DEFAULT_TIMEOUT; }
@Test public void testValid() throws Exception { HostReachabilityDetector detector = new HostReachabilityDetector(InetAddress.getLocalHost().getHostAddress(), 2000); assertTrue(detector.isValid(newNode())); } @Test public void testInvalid() throws Exception { HostReachabilityDetector detector = new HostReachabilityDetector("some.invalid.host", 2000); assertFalse(detector.isValid(newNode())); }
KubernetesSeedNodeProviderConfig { @Override public String toString() { return ToString.format(this); } String getContainerPortName(); void setContainerPortName(String containerPortName); KubernetesSeedNodeProviderConfig withContainerPortName(String containerPortName); String getNamespace(); void setNamespace(String namespace); KubernetesSeedNodeProviderConfig withNamespace(String namespace); String getMasterUrl(); void setMasterUrl(String masterUrl); KubernetesSeedNodeProviderConfig withMasterUrl(String masterUrl); Boolean getTrustCertificates(); void setTrustCertificates(Boolean trustCertificates); KubernetesSeedNodeProviderConfig withTrustCertificates(Boolean trustCertificates); @Override String toString(); static final String DEFAULT_CONTAINER_PORT_NAME; }
@Test public void testToString() { assertEquals(ToString.format(cfg), cfg.toString()); }
RpcServiceFactory extends MessagingConfigBase<RpcServiceFactory> implements ServiceFactory<RpcService> { @Override public String toString() { return ToString.format(this); } List<RpcClientConfig> getClients(); void setClients(List<RpcClientConfig> clients); RpcServiceFactory withClient(RpcClientConfig client); List<RpcClientConfigProvider> getClientProviders(); void setClientProviders(List<RpcClientConfigProvider> clientProviders); RpcServiceFactory withClientProvider(RpcClientConfigProvider clientProvider); List<RpcServerConfig> getServers(); void setServers(List<RpcServerConfig> servers); RpcServiceFactory withServer(RpcServerConfig server); List<RpcServerConfigProvider> getServerProviders(); void setServerProviders(List<RpcServerConfigProvider> serverProviders); RpcServiceFactory withServerProvider(RpcServerConfigProvider serverProvider); int getWorkerThreads(); void setWorkerThreads(int workerThreads); RpcServiceFactory withWorkerThreads(int workerThreads); @Override RpcService createService(); @Override String toString(); }
@Test public void testToString() { assertEquals(ToString.format(factory), factory.toString()); }
RpcRetryInfo implements GenericRetryConfigurer { @Override public String toString() { return ToString.format(this); } private RpcRetryInfo( OptionalInt maxAttempts, OptionalLong delay, OptionalLong maxDelay, List<Class<? extends Throwable>> errors ); static RpcRetryInfo parse(RpcRetry retry, PlaceholderResolver resolver); OptionalInt maxAttempts(); OptionalLong delay(); OptionalLong maxDelay(); List<Class<? extends Throwable>> errors(); @Override void configure(RetryPolicy<?> retry); @Override String toString(); }
@Test public void testToString() { RpcRetryInfo info = buildInfo("", "", "", emptyList()); assertEquals(ToString.format(info), info.toString()); }
HekateSerializableClasses { public static SortedSet<Class<?>> get() { return CLASSES; } private HekateSerializableClasses(); static SortedSet<Class<?>> get(); }
@Test public void testKnownClasses() throws Exception { SortedSet<Class<?>> known = HekateSerializableClasses.get(); for (String name : scanForSerializableClasses()) { Class<?> clazz = Class.forName(name); assertTrue(clazz.getName(), known.contains(clazz)); } }
KryoCodec implements Codec<Object> { @Override public boolean isStateful() { return stateful; } KryoCodec(KryoCodecFactory<?> factory); @Override boolean isStateful(); @Override Class<Object> baseType(); @Override Object decode(DataReader in); @Override void encode(Object obj, DataWriter out); @Override String toString(); }
@Test public void testStateless() { assertEquals(factory.isCacheUnknownTypes(), factory.createCodec().isStateful()); }
ThreadLocalCodecFactory implements CodecFactory<T> { public static <T> CodecFactory<T> tryWrap(CodecFactory<T> factory) { ArgAssert.notNull(factory, "Codec factory is null."); if (factory instanceof ThreadLocalCodecFactory) { return factory; } Codec<T> probe = factory.createCodec(); if (probe.isStateful()) { return factory; } else { return new ThreadLocalCodecFactory<>(probe.baseType(), factory); } } private ThreadLocalCodecFactory(Class<T> baseType, CodecFactory<T> delegate); static CodecFactory<T> tryWrap(CodecFactory<T> factory); @SuppressWarnings("unchecked") static CodecFactory<T> tryUnwrap(CodecFactory<T> factory); @Override Codec<T> createCodec(); @Override String toString(); }
@Test public void testDoNotWrapIfAlreadyWrapped() { CodecFactory<Object> wrap = ThreadLocalCodecFactory.tryWrap(factoryMock); assertTrue(wrap instanceof ThreadLocalCodecFactory); assertSame(wrap, ThreadLocalCodecFactory.tryWrap(wrap)); } @Test public void testDoNotWrapIfStatefulCodec() { when(codecMock.isStateful()).thenReturn(true); CodecFactory<Object> wrap = ThreadLocalCodecFactory.tryWrap(factoryMock); assertSame(factoryMock, wrap); }
ThreadLocalCodecFactory implements CodecFactory<T> { @Override public String toString() { return ThreadLocalCodecFactory.class.getSimpleName() + "[delegate=" + delegate + ']'; } private ThreadLocalCodecFactory(Class<T> baseType, CodecFactory<T> delegate); static CodecFactory<T> tryWrap(CodecFactory<T> factory); @SuppressWarnings("unchecked") static CodecFactory<T> tryUnwrap(CodecFactory<T> factory); @Override Codec<T> createCodec(); @Override String toString(); }
@Test public void testToString() { CodecFactory<Object> factory = ThreadLocalCodecFactory.tryWrap(factoryMock); assertEquals(ThreadLocalCodecFactory.class.getSimpleName() + "[delegate=" + factoryMock + ']', factory.toString()); }
CloudStoreSeedNodeProviderConfig extends CloudPropertiesBase<CloudStoreSeedNodeProviderConfig> { @Override public String toString() { return ToString.format(this); } String getProvider(); void setProvider(String provider); CloudStoreSeedNodeProviderConfig withProvider(String provider); CredentialsSupplier getCredentials(); void setCredentials(CredentialsSupplier credentials); CloudStoreSeedNodeProviderConfig withCredentials(CredentialsSupplier credentials); Properties getProperties(); void setProperties(Properties properties); CloudStoreSeedNodeProviderConfig withProperty(String key, String value); long getCleanupInterval(); void setCleanupInterval(long cleanupInterval); CloudStoreSeedNodeProviderConfig withCleanupInterval(long cleanupInterval); String getContainer(); void setContainer(String container); CloudStoreSeedNodeProviderConfig withContainer(String container); @Override String toString(); static final long DEFAULT_CLEANUP_INTERVAL; }
@Test public void testToString() { assertEquals(ToString.format(cfg), cfg.toString()); }
JdkCodec implements Codec<Object> { @Override public boolean isStateful() { return false; } @Override boolean isStateful(); @Override Class<Object> baseType(); @Override Object decode(DataReader in); @Override void encode(Object message, DataWriter out); @Override String toString(); }
@Test public void testStateless() { assertFalse(factory.createCodec().isStateful()); }
FstCodec implements Codec<Object> { @Override public boolean isStateful() { return false; } FstCodec(FSTConfiguration fst); @Override boolean isStateful(); @Override Class<Object> baseType(); @Override void encode(Object obj, DataWriter out); @Override Object decode(DataReader in); @Override String toString(); }
@Test public void testStateless() { assertFalse(factory.createCodec().isStateful()); }
AutoSelectCodecFactory implements CodecFactory<T> { public CodecFactory<T> selected() { return factory; } AutoSelectCodecFactory(); static boolean isKryoAvailable(); static boolean isFstAvailable(); CodecFactory<T> selected(); @Override Codec<T> createCodec(); @Override String toString(); }
@Test public void testKryo() throws Exception { AutoSelectCodecFactory<Object> factory = new AutoSelectCodecFactory<>(); assertEquals(KryoCodecFactory.class, factory.selected().getClass()); } @Test public void testFst() throws Exception { ClassLoader oldLoader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(new ExclusiveClassLoader(singletonList(KRYO_CLASS), oldLoader)); AutoSelectCodecFactory<Object> factory = new AutoSelectCodecFactory<>(); assertEquals(FstCodecFactory.class, factory.selected().getClass()); } finally { Thread.currentThread().setContextClassLoader(oldLoader); } } @Test public void testJdk() throws Exception { ClassLoader oldLoader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(new ExclusiveClassLoader(asList(KRYO_CLASS, FST_CLASS), oldLoader)); AutoSelectCodecFactory<Object> factory = new AutoSelectCodecFactory<>(); assertEquals(JdkCodecFactory.class, factory.selected().getClass()); } finally { Thread.currentThread().setContextClassLoader(oldLoader); } }
AutoSelectCodecFactory implements CodecFactory<T> { @Override public String toString() { return ToString.format(this); } AutoSelectCodecFactory(); static boolean isKryoAvailable(); static boolean isFstAvailable(); CodecFactory<T> selected(); @Override Codec<T> createCodec(); @Override String toString(); }
@Test public void testToString() throws Exception { AutoSelectCodecFactory<Object> factory = new AutoSelectCodecFactory<>(); assertEquals(ToString.format(factory), factory.toString()); }
CoordinationProcessConfig { @Override public String toString() { return ToString.format(this); } CoordinationProcessConfig(); CoordinationProcessConfig(String name); String getName(); void setName(String name); CoordinationProcessConfig withName(String name); boolean isAsyncInit(); void setAsyncInit(boolean asyncInit); CoordinationProcessConfig withAsyncInit(boolean asyncInit); CoordinationHandler getHandler(); void setHandler(CoordinationHandler handler); CoordinationProcessConfig withHandler(CoordinationHandler handler); CodecFactory<Object> getMessageCodec(); void setMessageCodec(CodecFactory<Object> messageCodec); CoordinationProcessConfig withMessageCodec(CodecFactory<Object> messageCodec); @Override String toString(); }
@Test public void testToString() { assertEquals(ToString.format(cfg), cfg.toString()); }
CoordinationServiceFactory implements ServiceFactory<CoordinationService> { @Override public CoordinationService createService() { return new DefaultCoordinationService(this); } int getNioThreads(); void setNioThreads(int nioThreads); CoordinationServiceFactory withNioThreads(int nioThreads); long getRetryInterval(); void setRetryInterval(long retryInterval); CoordinationServiceFactory withRetryInterval(long retryInterval); List<CoordinationProcessConfig> getProcesses(); void setProcesses(List<CoordinationProcessConfig> processes); CoordinationServiceFactory withProcess(CoordinationProcessConfig process); CoordinationProcessConfig withProcess(String name); List<CoordinationConfigProvider> getConfigProviders(); void setConfigProviders(List<CoordinationConfigProvider> configProviders); CoordinationServiceFactory withConfigProvider(CoordinationConfigProvider configProvider); long getIdleSocketTimeout(); void setIdleSocketTimeout(long idleSocketTimeout); CoordinationServiceFactory withIdleSocketTimeout(long idleTimeout); @Override CoordinationService createService(); static final int DEFAULT_RETRY_INTERVAL; static final long DEFAULT_IDLE_SOCKET_TIMEOUT; }
@Test public void testCreateService() { assertNotNull(factory.createService()); }
CoordinationBroadcastAdaptor implements CoordinationRequestCallback { @Override public void onResponse(Object response, CoordinationMember from) { Map<CoordinationMember, Object> responsesCopy = null; synchronized (responses) { responses.put(from, response); if (responses.size() == expected) { responsesCopy = new HashMap<>(responses); } } if (responsesCopy != null && completed.compareAndSet(false, true)) { callback.onResponses(responsesCopy); } } CoordinationBroadcastAdaptor(int expectedResponses, CoordinationBroadcastCallback callback); @Override void onResponse(Object response, CoordinationMember from); @Override void onCancel(); }
@Test public void testOnResponses() throws Exception { repeat(3, i -> { int membersSize = i + 1; CoordinationBroadcastCallback callback = mock(CoordinationBroadcastCallback.class); CoordinationBroadcastAdaptor adaptor = new CoordinationBroadcastAdaptor(membersSize, callback); ArgumentCaptor<Map<CoordinationMember, Object>> captor = newResultCaptor(); List<CoordinationMember> members = new ArrayList<>(); for (int j = 0; j < membersSize; j++) { CoordinationMember member = mock(CoordinationMember.class); members.add(member); adaptor.onResponse("test" + j, member); } verify(callback).onResponses(captor.capture()); assertEquals(membersSize, captor.getValue().size()); for (int j = 0; j < membersSize; j++) { assertEquals("test" + j, captor.getValue().get(members.get(j))); } verifyNoMoreInteractions(callback); }); }
CoordinationBroadcastAdaptor implements CoordinationRequestCallback { @Override public void onCancel() { if (completed.compareAndSet(false, true)) { Map<CoordinationMember, Object> responsesCopy; synchronized (responses) { responsesCopy = new HashMap<>(responses); } callback.onCancel(responsesCopy); } } CoordinationBroadcastAdaptor(int expectedResponses, CoordinationBroadcastCallback callback); @Override void onResponse(Object response, CoordinationMember from); @Override void onCancel(); }
@Test public void testOnCancel() throws Exception { CoordinationBroadcastCallback callback = mock(CoordinationBroadcastCallback.class); CoordinationBroadcastAdaptor adaptor = new CoordinationBroadcastAdaptor(3, callback); ArgumentCaptor<Map<CoordinationMember, Object>> captor = newResultCaptor(); adaptor.onCancel(); verify(callback).onCancel(captor.capture()); assertEquals(0, captor.getValue().size()); adaptor.onCancel(); adaptor.onCancel(); adaptor.onResponse("test", mock(CoordinationMember.class)); adaptor.onResponse("test", mock(CoordinationMember.class)); adaptor.onResponse("test", mock(CoordinationMember.class)); verifyNoMoreInteractions(callback); }
CloudSeedNodeProvider implements SeedNodeProvider, ConfigReportSupport { @Override public String toString() { return ToString.format(this); } CloudSeedNodeProvider(CloudSeedNodeProviderConfig cfg); @Override void report(ConfigReporter report); String provider(); String endpoint(); Properties properties(); @Override void startDiscovery(String cluster, InetSocketAddress node); @Override void stopDiscovery(String cluster, InetSocketAddress node); @Override List<InetSocketAddress> findSeedNodes(String cluster); @Override void suspendDiscovery(); @Override long cleanupInterval(); @Override void registerRemote(String cluster, InetSocketAddress node); @Override void unregisterRemote(String cluster, InetSocketAddress node); @Override String toString(); }
@Test public void testToString() throws Exception { CloudSeedNodeProvider provider = provider(); assertEquals(ToString.format(provider), provider.toString()); }
StateGuard { public <E extends Exception> void withReadLock(GuardedRunnable<E> task) throws E { lockRead(); try { task.run(); } finally { unlockRead(); } } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testRunWithReadLock() throws Exception { GuardedRunnable<?> task = mock(GuardedRunnable.class); guard.withReadLock(task); verify(task).run(); verifyNoMoreInteractions(task); } @Test public void testGetWithReadLock() throws Exception { GuardedSupplier<String, ?> task = () -> "test"; assertEquals("test", guard.withReadLock(task)); }
StateGuard { public void becomeInitializing() { assert writeLock.isHeldByCurrentThread() : "Thread must hold write lock."; if (state == INITIALIZING || state == INITIALIZED) { throw new IllegalStateException(type.getSimpleName() + " is already " + state.name().toLowerCase(Locale.US) + '.'); } state = INITIALIZING; } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeInitializing() { guard.lockWrite(); try { assertFalse(guard.isInitializing()); guard.becomeInitializing(); assertTrue(guard.isInitializing()); expect( IllegalStateException.class, getClass().getSimpleName() + " is already initializing.", guard::becomeInitializing ); } finally { guard.unlockWrite(); } }
StateGuard { public void becomeInitialized() { assert writeLock.isHeldByCurrentThread() : "Thread must hold write lock."; if (state == INITIALIZED) { throw new IllegalStateException(type.getSimpleName() + " already initialized."); } state = INITIALIZED; } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeInitialized() { guard.lockWrite(); try { assertFalse(guard.isInitialized()); guard.becomeInitialized(); assertTrue(guard.isInitialized()); expect( IllegalStateException.class, getClass().getSimpleName() + " already initialized.", guard::becomeInitialized ); expect( IllegalStateException.class, getClass().getSimpleName() + " is already initialized.", guard::becomeInitializing ); } finally { guard.unlockWrite(); } }
StateGuard { public boolean becomeTerminating() { assert writeLock.isHeldByCurrentThread() : "Thread must hold write lock."; if (state != TERMINATED && state != TERMINATING) { state = TERMINATING; return true; } return false; } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeTerminating() { guard.lockWrite(); try { assertFalse(guard.becomeTerminating()); guard.becomeInitialized(); assertTrue(guard.becomeTerminating()); } finally { guard.unlockWrite(); } }
StateGuard { public boolean becomeTerminated() { assert writeLock.isHeldByCurrentThread() : "Thread must hold write lock."; if (state != TERMINATED) { state = TERMINATED; return true; } return false; } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeTerminated() { guard.lockWrite(); try { assertFalse(guard.becomeTerminated()); guard.becomeInitialized(); assertTrue(guard.becomeTerminated()); } finally { guard.unlockWrite(); } }
StateGuard { public void lockReadWithStateCheck() { lockReadWithStateCheck(INITIALIZED); } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testLockReadWithStateCheck() { expect( IllegalStateException.class, getClass().getSimpleName() + " is not initialized.", guard::lockReadWithStateCheck ); expect( IllegalStateException.class, getClass().getSimpleName() + " is not initialized.", () -> guard.lockReadWithStateCheck(StateGuard.State.INITIALIZED) ); guard.lockWrite(); guard.becomeInitialized(); guard.unlockWrite(); guard.lockReadWithStateCheck(); guard.unlockRead(); guard.lockReadWithStateCheck(StateGuard.State.INITIALIZED); guard.unlockRead(); }
StateGuard { public boolean tryLockReadWithStateCheck() { lockRead(); if (state != INITIALIZED) { unlockRead(); return false; } return true; } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testTryLockReadWithStateCheck() { assertFalse(guard.tryLockReadWithStateCheck()); assertFalse(guard.tryLockReadWithStateCheck(StateGuard.State.INITIALIZED)); guard.lockWrite(); guard.becomeInitialized(); guard.unlockWrite(); assertTrue(guard.tryLockReadWithStateCheck()); guard.unlockRead(); assertTrue(guard.tryLockReadWithStateCheck(StateGuard.State.INITIALIZED)); guard.unlockRead(); }
StateGuard { public void lockWriteWithStateCheck() { lockWrite(); if (state != INITIALIZED) { unlockWrite(); throw new IllegalStateException(type.getSimpleName() + " is not " + INITIALIZED.name().toLowerCase(Locale.US) + '.'); } } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testLockWriteWithStateCheck() { expect( IllegalStateException.class, getClass().getSimpleName() + " is not initialized.", guard::lockWriteWithStateCheck ); guard.lockWrite(); guard.becomeInitialized(); guard.unlockWrite(); guard.lockWriteWithStateCheck(); assertTrue(guard.isWriteLocked()); guard.unlockWrite(); }
StateGuard { @Override public String toString() { readLock.lock(); try { return ToString.format(this); } finally { readLock.unlock(); } } StateGuard(Class<?> type); boolean withReadLockIfInitialized(GuardedRunnable<E> task); boolean withWriteLockIfInitialized(GuardedRunnable<E> task); void withReadLock(GuardedRunnable<E> task); T withReadLock(GuardedSupplier<T, E> task); void withWriteLock(GuardedRunnable<E> task); T withWriteLock(GuardedSupplier<T, E> task); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); void becomeInitialized(GuardedRunnable<E> task); boolean isInitialized(); boolean becomeTerminating(); Waiting becomeTerminating(GuardedSupplier<List<Waiting>, E> task); void becomeTerminating(GuardedRunnable<E> task); boolean becomeTerminated(); Waiting becomeTerminated(GuardedSupplier<List<Waiting>, E> task); void becomeTerminated(GuardedRunnable<E> task); void lockReadWithStateCheck(); void lockReadWithStateCheck(State state); T withReadLockAndStateCheck(GuardedSupplier<T, E> task); void withReadLockAndStateCheck(GuardedRunnable<E> task); boolean tryLockReadWithStateCheck(); boolean tryLockReadWithStateCheck(State state); void lockRead(); boolean tryLockRead(long timeout, TimeUnit unit); void unlockRead(); void lockWriteWithStateCheck(); void lockWrite(); boolean tryLockWrite(long timeout, TimeUnit unit); void unlockWrite(); boolean isWriteLocked(); @Override String toString(); }
@Test public void testToString() { assertEquals(guard.toString(), ToString.format(guard), guard.toString()); }
CloudSeedNodeProviderConfig extends CloudPropertiesBase<CloudSeedNodeProviderConfig> { @Override public String toString() { return ToString.format(this); } String getProvider(); void setProvider(String provider); CloudSeedNodeProviderConfig withProvider(String provider); String getEndpoint(); void setEndpoint(String endpoint); CloudSeedNodeProviderConfig withEndpoint(String endpoint); CredentialsSupplier getCredentials(); void setCredentials(CredentialsSupplier credentials); CloudSeedNodeProviderConfig withCredentials(CredentialsSupplier credentials); Properties getProperties(); void setProperties(Properties properties); CloudSeedNodeProviderConfig withProperty(String key, String value); Set<String> getRegions(); void setRegions(Set<String> regions); CloudSeedNodeProviderConfig withRegion(String region); Set<String> getZones(); void setZones(Set<String> zones); CloudSeedNodeProviderConfig withZone(String zone); Map<String, String> getTags(); void setTags(Map<String, String> tags); CloudSeedNodeProviderConfig withTag(String name, String value); @Override String toString(); }
@Test public void testToString() { assertEquals(ToString.format(cfg), cfg.toString()); }
StampedStateGuard { public void becomeInitializing() { assert lock.isWriteLocked() : "Thread must hold write lock."; if (state == INITIALIZING || state == INITIALIZED) { throw new IllegalStateException(type.getSimpleName() + " is already " + state.name().toLowerCase(Locale.US) + '.'); } state = INITIALIZING; } StampedStateGuard(Class<?> type); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); boolean isInitialized(); boolean becomeTerminating(); boolean becomeTerminated(); long lockReadWithStateCheck(); long lockRead(); void unlockRead(long stamp); long lockWriteWithStateCheck(); long lockWrite(); void unlockWrite(long stamp); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeInitializing() { long lock = guard.lockWrite(); try { assertFalse(guard.isInitializing()); guard.becomeInitializing(); assertTrue(guard.isInitializing()); expect(IllegalStateException.class, getClass().getSimpleName() + " is already initializing.", guard::becomeInitializing); } finally { guard.unlockWrite(lock); } }
StampedStateGuard { public void becomeInitialized() { assert lock.isWriteLocked() : "Thread must hold write lock."; if (state == INITIALIZED) { throw new IllegalStateException(type.getSimpleName() + " is already " + INITIALIZED.name().toLowerCase(Locale.US) + '.'); } state = INITIALIZED; } StampedStateGuard(Class<?> type); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); boolean isInitialized(); boolean becomeTerminating(); boolean becomeTerminated(); long lockReadWithStateCheck(); long lockRead(); void unlockRead(long stamp); long lockWriteWithStateCheck(); long lockWrite(); void unlockWrite(long stamp); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeInitialized() { long lock = guard.lockWrite(); try { assertFalse(guard.isInitialized()); guard.becomeInitialized(); assertTrue(guard.isInitialized()); expect(IllegalStateException.class, getClass().getSimpleName() + " is already initialized.", guard::becomeInitialized); expect(IllegalStateException.class, getClass().getSimpleName() + " is already initialized.", guard::becomeInitializing); } finally { guard.unlockWrite(lock); } }
StampedStateGuard { public boolean becomeTerminating() { assert lock.isWriteLocked() : "Thread must hold write lock."; if (state != TERMINATING && state != TERMINATED) { state = TERMINATING; return true; } return false; } StampedStateGuard(Class<?> type); void becomeInitializing(); boolean isInitializing(); void becomeInitialized(); boolean isInitialized(); boolean becomeTerminating(); boolean becomeTerminated(); long lockReadWithStateCheck(); long lockRead(); void unlockRead(long stamp); long lockWriteWithStateCheck(); long lockWrite(); void unlockWrite(long stamp); boolean isWriteLocked(); @Override String toString(); }
@Test public void testBecomeTerminating() { long lock = guard.lockWrite(); try { assertFalse(guard.becomeTerminating()); guard.becomeInitialized(); assertTrue(guard.becomeTerminating()); } finally { guard.unlockWrite(lock); } }