Example usage for org.eclipse.jgit.api MergeCommand include

List of usage examples for org.eclipse.jgit.api MergeCommand include

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.api.*
  5. MergeCommand
  6. include

Introduction

In this page you can find the example usage for org.eclipse.jgit.api MergeCommand include.

Prototype

public MergeCommand include(AnyObjectId aCommit)

Source Link

Document

Id of a commit which is to be merged with the current head

Usage

From source file:br.com.riselabs.cotonet.builder.NetworkBuilder.java

License:Open Source License

/**
 * Returns the conflicting files of the given scenario.
 * //w ww.ja  v a2  s  .  c  o m
 * @param scenario
 * @return
 * @throws CheckoutConflictException
 * @throws GitAPIException
 */
private List<File> getConflictingFiles(MergeScenario scenario)
        throws CheckoutConflictException, GitAPIException {
    Git git = Git.wrap(getProject().getRepository());
    // this is for the cases of restarting after exception in a conflict
    // scenario analysis
    try {
        git.reset().setRef(scenario.getLeft().getName()).setMode(ResetType.HARD).call();
    } catch (JGitInternalException e) {
        Logger.log(log, "[" + project.getName() + "] JGit Reset Command ended with exception."
                + " Trying external reset command.");
        ExternalGitCommand egit = new ExternalGitCommand();
        try {
            egit.setType(CommandType.RESET).setDirectory(project.getRepository().getDirectory().getParentFile())
                    .call();
        } catch (BlameException e1) {
            Logger.logStackTrace(log, e1);
            return null;
        }
    }

    CheckoutCommand ckoutCmd = git.checkout();
    ckoutCmd.setName(scenario.getLeft().getName());
    ckoutCmd.setStartPoint(scenario.getLeft());
    ckoutCmd.call();

    MergeCommand mergeCmd = git.merge();
    mergeCmd.setCommit(false);
    mergeCmd.setStrategy(MergeStrategy.RECURSIVE);
    mergeCmd.include(scenario.getRight());

    Set<String> conflictingPaths;
    try {
        // dealing with MissingObjectException
        MergeResult mResult = mergeCmd.call();
        // dealing with Ghosts conflicts
        conflictingPaths = mResult.getConflicts().keySet();
    } catch (NullPointerException | JGitInternalException e) {
        StringBuilder sb = new StringBuilder();
        sb.append("[" + project.getName() + ":" + project.getUrl() + "] " + "Skipping merge scenario due to '"
                + e.getMessage() + "'\n");
        sb.append("--> Exception: " + e.getClass());
        sb.append("--> Skipped scenario:\n");
        sb.append("::Base:" + scenario.getBase().getName() + "\n");
        sb.append("::Left:" + scenario.getLeft().getName() + "\n");
        sb.append("::Right:" + scenario.getRight().getName() + "\n");
        Logger.log(log, sb.toString());
        return null;
    }
    List<File> result = new ArrayList<File>();
    for (String path : conflictingPaths) {
        result.add(new File(getProject().getRepository().getDirectory().getParent(), path));
    }
    return result;
}

From source file:br.com.riselabs.cotonet.test.helpers.ConflictBasedRepositoryTestCase.java

License:Open Source License

public MergeResult runMerge(MergeScenario scenario) throws RefAlreadyExistsException, RefNotFoundException,
        InvalidRefNameException, CheckoutConflictException, GitAPIException {
    Git git = Git.wrap(db);/*from  ww  w.  j a v a2 s  .com*/
    CheckoutCommand ckoutCmd = git.checkout();
    ckoutCmd.setName(scenario.getLeft().getName());
    ckoutCmd.setStartPoint(scenario.getLeft());
    ckoutCmd.call();

    MergeCommand mergeCmd = git.merge();
    mergeCmd.setCommit(false);
    mergeCmd.include(scenario.getRight());
    return mergeCmd.call();
}

From source file:com.rimerosolutions.ant.git.tasks.MergeTask.java

License:Apache License

@Override
public void doExecute() {
    try {/*w w w.ja  va2  s .  c o  m*/
        MergeCommand mergeCommand = git.merge().setSquash(squash);
        mergeCommand.include(mergeCommand.getRepository().getRef(branchname));

        setupCredentials(mergeCommand);
        MergeResult mergeResult = mergeCommand.call();

        if (!mergeResult.getMergeStatus().isSuccessful()) {

            if (mergeResult.getFailingPaths() != null && mergeResult.getFailingPaths().size() > 0) {
                throw new BuildException(String.format("%s - Failing paths: %s", MESSAGE_MERGE_FAILED,
                        mergeResult.getFailingPaths()));
            }

            throw new BuildException(
                    String.format(MESSAGE_MERGE_FAILED_WITH_STATUS, mergeResult.getMergeStatus().name()));
        }
    } catch (Exception e) {
        throw new GitBuildException(String.format(MESSAGE_MERGE_FAILED_WITH_URI, getUri()), e);
    }
}

