Example usage for org.eclipse.jgit.api Git getRepository

List of usage examples for org.eclipse.jgit.api Git getRepository

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.api.*
  5. Git
  6. getRepository

Introduction

In this page you can find the example usage for org.eclipse.jgit.api Git getRepository.

Prototype

public Repository getRepository()

Source Link

Document

Get repository

Usage

From source file:org.craftercms.deployer.impl.processors.GitDiffProcessor.java

License:Open Source License

protected ChangeSet resolveChangeSetFromCommits(Git git, ObjectId fromCommitId, ObjectId toCommitId)
        throws DeployerException {
    String fromCommitIdStr = fromCommitId != null ? fromCommitId.name() : "{empty}";
    String toCommitIdStr = toCommitId != null ? toCommitId.name() : "{empty}";

    if (!Objects.equals(fromCommitId, toCommitId)) {
        logger.info("Calculating change set from commits: {} -> {}", fromCommitIdStr, toCommitIdStr);

        try (ObjectReader reader = git.getRepository().newObjectReader()) {
            AbstractTreeIterator fromTreeIter = getTreeIteratorForCommit(git, reader, fromCommitId);
            AbstractTreeIterator toTreeIter = getTreeIteratorForCommit(git, reader, toCommitId);

            List<DiffEntry> diffEntries = git.diff().setOldTree(fromTreeIter).setNewTree(toTreeIter).call();

            return processDiffEntries(diffEntries);
        } catch (IOException | GitAPIException e) {
            throw new DeployerException(
                    "Failed to calculate change set from commits: " + fromCommitIdStr + " -> " + toCommitIdStr,
                    e);//from   ww w .j  av  a  2s  .co m
        }
    } else {
        logger.info("Commits are the same. No change set will be calculated", fromCommitIdStr, toCommitIdStr);

        return null;
    }
}

From source file:org.craftercms.deployer.impl.processors.GitDiffProcessor.java

License:Open Source License

protected AbstractTreeIterator getTreeIteratorForCommit(Git git, ObjectReader reader, ObjectId commitId)
        throws IOException {
    if (commitId != null) {
        RevTree tree = getTreeForCommit(git.getRepository(), commitId);
        CanonicalTreeParser treeParser = new CanonicalTreeParser();

        treeParser.reset(reader, tree.getId());

        return treeParser;
    } else {/*from  w  ww .  j a  v  a 2 s.c  o m*/
        return new EmptyTreeIterator();
    }
}

From source file:org.craftercms.deployer.impl.processors.GitPullProcessor.java

License:Open Source License

protected ChangeSet pullChanges(Git git) {
    try {/* w ww .j av a  2s . c  o m*/
        logger.info("Executing git pull for repository {}...", localRepositoryFolder);

        ObjectId head = git.getRepository().resolve(Constants.HEAD);
        PullResult pullResult = git.pull().call();

        if (pullResult.isSuccessful()) {
            MergeResult mergeResult = pullResult.getMergeResult();
            switch (mergeResult.getMergeStatus()) {
            case FAST_FORWARD:
                logger.info("Changes successfully pulled from remote {} for repository {}. Processing them...",
                        remoteRepositoryUrl, localRepositoryFolder);

                return resolveChangeSetFromPull(git, head, mergeResult.getNewHead());
            case ALREADY_UP_TO_DATE:
                logger.info("Git repository {} up to date (no changes pulled from remote {})",
                        localRepositoryFolder, remoteRepositoryUrl);
                return new ChangeSetImpl();
            default:
                // Not supported merge results
                throw new DeploymentException("Received unsupported merge result after executing pull command: "
                        + mergeResult.getMergeStatus());
            }
        }
    } catch (Exception e) {
        throw new DeploymentException("Git pull for repository " + localRepositoryFolder + " failed", e);
    }

    return new ChangeSetImpl();
}

From source file:org.craftercms.deployer.impl.processors.GitPullProcessor.java

License:Open Source License

