From ad6000722deb66bd6a2eedbbb3da4478033664db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Pfeuffer?= <rene.pfeuffer@cloudogu.com>
Date: Wed, 28 Jul 2021 07:54:37 +0200
Subject: [PATCH] LRU semantic for workdir cache (#1735)

Introduces a maximum size for the simple workdir cache. On cache overflow workdirs are evicted using an LRU strategy.
Furthermore parallel requests for the same repository will now block until the workdir is released.
---
 CHANGELOG.md                                  |   2 +-
 docs/en/administration/workdir_caching.md     |  20 ++
 docs/en/navigation.yml                        |   1 +
 gradle/changelog/simple_workdir_cache.yaml    |   2 +
 .../work/SimpleCachingWorkingCopyPool.java    | 198 +++++++++++++++---
 .../scm/repository/work/WorkdirProvider.java  |  53 ++++-
 .../SimpleCachingWorkingCopyPoolTest.java     | 141 +++++++++----
 .../repository/work/WorkdirProviderTest.java  |  83 +++++++-
 .../GitRepositoryConfigStoreProvider.java     |   6 +-
 .../spi/GitWorkingCopyReclaimer.java          |  19 +-
 .../spi/SimpleGitWorkingCopyFactory.java      |   2 +-
 .../spi/SimpleGitWorkingCopyFactoryTest.java  |  28 +++
 .../scm/repository/HgRepositoryFactory.java   |   2 +
 .../spi/SimpleHgWorkingCopyFactory.java       |   5 +-
 .../spi/SimpleHgWorkingCopyFactoryTest.java   | 102 ++++++++-
 .../spi/scm-hg-spi-workdir-test.zip           | Bin 0 -> 7895 bytes
 .../spi/SimpleSvnWorkingCopyFactoryTest.java  |  11 +-
 17 files changed, 578 insertions(+), 97 deletions(-)
 create mode 100644 docs/en/administration/workdir_caching.md
 create mode 100644 gradle/changelog/simple_workdir_cache.yaml
 create mode 100644 scm-plugins/scm-hg-plugin/src/test/resources/sonia/scm/repository/spi/scm-hg-spi-workdir-test.zip

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57e365aada..6ef07d9123 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -281,7 +281,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [2.9.0] - 2020-11-06
 ### Added
-- Tracing api ([#1393](https://github.com/scm-manager/scm-manager/pull/#1393))
+- Tracing api ([#1393](https://github.com/scm-manager/scm-manager/pull/1393))
 - Automatic user converter for external users ([#1380](https://github.com/scm-manager/scm-manager/pull/1380))
 - Create _authenticated group on setup ([#1396](https://github.com/scm-manager/scm-manager/pull/1396))
 - The name of the initial git branch can be configured and is set to `main` by default ([#1399](https://github.com/scm-manager/scm-manager/pull/1399))
diff --git a/docs/en/administration/workdir_caching.md b/docs/en/administration/workdir_caching.md
new file mode 100644
index 0000000000..7df2b557e0
--- /dev/null
+++ b/docs/en/administration/workdir_caching.md
@@ -0,0 +1,20 @@
+---
+title: Caching for Working Directories
+---
+
+SCM-Manager offers commands to modify repositories on the server side. For example this is used by the
+[Editor Plugin](https://www.scm-manager.org/plugins/scm-editor-plugin/) and the
+[Review Plugin](https://www.scm-manager.org/plugins/scm-review-plugin/). Without further configuration, this is done
+by cloning/checking out the repository temporarily, performing the change, creating a commit and pushing the changes
+back to the central repository. The larger the repositories, the longer this may take.
+
+To speed up such changes a lot, SCM-Manager offers a strategy where the local clones will be cached and reused for
+subsequent requests. This strategy caches up to a configurable amount of clones (but at most one per repository).
+To enable this strategy, add the system property `scm.workingCopyPoolStrategy` to the value 
+`sonia.scm.repository.work.SimpleCachingWorkingCopyPool`:
+
+```bash
+-Dscm.workingCopyPoolStrategy=sonia.scm.repository.work.SimpleCachingWorkingCopyPool
+```
+
+The maximum capacity of the cache can be set using the property `scm.workingCopyPoolSize` (the default is 5).
diff --git a/docs/en/navigation.yml b/docs/en/navigation.yml
index e0edf3418d..bdae6704ae 100644
--- a/docs/en/navigation.yml
+++ b/docs/en/navigation.yml
@@ -22,6 +22,7 @@
   - /administration/logging/
   - /administration/scm-server/
   - /administration/reverse-proxies/
+  - /administration/workdir_caching/
 
 - section: Development
   entries:
diff --git a/gradle/changelog/simple_workdir_cache.yaml b/gradle/changelog/simple_workdir_cache.yaml
new file mode 100644
index 0000000000..7ff1960e21
--- /dev/null
+++ b/gradle/changelog/simple_workdir_cache.yaml
@@ -0,0 +1,2 @@
+- type: changed
+  description: The simple workdir cache has a maximum size, an lru semantic and blocks on parallel requests ([#1735](https://github.com/scm-manager/scm-manager/pull/1735))
diff --git a/scm-core/src/main/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPool.java b/scm-core/src/main/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPool.java
index a66e55aa4e..d57b3cfeed 100644
--- a/scm-core/src/main/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPool.java
+++ b/scm-core/src/main/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPool.java
@@ -24,35 +24,53 @@
 
 package sonia.scm.repository.work;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Stopwatch;
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Timer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.util.IOUtil;
 
 import javax.inject.Inject;
 import java.io.File;
+import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import static java.lang.Integer.getInteger;
+import static java.util.Optional.empty;
+import static java.util.Optional.of;
 
 /**
  * This class is a simple implementation of the {@link WorkingCopyPool} to demonstrate,
- * how caching can work in the simplest way. For the first time a {@link WorkingCopy} is
+ * how caching can work in an LRU style. For the first time a {@link WorkingCopy} is
  * requested for a repository with {@link #getWorkingCopy(SimpleWorkingCopyFactory.WorkingCopyContext)},
  * this implementation fetches a new directory from the {@link WorkdirProvider}.
  * On {@link #contextClosed(SimpleWorkingCopyFactory.WorkingCopyContext, File)},
- * the directory is not deleted, but put into a map with the repository id as key.
+ * the directory is not deleted, but put into a cache with the repository id as key.
  * When a working copy is requested with {@link #getWorkingCopy(SimpleWorkingCopyFactory.WorkingCopyContext)}
  * for a repository with such an existing directory, it is taken from the map, reclaimed and
  * returned as {@link WorkingCopy}.
  * If for one repository a working copy is requested, while another is in use already,
- * a second directory is requested from the {@link WorkdirProvider} for the second one.
- * If a context is closed with {@link #contextClosed(SimpleWorkingCopyFactory.WorkingCopyContext, File)}
- * and there already is a directory stored in the map for the repository,
- * the directory from the closed context simply is deleted.
+ * the process will wait until the other process has finished.
+ * The number of directories cached is limited. By default, directories are cached for
+ * {@value DEFAULT_WORKING_COPY_POOL_SIZE} repositories. This can be changes with the system
+ * property '{@value WORKING_COPY_POOL_SIZE_PROPERTY}' (if this is set to zero, no caching will
+ * take place; to cache the directories for each repository without eviction simply set this to a
+ * high enough value).
  * <br>
- * In general, this implementation should speed up things a bit, but one has to take into
- * account, that there is no monitoring of diskspace. So you have to make sure, that
- * there is enough space for a clone of each repository in the working dir.
+ * The usage of this pool has to be enabled by setting the system property `scm.workingCopyPoolStrategy`
+ * to 'sonia.scm.repository.work.SimpleCachingWorkingCopyPool'.
+ * <br>
+ * In general, this implementation should speed up modifications inside SCM-Manager performed by
+ * the editor plugin or the review plugin, but one has to take into
+ * account, that the space needed for repositories is multiplied. So you have to make sure, that
+ * there is enough space for clones of the repository.
  * <br>
  * Possible enhancements:
  * <ul>
@@ -65,49 +83,142 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class SimpleCachingWorkingCopyPool implements WorkingCopyPool {
 
+  public static final int DEFAULT_WORKING_COPY_POOL_SIZE = 5;
+  public static final String WORKING_COPY_POOL_SIZE_PROPERTY = "scm.workingCopyPoolSize";
+
   private static final Logger LOG = LoggerFactory.getLogger(SimpleCachingWorkingCopyPool.class);
 
-  private final Map<String, File> workdirs = new ConcurrentHashMap<>();
-
   private final WorkdirProvider workdirProvider;
+  private final LinkedHashMap<String, File> workdirs;
+  private final Map<String, Lock> locks;
+  private final boolean cacheEnabled;
+
+  private final Counter cacheHitCounter;
+  private final Counter cacheMissCounter;
+  private final Counter reclaimFailureCounter;
+  private final Counter overflowCounter;
+  private final Timer parallelWaitTimer;
+  private final Timer reclaimTimer;
+  private final Timer initializeTimer;
+  private final Timer deleteTimer;
 
   @Inject
-  public SimpleCachingWorkingCopyPool(WorkdirProvider workdirProvider) {
+  public SimpleCachingWorkingCopyPool(WorkdirProvider workdirProvider, MeterRegistry meterRegistry) {
+    this(getInteger(WORKING_COPY_POOL_SIZE_PROPERTY, DEFAULT_WORKING_COPY_POOL_SIZE), workdirProvider, meterRegistry);
+  }
+
+  @VisibleForTesting
+  SimpleCachingWorkingCopyPool(int size, WorkdirProvider workdirProvider, MeterRegistry meterRegistry) {
     this.workdirProvider = workdirProvider;
+    this.workdirs = new LruMap(size);
+    this.locks = new ConcurrentHashMap<>();
+    cacheEnabled = size > 0;
+    cacheHitCounter = Counter
+      .builder("scm.workingcopy.pool.cache.hit")
+      .description("The amount of cache hits for the working copy pool")
+      .register(meterRegistry);
+    cacheMissCounter = Counter
+      .builder("scm.workingcopy.pool.cache.miss")
+      .description("The amount of cache misses for the working copy pool")
+      .register(meterRegistry);
+    reclaimFailureCounter = Counter
+      .builder("scm.workingcopy.pool.reclaim.failure")
+      .description("The amount of failed reclaim processes from pool")
+      .register(meterRegistry);
+    overflowCounter = Counter
+      .builder("scm.workingcopy.pool.cache.overflow")
+      .description("The amount of discarded working copies from pool due to cache overflow")
+      .register(meterRegistry);
+    parallelWaitTimer = Timer
+      .builder("scm.workingcopy.pool.parallel")
+      .description("Duration of blocking waits for available working copies in pool")
+      .register(meterRegistry);
+    reclaimTimer = Timer
+      .builder("scm.workingcopy.pool.reclaim.duration")
+      .description("Duration of reclaiming existing working copies in pool")
+      .register(meterRegistry);
+    initializeTimer = Timer
+      .builder("scm.workingcopy.pool.initialize.duration")
+      .description("Duration of initialization of working copies in pool")
+      .register(meterRegistry);
+    deleteTimer = Timer
+      .builder("scm.workingcopy.pool.delete.duration")
+      .description("Duration of deletes of working copies from pool")
+      .register(meterRegistry);
   }
 
   @Override
-  public <R, W> WorkingCopy<R, W> getWorkingCopy(SimpleWorkingCopyFactory<R, W, ?>.WorkingCopyContext workingCopyContext) {
+  public <R, W> WorkingCopy<R, W> getWorkingCopy(SimpleWorkingCopyFactory<R, W, ?>.WorkingCopyContext context) {
+    Lock lock = getLock(context);
+    parallelWaitTimer.record(lock::lock);
+    try {
+      return getWorkingCopyFromPoolOrCreate(context);
+    } catch (RuntimeException e) {
+      lock.unlock();
+      throw e;
+    }
+  }
+
+  private <R, W> WorkingCopy<R, W> getWorkingCopyFromPoolOrCreate(SimpleWorkingCopyFactory<R, W, ?>.WorkingCopyContext workingCopyContext) {
     String id = workingCopyContext.getScmRepository().getId();
-    File existingWorkdir = workdirs.remove(id);
+    File existingWorkdir;
+    synchronized (workdirs) {
+      existingWorkdir = workdirs.remove(id);
+    }
     if (existingWorkdir != null) {
-      Stopwatch stopwatch = Stopwatch.createStarted();
-      try {
-        WorkingCopy<R, W> reclaimed = workingCopyContext.reclaim(existingWorkdir);
-        LOG.debug("reclaimed workdir for {} in path {} in {}", workingCopyContext.getScmRepository(), existingWorkdir, stopwatch.stop());
-        return reclaimed;
-      } catch (SimpleWorkingCopyFactory.ReclaimFailedException e) {
-        LOG.debug("failed to reclaim workdir for {} in path {} in {}", workingCopyContext.getScmRepository(), existingWorkdir, stopwatch.stop(), e);
-        deleteWorkdir(existingWorkdir);
+      Optional<WorkingCopy<R, W>> reclaimedWorkingCopy = tryToReclaim(workingCopyContext, existingWorkdir);
+      if (reclaimedWorkingCopy.isPresent()) {
+        cacheHitCounter.increment();
+        return reclaimedWorkingCopy.get();
       }
+    } else {
+      cacheMissCounter.increment();
     }
     return createNewWorkingCopy(workingCopyContext);
   }
 
+  private <R, W> Optional<WorkingCopy<R, W>> tryToReclaim(SimpleWorkingCopyFactory<R, W, ?>.WorkingCopyContext workingCopyContext, File existingWorkdir) {
+    return reclaimTimer.record(() -> {
+      Stopwatch stopwatch = Stopwatch.createStarted();
+      try {
+        WorkingCopy<R, W> reclaimed = workingCopyContext.reclaim(existingWorkdir);
+        LOG.debug("reclaimed workdir for {} in path {} in {}", workingCopyContext.getScmRepository(), existingWorkdir, stopwatch.stop());
+        return of(reclaimed);
+      } catch (Exception e) {
+        LOG.debug("failed to reclaim workdir for {} in path {} in {}", workingCopyContext.getScmRepository(), existingWorkdir, stopwatch.stop(), e);
+        deleteWorkdir(existingWorkdir);
+        reclaimFailureCounter.increment();
+        return empty();
+      }
+    });
+  }
+
   private <R, W> WorkingCopy<R, W> createNewWorkingCopy(SimpleWorkingCopyFactory<R, W, ?>.WorkingCopyContext workingCopyContext) {
-    Stopwatch stopwatch = Stopwatch.createStarted();
-    File newWorkdir = workdirProvider.createNewWorkdir(workingCopyContext.getScmRepository().getId());
-    WorkingCopy<R, W> parentAndClone = workingCopyContext.initialize(newWorkdir);
-    LOG.debug("initialized new workdir for {} in path {} in {}", workingCopyContext.getScmRepository(), newWorkdir, stopwatch.stop());
-    return parentAndClone;
+    return initializeTimer.record(() -> {
+      Stopwatch stopwatch = Stopwatch.createStarted();
+      File newWorkdir = workdirProvider.createNewWorkdir(workingCopyContext.getScmRepository().getId());
+      WorkingCopy<R, W> parentAndClone = workingCopyContext.initialize(newWorkdir);
+      LOG.debug("initialized new workdir for {} in path {} in {}", workingCopyContext.getScmRepository(), newWorkdir, stopwatch.stop());
+      return parentAndClone;
+    });
   }
 
   @Override
   public void contextClosed(SimpleWorkingCopyFactory<?, ?, ?>.WorkingCopyContext workingCopyContext, File workdir) {
-    String id = workingCopyContext.getScmRepository().getId();
-    File putResult = workdirs.putIfAbsent(id, workdir);
-    if (putResult != null && putResult != workdir) {
+    try {
+      putWorkingCopyToCache(workingCopyContext, workdir);
+    } finally {
+      getLock(workingCopyContext).unlock();
+    }
+  }
+
+  private void putWorkingCopyToCache(SimpleWorkingCopyFactory<?, ?, ?>.WorkingCopyContext workingCopyContext, File workdir) {
+    if (!cacheEnabled) {
       deleteWorkdir(workdir);
+      return;
+    }
+    synchronized (workdirs) {
+      workdirs.put(workingCopyContext.getScmRepository().getId(), workdir);
     }
   }
 
@@ -118,8 +229,33 @@ public class SimpleCachingWorkingCopyPool implements WorkingCopyPool {
   }
 
   private void deleteWorkdir(File workdir) {
+    LOG.debug("deleting old workdir {}", workdir);
     if (workdir.exists()) {
-      IOUtil.deleteSilently(workdir);
+      deleteTimer.record(() -> IOUtil.deleteSilently(workdir));
+    }
+  }
+
+  private <R, W> Lock getLock(SimpleWorkingCopyFactory<R, W, ?>.WorkingCopyContext context) {
+    return locks.computeIfAbsent(context.getScmRepository().getId(), id -> new ReentrantLock(true));
+  }
+
+  @SuppressWarnings("java:S2160") // no need for equals here
+  private class LruMap extends LinkedHashMap<String, File> {
+    private final int maxSize;
+
+    public LruMap(int maxSize) {
+      super(maxSize);
+      this.maxSize = maxSize;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Map.Entry<String, File> eldest) {
+      if (size() > maxSize) {
+        overflowCounter.increment();
+        deleteWorkdir(eldest.getValue());
+        return true;
+      }
+      return false;
     }
   }
 }
diff --git a/scm-core/src/main/java/sonia/scm/repository/work/WorkdirProvider.java b/scm-core/src/main/java/sonia/scm/repository/work/WorkdirProvider.java
index 52124f6c9a..385b6a5dd6 100644
--- a/scm-core/src/main/java/sonia/scm/repository/work/WorkdirProvider.java
+++ b/scm-core/src/main/java/sonia/scm/repository/work/WorkdirProvider.java
@@ -24,15 +24,25 @@
 
 package sonia.scm.repository.work;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sonia.scm.plugin.Extension;
 import sonia.scm.repository.RepositoryLocationResolver;
+import sonia.scm.util.IOUtil;
 
 import javax.inject.Inject;
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletContextListener;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 
-public class WorkdirProvider {
+@Extension
+public class WorkdirProvider implements ServletContextListener {
+
+  private static final Logger LOG = LoggerFactory.getLogger(WorkdirProvider.class);
 
   private final File rootDirectory;
   private final RepositoryLocationResolver repositoryLocationResolver;
@@ -58,21 +68,58 @@ public class WorkdirProvider {
 
   public File createNewWorkdir(String repositoryId) {
     if (useRepositorySpecificDir) {
-      return createWorkDir(repositoryLocationResolver.forClass(Path.class).getLocation(repositoryId).resolve("work").toFile());
+      Path repositoryLocation = repositoryLocationResolver.forClass(Path.class).getLocation(repositoryId);
+      File workDirectoryForRepositoryLocation = getWorkDirectoryForRepositoryLocation(repositoryLocation);
+      LOG.debug("creating work dir for repository {} in relative path {}", repositoryId, workDirectoryForRepositoryLocation);
+      return createWorkDir(workDirectoryForRepositoryLocation);
     } else {
+      LOG.debug("creating work dir for repository {} in global path", repositoryId);
       return createNewWorkdir();
     }
   }
 
+  private File getWorkDirectoryForRepositoryLocation(Path repositoryLocation) {
+    return repositoryLocation.resolve("work").toFile();
+  }
+
   private File createWorkDir(File baseDirectory) {
     // recreate base directory when it may be deleted (see https://github.com/scm-manager/scm-manager/issues/1493 for example)
     if (!baseDirectory.exists() && !baseDirectory.mkdirs()) {
       throw new WorkdirCreationException(baseDirectory.toString());
     }
     try {
-      return Files.createTempDirectory(baseDirectory.toPath(),"work-").toFile();
+      File newWorkDir = Files.createTempDirectory(baseDirectory.toPath(), "work-").toFile();
+      LOG.debug("created new work dir {}", newWorkDir);
+      return newWorkDir;
     } catch (IOException e) {
       throw new WorkdirCreationException(baseDirectory.toString(), e);
     }
   }
+
+  @Override
+  public void contextInitialized(ServletContextEvent sce) {
+    deleteWorkDirs();
+  }
+
+  @Override
+  public void contextDestroyed(ServletContextEvent sce) {
+    deleteWorkDirs();
+  }
+
+  private void deleteWorkDirs() {
+    deleteWorkDirs(rootDirectory);
+    repositoryLocationResolver.forClass(Path.class).forAllLocations(
+      (repo, repositoryLocation) -> deleteWorkDirs(getWorkDirectoryForRepositoryLocation(repositoryLocation))
+    );
+  }
+
+  private void deleteWorkDirs(File root) {
+    File[] workDirs = root.listFiles();
+    if (workDirs != null) {
+      LOG.info("deleting {} old work dirs in {}", workDirs.length, root);
+      Arrays.stream(workDirs)
+        .filter(File::isDirectory)
+        .forEach(IOUtil::deleteSilently);
+    }
+  }
 }
diff --git a/scm-core/src/test/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPoolTest.java b/scm-core/src/test/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPoolTest.java
index cda11dc080..1f5096047a 100644
--- a/scm-core/src/test/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPoolTest.java
+++ b/scm-core/src/test/java/sonia/scm/repository/work/SimpleCachingWorkingCopyPoolTest.java
@@ -24,14 +24,17 @@
 
 package sonia.scm.repository.work;
 
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.api.io.TempDir;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import sonia.scm.repository.Repository;
+import sonia.scm.repository.work.SimpleWorkingCopyFactory.ReclaimFailedException;
 
 import java.io.File;
 import java.nio.file.Path;
@@ -40,7 +43,6 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -51,66 +53,121 @@ class SimpleCachingWorkingCopyPoolTest {
 
   @Mock
   WorkdirProvider workdirProvider;
-  @InjectMocks
+  MeterRegistry meterRegistry = new SimpleMeterRegistry();
+
   SimpleCachingWorkingCopyPool simpleCachingWorkingCopyPool;
 
   @Mock
   SimpleWorkingCopyFactory<Object, Path, ?>.WorkingCopyContext workingCopyContext;
 
   @BeforeEach
-  void initContext() throws SimpleWorkingCopyFactory.ReclaimFailedException {
-
+  void initContext() throws ReclaimFailedException {
     lenient().when(workingCopyContext.initialize(any()))
       .thenAnswer(invocationOnMock -> new WorkingCopy<>(null, null, () -> {}, invocationOnMock.getArgument(0, File.class)));
     lenient().when(workingCopyContext.reclaim(any()))
       .thenAnswer(invocationOnMock -> new WorkingCopy<>(null, null, () -> {}, invocationOnMock.getArgument(0, File.class)));
   }
 
-  @Test
-  void shouldCreateNewWorkdirForTheFirstRequest(@TempDir Path temp) {
-    when(workingCopyContext.getScmRepository()).thenReturn(REPOSITORY);
-    when(workdirProvider.createNewWorkdir(anyString())).thenReturn(temp.toFile());
+  @Nested
+  class WithCache {
 
-    WorkingCopy<?, ?> workdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+    @BeforeEach
+    void initContext() {
+      simpleCachingWorkingCopyPool = new SimpleCachingWorkingCopyPool(2, workdirProvider, meterRegistry);
+    }
 
-    verify(workingCopyContext).initialize(temp.toFile());
+    @Test
+    void shouldCreateNewWorkdirForTheFirstRequest(@TempDir Path temp) {
+      when(workingCopyContext.getScmRepository()).thenReturn(REPOSITORY);
+      when(workdirProvider.createNewWorkdir(anyString())).thenReturn(temp.toFile());
+
+      WorkingCopy<?, ?> workdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+
+      verify(workingCopyContext).initialize(temp.toFile());
+      assertThat(meterRegistry.get("scm.workingcopy.pool.cache.miss").counter().count()).isEqualTo(1d);
+    }
+
+    @Test
+    void shouldReuseWorkdirForTheSameRepository(@TempDir Path temp) throws ReclaimFailedException {
+      when(workingCopyContext.getScmRepository()).thenReturn(REPOSITORY);
+      when(workdirProvider.createNewWorkdir(anyString())).thenReturn(temp.toFile());
+
+      WorkingCopy<?, ?> firstWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+      simpleCachingWorkingCopyPool.contextClosed(workingCopyContext, firstWorkdir.getDirectory());
+      WorkingCopy<?, ?> secondWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+
+      verify(workingCopyContext).initialize(temp.toFile());
+      verify(workingCopyContext).reclaim(temp.toFile());
+      assertThat(secondWorkdir.getDirectory()).isEqualTo(temp.toFile());
+      assertThat(meterRegistry.get("scm.workingcopy.pool.cache.hit").counter().count()).isEqualTo(1d);
+    }
+
+    @Test
+    void shouldCreateNewWorkdirIfReclaimFails(@TempDir Path temp) throws ReclaimFailedException {
+      when(workingCopyContext.getScmRepository()).thenReturn(REPOSITORY);
+      when(workdirProvider.createNewWorkdir(anyString())).thenReturn(temp.resolve("1").toFile(), temp.resolve("2").toFile());
+      when(workingCopyContext.reclaim(any())).thenThrow(ReclaimFailedException.class);
+
+      WorkingCopy<?, ?> firstWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+      simpleCachingWorkingCopyPool.contextClosed(workingCopyContext, firstWorkdir.getDirectory());
+      WorkingCopy<?, ?> secondWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+
+      assertThat(secondWorkdir.getDirectory()).isNotEqualTo(temp.toFile());
+      assertThat(meterRegistry.get("scm.workingcopy.pool.reclaim.failure").counter().count()).isEqualTo(1d);
+    }
+
+    @Test
+    void shouldDeleteWorkdirIfCacheSizeReached(@TempDir Path temp) {
+      fillPool(temp, 3);
+      assertThat(temp.resolve("path-0")).doesNotExist();
+      assertThat(temp.resolve("path-1")).exists();
+      assertThat(temp.resolve("path-2")).exists();
+      assertThat(meterRegistry.get("scm.workingcopy.pool.cache.overflow").counter().count()).isEqualTo(1d);
+    }
+
+    @Test
+    void shouldReorderUsedWorkdirsInCache(@TempDir Path temp) {
+      fillPool(temp, 2);
+      queryAndCloseWorkdir(temp, 0); // querying first repository again should keep it from eviction
+      queryAndCloseWorkdir(temp, 2);
+      assertThat(temp.resolve("path-0")).exists();
+      assertThat(temp.resolve("path-1")).doesNotExist();
+      assertThat(temp.resolve("path-2")).exists();
+    }
   }
 
-  @Test
-  void shouldCreateWorkdirOnlyOnceForTheSameRepository(@TempDir Path temp) throws SimpleWorkingCopyFactory.ReclaimFailedException {
-    when(workingCopyContext.getScmRepository()).thenReturn(REPOSITORY);
-    when(workdirProvider.createNewWorkdir(anyString())).thenReturn(temp.toFile());
+  @Nested
+  class WithoutCaching {
 
-    WorkingCopy<?, ?> firstWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
-    simpleCachingWorkingCopyPool.contextClosed(workingCopyContext, firstWorkdir.getDirectory());
-    WorkingCopy<?, ?> secondWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+    @BeforeEach
+    void initContext() {
+      simpleCachingWorkingCopyPool = new SimpleCachingWorkingCopyPool(0, workdirProvider, meterRegistry);
+    }
 
-    verify(workingCopyContext).initialize(temp.toFile());
-    verify(workingCopyContext).reclaim(temp.toFile());
-    assertThat(secondWorkdir.getDirectory()).isEqualTo(temp.toFile());
+    @Test
+    void shouldNotCacheAnything(@TempDir Path temp) {
+      fillPool(temp, 2);
+      assertThat(temp.resolve("path-0")).doesNotExist();
+      assertThat(temp.resolve("path-1")).doesNotExist();
+    }
   }
 
-  @Test
-  void shouldCacheOnlyOneWorkdirForRepository(@TempDir Path temp) throws SimpleWorkingCopyFactory.ReclaimFailedException {
-    when(workingCopyContext.getScmRepository()).thenReturn(REPOSITORY);
-    File firstDirectory = temp.resolve("first").toFile();
-    firstDirectory.mkdirs();
-    File secondDirectory = temp.resolve("second").toFile();
-    secondDirectory.mkdirs();
-    when(workdirProvider.createNewWorkdir(anyString())).thenReturn(
-      firstDirectory,
-      secondDirectory);
+  private void fillPool(Path temp, int size) {
+    for (int i = 0; i < size; ++i) {
+      queryAndCloseWorkdir(temp, i);
+    }
+  }
 
-    WorkingCopy<?, ?> firstWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
-    WorkingCopy<?, ?> secondWorkdir = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
-    simpleCachingWorkingCopyPool.contextClosed(workingCopyContext, firstWorkdir.getDirectory());
-    simpleCachingWorkingCopyPool.contextClosed(workingCopyContext, secondWorkdir.getDirectory());
-
-    verify(workingCopyContext, never()).reclaim(any());
-    verify(workingCopyContext).initialize(firstDirectory);
-    verify(workingCopyContext).initialize(secondDirectory);
-    assertThat(firstWorkdir.getDirectory()).isNotEqualTo(secondWorkdir.getDirectory());
-    assertThat(firstWorkdir.getDirectory()).exists();
-    assertThat(secondWorkdir.getDirectory()).doesNotExist();
+  private void queryAndCloseWorkdir(Path temp, int index) {
+    Repository repository = new Repository("repo-" + index, "git", "space", "X" + index);
+    when(workingCopyContext.getScmRepository()).thenReturn(repository);
+    String workdirName = "path-" + index;
+    lenient().doAnswer(invocation -> {
+      File newWorkdir = temp.resolve(workdirName).toFile();
+      newWorkdir.mkdirs();
+      return newWorkdir;
+    }).when(workdirProvider).createNewWorkdir(anyString());
+    WorkingCopy<Object, Path> workingCopy = simpleCachingWorkingCopyPool.getWorkingCopy(workingCopyContext);
+    simpleCachingWorkingCopyPool.contextClosed(workingCopyContext, workingCopy.getDirectory());
   }
 }
diff --git a/scm-core/src/test/java/sonia/scm/repository/work/WorkdirProviderTest.java b/scm-core/src/test/java/sonia/scm/repository/work/WorkdirProviderTest.java
index 08f2802f35..f274405b65 100644
--- a/scm-core/src/test/java/sonia/scm/repository/work/WorkdirProviderTest.java
+++ b/scm-core/src/test/java/sonia/scm/repository/work/WorkdirProviderTest.java
@@ -25,6 +25,7 @@
 package sonia.scm.repository.work;
 
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.api.io.TempDir;
@@ -34,10 +35,15 @@ import sonia.scm.repository.RepositoryLocationResolver;
 import sonia.scm.repository.RepositoryLocationResolver.RepositoryLocationResolverInstance;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.function.BiConsumer;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
@@ -52,7 +58,7 @@ class WorkdirProviderTest {
   private RepositoryLocationResolverInstance<Path> repositoryLocationResolverInstance;
 
   @BeforeEach
-  void initResolver(@TempDir Path temp) {
+  void initResolver() {
     lenient().when(repositoryLocationResolver.forClass(Path.class)).thenReturn(repositoryLocationResolverInstance);
   }
 
@@ -62,8 +68,9 @@ class WorkdirProviderTest {
 
     File newWorkdir = provider.createNewWorkdir();
 
-    assertThat(newWorkdir).exists();
-    assertThat(newWorkdir).hasParent(temp.toFile());
+    assertThat(newWorkdir)
+      .exists()
+      .hasParent(temp.toFile());
     verify(repositoryLocationResolverInstance, never()).getLocation(anyString());
   }
 
@@ -86,8 +93,74 @@ class WorkdirProviderTest {
 
     File newWorkdir = provider.createNewWorkdir("42");
 
-    assertThat(newWorkdir).exists();
-    assertThat(newWorkdir).hasParent(temp.toFile());
+    assertThat(newWorkdir)
+      .exists()
+      .hasParent(temp.toFile());
     verify(repositoryLocationResolverInstance, never()).getLocation(anyString());
   }
+
+  @Nested
+  class WithExistingGlobalWorkDir {
+
+    private Path globalRootDir;
+    private WorkdirProvider provider;
+
+    @BeforeEach
+    void createExistingWorkDir(@TempDir Path temp) throws IOException {
+      globalRootDir = temp.resolve("global");
+      Files.createDirectories(globalRootDir.resolve("global-temp"));
+
+      provider = new WorkdirProvider(globalRootDir.toFile(), repositoryLocationResolver, true);
+    }
+
+    @Test
+    void shouldDeleteOldGlobalWorkDirsOnStartup() {
+      provider.contextInitialized(null);
+
+      assertThat(globalRootDir).isEmptyDirectory();
+    }
+
+    @Test
+    void shouldDeleteOldGlobalWorkDirsOnShutdown() {
+      provider.contextDestroyed(null);
+
+      assertThat(globalRootDir).isEmptyDirectory();
+    }
+  }
+
+  @Nested
+  class WithExistingRepositoryWorkDir {
+
+    private Path repositoryRootDir;
+    private WorkdirProvider provider;
+
+    @BeforeEach
+    void createExistingWorkDir(@TempDir Path temp) throws IOException {
+      repositoryRootDir = temp.resolve("42");
+      Files.createDirectories(repositoryRootDir.resolve("work").resolve("repo-temp"));
+
+      doAnswer(
+        invocationOnMock -> {
+          invocationOnMock.getArgument(0, BiConsumer.class)
+            .accept("42", repositoryRootDir);
+          return null;
+        }
+      ).when(repositoryLocationResolverInstance).forAllLocations(any());
+      provider = new WorkdirProvider(temp.resolve("global").toFile(), repositoryLocationResolver, true);
+    }
+
+    @Test
+    void shouldDeleteOldRepositoryRelatedWorkDirsOnStartup() {
+      provider.contextInitialized(null);
+
+      assertThat(repositoryRootDir.resolve("work")).isEmptyDirectory();
+    }
+
+    @Test
+    void shouldDeleteOldRepositoryRelatedWorkDirsOnShutdown() {
+      provider.contextInitialized(null);
+
+      assertThat(repositoryRootDir.resolve("work")).isEmptyDirectory();
+    }
+  }
 }
diff --git a/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/api/v2/resources/GitRepositoryConfigStoreProvider.java b/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/api/v2/resources/GitRepositoryConfigStoreProvider.java
index be96f80859..552af5f72d 100644
--- a/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/api/v2/resources/GitRepositoryConfigStoreProvider.java
+++ b/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/api/v2/resources/GitRepositoryConfigStoreProvider.java
@@ -46,10 +46,10 @@ public class GitRepositoryConfigStoreProvider {
   }
 
   public GitRepositoryConfig getGitRepositoryConfig(String repositoryId) {
-    return getFronStore(createStore(repositoryId));
+    return getFromStore(createStore(repositoryId));
   }
 
-  private static GitRepositoryConfig getFronStore(ConfigurationStore<GitRepositoryConfig> store) {
+  private static GitRepositoryConfig getFromStore(ConfigurationStore<GitRepositoryConfig> store) {
     return store.getOptional().orElse(new GitRepositoryConfig());
   }
 
@@ -72,7 +72,7 @@ public class GitRepositoryConfigStoreProvider {
 
     @Override
     public GitRepositoryConfig get() {
-      return getFronStore(delegate);
+      return getFromStore(delegate);
     }
 
     @Override
diff --git a/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitWorkingCopyReclaimer.java b/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitWorkingCopyReclaimer.java
index 37d227a17d..151b0e9cd7 100644
--- a/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitWorkingCopyReclaimer.java
+++ b/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitWorkingCopyReclaimer.java
@@ -44,21 +44,22 @@ class GitWorkingCopyReclaimer {
 
   private final GitContext context;
 
-  public GitWorkingCopyReclaimer(GitContext context) {
+  GitWorkingCopyReclaimer(GitContext context) {
     this.context = context;
   }
 
   public ParentAndClone<Repository, Repository> reclaim(File target, String initialBranch) throws SimpleWorkingCopyFactory.ReclaimFailedException {
     LOG.trace("reclaim repository {}", context.getRepository());
+    String branchToCheckout = determineBranch(initialBranch);
     Stopwatch stopwatch = Stopwatch.createStarted();
     Repository repo = openTarget(target);
     try (Git git = Git.open(target)) {
       git.reset().setMode(ResetCommand.ResetType.HARD).call();
       git.clean().setForce(true).setCleanDirectories(true).call();
       git.fetch().call();
-      git.checkout().setForced(true).setName("origin/" + initialBranch).call();
-      git.branchDelete().setBranchNames(initialBranch).setForce(true).call();
-      git.checkout().setName(initialBranch).setCreateBranch(true).call();
+      git.checkout().setForced(true).setName("origin/" + branchToCheckout).call();
+      git.branchDelete().setBranchNames(branchToCheckout).setForce(true).call();
+      git.checkout().setName(branchToCheckout).setCreateBranch(true).call();
       return new ParentAndClone<>(null, repo, target);
     } catch (GitAPIException | IOException e) {
       throw new SimpleWorkingCopyFactory.ReclaimFailedException(e);
@@ -67,6 +68,16 @@ class GitWorkingCopyReclaimer {
     }
   }
 
+  private String determineBranch(String initialBranch) {
+    if (initialBranch != null) {
+      return initialBranch;
+    }
+    if (context.getConfig().getDefaultBranch() != null) {
+      return context.getConfig().getDefaultBranch();
+    }
+    return context.getGlobalConfig().getDefaultBranch();
+  }
+
   private Repository openTarget(File target) throws SimpleWorkingCopyFactory.ReclaimFailedException {
     try {
       return GitUtil.open(target);
diff --git a/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactory.java b/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactory.java
index 5dc440fb6e..7190881ae3 100644
--- a/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactory.java
+++ b/scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactory.java
@@ -70,7 +70,7 @@ public class SimpleGitWorkingCopyFactory extends SimpleWorkingCopyFactory<Reposi
   }
 
   @Override
-  protected void closeWorkingCopy(Repository workingCopy) throws Exception {
+  protected void closeWorkingCopy(Repository workingCopy) {
     if (workingCopy != null) {
       workingCopy.close();
     }
diff --git a/scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactoryTest.java b/scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactoryTest.java
index c356fea75b..4484b7956e 100644
--- a/scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactoryTest.java
+++ b/scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/SimpleGitWorkingCopyFactoryTest.java
@@ -35,6 +35,7 @@ import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import sonia.scm.repository.GitRepositoryConfig;
 import sonia.scm.repository.GitRepositoryHandler;
 import sonia.scm.repository.GitTestHelper;
 import sonia.scm.repository.PreProcessorUtil;
@@ -149,6 +150,32 @@ public class SimpleGitWorkingCopyFactoryTest extends AbstractGitCommandTestBase
     assertBranchCheckedOutAndClean(workdir, "master");
   }
 
+  @Test
+  public void shouldReclaimCleanDirectoryConfiguredDefaultBranch() throws Exception {
+    SimpleGitWorkingCopyFactory factory = new SimpleGitWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    GitContext context = createContext();
+    GitRepositoryConfig config = context.getConfig();
+    config.setDefaultBranch("master");
+    context.setConfig(config);
+    factory.reclaim(context, workdir, null);
+
+    assertBranchCheckedOutAndClean(workdir, "master");
+  }
+
+  @Test
+  public void shouldReclaimCleanDirectoryGloballyConfiguredDefaultBranch() throws Exception {
+    SimpleGitWorkingCopyFactory factory = new SimpleGitWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    GitContext context = createContext();
+    context.getGlobalConfig().setDefaultBranch("master");
+    factory.reclaim(context, workdir, null);
+
+    assertBranchCheckedOutAndClean(workdir, "master");
+  }
+
   @Test
   public void shouldReclaimCleanDirectoryWithOtherBranch() throws Exception {
     SimpleGitWorkingCopyFactory factory = new SimpleGitWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
@@ -192,6 +219,7 @@ public class SimpleGitWorkingCopyFactoryTest extends AbstractGitCommandTestBase
     factory.reclaim(createContext(), workdir, "master");
 
     assertBranchCheckedOutAndClean(workdir, "master");
+    assertThat(newDirectory).doesNotExist();
   }
 
   public File createExistingClone(SimpleGitWorkingCopyFactory factory) throws Exception {
diff --git a/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/HgRepositoryFactory.java b/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/HgRepositoryFactory.java
index 77daef742b..0fba372571 100644
--- a/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/HgRepositoryFactory.java
+++ b/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/HgRepositoryFactory.java
@@ -25,6 +25,7 @@
 package sonia.scm.repository;
 
 import com.aragost.javahg.RepositoryConfiguration;
+import com.aragost.javahg.ext.purge.PurgeExtension;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.repository.hooks.HookEnvironment;
@@ -69,6 +70,7 @@ public class HgRepositoryFactory {
     RepositoryConfiguration repoConfiguration = RepositoryConfiguration.DEFAULT;
     repoConfiguration.getEnvironment().putAll(environment);
     repoConfiguration.addExtension(HgFileviewExtension.class);
+    repoConfiguration.addExtension(PurgeExtension.class);
 
     boolean pending = hookEnvironment.isPending();
     repoConfiguration.setEnablePendingChangesets(pending);
diff --git a/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactory.java b/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactory.java
index fd4541fcbd..28e566cab5 100644
--- a/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactory.java
+++ b/scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactory.java
@@ -32,6 +32,7 @@ import com.aragost.javahg.commands.PullCommand;
 import com.aragost.javahg.commands.StatusCommand;
 import com.aragost.javahg.commands.UpdateCommand;
 import com.aragost.javahg.commands.flags.CloneCommandFlags;
+import com.aragost.javahg.ext.purge.PurgeCommand;
 import io.micrometer.core.instrument.MeterRegistry;
 import sonia.scm.repository.HgExtensions;
 import sonia.scm.repository.InternalRepositoryException;
@@ -78,7 +79,9 @@ public class SimpleHgWorkingCopyFactory extends SimpleWorkingCopyFactory<Reposit
       for (String unknown : StatusCommand.on(clone).execute().getUnknown()) {
         delete(clone.getDirectory(), unknown);
       }
-      UpdateCommand.on(clone).rev(initialBranch).clean().execute();
+      String branchToCheckOut = initialBranch == null ? "default" : initialBranch;
+      UpdateCommand.on(clone).rev(branchToCheckOut).clean().execute();
+      PurgeCommand.on(clone).execute();
       return new ParentAndClone<>(centralRepository, clone, target);
     } catch (ExecutionException | IOException e) {
       throw new ReclaimFailedException(e);
diff --git a/scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactoryTest.java b/scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactoryTest.java
index 61f2551a81..6859ed2e90 100644
--- a/scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactoryTest.java
+++ b/scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/repository/spi/SimpleHgWorkingCopyFactoryTest.java
@@ -24,12 +24,19 @@
 
 package sonia.scm.repository.spi;
 
+import com.aragost.javahg.BaseRepository;
 import com.aragost.javahg.Repository;
+import com.aragost.javahg.commands.BranchCommand;
+import com.aragost.javahg.commands.RemoveCommand;
+import com.aragost.javahg.commands.StatusCommand;
+import com.aragost.javahg.commands.results.StatusResult;
+import io.micrometer.core.instrument.MeterRegistry;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import sonia.scm.repository.work.NoneCachingWorkingCopyPool;
 import sonia.scm.repository.work.SimpleCachingWorkingCopyPool;
 import sonia.scm.repository.work.WorkdirProvider;
 import sonia.scm.repository.work.WorkingCopy;
@@ -38,6 +45,7 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Collections;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -46,6 +54,7 @@ public class SimpleHgWorkingCopyFactoryTest extends AbstractHgCommandTestBase {
 
   @Rule
   public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  private MeterRegistry meterRegistry = new SimpleMeterRegistry();
 
   private WorkdirProvider workdirProvider;
 
@@ -54,7 +63,7 @@ public class SimpleHgWorkingCopyFactoryTest extends AbstractHgCommandTestBase {
   @Before
   public void bindScmProtocol() throws IOException {
     workdirProvider = new WorkdirProvider(temporaryFolder.newFolder(), repositoryLocationResolver, false);
-    workingCopyFactory = new SimpleHgWorkingCopyFactory(new SimpleCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry()) {
+    workingCopyFactory = new SimpleHgWorkingCopyFactory(new SimpleCachingWorkingCopyPool(workdirProvider, meterRegistry), new SimpleMeterRegistry()) {
       @Override
       public void configure(com.aragost.javahg.commands.PullCommand pullCommand) {
         // we do not want to configure http hooks in this unit test
@@ -134,6 +143,95 @@ public class SimpleHgWorkingCopyFactoryTest extends AbstractHgCommandTestBase {
 
     WorkingCopy<Repository, Repository> cachedWorkingCopy = workingCopyFactory.createWorkingCopy(cmdContext, "default");
     assertThat(cachedWorkingCopy.getDirectory()).isEqualTo(initialDirectory);
-    assertThat(cachedWorkingCopy.getDirectory().toPath().resolve("newDir")).isEmptyDirectory();
+    assertThat(cachedWorkingCopy.getDirectory().toPath().resolve("newDir")).doesNotExist();
+  }
+
+  @Test
+  public void shouldReclaimCleanDirectoryWithSameBranch() throws Exception {
+    SimpleHgWorkingCopyFactory factory = new SimpleHgWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    factory.reclaim(cmdContext, workdir, "default");
+
+    assertBranchCheckedOutAndClean(workdir, "default");
+  }
+
+  @Test
+  public void shouldReclaimCleanDirectoryWithDefaultBranch() throws Exception {
+    SimpleHgWorkingCopyFactory factory = new SimpleHgWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    factory.reclaim(cmdContext, workdir, null);
+
+    assertBranchCheckedOutAndClean(workdir, "default");
+  }
+
+  @Test
+  public void shouldReclaimCleanDirectoryWithOtherBranch() throws Exception {
+    SimpleHgWorkingCopyFactory factory = new SimpleHgWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    factory.reclaim(cmdContext, workdir, "test-branch");
+
+    assertBranchCheckedOutAndClean(workdir, "test-branch");
+  }
+
+  @Test
+  public void shouldReclaimDirectoryWithDeletedFileInIndex() throws Exception {
+    SimpleHgWorkingCopyFactory factory = new SimpleHgWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    RemoveCommand.on(Repository.open(workdir)).execute("a.txt");
+
+    factory.reclaim(cmdContext, workdir, "default");
+
+    assertBranchCheckedOutAndClean(workdir, "default");
+  }
+
+  @Test
+  public void shouldReclaimDirectoryWithDeletedFileInDirectory() throws Exception {
+    SimpleHgWorkingCopyFactory factory = new SimpleHgWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    RemoveCommand.on(Repository.open(workdir)).execute("c");
+
+    factory.reclaim(cmdContext, workdir, "default");
+
+    assertBranchCheckedOutAndClean(workdir, "default");
+  }
+
+  @Test
+  public void shouldReclaimDirectoryWithAdditionalFileInDirectory() throws Exception {
+    SimpleHgWorkingCopyFactory factory = new SimpleHgWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    File workdir = createExistingClone(factory);
+
+    Path newDirectory = workdir.toPath().resolve("new");
+    Files.createDirectories(newDirectory);
+    Files.createFile(newDirectory.resolve("newFile"));
+
+    factory.reclaim(cmdContext, workdir, "default");
+
+    assertBranchCheckedOutAndClean(workdir, "default");
+    assertThat(newDirectory).doesNotExist();
+  }
+
+  private void assertBranchCheckedOutAndClean(File workdir, String expectedBranch) {
+    BaseRepository repository = Repository.open(workdir);
+    StatusResult statusResult = StatusCommand.on(repository).execute();
+    assertThat(statusResult.getAdded()).isEmpty();
+    assertThat(statusResult.getCopied()).isEmpty();
+    assertThat(statusResult.getIgnored()).isEmpty();
+    assertThat(statusResult.getMissing()).isEmpty();
+    assertThat(statusResult.getModified()).isEmpty();
+    assertThat(statusResult.getRemoved()).isEmpty();
+    assertThat(statusResult.getUnknown()).isEmpty();
+    assertThat(BranchCommand.on(repository).get()).isEqualTo(expectedBranch);
+  }
+
+  public File createExistingClone(SimpleHgWorkingCopyFactory factory) throws Exception {
+    File workdir = temporaryFolder.newFolder();
+    extract(workdir, "sonia/scm/repository/spi/scm-hg-spi-workdir-test.zip");
+    Files.write(workdir.toPath().resolve(".hg").resolve("hgrc"), Arrays.asList("[paths]", "default = " + repositoryDirectory.getAbsolutePath()));
+    return workdir;
   }
 }
diff --git a/scm-plugins/scm-hg-plugin/src/test/resources/sonia/scm/repository/spi/scm-hg-spi-workdir-test.zip b/scm-plugins/scm-hg-plugin/src/test/resources/sonia/scm/repository/spi/scm-hg-spi-workdir-test.zip
new file mode 100644
index 0000000000000000000000000000000000000000..6ef013c4a713534f50991d2d2552a4d1b4a37383
GIT binary patch
literal 7895
zcmb7Jc|4R`7#`cuOd4sLv`>-hCZ>?2ESIwHDobe0!epPZl%*Ofxus30WVw-OL#aqw
zY^As=DZ3U~vS%4fxZgK3W-$}`e!s)#kMDV(^PKmb_dO3YLm^=p1bh(MG>hjdw=M_*
z@8A%DEQ1i`eGdBUwwePGir+u7KM@$d2jLI_;Z`9Cg#LpFGvflVLJg7U10RC}1i;P&
zfQ7k{JP2r_CmHSJhIJ=Q!2@7ek05}DQ(&=q#mk19ixB=q&g5i7>E9A&Vly@T-@D@y
zxgqc~LEt%NAOT3qq7S?X11#iSoEdWf)tqq-oL|G3U*oVi7s4OtfNmNZ*#H26V-XjI
z57wEod7~eRLUM8=u!QBa%u49ZPFSqdR>D@y=B*e45u=P%#bQ;q;FMHxDqDyI9Cq_o
zmCab9lL~$INFb6JJ)sH?JCr&Ce?<WU#TDC$jP<~|Y~JXErLaTu(IetbnRq^CF7$0+
zN~@rr$(14JtL15TR!Bq{RIS|gdE9~WT>0V^3mI`K^!8liFQ>y(-k+1VQ|NRIaMzVl
zFW+5wb$PY%ft?wrUo0t13F~N*J@1R?9Ew`lJ<zi>{ZO<5m@*8y8Tc~IP0O$6Zw08T
z0%JatE(U{h!Fo6o+&rD-Npz81-K$LbFcp8L1$&O3EByRzOvk5W=*Gg^E*3qs&Sknf
z@*kFc``lF&yJTs|B}2yn&90XdtuWi7_xjeVr9%)l1#k-%Cfb?`2|ytAzz}0naB(K%
zrdyt<^O+`vn7Jot+lv%@v(?&MXbZxmE=eqqtY|xt>Km&msq6ihePjH-b!cID{Ic4F
zv09SmqRu2~nSbQAP;B2)q&kn?k-*|)rO4jm9vE^+i%tf%DQ?@&xQMHjno05Y#q;e4
zGjoxaH(w~jJ8z>T@la>&IeFjA8n&-qy200n6c*ERL()j<j<k(TWcrhf>PJW<*Pk)h
zQZA++nCFdBT)WpQ{F3&kym>~n_G0(My31+BO({x;HY7UU3^N@?SU(zpsujc^cxP+V
zXAnmWl-GP4pI89-S+mV;IjzRtwBPr_*~Y3++{0yAwVhg>A5eZMgD8!!<}sHMM%iPl
zGM$gyXb|Au`oQwB9yn7(|3BR~ECk?XGIyCEzy`#*k|>0O1opb{$%x;RTFOm|jt3ls
zt{Z)@WM=~V$o(Tw<ZnP(sq;r@{HE;TIh!f7x4$3a<&GjiK2ac<(cJ9Zu^uEMf#O5-
zb#wC}9Q2{D4vQ(DGidpLdB(z8b2Yz2>Akgps0s+^eO`R_<->JHp)UK2H5Tsk8h-FM
zZ0Fnjg@22leAnC<*)TBH*7B{Zy}5IAxOY4taCmgPhFk5RnuAG8#R+58>QW(yxp8G!
zD0=u9MCr3c)WzTxPmbv=G9V+QJ%nO6op!UeB>9~s<=^QT{Gp3MX3g`lxp?E|R~ej4
zSB_U@$tJOT>F6_w<xl-q$H_(SKeOh^n%#Hadugu8znRnWqEaku&4F}5L9=Wm5>_s+
zcww#5pjpiXJxv+%fVJVmNrcT#K%OhWn9Gz0Pa;!%us)145tQLy-a1#|@Zg(>WkKM_
zs9Uekl&&B3H%M|B^MlHv&r<*OhMyxE3`JoOdiPV>qO2}H*Ac;93x9PD^Pr<-WPMek
zO{7<<iAcB*{n%kw{*N)%GGYJ?a7-2&#t}W;n&1gUtgo97N67<^FaUz}h%=|<<mu_^
zjwQQNSa4uRF{PXM{eGFGMDg(?&s_T$3i}=?)9i|Gg;@X<ya5=K3C+O3U?ww=d8!-x
zSDEtRgxinbk3V`8jXo24Z}GS`)!egVFlSY4B_eY>t-7S&LMQNhhZj`FY?JQb2dx)E
zuw`<hgTkZPb71k3O%)@U-pJmj8k%p*&4I7?t)181c5zkDJb7r3b9C!<{Y|nj8$UjC
zOd~{<$=LidHz5wxCKtszYzfZs>hIQowtK!8@Op&76he9hQg@!l?A5RCm{WWCW#9gQ
zppfhB7t;xHr>r~7?2`jVl)AB^^G-ac1RU@dy&PTEpZab*ai~9gk)yY=qV_nV_qA*K
zME#+R2<NU_c84uU9-@0!yt8<EC9|h<#Uu6D#^x2vNsT)1JL4X{7TsgmbC*`Hf^9zT
zta0hC(fKq1yNr28wnDu+sZmB~8nw<(2mg(h10zl#mIf;xDzmi?-sa!85NZU05yo`#
zF8m{TLMK$F09k;P4wbPyrKDJ(RFRA{OtPv#_Q@zJ8cHWM$yhFcTf!~1<ui(7_TPh@
zY}Af$I$@Kik=;cdHYm!snaJt9czRFg?m&f>@FjAO^VX^&)WkA^@?tWYi9a7BSG0RY
z{{?U8Usj|hFgoC1QyS|!KHe>#+aA8nJj4O9NI~td-q#;XTzW%PVVw&Snu2mI>y=ln
zdRO$L;*Qgsg7#>6RNL-twM*h1$9rgf%3c4y^zX9w)7MP=Qs*!cnj06nnzF@O*!|ZV
ziK5g)sAYjAJ({68S4Elv&b?8{bzKho;_${T&&1C7*Jj<mXKNN3SPL4jobOUB8{JH5
zE-6``289+EN0&rLuMb}jMHQ#4*N3J-i%X!*X{cxv3AK---h&zH&?B_xFwjna0mfu^
zHkqMQ8;|Kz6o&Q)15@<HYx^7O9uq}<Bjx1bM~BaQD#k1}F?ZG!Tu8AxD@xw99){VM
zN>f47vKJi8$xPBOZ}mRbQ0u;+3g5Z6%vmEL$h}DBES@?Z1<y9Ni;8#4mXX91NSC;b
z)V^<B9wxn^5w$P%)1CDHMs8;gcF-K{ERsem)XNMXKMLISwI3cG_GU24^lBsO@s;pu
zhhv2Lmc+&m%34>qu-r@3e^;Jds})xuM#-hN1b=&$+il+}pXz|~Z_cM}e4(3bUca$+
zX_@aU&F2H%YS)qXkLAdYSqM@^UMrMmW#B1Gx7aMIQ%5<kqI8YaKdK!Zx64FZwmql`
zM3uwGh<o;S?QBxG5EVzr`26*HuEW#r%de#$G%rKluYZcOIo<qTV}ZQ=_=6jT8`K&b
zO(P%Wz5P;lYQcje>B;p^B4fse2E_-n3eOm13eW2zhHX9WTikH^nbZauAJ5SG|K|Bs
zBhd};LL;+Mv7aX2AKE*n!0#F&$_}2ZwkzE+me&JUu<9NfwC)qgE3n<6p?@Sld`v|K
zX}_=hpRVDD^15d0)}$mhC%mnGb6>e~wWW~CPu&2G_)XPbAL}AE?o2RQqh|c<(zW`S
z;K%6pSIAo`8rxTz=2ezG>bE-?<DSv~{bp=knz~}?ubRbI(nUA9*Jk1?YA<{WOYpY~
zx`mpUzgNoU*9SxLOI6eh-AJUu=r4Quo*xx8LcOMoO&3=$2^mvb+VR8!eOJhdxDGnH
zUT4(sM(6d3`EZ9tCgM+41bW`U3kD$LyqdP%MnCu3Pa8p$Uh}6!+J+uhZW#U`W$Tbl
zjy+lylMvwyQ)$yH&GPM&)ca|62=7+-9GUG=AR8V0Bldez%9A;YfolGZDsKivP6cLl
z52rYf)O_j~lDVTG=QV73>~llj-IZOwrQ-=Dlz|VGckj9HG_uUA{1_@nl!Vl3%s)Ar
zIFBgs4z25&Ueg<r_GL%=>)iz1=8I!$*UhsItKCd;FW>f4d9hfQtiyfx?RodHC5xf;
zCIz?>HKL=172)yglzl@zM32I=`ojr*-vk@2ZnTYh`UXAn{{FFPAZ~Nr9@Uz&JCgEZ
z;bdP_=SXTt{z`e5hBo`EAl3RKZQb7+BtLc9s{gnX)R!%5q|`GKK~lZlRc2lj@QI>*
z#5TF%2<5Ybe{TDZ(1tD{!F;uC6-PD)h_u>3rqoeZ;R9X}%-YA;&Uma3cE(#9yK*T#
zggiYBfHVMuyK>Qi=ojnRR4xb+O$?zQ3xoeXQ=uS&8*VA-4i@K*{(3o-rMN;7O?|H;
zpG|~9P0-B{r(KuK(b6clCkMmTzQzXi8|PL1$kN|tw_~-Sd4!o>siC=Eh*Y7F?D3=4
z5(mWKrRd1E#_~EGCSI}c<MHMyafDlyW9bmJIr?hp6RYD{zg8blzFJskB|nWwlh-T`
zk!HT+Gh}KZm1+9#*tc2^kVqRCQoMTO6zCUrrchdb)0B9oP!rlO3`{oGMi*5ouJzpE
zVLR9v-#oZipi%0aCJDBP<M0NfM@Q)2n>IS#armR?T7Dy!X?x4RtEb<xYhS69R`k#M
z4=(CLlIx7W3vxs+0iw&w+*&mmollB5fmQ`GHf$C%2b!CGy1Rlp@{-n^3Wj|Q{9#(}
z=V_WN4aWY;8QTUZTNe;DTA-l->dq%N-8f>#UNT){MOQr&5dG?B<%Am~FU(1}ZDD<R
z6)iY)G%szgUZPS2oMYNxXq?BDid8^ZD`0SE57C2tivXkYx$hY2%jthGeZL`X-McqU
z1_Is}1}x2TNU!R2ta7aI@<yvTG8HrgDqB58z*yjz?9j;sZ(kCb!02Q_FM!Wwg-q}R
z`~tsCFeW7!J-uOgPalE@&J#b?XDa;pa&XdT0&O$;(y=;aKKM>R%Pk<dLWteKb6a;(
z0AC1102o<R@QrEYi7<>jp0=ACird8Fgwg__n3mq`pupIZk07u?8IJ^HOzS-G3U2h-
z;c$C-oRrGwI80}6c3|AD9w(RtpcwPWm<=;te~)v9mH-&T?E`4>S;MI-$P|bE3&yP#
z6N#SPv(}8;_hU~pnOez(H^l{<PD94I3*Pa#jXgGa7S$X`WN_LHvfMV`%-Fmx+@z!s
zNHP@yG|3?L6i*I-1@|G}v}RN0cGfs4hcaOqKHGF8+53%iwcuQ<^-7pQl4UskIUtG!
z2!WJP#YMOPxy+|O$6m^Tokg|hgUw|`{doW+SAcuJ2{4=eHPuYulm$4~puDn78dTG<
zW@iMqJ;hG6EUFnd_M}xX#jKh+3a`t<8O2kSF$1>e10c@gq~JDdI5T;Ki8yK9OvjLa
zE{k)lUNUtT;0J*lj>EqBb4c#PEP@HiX!xd21IAME8aZqcld12x@VIRqfGc=sp5|cS
zy@GRMQ{as0Gr01eI==<yuPuV5Em#5nMsR{NuLskq%T|N?a=^*>6fY?2sxX}z{0YzJ
zBJ3=|LwKeN&Y;ZOsB==j#}Ag(wgaTWwtbo<<ZZ+`(J{ckBEbyix?ix`@|n?j8*NVX
zyS(VEwj00(+wN(Y^ET3)*ndg#FlV*Z05;g*&VbF`DKoHv(hn5U>s;8ZzIi%WMuzY<
z#hkG77ceNZTVw$7x22h#bKLze8!?M|5I|&h!vGW?f7Z-U1URd~4t*6w4A`zYzy}b>
E|G=E4kN^Mx

literal 0
HcmV?d00001

diff --git a/scm-plugins/scm-svn-plugin/src/test/java/sonia/scm/repository/spi/SimpleSvnWorkingCopyFactoryTest.java b/scm-plugins/scm-svn-plugin/src/test/java/sonia/scm/repository/spi/SimpleSvnWorkingCopyFactoryTest.java
index 30dec01525..2a44af2fcd 100644
--- a/scm-plugins/scm-svn-plugin/src/test/java/sonia/scm/repository/spi/SimpleSvnWorkingCopyFactoryTest.java
+++ b/scm-plugins/scm-svn-plugin/src/test/java/sonia/scm/repository/spi/SimpleSvnWorkingCopyFactoryTest.java
@@ -24,6 +24,7 @@
 
 package sonia.scm.repository.spi;
 
+import io.micrometer.core.instrument.MeterRegistry;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.junit.Before;
 import org.junit.Rule;
@@ -44,17 +45,19 @@ public class SimpleSvnWorkingCopyFactoryTest extends AbstractSvnCommandTestBase
 
   @Rule
   public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  private MeterRegistry meterRegistry = new SimpleMeterRegistry();
 
   // keep this so that it will not be garbage collected (Transport keeps this in a week reference)
   private WorkdirProvider workdirProvider;
 
+
   @Before
   public void initWorkDirProvider() throws IOException {
     workdirProvider = new WorkdirProvider(temporaryFolder.newFolder(), repositoryLocationResolver, false);
   }
 
   @Test
-  public void shouldCheckoutLatestRevision() throws SVNException, IOException {
+  public void shouldCheckoutLatestRevision() {
     SimpleSvnWorkingCopyFactory factory = new SimpleSvnWorkingCopyFactory(new NoneCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
 
     try (WorkingCopy<File, File> workingCopy = factory.createWorkingCopy(createContext(), null)) {
@@ -96,7 +99,7 @@ public class SimpleSvnWorkingCopyFactoryTest extends AbstractSvnCommandTestBase
 
   @Test
   public void shouldDeleteUntrackedFileOnReclaim() throws IOException {
-    SimpleSvnWorkingCopyFactory factory = new SimpleSvnWorkingCopyFactory(new SimpleCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+    SimpleSvnWorkingCopyFactory factory = new SimpleSvnWorkingCopyFactory(new SimpleCachingWorkingCopyPool(workdirProvider, meterRegistry), new SimpleMeterRegistry());
 
     WorkingCopy<File, File> workingCopy = factory.createWorkingCopy(createContext(), null);
     File directory = workingCopy.getWorkingRepository();
@@ -113,8 +116,8 @@ public class SimpleSvnWorkingCopyFactoryTest extends AbstractSvnCommandTestBase
   }
 
   @Test
-  public void shouldRestoreDeletedFileOnReclaim() throws IOException {
-    SimpleSvnWorkingCopyFactory factory = new SimpleSvnWorkingCopyFactory(new SimpleCachingWorkingCopyPool(workdirProvider), new SimpleMeterRegistry());
+  public void shouldRestoreDeletedFileOnReclaim() {
+    SimpleSvnWorkingCopyFactory factory = new SimpleSvnWorkingCopyFactory(new SimpleCachingWorkingCopyPool(workdirProvider, meterRegistry), new SimpleMeterRegistry());
 
     WorkingCopy<File, File> workingCopy = factory.createWorkingCopy(createContext(), null);
     File directory = workingCopy.getWorkingRepository();