Example usage for org.eclipse.jgit.lib RefUpdate update

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib RefUpdate update.

Prototype

public Result update() throws IOException 

Source Link

Document

Gracefully update the ref to the new value.

Usage

From source file:jetbrains.buildServer.buildTriggers.vcs.git.tests.CollectChangesTest.java

License:Apache License

@TestFor(issues = { "TW-36080", "TW-35700" })
@Test(dataProvider = "separateProcess,newConnectionForPrune")
public void branch_turned_into_dir(boolean fetchInSeparateProcess, boolean newConnectionForPrune)
        throws Exception {
    myConfig.setSeparateProcessForFetch(fetchInSeparateProcess).setNewConnectionForPrune(newConnectionForPrune);
    VcsRoot root = vcsRoot().withFetchUrl(myRepo).withBranch("master").build();
    RepositoryStateData s1 = createVersionState("refs/heads/master",
            map("refs/heads/master", "f3f826ce85d6dad25156b2d7550cedeb1a422f4c", "refs/heads/patch-tests",
                    "a894d7d58ffde625019a9ecf8267f5f1d1e5c341"));
    RepositoryStateData s2 = createVersionState("refs/heads/master",
            map("refs/heads/master", "3b9fbfbb43e7edfad018b482e15e7f93cca4e69f", "refs/heads/patch-tests",
                    "a894d7d58ffde625019a9ecf8267f5f1d1e5c341"));

    git().getCollectChangesPolicy().collectChanges(root, s1, s2, CheckoutRules.DEFAULT);

    //rename refs/heads/patch-tests to refs/heads/patch-tests/a and make it point to commit not yet fetched by TC, so the fetch is required
    Repository r = new RepositoryBuilder().setGitDir(myRepo).build();
    r.getRefDatabase().newRename("refs/heads/patch-tests", "refs/heads/patch-tests/a").rename();
    RefUpdate refUpdate = r.updateRef("refs/heads/patch-tests/a");
    refUpdate.setForceUpdate(true);//from  w  w  w .  j  ava 2s  .  com
    refUpdate.setNewObjectId(ObjectId.fromString("39679cc440c83671fbf6ad8083d92517f9602300"));
    refUpdate.update();

    RepositoryStateData s3 = createVersionState("refs/heads/master",
            map("refs/heads/master", "3b9fbfbb43e7edfad018b482e15e7f93cca4e69f", "refs/heads/patch-tests/a",
                    "39679cc440c83671fbf6ad8083d92517f9602300"));
    git().getCollectChangesPolicy().collectChanges(root, s2, s3, CheckoutRules.DEFAULT);
}

---

From source file:org.commonjava.gitwrap.BareGitRepository.java

License:Open Source License

public BareGitRepository createTag(final String tagSource, final String tagName, final String message,
        final boolean force) throws GitWrapException {
    try {/*from w w w. ja  v a  2s .  co m*/
        final ObjectId src = repository.resolve(tagSource);
        if (src == null) {
            throw new GitWrapException("Cannot resolve tag-source: %s", tagSource);
        }

        if (!force && repository.resolve(tagName) != null) {
            throw new GitWrapException("Tag: %s already exists!", tagName);
        }

        String dest = tagName;
        if (!dest.startsWith(Constants.R_TAGS)) {
            dest = Constants.R_TAGS + tagName;
        }

        final String tagShort = dest.substring(Constants.R_TAGS.length());

        final ObjectLoader sourceLoader = repository.open(src);
        final ObjectInserter inserter = repository.newObjectInserter();

        final TagBuilder tag = new TagBuilder();
        tag.setTag(tagShort);
        tag.setTagger(new PersonIdent(repository));
        tag.setObjectId(src, sourceLoader.getType());
        tag.setMessage(message);

        final ObjectId tagId = inserter.insert(tag);
        tag.setTagId(tagId);

        final String refName = Constants.R_TAGS + tag.getTag();

        final RefUpdate tagRef = repository.updateRef(refName);
        tagRef.setNewObjectId(tag.getTagId());
        tagRef.setForceUpdate(force);
        tagRef.setRefLogMessage("Tagging source: " + src.name() + " as " + tagName, false);

        final Result updateResult = tagRef.update();

        switch (updateResult) {
        case NEW:
        case FAST_FORWARD:
        case FORCED: {
            break;
        }
        case REJECTED: {
            throw new GitWrapException("Tag already exists: %s", tagName);
        }
        default: {
            throw new GitWrapException("Cannot lock tag: %s", tagName);
        }
        }
    } catch (final IOException e) {
        throw new GitWrapException("Failed to add tag: %s", e, e.getMessage());
    }

    return this;
}

