public void lock(Map pathsToRevisions, String comment, boolean force, ISVNLockHandler handler)
     throws SVNException {
   try {
     openConnection();
     Object[] buffer = new Object[] {"lock-many", comment, Boolean.valueOf(force)};
     write("(w((s)w(", buffer);
     buffer = new Object[2];
     for (Iterator paths = pathsToRevisions.keySet().iterator(); paths.hasNext(); ) {
       buffer[0] = paths.next();
       buffer[1] = pathsToRevisions.get(buffer[0]);
       write("(s(n))", buffer);
     }
     write(")))", buffer);
     try {
       authenticate();
     } catch (SVNException e) {
       if (e.getErrorMessage() != null
           && e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_SVN_UNKNOWN_CMD) {
         closeConnection();
         closeSession();
         openConnection();
         lock12(pathsToRevisions, comment, force, handler);
         return;
       }
       closeSession();
       throw e;
     }
     for (Iterator paths = pathsToRevisions.keySet().iterator(); paths.hasNext(); ) {
       String path = (String) paths.next();
       SVNLock lock = null;
       SVNErrorMessage error = null;
       try {
         read("[L]", buffer, false);
         lock = (SVNLock) buffer[0];
         path = lock.getPath();
       } catch (SVNException e) {
         path = getRepositoryPath(path);
         error = e.getErrorMessage();
       }
       if (handler != null) {
         handler.handleLock(path, lock, error);
       }
     }
     read("x", buffer, true);
     read("[()]", buffer, true);
   } catch (SVNException e) {
     closeSession();
     handleUnsupportedCommand(e, "Server doesn't support the lock command");
   } finally {
     closeConnection();
   }
 }
예제 #2
0
  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
    }
  }
예제 #3
0
  @Test
  public void testCommitOfLockedFile() throws SVNException {
    final String fullFilePath = "Project/Prueba/Modify/prueba.txt";
    final String filePath = "Prueba/Modify/prueba.txt";

    final TestOptions options = TestOptions.getInstance();
    final Sandbox sandbox =
        Sandbox.createWithCleanup(getClass().getSimpleName() + ".testModifyLocked", options);
    final SVNURL url = sandbox.createSvnRepository();
    final CommitBuilder commitBuilder = new CommitBuilder(url);
    commitBuilder.addFile(fullFilePath);
    commitBuilder.commit();

    // user paths relative to Project directory.

    SVNRepository repository = SVNRepositoryFactory.create(url.appendPath("Project", false));
    repository.setAuthenticationManager(new BasicAuthenticationManager("user", "password"));
    final Map<String, Long> pathsToRevisions = new HashMap<String, Long>();
    pathsToRevisions.put(filePath, 1l);
    repository.lock(pathsToRevisions, null, false, null);

    repository.closeSession();
    // same user as one who owns the lock.
    repository.setAuthenticationManager(new BasicAuthenticationManager("user", "password"));

    final SVNLock lock = repository.getLock(filePath);
    Assert.assertNotNull(lock);
    Assert.assertNotNull(lock.getID());
    Assert.assertEquals("user", lock.getOwner());

    final Map<String, String> locks = new HashMap<String, String>();

    try {
      tryCommit(filePath, repository, locks);
      Assert.fail();
    } catch (SVNException e) {
      // no lock token.
    }

    locks.put(filePath, lock.getID());
    SVNCommitInfo info = tryCommit(filePath, repository, locks);
    Assert.assertNotNull(info);
    Assert.assertEquals(2, info.getNewRevision());
  }
 private void unlock12(Map pathToTokens, boolean force, ISVNLockHandler handler)
     throws SVNException {
   for (Iterator paths = pathToTokens.keySet().iterator(); paths.hasNext(); ) {
     String path = (String) paths.next();
     String id = (String) pathToTokens.get(path);
     path = getRepositoryPath(path);
     if (id == null) {
       Object[] buffer = new Object[] {"get-lock", path};
       write("(w(s))", buffer);
       authenticate();
       read("[((?L))]", buffer, true);
       SVNLock lock = (SVNLock) buffer[0];
       if (lock == null) {
         lock = new SVNLock(path, "", null, null, null, null);
         SVNErrorMessage err =
             SVNErrorMessage.create(SVNErrorCode.RA_NOT_LOCKED, "No lock on path ''{0}''", path);
         handler.handleUnlock(path, lock, err);
         continue;
       }
       id = lock.getID();
     }
     Object[] buffer = new Object[] {"unlock", path, id, Boolean.valueOf(force)};
     write("(w(s(s)w))", buffer);
     authenticate();
     SVNErrorMessage error = null;
     try {
       read("[()]", buffer, true);
     } catch (SVNException e) {
       if (e.getErrorMessage() != null
           && e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_LOCKED) {
         error = e.getErrorMessage();
         error = SVNErrorMessage.create(error.getErrorCode(), error.getMessageTemplate(), path);
       } else {
         throw e;
       }
     }
     if (handler != null) {
       SVNLock lock = new SVNLock(path, id, null, null, null, null);
       handler.handleUnlock(path, lock, error);
     }
   }
 }
예제 #5
0
  private static void verifyLock(SVNLock lock, Collection lockTokens, String username)
      throws SVNException {
    if (username == null || "".equals(username)) {
      SVNErrorMessage err =
          SVNErrorMessage.create(
              SVNErrorCode.FS_NO_USER,
              "Cannot verify lock on path ''{0}''; no username available",
              lock.getPath());
      SVNErrorManager.error(err, SVNLogType.FSFS);
    } else if (username.compareTo(lock.getOwner()) != 0) {
      SVNErrorMessage err =
          SVNErrorMessage.create(
              SVNErrorCode.FS_LOCK_OWNER_MISMATCH,
              "User {0} does not own lock on path ''{1}'' (currently locked by {2})",
              new Object[] {username, lock.getPath(), lock.getOwner()});
      SVNErrorManager.error(err, SVNLogType.FSFS);
    }

    if (lockTokens.contains(lock.getID())) {
      return;
    }

    SVNErrorMessage err =
        SVNErrorMessage.create(
            SVNErrorCode.FS_BAD_LOCK_TOKEN,
            "Cannot verify lock on path ''{0}''; no matching lock-token available",
            lock.getPath());
    SVNErrorManager.error(err, SVNLogType.FSFS);
  }