File lock for svn

gradle/changelog/lock_command_for_svn.yaml

@@ -0,0 +1,2 @@
+- type: added
+  description: Lock and unlock command for SVN ([#1847](https://github.com/scm-manager/scm-manager/pull/1847))

scm-core/src/main/java/sonia/scm/repository/api/FileLock.java

@@ -26,6 +26,7 @@
 
 import java.io.Serializable;
 import java.time.Instant;
+import java.util.Optional;
 
 /**
  * Detailes of a file lock.
@@ -39,12 +40,18 @@ public class FileLock implements Serializable {
   private final String id;
   private final String userId;
   private final Instant timestamp;
+  private final String message;
 
   public FileLock(String path, String id, String userId, Instant timestamp) {
+    this(path, id, userId, timestamp, null);
+  }
+
+  public FileLock(String path, String id, String userId, Instant timestamp, String message) {
     this.path = path;
     this.id = id;
     this.userId = userId;
     this.timestamp = timestamp;
+    this.message = message;
   }
 
   /**
@@ -74,4 +81,8 @@ public String getUserId() {
   public Instant getTimestamp() {
     return timestamp;
   }
+
+  public Optional<String> getMessage() {
+    return Optional.ofNullable(message);
+  }
 }

scm-plugins/scm-svn-plugin/src/main/java/sonia/scm/repository/spi/SvnFileLockCommand.java

@@ -0,0 +1,162 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2020-present Cloudogu GmbH and Contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package sonia.scm.repository.spi;
+
+import org.apache.shiro.SecurityUtils;
+import org.tmatesoft.svn.core.SVNException;
+import org.tmatesoft.svn.core.SVNLock;
+import org.tmatesoft.svn.core.auth.ISVNAuthenticationManager;
+import org.tmatesoft.svn.core.io.SVNRepository;
+import sonia.scm.repository.InternalRepositoryException;
+import sonia.scm.repository.api.FileLock;
+import sonia.scm.repository.api.FileLockedException;
+import sonia.scm.repository.api.LockCommandResult;
+import sonia.scm.repository.api.UnlockCommandResult;
+
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.function.Predicate;
+
+import static java.util.Collections.singletonMap;
+import static java.util.Optional.ofNullable;
+import static java.util.stream.Collectors.toList;
+import static org.tmatesoft.svn.core.auth.BasicAuthenticationManager.newInstance;
+import static sonia.scm.ContextEntry.ContextBuilder.entity;
+
+public class SvnFileLockCommand extends AbstractSvnCommand implements FileLockCommand {
+
+  private static final String LOCK_MESSAGE_PREFIX = "locked by SCM-Manager for ";
+
+  protected SvnFileLockCommand(SvnContext context) {
+    super(context);
+  }
+
+  @Override
+  public LockCommandResult lock(LockCommandRequest request) {
+    String fileToLock = request.getFile();
+    try {
+      doLock(fileToLock);
+      return new LockCommandResult(true);
+    } catch (SVNException e) {
+      throw new InternalRepositoryException(entity("File", fileToLock).in(repository), "failed to lock file", e);
+    }
+  }
+
+  private void doLock(String fileToLock) throws SVNException {
+    SVNRepository svnRepository = open();
+    String currentUser = initializeAuthentication(svnRepository);
+    getFileLock(fileToLock, svnRepository)
+      .ifPresent(lock -> {
+        throw new FileLockedException(repository.getNamespaceAndName(), lock);
+      });
+    svnRepository.lock(singletonMap(fileToLock, null), LOCK_MESSAGE_PREFIX + currentUser, false, null);
+  }
+
+  @Override
+  public UnlockCommandResult unlock(UnlockCommandRequest request) {
+    return unlock(request, any -> true);
+  }
+
+  public UnlockCommandResult unlock(UnlockCommandRequest request, Predicate<SvnFileLock> predicate) {
+    String fileToUnlock = request.getFile();
+    try {
+      doUnlock(request, predicate);
+      return new UnlockCommandResult(true);
+    } catch (SVNException e) {
+      throw new InternalRepositoryException(entity("File", fileToUnlock).in(repository), "failed to unlock file", e);
+    }
+  }
+
+  private void doUnlock(UnlockCommandRequest request, Predicate<SvnFileLock> predicate) throws SVNException {
+    String fileToUnlock = request.getFile();
+    SVNRepository svnRepository = open();
+    initializeAuthentication(svnRepository);
+    Optional<SvnFileLock> fileLock = getFileLock(fileToUnlock, svnRepository);
+    if (fileLock.isPresent()) {
+      SvnFileLock lock = fileLock.get();
+      if (!request.isForce() && !getCurrentUser().equals(lock.getUserId()) || !predicate.test(lock)) {
+        throw new FileLockedException(repository.getNamespaceAndName(), lock);
+      }
+      svnRepository.unlock(singletonMap(fileToUnlock, lock.getId()), request.isForce(), null);
+    }
+  }
+
+  @Override
+  public Optional<FileLock> status(LockStatusCommandRequest request) {
+    String file = request.getFile();
+    try {
+      return getFileLock(file, open()).map(lock -> lock);
+    } catch (SVNException e) {
+      throw new InternalRepositoryException(entity("File", file).in(repository), "failed to read lock status", e);
+    }
+  }
+
+  @Override
+  public Collection<FileLock> getAll() {
+    try {
+      SVNRepository svnRepository = open();
+      return Arrays.stream(svnRepository.getLocks("/"))
+        .map(this::createLock)
+        .collect(toList());
+    } catch (SVNException e) {
+      throw new InternalRepositoryException(repository, "failed to read locks", e);
+    }
+  }
+
+  private Optional<SvnFileLock> getFileLock(String file, SVNRepository svnRepository) throws SVNException {
+    return ofNullable(svnRepository.getLock(file)).map(this::createLock);
+  }
+
+  private SvnFileLock createLock(SVNLock lock) {
+    String path = lock.getPath();
+    if (path.startsWith("/")) {
+      path = path.substring(1);
+    }
+    return new SvnFileLock(path, lock.getID(), lock.getOwner(), lock.getCreationDate().toInstant(), lock.getComment());
+  }
+
+  private String initializeAuthentication(SVNRepository svnRepository) {
+    String currentUser = getCurrentUser();
+    ISVNAuthenticationManager authenticationManager = newInstance(currentUser, null);
+    svnRepository.setAuthenticationManager(authenticationManager);
+    return currentUser;
+  }
+
+  private String getCurrentUser() {
+    return SecurityUtils.getSubject().getPrincipal().toString();
+  }
+
+  static class SvnFileLock extends FileLock {
+    private SvnFileLock(String path, String id, String userId, Instant timestamp, String message) {
+      super(path, id, userId, timestamp, message);
+    }
+
+    boolean isCreatedByScmManager() {
+      return getMessage().filter(message -> message.startsWith(LOCK_MESSAGE_PREFIX)).isPresent();
+    }
+  }
+}

scm-plugins/scm-svn-plugin/src/main/java/sonia/scm/repository/spi/SvnModifyCommand.java

@@ -34,7 +34,6 @@
 import org.tmatesoft.svn.core.wc.SVNWCClient;
 import org.tmatesoft.svn.core.wc.SVNWCUtil;
 import sonia.scm.ConcurrentModificationException;
-import sonia.scm.ContextEntry;
 import sonia.scm.repository.InternalRepositoryException;
 import sonia.scm.repository.Repository;
 import sonia.scm.repository.SvnWorkingCopyFactory;
@@ -57,10 +56,13 @@ public class SvnModifyCommand implements ModifyCommand {
   private final SvnWorkingCopyFactory workingCopyFactory;
   private final Repository repository;
 
+  private final SvnFileLockCommand lockCommand;
+
   SvnModifyCommand(SvnContext context, SvnWorkingCopyFactory workingCopyFactory) {
     this.context = context;
     this.repository = context.getRepository();
     this.workingCopyFactory = workingCopyFactory;
+    this.lockCommand = new SvnFileLockCommand(context);
   }
 
   @Override
@@ -137,6 +139,7 @@ private ModifyWorker(SVNWCClient wcClient, File workingDirectory) {
 
     @Override
     public void doScmDelete(String toBeDeleted) {
+      unlock(toBeDeleted);
       try {
         wcClient.doDelete(new File(workingDirectory, toBeDeleted), true, true, false);
       } catch (SVNException e) {
@@ -146,6 +149,7 @@ public void doScmDelete(String toBeDeleted) {
 
     @Override
     public void addFileToScm(String name, Path file) {
+      unlock(name);
       try {
         wcClient.doAdd(
           file.toFile(),
@@ -161,6 +165,19 @@ public void addFileToScm(String name, Path file) {
       }
     }
 
+    private void unlock(String toBeDeleted) {
+      lockCommand.unlock(
+        createUnlockRequest(toBeDeleted),
+        SvnFileLockCommand.SvnFileLock::isCreatedByScmManager
+      );
+    }
+
+    private UnlockCommandRequest createUnlockRequest(String toBeDeleted) {
+      UnlockCommandRequest request = new UnlockCommandRequest();
+      request.setFile(toBeDeleted);
+      return request;
+    }
+
     @Override
     public File getWorkDir() {
       return workingDirectory;

scm-plugins/scm-svn-plugin/src/main/java/sonia/scm/repository/spi/SvnRepositoryServiceProvider.java

@@ -55,7 +55,8 @@ public class SvnRepositoryServiceProvider extends RepositoryServiceProvider {
     Command.MODIFY,
     Command.LOOKUP,
     Command.FULL_HEALTH_CHECK,
-    Command.MIRROR
+    Command.MIRROR,
+    Command.FILE_LOCK
   );
 
   public static final Set<Feature> FEATURES = EnumSet.of(
@@ -155,4 +156,9 @@ public FullHealthCheckCommand getFullHealthCheckCommand() {
   public MirrorCommand getMirrorCommand() {
     return new SvnMirrorCommand(context, trustManager, globalProxyConfiguration);
   }
+
+  @Override
+  public FileLockCommand getFileLockCommand() {
+    return new SvnFileLockCommand(context);
+  }
 }