CheckPythonModules.java

package com.proalpha.pds.paconnector.utils;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.ProcessBuilder.Redirect;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class CheckPythonModules {
    private final Logger logger = LoggerFactory.getLogger(CheckPythonModules.class);
    HashMap<String, String> pyModuleVersions = new HashMap<String, String>();
 
    public CheckPythonModules() {
 
        this.pyModuleVersions.put("pa-installer", "0.0.27");
    }
 
    private HashMap<String, String> getPythonModules() {
 
        // return a hash map of 2 Strings with modul an version
        ProcessBuilder builder = new ProcessBuilder();
        HashMap<String, String> resultLines = new HashMap<String, String>();
        // pattern for result lines
        final String regex = "([a-zA-Z0-9-]{1,}\\s*)([0-9]{1,4}(\\.[0-9]+){0,3})";
        final Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE);
 
        // exec python pip
        builder.command("python", "-m", "pip", "list");
        builder.redirectErrorStream(true);
        builder.redirectInput(Redirect.PIPE);
        builder.redirectOutput(Redirect.PIPE);
 
        try {
            // exec python
            final Process p = builder.start();
            logger.info("query python modules. call '{}'", builder.command());
            // scan output lines
            try (Reader rOut = new InputStreamReader(p.getInputStream());
                    BufferedReader inOut = new BufferedReader(rOut)) {
                // content of read line
                String line;
                do {
                    // reed in one line
                    line = inOut.readLine();
                    // if line got values
                    if (line != null) {
                        // trim trailing spaces
                        line = line.trim();
                        // check line match regexp
                        Matcher m = pattern.matcher(line);
                        if (m.matches()) {
                            // line match add groups into resultlist.
                            resultLines.put(m.group(1).trim(), m.group(2).trim());
                            logger.debug("add modulinfo " + line);
                        } else
                            logger.debug("skip line " + line);
 
                    }
                } while (line != null);
            }
 
            // if result of call is an error clear result list
            Integer callExitValue = p.waitFor();
            if (callExitValue != 0)
                resultLines.clear();
 
        } catch (IOException | InterruptedException e) {
            // on any error clear list
            resultLines.clear();
        }
        // return the list. In case of errors list is empty
        return resultLines;
 
    }
 
    public Boolean pythonVersionsMatch() {
 
        Boolean pyVersionsMatch = true;
        // get current module versions from python
        HashMap<String, String> currentPythonModules = getPythonModules();
        // check the defined module / version list against list from python
        for (String pymodname : pyModuleVersions.keySet()) {
 
            String moduleversion = currentPythonModules.get(pymodname);
 
            if (moduleversion == null)
                pyVersionsMatch = false;
            else {
                // check version against needed
                String[] currentVersion = currentPythonModules.get(pymodname).split("\\.");
                String[] neededVersion = pyModuleVersions.get(pymodname).split("\\.");
 
                if (currentVersion.length != neededVersion.length)
                    pyVersionsMatch = false;
                else {
                    // go over all numbers
                    // watch out for 2.0.0 is higher than 1.9999.9999
                    for (Integer i = 0; i < currentVersion.length; i++) {
 
                        Integer current = Integer.parseInt(currentVersion[i]);
                        Integer needed = Integer.parseInt(neededVersion[i]);
                        // if a leading number is higher version match
                        if (current > needed)
                            break;
                        if (current < needed)
                            pyVersionsMatch = false;
                        // same number check next number
                    }
                }
 
            }
            logger.debug(String.format("module %s got version %s. needed version is %s", pymodname,
                    currentPythonModules.get(pymodname), pyModuleVersions.get(pymodname)));
            // if first version dosen't match update needed
            if (!pyVersionsMatch)
                break;
 
        }
 
        return pyVersionsMatch;
 
    }
 
}