public DAVLock refreshLock(DAVResource resource, String lockToken, Date newTime)
throws DAVException {
// TODO: add here authz check
FSFS fsfs = resource.getFSFS();
String path = resource.getResourceURI().getPath();
FSLock svnLock = null;
try {
svnLock = (FSLock) fsfs.getLockHelper(path, false);
} catch (SVNException e) {
throw DAVException.convertError(
e.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Token doesn't point to a lock.",
null);
}
if (svnLock == null || !svnLock.getID().equals(lockToken)) {
throw new DAVException(
"Lock refresh request doesn't match existing lock.",
HttpServletResponse.SC_UNAUTHORIZED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
try {
svnLock =
(FSLock)
fsfs.lockPath(
svnLock.getPath(),
svnLock.getID(),
resource.getUserName(),
svnLock.getComment(),
newTime,
SVNRepository.INVALID_REVISION,
true,
svnLock.isDAVComment());
} catch (SVNException e) {
SVNErrorMessage err = e.getErrorMessage();
if (err.getErrorCode() == SVNErrorCode.FS_NO_USER) {
throw new DAVException(
"Anonymous lock refreshing is not allowed.",
HttpServletResponse.SC_UNAUTHORIZED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
throw DAVException.convertError(
err,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to refresh existing lock.",
null);
}
return convertSVNLockToDAVLock(svnLock, false, resource.exists());
}
public void appendLock(DAVResource resource, DAVLock lock) throws DAVException {
// TODO: add here authz check later
FSFS fsfs = resource.getFSFS();
String path = resource.getResourceURI().getPath();
if (!resource.exists()) {
SVNProperties revisionProps = new SVNProperties();
revisionProps.put(SVNRevisionProperty.AUTHOR, resource.getUserName());
DAVConfig config = resource.getRepositoryManager().getDAVConfig();
if (resource.isSVNClient()) {
throw new DAVException(
"Subversion clients may not lock nonexistent paths.",
HttpServletResponse.SC_METHOD_NOT_ALLOWED,
DAVErrorCode.LOCK_SAVE_LOCK);
} else if (!config.isAutoVersioning()) {
throw new DAVException(
"Attempted to lock non-existent path; turn on autoversioning first.",
HttpServletResponse.SC_METHOD_NOT_ALLOWED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
long youngestRev = SVNRepository.INVALID_REVISION;
try {
youngestRev = resource.getLatestRevision();
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Could not determine youngest revision",
null);
}
FSTransactionInfo txnInfo = null;
try {
txnInfo = FSTransactionRoot.beginTransactionForCommit(youngestRev, revisionProps, fsfs);
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Could not begin a transaction",
null);
}
FSTransactionRoot root = null;
try {
root = fsfs.createTransactionRoot(txnInfo);
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Could not begin a transaction",
null);
}
FSCommitter committer =
new FSCommitter(fsfs, root, txnInfo, resource.getLockTokens(), resource.getUserName());
try {
committer.makeFile(path);
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Could not create empty file.",
null);
}
try {
DAVServletUtil.attachAutoRevisionProperties(txnInfo, path, fsfs);
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Could not create empty file.",
null);
}
StringBuffer conflictPath = new StringBuffer();
try {
committer.commitTxn(true, true, null, conflictPath);
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_CONFLICT,
"Conflict when committing ''{0}''.",
new Object[] {conflictPath.toString()});
}
}
FSLock svnLock =
convertDAVLockToSVNLock(
lock, path, resource.isSVNClient(), ServletDAVHandler.getSAXParserFactory());
try {
fsfs.lockPath(
path,
svnLock.getID(),
svnLock.getOwner(),
svnLock.getComment(),
svnLock.getExpirationDate(),
myWorkingRevision,
myIsStealLock,
svnLock.isDAVComment());
} catch (SVNException svne) {
if (svne.getErrorMessage().getErrorCode() == SVNErrorCode.FS_NO_USER) {
throw new DAVException(
"Anonymous lock creation is not allowed.",
HttpServletResponse.SC_UNAUTHORIZED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to create new lock.",
null);
}
myOwner.setResponseHeader(
HTTPHeader.CREATION_DATE_HEADER, SVNDate.formatDate(svnLock.getCreationDate()));
myOwner.setResponseHeader(HTTPHeader.LOCK_OWNER_HEADER, svnLock.getOwner());
// TODO: add logging here later
}