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

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

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

Introduction

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

Prototype

@NonNull
public ObjectReader newObjectReader()

Source Link

Document

Create a new reader to read objects from #getObjectDatabase() .

Usage

From source file:org.eclipse.orion.server.gerritfs.GitDiff.java

License:Open Source License

private AbstractTreeIterator getTreeIterator(Repository db, String name) throws IOException {
    final ObjectId id = db.resolve(name);
    if (id == null)
        throw new IllegalArgumentException(name);
    final CanonicalTreeParser p = new CanonicalTreeParser();
    final ObjectReader or = db.newObjectReader();
    RevWalk rw = new RevWalk(db);
    try {/*from ww w  . j a  va2 s  .  c  o  m*/
        p.reset(or, rw.parseTree(id));
        return p;
    } finally {
        or.release();
        rw.release();
    }
}

From source file:org.gitective.core.TreeUtils.java

License:Open Source License

/**
 * Create a tree walk with all the trees from the given commit's parents.
 *
 * @param repository/*from  w ww. j  av a  2  s .  c o  m*/
 * @param commitId
 * @return tree walk
 */
public static TreeWalk withParents(final Repository repository, final AnyObjectId commitId) {
    if (repository == null)
        throw new IllegalArgumentException(Assert.formatNotNull("Repository"));
    if (commitId == null)
        throw new IllegalArgumentException(Assert.formatNotNull("Commit id"));

    final ObjectReader reader = repository.newObjectReader();
    final RevWalk walk = new RevWalk(reader);
    try {
        return withParents(reader, walk, walk.parseCommit(commitId));
    } catch (IOException e) {
        walk.release();
        throw new GitException(e, repository);
    }
}

From source file:org.gitective.core.TreeUtils.java

License:Open Source License

/**
 * Create a tree walk with all the trees from the given revision's commit
 * parents.//  w w  w.  j  a  v  a  2  s .  co  m
 *
 * @param repository
 * @param revision
 * @return tree walk
 */
public static TreeWalk withParents(final Repository repository, final String revision) {
    if (repository == null)
        throw new IllegalArgumentException(Assert.formatNotNull("Repository"));
    if (revision == null)
        throw new IllegalArgumentException(Assert.formatNotNull("Revision"));
    if (revision.length() == 0)
        throw new IllegalArgumentException(Assert.formatNotEmpty("Revision"));

    final ObjectId commit = CommitUtils.strictResolve(repository, revision);
    final ObjectReader reader = repository.newObjectReader();
    final RevWalk walk = new RevWalk(reader);
    try {
        return withParents(reader, walk, walk.parseCommit(commit));
    } catch (IOException e) {
        walk.release();
        throw new GitException(e, repository);
    }
}

From source file:org.gitistics.visitor.commit.TreeWalkVisitorRoot.java

License:Open Source License

