Example usage for org.eclipse.jgit.lib Repository updateRef

List of usage examples for org.eclipse.jgit.lib Repository updateRef

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. Repository
  6. updateRef

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib Repository updateRef.

Prototype

@NonNull
public RefUpdate updateRef(String ref) throws IOException

Source Link

Document

Create a command to update, create or delete a ref in this repository.

Usage

From source file:org.eclipse.egit.core.test.op.T0001_ConnectProviderOperationTest.java

License:Open Source License

@Test
public void testNewUnsharedFile() throws CoreException, IOException, InterruptedException {

    project.createSourceFolder();//from   w w w  .  j  a  v a 2  s .c o  m
    IFile fileA = project.getProject().getFolder("src").getFile("A.java");
    String srcA = "class A {\n" + "}\n";
    fileA.create(new ByteArrayInputStream(srcA.getBytes()), false, null);

    File gitDir = new File(project.getProject().getWorkspace().getRoot().getRawLocation().toFile(),
            Constants.DOT_GIT);
    Repository thisGit = new Repository(gitDir);
    thisGit.create();
    Tree rootTree = new Tree(thisGit);
    Tree prjTree = rootTree.addTree(project.getProject().getName());
    Tree srcTree = prjTree.addTree("src");
    FileTreeEntry entryA = srcTree.addFile("A.java");
    ObjectWriter writer = new ObjectWriter(thisGit);
    entryA.setId(writer.writeBlob(fileA.getRawLocation().toFile()));
    srcTree.setId(writer.writeTree(srcTree));
    prjTree.setId(writer.writeTree(prjTree));
    rootTree.setId(writer.writeTree(rootTree));
    Commit commit = new Commit(thisGit);
    commit.setTree(rootTree);
    commit.setAuthor(new PersonIdent("J. Git", "j.git@egit.org", new Date(60876075600000L),
            TimeZone.getTimeZone("GMT+1")));
    commit.setCommitter(commit.getAuthor());
    commit.setMessage("testNewUnsharedFile\n\nJunit tests\n");
    ObjectId id = writer.writeCommit(commit);
    RefUpdate lck = thisGit.updateRef("refs/heads/master");
    assertNotNull("obtained lock", lck);
    lck.setNewObjectId(id);
    assertEquals(RefUpdate.Result.NEW, lck.forceUpdate());

    ConnectProviderOperation operation = new ConnectProviderOperation(project.getProject(), gitDir);
    operation.execute(null);

    final boolean f[] = new boolean[1];
    new Job("wait") {
        protected IStatus run(IProgressMonitor monitor) {

            System.out.println("MyJob");
            f[0] = true;
            return null;
        }

        {
            setRule(project.getProject());
            schedule();
        }
    };
    while (!f[0]) {
        System.out.println("Waiting");
        Thread.sleep(1000);
    }
    System.out.println("DONE");

    assertNotNull(RepositoryProvider.getProvider(project.getProject()));

}

From source file:org.eclipse.egit.ui.common.LocalRepositoryTestCase.java

License:Open Source License

protected static void createStableBranch(Repository myRepository) throws IOException {
    // let's create a stable branch temporarily so
    // that we push two branches to remote
    String newRefName = "refs/heads/stable";
    RefUpdate updateRef = myRepository.updateRef(newRefName);
    Ref sourceBranch = myRepository.getRef("refs/heads/master");
    ObjectId startAt = sourceBranch.getObjectId();
    String startBranch = Repository.shortenRefName(sourceBranch.getName());
    updateRef.setNewObjectId(startAt);// www .java2s  . com
    updateRef.setRefLogMessage("branch: Created from " + startBranch, false); //$NON-NLS-1$
    updateRef.update();
}

From source file:org.eclipse.egit.ui.view.repositories.GitRepositoriesViewTestBase.java

License:Open Source License

