public DAVLock findLock(DAVResource resource, String lockToken) throws DAVException {
// TODO: add here authz check later
DAVLock davLock = null;
FSLock lock = null;
try {
lock = (FSLock) resource.getLock();
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to look up lock by path.",
null);
}
if (lock != null) {
if (!lockToken.equals(lock.getID())) {
throw new DAVException(
"Incoming token doesn't match existing lock.",
HttpServletResponse.SC_BAD_REQUEST,
DAVErrorCode.LOCK_SAVE_LOCK);
}
davLock = convertSVNLockToDAVLock(lock, false, resource.exists());
myOwner.setResponseHeader(
HTTPHeader.CREATION_DATE_HEADER, SVNDate.formatDate(lock.getCreationDate()));
myOwner.setResponseHeader(HTTPHeader.LOCK_OWNER_HEADER, lock.getOwner());
}
return davLock;
}
public DAVLock getLock(DAVResource resource) throws DAVException {
if (resource.getResourceURI().getPath() == null) {
return null;
}
if (DAVHandlerFactory.METHOD_LOCK.equals(myOwner.getRequestMethod())) {
return null;
}
// TODO: add authz check here later
DAVLock davLock = null;
FSLock lock = null;
try {
lock = (FSLock) resource.getLock();
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to check path for a lock.",
null);
}
if (lock != null) {
davLock = convertSVNLockToDAVLock(lock, myIsBreakLock, resource.exists());
myOwner.setResponseHeader(
HTTPHeader.CREATION_DATE_HEADER, SVNDate.formatDate(lock.getCreationDate()));
myOwner.setResponseHeader(HTTPHeader.LOCK_OWNER_HEADER, lock.getOwner());
}
return davLock;
}
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 static DAVLock convertSVNLockToDAVLock(FSLock lock, boolean hideAuthUser, boolean exists) {
String authUser = null;
StringBuffer owner = null;
if (lock.getComment() != null) {
owner = new StringBuffer();
if (!lock.isDAVComment()) {
List namespaces = new ArrayList(1);
namespaces.add(DAVElement.DAV_NAMESPACE);
owner =
DAVXMLUtil.openNamespaceDeclarationTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX,
DAVElement.LOCK_OWNER.getName(),
namespaces,
null,
owner,
false,
false);
owner.append(SVNEncodingUtil.xmlEncodeCDATA(lock.getComment(), true));
owner =
SVNXMLUtil.addXMLFooter(
SVNXMLUtil.DAV_NAMESPACE_PREFIX, DAVElement.LOCK_OWNER.getName(), owner);
} else {
owner.append(lock.getComment());
}
}
if (!hideAuthUser) {
authUser = lock.getOwner();
}
return new DAVLock(
authUser,
DAVDepth.DEPTH_ZERO,
exists,
lock.getID(),
owner != null ? owner.toString() : null,
DAVLockRecType.DIRECT,
DAVLockScope.EXCLUSIVE,
DAVLockType.WRITE,
lock.getExpirationDate());
}
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
}