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 [https://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, IncompleteConstraintValidationException {
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());
}
}
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();
}
}
}
}