Example usage for org.eclipse.jgit.lib Constants R_HEADS

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib Constants R_HEADS.

Prototype

String R_HEADS

To view the source code for org.eclipse.jgit.lib Constants R_HEADS.

Click Source Link

Document

Prefix for branch refs

Usage

From source file:org.jenkinsci.git.LsRemoteOperationTest.java

License:Open Source License

/**
 * List remote on empty repository//from   ww  w .  j  a v  a  2  s  . c o  m
 *
 * @throws Exception
 */
@Test
public void listEmptyRemote() throws Exception {
    Repository gitRepo = git.repo();
    BuildRepository repo = new BuildRepository(gitRepo.getDirectory().toURI().toString(),
            Constants.R_HEADS + Constants.MASTER, null);
    LsRemoteOperation op = new LsRemoteOperation(repo, gitRepo);
    assertNull(op.call());
}

---

From source file:org.jenkinsci.git.LsRemoteOperationTest.java

License:Open Source License

/**
 * List remote on empty repository/*from   w  ww.  j a  va 2 s.  c  o m*/
 *
 * @throws Exception
 */
@Test
public void listRemote() throws Exception {
    Repository gitRepo = git.repo();
    BuildRepository repo = new BuildRepository(gitRepo.getDirectory().toURI().toString(),
            Constants.R_HEADS + Constants.MASTER, null);
    LsRemoteOperation op = new LsRemoteOperation(repo, gitRepo);
    RevCommit commit1 = git.add("file.txt", "a");
    assertEquals(commit1, op.call());
    RevCommit commit2 = git.add("file.txt", "b");
    assertEquals(commit2, op.call());
}

---

From source file:org.jenkinsci.plugins.github_branch_source.GitHubSCMBuilder.java

License:Open Source License

/**
 * {@inheritDoc}//  w ww  .  j ava  2 s  .  c  o m
 */
@NonNull
@Override
public GitSCM build() {
    final SCMHead h = head();
    final SCMRevision r = revision();
    try {
        withGitHubRemote();

        if (h instanceof PullRequestSCMHead) {
            PullRequestSCMHead head = (PullRequestSCMHead) h;
            if (head.isMerge()) {
                // add the target branch to ensure that the revision we want to merge is also available
                String name = head.getTarget().getName();
                String localName = "remotes/" + remoteName() + "/" + name;
                Set<String> localNames = new HashSet<>();
                boolean match = false;
                String targetSrc = Constants.R_HEADS + name;
                String targetDst = Constants.R_REMOTES + remoteName() + "/" + name;
                for (RefSpec b : asRefSpecs()) {
                    String dst = b.getDestination();
                    assert dst.startsWith(Constants.R_REFS) : "All git references must start with refs/";
                    if (targetSrc.equals(b.getSource())) {
                        if (targetDst.equals(dst)) {
                            match = true;
                        } else {
                            // pick up the configured destination name
                            localName = dst.substring(Constants.R_REFS.length());
                            match = true;
                        }
                    } else {
                        localNames.add(dst.substring(Constants.R_REFS.length()));
                    }
                }
                if (!match) {
                    if (localNames.contains(localName)) {
                        // conflict with intended name
                        localName = "remotes/" + remoteName() + "/upstream-" + name;
                    }
                    if (localNames.contains(localName)) {
                        // conflict with intended alternative name
                        localName = "remotes/" + remoteName() + "/pr-" + head.getNumber() + "-upstream-" + name;
                    }
                    if (localNames.contains(localName)) {
                        // ok we're just going to mangle our way to something that works
                        Random entropy = new Random();
                        while (localNames.contains(localName)) {
                            localName = "remotes/" + remoteName() + "/pr-" + head.getNumber() + "-upstream-"
                                    + name + "-" + Integer.toHexString(entropy.nextInt(Integer.MAX_VALUE));
                        }
                    }
                    withRefSpec("+refs/heads/" + name + ":refs/" + localName);
                }
                withExtension(new MergeWithGitSCMExtension(localName,
                        r instanceof PullRequestSCMRevision ? ((PullRequestSCMRevision) r).getBaseHash()
                                : null));
            }
            if (r instanceof PullRequestSCMRevision) {
                PullRequestSCMRevision rev = (PullRequestSCMRevision) r;
                withRevision(new AbstractGitSCMSource.SCMRevisionImpl(head, rev.getPullHash()));
            }
        }
        return super.build();
    } finally {
        withHead(h);
        withRevision(r);
    }
}

