CompileJob.java

package com.proalpha.pds.gitutils.checks;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.ProcessBuilder.Redirect;
import java.nio.file.Files;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
 
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
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.PreferencesConstants;
import com.proalpha.pds.paconnector.PaProject;
 
public class CompileJob extends Job {
    private static final String LAST_PROCEDURE_ENV_NAME = "LASTPROCEDURE";
    private static final String COMPPROC_ENV_NAME = "COMPPROC";
    private Integer maxFileCount = 0;
    private Logger logger;
    private RepositoryTools repositoryTools = null;
 
    private CompileOptions options;
    private File compilerInputFile = null;
 
    public CompileJob(String name, RepositoryTools repositoryTools, CompileOptions options) {
        super(name);
        this.repositoryTools = repositoryTools;
        this.options = options;
 
        this.maxFileCount = getMaxCompileCount();
        this.logger = LoggerFactory.getLogger(PaProject.class);
    }
 
    private boolean checkPreconditions(PaProject paProject) {
        if (paProject == null) {
            Display.getDefault().syncExec(new Runnable() {
                public void run() {
                    MessageDialog.openError(Display.getDefault().getActiveShell(), "Compile Job",
                            "There is no active proALPHA project associated with this git repository.");
                }
            });
 
            return false;
 
        } else if (!paProject.isAvailable()) {
            Display.getDefault().syncExec(new Runnable() {
                public void run() {
                    MessageDialog.openError(Display.getDefault().getActiveShell(), "Compile Job",
                            "proALPHA not available! \n\nIs the OE project opened and proALPHA running?");
                }
            });
            return false;
        }
 
        return true;
    }
 
    @Override
    protected IStatus run(IProgressMonitor monitor) {
        if (!this.checkPreconditions(repositoryTools.getPaProject()))
            return Status.CANCEL_STATUS;
 
        String paTmpDir = repositoryTools.getPaProject().getBridge().getpAStartupParam("temp", "");
        compilerInputFile = new Path(paTmpDir).append(options.compilerInputFileName).toFile();
 
        SubMonitor subMonitor = SubMonitor.convert(monitor, "Compile Job", 3);
 
        try {
            subMonitor.worked(0);
 
            // delete the file to ensure to not re-use old results
            this.deleteCompilerFile(this.compilerInputFile);
            if (this.createCompInputFile()) {
                List<String> filesToCompile = this.readCompilerInputFile();
 
                subMonitor.worked(1);
                this.runCompiler(filesToCompile);
                
                // In case of delta compile: Update the objectcodeinfo file
                if (this.options.type == CompileType.DELTA) {
                    try {
                        ObjectId head = repositoryTools.getRepository().resolve(Constants.HEAD);
                        Activator.writeObjectCodeInfoFile(repositoryTools.getRepository(),
                            head.getName());
                    } 
                    catch (IOException e) {
                        logger.error("Error while writing objectcodeinfo file: {}\n Stack:\n{}",
                            e.getMessage(), e.getStackTrace());
                    }
                }
            }
 
        } catch (IOException e) {
            e.printStackTrace();
            return Status.CANCEL_STATUS;
        } finally {
            subMonitor.done();
        }
 
        return Status.OK_STATUS;
    }
 
    private boolean createCompInputFile() {
        // python -m pa_common.compiler -r <gitWorkDir> --branch/--diff --no-compile
        // --input-file <this.getCompilerInputFilename()>
        Integer callExitValue = -1;
        ProcessBuilder builder = new ProcessBuilder();
 
        if (options.type == CompileType.BRANCH)
            // Branch compile
            builder.command("python", "-m", "pa_common.compiler", "-r",
                    repositoryTools.getRepository().getWorkTree().getAbsolutePath(), "--branch", "--no-compile",
                    "--input-file", this.compilerInputFile.getAbsolutePath());
 
        if (options.type == CompileType.DIFF)
            // Diff compile
            builder.command("python", "-m", "pa_common.compiler", "-r",
                    repositoryTools.getRepository().getWorkTree().getAbsolutePath(), "--from", options.commit1, "--to",
                    options.commit2, "--no-compile", "--input-file", this.compilerInputFile.getAbsolutePath());
 
        if (options.type == CompileType.DELTA)
            // Diff compile
            builder.command("python", "-m", "pa_common.compiler", "-r",
                    repositoryTools.getRepository().getWorkTree().getAbsolutePath(), "--delta",
                    "--no-compile", "--input-file", this.compilerInputFile.getAbsolutePath());
 
        builder.redirectErrorStream(true);
        builder.redirectInput(Redirect.PIPE);
        builder.redirectOutput(Redirect.PIPE);
 
        try {
            final Process p = builder.start();
 
            logger.info("Start of compiler file generation:  Running '{}'", builder.command());
            try (Reader rOut = new InputStreamReader(p.getInputStream());
                    BufferedReader inOut = new BufferedReader(rOut)) {
 
                String line;
                do {
                    line = inOut.readLine();
                    if (line != null) {
                        Activator.logToConsole(line);
                    }
                } while (line != null);
            }
 
            // Store the result of the call to display
            callExitValue = p.waitFor();
 
            if (callExitValue > 0) {
                Reader rErr = new InputStreamReader(p.getErrorStream());
                try (BufferedReader inErr = new BufferedReader(rErr)) {
                    String line;
                    do {
                        line = inErr.readLine();
                        if (line != null) {
                            Activator.logToConsole(line);
                        }
                    } while (line != null);
                }
 
                if (callExitValue > 1) {
                    final String errorMsg = MessageFormat.format(
                            "Error while generating compiler input file {0} for git repo {1}\n\n"
                                    + "See console output for more information.",
                            this.compilerInputFile.getAbsolutePath(),
                            repositoryTools.getRepository().getWorkTree().getAbsolutePath());
                    Activator.logToConsole(errorMsg);
                    Display.getDefault().syncExec(new Runnable() {
                        public void run() {
                            MessageDialog.openError(Display.getDefault().getActiveShell(), "Compile Job", errorMsg);
                        }
                    });
 
                }
 
                if (callExitValue == 1) {
                    final String errorMsg = "No files to compile";
                    Activator.logToConsole(errorMsg);
                    Display.getDefault().syncExec(new Runnable() {
                        public void run() {
                            MessageDialog.openInformation(Display.getDefault().getActiveShell(), "Compile Job",
                                    errorMsg);
                        }
                    });
                }
                return false;
            }
 
        } catch (IOException e) {
            final String errorMsg = MessageFormat.format(
                    "Exception while running python package pa_common.compiler with exitcode {0} and {1}",
                    callExitValue, e.getMessage());
            logger.error(errorMsg);
            return false;
        } catch (InterruptedException e) {
            final String errorMsg = MessageFormat.format("Error {0} occured", e.getMessage());
            logger.error(errorMsg);
            Thread.currentThread().interrupt();
            return false;
        }
 
        return true;
 
    }
 