protected ChangeSet resolveChangeSetFromPull(Git git, ObjectId oldHead, ObjectId newHead)
        throws IOException, GitAPIException {
    List<String> createdFiles = new ArrayList<>();
    List<String> updatedFiles = new ArrayList<>();
    List<String> deletedFiles = new ArrayList<>();
    RevWalk revWalk = new RevWalk(git.getRepository());
    ObjectId oldHeadTree = revWalk.parseCommit(oldHead).getTree().getId();
    ObjectId newHeadTree = revWalk.parseCommit(newHead).getTree().getId();

    // prepare the two iterators to compute the diff between
    try (ObjectReader reader = git.getRepository().newObjectReader()) {
        CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
        CanonicalTreeParser newTreeIter = new CanonicalTreeParser();

        oldTreeIter.reset(reader, oldHeadTree);
        newTreeIter.reset(reader, newHeadTree);

        // finally get the list of changed files
        List<DiffEntry> diffs = git.diff().setNewTree(newTreeIter).setOldTree(oldTreeIter).call();
        for (DiffEntry entry : diffs) {
            switch (entry.getChangeType()) {
            case MODIFY:
                updatedFiles.add(entry.getNewPath());
                logger.debug("Updated file: {}", entry.getNewPath());
                break;
            case DELETE:
                deletedFiles.add(entry.getOldPath());
                logger.debug("Deleted file: {}", entry.getOldPath());
                break;
            case RENAME:
                deletedFiles.add(entry.getOldPath());
                createdFiles.add(entry.getNewPath());
                logger.debug("Renamed file: {} -> {}", entry.getOldPath(), entry.getNewPath());
                break;
            case COPY:
                createdFiles.add(entry.getNewPath());
                logger.debug("Copied file: {} -> {}", entry.getOldPath(), entry.getNewPath());
                break;
            default: // ADD
                createdFiles.add(entry.getNewPath());
                logger.debug("New file: {}", entry.getNewPath());
                break;
            }/*from  ww  w.ja v a 2  s  . co  m*/
        }
    }

    return new ChangeSetImpl(createdFiles, updatedFiles, deletedFiles);
}

From source file:org.craftercms.studio.impl.v1.deployment.EnvironmentStoreGitBranchDeployer.java

License:Open Source License

private void addWorkAreaRemote(String site, Repository envStoreRepo) {
    envStoreRepo.getRemoteName("work-area");
    Git git = new Git(envStoreRepo);
    StoredConfig config = git.getRepository().getConfig();
    Path siteRepoPath = Paths.get(rootPath, "sites", site, ".git");
    config.setString("remote", "work-area", "url", siteRepoPath.normalize().toAbsolutePath().toString());
    try {// ww  w. j ava 2  s  . c  o m
        config.save();
    } catch (IOException e) {
        logger.error("Error adding work area as remote for environment store.", e);
    }
}

From source file:org.curioswitch.gradle.plugins.ci.CurioGenericCiPlugin.java

License:Open Source License

private static Set<String> computeAffectedFilesForBranch(Git git, String branch, Project rootProject)
        throws IOException {
    String masterRemote = git.getRepository().getRemoteNames().contains("upstream") ? "upstream" : "origin";
    CanonicalTreeParser oldTreeParser = parserForBranch(git,
            git.getRepository().exactRef("refs/remotes/" + masterRemote + "/master"));
    CanonicalTreeParser newTreeParser = parserForBranch(git, git.getRepository().exactRef(Constants.HEAD));
    return computeAffectedFiles(git, oldTreeParser, newTreeParser, rootProject);
}

From source file:org.curioswitch.gradle.plugins.ci.CurioGenericCiPlugin.java

License:Open Source License

private static Set<String> computeAffectedFilesForMaster(Git git, Project rootProject) throws IOException {
    ObjectId oldTreeId = git.getRepository().resolve("HEAD^{tree}");
    ObjectId newTreeId = git.getRepository().resolve("HEAD^^{tree}");

    final CanonicalTreeParser oldTreeParser;
    final CanonicalTreeParser newTreeParser;
    try (ObjectReader reader = git.getRepository().newObjectReader()) {
        oldTreeParser = parser(reader, oldTreeId);
        newTreeParser = parser(reader, newTreeId);
    }//from   w  w w.  j  av a  2 s  .  c o m

    return computeAffectedFiles(git, oldTreeParser, newTreeParser, rootProject);
}

From source file:org.curioswitch.gradle.plugins.ci.CurioGenericCiPlugin.java

License:Open Source License

