merge

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

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2010, Sebastian Sdorra
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of SCM-Manager; nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * http://bitbucket.org/sdorra/scm-manager
+ *
+ */
+
+
+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.api.BranchRequest;
+import sonia.scm.repository.util.WorkingCopy;
+
+import java.util.stream.StreamSupport;
+
+public class GitBranchCommand extends AbstractGitCommand implements BranchCommand {
+
+  private final GitWorkdirFactory workdirFactory;
+
+  GitBranchCommand(GitContext context, Repository repository, GitWorkdirFactory workdirFactory) {
+    super(context, repository);
+    this.workdirFactory = workdirFactory;
+  }
+
+  @Override
+  public Branch branch(BranchRequest request) {
+    try (WorkingCopy<org.eclipse.jgit.lib.Repository> workingCopy = workdirFactory.createWorkingCopy(context)) {
+      Git clone = new Git(workingCopy.getWorkingRepository());
+      if (request.getParentBranch() != null) {
+        clone.checkout().setName(request.getParentBranch());
+      }
+      Ref ref = clone.branchCreate().setName(request.getNewBranch()).call();
+      Iterable<PushResult> call = clone.push().add(request.getNewBranch()).call();
+      StreamSupport.stream(call.spliterator(), false)
+        .flatMap(pushResult -> pushResult.getRemoteUpdates().stream())
+        .filter(remoteRefUpdate -> remoteRefUpdate.getStatus() != RemoteRefUpdate.Status.OK)
+        .findFirst()
+        .ifPresent(r -> this.handlePushError(r, request, context.getRepository()));
+      return Branch.normalBranch(request.getNewBranch(), GitUtil.getId(ref.getObjectId()));
+    } catch (GitAPIException ex) {
+      throw new InternalRepositoryException(repository, "could not create branch " + request.getNewBranch(), ex);
+    }
+  }
+
+  private void handlePushError(RemoteRefUpdate remoteRefUpdate, BranchRequest request, Repository repository) {
+    if (remoteRefUpdate.getStatus() != RemoteRefUpdate.Status.OK) {
+      // TODO handle failed remote update
+      throw new IntegrateChangesFromWorkdirException(repository,
+        String.format("Could not push new branch '%s' into central repository", request.getNewBranch()));
+    }
+  }
+}

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;
@@ -46,10 +47,8 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
 
   @Override
   public MergeCommandResult merge(MergeCommandRequest request) {
-    RepositoryPermissions.push(context.getRepository().getId()).check();
-
-    try (WorkingCopy workingCopy = workdirFactory.createWorkingCopy(context)) {
-      Repository repository = workingCopy.get();
+    try (WorkingCopy<Repository> workingCopy = workdirFactory.createWorkingCopy(context)) {
+      Repository repository = workingCopy.getWorkingRepository();
       logger.debug("cloned repository to folder {}", repository.getWorkTree());
       return new MergeWorker(repository, request).merge();
     } catch (IOException e) {
@@ -186,7 +185,8 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
       try {
         clone.push().call();
       } catch (GitAPIException e) {
-        throw new InternalRepositoryException(context.getRepository(), "could not push merged branch " + target + " to origin", e);
+        throw new IntegrateChangesFromWorkdirException(repository,
+          "could not push merged branch " + target + " into central repository", e);
       }
       logger.debug("pushed merged branch {}", target);
     }

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

@@ -120,6 +120,18 @@ public class GitRepositoryServiceProvider extends RepositoryServiceProvider
     return new GitBranchesCommand(context, repository);
   }
 
+  /**
+   * Method description
+   *
+   *
+   * @return
+   */
+  @Override
+  public BranchCommand getBranchCommand()
+  {
+    return new GitBranchCommand(context, repository, handler.getWorkdirFactory());
+  }
+
   /**
    * Method description
    *

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

@@ -4,64 +4,49 @@ import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.transport.ScmTransportProtocol;
-import org.eclipse.jgit.util.FileUtils;
-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 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"));
   }
 
-  public SimpleGitWorkdirFactory(File poolDirectory) {
-    this.poolDirectory = poolDirectory;
-    poolDirectory.mkdirs();
+  SimpleGitWorkdirFactory(File poolDirectory) {
+    super(poolDirectory);
   }
 
-  public WorkingCopy createWorkingCopy(GitContext gitContext) {
+  @Override
+  public ParentAndClone<Repository> cloneRepository(GitContext context, File target) {
     try {
-      Repository clone = cloneRepository(gitContext.getDirectory(), createNewWorkdir());
-      return new WorkingCopy(clone, this::close);
+      return new ParentAndClone<>(null, Git.cloneRepository()
+        .setURI(createScmTransportProtocolUri(context.getDirectory()))
+        .setDirectory(target)
+        .call()
+        .getRepository());
     } 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);
+      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);
+  @Override
+  protected void closeRepository(Repository repository) {
+    // we have to check for null here, because we do not create a repository for
+    // the parent in cloneRepository
+    if (repository != null) {
+      repository.close();
     }
   }
+
+  @Override
+  protected sonia.scm.repository.Repository getScmRepository(GitContext context) {
+    return context.getRepository();
+  }
 }

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;
 
@@ -11,19 +12,20 @@ public class CloseableWrapperTest {
 
   @Test
   public void shouldExecuteGivenMethodAtClose() {
-    Consumer<String> wrapped = new Consumer<String>() {
+    Consumer<AutoCloseable> wrapped = new Consumer<AutoCloseable>() {
       // no this cannot be replaced with a lambda because otherwise we could not use Mockito#spy
       @Override
-      public void accept(String s) {
+      public void accept(AutoCloseable s) {
       }
     };
 
-    Consumer<String> closer = spy(wrapped);
+    Consumer<AutoCloseable> closer = spy(wrapped);
 
-    try (CloseableWrapper<String> wrapper = new CloseableWrapper<>("test", closer)) {
+    AutoCloseable autoCloseable = () -> {};
+    try (CloseableWrapper<AutoCloseable> wrapper = new CloseableWrapper<>(autoCloseable, closer)) {
       // nothing to do here
     }
 
-    verify(closer).accept("test");
+    verify(closer).accept(autoCloseable);
   }
 }

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

@@ -0,0 +1,35 @@
+package sonia.scm.repository.spi;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Rule;
+import org.junit.Test;
+import sonia.scm.repository.Branch;
+import sonia.scm.repository.api.BranchRequest;
+
+import java.io.IOException;
+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();
+
+    BranchRequest branchRequest = new BranchRequest();
+    branchRequest.setNewBranch("new_branch");
+
+    new GitBranchCommand(context, repository, new SimpleGitWorkdirFactory()).branch(branchRequest);
+
+    Assertions.assertThat(readBranches(context)).filteredOn(b -> b.getName().equals("new_branch")).isNotEmpty();
+  }
+
+  private List<Branch> readBranches(GitContext context) throws IOException {
+    return new GitBranchesCommand(context, repository).getBranches();
+  }
+}

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

@@ -1,6 +1,5 @@
 package sonia.scm.repository.spi;
 
-import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.transport.ScmTransportProtocol;
 import org.eclipse.jgit.transport.Transport;
@@ -12,6 +11,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,39 +44,29 @@ 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())
+      assertThat(workingCopy.getDirectory())
         .exists()
         .isNotEqualTo(masterRepo)
         .isDirectory();
-      assertThat(new File(workingCopy.get().getWorkTree(), "a.txt"))
+      assertThat(new File(workingCopy.getWorkingRepository().getWorkTree(), "a.txt"))
         .exists()
         .isFile()
         .hasContent("a\nline for blame");
     }
   }
 
-  @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())) {
-      firstDirectory = workingCopy.get().getDirectory();
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
+      firstDirectory = workingCopy.getDirectory();
     }
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
-      File secondDirectory = workingCopy.get().getDirectory();
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
+      File secondDirectory = workingCopy.getDirectory();
       assertThat(secondDirectory).isNotEqualTo(firstDirectory);
     }
   }
@@ -86,23 +76,9 @@ public class SimpleGitWorkdirFactoryTest extends AbstractGitCommandTestBase {
     SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
 
     File directory;
-    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
-      directory = workingCopy.get().getWorkTree();
+    try (WorkingCopy<Repository> workingCopy = factory.createWorkingCopy(createContext())) {
+      directory = workingCopy.getWorkingRepository().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;
-    }
-  }
 }