FeatureBranchOperation.java

package com.proalpha.pds.gitutils.mylyn;
 
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.egit.core.EclipseGitProgressTransformer;
import org.eclipse.egit.core.internal.job.RuleUtil;
import org.eclipse.egit.core.internal.util.ProjectUtil;
import org.eclipse.jgit.api.CheckoutResult;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Display;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.PaGit;
import com.proalpha.pds.gitutils.common.CheckoutOperation;
import com.proalpha.pds.gitutils.external.DbAndBinaryOperation;
import com.proalpha.pds.paconnector.Activator;
 
public class FeatureBranchOperation {
 
    private final Logger logger = LoggerFactory.getLogger(FeatureBranchOperation.class);
 
    private FeatureBranchSettings settings;
    private ReconcileActionSettings recoSettings;
 
    private IProgressMonitor monitor;
 
    private CheckoutOperation coOp;
 
    private DbAndBinaryOperation updateDbBinaryOp;
 
    public FeatureBranchOperation(FeatureBranchSettings settings) {
        this.settings = settings;
        this.recoSettings = new ReconcileActionSettings(this.settings.getCheckoutAction());
 
        PaGit.init(new Git(settings.getRepository()));
    }
 
    public FeatureBranchOperation(FeatureBranchSettings settings, ReconcileActionSettings recoSettings) {
        this.settings = settings;
        this.recoSettings = recoSettings;
        PaGit.init(new Git(settings.getRepository()));
    }
 
    public void execute() {
        Runnable r = new Runnable() {
 
            @Override
            public void run() {
                try {
                    SubMonitor subMonitor = SubMonitor.convert(monitor, "pA feature branch creation", 10);
                    PaGit.getInstance().setProgressMonitor(new EclipseGitProgressTransformer(subMonitor.newChild(1)));
 
                    coOp = new CheckoutOperation(settings.getRepository(), Constants.DEFAULT_REMOTE_NAME,
                            settings.getSourceBranch(), settings.getTargetBranch(), settings.isUpdateSourceBranch(),
                            settings.isUpdateTargetBranch());
                    coOp.setProgressMonitor(subMonitor);
                    coOp.run();
                    subMonitor.worked(1);
                    // only start an operation if the checkout-action is not "NONE"
                    if (!recoSettings.getPaUpdateStages().isEmpty()) {
                        performReconcileJob(settings.getRepository(), recoSettings, subMonitor);
                    }
                } catch (InvocationTargetException e) {
                    logger.error("An error {0} occured", e);
                }
 
            }
 
            public void performReconcileJob(Repository repository, ReconcileActionSettings recoSettings,
                    IProgressMonitor monitor) {
 
                // collect all affected projects which include the repository
                IProject[] projects = ProjectUtil.getProjects(repository);
                ArrayList<IProject> openedProjects = new ArrayList<>(Arrays.asList(projects));
                SubMonitor subMonitorArtifacts = SubMonitor.convert(monitor, "database reconcile and artifact update",
                        recoSettings.getPaUpdateStages().size());
 
                if (recoSettings.isLoadDf())
                    Activator.getDefault().getProjectManager().closeProjects(openedProjects, subMonitorArtifacts);
 
                updateDbBinaryOp = new DbAndBinaryOperation(repository, recoSettings);
                updateDbBinaryOp.setProgressMonitor(subMonitorArtifacts);
                updateDbBinaryOp.execute();
 
                try {
                    coOp = new CheckoutOperation(settings.getRepository(), Constants.DEFAULT_REMOTE_NAME,
                            settings.getSourceBranch(), settings.getTargetBranch(), settings.isUpdateSourceBranch(),
                            settings.isUpdateTargetBranch());
                    coOp.run();
                } catch (InvocationTargetException e) {
                    logger.error("An error {0} occured", e);
                }
 
                if (recoSettings.isLoadDf())
                    Activator.getDefault().getProjectManager().openProjects(openedProjects, subMonitorArtifacts);
            }
        };
        BusyIndicator.showWhile(Display.getCurrent(), r);
    }
 
    @SuppressWarnings("restriction")
    public ISchedulingRule getSchedulingRule() {
        if (settings != null)
            return RuleUtil.getRule(settings.getRepository());
        else
            return null;
    }
 
    public void setProgressMonitor(IProgressMonitor monitor) {
        this.monitor = monitor;
    }
 
    public List<ActionResult> getResult() {
 
        List<ActionResult> results = new ArrayList<>();
        if (updateDbBinaryOp != null)
            results.addAll(updateDbBinaryOp.getActionResults());
        if (coOp != null) {
            ActionResult checkoutResult = new ActionResult("checkout");
            if (coOp.getResult().getStatus() != CheckoutResult.Status.OK)
                checkoutResult.setStatus("FAIL");
            results.add(0, checkoutResult);
        }
 
        return results;
    }
 
    public FeatureBranchSettings getSettings() {
        return settings;
    }
 
    public void setSettings(FeatureBranchSettings settings) {
        this.settings = settings;
    }
}