@Override public boolean tryExclusiveLock( ResourceType resourceType, long resourceId ) { ensureHoldingToken(); return localClient.tryExclusiveLock( resourceType, resourceId ); }
@Override public boolean tryExclusiveLock( ResourceType resourceType, long resourceId ) { ensureHoldingToken(); return localClient.tryExclusiveLock( resourceType, resourceId ); }
@Test public void exclusiveLocksShouldBeReentrantAndBlockOtherSharedLocks() { // When clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); clientA.acquireShared( LockTracer.NONE, NODE, 1L ); clientA.tryExclusiveLock( NODE, 1L ); // Then exclusive locks should wait Future<Object> clientBLock = acquireShared( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseExclusive( NODE, 1L ); 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 releaseMultipleSharedLocksWhileHavingSomeExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); clientA.releaseShared( NODE, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test public void releaseSharedLocksAcquiredSeparately() { clientA.acquireShared( LockTracer.NONE, NODE, 1 ); clientA.acquireShared( LockTracer.NONE, NODE, 2 ); clientA.acquireShared( LockTracer.NONE, NODE, 3 ); assertEquals( 3, lockCount() ); assertFalse( clientB.tryExclusiveLock( NODE, 1 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 2 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 3 ) ); clientA.releaseShared( NODE, 1, 2, 3 ); assertEquals( 0, lockCount() ); assertTrue( clientB.tryExclusiveLock( NODE, 1 ) ); assertTrue( clientB.tryExclusiveLock( NODE, 2 ) ); assertTrue( clientB.tryExclusiveLock( NODE, 3 ) ); }
@Test public void releaseMultipleExclusiveLocksWhileHavingSomeSharedLocks() { clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); clientA.releaseExclusive( NODE, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 100 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test public void releaseMultipleAlreadyAcquiredSharedLocks() { clientA.acquireShared( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); clientA.releaseShared( NODE, 100, 1000 ); assertEquals( 4, lockCount() ); assertFalse( clientB.tryExclusiveLock( NODE, 100 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 1000 ) ); clientA.releaseShared( NODE, 100, 1000 ); assertEquals( 2, lockCount() ); }
@Test public void shouldAcquireMultipleSharedLocksWhileHavingSomeExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test( expected = LockClientStoppedException.class ) public void tryExclusiveLockThrowsWhenClientStopped() { stoppedClient().tryExclusiveLock( NODE, 1 ); }
@Test public void shouldAcquireMultipleAlreadyAcquiredSharedLocks() { clientA.acquireShared( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); assertFalse( clientB.tryExclusiveLock( NODE, 10 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 100 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test public void shouldAcquireMultipleSharedLocks() { clientA.acquireShared( LockTracer.NONE, NODE, 10, 100, 1000 ); assertFalse( clientB.tryExclusiveLock( NODE, 10 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 100 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 1000 ) ); assertEquals( 3, lockCount() ); }
@Test public void releaseTryLocksOnClose() { assertTrue( clientA.trySharedLock( ResourceTypes.NODE, 1L ) ); assertTrue( clientB.tryExclusiveLock( ResourceTypes.NODE, 2L ) ); clientA.close(); clientB.close(); LockCountVisitor lockCountVisitor = new LockCountVisitor(); locks.accept( lockCountVisitor ); assertEquals( 0, lockCountVisitor.getLockCount() ); } }
@Test( expected = LockClientStoppedException.class ) public void shouldNotBeAbleToTryAcquireExclusiveLockFromClosedClient() { clientA.close(); clientA.tryExclusiveLock( NODE, 1L ); }
@Test public void releaseMultipleSharedLocks() { clientA.acquireShared( LockTracer.NONE, NODE, 10, 100, 1000 ); assertEquals( 3, lockCount() ); clientA.releaseShared( NODE, 100, 1000 ); assertEquals( 1, lockCount() ); assertFalse( clientB.tryExclusiveLock( NODE, 10 ) ); assertTrue( clientB.tryExclusiveLock( NODE, 100 ) ); assertTrue( clientB.tryExclusiveLock( NODE, 1000 ) ); }
@Test public void shouldTryExclusiveLock() { // Given I've grabbed an exclusive lock assertTrue( clientA.tryExclusiveLock( NODE, 1L ) ); // Then other clients can't have exclusive locks assertFalse( clientB.tryExclusiveLock( NODE, 1L ) ); // Nor can they have share locks assertFalse( clientB.trySharedLock( NODE, 1L ) ); }
@Test public void shouldTrySharedLock() { // Given I've grabbed a share lock assertTrue( clientA.trySharedLock( NODE, 1L ) ); // Then other clients can't have exclusive locks assertFalse( clientB.tryExclusiveLock( NODE, 1L ) ); // But they are allowed share locks assertTrue( clientB.trySharedLock( NODE, 1L ) ); }
@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 ); }
@Test public void shouldTryUpgradeSharedToExclusive() { // Given I've grabbed an exclusive lock assertTrue( clientA.trySharedLock( NODE, 1L ) ); // Then I can upgrade it to exclusive assertTrue( clientA.tryExclusiveLock( NODE, 1L ) ); // And other clients are denied it assertFalse( clientB.trySharedLock( NODE, 1L ) ); }