Use clone and push to create branches

Generalize workdir creation for git and hg and create branches in
clones instead of the scm repository, so that hooks will be fired
correctly once the changes are pushed back.

Missing:

- Evaluation of the git response from the push command
- configuration of the hg environment and the authentication, so that
  the scmhooks.py script can be triggeret correctly and can callback
  the scm manager

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/CloseableWrapper.java

@@ -1,25 +0,0 @@
-package sonia.scm.repository;
-
-import java.util.function.Consumer;
-
-public class CloseableWrapper<C> implements AutoCloseable {
-
-  private final C wrapped;
-  private final Consumer<C> cleanup;
-
-  public CloseableWrapper(C wrapped, Consumer<C> cleanup) {
-    this.wrapped = wrapped;
-    this.cleanup = cleanup;
-  }
-
-  public C get() { return wrapped; }
-
-  @Override
-  public void close() {
-    try {
-      cleanup.accept(wrapped);
-    } catch (Throwable t) {
-      throw new RuntimeException(t);
-    }
-  }
-}

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/GitWorkdirFactory.java

@@ -1,8 +1,8 @@
 package sonia.scm.repository;
 
+import org.eclipse.jgit.lib.Repository;
 import sonia.scm.repository.spi.GitContext;
-import sonia.scm.repository.spi.WorkingCopy;
+import sonia.scm.repository.util.WorkdirFactory;
 