---

From source file:org.kuali.student.git.cleaner.AbstractRepositoryCleaner.java

License:Educational Community License

@Override
public final void execute() throws IOException {

    onBeforeExecute();//from   w w w. j  ava 2s .  c o m

    inserter = getRepo().newObjectInserter();

    boolean localBranchSource = true;

    if (!getBranchRefSpec().equals(Constants.R_HEADS))
        localBranchSource = false;

    dateString = formatter.print(new DateTime());

    /*
     * Track the commits that are rewritten.
     * 
     * This is important so that we can update the grafts file to relate to
     * the current parent object ids.
     */
    PrintWriter objectTranslationWriter = new PrintWriter(
            "object-translations-" + getFileNameSuffix() + "-" + dateString + ".txt");

    branchHeads = getRepo().getRefDatabase().getRefs(getBranchRefSpec());

    commitToBranchMap = new HashMap<ObjectId, Set<Ref>>();

    walkRepo = new RevWalk(getRepo());

    for (Ref branchRef : branchHeads.values()) {

        ObjectId branchObjectId = branchRef.getObjectId();

        Set<Ref> refs = commitToBranchMap.get(branchObjectId);

        if (refs == null) {
            refs = new HashSet<>();
            commitToBranchMap.put(branchObjectId, refs);
        }

        refs.add(branchRef);

        walkRepo.markStart(walkRepo.parseCommit(branchObjectId));

        onBranchHead(branchRef, branchObjectId);

    }

    if (includeTagsInRevWalk()) {

        tagHeads = getRepo().getRefDatabase().getRefs(Constants.R_TAGS);
    } else {
        tagHeads = new HashMap<String, Ref>();
    }

    commitToTagMap = new HashMap<ObjectId, Set<Ref>>();

    for (Ref tagRef : tagHeads.values()) {

        RevTag tag = walkRepo.parseTag(tagRef.getObjectId());

        ObjectId commitId = tag.getObject().getId();

        Set<Ref> refs = commitToTagMap.get(commitId);

        if (refs == null) {
            refs = new HashSet<>();
            commitToTagMap.put(commitId, refs);
        }

        refs.add(tagRef);

        walkRepo.markStart(walkRepo.parseCommit(commitId));

        onTag(tag.getId(), commitId);
    }

    onBeforeRevWalk();

    walkRepo.sort(RevSort.TOPO, true);
    walkRepo.sort(RevSort.REVERSE, true);

    Iterator<RevCommit> it = provideRevCommitIterator(walkRepo.iterator());

    deferredReferenceDeletes = new LinkedList<>();
    deferredReferenceCreates = new LinkedList<>();

    objectTranslationWriter.println("# new-object-id <space> original-object-id");

    originalCommitIdToNewCommitIdMap = new HashMap<>();

    GitTreeProcessor treeProcessor = new GitTreeProcessor(getRepo());

    processedCommits = new HashSet<ObjectId>();

    while (it.hasNext()) {

        RevCommit commit = it.next();

        boolean recreateCommitByTranslatedParent = determineIfRecreateByTranslatedParent(commit);

        GitTreeData tree = treeProcessor.extractExistingTreeDataFromCommit(commit.getId());

        boolean recreate = processCommitTree(commit, tree);

        if (!recreateCommitByTranslatedParent && !recreate) {
            processedCommits.add(commit.getId());
            continue;
        }

        /*
         * Process in reverse order from old to new.
         */
        CommitBuilder builder = new CommitBuilder();

        builder.setAuthor(commit.getAuthorIdent());
        builder.setMessage(commit.getFullMessage());

        builder.setCommitter(commit.getCommitterIdent());

        if (tree.isTreeDirty()) {

            ObjectId newTreeId = tree.buildTree(inserter);

            builder.setTreeId(newTreeId);
        } else {
            builder.setTreeId(commit.getTree().getId());
        }

        builder.setEncoding("UTF-8");

        Set<ObjectId> newParents = processParents(commit);

        builder.setParentIds(new ArrayList<>(newParents));

        ObjectId newCommitId = inserter.insert(builder);

        onNewCommit(commit, newCommitId);

        originalCommitIdToNewCommitIdMap.put(commit.getId(), newCommitId);

        objectTranslationWriter.println(newCommitId.name() + " " + commit.getId().getName());

        RevWalk commitWalk = new RevWalk(getRepo());

        RevCommit newCommit = commitWalk.parseCommit(newCommitId);

        processedCommits.add(newCommitId);

        // check if any tags need to be moved
        if (commitToTagMap.containsKey(commit.getId())) {

            Set<Ref> tags = commitToTagMap.get(commit.getId());

            Set<TagBuilder> newTagSet = new HashSet<>();

            for (Ref tagRef : tags) {

                RevTag tag = commitWalk.parseTag(tagRef.getObjectId());

                TagBuilder tb = new TagBuilder();

                tb.setMessage(tag.getFullMessage());
                tb.setObjectId(newCommit);
                tb.setTag(tag.getTagName());
                tb.setTagger(tag.getTaggerIdent());

                newTagSet.add(tb);

                deferDelete(tagRef.getName(), tagRef.getObjectId());

            }

            for (TagBuilder tagBuilder : newTagSet) {

                ObjectId tagId = inserter.insert(tagBuilder);

                String tagName = Constants.R_TAGS + tagBuilder.getTag();

                deferCreate(tagName, tagId);

                onTagRefCreate(tagName, tagId);

            }

        }

        // check if any branches need to be moved
        if (commitToBranchMap.containsKey(commit.getId())) {

            Set<Ref> refs = commitToBranchMap.get(commit.getId());

            for (Ref branchRef : refs) {

                if (localBranchSource) {

                    deferDelete(branchRef.getName(), branchRef.getObjectId());

                }

                String adjustedBranchName = Constants.R_HEADS
                        + branchRef.getName().substring(getBranchRefSpec().length());

                deferCreate(adjustedBranchName, newCommitId);

                onBranchRefCreate(adjustedBranchName, newCommitId);

            }

        }

        commitWalk.release();
    }

    inserter.flush();

    getRepo().getRefDatabase().refresh();

    log.info("Applying updates: " + deferredReferenceDeletes.size() + " deletes, "
            + deferredReferenceCreates.size() + " creates.");

    if (getExternalGitCommandPath() != null) {
        ExternalGitUtils.batchRefUpdate(getExternalGitCommandPath(), getRepo(), deferredReferenceDeletes,
                System.out);
    } else {
        GitRefUtils.batchRefUpdate(getRepo(), deferredReferenceDeletes, NullProgressMonitor.INSTANCE);
    }

    getRepo().getRefDatabase().refresh();

    if (getExternalGitCommandPath() != null) {
        ExternalGitUtils.batchRefUpdate(getExternalGitCommandPath(), getRepo(), deferredReferenceCreates,
                System.out);
    } else {

        GitRefUtils.batchRefUpdate(getRepo(), deferredReferenceCreates, NullProgressMonitor.INSTANCE);

    }

    log.info("Completed.");

    walkRepo.release();

    inserter.release();

    close();

    objectTranslationWriter.close();

}