---

From source file:org.commonjava.gitwrap.BareGitRepository.java

License:Open Source License

public BareGitRepository createBranch(final String source, final String name) throws GitWrapException {
    final String refName = (name.startsWith(Constants.R_HEADS) || name.startsWith(Constants.R_TAGS)) ? name
            : Constants.R_HEADS + name;/* w w w. ja va 2s .  com*/

    try {
        String src;
        final Ref from = repository.getRef(source);

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Creating branch: " + refName + " from: " + from);
        }

        final ObjectId startAt = repository.resolve(source + "^0");
        if (from != null) {
            src = from.getName();
        } else {
            src = startAt.name();
        }
        src = repository.shortenRefName(src);

        if (!Repository.isValidRefName(refName)) {
            throw new GitWrapException("Invalid branch name: " + refName);
        }

        if (repository.resolve(refName) != null) {
            throw new GitWrapException("Branch: " + refName + " already exists!");
        }

        final RefUpdate updateRef = repository.updateRef(refName);
        updateRef.setNewObjectId(startAt);
        updateRef.setRefLogMessage("branch: Created from " + source, false);
        final Result updateResult = updateRef.update();

        if (updateResult == Result.REJECTED) {
            throw new GitWrapException("Branch creation rejected for: %s", refName);
        }
    } catch (final IOException e) {
        throw new GitWrapException("Failed to create branch: %s from: %s.\nReason: %s", e, refName, source,
                e.getMessage());
    }

    return this;
}

---

From source file:org.eclipse.egit.core.op.TagOperation.java

License:Open Source License

private void updateRepo(ObjectId tagId) throws TeamException {
    String refName = Constants.R_TAGS + tag.getTag();

    try {/*from   w ww  .ja v  a2s  .c  o  m*/
        RefUpdate tagRef = repo.updateRef(refName);
        tagRef.setNewObjectId(tagId);

        tagRef.setForceUpdate(shouldMoveTag);
        Result updateResult = tagRef.update();

        if (updateResult != Result.NEW && updateResult != Result.FORCED)
            throw new TeamException(NLS.bind(CoreText.TagOperation_taggingFailure, tag.getTag(), updateResult));
    } catch (IOException e) {
        throw new TeamException(NLS.bind(CoreText.TagOperation_taggingFailure, tag.getTag(), e.getMessage()),
                e);
    }
}

---

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

License:Open Source License

/**
 * Set up repository1 with branch "master", create some project and commit
 * it; then clone into repository2; finally create a branch "test" on top of
 * "master" in repository2/*from   ww  w  .  j a  va2  s.  c  o  m*/
 *
 * @throws Exception
 */