From source file:com.verigreen.jgit.JGitOperator.java

License:Apache License

public Pair<Boolean, String> merge(String branchToUpdate, String branchHead, boolean commit) {

    Pair<Boolean, String> ret = new Pair<>(false, "");
    MergeCommand command = _git.merge();
    try {//w ww.j  a  v  a2s .com
        String refName = !branchHead.contains(REFS_HEADS) ? REFS_REMOTES + branchHead : branchHead;
        command.include(_repo.getRef(refName));
        command.setCommit(commit);
        MergeResult mergeResult = command.call();
        ret = checkResult(branchToUpdate, branchHead, ret, mergeResult);
    } catch (Throwable e) {
        VerigreenLogger.get().log(getClass().getName(), RuntimeUtils.getCurrentMethodName(), String
                .format("Failed to update branch [%s] with parent branch [%s]", branchToUpdate, branchHead));
    }

    return ret;
}

From source file:net.mobid.codetraq.runnables.GitChecker.java

License:Open Source License

private void attachHead(Git g, String branch) {
    LogService.writeMessage("Trying to attach HEAD to " + g.getRepository().toString());
    try {/*from w w w.j a v a2s  .c  o m*/
        CheckoutCommand temp = g.checkout();
        temp.setCreateBranch(true);
        temp.setName("temp");
        Ref tRef = temp.call();
        CheckoutCommand b = g.checkout();
        b.setName(branch);
        b.setCreateBranch(true);
        b.call();
        MergeCommand merge = g.merge();
        merge.include(tRef);
        merge.call();
    } catch (Exception ex) {
        LogService.getLogger(GitChecker.class.getName()).log(Level.SEVERE, null, ex);
        LogService.writeLog(Level.SEVERE, ex);
    }
}

From source file:org.ajoberstar.gradle.git.tasks.GitMerge.java

License:Apache License

/**
 * Merges some changes with the current branch.
 *///  w ww  .ja  v a 2  s.  co  m
@TaskAction
public void merge() {
    MergeCommand cmd = getGit().merge();
    cmd.include(findRef());
    cmd.setStrategy(getMergeStrategy());
    try {
        cmd.call();
    } catch (CheckoutConflictException e) {
        throw new GradleException("The working tree changes conflict with the specified commit.", e);
    } catch (GitAPIException e) {
        throw new GradleException("Problem with merge.", e);
    }
    //TODO add progress monitor to log progress to Gradle status bar
}

From source file:org.codehaus.mojo.versions.BumpMojo.java

License:Apache License

void gitMergeNFF(String c, String m) throws MojoExecutionException {
    try {/*from  w w w.ja v  a  2 s  . c o m*/
        MergeCommand ff = git.merge();
        ff.setCommit(false);
        ff.setFastForward(FastForwardMode.NO_FF);
        ff.include(git.getRepository().getRef(m));
        MergeResult f = ff.call();
        if (!f.getMergeStatus().isSuccessful()) {
            throw new MojoExecutionException(f.getMergeStatus().toString());
        }
        git.commit().setAll(true).setMessage(c).call();
    } catch (GitAPIException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    } catch (IOException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }
}

From source file:org.fedoraproject.eclipse.packager.git.api.ConvertLocalToRemoteCommand.java

License:Open Source License

/**
 * Merges remote HEAD with local HEAD (uses the JGit API)
 *
 * @param monitor/*from  www.ja v  a 2 s  . co m*/
 * @throws LocalProjectConversionFailedException
 */
private void mergeLocalRemoteBranches(IProgressMonitor monitor) throws LocalProjectConversionFailedException {

    MergeCommand merge = git.merge();
    try {
        merge.include(git.getRepository().getRef(Constants.R_REMOTES + "origin/" + Constants.MASTER)); //$NON-NLS-1$
        if (monitor.isCanceled()) {
            throw new OperationCanceledException();
        }
        merge.call();
    } catch (Exception e) {
        throw new LocalProjectConversionFailedException(e.getCause().getMessage(), e);
    }
}

From source file:org.jabylon.team.git.GitTeamProvider.java

License:Open Source License