---

From source file:org.kuali.student.git.cleaner.RepositorySplitter.java

License:Educational Community License

@Override
protected void onNewCommit(RevCommit commit, ObjectId newCommitId) {
    // intentionally not calling the constructor

    if (removedParents.size() > 0) {

        // create the graft.

        List<String> graftData = new ArrayList<>();

        graftData.add(newCommitId.getName());

        for (ObjectId parentId : newParents) {
            graftData.add(parentId.getName());
        }/* w  w w  .  j a  v  a2 s.  c om*/

        for (ObjectId parentId : removedParents) {
            graftData.add(parentId.getName());
        }

        pw.println(StringUtils.join(graftData, " "));

        /*
         * Make sure there is a branch or tag on the left side ref
         * 
         * and if not then put a branch to prevent the graph from being
         * gc'ed.
         * 
         * We use a branch and not a tag because branches are namespaced
         * but tags are global.
         */

        for (ObjectId leftCommitId : removedParents) {

            if (!commitToTagMap.containsKey(leftCommitId) && !commitToBranchMap.containsKey(leftCommitId)
                    && !leftSidePreventGCCommits.contains(leftCommitId)) {

                String preventGCBranchName = Constants.R_HEADS + "prevent_gc_" + counter;

                // put a branch
                deferCreate(preventGCBranchName, leftCommitId);

                counter++;

                leftSidePreventGCCommits.add(leftCommitId);

                leftRefsWriter.println(preventGCBranchName);

            }

        }

    }
}