protected static File createRemoteRepository(File repositoryDir) throws Exception {
    Repository myRepository = org.eclipse.egit.core.Activator.getDefault().getRepositoryCache()
            .lookupRepository(repositoryDir);
    File gitDir = new File(getTestDirectory(), REPO2);
    Repository myRemoteRepository = lookupRepository(gitDir);
    myRemoteRepository.create();/* ww w .  j  av a2  s  .  c  o  m*/

    createStableBranch(myRepository);

    // now we configure the push destination
    myRepository.getConfig().setString("remote", "push", "pushurl",
            "file:///" + myRemoteRepository.getDirectory().getPath());
    myRepository.getConfig().setString("remote", "push", "push", "+refs/heads/*:refs/heads/*");
    // TODO Bug: for some reason, this seems to be required
    myRepository.getConfig().setString(ConfigConstants.CONFIG_CORE_SECTION, null,
            ConfigConstants.CONFIG_KEY_REPO_FORMAT_VERSION, "0");

    myRepository.getConfig().save();
    // and push
    PushConfiguredRemoteAction pa = new PushConfiguredRemoteAction(myRepository, "push");

    pa.run(null, false);
    TestUtil.joinJobs(JobFamilies.PUSH);
    try {
        // delete the stable branch again
        RefUpdate op = myRepository.updateRef("refs/heads/stable");
        op.setRefLogMessage("branch deleted", //$NON-NLS-1$
                false);
        // we set the force update in order
        // to avoid having this rejected
        // due to minor issues
        op.setForceUpdate(true);
        op.delete();
    } catch (IOException ioe) {
        throw new InvocationTargetException(ioe);
    }
    return myRemoteRepository.getDirectory();
}

From source file:org.gitective.tests.RepositoryUtilsTest.java

License:Open Source License

/**
 * Test one origin change// w  w  w . ja  va 2  s . co  m
 *
 *
 * @throws Exception
 */
@Test
public void oneOriginChange() throws Exception {
    RevCommit commit1 = add("test.txt", "content");
    File repo2 = initRepo();
    RevCommit commit2 = add(repo2, "test2.txt", "content2.txt");
    Repository repo = new FileRepository(testRepo);
    RefUpdate originMaster = repo
            .updateRef(Constants.R_REMOTES + Constants.DEFAULT_REMOTE_NAME + "/" + Constants.MASTER);
    originMaster.setNewObjectId(commit1);
    originMaster.forceUpdate();
    RemoteConfig config = new RemoteConfig(repo.getConfig(), Constants.DEFAULT_REMOTE_NAME);
    config.addURI(new URIish(repo2.toURI().toString()));
    config.update(repo.getConfig());
    Collection<RefDiff> diffs = RepositoryUtils.diffOriginRefs(repo);
    assertNotNull(diffs);
    assertFalse(diffs.isEmpty());
    assertNotNull(diffs.iterator().next().getLocal());
    assertNotNull(diffs.iterator().next().getRemote());
    assertEquals(commit1, diffs.iterator().next().getLocal().getObjectId());
    assertEquals(commit2, diffs.iterator().next().getRemote().getObjectId());
}

From source file:org.kie.commons.java.nio.fs.jgit.util.JGitUtil.java

License:Apache License

