@Test public void shouldAcquireSchemaReadLockBeforeCheckingExistenceConstraints() { // WHEN allStoreHolder.constraintExists( ConstraintDescriptorFactory.uniqueForSchema( descriptor ) ); // THEN order.verify( locks ).acquireShared( LockTracer.NONE, ResourceTypes.LABEL, 123 ); order.verify( storageReader ).constraintExists( any() ); }
@Test public void shouldAcquireSchemaReadLockBeforeGettingConstraintsByLabel() { // WHEN allStoreHolder.constraintsGetForLabel( 42 ); // THEN order.verify( locks ).acquireShared( LockTracer.NONE, ResourceTypes.LABEL, 42 ); order.verify( storageReader ).constraintsGetForLabel( 42 ); }
@Test public void shouldAcquireSchemaReadLockBeforeGettingConstraintsByLabelAndProperty() { // WHEN allStoreHolder.constraintsGetForSchema( descriptor ); // THEN order.verify( locks ).acquireShared( LockTracer.NONE, ResourceTypes.LABEL, descriptor.getLabelId() ); order.verify( storageReader ).constraintsGetForSchema( descriptor ); }
private void acquireSharedLock( ResourceTypes types, long... ids ) { ktx.statementLocks().pessimistic().acquireShared( ktx.lockTracer(), types, ids ); }
void acquireSharedLock( ResourceType resource, long resourceId ) { ktx.statementLocks().optimistic().acquireShared( ktx.lockTracer(), resource, resourceId ); }
void acquireSharedSchemaLock( SchemaDescriptor schema ) { long[] lockingIds = schemaTokenLockingIds( schema ); ktx.statementLocks().optimistic().acquireShared( ktx.lockTracer(), schema.keyType(), lockingIds ); }
@Override protected void acquireLock( LockWorkerState state ) throws AcquireLockTimeoutException { state.doing( "+R " + resource + ", wait:" + wait ); state.client.acquireShared( LockTracer.NONE, NODE, resource ); state.done(); } }, wait );
@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 shouldReleaseSharedLocksAcquiredInABatch() { clientA.acquireShared( LockTracer.NONE, NODE, 1, 10, 100 ); assertEquals( 3, lockCount() ); clientA.releaseShared( NODE, 1 ); assertEquals( 2, lockCount() ); clientA.releaseShared( NODE, 10 ); assertEquals( 1, lockCount() ); clientA.releaseShared( NODE, 100 ); assertEquals( 0, 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 shouldNotBeAbleToAcquireSharedLockFromClosedClient() { clientA.close(); clientA.acquireShared( LockTracer.NONE, NODE, 1L ); }
/** * Assuming that the nodeCursor have been initialized to the node that labels are retrieved from */ private void acquireSharedNodeLabelLocks() { ktx.statementLocks().optimistic().acquireShared( ktx.lockTracer(), ResourceTypes.LABEL, nodeCursor.labels().all() ); }
private ConstraintDescriptor lockConstraint( ConstraintDescriptor constraint ) { SchemaDescriptor schema = constraint.schema(); ktx.statementLocks().pessimistic().acquireShared( ktx.lockTracer(), schema.keyType(), schema.keyId() ); return constraint; } }
@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 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 ); }
@Override public void doWork( Locks.Client client ) throws AcquireLockTimeoutException { client.acquireShared( tracer, resourceType, key ); } };
@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 ) ); }
private AcquiredLock acquireSharedLockInThisThread() { client.acquireShared( TRACER, NODE, FIRST_NODE_ID ); assertLocksHeld( FIRST_NODE_ID ); return AcquiredLock.shared( client, NODE, FIRST_NODE_ID ); }
@Test( expected = LockClientStoppedException.class ) public void acquireSharedThrowsWhenClientStopped() { stoppedClient().acquireShared( TRACER, NODE, 1 ); }