---

From source file:org.kuali.student.git.importer.ApplyManualBranchCleanup.java

License:Educational Community License

/**
 * @param args/*  w  w w. j  a v  a2s .c o  m*/
 */
public static void main(String[] args) {

    if (args.length < 4 || args.length > 7) {
        usage();
    }

    File inputFile = new File(args[0]);

    if (!inputFile.exists())
        usage();

    boolean bare = false;

    if (args[2].trim().equals("1")) {
        bare = true;
    }

    String remoteName = args[3].trim();

    String refPrefix = Constants.R_HEADS;

    if (args.length == 5)
        refPrefix = args[4].trim();

    String userName = null;
    String password = null;

    if (args.length == 6)
        userName = args[5].trim();

    if (args.length == 7)
        password = args[6].trim();

    try {

        Repository repo = GitRepositoryUtils.buildFileRepository(new File(args[1]).getAbsoluteFile(), false,
                bare);

        Git git = new Git(repo);

        RevWalk rw = new RevWalk(repo);

        ObjectInserter objectInserter = repo.newObjectInserter();

        BufferedReader fileReader = new BufferedReader(new FileReader(inputFile));

        String line = fileReader.readLine();

        int lineNumber = 1;

        BatchRefUpdate batch = repo.getRefDatabase().newBatchUpdate();

        List<RefSpec> branchesToDelete = new ArrayList<>();

        while (line != null) {

            if (line.startsWith("#") || line.length() == 0) {
                // skip over comments and blank lines
                line = fileReader.readLine();
                lineNumber++;

                continue;
            }

            String parts[] = line.trim().split(":");

            String branchName = parts[0];

            Ref branchRef = repo.getRef(refPrefix + "/" + branchName);

            if (branchRef == null) {
                log.warn("line: {}, No branch matching {} exists, skipping.", lineNumber, branchName);

                line = fileReader.readLine();
                lineNumber++;

                continue;
            }

            String tagName = null;

            if (parts.length > 1)
                tagName = parts[1];

            if (tagName != null) {

                if (tagName.equals("keep")) {
                    log.info("keeping existing branch for {}", branchName);

                    line = fileReader.readLine();
                    lineNumber++;

                    continue;
                }

                if (tagName.equals("tag")) {

                    /*
                     * Shortcut to say make the tag start with the same name as the branch.
                     */
                    tagName = branchName;
                }
                // create a tag

                RevCommit commit = rw.parseCommit(branchRef.getObjectId());

                ObjectId tag = GitRefUtils.insertTag(tagName, commit, objectInserter);

                batch.addCommand(new ReceiveCommand(null, tag, Constants.R_TAGS + tagName, Type.CREATE));

                log.info("converting branch {} into a tag {}", branchName, tagName);

            }

            if (remoteName.equals("local")) {
                batch.addCommand(
                        new ReceiveCommand(branchRef.getObjectId(), null, branchRef.getName(), Type.DELETE));
            } else {

                // if the branch is remote then remember its name so we can batch delete after we have the full list.
                branchesToDelete.add(new RefSpec(":" + Constants.R_HEADS + branchName));
            }

            line = fileReader.readLine();
            lineNumber++;

        }

        fileReader.close();

        // run the batch update
        batch.execute(rw, new TextProgressMonitor());

        if (!remoteName.equals("local")) {
            // push the tag to the remote right now

            log.info("pushing tags to {}", remoteName);

            PushCommand pushCommand = git.push().setRemote(remoteName).setPushTags()
                    .setProgressMonitor(new TextProgressMonitor());

            if (userName != null)
                pushCommand.setCredentialsProvider(new UsernamePasswordCredentialsProvider(userName, password));

            Iterable<PushResult> results = pushCommand.call();

            for (PushResult pushResult : results) {

                if (!pushResult.equals(Result.NEW)) {
                    log.warn("failed to push tag " + pushResult.getMessages());
                }
            }

            // delete the branches from the remote

            log.info("pushing branch deletes to remote: {}", remoteName);

            results = git.push().setRemote(remoteName).setRefSpecs(branchesToDelete)
                    .setProgressMonitor(new TextProgressMonitor()).call();
        }

        objectInserter.release();

        rw.release();

    } catch (Exception e) {

        log.error("unexpected Exception ", e);
    }
}