public static MergeResult mergeBranches(final Git git, final String source, final String target)
        throws Exception {

    final Repository repo = git.getRepository();
    final MergeStrategy mergeStrategy = MergeStrategy.RESOLVE;
    final List<Ref> commits = new LinkedList<Ref>();
    final boolean squash = false;

    RevWalk revWalk = null;/*  w  w w  . j a v a  2  s .  com*/
    DirCacheCheckout dco = null;
    try {
        Ref head = repo.getRef(Constants.HEAD);
        if (head == null) {
            throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
        }
        final StringBuilder refLogMessage = new StringBuilder("merge ");

        // Check for FAST_FORWARD, ALREADY_UP_TO_DATE
        revWalk = new RevWalk(repo);

        // we know for now there is only one commit
        Ref ref = commits.get(0);

        refLogMessage.append(ref.getName());

        // handle annotated tags
        ObjectId objectId = ref.getPeeledObjectId();
        if (objectId == null) {
            objectId = ref.getObjectId();
        }

        final RevCommit srcCommit = revWalk.lookupCommit(objectId);

        ObjectId headId = head.getObjectId();
        if (headId == null) {
            revWalk.parseHeaders(srcCommit);
            dco = new DirCacheCheckout(repo, repo.lockDirCache(), srcCommit.getTree());
            dco.setFailOnConflict(true);
            dco.checkout();
            RefUpdate refUpdate = repo.updateRef(head.getTarget().getName());
            refUpdate.setNewObjectId(objectId);
            refUpdate.setExpectedOldObjectId(null);
            refUpdate.setRefLogMessage("initial pull", false);
            if (refUpdate.update() != RefUpdate.Result.NEW) {
                throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
            }

            return new MergeResult(srcCommit, srcCommit, new ObjectId[] { null, srcCommit },
                    MergeStatus.FAST_FORWARD, mergeStrategy, null, null);
        }

        final RevCommit headCommit = revWalk.lookupCommit(headId);

        if (revWalk.isMergedInto(srcCommit, headCommit)) {
            return new MergeResult(headCommit, srcCommit, new ObjectId[] { headCommit, srcCommit },
                    ALREADY_UP_TO_DATE, mergeStrategy, null, null);
        } else if (revWalk.isMergedInto(headCommit, srcCommit)) {
            // FAST_FORWARD detected: skip doing a real merge but only
            // update HEAD
            refLogMessage.append(": " + FAST_FORWARD);
            dco = new DirCacheCheckout(repo, headCommit.getTree(), repo.lockDirCache(), srcCommit.getTree());
            dco.setFailOnConflict(true);
            dco.checkout();
            String msg = null;
            ObjectId newHead, base = null;
            final MergeStatus mergeStatus;
            if (!squash) {
                updateHead(git, refLogMessage, srcCommit, headId);
                newHead = base = srcCommit;
                mergeStatus = FAST_FORWARD;
            } else {
                msg = JGitText.get().squashCommitNotUpdatingHEAD;
                newHead = base = headId;
                mergeStatus = FAST_FORWARD_SQUASHED;
                final List<RevCommit> squashedCommits = RevWalkUtils.find(revWalk, srcCommit, headCommit);
                final String squashMessage = new SquashMessageFormatter().format(squashedCommits, head);
                repo.writeSquashCommitMsg(squashMessage);
            }
            return new MergeResult(newHead, base, new ObjectId[] { headCommit, srcCommit }, mergeStatus,
                    mergeStrategy, null, msg);
        } else {
            String mergeMessage = "";
            if (!squash) {
                mergeMessage = new MergeMessageFormatter().format(commits, head);
                repo.writeMergeCommitMsg(mergeMessage);
                repo.writeMergeHeads(Arrays.asList(ref.getObjectId()));
            } else {
                final List<RevCommit> squashedCommits = RevWalkUtils.find(revWalk, srcCommit, headCommit);
                final String squashMessage = new SquashMessageFormatter().format(squashedCommits, head);
                repo.writeSquashCommitMsg(squashMessage);
            }
            boolean noProblems;
            final Merger merger = mergeStrategy.newMerger(repo);
            final Map<String, org.eclipse.jgit.merge.MergeResult<?>> lowLevelResults;
            final Map<String, ResolveMerger.MergeFailureReason> failingPaths;
            final List<String> unmergedPaths;

            if (merger instanceof ResolveMerger) {
                ResolveMerger resolveMerger = (ResolveMerger) merger;
                resolveMerger.setCommitNames(new String[] { "BASE", "HEAD", ref.getName() });
                resolveMerger.setWorkingTreeIterator(new FileTreeIterator(repo));
                noProblems = merger.merge(headCommit, srcCommit);
                lowLevelResults = resolveMerger.getMergeResults();
                failingPaths = resolveMerger.getFailingPaths();
                unmergedPaths = resolveMerger.getUnmergedPaths();
            } else {
                noProblems = merger.merge(headCommit, srcCommit);
                lowLevelResults = emptyMap();
                failingPaths = emptyMap();
                unmergedPaths = emptyList();
            }

            refLogMessage.append(": Merge made by ");
            refLogMessage.append(mergeStrategy.getName());
            refLogMessage.append('.');
            if (noProblems) {
                dco = new DirCacheCheckout(repo, headCommit.getTree(), repo.lockDirCache(),
                        merger.getResultTreeId());
                dco.setFailOnConflict(true);
                dco.checkout();

                String msg = null;
                RevCommit newHead = null;
                MergeStatus mergeStatus = null;
                if (!squash) {
                    newHead = new Git(repo).commit().setReflogComment(refLogMessage.toString()).call();
                    mergeStatus = MERGED;
                } else {
                    msg = JGitText.get().squashCommitNotUpdatingHEAD;
                    newHead = headCommit;
                    mergeStatus = MERGED_SQUASHED;
                }
                return new MergeResult(newHead.getId(), null,
                        new ObjectId[] { headCommit.getId(), srcCommit.getId() }, mergeStatus, mergeStrategy,
                        null, msg);
            } else {
                if (failingPaths != null && !failingPaths.isEmpty()) {
                    repo.writeMergeCommitMsg(null);
                    repo.writeMergeHeads(null);
                    return new MergeResult(null, merger.getBaseCommit(0, 1),
                            new ObjectId[] { headCommit.getId(), srcCommit.getId() }, FAILED, mergeStrategy,
                            lowLevelResults, failingPaths, null);
                } else {
                    final String mergeMessageWithConflicts = new MergeMessageFormatter()
                            .formatWithConflicts(mergeMessage, unmergedPaths);
                    repo.writeMergeCommitMsg(mergeMessageWithConflicts);
                    return new MergeResult(null, merger.getBaseCommit(0, 1),
                            new ObjectId[] { headCommit.getId(), srcCommit.getId() }, CONFLICTING,
                            mergeStrategy, lowLevelResults, null);
                }
            }
        }
    } catch (org.eclipse.jgit.errors.CheckoutConflictException e) {
        final List<String> conflicts = (dco == null) ? Collections.<String>emptyList() : dco.getConflicts();
        throw new CheckoutConflictException(conflicts, e);
    } catch (java.io.IOException e) {
        throw new JGitInternalException(
                MessageFormat.format(JGitText.get().exceptionCaughtDuringExecutionOfMergeCommand, e), e);
    } finally {
        if (revWalk != null) {
            revWalk.release();
        }
    }
}

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

