Example usage for org.eclipse.jgit.revwalk RevSort TOPO

List of usage examples for org.eclipse.jgit.revwalk RevSort TOPO

Introduction

In this page you can find the example usage for org.eclipse.jgit.revwalk RevSort TOPO.

Prototype

RevSort TOPO

To view the source code for org.eclipse.jgit.revwalk RevSort TOPO.

Click Source Link

Document

Topological sorting (all children before parents).

Usage

From source file:boa.datagen.scm.GitConnector.java

License:Apache License

@Override
protected void setRevisions() {
    try {//www  .j  av a 2  s .  c om
        revwalk.reset();
        revwalk.markStart(revwalk.parseCommit(repository.resolve(Constants.HEAD)));
        revwalk.sort(RevSort.TOPO, true);
        revwalk.sort(RevSort.COMMIT_TIME_DESC, true);
        revwalk.sort(RevSort.REVERSE, true);

        revisions.clear();
        revisionMap = new HashMap<String, Integer>();

        for (final RevCommit rc : revwalk) {
            final GitCommit gc = new GitCommit(repository, this);

            gc.setId(rc.getName());
            gc.setAuthor(rc.getAuthorIdent().getName());
            gc.setCommitter(rc.getCommitterIdent().getName());
            gc.setDate(new Date(((long) rc.getCommitTime()) * 1000));
            gc.setMessage(rc.getFullMessage());

            gc.getChangeFiles(this.revisionMap, rc);

            revisionMap.put(gc.id, revisions.size());
            revisions.add(gc);
        }
    } catch (final IOException e) {
        if (debug)
            System.err.println("Git Error getting parsing HEAD commit for " + path + ". " + e.getMessage());
    }
}

From source file:com.gitblit.git.PatchsetReceivePack.java

License:Apache License

/**
 * Prepares a patchset command./*from   w  w w . ja v  a 2s.co m*/
 *
 * @param cmd
 * @return the patchset command
 */