    private Integer getMaxCompileCount() {
        String maxCountPref = Activator.getDefault().getPreferenceStore()
                .getString(PreferencesConstants.SINGLE_COMPILE_FILE_COUNT);
        try {
            return Integer.parseInt(maxCountPref);
        } catch (NumberFormatException e) {
            maxCountPref = "100";
            return 100;
        }
    }
 
    private String envNameLastprocedure(Map<String, String> envparam) {
        // check the env is set in different cases. if param lowercase is set
        // a param set in Uppercase is ignored.
 
        // walk over all set Parameters
        for (Map.Entry<String, String> e : envparam.entrySet()) {
            // if upper case of parameter match upper case of given parameter
            if (e.getKey().toUpperCase().equals(LAST_PROCEDURE_ENV_NAME))
                return e.getKey();
        }
 
        // if given parameter not set return default
        return LAST_PROCEDURE_ENV_NAME;
    }
 
    private List<String> readCompilerInputFile() {
        List<String> resultList = new ArrayList<String>();
        if (!this.compilerInputFile.exists())
            return resultList; // Empty list
 
        try (BufferedReader reader = new BufferedReader(new FileReader(this.compilerInputFile))) {
            String line = reader.readLine();
            while (line != null) {
                resultList.add(line);
                line = reader.readLine();
            }
        } catch (IOException e) {
            // Ignore if file does not exist
        }
 
        return resultList;
    }
 
    private boolean deleteCompilerFile(File compFile) {
        // if a special name for input file given also delete this file
        if (compFile.isFile()) {
            try {
                Files.delete(compFile.toPath());
            } catch (IOException e) {
                return false;
            }
        }
 
        return true;
    }
 
    private void runCompiler(List<String> filesToCompile) throws IOException {
        // start a multi compiler is result higher than config parameter
        logger.info("Programms to compile = {}", filesToCompile.toString());
        if (filesToCompile.size() >= this.maxFileCount
                || (filesToCompile.size() == 1 && filesToCompile.get(0).equals("*"))) {
            List<String> commands = new ArrayList<>();
            StringBuilder paCcommand = new StringBuilder();
            // command and Params must be in one startement
            paCcommand.append(repositoryTools.getPaProject().getBridge().getpAStartupParam("PROALPHADIR", "")
                    + "\\common\\startup\\server\\pa-adm.bat");
            paCcommand.append(" dev ");
            paCcommand.append(" multi-comp ");
            paCcommand.append("start ");
            paCcommand.append("-p \"UserID=system\" ");
            paCcommand.append("-p \"Password=compakt\" ");
            paCcommand.append("-n ");
            paCcommand.append("-pool active ");
 
            // start a shell
            commands.add("CMD");
            commands.add("/C");
            commands.add(paCcommand.toString());
            // prepare the commands to a new process
            ProcessBuilder pb = new ProcessBuilder(commands);
 
            // check the env property is set in different cases
            String env_name = envNameLastprocedure(pb.environment());
            // set the env for LASTPROCEDURE
            pb.environment().put(env_name, this.compilerInputFile.getAbsolutePath());
            // Set pastartd.p to not use available object code
            pb.environment().put(COMPPROC_ENV_NAME, "pastartd.p");
            logger.debug(pb.environment().toString());
            logger.debug(pb.command().toString());
            // execute batch file
            Process p = pb.start();
            // log the output of execution
            BufferedReader bir = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = bir.readLine()) != null) {
                logger.info(line); // log output
            }
 
        } else
            // call compiler
            repositoryTools.getPaProject().getBridge().startCompilerOpt(this.compilerInputFile.getAbsolutePath(), true);
    }
 
}