public TreeWalkVisitorRoot(Repository repository) {
    this.repository = repository;
    this.reader = repository.newObjectReader();
}

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 {/*from   www. j a  va  2 s  .c o m*/
        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.jabylon.team.git.GitTeamProvider.java

License:Open Source License

private static AbstractTreeIterator prepareTreeParser(Repository repository, String ref)
        throws IOException, MissingObjectException, IncorrectObjectTypeException {
    // from the commit we can build the tree which allows us to construct
    // the TreeParser
    Ref head = repository.getRef(ref);
    RevWalk walk = new RevWalk(repository);
    RevCommit commit = walk.parseCommit(head.getObjectId());
    RevTree tree = walk.parseTree(commit.getTree().getId());

    CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
    ObjectReader oldReader = repository.newObjectReader();
    try {//from w  w w  .j  a  va  2  s. co m
        oldTreeParser.reset(oldReader, tree.getId());
    } finally {
        oldReader.release();
    }
    return oldTreeParser;
}

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

License:Apache License

public static List<DiffEntry> getDiff(final Repository repo, final ObjectId oldRef, final ObjectId newRef) {
    try {//from  w  ww .j ava2  s  .  co m
        ObjectReader reader = repo.newObjectReader();
        CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
        oldTreeIter.reset(reader, oldRef);
        CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
        newTreeIter.reset(reader, newRef);
        return new Git(repo).diff().setNewTree(newTreeIter).setOldTree(oldTreeIter)
                .setShowNameAndStatusOnly(true).call();
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

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

License:Educational Community License

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

    if (args.length != 6 && args.length != 7) {
        System.err.println(
                "USAGE: <git repository> <mode> <bare> <object id> <svn:externals containing file> <svn revision> [<ref prefix>]");
        System.err.println("\t<mode> : commit or branch");
        System.err.println("\t<bare> : 0 (false) or 1 (true)");
        System.err.println("\t<object id> : the sha1 of the commit or the name of the branch in branch mode");
        System.err.println(
                "\t<svn:externals file> : contains the content of the svn:externals property for the target");

        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 branchMode = false;
    boolean commitMode = false;

    if (args[1].equals("branch"))
        branchMode = true;
    else if (args[1].equals("commit"))
        commitMode = true;

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

    String svnExternalsDataFile = args[4].trim();

    Long svnRevision = Long.parseLong(args[5].trim());

    String refPrefix = Constants.R_HEADS;

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

    try {

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

        SvnRevisionMapper revisionMapper = new SvnRevisionMapper(repo);

        if (commitMode) {

            /*
             * 
             */

            List<ExternalModuleInfo> externals = ExternalModuleUtils
                    .extractExternalModuleInfoFromSvnExternalsInputStream(svnRevision,
                            "https://svn.kuali.org/repos/student", new FileInputStream(svnExternalsDataFile));

            /*
             * Take the existing content of the commit pointed at and then materialize the externals within it.
             */

            RevWalk rw = new RevWalk(repo);

            ObjectInserter inserter = repo.newObjectInserter();

            RevCommit commit = rw.parseCommit(ObjectId.fromString(reference));

            TreeWalk tw = new TreeWalk(repo);

            tw.setRecursive(false);

            while (tw.next()) {

                if (tw.getNameString().equals("fusion-maven-plugin.dat")) {
                    ObjectId blobId = tw.getObjectId(0);

                    ObjectLoader loader = repo.newObjectReader().open(blobId, Constants.OBJ_BLOB);

                    List<String> lines = IOUtils.readLines(loader.openStream());

                    // pull out and use the sha1's from the stream to fuse the externals.

                }
            }
            CommitBuilder commitBuilder = new CommitBuilder();

            ObjectReader or;
            commitBuilder.setTreeId(ExternalModuleUtils.createFusedTree(or = repo.newObjectReader(), inserter,
                    rw, commit, externals));

            List<ObjectId> parentIds = new LinkedList<>();

            for (int i = 0; i < commit.getParentCount(); i++) {

                RevCommit parent = commit.getParent(i);

                parentIds.add(parent.getId());

            }

            commitBuilder.setParentIds(parentIds);

            commitBuilder.setAuthor(commit.getAuthorIdent());

            commitBuilder.setCommitter(commit.getCommitterIdent());

            commitBuilder.setMessage(commit.getFullMessage());

            ObjectId commitId = inserter.insert(commitBuilder);

            log.info("new commit id = " + commitId);

            rw.release();

            inserter.release();

            or.release();
        }

    } catch (Exception e) {

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

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

License:Educational Community License

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

    if (args.length != 3 && args.length != 4) {
        System.err.println(
                "USAGE: <git repository> <bare: 0 or 1> <output file name>[<refs prefix: default to refs/heads >]");
        System.exit(-1);
    }

    String gitRepositoryPath = args[0];

    String bareString = args[1].trim();

    boolean bare = false;

    if (bareString.equals("1"))
        bare = true;

    String refPrefix = Constants.R_HEADS;

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

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

    try {

        PrintWriter outputWriter = new PrintWriter(outputFileName);
        Repository repo = GitRepositoryUtils.buildFileRepository(new File(gitRepositoryPath).getAbsoluteFile(),
                false, bare);

        Map<String, Ref> branchHeads = repo.getRefDatabase().getRefs(refPrefix);

        ObjectReader objectReader = repo.newObjectReader();

        RevWalk rw = new RevWalk(objectReader);

        TreeWalk tw = new TreeWalk(objectReader);

        tw.setRecursive(true);

        String header = String.format(
                "Branch Name :: Total Commits in Graph :: Total Blob Size in Bytes :: Total Blob Size in Mega Bytes :: Total Blob Size in Giga Bytes");

        System.out.println(header);

        outputWriter.println(header);

        for (Map.Entry<String, Ref> entry : branchHeads.entrySet()) {

            String branchName = entry.getKey();
            Ref branchRef = entry.getValue();

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

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

            RevWalk commitHistoryWalk = new RevWalk(objectReader);

            commitHistoryWalk.markStart(commit);

            processCommit(commit, tw, blobIds);

            int totalReachableCommits = 0;

            while ((commit = commitHistoryWalk.next()) != null) {

                processCommit(commit, tw, blobIds);

                totalReachableCommits++;
            }

            long totalSize = 0L;

            AsyncObjectSizeQueue<ObjectId> sq = objectReader.getObjectSize(blobIds, true);

            while (sq.next())
                totalSize += sq.getSize();

            BigDecimal totalCounter = new BigDecimal(totalSize);

            String output = String.format("%s::%d::%s::%s::%s", branchName, totalReachableCommits,
                    totalCounter.toString(), getMB(totalCounter).toString(), getGB(totalCounter).toString());

            System.out.println(output);
            outputWriter.println(output);

            commitHistoryWalk.release();

        }

        tw.release();
        rw.release();
        objectReader.release();

        outputWriter.close();

    } catch (Exception e) {

        log.error("unexpected exception", e);

    }

}

From source file:org.kuali.student.git.model.ExternalModuleUtils.java

License:Educational Community License

/**
 * Look at the given commit and if there is a fusion-maven-plugin.dat in the root of its tree then load and return the contents.
 * /*  w  ww  .j  av  a  2s.c o  m*/
 * @param commit
 * @return the ExternalsModuleInfo's found, an empty list if none are found.
 * @throws IOException 
 * @throws CorruptObjectException 
 * @throws IncorrectObjectTypeException 
 * @throws MissingObjectException 
 */
public static List<ExternalModuleInfo> findExternalModulesForCommit(Repository repo, RevCommit commit)
        throws MissingObjectException, IncorrectObjectTypeException, CorruptObjectException, IOException {

    List<ExternalModuleInfo> modules = new LinkedList<ExternalModuleInfo>();

    GitTreeProcessor treeProcessor = new GitTreeProcessor(repo);

    GitTreeNodeData tree = treeProcessor.extractExistingTreeData(commit.getTree().getId(), "");

    ObjectId fusionDataBlobId = tree.find(repo, "fusion-maven-plugin.dat");

    if (fusionDataBlobId == null)
        return modules;

    ObjectReader reader = repo.newObjectReader();

    modules = ExternalModuleUtils
            .extractFusionMavenPluginData(reader.open(fusionDataBlobId, Constants.OBJ_BLOB).openStream());

    reader.release();

    return modules;

}