DiffOperation.java

package com.proalpha.pds.gitutils.common;
 
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
 
import org.eclipse.jgit.api.DiffCommand;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.treewalk.filter.PathSuffixFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.PaGit;
 
public class DiffOperation extends CheckoutOperation {
 
    private DiffCommand cmd;
    private String dbCommit;
    private String artifactsCommit;
    private String targetRefName;
    private String newHead;
    private List<DiffEntry> pdiDiffList;
    private List<DiffEntry> stateInfoDiffList;
    private boolean isAssembliesXmlChanged;
 
    public DiffOperation(Repository repository, String remote, String sourceRef, String targetRef,
            boolean updateSourceRef, boolean updateTargetRef, String dbCommit, String artifactsCommit) {
        super(repository, remote, sourceRef, targetRef, updateSourceRef, updateTargetRef);
        this.dbCommit = dbCommit;
        this.artifactsCommit = artifactsCommit;
        this.isAssembliesXmlChanged = false;
    }
 
    public DiffOperation(Repository repository, String remote, String sourceRef, String targetRef,
            boolean updateSourceRef, boolean updateTargetRef, String dbCommit) {
        super(repository, remote, sourceRef, targetRef, updateSourceRef, updateTargetRef);
        this.dbCommit = dbCommit;
        this.artifactsCommit = dbCommit;
        this.isAssembliesXmlChanged = false;
    }
 
    public DiffOperation(Repository repository, String targetRef) {
        super(repository, targetRef);
    }
 
    private final Logger logger = LoggerFactory.getLogger(DiffOperation.class);
 
    @Override
    public void run() throws InvocationTargetException {
 
        if (logger.isInfoEnabled())
            logger.info("Get diff between selected commits");
 
        try {
 
            if (isLocalBranch(this.targetRef)) {
                targetRefName = this.targetRef;
                if (this.updateTargetRef)
                    tryFetch(this.targetRef);
            } else if (isServerBranch(this.targetRef)) {
                targetRefName = "remotes/" + this.remote + "/" + this.targetRef;
                if (this.updateTargetRef)
                    tryFetch(this.targetRef);
            } else {
                targetRefName = "remotes/" + this.remote + "/" + this.sourceRef;
                if (this.updateSourceRef)
                    tryFetch(this.sourceRef);
            }
 
            newHead = PaGit.getInstance().getGit().getRepository().findRef(targetRefName).getObjectId().getName();
 
            logger.info("New head is {}", newHead);
 
            this.pdiDiffList = executeCommand(this.dbCommit, targetRefName, ".pdi");
            this.stateInfoDiffList = executeCommand(this.artifactsCommit, targetRefName, ".state_info");
            this.isAssembliesXmlChanged = !executeCommand(this.artifactsCommit, targetRefName, "assemblies.xml").isEmpty();
 
        } catch (IOException e) {
            // TODO Auto-generated catch block
            logger.info(e.getMessage());
            e.printStackTrace();
        } catch (GitAPIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            PaGit.getInstance().close();
        }
 
    }
 
    private List<DiffEntry> executeCommand(String commitId, String refName, String pathFilter)
            throws GitAPIException, IOException {
 
        // A diff command needs two TreeIterators (old and new)
        AbstractTreeIterator oldTreeParser = prepareTreeParserWithCommitId(repository, commitId);
        AbstractTreeIterator newTreeParser = prepareTreeParserWithRef(repository, refName);
 
        // Prepare the command which gets called
        cmd = PaGit.getInstance().getGit().diff().setOldTree(oldTreeParser).setNewTree(newTreeParser)
                .setShowNameAndStatusOnly(true).setPathFilter(PathSuffixFilter.create(pathFilter));
 
        List<DiffEntry> diffList = cmd.call();
 
        // Debug output of results
        if (logger.isDebugEnabled()) {
            for (DiffEntry entry : diffList) {
                logger.debug("Entry: {}", entry);
            }
        }
        return diffList;
    }
 
    private static AbstractTreeIterator prepareTreeParserWithRef(Repository repository, String ref) throws IOException {
        ObjectId treeId = repository.resolve(ref + "^{tree}");
        try (RevWalk walk = new RevWalk(repository)) {
            RevTree tree = walk.parseTree(treeId);
 
            CanonicalTreeParser treeParser = new CanonicalTreeParser();
            try (ObjectReader reader = repository.newObjectReader()) {
                treeParser.reset(reader, tree.getId());
            }
 
            walk.dispose();
 
            return treeParser;
        }
    }
 
    private static AbstractTreeIterator prepareTreeParserWithCommitId(Repository repository, String objectId)
            throws IOException {
        // from the commit we can build the tree which allows us to construct the
        // TreeParser
 
        try (RevWalk walk = new RevWalk(repository)) {
            RevCommit commit = walk.parseCommit(ObjectId.fromString(objectId));
            RevTree tree = walk.parseTree(commit.getTree().getId());
 
            CanonicalTreeParser treeParser = new CanonicalTreeParser();
            try (ObjectReader reader = repository.newObjectReader()) {
                treeParser.reset(reader, tree.getId());
            }
 
            walk.dispose();
 
            return treeParser;
        }
    }
 
    public String getDbCommit() {
        return dbCommit;
    }
 
    public String getArtifactsCommit() {
        return artifactsCommit;
    }
 
    public String getTargetRefName() {
        return targetRefName;
    }
 
    public String getNewHead() {
        return newHead;
    }
 
    public List<DiffEntry> getPdiDiffList() {
        return pdiDiffList;
    }
 
    public List<DiffEntry> getStateInfoDiffList() {
        return stateInfoDiffList;
    }
    
    public boolean isAssembliesXmlChanged() {
        return isAssembliesXmlChanged;
    }
 
}