GatherCommitsOperation.java

package com.proalpha.pds.gitutils.cherrypick;
 
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
 
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.egit.core.internal.job.RuleUtil;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.revwalk.RevCommit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.PaGit;
import com.proalpha.git.util.PaIssueExplorer;
import com.proalpha.git.util.PaRepository;
import com.proalpha.pds.gitutils.Activator;
import com.proalpha.pds.gitutils.PreferencesConstants;
 
public class GatherCommitsOperation {
 
    private final Logger logger = LoggerFactory.getLogger(GatherCommitsOperation.class);
 
    private List<RevCommit> gatheredCommits;
    private String repository;
    private String branch;
    private String issue;
 
    public GatherCommitsOperation(String repository, String branch, String issue) {
        this.repository = repository;
        this.branch = branch;
        this.issue = issue;
    }
 
    public void run() throws InvocationTargetException {
 
        String repTemp = null;
 
        try {
            String remoteBranch = "";
            String gitServerPath = Activator.getDefault().getPreferenceStore()
                    .getString(PreferencesConstants.GIT_SERVER_URL);
            if (!gitServerPath.endsWith("/"))
                gitServerPath = gitServerPath + '/';
 
            remoteBranch = gitServerPath + "scm/" + this.repository;
 
            repTemp = PaRepository.connectRemoteBranch(remoteBranch, this.branch, '_' + this.repository);
 
            logger.debug("Remotebranch created as: {}", repTemp);
            List<RevCommit> commits = PaIssueExplorer.getCommitsOfIssue(repTemp, this.issue);
 
            if (logger.isDebugEnabled())
                for (RevCommit commit : commits) {
                    logger.debug("Found commit: {}, message: {}", commit.getName(), commit.getFullMessage());
                }
 
            this.gatheredCommits = commits;
 
        } catch (GitAPIException e) {
            throw new InvocationTargetException(e.getCause() != null ? e.getCause() : e);
        } catch (IOException e) {
            throw new InvocationTargetException(e);
        } finally {
            try {
                PaRepository.disconnectRemote('_' + this.repository);
            } catch (IOException | GitAPIException e) {
                logger.error("Exception while disconnecting remote {}", repTemp, e);
            }
        }
 
    }
 
    public List<RevCommit> getOperationResult() {
        return gatheredCommits;
    }
 
    @SuppressWarnings("restriction")
    public ISchedulingRule getSchedulingRule() {
        try {
            return RuleUtil.getRule(PaGit.getInstance().getGit().getRepository());
        } catch (NullPointerException npe) {
            return null;
        }
    }
}