---

From source file:org.kuali.student.git.importer.ConvertBuildTagBranchesToGitTags.java

License:Educational Community License

/**
 * @param args/*from   w  w w.j  av a  2  s.  c  o m*/
 */
public static void main(String[] args) {

    if (args.length < 3 || args.length > 6) {
        System.err.println("USAGE: <git repository> <bare> <ref mode> [<ref prefix> <username> <password>]");
        System.err.println("\t<bare> : 0 (false) or 1 (true)");
        System.err.println("\t<ref mode> : local or name of remote");
        System.err.println("\t<ref prefix> : refs/heads (default) or say refs/remotes/origin (test clone)");
        System.exit(-1);
    }

    boolean bare = false;

    if (args[1].trim().equals("1")) {
        bare = true;
    }

    String remoteName = args[2].trim();

    String refPrefix = Constants.R_HEADS;

    if (args.length == 4)
        refPrefix = args[3].trim();

    String userName = null;
    String password = null;

    if (args.length == 5)
        userName = args[4].trim();

    if (args.length == 6)
        password = args[5].trim();

    try {

        Repository repo = GitRepositoryUtils.buildFileRepository(new File(args[0]).getAbsoluteFile(), false,
                bare);

        Git git = new Git(repo);

        ObjectInserter objectInserter = repo.newObjectInserter();

        Collection<Ref> repositoryHeads = repo.getRefDatabase().getRefs(refPrefix).values();

        RevWalk rw = new RevWalk(repo);

        Map<String, ObjectId> tagNameToTagId = new HashMap<>();

        Map<String, Ref> tagNameToRef = new HashMap<>();

        for (Ref ref : repositoryHeads) {

            String branchName = ref.getName().substring(refPrefix.length() + 1);

            if (branchName.contains("tag") && branchName.contains("builds")) {

                String branchParts[] = branchName.split("_");

                int buildsIndex = ArrayUtils.indexOf(branchParts, "builds");

                String moduleName = StringUtils.join(branchParts, "_", buildsIndex + 1, branchParts.length);

                RevCommit commit = rw.parseCommit(ref.getObjectId());

                ObjectId tag = GitRefUtils.insertTag(moduleName, commit, objectInserter);

                tagNameToTagId.put(moduleName, tag);

                tagNameToRef.put(moduleName, ref);

            }

        }

        BatchRefUpdate batch = repo.getRefDatabase().newBatchUpdate();

        List<RefSpec> branchesToDelete = new ArrayList<>();

        for (Entry<String, ObjectId> entry : tagNameToTagId.entrySet()) {

            String tagName = entry.getKey();

            // create the reference to the tag object
            batch.addCommand(
                    new ReceiveCommand(null, entry.getValue(), Constants.R_TAGS + tagName, Type.CREATE));

            // delete the original branch object

            Ref branch = tagNameToRef.get(entry.getKey());

            if (remoteName.equals("local")) {

                batch.addCommand(new ReceiveCommand(branch.getObjectId(), null, branch.getName(), Type.DELETE));

            } else {
                String adjustedBranchName = branch.getName().substring(refPrefix.length() + 1);

                branchesToDelete.add(new RefSpec(":" + Constants.R_HEADS + adjustedBranchName));
            }

        }

        // create the tags
        batch.execute(rw, new TextProgressMonitor());

        if (!remoteName.equals("local")) {
            // push the tag to the remote right now
            PushCommand pushCommand = git.push().setRemote(remoteName).setPushTags()
                    .setProgressMonitor(new TextProgressMonitor());

            if (userName != null)
                pushCommand.setCredentialsProvider(new UsernamePasswordCredentialsProvider(userName, password));

            Iterable<PushResult> results = pushCommand.call();

            for (PushResult pushResult : results) {

                if (!pushResult.equals(Result.NEW)) {
                    log.warn("failed to push tag " + pushResult.getMessages());
                }
            }

            // delete the branches from the remote
            results = git.push().setRemote(remoteName).setRefSpecs(branchesToDelete)
                    .setProgressMonitor(new TextProgressMonitor()).call();

            log.info("");

        }

        //         Result result = GitRefUtils.createTagReference(repo, moduleName, tag);
        //         
        //         if (!result.equals(Result.NEW)) {
        //            log.warn("failed to create tag {} for branch {}", moduleName, branchName);
        //            continue;
        //         }
        //         
        //         if (deleteMode) {
        //         result = GitRefUtils.deleteRef(repo, ref);
        //   
        //         if (!result.equals(Result.NEW)) {
        //            log.warn("failed to delete branch {}", branchName);
        //            continue;
        //         }

        objectInserter.release();

        rw.release();

    } catch (Exception e) {

        log.error("unexpected Exception ", e);
    }
}

