org.neo4j.kernel.impl.api.index.FlippableIndexProxy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [http://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see
* if ( !lock.tryLock() ) // try to barge
* lock.lock(); // fall back to normal blocking lock call
*
* This would however not implement the appropriate barging behaviour in a scenario like the following: Say the
* exclusive lock is held, and there is a queue waiting containing first a reader and then a writer, in this case
* the {@code tryLock()} method will return false. If the writer then finishes between the naive implementation
* exiting {@code tryLock()} and before entering {@code lock()} the {@code barge(...)} method would now block in
* the exact way we don't want it to block, with a read lock held and a writer waiting.
* In order to get around this situation, the implementation of this method uses a
* {@linkplain Lock#tryLock(long, TimeUnit) timed wait} in a retry-loop in order to ensure that we make another
* attempt to barge the lock at a later point.
*
* This method is written to be compatible with the signature of {@link Lock#lock()}, which is not interruptible,
* but implemented based on the interruptible {@link Lock#tryLock(long, TimeUnit)}, so the implementation needs to
* remember being interrupted, and reset the flag before exiting, so that later invocations of interruptible
* methods detect the interruption.
*
* @param lock a {@link java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock}
*/
private static void barge( ReentrantReadWriteLock.ReadLock lock )
{
boolean interrupted = false;
// exponential retry back-off, no more than 1 second
for ( long timeout = 10; !lock.tryLock(); timeout = Math.min( 1000, timeout * 2 ) )
{
try
{
if ( lock.tryLock( timeout, TimeUnit.MILLISECONDS ) )
{
return;
}
}
// the barge()-method is uninterruptable, but implemented based on the interruptible tryLock()-method
catch ( InterruptedException e )
{
Thread.interrupted(); // ensure the interrupt flag is cleared
interrupted = true; // remember to set interrupt flag before we exit
}
}
if ( interrupted )
{
Thread.currentThread().interrupt(); // reset the interrupt flag
}
}
@Override
public IndexDescriptor getDescriptor()
{
lock.readLock().lock();
try
{
return delegate.getDescriptor();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public InternalIndexState getState()
{
lock.readLock().lock();
try
{
return delegate.getState();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public void close( CursorContext cursorContext ) throws IOException
{
lock.readLock().lock();
try
{
closed = true;
delegate.close( cursorContext );
}
finally
{
lock.readLock().unlock();
}
}
@Override
public ValueIndexReader newValueReader() throws IndexNotFoundKernelException
{
lock.readLock().lock();
try
{
return delegate.newValueReader();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public TokenIndexReader newTokenReader() throws IndexNotFoundKernelException
{
lock.readLock().lock();
try
{
return delegate.newTokenReader();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public boolean awaitStoreScanCompleted( long time, TimeUnit unit ) throws IndexPopulationFailedKernelException, InterruptedException
{
IndexProxy proxy;
lock.readLock().lock();
proxy = delegate;
lock.readLock().unlock();
if ( closed )
{
return false;
}
boolean stillGoing = proxy.awaitStoreScanCompleted( time, unit );
if ( !stillGoing )
{
// The waiting has ended. However we're not done because say that the delegate typically is a populating proxy, when the wait is over
// the populating proxy flips into something else, and if that is a failed proxy then that failure should propagate out from this call.
lock.readLock().lock();
proxy = delegate;
lock.readLock().unlock();
proxy.awaitStoreScanCompleted( time, unit );
}
return stillGoing;
}
@Override
public void activate() throws IndexActivationFailedKernelException
{
// use write lock, since activate() might call flip*() which acquires a write lock itself.
lock.writeLock().lock();
try
{
delegate.activate();
}
finally
{
lock.writeLock().unlock();
}
}
@Override
public void validate() throws IndexPopulationFailedKernelException, UniquePropertyValueValidationException
{
lock.readLock().lock();
try
{
delegate.validate();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public void validateBeforeCommit( Value[] tuple, long entityId )
{
lock.readLock().lock();
try
{
delegate.validateBeforeCommit( tuple, entityId );
}
finally
{
lock.readLock().unlock();
}
}
@Override
public ResourceIterator snapshotFiles() throws IOException
{
lock.readLock().lock();
try
{
return delegate.snapshotFiles();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public Map indexConfig()
{
lock.readLock().lock();
try
{
return delegate.indexConfig();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public IndexPopulationFailure getPopulationFailure() throws IllegalStateException
{
lock.readLock().lock();
try
{
return delegate.getPopulationFailure();
}
finally
{
lock.readLock().unlock();
}
}
@Override
public PopulationProgress getIndexPopulationProgress()
{
lock.readLock().lock();
try
{
return delegate.getIndexPopulationProgress();
}
finally
{
lock.readLock().unlock();
}
}
void setFlipTarget( IndexProxyFactory flipTarget )
{
lock.writeLock().lock();
try
{
this.flipTarget = flipTarget;
}
finally
{
lock.writeLock().unlock();
}
}
void flipTo( IndexProxy targetDelegate )
{
lock.writeLock().lock();
try
{
this.delegate = targetDelegate;
}
finally
{
lock.writeLock().unlock();
}
}
public void flip( Callable actionDuringFlip, FailedIndexProxyFactory failureDelegate )
throws FlipFailedKernelException
{
lock.writeLock().lock();
try
{
assertOpen();
try
{
if ( actionDuringFlip.call() )
{
this.delegate = flipTarget.create();
if ( started )
{
this.delegate.start();
}
}
}
catch ( Exception e )
{
this.delegate = failureDelegate.create( e );
throw new ExceptionDuringFlipKernelException( e );
}
}
finally
{
lock.writeLock().unlock();
}
}
@Override
public String toString()
{
return getClass().getSimpleName() + " -> " + delegate + "[target:" + flipTarget + "]";
}
private void assertOpen() throws IndexProxyAlreadyClosedKernelException
{
if ( closed )
{
throw new IndexProxyAlreadyClosedKernelException( this.getClass() );
}
}
@Override
public void verifyDeferredConstraints( NodePropertyAccessor accessor ) throws IndexEntryConflictException, IOException
{
lock.readLock().lock();
try
{
delegate.verifyDeferredConstraints( accessor );
}
finally
{
lock.readLock().unlock();
}
}
private class LockingIndexUpdater extends DelegatingIndexUpdater
{
private LockingIndexUpdater( IndexUpdater delegate )
{
super( delegate );
lock.readLock().lock();
}
@Override
public void close() throws IndexEntryConflictException
{
try
{
delegate.close();
}
finally
{
lock.readLock().unlock();
}
}
}
}