CherryPickJob.java

package com.proalpha.pds.gitutils.cherrypick;
 
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.text.MessageFormat;
 
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.egit.core.EclipseGitProgressTransformer;
import org.eclipse.egit.ui.JobFamilies;
import org.eclipse.egit.ui.internal.staging.StagingView;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jgit.api.CherryPickResult.CherryPickStatus;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.PaGit;
import com.proalpha.git.commands.PaIssueConveyanceCommand;
import com.proalpha.git.model.PaCherryPickResult;
import com.proalpha.git.util.PaBranchName;
import com.proalpha.git.util.PaCommitMsg;
import com.proalpha.git.util.PaRepository;
import com.proalpha.pds.gitutils.common.CheckoutOperation;
 
@SuppressWarnings("restriction")
public class CherryPickJob extends Job {
 
    private final Logger logger = LoggerFactory.getLogger(CherryPickJob.class);
 
    private int noOfCommits = 0;
 
    public CherryPickJob(int noOfCommits) {
        super(MessageFormat.format("Cherry picking {0} commits", noOfCommits));
 
        this.noOfCommits = noOfCommits;
    }
 
    @Override
    protected IStatus run(IProgressMonitor monitor) {
 
        PaIssueConveyanceCommand picCo = CherryPick.getInstance().getCherryPickCommand();
        CherryPickSettings cherryPickSettings = CherryPick.getInstance().getCherryPickSettings();
        PaCherryPickResult cpResult = null;
        CherryPickStatus cpStatus = null;
 
        final SubMonitor progress = SubMonitor.convert(monitor, "pA CherryPick", this.noOfCommits + 2);
        final CherryPickOperation cpOp = new CherryPickOperation(picCo);
 
        CheckoutOperation coOp;
        if (cherryPickSettings.getTargetBranchPoint().startsWith(Constants.DEFAULT_REMOTE_NAME))
            coOp = new CheckoutOperation(picCo.getRepository(), Constants.DEFAULT_REMOTE_NAME,
                    cherryPickSettings.getTargetBranchPoint(), PaBranchName.getShortBranchName(picCo.getTargetRef()),
                    cherryPickSettings.isUpdateTargetBranchPoint(), // Update source branch (this is the branch, where
                                                                    // the new branch is branched off
                    true /* Update target branch if it already exists */);
        else
            coOp = new CheckoutOperation(picCo.getRepository(), PaBranchName.getShortBranchName(picCo.getTargetRef()));
 
        try {
            // Ensure that branch is checked out
            progress.setTaskName("Creating the target branch");
            coOp.run();
            progress.worked(1);
 
            progress.setTaskName("Picking the commits");
            PaGit.getInstance()
                    .setProgressMonitor(new EclipseGitProgressTransformer(progress.newChild(this.noOfCommits)));
            cpOp.execute();
            CherryPick.getInstance().setCherryPickResult(cpOp.getOperationResult());
 
            cpResult = CherryPick.getInstance().getCherryPickResult();
            cpStatus = CherryPick.getInstance().getCherryPickResult().getStatus();
 
            if (cpStatus != CherryPickStatus.OK)
                setConflictMessage(cherryPickSettings, cpResult);
            else {
                try {
                    PaRepository.disconnectRemote('_' + cherryPickSettings.getSourceRepoString());
 
                } catch (IOException | GitAPIException e) {
                    logger.error("Exception while disconnecting remote {}", picCo.getSourceRef(), e);
                }
            }
 
            showResultDialog(monitor, picCo.getRepository(), cpResult);
        } catch (InvocationTargetException | GitAPIException e) {
            Throwable cause = (e.getCause() == null) ? e : e.getCause();
            String msg = cause.getMessage();
            // Display display = Display.getDefault();
            // Shell shell = Display.getDefault().getActiveShell(); --> throws "Invalid
            // thread access"
            Display.getDefault().asyncExec(() -> MessageDialog.openError(null, "Cherry pick failed", msg));
        } finally {
            // If an unexpected error occurred (there is no result) or
            // all is complete: forget the last pick to be able to run a new cherry pick
            // operation
            if (CherryPick.getInstance().getCherryPickResult() == null
                    || CherryPick.getInstance().getCherryPickResult() != null
                            && CherryPick.getInstance().getCherryPickResult().getStatus() == CherryPickStatus.OK)
                CherryPick.getInstance().reinitialize();
 
            monitor.done();
        }
        return Status.OK_STATUS;
    }
 
    @Override
    public boolean belongsTo(Object family) {
        if (JobFamilies.CHERRY_PICK.equals(family))
            return true;
        return super.belongsTo(family);
    }
 
    private void setConflictMessage(CherryPickSettings settings, PaCherryPickResult result) {
        PlatformUI.getWorkbench().getDisplay().asyncExec(() -> {
            StagingView view = (StagingView) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()
                    .findView(StagingView.VIEW_ID);
 
            logger.debug("Commit failed: Initialize the commit msg of the git staging view.");
            if (view != null) {
                String msg = PaCommitMsg.getCherryPickMsg(settings.getTargetIssue(),
                        result.getOpenPicks().get(0).getFullMessage(), result.getOpenPicks().get(0).getId().name());
                msg = msg + System.getProperty("line.separator");
                msg = msg + System.getProperty("line.separator");
                msg += "Conflict resolution: DO NOT EDIT THIS MESSAGE";
                view.setCommitMessage(msg);
                view.setFocus();
            }
        });
    }
 
    private void showResultDialog(IProgressMonitor monitor, Repository repository,
            PaCherryPickResult cherryPickResult) {
        PlatformUI.getWorkbench().getDisplay()
                .asyncExec(() -> new CherryPickResultDialog(
                        PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), monitor, cherryPickResult)
                                .open());
    }
 
}