@Test public void detachDeleteNodeWithoutRelationshipsExclusivelyLockNode() throws KernelException { long nodeId = 1L; returnRelationships( transaction, false, new TestRelationshipChain( nodeId ) ); when( transaction.ambientNodeCursor() ).thenReturn( new StubNodeCursor( false ) ); when( nodeCursor.next() ).thenReturn( true ); LabelSet labels = mock( LabelSet.class ); when( labels.all() ).thenReturn( EMPTY_LONG_ARRAY ); when( nodeCursor.labels() ).thenReturn( labels ); operations.nodeDetachDelete( nodeId ); order.verify( locks ).acquireExclusive( LockTracer.NONE, ResourceTypes.NODE, nodeId ); order.verify( locks, never() ).releaseExclusive( ResourceTypes.NODE, nodeId ); order.verify( txState ).nodeDoDelete( nodeId ); }
@Test public void shouldTraceWaitTimeWhenTryingToAcquireSharedLockAndExclusiveIsHeld() throws Exception { // given Tracer tracerA = new Tracer(); Tracer tracerB = new Tracer(); clientA.acquireExclusive( tracerA, NODE, 17 ); // when Future<Object> future = acquireShared( clientB, tracerB, NODE, 17 ).callAndAssertWaiting(); // then clientA.releaseExclusive( NODE, 17 ); future.get(); tracerA.assertCalls( 0 ); tracerB.assertCalls( 1 ); }
@Test public void shouldTraceWaitTimeWhenTryingToAcquireExclusiveLockAndExclusiveIsHeld() throws Exception { // given Tracer tracerA = new Tracer(); Tracer tracerB = new Tracer(); clientA.acquireExclusive( tracerA, NODE, 17 ); // when Future<Object> future = acquireExclusive( clientB, tracerB, NODE, 17 ).callAndAssertWaiting(); // then clientA.releaseExclusive( NODE, 17 ); future.get(); tracerA.assertCalls( 0 ); tracerB.assertCalls( 1 ); }
@Test public void shouldRetainExclusiveLockAfterReleasingSharedLock() { // When clientA.acquireShared( LockTracer.NONE, NODE, 1L ); clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); // Then shared locks should wait Future<Object> clientBLock = acquireShared( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseShared( NODE, 1L ); // Then other thread should still wait assertWaiting( clientB, clientBLock ); // But when clientA.releaseExclusive( NODE, 1L ); // Then assertNotWaiting( clientB, clientBLock ); }
@Test public void sharedLocksShouldNotReplaceExclusiveLocks() { // When clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); clientA.acquireShared( LockTracer.NONE, NODE, 1L ); // Then shared locks should wait Future<Object> clientBLock = acquireShared( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseShared( NODE, 1L ); // Then other thread should still wait assertWaiting( clientB, clientBLock ); // But when clientA.releaseExclusive( NODE, 1L ); // Then assertNotWaiting( clientB, clientBLock ); }
@Test public void shouldAcquireExclusiveIfClientIsOnlyOneHoldingShared() { // When clientA.acquireShared( LockTracer.NONE, NODE, 1L ); clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); // Then shared locks should wait Future<Object> clientBLock = acquireExclusive( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseExclusive( NODE, 1L ); // Then other thread should still wait assertWaiting( clientB, clientBLock ); // But when clientA.releaseShared( NODE, 1L ); // Then assertNotWaiting( clientB, clientBLock ); }
@Test public void shouldRetainSharedLockWhenAcquiredAfterExclusiveLock() { // When clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); clientA.acquireShared( LockTracer.NONE, NODE, 1L ); // Then this should wait Future<Object> clientBLock = acquireExclusive( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseExclusive( NODE, 1L ); // Then other thread should still wait assertWaiting( clientB, clientBLock ); // But when clientA.releaseShared( NODE, 1L ); // Then assertNotWaiting( clientB, clientBLock ); }
@Test public void releaseExclusiveLocksAcquiredSeparately() { clientA.acquireExclusive( LockTracer.NONE, NODE, 1 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 2 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 3 ); assertEquals( 3, lockCount() ); assertFalse( clientB.trySharedLock( NODE, 1 ) ); assertFalse( clientB.trySharedLock( NODE, 2 ) ); assertFalse( clientB.trySharedLock( NODE, 3 ) ); clientA.releaseExclusive( NODE, 1, 2, 3 ); assertEquals( 0, lockCount() ); assertTrue( clientB.trySharedLock( NODE, 1 ) ); assertTrue( clientB.trySharedLock( NODE, 2 ) ); assertTrue( clientB.trySharedLock( NODE, 3 ) ); }
@Test public void releaseMultipleAlreadyAcquiredExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 100, 1000, 10000 ); clientA.releaseExclusive( NODE, 100, 1000 ); assertEquals( 4, lockCount() ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.trySharedLock( NODE, 10000 ) ); clientA.releaseExclusive( NODE, 100, 1000 ); assertEquals( 2, lockCount() ); }
@Test public void releaseMultipleExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertEquals( 3, lockCount() ); clientA.releaseExclusive( NODE, 10, 100 ); assertEquals( 1, lockCount() ); assertTrue( clientB.trySharedLock( NODE, 10 ) ); assertTrue( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); }
private void unlockAllNodes( long[] nodeIds ) { locks.releaseExclusive( ResourceTypes.NODE, nodeIds ); }
private void releaseExclusiveLock( ResourceTypes types, long... ids ) { ktx.statementLocks().pessimistic().releaseExclusive( types, ids ); }
@Test public void shouldUpgradeExclusiveOnTry() { // Given I've grabbed a shared lock clientA.acquireShared( LockTracer.NONE, NODE, 1L ); // When assertTrue( clientA.tryExclusiveLock( NODE, 1L ) ); // Then I should be able to release it clientA.releaseExclusive( NODE, 1L ); }
void release() { if ( shared ) { client.releaseShared( resourceType, resourceId ); } else { client.releaseExclusive( resourceType, resourceId ); } } }
@Test public void shouldReleaseExclusiveLocksAcquiredInABatch() { clientA.acquireExclusive( LockTracer.NONE, NODE, 1, 10, 100 ); assertEquals( 3, lockCount() ); clientA.releaseExclusive( NODE, 1 ); assertEquals( 2, lockCount() ); clientA.releaseExclusive( NODE, 10 ); assertEquals( 1, lockCount() ); clientA.releaseExclusive( NODE, 100 ); assertEquals( 0, lockCount() ); }
@Override public void doWork( Locks.Client client ) { client.releaseExclusive( resourceType, key ); } };
@Test public void exclusiveShouldWaitForExclusive() { // When clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); // Then Future<Object> clientBLock = acquireExclusive( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseExclusive( NODE, 1L ); // Then this should not block assertNotWaiting( clientB, clientBLock ); }
@Override protected void acquireLock( LockWorkerState state ) { state.doing( "-W " + resource ); state.client.releaseExclusive( NODE, resource ); state.done(); } }, true );
@Test public void sharedShouldWaitForExclusive() { // When clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); // Then shared locks should wait Future<Object> clientBLock = acquireShared( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseExclusive( NODE, 1L ); // Then this should not block assertNotWaiting( clientB, clientBLock ); }
@Test( expected = LockClientStoppedException.class ) public void releaseExclusiveThrowsWhenClientStopped() { stoppedClient().releaseExclusive( NODE, 1 ); }