private PatchsetCommand preparePatchset(ReceiveCommand cmd) {
    String branch = getIntegrationBranch(cmd.getRefName());
    long number = getTicketId(cmd.getRefName());

    TicketModel ticket = null;
    if (number > 0 && ticketService.hasTicket(repository, number)) {
        ticket = ticketService.getTicket(repository, number);
    }

    if (ticket == null) {
        if (number > 0) {
            // requested ticket does not exist
            sendError("Sorry, {0} does not have ticket {1,number,0}!", repository.name, number);
            sendRejection(cmd, "Invalid ticket number");
            return null;
        }
    } else {
        if (ticket.isMerged()) {
            // ticket already merged & resolved
            Change mergeChange = null;
            for (Change change : ticket.changes) {
                if (change.isMerge()) {
                    mergeChange = change;
                    break;
                }
            }
            if (mergeChange != null) {
                sendError("Sorry, {0} already merged {1} from ticket {2,number,0} to {3}!", mergeChange.author,
                        mergeChange.patchset, number, ticket.mergeTo);
            }
            sendRejection(cmd, "Ticket {0,number,0} already resolved", number);
            return null;
        } else if (!StringUtils.isEmpty(ticket.mergeTo)) {
            // ticket specifies integration branch
            branch = ticket.mergeTo;
        }
    }

    final int shortCommitIdLen = settings.getInteger(Keys.web.shortCommitIdLength, 6);
    final String shortTipId = cmd.getNewId().getName().substring(0, shortCommitIdLen);
    final RevCommit tipCommit = JGitUtils.getCommit(getRepository(), cmd.getNewId().getName());
    final String forBranch = branch;
    RevCommit mergeBase = null;
    Ref forBranchRef = getAdvertisedRefs().get(Constants.R_HEADS + forBranch);
    if (forBranchRef == null || forBranchRef.getObjectId() == null) {
        // unknown integration branch
        sendError("Sorry, there is no integration branch named ''{0}''.", forBranch);
        sendRejection(cmd, "Invalid integration branch specified");
        return null;
    } else {
        // determine the merge base for the patchset on the integration branch
        String base = JGitUtils.getMergeBase(getRepository(), forBranchRef.getObjectId(), tipCommit.getId());
        if (StringUtils.isEmpty(base)) {
            sendError("");
            sendError("There is no common ancestry between {0} and {1}.", forBranch, shortTipId);
            sendError("Please reconsider your proposed integration branch, {0}.", forBranch);
            sendError("");
            sendRejection(cmd, "no merge base for patchset and {0}", forBranch);
            return null;
        }
        mergeBase = JGitUtils.getCommit(getRepository(), base);
    }

    // ensure that the patchset can be cleanly merged right now
    MergeStatus status = JGitUtils.canMerge(getRepository(), tipCommit.getName(), forBranch,
            repository.mergeType);
    switch (status) {
    case ALREADY_MERGED:
        sendError("");
        sendError("You have already merged this patchset.", forBranch);
        sendError("");
        sendRejection(cmd, "everything up-to-date");
        return null;
    case MERGEABLE:
        break;
    default:
        if (ticket == null || requireMergeablePatchset) {
            sendError("");
            sendError("Your patchset can not be cleanly merged into {0}.", forBranch);
            sendError("Please rebase your patchset and push again.");
            sendError("NOTE:", number);
            sendError("You should push your rebase to refs/for/{0,number,0}", number);
            sendError("");
            sendError("  git push origin HEAD:refs/for/{0,number,0}", number);
            sendError("");
            sendRejection(cmd, "patchset not mergeable");
            return null;
        }
    }

    // check to see if this commit is already linked to a ticket
    if (ticket != null
            && JGitUtils.getTicketNumberFromCommitBranch(getRepository(), tipCommit) == ticket.number) {
        sendError("{0} has already been pushed to ticket {1,number,0}.", shortTipId, ticket.number);
        sendRejection(cmd, "everything up-to-date");
        return null;
    }

    List<TicketLink> ticketLinks = JGitUtils.identifyTicketsFromCommitMessage(getRepository(), settings,
            tipCommit);

    PatchsetCommand psCmd;
    if (ticket == null) {
        /*
         *  NEW TICKET
         */
        Patchset patchset = newPatchset(null, mergeBase.getName(), tipCommit.getName());

        int minLength = 10;
        int maxLength = 100;
        String minTitle = MessageFormat.format("  minimum length of a title is {0} characters.", minLength);
        String maxTitle = MessageFormat.format("  maximum length of a title is {0} characters.", maxLength);

        if (patchset.commits > 1) {
            sendError("");
            sendError("You may not create a ''{0}'' branch proposal ticket from {1} commits!", forBranch,
                    patchset.commits);
            sendError("");
            // display an ellipsized log of the commits being pushed
            RevWalk walk = getRevWalk();
            walk.reset();
            walk.sort(RevSort.TOPO);
            int boundary = 3;
            int count = 0;
            try {
                walk.markStart(tipCommit);
                walk.markUninteresting(mergeBase);

                for (;;) {

                    RevCommit c = walk.next();
                    if (c == null) {
                        break;
                    }

                    if (count < boundary || count >= (patchset.commits - boundary)) {

                        walk.parseBody(c);
                        sendError("   {0}  {1}", c.getName().substring(0, shortCommitIdLen),
                                StringUtils.trimString(c.getShortMessage(), 60));

                    } else if (count == boundary) {

                        sendError("   ... more commits ...");

                    }

                    count++;
                }

            } catch (IOException e) {
                // Should never happen, the core receive process would have
                // identified the missing object earlier before we got control.
                LOGGER.error("failed to get commit count", e);
            } finally {
                walk.close();
            }

            sendError("");
            sendError("Possible Solutions:");
            sendError("");
            int solution = 1;
            String forSpec = cmd.getRefName().substring(Constants.R_FOR.length());
            if (forSpec.equals("default") || forSpec.equals("new")) {
                try {
                    // determine other possible integration targets
                    List<String> bases = Lists.newArrayList();
                    for (Ref ref : getRepository().getRefDatabase().getRefs(Constants.R_HEADS).values()) {
                        if (!ref.getName().startsWith(Constants.R_TICKET)
                                && !ref.getName().equals(forBranchRef.getName())) {
                            if (JGitUtils.isMergedInto(getRepository(), ref.getObjectId(), tipCommit)) {
                                bases.add(Repository.shortenRefName(ref.getName()));
                            }
                        }
                    }

                    if (!bases.isEmpty()) {

                        if (bases.size() == 1) {
                            // suggest possible integration targets
                            String base = bases.get(0);
                            sendError("{0}. Propose this change for the ''{1}'' branch.", solution++, base);
                            sendError("");
                            sendError("   git push origin HEAD:refs/for/{0}", base);
                            sendError("   pt propose {0}", base);
                            sendError("");
                        } else {
                            // suggest possible integration targets
                            sendError("{0}. Propose this change for a different branch.", solution++);
                            sendError("");
                            for (String base : bases) {
                                sendError("   git push origin HEAD:refs/for/{0}", base);
                                sendError("   pt propose {0}", base);
                                sendError("");
                            }
                        }

                    }
                } catch (IOException e) {
                    LOGGER.error(null, e);
                }
            }
            sendError("{0}. Squash your changes into a single commit with a meaningful message.", solution++);
            sendError("");
            sendError("{0}. Open a ticket for your changes and then push your {1} commits to the ticket.",
                    solution++, patchset.commits);
            sendError("");
            sendError("   git push origin HEAD:refs/for/{id}");
            sendError("   pt propose {id}");
            sendError("");
            sendRejection(cmd, "too many commits");
            return null;
        }

        // require a reasonable title/subject
        String title = tipCommit.getFullMessage().trim().split("\n")[0];
        if (title.length() < minLength) {
            // reject, title too short
            sendError("");
            sendError("Please supply a longer title in your commit message!");
            sendError("");
            sendError(minTitle);
            sendError(maxTitle);
            sendError("");
            sendRejection(cmd, "ticket title is too short [{0}/{1}]", title.length(), maxLength);
            return null;
        }
        if (title.length() > maxLength) {
            // reject, title too long
            sendError("");
            sendError("Please supply a more concise title in your commit message!");
            sendError("");
            sendError(minTitle);
            sendError(maxTitle);
            sendError("");
            sendRejection(cmd, "ticket title is too long [{0}/{1}]", title.length(), maxLength);
            return null;
        }

        // assign new id
        long ticketId = ticketService.assignNewId(repository);

        // create the patchset command
        psCmd = new PatchsetCommand(user.username, patchset);
        psCmd.newTicket(tipCommit, forBranch, ticketId, cmd.getRefName());
    } else {
        /*
         *  EXISTING TICKET
         */
        Patchset patchset = newPatchset(ticket, mergeBase.getName(), tipCommit.getName());
        psCmd = new PatchsetCommand(user.username, patchset);
        psCmd.updateTicket(tipCommit, forBranch, ticket, cmd.getRefName());
    }

    // confirm user can push the patchset
    boolean pushPermitted = ticket == null || !ticket.hasPatchsets() || ticket.isAuthor(user.username)
            || ticket.isPatchsetAuthor(user.username) || ticket.isResponsible(user.username)
            || user.canPush(repository);

    switch (psCmd.getPatchsetType()) {
    case Proposal:
        // proposals (first patchset) are always acceptable
        break;
    case FastForward:
        // patchset updates must be permitted
        if (!pushPermitted) {
            // reject
            sendError("");
            sendError("To push a patchset to this ticket one of the following must be true:");
            sendError("  1. you created the ticket");
            sendError("  2. you created the first patchset");
            sendError("  3. you are specified as responsible for the ticket");
            sendError("  4. you have push (RW) permissions to {0}", repository.name);
            sendError("");
            sendRejection(cmd, "not permitted to push to ticket {0,number,0}", ticket.number);
            return null;
        }
        break;
    default:
        // non-fast-forward push
        if (!pushPermitted) {
            // reject
            sendRejection(cmd, "non-fast-forward ({0})", psCmd.getPatchsetType());
            return null;
        }
        break;
    }

    Change change = psCmd.getChange();
    change.pendingLinks = ticketLinks;

    return psCmd;
}

