//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyAsyncActionCausesConcurrentFlushingRush(org.neo4j.function.ThrowingConsumer<CheckPointerImpl,java.io.IOException> asyncAction) throws Exception
private void VerifyAsyncActionCausesConcurrentFlushingRush(ThrowingConsumer <CheckPointerImpl, IOException> asyncAction)
{
AtomicLong limitDisableCounter = new AtomicLong();
AtomicLong observedRushCount = new AtomicLong();
BinaryLatch backgroundCheckPointStartedLatch = new BinaryLatch();
BinaryLatch forceCheckPointStartLatch = new BinaryLatch();
_limiter = new IOLimiterAnonymousInnerClass4(this, limitDisableCounter, forceCheckPointStartLatch);
MockTxIdStore();
CheckPointerImpl checkPointer = checkPointer();
doAnswer(invocation =>
{
backgroundCheckPointStartedLatch.Release();
forceCheckPointStartLatch.Await();
long newValue = limitDisableCounter.get();
observedRushCount.set(newValue);
return(null);
}).when(_storageEngine).flushAndForce(_limiter);
Future <object> forceCheckPointer = forkFuture(() =>
{
backgroundCheckPointStartedLatch.Await();
asyncAction.Accept(checkPointer);
return(null);
});
when(_threshold.isCheckPointingNeeded(anyLong(), eq(_info))).thenReturn(true);
checkPointer.CheckPointIfNeeded(_info);
forceCheckPointer.get();
assertThat(observedRushCount.get(), @is(1L));
}
/// <summary>
/// In order to avoid browsers popping up an auth box when using the Neo4j Browser, it sends us a special header.
/// When we get that special header, we send a crippled authentication challenge back that the browser does not
/// understand, which lets the Neo4j Browser handle auth on its own.
///
/// Otherwise, we send a regular basic auth challenge. This method adds the appropriate header depending on the
/// inbound request.
/// </summary>
private static ThrowingConsumer <HttpServletResponse, IOException> RequestAuthentication(HttpServletRequest req, ThrowingConsumer <HttpServletResponse, IOException> responseGen)
{
if ("true".Equals(req.getHeader("X-Ajax-Browser-Auth")))
{
return(res =>
{
responseGen.Accept(res);
res.addHeader(HttpHeaders.WWW_AUTHENTICATE, "None");
});
}
else
{
return(res =>
{
responseGen.Accept(res);
res.addHeader(HttpHeaders.WWW_AUTHENTICATE, "Basic realm=\"Neo4j\"");
});
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void runFailing(org.neo4j.function.ThrowingConsumer<SuspendableLifeCycle,Throwable> consumer) throws Throwable
private void RunFailing(ThrowingConsumer <SuspendableLifeCycle, Exception> consumer)
{
try
{
consumer.Accept(_lifeCycle);
fail();
}
catch (System.InvalidOperationException)
{
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void updateStore(final Store store, long transaction) throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
private void UpdateStore(Store store, long transaction)
{
ThrowingConsumer <long, IOException> update = u =>
{
using (EntryUpdater <string> updater = store.Updater(u).get())
{
updater.Apply("key " + u, Value("value " + u));
}
};
update.Accept(transaction);
}
private void ForToken(ThrowingConsumer <Token, KernelException> f)
{
try
{
using (Transaction tx = beginTransaction())
{
f.Accept(tx.Token());
}
}
catch (KernelException e)
{
fail("Unwanted exception: " + e.Message);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] createRunWith(org.neo4j.function.ThrowingConsumer<org.neo4j.bolt.messaging.Neo4jPack_Packer, java.io.IOException> valuePacker) throws java.io.IOException
private sbyte[] CreateRunWith(ThrowingConsumer <Org.Neo4j.Bolt.messaging.Neo4jPack_Packer, IOException> valuePacker)
{
PackedOutputArray @out = new PackedOutputArray();
Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = (new Neo4jPackV2()).newPacker(@out);
packer.PackStructHeader(2, RunMessage.SIGNATURE);
packer.Pack("RETURN $x");
packer.PackMapHeader(1);
packer.Pack("x");
valuePacker.Accept(packer);
return(@out.Bytes());
}
private void ForEachPopulation(ThrowingConsumer <IndexPopulation, Exception> action)
{
foreach (IndexPopulation population in Populations)
{
try
{
action.Accept(population);
}
catch (Exception failure)
{
Fail(population, failure);
}
}
}
/// <summary>
/// Iterate over some schema suppliers, and invoke a callback for every supplier that matches the node. To match the
/// node N the supplier must supply a LabelSchemaDescriptor D, such that N has values for all the properties of D.
/// The supplied schemas are all assumed to match N on label.
/// <para>
/// To avoid unnecessary store lookups, this implementation only gets propertyKeyIds for the node if some
/// descriptor has a valid label.
///
/// </para>
/// </summary>
/// @param <SUPPLIER> the type to match. Must implement SchemaDescriptorSupplier </param>
/// @param <EXCEPTION> The type of exception that can be thrown when taking the action </param>
/// <param name="schemaSuppliers"> The suppliers to match </param>
/// <param name="specialPropertyId"> This property id will always count as a match for the descriptor, regardless of
/// whether the node has this property or not </param>
/// <param name="existingPropertyIds"> sorted array of property ids for the entity to match schema for. </param>
/// <param name="callback"> The action to take on match </param>
/// <exception cref="EXCEPTION"> This exception is propagated from the action </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static <SUPPLIER extends org.neo4j.internal.kernel.api.schema.SchemaDescriptorSupplier, EXCEPTION extends Exception> void onMatchingSchema(java.util.Iterator<SUPPLIER> schemaSuppliers, int specialPropertyId, int[] existingPropertyIds, org.neo4j.function.ThrowingConsumer<SUPPLIER,EXCEPTION> callback) throws EXCEPTION
internal static void OnMatchingSchema <SUPPLIER, EXCEPTION>(IEnumerator <SUPPLIER> schemaSuppliers, int specialPropertyId, int[] existingPropertyIds, ThrowingConsumer <SUPPLIER, EXCEPTION> callback) where SUPPLIER : [email protected] where EXCEPTION : Exception
{
Debug.Assert(isSortedSet(existingPropertyIds));
while (schemaSuppliers.MoveNext())
{
SUPPLIER schemaSupplier = schemaSuppliers.Current;
SchemaDescriptor schema = schemaSupplier.schema();
if (NodeHasSchemaProperties(existingPropertyIds, Schema.PropertyIds, specialPropertyId))
{
callback.Accept(schemaSupplier);
}
}
}
private TimeoutHandler Renewing(ThrowingConsumer <Clock, Exception> action)
{
return(timeout =>
{
try
{
action.Accept(_clock);
}
catch (Exception e)
{
_log.error("Failed to process timeout.", e);
}
timeout.reset();
});
}
private ThrowingFunction <CyclicBarrier, Node, Exception> MergeThen <T1>(ThrowingConsumer <T1> action) where T1 : Exception
{
return(barrier =>
{
using (Transaction tx = Db.beginTx())
{
Node node = MergeNode();
barrier.await();
action.Accept(node);
tx.success();
return node;
}
});
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: void withPopulator(IndexPopulator populator, org.neo4j.function.ThrowingConsumer<IndexPopulator,Exception> runWithPopulator, boolean closeSuccessfully) throws Exception
internal virtual void WithPopulator(IndexPopulator populator, ThrowingConsumer <IndexPopulator, Exception> runWithPopulator, bool closeSuccessfully)
{
try
{
populator.Create();
runWithPopulator.Accept(populator);
if (closeSuccessfully)
{
populator.ScanCompleted(Org.Neo4j.Kernel.Impl.Api.index.PhaseTracker_Fields.NullInstance);
TestSuite.consistencyCheck(populator);
}
}
finally
{
populator.Close(closeSuccessfully);
}
}
private void AssertIllegalToken(ThrowingConsumer <Token, KernelException> f)
{
try
{
using (Transaction tx = beginTransaction())
{
f.Accept(tx.Token());
fail("Expected IllegalTokenNameException");
}
}
catch (IllegalTokenNameException)
{
// wanted
}
catch (KernelException e)
{
fail("Unwanted exception: " + e.Message);
}
}
/// <summary>
/// Method for calling a lambda function on many objects when it is expected that the function might
/// throw an exception. First exception will be thrown and subsequent will be suppressed.
/// This method guarantees that all subjects will be consumed, unless <seealso cref="System.OutOfMemoryException"/> or some other serious error happens.
/// </summary>
/// <param name="consumer"> lambda function to call on each object passed </param>
/// <param name="subjects"> <seealso cref="System.Collections.IEnumerable"/> of objects to call the function on </param>
/// @param <E> the type of exception anticipated, inferred from the lambda </param>
/// <exception cref="E"> if consumption fails with this exception </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static <T, E extends Exception> void safeForAll(org.neo4j.function.ThrowingConsumer<T,E> consumer, Iterable<T> subjects) throws E
public static void SafeForAll <T, E>(ThrowingConsumer <T, E> consumer, IEnumerable <T> subjects) where E : Exception
{
E exception = null;
foreach (T instance in subjects)
{
try
{
consumer.Accept(instance);
}
catch (Exception e)
{
exception = Exceptions.chain(exception, ( E )e);
}
}
if (exception != null)
{
throw exception;
}
}