@Override
public Collection<PropertyFileDiff> update(ProjectVersion project, IProgressMonitor monitor)
        throws TeamProviderException {

    SubMonitor subMon = SubMonitor.convert(monitor, 100);
    List<PropertyFileDiff> updatedFiles = new ArrayList<PropertyFileDiff>();
    try {//  w  w w.  jav a 2 s.com
        Repository repository = createRepository(project);
        Git git = Git.wrap(repository);
        FetchCommand fetchCommand = git.fetch();
        URI uri = project.getParent().getRepositoryURI();
        if (uri != null)
            fetchCommand.setRemote(stripUserInfo(uri).toString());
        String refspecString = "refs/heads/{0}:refs/remotes/origin/{0}";
        refspecString = MessageFormat.format(refspecString, project.getName());
        RefSpec spec = new RefSpec(refspecString);
        fetchCommand.setRefSpecs(spec);
        subMon.subTask("Fetching from remote");
        if (!"https".equals(uri.scheme()) && !"http".equals(uri.scheme()))
            fetchCommand.setTransportConfigCallback(createTransportConfigCallback(project.getParent()));
        fetchCommand.setCredentialsProvider(createCredentialsProvider(project.getParent()));
        fetchCommand.setProgressMonitor(new ProgressMonitorWrapper(subMon.newChild(80)));
        fetchCommand.call();
        ObjectId remoteHead = repository.resolve("refs/remotes/origin/" + project.getName() + "^{tree}");

        DiffCommand diff = git.diff();
        subMon.subTask("Caculating Diff");
        diff.setProgressMonitor(new ProgressMonitorWrapper(subMon.newChild(20)));
        diff.setOldTree(new FileTreeIterator(repository));
        CanonicalTreeParser p = new CanonicalTreeParser();
        ObjectReader reader = repository.newObjectReader();
        try {
            p.reset(reader, remoteHead);
        } finally {
            reader.release();
        }
        diff.setNewTree(p);
        checkCanceled(subMon);
        List<DiffEntry> diffs = diff.call();
        for (DiffEntry diffEntry : diffs) {
            checkCanceled(subMon);
            updatedFiles.add(convertDiffEntry(diffEntry));
            LOGGER.trace(diffEntry.toString());
        }
        if (!updatedFiles.isEmpty()) {
            checkCanceled(subMon);
            //no more cancel after this point
            ObjectId lastCommitID = repository
                    .resolve("refs/remotes/origin/" + project.getName() + "^{commit}");
            LOGGER.info("Merging remote commit {} to {}/{}",
                    new Object[] { lastCommitID, project.getName(), project.getParent().getName() });
            //TODO: use rebase here?
            if (isRebase(project)) {
                RebaseCommand rebase = git.rebase();
                rebase.setUpstream("refs/remotes/origin/" + project.getName());
                RebaseResult result = rebase.call();
                if (result.getStatus().isSuccessful()) {
                    LOGGER.info("Rebase finished: {}", result.getStatus());
                } else {
                    LOGGER.error("Rebase of {} failed. Attempting abort", project.relativePath());
                    rebase = git.rebase();
                    rebase.setOperation(Operation.ABORT);
                    result = rebase.call();
                    LOGGER.error("Abort finished with {}", result.getStatus());
                }
            } else {
                MergeCommand merge = git.merge();
                merge.include(lastCommitID);
                MergeResult mergeResult = merge.call();

                LOGGER.info("Merge finished: {}", mergeResult.getMergeStatus());
            }
        } else
            LOGGER.info("Update finished successfully. Nothing to merge, already up to date");
    } catch (JGitInternalException e) {
        throw new TeamProviderException(e);
    } catch (InvalidRemoteException e) {
        throw new TeamProviderException(e);
    } catch (GitAPIException e) {
        throw new TeamProviderException(e);
    } catch (AmbiguousObjectException e) {
        throw new TeamProviderException(e);
    } catch (IOException e) {
        throw new TeamProviderException(e);
    } finally {
        monitor.done();
    }
    return updatedFiles;
}

From source file:org.springframework.cloud.config.server.environment.JGitEnvironmentRepository.java

License:Apache License

private MergeResult merge(Git git, String label) {
    try {/*  w w  w  . j  ava  2 s . c om*/
        MergeCommand merge = git.merge();
        merge.include(git.getRepository().getRef("origin/" + label));
        MergeResult result = merge.call();
        if (!result.getMergeStatus().isSuccessful()) {
            this.logger.warn("Merged from remote " + label + " with result " + result.getMergeStatus());
        }
        return result;
    } catch (Exception ex) {
        String message = "Could not merge remote for " + label + " remote: "
                + git.getRepository().getConfig().getString("remote", "origin", "url");
        warn(message, ex);
        return null;
    }
}