---

From source file:org.kuali.student.git.importer.ConvertOldBranchesToTagsMain.java

License:Educational Community License

/**
 * @param args//from   w ww .j a  v a2  s  . co m
 */
public static void main(String[] args) {

    if (args.length != 3 && args.length != 4) {
        System.err.println("USAGE: <git repository> <mode> <bare> [<ref prefix>]");
        System.err.println("\t<mode> : tag or delete");
        System.err.println("\t<bare> : 0 (false) or 1 (true)");
        System.err.println("\t<ref prefix> : refs/heads (default) or say refs/remotes/origin (test clone)");
        System.exit(-1);
    }

    boolean bare = false;

    if (args[2].trim().equals("1")) {
        bare = true;
    }

    boolean tagMode = false;

    boolean deleteMode = false;

    if (args[1].equals("tag"))
        tagMode = true;
    else if (args[1].equals("delete"))
        deleteMode = true;

    String refPrefix = Constants.R_HEADS;

    if (args.length == 4)
        refPrefix = args[3].trim();

    try {

        Repository repo = GitRepositoryUtils.buildFileRepository(new File(args[0]).getAbsoluteFile(), false,
                bare);

        Collection<Ref> repositoryHeads = repo.getRefDatabase().getRefs(refPrefix).values();

        RevWalk rw = new RevWalk(repo);

        Git git = new Git(repo);

        ObjectInserter objectInserter = repo.newObjectInserter();

        List<String> branchesToDelete = new ArrayList<>();

        for (Ref ref : repositoryHeads) {

            if (!ref.getName().contains("@"))
                continue; // we only want those with @ in the name

            if (deleteMode)
                branchesToDelete.add(ref.getName());

            if (!tagMode)
                continue;

            // else tag mode

            String simpleTagName = ref.getName().replaceFirst(refPrefix, "");

            RevCommit commit = rw.parseCommit(ref.getObjectId());

            ObjectId tagId = null;

            // tag this commit
            tagId = GitRefUtils.insertTag(simpleTagName, commit, objectInserter);

            if (tagId != null) {

                // update the tag reference
                // copied from JGit's TagCommand
                Result updateResult = GitRefUtils.createTagReference(repo, simpleTagName, tagId);

                if (updateResult != Result.NEW) {
                    log.warn("problem creating tag reference for " + simpleTagName + " result = "
                            + updateResult);
                }
            }

        }

        if (deleteMode) {

            for (String branch : branchesToDelete) {

                RefUpdate update = repo.updateRef(branch);

                update.setForceUpdate(true);

                Result result = update.delete(rw);

                if (result != Result.FORCED) {

                    log.warn("failed to delete the branch ref = " + branch);
                }

            }
        }

        rw.release();

        objectInserter.flush();
        objectInserter.release();

    } catch (Exception e) {

        log.error("unexpected Exception ", e);
    }
}

