//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testIndexFlip()
public virtual void TestIndexFlip()
{
IndexProxyFactory indexProxyFactory = mock(typeof(IndexProxyFactory));
FailedIndexProxyFactory failedIndexProxyFactory = mock(typeof(FailedIndexProxyFactory));
FlippableIndexProxy flipper = new FlippableIndexProxy();
flipper.FlipTarget = indexProxyFactory;
IndexPopulator indexPopulator1 = CreateIndexPopulator();
IndexPopulator indexPopulator2 = CreateIndexPopulator();
AddPopulator(indexPopulator1, 1, flipper, failedIndexProxyFactory);
AddPopulator(indexPopulator2, 2, flipper, failedIndexProxyFactory);
when(indexPopulator1.SampleResult()).thenThrow(SampleError);
_multipleIndexPopulator.indexAllEntities();
_multipleIndexPopulator.flipAfterPopulation(false);
verify(indexPopulator1).close(false);
verify(failedIndexProxyFactory, times(1)).create(any(typeof(Exception)));
verify(indexPopulator2).close(true);
verify(indexPopulator2).sampleResult();
verify(_indexStoreView).replaceIndexCounts(anyLong(), anyLong(), anyLong(), anyLong());
verify(_schemaState).clear();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToCancelPopulationJob() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToCancelPopulationJob()
{
// GIVEN
CreateNode(map(_name, "Mattias"), _first);
IndexPopulator populator = mock(typeof(IndexPopulator));
FlippableIndexProxy index = mock(typeof(FlippableIndexProxy));
IndexStoreView storeView = mock(typeof(IndexStoreView));
ControlledStoreScan storeScan = new ControlledStoreScan();
when(storeView.VisitNodes(any(typeof(int[])), any(typeof(System.Func <int, bool>)), ArgumentMatchers.any(), ArgumentMatchers.any <Visitor <NodeLabelUpdate, Exception> >(), anyBoolean())).thenReturn(storeScan);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final IndexPopulationJob job = newIndexPopulationJob(populator, index, storeView, org.neo4j.logging.NullLogProvider.getInstance(), org.neo4j.storageengine.api.EntityType.NODE, indexDescriptor(FIRST, name, false));
IndexPopulationJob job = NewIndexPopulationJob(populator, index, storeView, NullLogProvider.Instance, EntityType.NODE, IndexDescriptor(_first, _name, false));
OtherThreadExecutor <Void> populationJobRunner = Cleanup.add(new OtherThreadExecutor <Void>("Population job test runner", null));
Future <Void> runFuture = populationJobRunner.ExecuteDontWait(state =>
{
job.Run();
return(null);
});
storeScan.Latch.waitForAllToStart();
job.Cancel().get();
storeScan.Latch.waitForAllToFinish();
// WHEN
runFuture.get();
// THEN
verify(populator, times(1)).close(false);
verify(index, never()).flip(any(), any());
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: IndexProxy createPopulatingIndexProxy(final org.neo4j.storageengine.api.schema.StoreIndexDescriptor descriptor, final boolean flipToTentative, final IndexingService.Monitor monitor, final IndexPopulationJob populationJob)
internal virtual IndexProxy CreatePopulatingIndexProxy(StoreIndexDescriptor descriptor, bool flipToTentative, IndexingService.Monitor monitor, IndexPopulationJob populationJob)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final FlippableIndexProxy flipper = new FlippableIndexProxy();
FlippableIndexProxy flipper = new FlippableIndexProxy();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String indexUserDescription = indexUserDescription(descriptor);
string indexUserDescription = indexUserDescription(descriptor);
IndexPopulator populator = PopulatorFromProvider(descriptor, _samplingConfig, populationJob.BufferFactory());
CapableIndexDescriptor capableIndexDescriptor = _providerMap.withCapabilities(descriptor);
FailedIndexProxyFactory failureDelegateFactory = new FailedPopulatingIndexProxyFactory(capableIndexDescriptor, populator, indexUserDescription, new IndexCountsRemover(_storeView, descriptor.Id), _logProvider);
MultipleIndexPopulator.IndexPopulation indexPopulation = populationJob.AddPopulator(populator, capableIndexDescriptor, indexUserDescription, flipper, failureDelegateFactory);
PopulatingIndexProxy populatingIndex = new PopulatingIndexProxy(capableIndexDescriptor, populationJob, indexPopulation);
flipper.FlipTo(populatingIndex);
// Prepare for flipping to online mode
flipper.FlipTarget = () =>
{
monitor.PopulationCompleteOn(descriptor);
IndexAccessor accessor = OnlineAccessorFromProvider(descriptor, _samplingConfig);
OnlineIndexProxy onlineProxy = new OnlineIndexProxy(capableIndexDescriptor, accessor, _storeView, true);
if (flipToTentative)
{
return(new TentativeConstraintIndexProxy(flipper, onlineProxy));
}
return(onlineProxy);
};
return(new ContractCheckingIndexProxy(flipper, false));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void logConstraintJobProgress() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void LogConstraintJobProgress()
{
// Given
CreateNode(map(_name, "irrelephant"), _first);
AssertableLogProvider logProvider = new AssertableLogProvider();
FlippableIndexProxy index = mock(typeof(FlippableIndexProxy));
when(index.State).thenReturn(InternalIndexState.POPULATING);
IndexPopulator populator = spy(IndexPopulator(false));
try
{
IndexPopulationJob job = NewIndexPopulationJob(populator, index, _indexStoreView, logProvider, EntityType.NODE, IndexDescriptor(_first, _name, true));
// When
job.Run();
// Then
AssertableLogProvider.LogMatcherBuilder match = inLog(typeof(IndexPopulationJob));
logProvider.AssertExactly(match.info("Index population started: [%s]", ":FIRST(name)"), match.info("Index created. Starting data checks. Index [%s] is %s.", ":FIRST(name)", "POPULATING"), match.info(containsString("TIME/PHASE Final: SCAN[")));
}
finally
{
populator.Close(true);
}
}
//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 org.neo4j.test.OtherThreadExecutor.WorkerCommand<Void, Void> dropTheIndex(final FlippableIndexProxy flippable)
private OtherThreadExecutor.WorkerCommand <Void, Void> DropTheIndex(FlippableIndexProxy flippable)
{
return(state =>
{
flippable.Drop();
return null;
});
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.kernel.impl.api.index.MultipleIndexPopulator.IndexPopulation addPopulator(org.neo4j.kernel.api.index.IndexPopulator indexPopulator, int id) throws org.neo4j.kernel.api.exceptions.index.FlipFailedKernelException
private IndexPopulation AddPopulator(IndexPopulator indexPopulator, int id)
{
FlippableIndexProxy indexProxy = mock(typeof(FlippableIndexProxy));
when(indexProxy.State).thenReturn(InternalIndexState.ONLINE);
doAnswer(invocation =>
{
Callable argument = invocation.getArgument(0);
return(argument.call());
}).when(indexProxy).flip(any(typeof(Callable)), any(typeof(FailedIndexProxyFactory)));
return(AddPopulator(indexPopulator, id, indexProxy, mock(typeof(FailedIndexProxyFactory))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFlipAfterPopulation() throws org.neo4j.kernel.api.exceptions.index.FlipFailedKernelException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestFlipAfterPopulation()
{
IndexPopulator indexPopulator1 = CreateIndexPopulator();
IndexPopulator indexPopulator2 = CreateIndexPopulator();
FlippableIndexProxy flipper1 = AddPopulator(indexPopulator1, 1).Flipper;
FlippableIndexProxy flipper2 = AddPopulator(indexPopulator2, 2).Flipper;
_multipleIndexPopulator.flipAfterPopulation(false);
verify(flipper1).flip(any(typeof(Callable)), any(typeof(FailedIndexProxyFactory)));
verify(flipper2).flip(any(typeof(Callable)), any(typeof(FailedIndexProxyFactory)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBlockAccessDuringFlipAndThenDelegateToCorrectContext() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBlockAccessDuringFlipAndThenDelegateToCorrectContext()
{
// GIVEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final IndexProxy contextBeforeFlip = mockIndexProxy();
IndexProxy contextBeforeFlip = mockIndexProxy();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final IndexProxy contextAfterFlip = mockIndexProxy();
IndexProxy contextAfterFlip = mockIndexProxy();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final FlippableIndexProxy flippable = new FlippableIndexProxy(contextBeforeFlip);
FlippableIndexProxy flippable = new FlippableIndexProxy(contextBeforeFlip);
flippable.FlipTarget = SingleProxy(contextAfterFlip);
// And given complicated thread race condition tools
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch triggerFinishFlip = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent triggerFinishFlip = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch triggerExternalAccess = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent triggerExternalAccess = new System.Threading.CountdownEvent(1);
OtherThreadExecutor <Void> flippingThread = Cleanup.add(new OtherThreadExecutor <Void>("Flipping thread", null));
OtherThreadExecutor <Void> dropIndexThread = Cleanup.add(new OtherThreadExecutor <Void>("Drop index thread", null));
// WHEN one thread starts flipping to another context
Future <Void> flipContextFuture = flippingThread.ExecuteDontWait(StartFlipAndWaitForLatchBeforeFinishing(flippable, triggerFinishFlip, triggerExternalAccess));
// And I wait until the flipping thread is in the middle of "the flip"
assertTrue(triggerExternalAccess.await(10, SECONDS));
// And another thread comes along and drops the index
Future <Void> dropIndexFuture = dropIndexThread.ExecuteDontWait(DropTheIndex(flippable));
dropIndexThread.WaitUntilWaiting();
// And the flipping thread finishes the flip
triggerFinishFlip.Signal();
// And both threads get to finish up and return
dropIndexFuture.get(10, SECONDS);
flipContextFuture.get(10, SECONDS);
// THEN the thread wanting to drop the index should not have interacted with the original context
// eg. it should have waited for the flip to finish
verifyNoMoreInteractions(contextBeforeFlip);
// But it should have gotten to drop the new index context, after the flip happened.
verify(contextAfterFlip).drop();
}
internal IndexPopulation(MultipleIndexPopulator outerInstance, IndexPopulator populator, CapableIndexDescriptor capableIndexDescriptor, FlippableIndexProxy flipper, FailedIndexProxyFactory failedIndexProxyFactory, string indexUserDescription)
{
this._outerInstance = outerInstance;
this.Populator = populator;
this.CapableIndexDescriptor = capableIndexDescriptor;
this.IndexId = capableIndexDescriptor.Id;
this.Flipper = flipper;
this.FailedIndexProxyFactory = failedIndexProxyFactory;
this.IndexUserDescription = indexUserDescription;
this.IndexCountsRemover = new IndexCountsRemover(outerInstance.storeView, IndexId);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: this.batchedUpdates = new java.util.ArrayList<>(BATCH_SIZE);
this.BatchedUpdates = new List <IndexEntryUpdate <object> >(outerInstance.BatchSize);
}
private static IndexPopulator AddPopulator(BatchingMultipleIndexPopulator batchingPopulator, IndexDescriptor descriptor)
{
IndexPopulator populator = mock(typeof(IndexPopulator));
IndexProxyFactory indexProxyFactory = mock(typeof(IndexProxyFactory));
FailedIndexProxyFactory failedIndexProxyFactory = mock(typeof(FailedIndexProxyFactory));
FlippableIndexProxy flipper = new FlippableIndexProxy();
flipper.FlipTarget = indexProxyFactory;
batchingPopulator.AddPopulator(populator, descriptor.WithId(1).withoutCapabilities(), flipper, failedIndexProxyFactory, "testIndex");
return(populator);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToSwitchDelegate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToSwitchDelegate()
{
// GIVEN
IndexProxy actual = mockIndexProxy();
IndexProxy other = mockIndexProxy();
FlippableIndexProxy @delegate = new FlippableIndexProxy(actual);
@delegate.FlipTarget = SingleProxy(other);
// WHEN
@delegate.Flip(NoOp(), null);
@delegate.Drop();
// THEN
verify(other).drop();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTransitionToFailedStateIfPopulationJobCrashes() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldTransitionToFailedStateIfPopulationJobCrashes()
{
// GIVEN
IndexPopulator failingPopulator = mock(typeof(IndexPopulator));
doThrow(new Exception("BORK BORK")).when(failingPopulator).add(any(typeof(System.Collections.ICollection)));
FlippableIndexProxy index = new FlippableIndexProxy();
CreateNode(map(_name, "Taylor"), _first);
IndexPopulationJob job = NewIndexPopulationJob(failingPopulator, index, EntityType.NODE, IndexDescriptor(_first, _name, false));
// WHEN
job.Run();
// THEN
assertThat(index.State, equalTo(InternalIndexState.FAILED));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotBeAbleToFlipAfterDrop() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotBeAbleToFlipAfterDrop()
{
//GIVEN
IndexProxy actual = mockIndexProxy();
IndexProxy failed = mockIndexProxy();
IndexProxyFactory indexContextFactory = mock(typeof(IndexProxyFactory));
FlippableIndexProxy @delegate = new FlippableIndexProxy(actual);
@delegate.FlipTarget = indexContextFactory;
//WHEN
@delegate.Drop();
//THEN
ExpectedException.expect(typeof(IndexProxyAlreadyClosedKernelException));
@delegate.Flip(NoOp(), SingleFailedDelegate(failed));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCloseAndFailOnFailure() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCloseAndFailOnFailure()
{
CreateNode(map(_name, "irrelephant"), _first);
LogProvider logProvider = NullLogProvider.Instance;
FlippableIndexProxy index = mock(typeof(FlippableIndexProxy));
IndexPopulator populator = spy(IndexPopulator(false));
IndexPopulationJob job = NewIndexPopulationJob(populator, index, _indexStoreView, logProvider, EntityType.NODE, IndexDescriptor(_first, _name, false));
string failureMessage = "not successful";
System.InvalidOperationException failure = new System.InvalidOperationException(failureMessage);
doThrow(failure).when(populator).create();
// When
job.Run();
// Then
verify(populator).markAsFailed(contains(failureMessage));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLogJobFailure() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldLogJobFailure()
{
// Given
CreateNode(map(_name, "irrelephant"), _first);
AssertableLogProvider logProvider = new AssertableLogProvider();
FlippableIndexProxy index = mock(typeof(FlippableIndexProxy));
IndexPopulator populator = spy(IndexPopulator(false));
IndexPopulationJob job = NewIndexPopulationJob(populator, index, _indexStoreView, logProvider, EntityType.NODE, IndexDescriptor(_first, _name, false));
Exception failure = new System.InvalidOperationException("not successful");
doThrow(failure).when(populator).create();
// When
job.Run();
// Then
AssertableLogProvider.LogMatcherBuilder match = inLog(typeof(IndexPopulationJob));
logProvider.AssertAtLeastOnce(match.error(@is("Failed to populate index: [:FIRST(name)]"), sameInstance(failure)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldVerifyConstraintsBeforeFlippingIfToldTo() throws org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldVerifyConstraintsBeforeFlippingIfToldTo()
{
// given
IndexProxyFactory indexProxyFactory = mock(typeof(IndexProxyFactory));
FailedIndexProxyFactory failedIndexProxyFactory = mock(typeof(FailedIndexProxyFactory));
FlippableIndexProxy flipper = new FlippableIndexProxy();
flipper.FlipTarget = indexProxyFactory;
IndexPopulator indexPopulator = CreateIndexPopulator();
AddPopulator(indexPopulator, 1, flipper, failedIndexProxyFactory);
when(indexPopulator.SampleResult()).thenReturn(new IndexSample());
// when
_multipleIndexPopulator.indexAllEntities();
_multipleIndexPopulator.flipAfterPopulation(true);
// then
verify(indexPopulator).verifyDeferredConstraints(any(typeof(NodePropertyAccessor)));
verify(indexPopulator).close(true);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAbortStoreScanWaitOnDrop() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldAbortStoreScanWaitOnDrop()
{
// given the proxy structure
FakePopulatingIndexProxy @delegate = new FakePopulatingIndexProxy();
FlippableIndexProxy flipper = new FlippableIndexProxy(@delegate);
OtherThreadExecutor <Void> waiter = Cleanup.add(new OtherThreadExecutor <Void>("Waiter", null));
// and a thread stuck in the awaitStoreScanCompletion loop
Future <object> waiting = waiter.ExecuteDontWait(state => flipper.AwaitStoreScanCompleted(0, MILLISECONDS));
while ([email protected])
{
Thread.Sleep(10);
}
// when
flipper.Drop();
// then the waiting should quickly be over
waiting.get(10, SECONDS);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustFlipToFailedIfFailureToApplyLastBatchWhileFlipping() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void MustFlipToFailedIfFailureToApplyLastBatchWhileFlipping()
{
// given
NullLogProvider logProvider = NullLogProvider.Instance;
IndexStoreView storeView = EmptyIndexStoreViewThatProcessUpdates();
Org.Neo4j.Kernel.Api.Index.IndexPopulator_Adapter populator = EmptyPopulatorWithThrowingUpdater();
FailedIndexProxy failedProxy = FailedIndexProxy(storeView, populator);
OnlineIndexProxy onlineProxy = OnlineIndexProxy(storeView);
FlippableIndexProxy flipper = new FlippableIndexProxy();
flipper.FlipTarget = () => onlineProxy;
MultipleIndexPopulator multipleIndexPopulator = new MultipleIndexPopulator(storeView, logProvider, EntityType.NODE, mock(typeof(SchemaState)));
MultipleIndexPopulator.IndexPopulation indexPopulation = multipleIndexPopulator.AddPopulator(populator, DummyMeta(), flipper, t => failedProxy, "userDescription");
multipleIndexPopulator.QueueUpdate(SomeUpdate());
multipleIndexPopulator.IndexAllEntities().run();
// when
indexPopulation.Flip(false);
// then
assertSame("flipper should have flipped to failing proxy", flipper.State, InternalIndexState.FAILED);
}
private IndexPopulation AddPopulator(MultipleIndexPopulator multipleIndexPopulator, IndexPopulator indexPopulator, int id, FlippableIndexProxy flippableIndexProxy, FailedIndexProxyFactory failedIndexProxyFactory)
{
return(AddPopulator(multipleIndexPopulator, TestIndexDescriptorFactory.forLabel(id, id).withId(id), indexPopulator, flippableIndexProxy, failedIndexProxyFactory));
}
private IndexPopulation AddPopulator(IndexPopulator indexPopulator, int id, FlippableIndexProxy flippableIndexProxy, FailedIndexProxyFactory failedIndexProxyFactory)
{
return(AddPopulator(_multipleIndexPopulator, indexPopulator, id, flippableIndexProxy, failedIndexProxyFactory));
}
private IndexPopulationJob NewIndexPopulationJob(IndexPopulator populator, FlippableIndexProxy flipper, IndexStoreView storeView, LogProvider logProvider, EntityType type, IndexDescriptor descriptor)
{
return(NewIndexPopulationJob(mock(typeof(FailedIndexProxyFactory)), populator, flipper, storeView, logProvider, type, descriptor));
}
internal TentativeConstraintIndexProxy(FlippableIndexProxy flipper, OnlineIndexProxy target)
{
this._flipper = flipper;
this._target = target;
}
internal LockingIndexUpdater(FlippableIndexProxy outerInstance, IndexUpdater @delegate) : base(@delegate)
{
this._outerInstance = outerInstance;
[email protected]().@lock();
}
private IndexPopulationJob NewIndexPopulationJob(FailedIndexProxyFactory failureDelegateFactory, IndexPopulator populator, FlippableIndexProxy flipper, IndexStoreView storeView, LogProvider logProvider, EntityType type, IndexDescriptor descriptor)
{
long indexId = 0;
flipper.FlipTarget = mock(typeof(IndexProxyFactory));
MultipleIndexPopulator multiPopulator = new MultipleIndexPopulator(storeView, logProvider, type, _stateHolder);
IndexPopulationJob job = new IndexPopulationJob(multiPopulator, NO_MONITOR, false);
job.AddPopulator(populator, descriptor.WithId(indexId).withoutCapabilities(), format(":%s(%s)", _first.name(), _name), flipper, failureDelegateFactory);
return(job);
}
/// <summary>
/// Adds an <seealso cref="IndexPopulator"/> to be populated in this store scan. All participating populators must
/// be added before calling <seealso cref="run()"/>. </summary>
/// <param name="populator"> <seealso cref="IndexPopulator"/> to participate. </param>
/// <param name="capableIndexDescriptor"> <seealso cref="CapableIndexDescriptor"/> meta information about index. </param>
/// <param name="indexUserDescription"> user description of this index. </param>
/// <param name="flipper"> <seealso cref="FlippableIndexProxy"/> to call after a successful population. </param>
/// <param name="failedIndexProxyFactory"> <seealso cref="FailedIndexProxyFactory"/> to use after an unsuccessful population. </param>
internal virtual MultipleIndexPopulator.IndexPopulation AddPopulator(IndexPopulator populator, CapableIndexDescriptor capableIndexDescriptor, string indexUserDescription, FlippableIndexProxy flipper, FailedIndexProxyFactory failedIndexProxyFactory)
{
Debug.Assert(_storeScan == null, "Population have already started, too late to add populators at this point");
return(this._multiPopulator.addPopulator(populator, capableIndexDescriptor, flipper, failedIndexProxyFactory, indexUserDescription));
}
internal virtual IndexPopulation AddPopulator(IndexPopulator populator, CapableIndexDescriptor capableIndexDescriptor, FlippableIndexProxy flipper, FailedIndexProxyFactory failedIndexProxyFactory, string indexUserDescription)
{
IndexPopulation population = CreatePopulation(populator, capableIndexDescriptor, flipper, failedIndexProxyFactory, indexUserDescription);
Populations.Add(population);
return(population);
}
private MultipleIndexPopulator.IndexPopulation AddPopulator(MultipleIndexPopulator multipleIndexPopulator, StoreIndexDescriptor descriptor, IndexPopulator indexPopulator, FlippableIndexProxy flippableIndexProxy, FailedIndexProxyFactory failedIndexProxyFactory)
{
return(multipleIndexPopulator.AddPopulator(indexPopulator, descriptor.WithoutCapabilities(), flippableIndexProxy, failedIndexProxyFactory, "userIndexDescription"));
}
private IndexPopulationJob NewIndexPopulationJob(IndexPopulator populator, FlippableIndexProxy flipper, EntityType type, IndexDescriptor descriptor)
{
return(NewIndexPopulationJob(populator, flipper, _indexStoreView, NullLogProvider.Instance, type, descriptor));
}
//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 org.neo4j.test.OtherThreadExecutor.WorkerCommand<Void, Void> startFlipAndWaitForLatchBeforeFinishing(final FlippableIndexProxy flippable, final java.util.concurrent.CountDownLatch triggerFinishFlip, final java.util.concurrent.CountDownLatch triggerExternalAccess)
private OtherThreadExecutor.WorkerCommand <Void, Void> StartFlipAndWaitForLatchBeforeFinishing(FlippableIndexProxy flippable, System.Threading.CountdownEvent triggerFinishFlip, System.Threading.CountdownEvent triggerExternalAccess)
{
return(state =>
{
flippable.Flip(() =>
{
triggerExternalAccess.Signal();
assertTrue(awaitLatch(triggerFinishFlip));
return true;
}, null);
return null;
});
}
private IndexPopulation CreatePopulation(IndexPopulator populator, CapableIndexDescriptor capableIndexDescriptor, FlippableIndexProxy flipper, FailedIndexProxyFactory failedIndexProxyFactory, string indexUserDescription)
{
return(new IndexPopulation(this, populator, capableIndexDescriptor, flipper, failedIndexProxyFactory, indexUserDescription));
}
