org.apache.lucene.store.SleepingLockWrapper Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.lucene.store;
import java.io.IOException;
import org.apache.lucene.util.ThreadInterruptedException;
/**
* Directory that wraps another, and that sleeps and retries
* if obtaining the lock fails.
*
* This is not a good idea.
*/
public final class SleepingLockWrapper extends FilterDirectory {
/**
* Pass this lockWaitTimeout to try forever to obtain the lock.
*/
public static final long LOCK_OBTAIN_WAIT_FOREVER = -1;
/**
* How long {@link #obtainLock} waits, in milliseconds,
* in between attempts to acquire the lock.
*/
public static long DEFAULT_POLL_INTERVAL = 1000;
private final long lockWaitTimeout;
private final long pollInterval;
/**
* Create a new SleepingLockFactory
* @param delegate underlying directory to wrap
* @param lockWaitTimeout length of time to wait in milliseconds
* or {@link #LOCK_OBTAIN_WAIT_FOREVER} to retry forever.
*/
public SleepingLockWrapper(Directory delegate, long lockWaitTimeout) {
this(delegate, lockWaitTimeout, DEFAULT_POLL_INTERVAL);
}
/**
* Create a new SleepingLockFactory
* @param delegate underlying directory to wrap
* @param lockWaitTimeout length of time to wait in milliseconds
* or {@link #LOCK_OBTAIN_WAIT_FOREVER} to retry forever.
* @param pollInterval poll once per this interval in milliseconds until
* {@code lockWaitTimeout} is exceeded.
*/
public SleepingLockWrapper(Directory delegate, long lockWaitTimeout, long pollInterval) {
super(delegate);
this.lockWaitTimeout = lockWaitTimeout;
this.pollInterval = pollInterval;
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER) {
throw new IllegalArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
}
if (pollInterval < 0) {
throw new IllegalArgumentException("pollInterval must be a non-negative number (got " + pollInterval + ")");
}
}
@Override
public Lock obtainLock(String lockName) throws IOException {
LockObtainFailedException failureReason = null;
long maxSleepCount = lockWaitTimeout / pollInterval;
long sleepCount = 0;
do {
try {
return in.obtainLock(lockName);
} catch (LockObtainFailedException failed) {
if (failureReason == null) {
failureReason = failed;
}
}
try {
Thread.sleep(pollInterval);
} catch (InterruptedException ie) {
throw new ThreadInterruptedException(ie);
}
} while (sleepCount++ < maxSleepCount || lockWaitTimeout == LOCK_OBTAIN_WAIT_FOREVER);
// we failed to obtain the lock in the required time
String reason = "Lock obtain timed out: " + this.toString();
if (failureReason != null) {
reason += ": " + failureReason;
}
throw new LockObtainFailedException(reason, failureReason);
}
@Override
public String toString() {
return "SleepingLockWrapper(" + in + ")";
}
}