Added force to push command for git and hg repos

Committed-by: Rene Pfeuffer <rene.pfeuffer@cloudogu.com>

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

@@ -32,19 +32,26 @@ import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.transport.PushResult;
 import org.eclipse.jgit.transport.RemoteRefUpdate;
-import org.eclipse.jgit.transport.ScmTransportProtocol;
 import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.repository.GitRepositoryHandler;
 import sonia.scm.repository.GitUtil;
 import sonia.scm.repository.InternalRepositoryException;
+import sonia.scm.repository.api.PushFailedException;
 
 import java.io.File;
 import java.util.Collection;
+import java.util.List;
 
 public abstract class AbstractGitPushOrPullCommand extends AbstractGitCommand {
 
+  private static final List<RemoteRefUpdate.Status> REJECTED_STATUSES = List.of(
+    RemoteRefUpdate.Status.REJECTED_NODELETE,
+    RemoteRefUpdate.Status.REJECTED_NONFASTFORWARD,
+    RemoteRefUpdate.Status.REJECTED_REMOTE_CHANGED,
+    RemoteRefUpdate.Status.REJECTED_OTHER_REASON
+  );
   private static final Logger LOG = LoggerFactory.getLogger(AbstractGitPushOrPullCommand.class);
 
   protected GitRepositoryHandler handler;
@@ -54,7 +61,7 @@ public abstract class AbstractGitPushOrPullCommand extends AbstractGitCommand {
     this.handler = handler;
   }
 
-  protected long push(Repository source, String remoteUrl, String username, String password) {
+  protected long push(Repository source, String remoteUrl, String username, String password, boolean force) {
     Git git = Git.wrap(source);
     org.eclipse.jgit.api.PushCommand push = git.push();
 
@@ -63,19 +70,23 @@ public abstract class AbstractGitPushOrPullCommand extends AbstractGitCommand {
     }
     push.setPushAll().setPushTags();
     push.setRemote(remoteUrl);
+    push.setForce(force);
 
-    long counter = -1;
+    long counter;
 
     try {
       Iterable<PushResult> results = push.call();
-
-      if (results != null) {
-        counter = 0;
-
-        for (PushResult result : results) {
-          counter += count(git, result);
-        }
+      if (hasPushFailed(results)) {
+        throw new PushFailedException(repository);
       }
+
+      counter = 0;
+
+      for (PushResult result : results) {
+        counter += count(git, result);
+      }
+    } catch (PushFailedException ex) {
+      throw ex;
     } catch (Exception ex) {
       throw new InternalRepositoryException(repository, "could not execute push/pull command", ex);
     }
@@ -83,6 +94,22 @@ public abstract class AbstractGitPushOrPullCommand extends AbstractGitCommand {
     return counter;
   }
 
+  private boolean hasPushFailed(Iterable<PushResult> pushResults) {
+    if (pushResults == null) {
+      return true;
+    }
+
+    for (PushResult nextResult : pushResults) {
+      for(RemoteRefUpdate remoteUpdate : nextResult.getRemoteUpdates()) {
+        if(REJECTED_STATUSES.contains(remoteUpdate.getStatus())) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   protected String getRemoteUrl(RemoteCommandRequest request) {
     String url;
     sonia.scm.repository.Repository remRepo = request.getRemoteRepository();

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

@@ -166,7 +166,7 @@ public class GitPullCommand extends AbstractGitPushOrPullCommand
 
     try (Git git = Git.open(sourceDirectory)) {
       source = git.getRepository();
-      response = new PullResponse(push(source, getRemoteUrl(targetDirectory), username, password));
+      response = new PullResponse(push(source, getRemoteUrl(targetDirectory), username, password, false));
     } finally {
       GitUtil.close(source);
     }

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

@@ -49,6 +49,6 @@ public class GitPushCommand extends AbstractGitPushOrPullCommand implements Push
 
     LOG.debug("push changes from {} to {}", repository, remoteUrl);
 
-    return new PushResponse(push(open(), remoteUrl, request.getUsername(), request.getPassword()));
+    return new PushResponse(push(open(), remoteUrl, request.getUsername(), request.getPassword(), request.isForce()));
   }
 }

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

@@ -65,7 +65,8 @@ public class GitRepositoryServiceProvider extends RepositoryServiceProvider {
 
   protected static final Set<Feature> FEATURES = EnumSet.of(
     Feature.INCOMING_REVISION,
-    Feature.MODIFICATIONS_BETWEEN_REVISIONS
+    Feature.MODIFICATIONS_BETWEEN_REVISIONS,
+    Feature.FORCE_PUSH
   );
 
   private final GitContext context;

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

@@ -30,11 +30,14 @@ import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.junit.Test;
 import sonia.scm.repository.GitConfig;
+import sonia.scm.repository.api.PushFailedException;
 import sonia.scm.repository.api.PushResponse;
 
 import java.io.IOException;
 import java.util.Iterator;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
@@ -82,6 +85,51 @@ public class GitPushCommandTest extends AbstractRemoteCommandTestBase
     assertEquals(o1, commits.next());
   }
 
+  @Test
+  public void testForcePush() throws IOException, GitAPIException {
+    write(outgoing, outgoingDirectory, "a.txt", "content of a.txt");
+    RevCommit outgoingCommit = commit(outgoing, "added a");
+
+    write(incoming, incomingDirectory, "a.txt", "conflicting change of a.txt");
+    commit(incoming, "changed a");
+
+    PushCommandRequest request = new PushCommandRequest();
+    request.setRemoteRepository(incomingRepository);
+    request.setForce(true);
+
+    GitPushCommand cmd = createCommand();
+    PushResponse response = cmd.push(request);
+
+    assertNotNull(response);
+    assertEquals(0L, response.getChangesetCount());
+
+    Iterator<RevCommit> commits = incoming.log().call().iterator();
+
+    assertEquals(outgoingCommit, commits.next());
+    assertThat(commits.hasNext()).isFalse();
+  }
+
+  @Test
+  public void testFailedPushBecauseOfConflict() throws IOException, GitAPIException {
+    write(outgoing, outgoingDirectory, "a.txt", "content of a.txt");
+    commit(outgoing, "added a");
+
+    write(incoming, incomingDirectory, "a.txt", "conflicting change of a.txt");
+    RevCommit incomingCommit = commit(incoming, "changed a");
+
+    GitPushCommand cmd = createCommand();
+    PushCommandRequest request = new PushCommandRequest();
+    request.setRemoteRepository(incomingRepository);
+
+    assertThatThrownBy(() -> cmd.push(request))
+      .isInstanceOf(PushFailedException.class)
+      .hasMessageContaining("Failed to push");
+
+    Iterator<RevCommit> commits = incoming.log().call().iterator();
+    assertEquals(incomingCommit, commits.next());
+    assertThat(commits.hasNext()).isFalse();
+  }
+
   /**
    * Method description
    *

scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/spi/HgPushCommand.java

@@ -26,25 +26,22 @@ package sonia.scm.repository.spi;
 
 //~--- non-JDK imports --------------------------------------------------------
 
+import com.google.common.base.Strings;
 import org.javahg.Changeset;
 import org.javahg.commands.ExecutionException;
-import com.google.common.base.Strings;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.repository.HgRepositoryHandler;
-import sonia.scm.repository.api.ImportFailedException;
+import sonia.scm.repository.api.PushFailedException;
 import sonia.scm.repository.api.PushResponse;
 
 import javax.inject.Inject;
 import java.io.IOException;
 import java.util.List;
 
-import static sonia.scm.ContextEntry.ContextBuilder.entity;
-
 //~--- JDK imports ------------------------------------------------------------
 
 /**
- *
  * @author Sebastian Sdorra
  */
 public class HgPushCommand extends AbstractHgPushOrPullCommand implements PushCommand {
@@ -74,9 +71,17 @@ public class HgPushCommand extends AbstractHgPushOrPullCommand implements PushCo
     List<Changeset> result;
 
     try {
-      result = org.javahg.commands.PushCommand.on(open()).execute(url);
+      result = builder.call(() -> {
+        org.javahg.commands.PushCommand hgPush = org.javahg.commands.PushCommand.on(open());
+
+        if (request.isForce()) {
+          hgPush.force();
+        }
+
+        return hgPush.execute(url);
+      });
     } catch (ExecutionException ex) {
-      throw new ImportFailedException(entity(getRepository()).build(), "could not execute pull command", ex);
+      throw new PushFailedException(getRepository());
     }
 
     return new PushResponse(result.size());

scm-plugins/scm-hg-plugin/src/main/java/sonia/scm/repository/spi/HgRepositoryServiceProvider.java

@@ -64,7 +64,8 @@ public class HgRepositoryServiceProvider extends RepositoryServiceProvider {
   public static final Set<Feature> FEATURES = EnumSet.of(
     Feature.COMBINED_DEFAULT_BRANCH,
     Feature.MODIFICATIONS_BETWEEN_REVISIONS,
-    Feature.INCOMING_REVISION
+    Feature.INCOMING_REVISION,
+    Feature.FORCE_PUSH
   );
 
   private final Injector commandInjector;

scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/repository/spi/HgPushCommandTest.java

@@ -0,0 +1,110 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2020-present Cloudogu GmbH and Contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package sonia.scm.repository.spi;
+
+import org.javahg.Changeset;
+import org.junit.Test;
+import sonia.scm.config.ScmConfiguration;
+import sonia.scm.net.GlobalProxyConfiguration;
+import sonia.scm.repository.HgConfigResolver;
+import sonia.scm.repository.HgTestUtil;
+import sonia.scm.repository.api.PushFailedException;
+import sonia.scm.repository.api.PushResponse;
+
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class HgPushCommandTest extends IncomingOutgoingTestBase {
+
+  @Test
+  public void testPush() throws IOException {
+    writeNewFile(outgoing, outgoingDirectory, "a.txt", "content of a.txt");
+    Changeset o1 = commit(outgoing, "added a");
+
+    writeNewFile(outgoing, outgoingDirectory, "b.txt", "content of b.txt");
+    Changeset o2 = commit(outgoing, "added b");
+
+    HgPushCommand cmd = createPushCommand();
+    PushCommandRequest request = new PushCommandRequest();
+    request.setRemoteRepository(incomingRepository);
+
+    PushResponse response = cmd.push(request);
+    assertThat(response).isNotNull();
+    assertThat(response.getChangesetCount()).isEqualTo(2);
+
+    assertThat(incoming.changeset(o1.getNode())).isNotNull();
+    assertThat(incoming.changeset(o2.getNode())).isNotNull();
+  }
+
+  @Test
+  public void testForcePush() throws IOException {
+    writeNewFile(outgoing, outgoingDirectory, "a.txt", "content of a.txt");
+    Changeset outgoingCommit = commit(outgoing, "added a");
+
+    writeNewFile(incoming, incomingDirectory, "a.txt", "conflicting change of a.txt");
+    commit(incoming, "changed a");
+
+    HgPushCommand cmd = createPushCommand();
+    PushCommandRequest request = new PushCommandRequest();
+    request.setRemoteRepository(incomingRepository);
+    request.setForce(true);
+
+    PushResponse response = cmd.push(request);
+    assertThat(response).isNotNull();
+    assertThat(response.getChangesetCount()).isEqualTo(1);
+
+    assertThat(incoming.tip().getNode()).isEqualTo(outgoingCommit.getNode());
+  }
+
+  @Test
+  public void testFailedPushBecauseOfConflict() throws IOException {
+    writeNewFile(outgoing, outgoingDirectory, "a.txt", "content of a.txt");
+    commit(outgoing, "added a");
+
+    writeNewFile(incoming, incomingDirectory, "a.txt", "conflicting change of a.txt");
+    Changeset incomingCommit = commit(incoming, "changed a");
+
+    HgPushCommand cmd = createPushCommand();
+    PushCommandRequest request = new PushCommandRequest();
+    request.setRemoteRepository(incomingRepository);
+
+    assertThatThrownBy(() -> cmd.push(request))
+      .isInstanceOf(PushFailedException.class)
+      .hasMessageContaining("Failed to push");
+
+    assertThat(incoming.tip().getNode()).isEqualTo(incomingCommit.getNode());
+  }
+
+  private HgPushCommand createPushCommand() {
+    HgConfigResolver resolver = new HgConfigResolver(handler);
+    return new HgPushCommand(
+      handler,
+      new HgCommandContext(resolver, HgTestUtil.createFactory(handler, outgoingDirectory), outgoingRepository),
+      new TemporaryConfigFactory(new GlobalProxyConfiguration(new ScmConfiguration()))
+    );
+  }
+}