/*
* 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.ivy.plugins.lock;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.util.Enumeration;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.apache.ivy.util.Message;
public abstract class FileBasedLockStrategy extends AbstractLockStrategy {
private static final int SLEEP_TIME = 100;
private static final long DEFAULT_TIMEOUT = 2 * 60 * 1000;
/**
* The locker to use to make file lock attempts.
*/
private FileLocker locker;
private long timeout = DEFAULT_TIMEOUT;
/**
* Lock counter list must be static: locks are implicitly shared to the entire process, so the
* list too much be.
*/
private static ConcurrentMap/* <File, Map<Thread, Integer>> */currentLockHolders = new ConcurrentHashMap();
protected FileBasedLockStrategy() {
this(new CreateFileLocker(false), false);
}
protected FileBasedLockStrategy(boolean debugLocking) {
this(new CreateFileLocker(debugLocking), debugLocking);
}
protected FileBasedLockStrategy(FileLocker locker, boolean debugLocking) {
super(debugLocking);
this.locker = locker;
}
protected boolean acquireLock(File file) throws InterruptedException {
Thread currentThread = Thread.currentThread();
if (isDebugLocking()) {
debugLocking("acquiring lock on " + file);
}
long start = System.currentTimeMillis();
do {
synchronized (currentLockHolders) {
if (isDebugLocking()) {
debugLocking("entered synchronized area (locking)");
}
int lockCount = hasLock(file, currentThread);
if (isDebugLocking()) {
debugLocking("current status for " + file + " is " + lockCount
+ " held locks: " + getCurrentLockHolderNames(file));
}
if (lockCount < 0) {
/* Another thread in this process holds the lock; we need to wait */
if (isDebugLocking()) {
debugLocking("waiting for another thread to release the lock: "
+ getCurrentLockHolderNames(file));
}
} else if (lockCount > 0) {
int holdLocks = incrementLock(file, currentThread);
if (isDebugLocking()) {
debugLocking("reentrant lock acquired on " + file + " in "
+ (System.currentTimeMillis() - start) + "ms" + " - hold locks = "
+ holdLocks);
}
return true;
} else {
/* No prior lock on this file is held at all */
if (locker.tryLock(file)) {
if (isDebugLocking()) {
debugLocking("lock acquired on " + file + " in "
+ (System.currentTimeMillis() - start) + "ms");
}
incrementLock(file, currentThread);
return true;
}
}
}
if (isDebugLocking()) {
debugLocking("failed to acquire lock; sleeping for retry...");
}
Thread.sleep(SLEEP_TIME);
} while (System.currentTimeMillis() - start < timeout);
return false;
}
protected void releaseLock(File file) {
Thread currentThread = Thread.currentThread();
if (isDebugLocking()) {
debugLocking("releasing lock on " + file);
}
synchronized (currentLockHolders) {
if (isDebugLocking()) {
debugLocking("entered synchronized area (unlocking)");
}
int holdLocks = decrementLock(file, currentThread);
if (holdLocks == 0) {
locker.unlock(file);
if (isDebugLocking()) {
debugLocking("lock released on " + file);
}
} else {
if (isDebugLocking()) {
debugLocking("reentrant lock released on " + file + " - hold locks = "
+ holdLocks);
}
}
}
}
private static void debugLocking(String msg) {
Message.info(Thread.currentThread() + " " + System.currentTimeMillis() + " " + msg);
}
/**
* Determine the state of the lockfile.
*
* Must be called from within a synchronized block.
*
* Three possibilities exist: - The lock is held by the current thread (>0) - The lock is held
* by one or more different threads (-1) - The lock is not held at all (0).
*
* @param file
* file to lock
* @param forThread
* thread for which lock status is being queried
*/
private int hasLock(File file, Thread forThread) {
Map locksPerThread = (Map) currentLockHolders.get(file);
if (locksPerThread == null) {
return 0;
}
if (locksPerThread.isEmpty()) {
return 0;
}
Integer counterObj = (Integer) locksPerThread.get(forThread);
int counter = counterObj == null ? 0 : counterObj.intValue();
if (counter > 0) {
return counter;
} else {
return -1;
}
}
/**
* Record that this thread holds the lock.
*
* Asserts that the lock has been previously grabbed by this thread. Must be called from a
* synchronized block in which the lock was grabbed.
*
* @param file
* file which has been locked
* @param forThread
* thread for which locking occurred
* @return number of times this thread has grabbed the lock
*/
private int incrementLock(File file, Thread forThread) {
Map locksPerThread = (Map) currentLockHolders.get(file);
if (locksPerThread == null) {
locksPerThread = new ConcurrentHashMap();
currentLockHolders.put(file, locksPerThread);
}
Integer c = (Integer) locksPerThread.get(forThread);
int holdLocks = c == null ? 1 : c.intValue() + 1;
locksPerThread.put(forThread, new Integer(holdLocks));
return holdLocks;
}
/**
* Decrease depth of this thread's lock.
*
* Must be called within a synchronized block.
*
* If this returns 0, the caller is responsible for releasing the lock within that same block.
*
* @param file
* file for which lock depth is being decreased
* @param forThread
* thread for which lock depth is being decreased
* @return remaining depth of this lock
*/
private int decrementLock(File file, Thread forThread) {
ConcurrentHashMap locksPerThread = (ConcurrentHashMap) currentLockHolders.get(file);
if (locksPerThread == null) {
throw new RuntimeException("Calling decrementLock on a thread which holds no locks");
}
Integer c = (Integer) locksPerThread.get(forThread);
int oldHeldLocks = c == null ? 0 : c.intValue();
if (oldHeldLocks <= 0) {
throw new RuntimeException("Calling decrementLock on a thread which holds no locks");
}
int newHeldLocks = oldHeldLocks - 1;
if (newHeldLocks > 0) {
locksPerThread.put(forThread, new Integer(newHeldLocks));
} else {
locksPerThread.remove(forThread);
}
return newHeldLocks;
}
/**
* Return a string naming the threads which currently hold this lock.
*/
protected String getCurrentLockHolderNames(File file) {
StringBuilder sb = new StringBuilder();
ConcurrentHashMap m = (ConcurrentHashMap) currentLockHolders.get(file);
if (m == null) {
return "(NULL)";
}
Enumeration threads = m.keys();
while (threads.hasMoreElements()) {
Thread t = (Thread) threads.nextElement();
sb.append(t.toString());
if (threads.hasMoreElements()) {
sb.append(", ");
}
}
return sb.toString();
}
public static interface FileLocker {
boolean tryLock(File f);
void unlock(File f);
}
/**
* "locks" a file by creating it if it doesn't exist, relying on the
* {@link File#createNewFile()} atomicity.
*/
public static class CreateFileLocker implements FileLocker {
private boolean debugLocking;
public CreateFileLocker(boolean debugLocking) {
this.debugLocking = debugLocking;
}
public boolean tryLock(File file) {
try {
if (file.getParentFile().exists() || file.getParentFile().mkdirs()) {
if (file.createNewFile()) {
DeleteOnExitHook.add(file);
return true;
} else {
if (debugLocking) {
debugLocking("file creation failed " + file);
}
}
}
} catch (IOException e) {
// ignored
Message.verbose("file creation failed due to an exception: " + e.getMessage()
+ " (" + file + ")");
}
return false;
}
public void unlock(File file) {
file.delete();
DeleteOnExitHook.remove(file);
}
}
/**
* Locks a file using the {@link FileLock} mechanism.
*/
public static class NIOFileLocker implements FileLocker {
private Map locks = new ConcurrentHashMap();
private boolean debugLocking;
public NIOFileLocker(boolean debugLocking) {
this.debugLocking = debugLocking;
}
private static class LockData {
private RandomAccessFile raf;
private FileLock l;
LockData(RandomAccessFile raf, FileLock l) {
this.raf = raf;
this.l = l;
}
}
public boolean tryLock(File file) {
try {
if (file.getParentFile().exists() || file.getParentFile().mkdirs()) {
// this must not be closed until unlock
RandomAccessFile raf = new RandomAccessFile(file, "rw");
FileLock l = raf.getChannel().tryLock();
if (l != null) {
synchronized (this) {
locks.put(file, new LockData(raf, l));
}
return true;
} else {
if (debugLocking) {
debugLocking("failed to acquire lock on " + file);
}
}
}
} catch (IOException e) {
// ignored
Message.verbose("file lock failed due to an exception: " + e.getMessage() + " ("
+ file + ")");
}
return false;
}
public void unlock(File file) {
synchronized (this) {
LockData data = (LockData) locks.get(file);
if (data == null) {
throw new IllegalArgumentException("file not previously locked: " + file);
}
try {
locks.remove(file);
data.l.release();
data.raf.close();
} catch (IOException e) {
Message.error("problem while releasing lock on " + file + ": " + e.getMessage());
}
}
}
}
}