---

From source file:org.kuali.student.git.importer.FixImportRepo.java

License:Educational Community License

/**
 * @param args/*from  ww w.  j a v  a2s . c  o  m*/
 */
public static void main(final String[] args) {

    if (args.length != 2) {
        log.error("USAGE: <git repository> <reset branches to revision>");
        System.exit(-1);
    }

    try {

        File gitRepository = new File(args[0]).getAbsoluteFile();

        if (!gitRepository.getParentFile().exists())
            throw new FileNotFoundException(args[1] + "path not found");

        final Repository repo = GitRepositoryUtils.buildFileRepository(gitRepository, false);

        String revision = args[1];

        long longRevision = Long.parseLong(revision);

        SvnRevisionMapper mapper = new SvnRevisionMapper(repo);

        mapper.initialize();

        Map<String, Ref> allRefs = new HashMap<String, Ref>();

        Map<String, Ref> existingRefs = repo.getRefDatabase().getRefs(Constants.R_HEADS);

        allRefs.putAll(existingRefs);

        for (SvnRevisionMap entry : mapper.getRevisionHeads(longRevision)) {

            updateRef(repo, entry.getBranchName(), revision, ObjectId.fromString(entry.getCommitId()));

            allRefs.remove(entry.getBranchName().substring(Constants.R_HEADS.length()));
        }

        if (allRefs.size() > 0) {
            // delete all of the left over refs that weren't updated.
            for (Ref ref : allRefs.values()) {

                deleteRef(repo, ref.getName(), revision);

            }
        }

        mapper.truncateTo(longRevision);

        mapper.shutdown();

    } catch (Exception e) {
        log.error("Processing failed", e);
    }

}

---

From source file:org.kuali.student.git.importer.GitImporterParseOptions.java

License:Educational Community License