From source file:com.gitblit.plugin.flowdock.FlowDockReceiveHook.java

License:Apache License

private List<RevCommit> getCommits(GitblitReceivePack receivePack, String baseId, String tipId) {
    List<RevCommit> list = new ArrayList<RevCommit>();
    RevWalk walk = receivePack.getRevWalk();
    walk.reset();/*from  w w  w  .  j av a2  s.  com*/
    walk.sort(RevSort.TOPO);
    try {
        RevCommit tip = walk.parseCommit(receivePack.getRepository().resolve(tipId));
        RevCommit base = walk.parseCommit(receivePack.getRepository().resolve(baseId));
        walk.markStart(tip);
        walk.markUninteresting(base);
        for (;;) {
            RevCommit c = walk.next();
            if (c == null) {
                break;
            }
            list.add(c);
        }
    } catch (IOException e) {
        // Should never happen, the core receive process would have
        // identified the missing object earlier before we got control.
        log.error("failed to get commits", e);
    } finally {
        walk.release();
    }
    return list;
}

From source file:com.gitblit.plugin.flowdock.TicketMessageGenerator.java

License:Apache License

private List<RevCommit> getCommits(String repositoryName, String baseId, String tipId) {
    IRepositoryManager repositoryManager = GitblitContext.getManager(IRepositoryManager.class);
    Repository db = repositoryManager.getRepository(repositoryName);
    List<RevCommit> list = new ArrayList<RevCommit>();
    RevWalk walk = new RevWalk(db);
    walk.reset();//w w  w.  jav  a  2  s.c o m
    walk.sort(RevSort.TOPO);
    walk.sort(RevSort.REVERSE, true);
    try {
        RevCommit tip = walk.parseCommit(db.resolve(tipId));
        RevCommit base = walk.parseCommit(db.resolve(baseId));
        walk.markStart(tip);
        walk.markUninteresting(base);
        for (;;) {
            RevCommit c = walk.next();
            if (c == null) {
                break;
            }
            list.add(c);
        }
    } catch (IOException e) {
        // Should never happen, the core receive process would have
        // identified the missing object earlier before we got control.
        log.error("failed to get commits", e);
    } finally {
        walk.release();
        db.close();
    }
    return list;
}

