/*
* ====================================================================
* Copyright (c) 2004-2009 TMate Software Ltd. All rights reserved.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://svnkit.com/license.html
* If newer versions of this license are posted there, you may use a
* newer version instead, at your option.
* ====================================================================
*/
package org.tmatesoft.svn.core.internal.io.fs;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.util.Map;
import org.tmatesoft.svn.core.SVNErrorCode;
import org.tmatesoft.svn.core.SVNErrorMessage;
import org.tmatesoft.svn.core.SVNException;
import org.tmatesoft.svn.core.internal.util.SVNHashMap;
import org.tmatesoft.svn.core.internal.wc.SVNErrorManager;
import org.tmatesoft.svn.core.internal.wc.SVNFileType;
import org.tmatesoft.svn.core.internal.wc.SVNFileUtil;
import org.tmatesoft.svn.util.SVNLogType;
/**
* @version 1.3
* @author TMate Software Ltd.
*/
public class FSWriteLock {
private static final Map ourThreadDBLocksCache = new SVNHashMap();
private static final Map ourThreadRepositoryLocksCache = new SVNHashMap();
private static final Map ourThreadLogLocksCache = new SVNHashMap();
private static final int DB_LOCK = 1;
private static final int LOGS_LOCK = 2;
private static final int REPOS_LOCK = 3;
private File myLockFile;
private RandomAccessFile myLockRAFile;
private FileLock myLock;
private String myToken;
private int myLockType;
private boolean myIsShared;
private int myReferencesCount = 0;
private FSWriteLock(String token, File lockFile, int lockType, boolean shared) {
myToken = token;
myLockFile = lockFile;
myLockType = lockType;
myIsShared = shared;
}
public static synchronized FSWriteLock getWriteLockForDB(FSFS owner) throws SVNException {
String uuid = owner.getUUID();
FSWriteLock lock = (FSWriteLock) ourThreadDBLocksCache.get(uuid);
if (lock == null) {
lock = new FSWriteLock(uuid, owner.getWriteLockFile(), DB_LOCK, false);
ourThreadDBLocksCache.put(uuid, lock);
}
lock.myReferencesCount++;
return lock;
}
public static synchronized FSWriteLock getWriteLockForCurrentTxn(String token, FSFS owner) throws SVNException {
if (token == null || token.length() == 0){
SVNErrorManager.error(SVNErrorMessage.create(SVNErrorCode.FS_NO_LOCK_TOKEN, "Incorrect lock token for current transaction"), SVNLogType.FSFS);
}
String uuid = owner.getUUID() + token;
FSWriteLock lock = (FSWriteLock) ourThreadDBLocksCache.get(uuid);
if (lock == null) {
lock = new FSWriteLock(uuid, owner.getTransactionCurrentLockFile(), DB_LOCK, false);
ourThreadDBLocksCache.put(uuid, lock);
}
lock.myReferencesCount++;
return lock;
}
public static synchronized FSWriteLock getWriteLockForTxn(String txnID, FSFS owner) throws SVNException {
if (txnID == null || txnID.length() == 0){
SVNErrorManager.error(SVNErrorMessage.create(SVNErrorCode.FS_NO_LOCK_TOKEN, "Incorrect txn id while locking"), SVNLogType.FSFS);
}
String uuid = owner.getUUID() + txnID;
FSWriteLock lock = (FSWriteLock) ourThreadDBLocksCache.get(uuid);
if (lock == null) {
lock = new FSWriteLock(uuid, owner.getTransactionProtoRevLockFile(txnID), DB_LOCK, false);
ourThreadDBLocksCache.put(uuid, lock);
}
lock.myReferencesCount++;
return lock;
}
public static synchronized FSWriteLock getDBLogsLock(FSFS owner, boolean exclusive) throws SVNException {
String uuid = owner.getUUID();
FSWriteLock lock = (FSWriteLock) ourThreadLogLocksCache.get(uuid);
if (lock == null) {
lock = new FSWriteLock(uuid, owner.getDBLogsLockFile(), LOGS_LOCK, !exclusive);
ourThreadLogLocksCache.put(uuid, lock);
}
lock.myReferencesCount++;
return lock;
}
public synchronized void lock() throws SVNException {
boolean errorOccured = false;
Exception childError = null;
if (myLock != null) {
errorOccured = true;
}
try {
SVNFileType type = SVNFileType.getType(myLockFile);
if (type == SVNFileType.UNKNOWN || type == SVNFileType.NONE) {
SVNFileUtil.createEmptyFile(myLockFile);
}
myLockRAFile = new RandomAccessFile(myLockFile, "rw");
myLock = myLockRAFile.getChannel().lock(0L, Long.MAX_VALUE, myIsShared);
} catch (IOException ioe) {
unlock();
errorOccured = true;
childError = ioe;
}
if (errorOccured) {
String msg = childError == null ? "file already locked" : childError.getMessage();
SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.IO_ERROR,
"Can''t get exclusive lock on file ''{0}'': {1}", new Object[]{ myLockFile, msg });
SVNErrorManager.error(err, childError, SVNLogType.FSFS);
}
}
public static synchronized void release(FSWriteLock lock) {
if (lock == null) {
return;
}
if ((--lock.myReferencesCount) == 0) {
if (lock.myLockType == DB_LOCK) {
ourThreadDBLocksCache.remove(lock.myToken);
} else if (lock.myLockType == REPOS_LOCK) {
ourThreadRepositoryLocksCache.remove(lock.myToken);
} else if (lock.myLockType == LOGS_LOCK) {
ourThreadLogLocksCache.remove(lock.myToken);
}
}
}
public synchronized void unlock() throws SVNException {
if (myLock != null) {
try {
myLock.release();
} catch (IOException ioex) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.IO_ERROR,
"Unexpected error while releasing file lock on ''{0}''", myLockFile);
SVNErrorManager.error(error, ioex, SVNLogType.FSFS);
}
myLock = null;
}
SVNFileUtil.closeFile(myLockRAFile);
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("{[");
buffer.append("File:");
buffer.append(myLockFile);
buffer.append("][");
buffer.append("RefCount:");
buffer.append(myReferencesCount);
buffer.append("][");
buffer.append("Token:");
buffer.append(myToken);
buffer.append("]}");
return buffer.toString();
}
}