private static CanonicalTreeParser parserForBranch(Git git, Ref branch) throws IOException {
    try (RevWalk walk = new RevWalk(git.getRepository())) {
        RevCommit commit = walk.parseCommit(branch.getObjectId());
        RevTree tree = walk.parseTree(commit.getTree().getId());

        final CanonicalTreeParser parser;
        try (ObjectReader reader = git.getRepository().newObjectReader()) {
            parser = parser(reader, tree.getId());
        }//www  . jav  a 2 s . c  o m

        walk.dispose();

        return parser;
    }
}

From source file:org.dstadler.jgit.api.JGitPrintContent.java

License:BSD License

public static void main(String[] args) throws Exception {
    File gitWorkDir = new File("C:\\Users\\kishore\\git\\JavaRepos\\.git");
    Git git = Git.open(gitWorkDir);
    Repository repo = git.getRepository();

    ObjectId lastCommitId = repo.resolve(Constants.HEAD);

    RevWalk revWalk = new RevWalk(repo);
    RevCommit commit = revWalk.parseCommit(lastCommitId);

    RevTree tree = commit.getTree();/*from   w ww  .  java2  s.c o  m*/

    TreeWalk treeWalk = new TreeWalk(repo);
    treeWalk.addTree(tree);
    treeWalk.setRecursive(true);
    treeWalk.setFilter(PathFilter.ALL);
    if (!treeWalk.next()) {
        System.out.println("Nothing found!");
        return;
    }

    ObjectId objectId = treeWalk.getObjectId(0);
    System.err.println(treeWalk.getPathString());
    System.err.println(objectId.getName());

    ObjectLoader loader = repo.open(objectId);

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    loader.copyTo(out);
    System.out.println("file1.txt:\n" + out.toString());
}

From source file:org.eclipse.oomph.setup.git.impl.GitCloneTaskImpl.java

License:Open Source License

public boolean isNeeded(final SetupTaskContext context) throws Exception {
    if (StringUtil.isEmpty(getRemoteURI())) {
        return false;
    }/*from w w  w  .  ja v a 2  s  .  c o  m*/

    // If the EGit UI is available, this will contain the list of repositories that have been added to the repositories view.
    Set<String> repositories = null;

    // Force start egit to make the clone appears in the repositories view and so projects are connected by the egit team provider.
    try {
        Class<?> egitUIActivatorClass = CommonPlugin.loadClass("org.eclipse.egit.ui",
                "org.eclipse.egit.ui.Activator");
        Object egitUIActivator = ReflectUtil.invokeMethod("getDefault", egitUIActivatorClass);
        repositoryUtil = ReflectUtil.invokeMethod("getRepositoryUtil", egitUIActivator);

        @SuppressWarnings("unchecked")
        List<String> configuredRepositories = (List<String>) ReflectUtil
                .invokeMethod("getConfiguredRepositories", repositoryUtil);
        repositories = new HashSet<String>(configuredRepositories);
    } catch (Throwable ex) {
        // Ignore.
    }

    String location = getLocation();

    workDir = new File(location);
    if (!workDir.isDirectory()) {
        return true;
    }

    workDirExisted = true;

    boolean needsToBeAdded = repositories != null
            && !repositories.contains(new File(workDir, ".git").toString());
    if (workDir.list().length > 1) {
        // Even though cloning isn't needed, return true if the repository needs to be added to the repositories view.
        bypassCloning = true;
        return needsToBeAdded;
    }

    context.log("Opening Git clone " + workDir);

    try {
        Git git = Git.open(workDir);
        if (!hasWorkTree(git) || !hasReflog(git)) {
            FileUtil.rename(workDir);
            workDirExisted = false;
            return true;
        }

        Repository repository = git.getRepository();
        String checkoutBranch = getCheckoutBranch();
        String remoteName = getRemoteName();
        String remoteURI = getRemoteURI();
        String pushURI = getPushURI();
        configureRepository(context, repository, checkoutBranch, remoteName, remoteURI, pushURI,
                getConfigSections());

        hasCheckout = repository.getAllRefs().containsKey("refs/heads/" + checkoutBranch);
        if (!hasCheckout) {
            cachedGit = git;
            cachedRepository = repository;
            return true;
        }

        // Even though cloning isn't needed, return true if the repository needs to be added to the repositories view.
        bypassCloning = true;
        return needsToBeAdded;
    } catch (Throwable ex) {
        if (!workDirExisted) {
            FileUtil.delete(workDir, new NullProgressMonitor() {
                @Override
                public boolean isCanceled() {
                    return context.isCanceled();
                }
            });
        }

        throw new Exception(ex);
    }
}