From source file:com.gitblit.plugin.jabber.JabberReceiveHook.java

License:Apache License

private List<RevCommit> getCommits(GitblitReceivePack receivePack, String baseId, String tipId) {
    List<RevCommit> list = new ArrayList<>();
    RevWalk walk = receivePack.getRevWalk();
    walk.reset();//from w w  w.j a va  2s .  c  om
    walk.sort(RevSort.TOPO);
    try {
        RevCommit tip = walk.parseCommit(receivePack.getRepository().resolve(tipId));
        RevCommit base = walk.parseCommit(receivePack.getRepository().resolve(baseId));
        walk.markStart(tip);
        walk.markUninteresting(base);
        for (;;) {
            RevCommit c = walk.next();
            if (c == null) {
                break;
            }
            list.add(c);
        }
    } catch (IOException e) {
        // Should never happen, the core receive process would have
        // identified the missing object earlier before we got control.
        log.error("failed to get commits", e);
    } finally {
        walk.release();
    }
    return list;
}

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

/**
 * Try to identify all referenced tickets between two commits
 *
 * @param commit//from  w  w  w.  jav  a 2  s .c o  m
 * @param parseMessage
 * @param currentTicketId, or 0 if not on a ticket branch
 * @return a collection of TicketLink, or null if commit is already linked
 */
public static List<TicketLink> identifyTicketsBetweenCommits(Repository repository, IStoredSettings settings,
        String baseSha, String tipSha) {
    List<TicketLink> links = new ArrayList<TicketLink>();
    if (repository == null) {
        return links;
    }

    RevWalk walk = new RevWalk(repository);
    walk.sort(RevSort.TOPO);
    walk.sort(RevSort.REVERSE, true);
    try {
        RevCommit tip = walk.parseCommit(repository.resolve(tipSha));
        RevCommit base = walk.parseCommit(repository.resolve(baseSha));
        walk.markStart(tip);
        walk.markUninteresting(base);
        for (;;) {
            RevCommit commit = walk.next();
            if (commit == null) {
                break;
            }
            links.addAll(JGitUtils.identifyTicketsFromCommitMessage(repository, settings, commit));
        }
    } catch (IOException e) {
        LOGGER.error("failed to identify tickets between commits.", e);
    } finally {
        walk.dispose();
    }

    return links;
}

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

