//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void oneOrTheOtherShouldDeadlock() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void OneOrTheOtherShouldDeadlock() { AtomicInteger deadlockCount = new AtomicInteger(); HighlyAvailableGraphDatabase master = _cluster.Master; Node masterA = CreateNodeOnMaster(_testLabel, master); Node masterB = CreateNodeOnMaster(_testLabel, master); HighlyAvailableGraphDatabase slave = _cluster.AnySlave; using (Transaction transaction = slave.BeginTx()) { Node slaveA = slave.GetNodeById(masterA.Id); Node slaveB = slave.GetNodeById(masterB.Id); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); transaction.AcquireWriteLock(slaveB); Thread masterTx = new Thread(() => { try { using (Transaction tx = master.BeginTx()) { tx.acquireWriteLock(masterA); latch.Signal(); tx.acquireWriteLock(masterB); } } catch (DeadlockDetectedException) { deadlockCount.incrementAndGet(); } }); masterTx.Start(); latch.await(); try { transaction.AcquireWriteLock(slaveA); } catch (DeadlockDetectedException) { deadlockCount.incrementAndGet(); } masterTx.Join(); } assertEquals(1, deadlockCount.get()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void transactionShouldReleaseLocksWhenGraphDbIsBeingShutdown() public virtual void TransactionShouldReleaseLocksWhenGraphDbIsBeingShutdown() { // GIVEN //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.impl.locking.Locks locks = db.getDependencyResolver().resolveDependency(org.neo4j.kernel.impl.locking.Locks.class); Locks locks = _db.DependencyResolver.resolveDependency(typeof(Locks)); assertEquals(0, LockCount(locks)); Exception exceptionThrownByTxClose = null; // WHEN try { using (Transaction tx = _db.beginTx()) { Node node = _db.createNode(); tx.AcquireWriteLock(node); assertThat(LockCount(locks), greaterThanOrEqualTo(1)); _db.shutdown(); _db.createNode(); tx.Success(); } } catch (Exception e) { exceptionThrownByTxClose = e; } // THEN assertThat(exceptionThrownByTxClose, instanceOf(typeof(DatabaseShutdownException))); assertFalse(_db.isAvailable(1)); assertEquals(0, LockCount(locks)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void releaseReleaseManually() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ReleaseReleaseManually() { string key = "name"; Node node = GraphDb.createNode(); Tx.success(); Transaction current = Tx.begin(); Lock nodeLock = current.AcquireWriteLock(node); _worker.beginTx(); try { _worker.setProperty(node, key, "ksjd"); fail("Shouldn't be able to grab it"); } catch (Exception) { } nodeLock.Release(); _worker.setProperty(node, key, "yo"); try { _worker.finishTx(); } catch (ExecutionException) { // Ok, interrupting the thread while it's waiting for a lock will lead to tx failure. } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.neo4j.graphdb.Transaction takeExclusiveLock(org.neo4j.graphdb.Label testLabel, org.neo4j.kernel.ha.HighlyAvailableGraphDatabase db) throws org.neo4j.internal.kernel.api.exceptions.EntityNotFoundException private Transaction TakeExclusiveLock(Label testLabel, HighlyAvailableGraphDatabase db) { Transaction transaction = Db.beginTx(); Node node = GetNode(db, testLabel); transaction.AcquireWriteLock(node); return(transaction); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testMultipleCreate() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TestMultipleCreate() { const int numThreads = 25; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String uuid = java.util.UUID.randomUUID().toString(); string uuid = System.Guid.randomUUID().ToString(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.graphdb.Node commonNode; Node commonNode; using (Transaction tx = _graphDb.beginTx()) { commonNode = _graphDb.createNode(); tx.Success(); } ExecutorCompletionService <Node> ecs = new ExecutorCompletionService <Node>(Executors.newFixedThreadPool(numThreads)); for (int i = 0; i < numThreads; i++) { ecs.submit(() => { using (Transaction tx = _graphDb.beginTx()) { Node node = _graphDb.createNode(); // Acquire lock tx.AcquireWriteLock(commonNode); Index <Node> index = _graphDb.index().forNodes("uuids"); Node existing = index.get("uuid", uuid).Single; if (existing != null) { throw new Exception("Node already exists"); } node.setProperty("uuid", uuid); index.add(node, "uuid", uuid); tx.Success(); return(node); } }); } int numSucceeded = 0; for (int i = 0; i < numThreads; i++) { try { ecs.take().get(); ++numSucceeded; } catch (ExecutionException) { } } assertEquals(1, numSucceeded); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void takeExclusiveLockOnSameNodeAfterSwitch(org.neo4j.graphdb.Label testLabel, org.neo4j.kernel.ha.HighlyAvailableGraphDatabase master, org.neo4j.kernel.ha.HighlyAvailableGraphDatabase db) throws org.neo4j.internal.kernel.api.exceptions.EntityNotFoundException private void TakeExclusiveLockOnSameNodeAfterSwitch(Label testLabel, HighlyAvailableGraphDatabase master, HighlyAvailableGraphDatabase db) { using (Transaction transaction = Db.beginTx()) { Node node = GetNode(master, testLabel); transaction.AcquireWriteLock(node); node.SetProperty("key", "value"); transaction.Success(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private <T extends org.neo4j.graphdb.PropertyContainer> Resource<T> test(System.Func<T> setup, String... queries) throws InterruptedException, java.util.concurrent.ExecutionException private Resource <T> Test <T>(System.Func <T> setup, params string[] queries) where T : Org.Neo4j.Graphdb.PropertyContainer { System.Threading.CountdownEvent resourceLocked = new System.Threading.CountdownEvent(1); System.Threading.CountdownEvent listQueriesLatch = new System.Threading.CountdownEvent(1); System.Threading.CountdownEvent finishQueriesLatch = new System.Threading.CountdownEvent(1); T resource; using (Transaction tx = _db.beginTx()) { resource = setup(); tx.Success(); } _threads.execute(parameter => { using (Transaction tx = _db.beginTx()) { tx.AcquireWriteLock(resource); resourceLocked.Signal(); listQueriesLatch.await(); } return(null); }, null); resourceLocked.await(); _threads.executeAndAwait(parameter => { try { using (Transaction tx = _db.beginTx()) { foreach (string query in queries) { _db.execute(query).close(); } tx.Success(); } } catch (Exception t) { Console.WriteLine(t.ToString()); Console.Write(t.StackTrace); throw new Exception(t); } finally { finishQueriesLatch.Signal(); } return(null); }, null, waitingWhileIn(typeof(GraphDatabaseFacade), "execute"), SECONDS_TIMEOUT, SECONDS); return(new Resource <T>(listQueriesLatch, finishQueriesLatch, resource)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void givenClusterWhenShutdownMasterThenCannotStartTransactionOnSlave() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void GivenClusterWhenShutdownMasterThenCannotStartTransactionOnSlave() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase master = cluster.getMaster(); HighlyAvailableGraphDatabase master = _cluster.Master; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase slave = cluster.getAnySlave(); HighlyAvailableGraphDatabase slave = _cluster.AnySlave; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long nodeId; long nodeId; using (Transaction tx = master.BeginTx()) { nodeId = master.CreateNode().Id; tx.Success(); } _cluster.sync(); // When //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.FutureTask<bool> result = new java.util.concurrent.FutureTask<>(() -> FutureTask <bool> result = new FutureTask <bool>(() => { try { using (Transaction tx = slave.BeginTx()) { tx.AcquireWriteLock(slave.GetNodeById(nodeId)); } } catch (Exception e) { return(contains(e, typeof(TransactionFailureException))); } // Fail otherwise return(false); }); DatabaseAvailabilityGuard masterGuard = master.DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard)); masterGuard.AddListener(new UnavailabilityListener(result)); master.Shutdown(); // Then assertThat(result.get(), equalTo(true)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 30_000) public void terminatingTransactionMustEagerlyReleaseTheirLocks() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TerminatingTransactionMustEagerlyReleaseTheirLocks() { AtomicBoolean nodeLockAcquired = new AtomicBoolean(); AtomicBoolean lockerDone = new AtomicBoolean(); BinaryLatch lockerPause = new BinaryLatch(); long nodeId; using (Transaction tx = Database.beginTx()) { nodeId = Database.createNode().Id; tx.Success(); } //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.concurrent.Future<?> locker = executor.submit(() -> Future <object> locker = _executor.submit(() => { using (Transaction tx = Database.beginTx()) { Node node = Database.getNodeById(nodeId); tx.AcquireReadLock(node); nodeLockAcquired.set(true); lockerPause.Await(); } lockerDone.set(true); }); bool proceed; do { proceed = nodeLockAcquired.get(); } while (!proceed); TerminateOngoingTransaction(); assertFalse(lockerDone.get()); // but the thread should still be blocked on the latch // Yet we should be able to proceed and grab the locks they once held using (Transaction tx = Database.beginTx()) { // Write-locking is only possible if their shared lock was released tx.AcquireWriteLock(Database.getNodeById(nodeId)); tx.Success(); } // No exception from our lock client being stopped (e.g. we ended up blocked for too long) or from timeout lockerPause.Release(); locker.get(); assertTrue(lockerDone.get()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void canOnlyReleaseOnce() public virtual void CanOnlyReleaseOnce() { Node node = GraphDb.createNode(); Tx.success(); Transaction current = Tx.begin(); Lock nodeLock = current.AcquireWriteLock(node); nodeLock.Release(); try { nodeLock.Release(); fail("Shouldn't be able to release more than once"); } catch (System.InvalidOperationException) { // Good } }