Push with JGit

JGitPushTest.java

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS org.eclipse.jgit:org.eclipse.jgit:5.0.3.201809091024-r
//DEPS org.slf4j:slf4j-simple:1.7.36

import java.io.File;
import java.io.IOException;

import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.MergeCommand;
import org.eclipse.jgit.api.MergeResult;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Map;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;

import org.eclipse.jgit.transport.PushResult;
import org.eclipse.jgit.transport.RemoteRefUpdate;

public class JGitPushTest {
    public static String ROOT = System.getProperty("user.home") + "/tmp/jgit-tmp";

    public static void main(String... args) throws Exception {
        System.out.println("Start");
        Repository repository1 = openOrCreateNewRepository("repo1");
        try (Git git1 = new Git(repository1)) {
                // create some commit on master
                createCommit(repository1, git1, "file" + System.currentTimeMillis(), "content" + System.currentTimeMillis());
        }

        File localPath = new File(ROOT + "/repo2");
        if(!localPath.exists()) {
            try (Git result = Git.cloneRepository()
                    .setURI(ROOT + "/repo1")
                    .setDirectory(localPath)
                    .setProgressMonitor(new SimpleProgressMonitor())
                    .call()) {
                System.out.println("Having repository: " + result.getRepository().getDirectory());
            }
        }

        try (Git git1 = new Git(repository1)) {
                createCommit(repository1, git1, "other" + System.currentTimeMillis(), "content" + System.currentTimeMillis());
        }

        Repository repository2 = openOrCreateNewRepository("repo2");
        try (Git git2 = new Git(repository2)) {
            createCommit(repository2, git2, "test" + System.currentTimeMillis(), "content" + System.currentTimeMillis());

            Iterable<PushResult> results = git2.push().call();
            for (PushResult result : results) {
                for(RemoteRefUpdate update : result.getRemoteUpdates()) {
                    if(update.getStatus() != RemoteRefUpdate.Status.OK && update.getStatus() != RemoteRefUpdate.Status.UP_TO_DATE) {
                        String error = "Push failed: "+ update.getStatus();
                        throw new RuntimeException(error);
                    }
                }
            }
        }
    }

    public static Repository openOrCreateNewRepository(String name) throws IOException {
        File localPath = new File(ROOT + "/" + name);

        if(localPath.exists()) {
            FileRepositoryBuilder builder = new FileRepositoryBuilder();
            return builder
                    .readEnvironment() // scan environment GIT_* variables
                    .findGitDir(localPath) // scan up the file system tree
                    .build();
        }

        // create the directory
        Repository repository = FileRepositoryBuilder.create(new File(localPath, ".git"));
        repository.create();

        return repository;
    }

    private static void createCommit(Repository repository, Git git, String fileName, String content) throws IOException, GitAPIException {
        // create the file
        File myFile = new File(repository.getDirectory().getParent(), fileName);
        Files.write(myFile.toPath(), content.getBytes(StandardCharsets.UTF_8));

        // run the add
        git.add()
                .addFilepattern(fileName)
                .call();

        // and then commit the changes
        RevCommit revCommit = git.commit()
                .setMessage("Added " + fileName)
                .call();

        System.out.println("Committed file " + myFile + " as " + revCommit + " to repository at " + repository.getDirectory());
    }

    private static class SimpleProgressMonitor implements ProgressMonitor {
        @Override
        public void start(int totalTasks) {
            System.out.println("Starting work on " + totalTasks + " tasks");
        }

        @Override
        public void beginTask(String title, int totalWork) {
            System.out.println("Start " + title + ": " + totalWork);
        }

        @Override
        public void update(int completed) {
            System.out.print(completed + "-");
        }

        @Override
        public void endTask() {
            System.out.println("Done");
        }

        @Override
        public boolean isCancelled() {
            return false;
        }
    }
}

References:

• Inspiration for this gist: GitTeamProvider.java in the jabylon project.
• Stackoverflow: JGit push won't fail when push is impossible
• PR to update the JGit Cookbook: centic9/jgit-cookbook#90