gerrit-server/src/main/java/com/google/gerrit/server/change/RebaseUtil.java

// Copyright (C) 2015 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.server.change;

import com.google.gerrit.extensions.restapi.ResourceConflictException;
import com.google.gerrit.extensions.restapi.RestApiException;
import com.google.gerrit.extensions.restapi.UnprocessableEntityException;
import com.google.gerrit.reviewdb.client.Branch;
import com.google.gerrit.reviewdb.client.Change;
import com.google.gerrit.reviewdb.client.Change.Status;
import com.google.gerrit.reviewdb.client.PatchSet;
import com.google.gerrit.reviewdb.client.RevId;
import com.google.gerrit.reviewdb.server.ReviewDb;
import com.google.gerrit.server.git.GitRepositoryManager;
import com.google.gwtorm.server.OrmException;
import com.google.inject.Inject;
import com.google.inject.Provider;

import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;

/** Utility methods related to rebasing changes. */
public class RebaseUtil {
  private static final Logger log = LoggerFactory.getLogger(RebaseUtil.class);

  private final Provider<ReviewDb> db;
  private final GitRepositoryManager gitManager;

  @Inject
  RebaseUtil(Provider<ReviewDb> db,
      GitRepositoryManager gitManager) {
    this.db = db;
    this.gitManager = gitManager;
  }

  public boolean canRebase(RevisionResource r) {
    PatchSet patchSet = r.getPatchSet();
    Branch.NameKey dest = r.getChange().getDest();
    try (Repository git = gitManager.openRepository(dest.getParentKey());
        RevWalk rw = new RevWalk(git)) {
      return canRebase(
          r.getPatchSet(), dest, git, rw, db.get());
    } catch (IOException e) {
      log.warn(String.format(
          "Error checking if patch set %s on %s can be rebased",
          patchSet.getId(), dest), e);
      return false;
    }
  }

  public static boolean canRebase(PatchSet patchSet, Branch.NameKey dest,
      Repository git, RevWalk rw, ReviewDb db) {
    try {
      findBaseRevision(patchSet, dest, git, rw, db);
      return true;
    } catch (RestApiException e) {
      return false;
    } catch (OrmException | IOException e) {
      log.warn(String.format(
          "Error checking if patch set %s on %s can be rebased",
          patchSet.getId(), dest), e);
      return false;
    }
  }

  /**
   * Find the commit onto which a patch set should be rebased.
   * <p>
   * This is defined as the latest patch set of the change corresponding to
   * this commit's parent, or the destination branch tip in the case where the
   * parent's change is merged.
   *
   * @param patchSet patch set for which the new base commit should be found.
   * @param destBranch the destination branch.
   * @param git the repository.
   * @param rw the RevWalk.
   * @return the commit onto which the patch set should be rebased.
   * @throws RestApiException if rebase is not possible.
   * @throws IOException if accessing the repository fails.
   * @throws OrmException if accessing the database fails.
   */
  static ObjectId findBaseRevision(PatchSet patchSet,
      Branch.NameKey destBranch, Repository git, RevWalk rw, ReviewDb db)
      throws RestApiException, IOException, OrmException {
    String baseRev = null;
    RevCommit commit = rw.parseCommit(
        ObjectId.fromString(patchSet.getRevision().get()));

    if (commit.getParentCount() > 1) {
      throw new UnprocessableEntityException(
          "Cannot rebase a change with multiple parents.");
    } else if (commit.getParentCount() == 0) {
      throw new UnprocessableEntityException(
          "Cannot rebase a change without any parents"
          + " (is this the initial commit?).");
    }

    RevId parentRev = new RevId(commit.getParent(0).name());

    for (PatchSet depPatchSet : db.patchSets().byRevision(parentRev)) {
      Change.Id depChangeId = depPatchSet.getId().getParentKey();
      Change depChange = db.changes().get(depChangeId);
      if (!depChange.getDest().equals(destBranch)) {
        continue;
      }

      if (depChange.getStatus() == Status.ABANDONED) {
        throw new ResourceConflictException(
            "Cannot rebase a change with an abandoned parent: "
            + depChange.getKey());
      }

      if (depChange.getStatus().isOpen()) {
        if (depPatchSet.getId().equals(depChange.currentPatchSetId())) {
          throw new ResourceConflictException(
              "Change is already based on the latest patch set of the"
              + " dependent change.");
        }
        PatchSet latestDepPatchSet =
            db.patchSets().get(depChange.currentPatchSetId());
        baseRev = latestDepPatchSet.getRevision().get();
      }
      break;
    }

    if (baseRev == null) {
      // We are dependent on a merged PatchSet or have no PatchSet
      // dependencies at all.
      Ref destRef = git.getRefDatabase().exactRef(destBranch.get());
      if (destRef == null) {
        throw new UnprocessableEntityException(
            "The destination branch does not exist: " + destBranch.get());
      }
      baseRev = destRef.getObjectId().getName();
      if (baseRev.equals(parentRev.get())) {
        throw new ResourceConflictException("Change is already up to date.");
      }
    }
    return ObjectId.fromString(baseRev);
  }
}