//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldApplyIndexUpdatesInWorkSyncedBatches() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldApplyIndexUpdatesInWorkSyncedBatches()
{
// GIVEN
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
long duration = parseTimeMillis.apply(System.getProperty(this.GetType().FullName + ".duration", "2s"));
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
int numThreads = Integer.getInteger(this.GetType().FullName + ".numThreads", Runtime.Runtime.availableProcessors());
DefaultFileSystemAbstraction fs = _fileSystemRule.get();
PageCache pageCache = _pageCacheRule.getPageCache(fs);
FusionIndexProvider indexProvider = NativeLuceneFusionIndexProviderFactory20.create(pageCache, _directory.databaseDir(), fs, IndexProvider.Monitor_Fields.EMPTY, Config.defaults(), OperationalMode.single, RecoveryCleanupWorkCollector.immediate());
RecordStorageEngine storageEngine = _storageEngineRule.getWith(fs, pageCache, _directory.databaseLayout()).indexProvider(indexProvider).build();
storageEngine.Apply(Tx(singletonList(createIndexRule(DESCRIPTOR, 1, _descriptor))), TransactionApplicationMode.EXTERNAL);
Dependencies dependencies = new Dependencies();
storageEngine.SatisfyDependencies(dependencies);
IndexProxy index = dependencies.ResolveDependency(typeof(IndexingService)).getIndexProxy(_descriptor);
AwaitOnline(index);
// WHEN
Workers <Worker> workers = new Workers <Worker>(this.GetType().Name);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean end = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean end = new AtomicBoolean();
for (int i = 0; i < numThreads; i++)
{
workers.Start(new Worker(this, i, end, storageEngine, 10, index));
}
// let the threads hammer the storage engine for some time
Thread.Sleep(duration);
end.set(true);
// THEN (assertions as part of the workers applying transactions)
workers.AwaitAndThrowOnError();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = 15000) public void commitDuringContinuousCheckpointing() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CommitDuringContinuousCheckpointing()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.index.Index<org.neo4j.graphdb.Node> index;
Index <Node> index;
using (Transaction tx = Db.beginTx())
{
index = Db.index().forNodes(INDEX_NAME, stringMap(Org.Neo4j.Graphdb.index.IndexManager_Fields.PROVIDER, DummyIndexExtensionFactory.IDENTIFIER));
tx.Success();
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean done = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean done = new AtomicBoolean();
Workers <ThreadStart> workers = new Workers <ThreadStart>(this.GetType().Name);
for (int i = 0; i < TOTAL_ACTIVE_THREADS; i++)
{
workers.Start(new RunnableAnonymousInnerClass(this, index, tx, done));
}
Thread.Sleep(SECONDS.toMillis(2));
done.set(true);
workers.AwaitAndThrowOnError();
NeoStores neoStores = GetDependency(typeof(RecordStorageEngine)).testAccessNeoStores();
assertThat("Count store should be rotated once at least", neoStores.Counts.txId(), greaterThan(0L));
long lastRotationTx = GetDependency(typeof(CheckPointer)).forceCheckPoint(new SimpleTriggerInfo("test"));
TransactionIdStore txIdStore = GetDependency(typeof(TransactionIdStore));
assertEquals("NeoStore last closed transaction id should be equal last count store rotation transaction id.", txIdStore.LastClosedTransactionId, lastRotationTx);
assertEquals("Last closed transaction should be last rotated tx in count store", txIdStore.LastClosedTransactionId, neoStores.Counts.txId());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void oneRound() throws Throwable
private void OneRound()
{
// GIVEN a cluster and a node
const string key = "key";
ClusterManager.ManagedCluster cluster = ClusterRule.startCluster();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.GraphDatabaseService master = cluster.getMaster();
GraphDatabaseService master = cluster.Master;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long nodeId = createNode(master);
long nodeId = CreateNode(master);
cluster.Sync();
// and a bunch of workers contending on that node, each changing it
Workers <ThreadStart> transactors = new Workers <ThreadStart>("Transactors");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger successes = new java.util.concurrent.atomic.AtomicInteger();
AtomicInteger successes = new AtomicInteger();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean end = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean end = new AtomicBoolean();
for (int i = 0; i < 10; i++)
{
transactors.Start(() =>
{
Random random = ThreadLocalRandom.current();
while (!end.get())
{
bool committed = true;
try
{
using (Transaction tx = master.BeginTx())
{
Node node = master.GetNodeById(nodeId);
// Acquiring lock, read int property value, increment, set incremented int property
// should not break under any circumstances.
tx.acquireWriteLock(node);
node.setProperty(key, ( int? )node.getProperty(key, 0) + 1);
// Throw in relationship for good measure
node.createRelationshipTo(master.CreateNode(), TEST);
Thread.Sleep(random.Next(1_000));
tx.success();
}
}
catch (Exception)
{
// It's OK
committed = false;
}
if (committed)
{
successes.incrementAndGet();
}
}
});
}
// WHEN entering a period of induced cluster instabilities
ReelectTheSameMasterMakingItGoToPendingAndBack(cluster);
// ... letting transactions run a bit after the role switch as well.
long targetSuccesses = successes.get() + 20;
while (successes.get() < targetSuccesses)
{
Thread.Sleep(100);
}
end.set(true);
transactors.AwaitAndThrowOnError();
// THEN verify that the count is equal to the number of successful transactions
assertEquals(successes.get(), GetNodePropertyValue(master, nodeId, key));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public static <RECORD> void distributeRecords(int numberOfThreads, String workerNames, int queueSize, java.util.Iterator<RECORD> records, final org.neo4j.helpers.progress.ProgressListener progress, RecordProcessor<RECORD> processor, org.neo4j.consistency.checking.full.QueueDistribution_QueueDistributor<RECORD> idDistributor)
public static void DistributeRecords <RECORD>(int numberOfThreads, string workerNames, int queueSize, IEnumerator <RECORD> records, ProgressListener progress, RecordProcessor <RECORD> processor, QueueDistribution_QueueDistributor <RECORD> idDistributor)
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
if (!records.hasNext())
{
return;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") final java.util.concurrent.ArrayBlockingQueue<RECORD>[] recordQ = new java.util.concurrent.ArrayBlockingQueue[numberOfThreads];
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
ArrayBlockingQueue <RECORD>[] recordQ = new ArrayBlockingQueue[numberOfThreads];
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.unsafe.impl.batchimport.cache.idmapping.string.Workers<RecordCheckWorker<RECORD>> workers = new org.neo4j.unsafe.impl.batchimport.cache.idmapping.string.Workers<>(workerNames);
Workers <RecordCheckWorker <RECORD> > workers = new Workers <RecordCheckWorker <RECORD> >(workerNames);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger idGroup = new java.util.concurrent.atomic.AtomicInteger(-1);
AtomicInteger idGroup = new AtomicInteger(-1);
for (int threadId = 0; threadId < numberOfThreads; threadId++)
{
recordQ[threadId] = new ArrayBlockingQueue <RECORD>(queueSize);
workers.Start(new RecordCheckWorker <RECORD>(threadId, idGroup, recordQ[threadId], processor));
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int[] recsProcessed = new int[numberOfThreads];
int[] recsProcessed = new int[numberOfThreads];
RecordConsumer <RECORD> recordConsumer = (record, qIndex) =>
{
recordQ[qIndex].put(record);
recsProcessed[qIndex]++;
};
try
{
while (records.MoveNext())
{
try
{
// Put records into the queues using the queue distributor. Each Worker will pull and process.
RECORD record = records.Current;
idDistributor.Distribute(record, recordConsumer);
progress.Add(1);
}
catch (InterruptedException)
{
Thread.CurrentThread.Interrupt();
break;
}
}
// No more records to distribute, mark as done so that the workers will exit when no more records in queue.
foreach (RecordCheckWorker <RECORD> worker in workers)
{
worker.Done();
}
workers.AwaitAndThrowOnError();
}
catch (InterruptedException)
{
Thread.CurrentThread.Interrupt();
throw new Exception("Was interrupted while awaiting completion");
}
}