-public interface GitWorkdirFactory {
-  WorkingCopy createWorkingCopy(GitContext gitContext);
+public interface GitWorkdirFactory extends WorkdirFactory<Repository, GitContext> {
 }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitBranchCommand.java

@@ -35,26 +35,44 @@ package sonia.scm.repository.spi;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.transport.PushResult;
+import org.eclipse.jgit.transport.RemoteRefUpdate;
 import sonia.scm.repository.Branch;
 import sonia.scm.repository.GitUtil;
+import sonia.scm.repository.GitWorkdirFactory;
 import sonia.scm.repository.InternalRepositoryException;
 import sonia.scm.repository.Repository;
+import sonia.scm.repository.util.WorkingCopy;
 
-import java.io.IOException;
+import java.util.stream.StreamSupport;
 
 public class GitBranchCommand extends AbstractGitCommand implements BranchCommand {
 
-  GitBranchCommand(GitContext context, Repository repository) {
+  private final GitWorkdirFactory workdirFactory;
+
+  GitBranchCommand(GitContext context, Repository repository, GitWorkdirFactory workdirFactory) {
     super(context, repository);
+    this.workdirFactory = workdirFactory;
   }
 
   @Override
-  public Branch branch(String name) throws IOException {
-    try (Git git = new Git(open())) {
-      Ref ref = git.branchCreate().setName(name).call();
+  public Branch branch(String name) {
+    try (WorkingCopy<org.eclipse.jgit.lib.Repository> workingCopy = workdirFactory.createWorkingCopy(context)) {
+      Git clone = new Git(workingCopy.get());
+      Ref ref = clone.branchCreate().setName(name).call();
+      Iterable<PushResult> call = clone.push().add(name).call();
+      StreamSupport.stream(call.spliterator(), false)
+        .flatMap(pushResult -> pushResult.getRemoteUpdates().stream())
+        .filter(remoteRefUpdate -> remoteRefUpdate.getStatus() != RemoteRefUpdate.Status.OK)
+        .findFirst()
+        .ifPresent(this::handlePushError);
       return Branch.normalBranch(name, GitUtil.getId(ref.getObjectId()));
     } catch (GitAPIException ex) {
       throw new InternalRepositoryException(repository, "could not create branch " + name, ex);
     }
   }
+
+  private void handlePushError(RemoteRefUpdate remoteRefUpdate) {
+    // TODO handle failed remote update
+  }
 }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitMergeCommand.java

@@ -20,6 +20,7 @@ import sonia.scm.repository.Person;
 import sonia.scm.repository.RepositoryPermissions;
 import sonia.scm.repository.api.MergeCommandResult;
 import sonia.scm.repository.api.MergeDryRunCommandResult;
+import sonia.scm.repository.util.WorkingCopy;
 import sonia.scm.user.User;
 
 import java.io.IOException;
@@ -48,7 +49,7 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
   public MergeCommandResult merge(MergeCommandRequest request) {
     RepositoryPermissions.push(context.getRepository().getId()).check();
 
-    try (WorkingCopy workingCopy = workdirFactory.createWorkingCopy(context)) {
+    try (WorkingCopy<Repository> workingCopy = workdirFactory.createWorkingCopy(context)) {
       Repository repository = workingCopy.get();
       logger.debug("cloned repository to folder {}", repository.getWorkTree());
       return new MergeWorker(repository, request).merge();

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitRepositoryServiceProvider.java

@@ -129,7 +129,7 @@ public class GitRepositoryServiceProvider extends RepositoryServiceProvider
   @Override
   public BranchCommand getBranchCommand()
   {
-    return new GitBranchCommand(context, repository);
+    return new GitBranchCommand(context, repository, handler.getWorkdirFactory());
   }
 
   /**

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/SimpleGitWorkdirFactory.java

@@ -9,59 +9,40 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.repository.GitWorkdirFactory;
 import sonia.scm.repository.InternalRepositoryException;
+import sonia.scm.repository.util.SimpleWorkdirFactory;
+import sonia.scm.repository.util.WorkingCopy;
 
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 
-public class SimpleGitWorkdirFactory implements GitWorkdirFactory {
-
-  private static final Logger logger = LoggerFactory.getLogger(SimpleGitWorkdirFactory.class);
-
-  private final File poolDirectory;
+public class SimpleGitWorkdirFactory extends SimpleWorkdirFactory<Repository, GitContext> implements GitWorkdirFactory {
 
   public SimpleGitWorkdirFactory() {
-    this(new File(System.getProperty("java.io.tmpdir"), "scmm-git-pool"));
+    super(null, new GitCloneProvider());
   }
 
   public SimpleGitWorkdirFactory(File poolDirectory) {
-    this.poolDirectory = poolDirectory;
-    poolDirectory.mkdirs();
+    super(poolDirectory, null, new GitCloneProvider());
   }
 
-  public WorkingCopy createWorkingCopy(GitContext gitContext) {
-    try {
-      Repository clone = cloneRepository(gitContext.getDirectory(), createNewWorkdir());
-      return new WorkingCopy(clone, this::close);
-    } catch (GitAPIException e) {
-      throw new InternalRepositoryException(gitContext.getRepository(), "could not clone working copy of repository", e);
-    } catch (IOException e) {
-      throw new InternalRepositoryException(gitContext.getRepository(), "could not create temporary directory for clone of repository", e);
+  private static class GitCloneProvider implements CloneProvider<Repository, GitContext> {
+
+    @Override
+    public Repository cloneRepository(GitContext context, File target) {
+      try {
+        return Git.cloneRepository()
+          .setURI(createScmTransportProtocolUri(context.getDirectory()))
+          .setDirectory(target)
+          .call()
+          .getRepository();
+      } catch (GitAPIException e) {
+        throw new InternalRepositoryException(context.getRepository(), "could not clone working copy of repository", e);
+      }
     }
-  }
 
-  private File createNewWorkdir() throws IOException {
-    return Files.createTempDirectory(poolDirectory.toPath(),"workdir").toFile();
-  }
-
-  protected Repository cloneRepository(File bareRepository, File target) throws GitAPIException {
-    return Git.cloneRepository()
-      .setURI(createScmTransportProtocolUri(bareRepository))
-      .setDirectory(target)
-      .call()
-      .getRepository();
-  }
-
-  private String createScmTransportProtocolUri(File bareRepository) {
-    return ScmTransportProtocol.NAME + "://" + bareRepository.getAbsolutePath();
-  }
-
-  private void close(Repository repository) {
-    repository.close();
-    try {
-      FileUtils.delete(repository.getWorkTree(), FileUtils.RECURSIVE);
-    } catch (IOException e) {
-      logger.warn("could not delete temporary git workdir '{}'", repository.getWorkTree(), e);
+    private String createScmTransportProtocolUri(File bareRepository) {
+      return ScmTransportProtocol.NAME + "://" + bareRepository.getAbsolutePath();
     }
   }
 }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/WorkingCopy.java

@@ -1,12 +0,0 @@
-package sonia.scm.repository.spi;
-
-import org.eclipse.jgit.lib.Repository;
-import sonia.scm.repository.CloseableWrapper;
-
-import java.util.function.Consumer;
-
-public class WorkingCopy extends CloseableWrapper<Repository> {
-  WorkingCopy(Repository wrapped, Consumer<Repository> cleanup) {
-    super(wrapped, cleanup);
-  }
-}

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/CloseableWrapperTest.java

@@ -1,6 +1,7 @@
 package sonia.scm.repository;
 
 import org.junit.Test;
+import sonia.scm.repository.util.CloseableWrapper;
 
 import java.util.function.Consumer;
 

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/AbstractGitCommandTestBase.java

@@ -34,11 +34,19 @@ package sonia.scm.repository.spi;
 
 //~--- non-JDK imports --------------------------------------------------------
 
+import org.eclipse.jgit.transport.ScmTransportProtocol;
+import org.eclipse.jgit.transport.Transport;
 import org.junit.After;
+import org.junit.Before;
 import sonia.scm.api.v2.resources.GitRepositoryConfigStoreProvider;
 import sonia.scm.repository.GitRepositoryConfig;
+import sonia.scm.repository.PreProcessorUtil;
+import sonia.scm.repository.api.HookContextFactory;
 import sonia.scm.store.InMemoryConfigurationStoreFactory;
 
+import static com.google.inject.util.Providers.of;
+import static org.mockito.Mockito.mock;
+
 /**
  *
  * @author Sebastian Sdorra
@@ -105,4 +113,5 @@ public class AbstractGitCommandTestBase extends ZippedRepositoryTestBase
 
   /** Field description */
   private GitContext context;
+  private ScmTransportProtocol scmTransportProtocol;
 }

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/BindTransportProtocolRule.java

@@ -0,0 +1,38 @@
+package sonia.scm.repository.spi;
+
+import org.eclipse.jgit.transport.ScmTransportProtocol;
+import org.eclipse.jgit.transport.Transport;
+import org.junit.rules.ExternalResource;
+import sonia.scm.repository.GitRepositoryHandler;
+import sonia.scm.repository.PreProcessorUtil;
+import sonia.scm.repository.RepositoryManager;
+import sonia.scm.repository.api.HookContextFactory;
+
+import static com.google.inject.util.Providers.of;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BindTransportProtocolRule extends ExternalResource {
+
+  private ScmTransportProtocol scmTransportProtocol;
+
+  @Override
+  protected void before() throws Throwable {
+    HookContextFactory hookContextFactory = new HookContextFactory(mock(PreProcessorUtil.class));
+    RepositoryManager repositoryManager = mock(RepositoryManager.class);
+    HookEventFacade hookEventFacade = new HookEventFacade(of(repositoryManager), hookContextFactory);
+    GitRepositoryHandler gitRepositoryHandler = mock(GitRepositoryHandler.class);
+    scmTransportProtocol = new ScmTransportProtocol(of(hookEventFacade), of(gitRepositoryHandler));
+
+    Transport.register(scmTransportProtocol);
+
+    when(gitRepositoryHandler.getRepositoryId(any())).thenReturn("1");
+    when(repositoryManager.get("1")).thenReturn(new sonia.scm.repository.Repository());
+  }
+
+  @Override
+  protected void after() {
+    Transport.unregister(scmTransportProtocol);
+  }
+}

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/GitBranchCommandTest.java

@@ -1,6 +1,7 @@
 package sonia.scm.repository.spi;
 
 import org.assertj.core.api.Assertions;
+import org.junit.Rule;
 import org.junit.Test;
 import sonia.scm.repository.Branch;
 
@@ -10,13 +11,16 @@ import java.util.List;
 
 public class GitBranchCommandTest extends AbstractGitCommandTestBase {
 
+  @Rule
+  public BindTransportProtocolRule transportProtocolRule = new BindTransportProtocolRule();
+
   @Test
   public void shouldCreateBranch() throws IOException {
     GitContext context = createContext();
 
     Assertions.assertThat(readBranches(context)).filteredOn(b -> b.getName().equals("new_branch")).isEmpty();
 
-    new GitBranchCommand(context, repository).branch("new_branch");
+    new GitBranchCommand(context, repository, new SimpleGitWorkdirFactory()).branch("new_branch");
 
     Assertions.assertThat(readBranches(context)).filteredOn(b -> b.getName().equals("new_branch")).isNotEmpty();
   }

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/GitMergeCommandTest.java

@@ -41,27 +41,8 @@ public class GitMergeCommandTest extends AbstractGitCommandTestBase {
 
   @Rule
   public ShiroRule shiro = new ShiroRule();
-
-  private ScmTransportProtocol scmTransportProtocol;
-
-  @Before
-  public void bindScmProtocol() {
-    HookContextFactory hookContextFactory = new HookContextFactory(mock(PreProcessorUtil.class));
-    RepositoryManager repositoryManager = mock(RepositoryManager.class);
-    HookEventFacade hookEventFacade = new HookEventFacade(of(repositoryManager), hookContextFactory);
-    GitRepositoryHandler gitRepositoryHandler = mock(GitRepositoryHandler.class);
-    scmTransportProtocol = new ScmTransportProtocol(of(hookEventFacade), of(gitRepositoryHandler));
-
-    Transport.register(scmTransportProtocol);
-
-    when(gitRepositoryHandler.getRepositoryId(any())).thenReturn("1");
-    when(repositoryManager.get("1")).thenReturn(new sonia.scm.repository.Repository());
-  }
-
-  @After
-  public void unregisterScmProtocol() {
-    Transport.unregister(scmTransportProtocol);
-  }
+  @Rule
+  public BindTransportProtocolRule transportProtocolRule = new BindTransportProtocolRule();
 
   @Test
   public void shouldDetectMergeableBranches() {

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/SimpleGitWorkdirFactoryTest.java

@@ -12,6 +12,7 @@ import sonia.scm.repository.GitRepositoryHandler;
 import sonia.scm.repository.PreProcessorUtil;
 import sonia.scm.repository.RepositoryManager;
 import sonia.scm.repository.api.HookContextFactory;
+import sonia.scm.repository.util.WorkingCopy;
 
 import java.io.File;
 import java.io.IOException;
@@ -44,7 +45,7 @@ public class SimpleGitWorkdirFactoryTest extends AbstractGitCommandTestBase {
     SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
     File masterRepo = createRepositoryDirectory();
 
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
 
       assertThat(workingCopy.get().getDirectory())
         .exists()
@@ -57,25 +58,15 @@ public class SimpleGitWorkdirFactoryTest extends AbstractGitCommandTestBase {
     }
   }
 
-  @Test
-  public void cloneFromPoolShouldBeClosed() throws IOException {
-    PoolWithSpy factory = new PoolWithSpy(temporaryFolder.newFolder());
-
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
-      assertThat(workingCopy).isNotNull();
-    }
-    verify(factory.createdClone).close();
-  }
-
   @Test
   public void cloneFromPoolShouldNotBeReused() throws IOException {
     SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
 
     File firstDirectory;
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
       firstDirectory = workingCopy.get().getDirectory();
     }
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
       File secondDirectory = workingCopy.get().getDirectory();
       assertThat(secondDirectory).isNotEqualTo(firstDirectory);
     }
@@ -86,23 +77,9 @@ public class SimpleGitWorkdirFactoryTest extends AbstractGitCommandTestBase {
     SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
 
     File directory;
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
       directory = workingCopy.get().getWorkTree();
     }
     assertThat(directory).doesNotExist();
   }
-
-  private static class PoolWithSpy extends SimpleGitWorkdirFactory {
-    PoolWithSpy(File poolDirectory) {
-      super(poolDirectory);
-    }
-
-    Repository createdClone;
-
-    @Override
-    protected Repository cloneRepository(File bareRepository, File destination) throws GitAPIException {
-      createdClone = spy(super.cloneRepository(bareRepository, destination));
-      return createdClone;
-    }
-  }
 }