@Before
public void setUp() throws Exception {

    workdir = testUtils.createTempDir("Repository1");
    workdir2 = testUtils.createTempDir("Repository2");

    repository1 = new TestRepository(new File(workdir, Constants.DOT_GIT));

    // now we create a project in repo1
    IProject project = testUtils.createProjectInLocalFileSystem(workdir, projectName);
    testUtils.addFileToProject(project, "folder1/file1.txt", "Hello world");

    repository1.connect(project);

    project.accept(new IResourceVisitor() {

        public boolean visit(IResource resource) throws CoreException {
            if (resource instanceof IFile) {
                try {
                    repository1.track(EFS.getStore(resource.getLocationURI()).toLocalFile(0, null));
                } catch (IOException e) {
                    throw new CoreException(Activator.error(e.getMessage(), e));
                }
            }
            return true;
        }
    });

    repository1.commit("Initial commit");

    // let's get rid of the project
    project.delete(false, false, null);

    // let's clone repository1 to repository2
    URIish uri = new URIish("file:///" + repository1.getRepository().getDirectory().toString());
    CloneOperation clop = new CloneOperation(uri, true, null, workdir2, "refs/heads/master", "origin", 0);
    clop.run(null);

    repository2 = new TestRepository(new FileRepository(new File(workdir2, Constants.DOT_GIT)));
    // we push to branch "test" of repository2
    RefUpdate createBranch = repository2.getRepository().updateRef("refs/heads/test");
    createBranch.setNewObjectId(repository2.getRepository().resolve("refs/heads/master"));
    createBranch.update();
}

---

From source file:org.eclipse.egit.core.test.TestRepository.java

License:Open Source License

/**
 * Creates a new branch/*  w ww. jav a  2 s  .  co m*/
 *
 * @param refName
 *            starting point for the new branch
 * @param newRefName
 * @throws IOException
 */
public void createBranch(String refName, String newRefName) throws IOException {
    RefUpdate updateRef;
    updateRef = repository.updateRef(newRefName);
    Ref startRef = repository.getRef(refName);
    ObjectId startAt = repository.resolve(refName);
    String startBranch;
    if (startRef != null)
        startBranch = refName;
    else
        startBranch = startAt.name();
    startBranch = Repository.shortenRefName(startBranch);
    updateRef.setNewObjectId(startAt);
    updateRef.setRefLogMessage("branch: Created from " + startBranch, false); //$NON-NLS-1$
    updateRef.update();
}

---

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);/*from  w w w . j a v  a2  s .c  o  m*/
    updateRef.setRefLogMessage("branch: Created from " + startBranch, false); //$NON-NLS-1$
    updateRef.update();
}

---

From source file:org.eclipse.emf.compare.diagram.papyrus.tests.egit.fixture.GitTestRepository.java

License:Open Source License

/**
 * Creates a new branch.//  w  ww .j  a v a2  s  . c  o  m
 * 
 * @param refName
 *            Starting point for the new branch.
 * @param newRefName
 *            Name of the new branch.
 */
public void createBranch(String refName, String newRefName) throws IOException {
    RefUpdate updateRef;
    updateRef = repository.updateRef(newRefName);
    Ref startRef = repository.getRef(refName);
    ObjectId startAt = repository.resolve(refName);
    String startBranch;
    if (startRef != null) {
        startBranch = refName;
    } else {
        startBranch = startAt.name();
    }
    startBranch = Repository.shortenRefName(startBranch);
    updateRef.setNewObjectId(startAt);
    updateRef.setRefLogMessage("branch: Created from " + startBranch, false);
    updateRef.update();
}

---

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 ww  .  j a v a 2 s.c  o m*/
    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.kie.commons.java.nio.fs.jgit.util.JGitUtil.java

License:Apache License

private static void updateHead(final Git git, final StringBuilder refLogMessage, final ObjectId newHeadId,
        final ObjectId oldHeadID) throws java.io.IOException, ConcurrentRefUpdateException {
    RefUpdate refUpdate = git.getRepository().updateRef(Constants.HEAD);
    refUpdate.setNewObjectId(newHeadId);
    refUpdate.setRefLogMessage(refLogMessage.toString(), false);
    refUpdate.setExpectedOldObjectId(oldHeadID);
    RefUpdate.Result rc = refUpdate.update();
    switch (rc) {
    case NEW:// w  w  w. j  ava  2  s  .  co m
    case FAST_FORWARD:
        return;
    case REJECTED:
    case LOCK_FAILURE:
        throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD, refUpdate.getRef(), rc);
    default:
        throw new JGitInternalException(MessageFormat.format(JGitText.get().updatingRefFailed, Constants.HEAD,
                newHeadId.toString(), rc));
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• »