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 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 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 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
  }