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 void removeLock(DAVResource resource, String lockToken) throws DAVException {
DAVResourceURI resourceURI = resource.getResourceURI();
if (resourceURI.getPath() == null) {
return;
}
if (isKeepLocks()) {
return;
}
// TODO: add here authz check later
String token = null;
SVNLock lock = null;
if (lockToken == null) {
try {
lock = 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) {
token = lock.getID();
}
} else {
token = lockToken;
}
if (token != null) {
try {
resource.unlock(token, isBreakLock());
} catch (SVNException svne) {
if (svne.getErrorMessage().getErrorCode() == SVNErrorCode.FS_NO_USER) {
throw new DAVException(
"Anonymous lock removal is not allowed.",
HttpServletResponse.SC_UNAUTHORIZED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to remove a lock.",
null);
}
// TODO: add logging here
}
}
public void addLock(DAVLock lock, DAVResource resource) throws DAVException {
DAVDepth depth = lock.getDepth();
if (!resource.isCollection()) {
depth = DAVDepth.DEPTH_ZERO;
}
appendLock(resource, lock);
if (depth != DAVDepth.DEPTH_ZERO) {
DAVResourceWalker walker = new DAVResourceWalker();
DAVLockWalker lockHandler = new DAVLockWalker(resource, lock);
DAVResponse response =
walker.walk(
this,
resource,
null,
0,
null,
DAVResourceWalker.DAV_WALKTYPE_NORMAL | DAVResourceWalker.DAV_WALKTYPE_AUTH,
lockHandler,
DAVDepth.DEPTH_INFINITY);
if (response != null) {
throw new DAVException(
"Error(s) occurred on resources during the addition of a depth lock.",
ServletDAVHandler.SC_MULTISTATUS,
0,
response);
}
}
}
public boolean hasLocks(DAVResource resource) throws DAVException {
if (resource.getResourceURI().getPath() == null) {
return false;
}
if (DAVHandlerFactory.METHOD_LOCK.equals(myOwner.getRequestMethod())) {
return false;
}
// TODO: add authz check here later
SVNLock lock = null;
try {
lock = resource.getLock();
} catch (SVNException svne) {
throw DAVException.convertError(
svne.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to check path for a lock.",
null);
}
return lock != null;
}
public String getSupportedLock(DAVResource resource) {
if (resource.isCollection()) {
return null;
}
StringBuffer buffer = new StringBuffer();
buffer.append('\n');
SVNXMLUtil.openXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX,
DAVElement.LOCK_ENTRY.getName(),
SVNXMLUtil.XML_STYLE_NORMAL,
null,
buffer);
SVNXMLUtil.openXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX,
DAVElement.LOCK_SCOPE.getName(),
SVNXMLUtil.XML_STYLE_PROTECT_CDATA,
null,
buffer);
SVNXMLUtil.openXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX,
DAVElement.EXCLUSIVE.getName(),
SVNXMLUtil.XML_STYLE_SELF_CLOSING | SVNXMLUtil.XML_STYLE_PROTECT_CDATA,
null,
buffer);
SVNXMLUtil.closeXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX, DAVElement.LOCK_SCOPE.getName(), buffer);
SVNXMLUtil.openXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX,
DAVElement.LOCK_TYPE.getName(),
SVNXMLUtil.XML_STYLE_PROTECT_CDATA,
null,
buffer);
SVNXMLUtil.openXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX,
DAVElement.WRITE.getName(),
SVNXMLUtil.XML_STYLE_SELF_CLOSING | SVNXMLUtil.XML_STYLE_PROTECT_CDATA,
null,
buffer);
SVNXMLUtil.closeXMLTag(SVNXMLUtil.DAV_NAMESPACE_PREFIX, DAVElement.LOCK_TYPE.getName(), buffer);
SVNXMLUtil.closeXMLTag(
SVNXMLUtil.DAV_NAMESPACE_PREFIX, DAVElement.LOCK_ENTRY.getName(), buffer);
return buffer.toString();
}
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
}