private void flushPendingBranchCommits() {

    try {//  w  w w  .j av  a2  s  .  c o m

        RevWalk rw = new RevWalk(repo);

        List<GitBranchData> externalsAwareOrdering = ExternalsUtils
                .computeExternalsAwareOrdering(knownBranchMap.values());

        for (GitBranchData data : externalsAwareOrdering) {

            String branchName = data.getBranchName();

            if (data.getExternals().size() > 0) {
                ObjectInserter objectInserter = repo.newObjectInserter();

                String fusionPluginDataString = ExternalModuleUtils.createFusionMavenPluginDataFileString(
                        currentRevision, repo, data.getExternals(), revisionMapper);

                ObjectId id = objectInserter.insert(Constants.OBJ_BLOB, fusionPluginDataString.getBytes());

                try {
                    data.addBlob(data.getBranchPath() + "/" + "fusion-maven-plugin.dat", id, blobLog);
                } catch (VetoBranchException e) {
                    // should never happen
                    log.error("failed to add fusion-maven-plugin.dat to the branch skipping. branchName = "
                            + data.getBranchName(), e);
                }

                objectInserter.flush();
                objectInserter.release();
            } else {
                // check for and remove if present.
                ObjectId blobId = data.findPath(repo, "fusion-maven-plugin.dat");

                if (blobId != null)
                    data.deletePath(data.getBranchPath() + "/" + "fusion-maven-plugin.dat", currentRevision);
            }

            Set<ObjectId> parentSet = new HashSet<ObjectId>();

            ObjectId parentId = data.getParentId();

            if (parentId != null)
                parentSet.add(parentId);

            parentSet.addAll(computeSvnMergeInfoParentIds(currentRevision, data));

            parentSet.addAll(data.getMergeParentIds());

            if (data.getBlobsAdded() == 0 && !data.isBlobsDeleted() && !data.isCreated()
                    && !data.isTreeDirty()) {

                // check the parentId is the same
                Ref existingRef = repo.getRef(Constants.R_HEADS + data.getBranchName());

                if (existingRef != null) {

                    if (parentSet.size() > 0 && parentSet.contains(existingRef.getObjectId())) {
                        /*
                         * Directory changes can cause a branch data object
                         * to be created but we really only want to save it
                         * if blob's have been added or deleted.
                         */
                        log.info("skipped commit on branch " + branchName + " at " + currentRevision
                                + " due to no blob changes present.");
                        continue;
                    }

                } else {
                    // existing Ref is null
                    if (parentSet.size() == 0) {
                        log.info("skipped commit on branch " + branchName + " at " + currentRevision
                                + " due to no blob changes present.");
                        continue;
                    }

                    // else fall through
                }

                // else fall through

            }

            // only flush if the branch has data to
            // commit for the current revision
            log.debug("branch = " + branchName + " has data to commit");

            // create the commit
            CommitBuilder commitBuilder = new CommitBuilder();

            ObjectInserter inserter = repo.newObjectInserter();

            // create the tree

            ObjectId treeId = data.buildTree(inserter);

            log.debug("create new tree id = " + treeId.name());

            commitBuilder.setTreeId(treeId);

            commitBuilder.setParentIds(Arrays.asList(parentSet.toArray(new ObjectId[] {})));

            commitBuilder.setAuthor(commitData.getPersonIdent());

            commitBuilder.setCommitter(commitData.getPersonIdent());

            if (printGitSvnIds) {
                StringBuilder commitMessageBuilder = new StringBuilder();

                commitMessageBuilder.append(commitData.getCommitMessage());

                appendGitSvnId(commitMessageBuilder, repositoryBaseUrl, data.getBranchPath(), currentRevision,
                        repositoryUUID);

                commitBuilder.setMessage(commitMessageBuilder.toString());
            } else {
                // just the commit message
                commitBuilder.setMessage(commitData.getCommitMessage());
            }

            ObjectId commitId = inserter.insert(commitBuilder);

            inserter.flush();

            inserter.release();

            // post commit update the branch reference.

            // create the branch in git

            String fullBranchNameReference = Constants.R_HEADS + data.getBranchName();

            if (fullBranchNameReference.length() >= GitBranchUtils.FILE_SYSTEM_NAME_LIMIT) {

                fullBranchNameReference = Constants.R_HEADS
                        + revisionMapper.storeLargeBranchName(fullBranchNameReference, currentRevision);
            }

            if (repo.getRefDatabase().isNameConflicting(fullBranchNameReference)) {
                log.warn(fullBranchNameReference + " is conflicting with an existing reference.");
            }

            Ref ref = GitRefUtils.createOrUpdateBranch(repo, fullBranchNameReference, commitId);

            ObjectId refObjectId = ref.getObjectId();

            log.info(String.format("updated %s to %s", fullBranchNameReference, commitId.name()));

            if (!commitId.equals(refObjectId)) {
                log.warn("failed to update ref for " + branchName);
            }

            List<BranchMergeInfo> accumulatedMergeData = data.getAccumulatedBranchMergeData();

            if (accumulatedMergeData.size() > 0)
                revisionMapper.createMergeData(currentRevision, data.getBranchPath(), accumulatedMergeData);

            repo.getRefDatabase().refresh();

        }

        Map<String, Ref> headRefs = repo.getRefDatabase().getRefs(Constants.R_HEADS);

        List<Ref> refs = new ArrayList<Ref>(headRefs.values());

        revisionMapper.createRevisionMap(currentRevision, refs);

        knownBranchMap.clear();

        rw.release();

    } catch (IOException e) {
        throw new RuntimeException("flushPendingBranchCommits failed on rev = " + currentRevision, e);
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• »