DbAndBinaryOperation.java

package com.proalpha.pds.gitutils.external;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.ProcessBuilder.Redirect;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
 
import org.apache.commons.lang.StringUtils;
import org.eclipse.core.runtime.SubMonitor;
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.pds.gitutils.Activator;
import com.proalpha.pds.gitutils.mylyn.ActionResult;
import com.proalpha.pds.gitutils.mylyn.ReconcileActionSettings;
 
public class DbAndBinaryOperation {
 
    private final Logger logger = LoggerFactory.getLogger(DbAndBinaryOperation.class);
 
    private Repository repository;
    private ReconcileActionSettings recoActionSettings;
    private List<ActionResult> actionResults = new ArrayList<>();
    private SubMonitor monitor;
 
    public DbAndBinaryOperation(Repository repository, ReconcileActionSettings recoSettings) {
        this.repository = repository;
        this.recoActionSettings = recoSettings;
    }
 
    public void execute() {
        Runnable runnable = new Runnable() {
 
            @Override
            public void run() {
                ArrayList<String> stages = (ArrayList<String>) recoActionSettings.getPaUpdateStages();
                monitor.setWorkRemaining(stages.size());
                String gitDir = repository.getDirectory().getAbsolutePath();
                File parentDir = new File(gitDir.substring(0, gitDir.lastIndexOf(File.separator)));
 
                try {
                    for (String stage : stages) {
                        monitor.setTaskName("Running action: " + stage);
                        runPaUpdateStage(parentDir, stage, monitor.newChild(1));
                    }
                } catch (Exception e) {
                    runPaUpdateStage(parentDir, "restore_repository", monitor.newChild(1));
                } finally {
                    deleteReconcileFile(parentDir);
                }
            }
 
            private void deleteReconcileFile(File parentDir) {
                Path reconcileFile = Paths.get(parentDir.getAbsolutePath(), "reconcile");
                if (reconcileFile.toFile().exists()) {
                    try {
                        Files.delete(reconcileFile);
                    } catch (Exception e) {
                        logger.error("an error occured while deleting reconcilefile in {}", reconcileFile);
                    }
                }
            }
        };
 
        BusyIndicator.showWhile(Display.getCurrent(), runnable);
 
    }
 
    private void runPaUpdateStage(File parentDir, String stage, SubMonitor subMonitor) {
 
        Integer callExitValue;
        String errorMsg = "";
        ActionResult actionStageResult = new ActionResult(stage);
        ProcessBuilder builder = new ProcessBuilder();
 
        builder.command("python", "-u", "-m", "pa_installer.reconcile", "--stage", stage, "--topodir", parentDir.toString(), "--env",
                "dev");
        builder.directory(parentDir);
        builder.redirectErrorStream(true);
        builder.redirectInput(Redirect.PIPE);
        builder.redirectOutput(Redirect.PIPE);
 
        try {
            final Process p = builder.start();
 
            logger.info("Start reconcile action: Running '{}' in {}", builder.command(), parentDir);
            parseOutputStream(subMonitor, actionStageResult, p);
            subMonitor.worked(1);
 
            // Store the result of the call to display
            callExitValue = p.waitFor();
 
            if (callExitValue > 0) {
                parseErrorStream(actionStageResult, p);
                errorMsg = MessageFormat.format(
                        "Error while running stage {0} of python package pa_installer.reconcile with exitcode {1}", stage,
                        callExitValue);
                Activator.logToConsole(errorMsg);
                logError(errorMsg, actionStageResult);
            }
 
        } catch (IOException e) {
            callExitValue = 1;
            errorMsg = MessageFormat.format(
                    "Exception while running stage {0} of python package pa_installer.reconcile with exitcode {1} and {2}", stage,
                    callExitValue, e.getMessage());
            logError(errorMsg, actionStageResult);
        } catch (InterruptedException e) {
            errorMsg = MessageFormat.format("Error {0} occured", e.getMessage());
            logError(errorMsg, actionStageResult);
            Thread.currentThread().interrupt();
        } finally {
            subMonitor.done();
            actionResults.add(actionStageResult);
        }
    }
 
    private void logError(String errorMsg, ActionResult actionStageResult) {
        actionStageResult.addToLog(errorMsg);
        actionStageResult.setStatus("FAIL");
        logger.error(errorMsg);
    }
 
    public void parseErrorStream(ActionResult actionStageResult, final Process p) throws IOException {
        Reader rErr = new InputStreamReader(p.getErrorStream());
        try (BufferedReader inErr = new BufferedReader(rErr)) {
            String line;
            do {
                line = inErr.readLine();
                if (line != null) {
                    actionStageResult.addToLog(line);
                    Activator.logToConsole(line);
                }
            } while (line != null);
        }
    }
 
    public void parseOutputStream(SubMonitor subMonitor, ActionResult actionStageResult, final Process p)
            throws IOException {
        try (Reader rOut = new InputStreamReader(p.getInputStream()); BufferedReader inOut = new BufferedReader(rOut)) {
 
            String line;
            do {
                line = inOut.readLine();
                if (line != null) {
                    int indexOfFourthSpace = StringUtils.ordinalIndexOf(line, " ", 4);
                    if (indexOfFourthSpace > -1) {
                        subMonitor.setTaskName(line.substring(indexOfFourthSpace));
                    }
                    actionStageResult.addToLog(line);
                    Activator.logToConsole(line);
                }
            } while (line != null);
        }
    }
 
    public void setProgressMonitor(SubMonitor monitor) {
        this.monitor = monitor;
    }
 
    public List<ActionResult> getActionResults() {
        return actionResults;
    }
}