License:Educational Community License

/**
 * @param args/* w w w. jav  a  2 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.model.ref.utils.GitRefUtils.java

License:Educational Community License

public static Ref createBranch(Repository repo, String absoluteBranchName, ObjectId commitId,
        boolean allowUpdate) throws BranchRefExistsException, IOException {

    if (!allowUpdate && repo.getRef(absoluteBranchName) != null)
        throw new BranchRefExistsException(absoluteBranchName + "already exists");

    RefUpdate update = repo.updateRef(absoluteBranchName);

    update.setNewObjectId(commitId);//from   ww  w.  j  av a  2s. c om
    update.setRefLogMessage("created new branch " + absoluteBranchName, true);

    Result result = update.forceUpdate();

    if (result.equals(Result.LOCK_FAILURE)) {
        log.warn("lockfailure updating " + absoluteBranchName + " to commitId = " + commitId);
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            //fall through
        }
        return createBranch(repo, absoluteBranchName, commitId, allowUpdate);
    }

    if (result == null || !(result.equals(Result.NEW) || result.equals(Result.FORCED)
            || result.equals(Result.FAST_FORWARD))) {
        throw new RuntimeException("failed to create new branch: " + absoluteBranchName);
    }

    Ref ref = repo.getRef(absoluteBranchName);

    return ref;
}

From source file:org.kuali.student.git.model.ref.utils.GitRefUtils.java

License:Educational Community License

public static Result createTagReference(Repository repo, String simpleTagName, ObjectId tagId)
        throws IOException {

    String refName = Constants.R_TAGS + simpleTagName;
    RefUpdate tagRef = repo.updateRef(refName);
    tagRef.setNewObjectId(tagId);//from  w  ww  . j  av a  2  s .co m
    tagRef.setForceUpdate(true);
    tagRef.setRefLogMessage("tagged " + simpleTagName, false);
    Result updateResult = tagRef.forceUpdate();

    return updateResult;

}

From source file:org.moxie.utils.JGitUtils.java

License:Apache License

/**
 * Create an orphaned branch in a repository.
 * /*w  w  w  . jav a 2  s .com*/
 * @param repository
 * @param branchName
 * @param author
 *            if unspecified, Moxie will be the author of this new branch
 * @return true if successful
 */
