private static bool ReadReplicasUpToDateAsTheLeader(CoreClusterMember leader, ICollection <ReadReplica> readReplicas)
{
long leaderTxId = LastClosedTransactionId(true, leader.Database());
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
return(readReplicas.Select(ReadReplica::database).Select(db => LastClosedTransactionId(false, db)).Aggregate(true, (acc, txId) => acc && txId == leaderTxId, bool?.logicalAnd));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void badFollowerShouldNotJoinCluster() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void BadFollowerShouldNotJoinCluster()
{
// GIVEN
_cluster.coreTx((db, tx) =>
{
Node node = Db.createNode(label("boo"));
node.setProperty("foobar", "baz_bat");
tx.success();
});
CoreClusterMember coreMember = _cluster.getCoreMemberById(0);
_cluster.removeCoreMemberWithServerId(0);
ChangeClusterId(coreMember);
SampleData.CreateSomeData(100, _cluster);
foreach (CoreClusterMember db in _cluster.coreMembers())
{
Db.raftLogPruner().prune();
}
// WHEN
try
{
_cluster.addCoreMemberWithId(0).start();
fail("Should not have joined the cluster");
}
catch (Exception e)
{
assertThat(e.InnerException, instanceOf(typeof(LifecycleException)));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToDownloadToNewInstanceAfterPruning() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToDownloadToNewInstanceAfterPruning()
{
// given
IDictionary <string, string> @params = stringMap(CausalClusteringSettings.state_machine_flush_window_size.name(), "1", CausalClusteringSettings.raft_log_pruning_strategy.name(), "3 entries", CausalClusteringSettings.raft_log_rotation_size.name(), "1K");
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.withSharedCoreParams(params).startCluster();
Cluster <object> cluster = ClusterRule.withSharedCoreParams(@params).startCluster();
CoreClusterMember leader = cluster.CoreTx((db, tx) =>
{
createData(db, 10000);
tx.success();
});
// when
foreach (CoreClusterMember coreDb in cluster.CoreMembers())
{
coreDb.RaftLogPruner().prune();
}
cluster.RemoveCoreMember(leader); // to force a change of leader
leader = cluster.AwaitLeader();
int newDbId = 3;
cluster.AddCoreMemberWithId(newDbId).start();
CoreGraphDatabase newDb = cluster.GetCoreMemberById(newDbId).database();
// then
assertEquals(DbRepresentation.of(leader.Database()), DbRepresentation.of(newDb));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeedNewMemberToCluster() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeedNewMemberToCluster()
{
// given
_cluster.start();
// when
Optional <File> backup = SeedStore.generate(_baseBackupDir, _cluster);
// then
// possibly add load to cluster in between backup
IntermediateLoad.start(_cluster);
// when
CoreClusterMember newCoreClusterMember = _cluster.addCoreMemberWithId(3);
if (backup.Present)
{
restoreFromBackup(backup.get(), _fileSystemRule.get(), newCoreClusterMember);
}
// we want the new instance to seed from backup and not delete and re-download the store
newCoreClusterMember.Monitors().addMonitorListener(_fileCopyDetector);
newCoreClusterMember.Start();
// then
IntermediateLoad.stop();
dataMatchesEventually(newCoreClusterMember, _cluster.coreMembers());
assertFalse(_fileCopyDetector.hasDetectedAnyFileCopied());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotBeAbleToWriteOnAReadSession() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotBeAbleToWriteOnAReadSession()
{
// given
_cluster = ClusterRule.withNumberOfReadReplicas(0).startCluster();
assertEventually("Failed to execute write query on read server", () =>
{
SwitchLeader(_cluster.awaitLeader());
CoreClusterMember leader = _cluster.awaitLeader();
Driver driver = GraphDatabase.driver(leader.routingURI(), AuthTokens.basic("neo4j", "neo4j"));
try
{
using (Session session = driver.session(AccessMode.READ))
{
// when
session.run("CREATE (n:Person {name: 'Jim'})").consume();
return(false);
}
}
catch (ClientException ex)
{
assertEquals("Write queries cannot be performed in READ access mode.", ex.Message);
return(true);
}
finally
{
driver.close();
}
}, @is(true), 30, SECONDS);
_cluster.shutdown();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void createIndexProcedureMustPropagate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CreateIndexProcedureMustPropagate()
{
// create an index
_cluster.coreTx((db, tx) =>
{
Db.execute("CALL db.createIndex( \":Person(name)\", \"lucene+native-1.0\")").close();
tx.success();
});
// node created just to be able to use dataMatchesEventually as a barrier
CoreClusterMember leader = _cluster.coreTx((db, tx) =>
{
Node person = Db.createNode(Label.label("Person"));
person.setProperty("name", "Bo Burnham");
tx.success();
});
// node creation is guaranteed to happen after index creation
dataMatchesEventually(leader, _cluster.coreMembers());
dataMatchesEventually(leader, _cluster.readReplicas());
// now the indexes must exist, so we wait for them to come online
_cluster.coreMembers().forEach(this.awaitIndexOnline);
_cluster.readReplicas().forEach(this.awaitIndexOnline);
// verify indexes
_cluster.coreMembers().forEach(core => verifyIndexes(core.database()));
_cluster.readReplicas().forEach(rr => verifyIndexes(rr.database()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToDownloadLargerFreshSnapshot() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToDownloadLargerFreshSnapshot()
{
// given
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.startCluster();
Cluster <object> cluster = ClusterRule.startCluster();
CoreClusterMember source = cluster.CoreTx((db, tx) =>
{
createData(db, 1000);
tx.success();
});
// when
CoreClusterMember follower = cluster.AwaitCoreMemberWithRole(Role.FOLLOWER, 5, TimeUnit.SECONDS);
// shutdown the follower, remove the store, restart
follower.Shutdown();
DeleteDirectoryRecursively(follower.DatabaseDirectory(), follower.ServerId());
DeleteDirectoryRecursively(follower.ClusterStateDirectory(), follower.ServerId());
follower.Start();
// then
assertEquals(DbRepresentation.of(source.Database()), DbRepresentation.of(follower.Database()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotAllowTokenCreationFromAFollowerWithNoInitialTokens() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotAllowTokenCreationFromAFollowerWithNoInitialTokens()
{
// given
CoreClusterMember leader = _cluster.coreTx((db, tx) =>
{
Db.createNode();
tx.success();
});
AwaitForDataToBeApplied(leader);
dataMatchesEventually(leader, _cluster.coreMembers());
CoreGraphDatabase follower = _cluster.getMemberWithRole(Role.FOLLOWER).database();
// when
try
{
using (Transaction tx = follower.BeginTx())
{
follower.AllNodes.GetEnumerator().next().setProperty("name", "Mark");
tx.Success();
fail("Should have thrown exception");
}
}
catch (WriteOperationsNotAllowedException ex)
{
assertThat(ex.Message, containsString("No write operations are allowed"));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sessionShouldExpireOnLeaderSwitch() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void SessionShouldExpireOnLeaderSwitch()
{
// given
_cluster = ClusterRule.withNumberOfReadReplicas(0).startCluster();
CoreClusterMember leader = _cluster.awaitLeader();
Driver driver = GraphDatabase.driver(leader.RoutingURI(), AuthTokens.basic("neo4j", "neo4j"));
try
{
using (Session session = driver.session())
{
session.run("CREATE (n:Person {name: 'Jim'})").consume();
// when
SwitchLeader(leader);
session.run("CREATE (n:Person {name: 'Mark'})").consume();
fail("Should have thrown exception");
}
}
catch (SessionExpiredException sep)
{
// then
assertEquals(string.Format("Server at {0} no longer accepts writes", leader.BoltAdvertisedAddress()), sep.Message);
}
finally
{
driver.close();
}
_cluster.shutdown();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReplicateTransactionToCoreMemberAddedAfterInitialStartUp() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReplicateTransactionToCoreMemberAddedAfterInitialStartUp()
{
// given
_cluster.getCoreMemberById(0).shutdown();
_cluster.addCoreMemberWithId(3).start();
_cluster.getCoreMemberById(0).start();
_cluster.coreTx((db, tx) =>
{
Node node = Db.createNode();
node.setProperty("foobar", "baz_bat");
tx.success();
});
// when
_cluster.addCoreMemberWithId(4).start();
CoreClusterMember last = _cluster.coreTx((db, tx) =>
{
Node node = Db.createNode();
node.setProperty("foobar", "baz_bat");
tx.success();
});
// then
assertEquals(2, countNodes(last));
dataMatchesEventually(last, _cluster.coreMembers());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void procedureCallsShouldReflectMembershipChanges() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ProcedureCallsShouldReflectMembershipChanges()
{
string dbName = GetFirstDbName(_dbNames);
CoreClusterMember follower = _cluster.getMemberWithAnyRole(dbName, Role.FOLLOWER);
int followerId = follower.ServerId();
_cluster.removeCoreMemberWithServerId(followerId);
CoreGraphDatabase db = _cluster.getMemberWithAnyRole(dbName, Role.FOLLOWER, Role.LEADER).database();
System.Func <CoreGraphDatabase, ISet <Endpoint> > getResult = database =>
{
Optional <MultiClusterRoutingResult> optResult = CallProcedure(database, GET_ROUTERS_FOR_ALL_DATABASES, java.util.Collections.emptyMap());
return(optResult.map(r => r.routers().values().stream().flatMap(System.Collections.IList.stream).collect(Collectors.toSet())).orElse(java.util.Collections.emptySet()));
};
assertEventually("The procedure should return one fewer routers when a core member has been removed.", () => getResult(db).size(), @is(_numCores - 1), 15, TimeUnit.SECONDS);
System.Func <ISet <Endpoint>, CoreClusterMember, bool> containsFollower = (rs, f) => rs.Any(r => r.address().ToString().Equals(f.boltAdvertisedAddress()));
assertEventually("The procedure should not return a host as a router after it has been removed from the cluster", () => containsFollower(getResult(db), follower), @is(false), 15, TimeUnit.SECONDS);
CoreClusterMember newFollower = _cluster.addCoreMemberWithId(followerId);
newFollower.Start();
assertEventually("The procedure should return one more router when a core member has been added.", () => getResult(db).size(), @is(_numCores), 15, TimeUnit.SECONDS);
assertEventually("The procedure should return a core member as a router after it has been added to the cluster", () => containsFollower(getResult(db), newFollower), @is(true), 15, TimeUnit.SECONDS);
}
/// <summary>
/// Perform a transaction against the leader of the core cluster, retrying as necessary.
/// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private CoreClusterMember leaderTx(String dbName, System.Action<org.neo4j.causalclustering.core.CoreGraphDatabase,org.neo4j.graphdb.Transaction> op, int timeout, java.util.concurrent.TimeUnit timeUnit) throws Exception
private CoreClusterMember LeaderTx(string dbName, System.Action <CoreGraphDatabase, Transaction> op, int timeout, TimeUnit timeUnit)
{
ThrowingSupplier <CoreClusterMember, Exception> supplier = () =>
{
CoreClusterMember member = AwaitLeader(dbName, timeout, timeUnit);
CoreGraphDatabase db = member.Database();
if (db == null)
{
throw new DatabaseShutdownException();
}
try
{
using (Transaction tx = Db.beginTx())
{
op(db, tx);
return(member);
}
}
catch (Exception e)
{
if (IsTransientFailure(e))
{
return(null);
}
else
{
throw e;
}
}
};
return(awaitEx(supplier, notNull().test, timeout, timeUnit));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReplicateTransactionsToReplacementCoreMembers() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReplicateTransactionsToReplacementCoreMembers()
{
// when
_cluster.coreTx((db, tx) =>
{
Node node = Db.createNode(label("boo"));
node.setProperty("foobar", "baz_bat");
tx.success();
});
_cluster.removeCoreMemberWithServerId(0);
CoreClusterMember replacement = _cluster.addCoreMemberWithId(0);
replacement.Start();
CoreClusterMember leader = _cluster.coreTx((db, tx) =>
{
Db.schema().indexFor(label("boo")).on("foobar").create();
tx.success();
});
// then
assertEquals(1, countNodes(leader));
dataMatchesEventually(leader, _cluster.coreMembers());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void leaderShouldStepDownWhenFollowersAreGone() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void LeaderShouldStepDownWhenFollowersAreGone()
{
// when
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.startCluster();
Cluster <object> cluster = ClusterRule.startCluster();
//Do some work to make sure the cluster is operating normally.
CoreClusterMember leader = cluster.CoreTx((db, tx) =>
{
Node node = Db.createNode(Label.label("bam"));
node.setProperty("bam", "bam");
tx.success();
});
ThrowingSupplier <IList <CoreClusterMember>, Exception> followers = () => cluster.CoreMembers().Where(m => m.raft().currentRole() != Role.LEADER).ToList();
assertEventually("All followers visible", followers, Matchers.hasSize(7), 2, TimeUnit.MINUTES);
//when
//shutdown 4 servers, leaving 4 remaining and therefore not a quorum.
followers.Get().subList(0, 4).forEach(CoreClusterMember.shutdown);
//then
assertEventually("Leader should have stepped down.", () => leader.Raft().Leader, Matchers.@is(false), 2, TimeUnit.MINUTES);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void createNodeKeyConstraintMustPropagate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CreateNodeKeyConstraintMustPropagate()
{
// create a node key
CoreClusterMember leader = _cluster.coreTx((db, tx) =>
{
Db.execute("CALL db.createNodeKey( \":Person(name)\", \"lucene+native-1.0\")").close();
tx.success();
});
// node created just to be able to use dataMatchesEventually as a barrier
_cluster.coreTx((db, tx) =>
{
Node person = Db.createNode(Label.label("Person"));
person.setProperty("name", "Bo Burnham");
tx.success();
});
// node creation is guaranteed to happen after constraint creation
dataMatchesEventually(leader, _cluster.coreMembers());
dataMatchesEventually(leader, _cluster.readReplicas());
// verify indexes
_cluster.coreMembers().forEach(core => verifyIndexes(core.database()));
_cluster.readReplicas().forEach(rr => verifyIndexes(rr.database()));
// verify node keys
_cluster.coreMembers().forEach(core => verifyConstraints(core.database(), NODE_KEY));
_cluster.readReplicas().forEach(rr => verifyConstraints(rr.database(), NODE_KEY));
}
public virtual int NumberOfCoreMembersReportedByTopology()
{
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
CoreClusterMember aCoreGraphDb = _coreMembers.Values.Where(member => member.database() != null).First().orElseThrow(System.ArgumentException::new);
CoreTopologyService coreTopologyService = aCoreGraphDb.Database().DependencyResolver.resolveDependency(typeof(CoreTopologyService));
return(coreTopologyService.LocalCoreServers().members().Count);
}
private CoreClusterMember AddCoreMemberWithId(int memberId, IDictionary <string, string> extraParams, IDictionary <string, System.Func <int, string> > instanceExtraParams, string recordFormat)
{
IList <AdvertisedSocketAddress> initialHosts = ExtractInitialHosts(_coreMembers);
CoreClusterMember coreClusterMember = CreateCoreClusterMember(memberId, PortAuthority.allocatePort(), DEFAULT_CLUSTER_SIZE, initialHosts, recordFormat, extraParams, instanceExtraParams);
_coreMembers[memberId] = coreClusterMember;
return(coreClusterMember);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private void createCoreMembers(final int noOfCoreMembers, java.util.List<org.neo4j.helpers.AdvertisedSocketAddress> initialHosts, java.util.Map<String,String> extraParams, java.util.Map<String,System.Func<int, String>> instanceExtraParams, String recordFormat)
private void CreateCoreMembers(int noOfCoreMembers, IList <AdvertisedSocketAddress> initialHosts, IDictionary <string, string> extraParams, IDictionary <string, System.Func <int, string> > instanceExtraParams, string recordFormat)
{
for (int i = 0; i < initialHosts.Count; i++)
{
int discoveryListenAddress = initialHosts[i].Port;
CoreClusterMember coreClusterMember = CreateCoreClusterMember(i, discoveryListenAddress, noOfCoreMembers, initialHosts, recordFormat, extraParams, instanceExtraParams);
_coreMembers[i] = coreClusterMember;
}
_highestCoreServerId = noOfCoreMembers - 1;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldMonitorCoreEdge() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldMonitorCoreEdge()
{
// given
_cluster = ClusterRule.startCluster();
// when
CoreClusterMember coreMember = _cluster.coreTx((db, tx) =>
{
Node node = Db.createNode(label("boo"));
node.setProperty("foobar", "baz_bat");
tx.success();
});
// then
foreach (CoreClusterMember db in _cluster.coreMembers())
{
AssertAllNodesVisible(Db.database());
}
foreach (ReadReplica db in _cluster.readReplicas())
{
AssertAllNodesVisible(Db.database());
}
File coreMetricsDir = new File(coreMember.HomeDir(), csvPath.DefaultValue);
assertEventually("append index eventually accurate", () => readLongValue(metricsCsv(coreMetricsDir, CoreMetrics.APPEND_INDEX)), greaterThan(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("commit index eventually accurate", () => readLongValue(metricsCsv(coreMetricsDir, CoreMetrics.COMMIT_INDEX)), greaterThan(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("term eventually accurate", () => readLongValue(metricsCsv(coreMetricsDir, CoreMetrics.TERM)), greaterThanOrEqualTo(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("tx pull requests received eventually accurate", () =>
{
long total = 0;
foreach (File homeDir in _cluster.coreMembers().Select(CoreClusterMember.homeDir).ToList())
{
File metricsDir = new File(homeDir, "metrics");
total += readLongValue(metricsCsv(metricsDir, CatchUpMetrics.TX_PULL_REQUESTS_RECEIVED));
}
return(total);
}, greaterThan(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("tx retries eventually accurate", () => readLongValue(metricsCsv(coreMetricsDir, CoreMetrics.TX_RETRIES)), equalTo(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("is leader eventually accurate", () => readLongValue(metricsCsv(coreMetricsDir, CoreMetrics.IS_LEADER)), greaterThanOrEqualTo(0L), TIMEOUT, TimeUnit.SECONDS);
File readReplicaMetricsDir = new File(_cluster.getReadReplicaById(0).homeDir(), "metrics");
assertEventually("pull update request registered", () => readLongValue(metricsCsv(readReplicaMetricsDir, PULL_UPDATES)), greaterThan(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("pull update request registered", () => readLongValue(metricsCsv(readReplicaMetricsDir, PULL_UPDATE_HIGHEST_TX_ID_REQUESTED)), greaterThan(0L), TIMEOUT, TimeUnit.SECONDS);
assertEventually("pull update response received", () => readLongValue(metricsCsv(readReplicaMetricsDir, PULL_UPDATE_HIGHEST_TX_ID_RECEIVED)), greaterThan(0L), TIMEOUT, TimeUnit.SECONDS);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReuseIdsInCluster() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReuseIdsInCluster()
{
_cluster = ClusterRule.startCluster();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong first = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong first = new MutableLong();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong second = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong second = new MutableLong();
CoreClusterMember leader1 = CreateThreeNodes(_cluster, first, second);
CoreClusterMember leader2 = RemoveTwoNodes(_cluster, first, second);
assumeTrue(leader1 != null && leader1.Equals(leader2));
// Force maintenance on leader
IdMaintenanceOnLeader(leader1);
IdGeneratorFactory idGeneratorFactory = ResolveDependency(leader1, typeof(IdGeneratorFactory));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.store.id.IdGenerator idGenerator = idGeneratorFactory.get(org.neo4j.kernel.impl.store.id.IdType.NODE);
IdGenerator idGenerator = idGeneratorFactory.Get(IdType.NODE);
assertEquals(2, idGenerator.DefragCount);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong node1id = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong node1id = new MutableLong();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong node2id = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong node2id = new MutableLong();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong node3id = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong node3id = new MutableLong();
CoreClusterMember clusterMember = _cluster.coreTx((db, tx) =>
{
Node node1 = Db.createNode();
Node node2 = Db.createNode();
Node node3 = Db.createNode();
node1id.Value = node1.Id;
node2id.Value = node2.Id;
node3id.Value = node3.Id;
tx.success();
});
assumeTrue(leader1.Equals(clusterMember));
assertEquals(first.longValue(), node1id.longValue());
assertEquals(second.longValue(), node2id.longValue());
assertEquals(idGenerator.HighestPossibleIdInUse, node3id.longValue());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static int executeWriteAndReadThroughBolt(org.neo4j.causalclustering.discovery.CoreClusterMember core) throws java.util.concurrent.TimeoutException
private static int ExecuteWriteAndReadThroughBolt(CoreClusterMember core)
{
using (Driver driver = GraphDatabase.driver(core.RoutingURI(), AuthTokens.basic("neo4j", "neo4j")))
{
return(InExpirableSession(driver, d => d.session(AccessMode.WRITE), session =>
{
// when
session.run("MERGE (n:Person {name: 'Jim'})").consume();
Record record = session.run("MATCH (n:Person) RETURN COUNT(*) AS count").next();
return record.get("count").asInt();
}));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReplicateTransactionsToCoreMembers() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReplicateTransactionsToCoreMembers()
{
// when
CoreClusterMember leader = _cluster.coreTx((db, tx) =>
{
Node node = Db.createNode(label("boo"));
node.setProperty("foobar", "baz_bat");
tx.success();
});
// then
assertEquals(1, countNodes(leader));
dataMatchesEventually(leader, _cluster.coreMembers());
}
public virtual void RemoveCoreMemberWithServerId(int serverId)
{
CoreClusterMember memberToRemove = GetCoreMemberById(serverId);
if (memberToRemove != null)
{
memberToRemove.Shutdown();
RemoveCoreMember(memberToRemove);
}
else
{
throw new Exception("Could not remove core member with id " + serverId);
}
}
private static void ForceLogRotationAndPruning(CoreClusterMember core)
{
try
{
DependencyResolver dependencyResolver = core.Database().DependencyResolver;
dependencyResolver.ResolveDependency(typeof(LogRotation)).rotateLogFile();
SimpleTriggerInfo info = new SimpleTriggerInfo("test");
dependencyResolver.ResolveDependency(typeof(CheckPointer)).forceCheckPoint(info);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void newLeaderShouldNotReuseIds() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void NewLeaderShouldNotReuseIds()
{
_cluster = ClusterRule.startCluster();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong first = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong first = new MutableLong();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.lang3.mutable.MutableLong second = new org.apache.commons.lang3.mutable.MutableLong();
MutableLong second = new MutableLong();
CoreClusterMember creationLeader = CreateThreeNodes(_cluster, first, second);
CoreClusterMember deletionLeader = RemoveTwoNodes(_cluster, first, second);
// the following assumption is not sufficient for the subsequent assertions, since leadership is a volatile state
assumeTrue(creationLeader != null && creationLeader.Equals(deletionLeader));
IdMaintenanceOnLeader(creationLeader);
IdGeneratorFactory idGeneratorFactory = ResolveDependency(creationLeader, typeof(IdGeneratorFactory));
IdGenerator creationLeaderIdGenerator = idGeneratorFactory.Get(IdType.NODE);
assertEquals(2, creationLeaderIdGenerator.DefragCount);
// Force leader switch
_cluster.removeCoreMemberWithServerId(creationLeader.ServerId());
// waiting for new leader
CoreClusterMember newLeader = _cluster.awaitLeader();
assertNotSame(creationLeader.ServerId(), newLeader.ServerId());
IdMaintenanceOnLeader(newLeader);
IdGeneratorFactory newLeaderIdGeneratorFactory = ResolveDependency(newLeader, typeof(IdGeneratorFactory));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.store.id.IdGenerator idGenerator = newLeaderIdGeneratorFactory.get(org.neo4j.kernel.impl.store.id.IdType.NODE);
IdGenerator idGenerator = newLeaderIdGeneratorFactory.Get(IdType.NODE);
assertEquals(0, idGenerator.DefragCount);
CoreClusterMember newCreationLeader = _cluster.coreTx((db, tx) =>
{
Node node = Db.createNode();
assertEquals(idGenerator.HighestPossibleIdInUse, node.Id);
tx.success();
});
assumeTrue(newLeader.Equals(newCreationLeader));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDiscoverTimeoutBasedLeaderStepdown() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDiscoverTimeoutBasedLeaderStepdown()
{
ClusterRule.withNumberOfCoreMembers(3);
ClusterRule.withNumberOfReadReplicas(0);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.startCluster();
Cluster <object> cluster = ClusterRule.startCluster();
IList <CoreClusterMember> followers = cluster.GetAllMembersWithRole(Role.FOLLOWER);
CoreClusterMember leader = cluster.GetMemberWithRole(Role.LEADER);
followers.ForEach(CoreClusterMember.shutdown);
AssertEventualOverview(ContainsRole(LEADER, 0), leader, "core");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToCopyStoresFromCoreToReadReplica() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToCopyStoresFromCoreToReadReplica()
{
// given
IDictionary <string, string> @params = stringMap(CausalClusteringSettings.raft_log_rotation_size.name(), "1k", CausalClusteringSettings.raft_log_pruning_frequency.name(), "500ms", CausalClusteringSettings.state_machine_flush_window_size.name(), "1", CausalClusteringSettings.raft_log_pruning_strategy.name(), "1 entries");
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.withNumberOfReadReplicas(0).withSharedCoreParams(params).withRecordFormat(org.neo4j.kernel.impl.store.format.highlimit.HighLimit.NAME).startCluster();
Cluster <object> cluster = ClusterRule.withNumberOfReadReplicas(0).withSharedCoreParams(@params).withRecordFormat(HighLimit.NAME).startCluster();
cluster.CoreTx((db, tx) =>
{
Node node = Db.createNode(Label.label("L"));
for (int i = 0; i < 10; i++)
{
node.setProperty("prop-" + i, "this is a quite long string to get to the log limit soonish");
}
tx.success();
});
long baseVersion = VersionBy(cluster.AwaitLeader().raftLogDirectory(), Math.max);
CoreClusterMember coreGraphDatabase = null;
for (int j = 0; j < 2; j++)
{
coreGraphDatabase = cluster.CoreTx((db, tx) =>
{
Node node = Db.createNode(Label.label("L"));
for (int i = 0; i < 10; i++)
{
node.setProperty("prop-" + i, "this is a quite long string to get to the log limit soonish");
}
tx.success();
});
}
File raftLogDir = coreGraphDatabase.RaftLogDirectory();
assertEventually("pruning happened", () => VersionBy(raftLogDir, Math.min), greaterThan(baseVersion), 5, SECONDS);
// when
cluster.AddReadReplicaWithIdAndRecordFormat(4, HighLimit.NAME).start();
// then
foreach (ReadReplica readReplica in cluster.ReadReplicas())
{
assertEventually("read replica available", () => readReplica.database().isAvailable(0), @is(true), 10, SECONDS);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReplicateWithCompression() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReplicateWithCompression()
{
// given
ClusterRule.withSharedCoreParam(compression_implementations, ModifierProtocol.implementation()).withSharedReadReplicaParam(compression_implementations, ModifierProtocol.implementation());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.startCluster();
Cluster <object> cluster = ClusterRule.startCluster();
// when
int numberOfNodes = 10;
CoreClusterMember leader = createLabelledNodesWithProperty(cluster, numberOfNodes, label("Foo"), () => Pair.of("foobar", format("baz_bat%s", System.Guid.randomUUID())));
// then
assertEquals(numberOfNodes, countNodes(leader));
dataMatchesEventually(leader, cluster.CoreMembers());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void rejoiningFollowerShouldDownloadSnapshotFromCorrectDatabase() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void RejoiningFollowerShouldDownloadSnapshotFromCorrectDatabase()
{
string dbName = GetFirstDbName(_dbNames);
int followerId = _cluster.getMemberWithAnyRole(dbName, Role.FOLLOWER).serverId();
_cluster.removeCoreMemberWithServerId(followerId);
for (int i = 0; i < 100; i++)
{
_cluster.coreTx(dbName, (db, tx) =>
{
Node node = Db.createNode(label(dbName + "Node"));
node.setProperty("name", dbName);
tx.success();
});
}
foreach (CoreClusterMember m in _cluster.coreMembers())
{
m.RaftLogPruner().prune();
}
_cluster.addCoreMemberWithId(followerId).start();
CoreClusterMember dbLeader = _cluster.awaitLeader(dbName);
bool followerIsHealthy = _cluster.healthyCoreMembers().Any(m => m.serverId() == followerId);
assertTrue("Rejoining / lagging follower is expected to be healthy.", followerIsHealthy);
CoreClusterMember follower = _cluster.getCoreMemberById(followerId);
dataMatchesEventually(dbLeader, Collections.singleton(follower));
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
IList <File> storeDirs = _cluster.coreMembers().Where(m => dbName.Equals(m.dbName())).Select(CoreClusterMember::databaseDirectory).ToList();
_cluster.shutdown();
ISet <StoreId> storeIds = getStoreIds(storeDirs, _fs);
string message = "All members of a sub-cluster should have the same store Id after downloading a snapshot.";
assertEquals(message, 1, storeIds.Count);
}
protected internal override void DoWork()
{
try
{
CoreClusterMember leader = Cluster.awaitLeader();
leader.Shutdown();
leader.Start();
Log.info("Restarting leader");
TimeUnit.SECONDS.sleep(ReelectIntervalSeconds);
}
catch (Exception e)
{
if (isInterrupted(e) || isTransient(e))
{
// whatever let's go on with the workload
return;
}
throw new Exception("ReelectionWorkload", e);
}
}