public static int countCommits(Repository repository, RevWalk walk, ObjectId baseId, ObjectId tipId) {
    int count = 0;
    walk.reset();//from   w ww  .ja  va  2s. co  m
    walk.sort(RevSort.TOPO);
    walk.sort(RevSort.REVERSE, true);
    try {
        RevCommit tip = walk.parseCommit(tipId);
        RevCommit base = walk.parseCommit(baseId);
        walk.markStart(tip);
        walk.markUninteresting(base);
        for (;;) {
            RevCommit c = walk.next();
            if (c == null) {
                break;
            }
            count++;
        }
    } catch (IOException e) {
        // Should never happen, the core receive process would have
        // identified the missing object earlier before we got control.
        LOGGER.error("failed to get commit count", e);
        return 0;
    } finally {
        walk.close();
    }
    return count;
}

From source file:com.google.gerrit.server.change.GetRelatedByAncestors.java

License:Apache License

private List<ChangeAndCommit> walk(RevisionResource rsrc, RevWalk rw, Ref ref)
        throws OrmException, IOException {
    Map<Change.Id, ChangeData> changes = allOpenChanges(rsrc);
    Map<PatchSet.Id, PatchSet> patchSets = allPatchSets(rsrc, changes.values());

    Map<String, PatchSet> commits = Maps.newHashMap();
    for (PatchSet p : patchSets.values()) {
        commits.put(p.getRevision().get(), p);
    }/*  w  w w .  j  a  v  a 2 s  .co  m*/

    RevCommit rev = rw.parseCommit(ObjectId.fromString(rsrc.getPatchSet().getRevision().get()));
    rw.sort(RevSort.TOPO);
    rw.markStart(rev);

    if (ref != null && ref.getObjectId() != null) {
        try {
            rw.markUninteresting(rw.parseCommit(ref.getObjectId()));
        } catch (IncorrectObjectTypeException notCommit) {
            // Ignore and treat as new branch.
        }
    }

    Set<Change.Id> added = Sets.newHashSet();
    List<ChangeAndCommit> parents = Lists.newArrayList();
    for (RevCommit c; (c = rw.next()) != null;) {
        PatchSet p = commits.get(c.name());
        Change g = null;
        if (p != null) {
            g = changes.get(p.getId().getParentKey()).change();
            added.add(p.getId().getParentKey());
        }
        parents.add(new ChangeAndCommit(g, p, c));
    }
    List<ChangeAndCommit> list = children(rsrc, rw, changes, patchSets, added);
    list.addAll(parents);

    if (list.size() == 1) {
        ChangeAndCommit r = list.get(0);
        if (r.commit != null && r.commit.commit.equals(rsrc.getPatchSet().getRevision().get())) {
            return Collections.emptyList();
        }
    }
    return list;
}

From source file:com.google.gerrit.server.git.GroupCollectorTest.java

License:Apache License

private RevWalk newWalk(ObjectId start, ObjectId branchTip) throws Exception {
    // Match RevWalk conditions from ReceiveCommits.
    RevWalk rw = new RevWalk(tr.getRepository());
    rw.sort(RevSort.TOPO);
    rw.sort(RevSort.REVERSE, true);/*from  w w w .j  a va 2  s  .c  om*/
    rw.markStart(rw.parseCommit(start));
    rw.markUninteresting(rw.parseCommit(branchTip));
    return rw;
}

From source file:com.google.gerrit.server.git.MergeOp.java

License:Apache License

private void openRepository(Project.NameKey name) throws MergeException, NoSuchProjectException {
    try {/*from  ww  w.ja va  2 s  . c o m*/
        repo = repoManager.openRepository(name);
    } catch (RepositoryNotFoundException notFound) {
        throw new NoSuchProjectException(name, notFound);
    } catch (IOException err) {
        String m = "Error opening repository \"" + name.get() + '"';
        throw new MergeException(m, err);
    }

    rw = CodeReviewCommit.newRevWalk(repo);
    rw.sort(RevSort.TOPO);
    rw.sort(RevSort.COMMIT_TIME_DESC, true);
    canMergeFlag = rw.newFlag("CAN_MERGE");

    inserter = repo.newObjectInserter();
}