public static boolean createOrphanBranch(Repository repository, String branchName, PersonIdent author) {
    boolean success = false;
    String message = "Created branch " + branchName;
    if (author == null) {
        author = new PersonIdent("Moxie", "moxie@localhost");
    }
    try {
        ObjectInserter odi = repository.newObjectInserter();
        try {
            // Create a blob object to insert into a tree
            ObjectId blobId = odi.insert(Constants.OBJ_BLOB, message.getBytes(Constants.CHARACTER_ENCODING));

            // Create a tree object to reference from a commit
            TreeFormatter tree = new TreeFormatter();
            tree.append("NEWBRANCH", FileMode.REGULAR_FILE, blobId);
            ObjectId treeId = odi.insert(tree);

            // Create a commit object
            CommitBuilder commit = new CommitBuilder();
            commit.setAuthor(author);
            commit.setCommitter(author);
            commit.setEncoding(Constants.CHARACTER_ENCODING);
            commit.setMessage(message);
            commit.setTreeId(treeId);

            // Insert the commit into the repository
            ObjectId commitId = odi.insert(commit);
            odi.flush();

            RevWalk revWalk = new RevWalk(repository);
            try {
                RevCommit revCommit = revWalk.parseCommit(commitId);
                if (!branchName.startsWith("refs/")) {
                    branchName = "refs/heads/" + branchName;
                }
                RefUpdate ru = repository.updateRef(branchName);
                ru.setNewObjectId(commitId);
                ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
                Result rc = ru.forceUpdate();
                switch (rc) {
                case NEW:
                case FORCED:
                case FAST_FORWARD:
                    success = true;
                    break;
                default:
                    success = false;
                }
            } finally {
                revWalk.release();
            }
        } finally {
            odi.release();
        }
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return success;
}

From source file:org.moxie.utils.JGitUtils.java

License:Apache License

public static void updateGhPages(File repositoryFolder, File sourceFolder, boolean obliterate) {
    String ghpages = "refs/heads/gh-pages";
    try {// ww w .j  a v a2  s .co m
        File gitDir = FileKey.resolve(repositoryFolder, FS.DETECTED);
        Repository repository = new FileRepository(gitDir);

        ObjectId objectId = repository.resolve(ghpages);
        if (objectId == null) {
            JGitUtils.createOrphanBranch(repository, "gh-pages", null);
        }

        System.out.println("Updating gh-pages branch...");
        ObjectId headId = repository.resolve(ghpages + "^{commit}");
        ObjectInserter odi = repository.newObjectInserter();
        try {
            // Create the in-memory index of the new/updated issue.
            DirCache index = createIndex(repository, headId, sourceFolder, obliterate);
            ObjectId indexTreeId = index.writeTree(odi);

            // Create a commit object
            PersonIdent author = new PersonIdent("Moxie", "moxie@localhost");
            CommitBuilder commit = new CommitBuilder();
            commit.setAuthor(author);
            commit.setCommitter(author);
            commit.setEncoding(Constants.CHARACTER_ENCODING);
            commit.setMessage("updated pages");
            commit.setParentId(headId);
            commit.setTreeId(indexTreeId);

            // Insert the commit into the repository
            ObjectId commitId = odi.insert(commit);
            odi.flush();

            RevWalk revWalk = new RevWalk(repository);
            try {
                RevCommit revCommit = revWalk.parseCommit(commitId);
                RefUpdate ru = repository.updateRef(ghpages);
                ru.setNewObjectId(commitId);
                ru.setExpectedOldObjectId(headId);
                ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
                Result rc = ru.forceUpdate();
                switch (rc) {
                case NEW:
                case FORCED:
                case FAST_FORWARD:
                    break;
                case REJECTED:
                case LOCK_FAILURE:
                    throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, ru.getRef(), rc);
                default:
                    throw new JGitInternalException(MessageFormat.format(JGitText.get().updatingRefFailed,
                            ghpages, commitId.toString(), rc));
                }
            } finally {
                revWalk.release();
            }
        } finally {
            odi.release();
        }
        System.out.println("gh-pages updated.");
    } catch (Throwable t) {
        t.printStackTrace();
    }
}