subprocess_util.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2014> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#include <QFile>
#include <QCoreApplication>
#include <QProcess>
#include <QDir>
 
#include "Tympan/core/defines.h"
#include "Tympan/core/chrono.h"
#include "Tympan/core/logging.h"
#include "Tympan/core/exceptions.h"
#include "subprocess_util.h"
 
#if defined _DEBUG
    #define TYMPAN_REL_CYTHON_PATH "cython_d"
#else // undefined _DEBUG (release install)
    #define TYMPAN_REL_CYTHON_PATH "cython"
#endif // defined _DEBUG
 
#define COMPUTATION_TIMEOUT 10000 // In ms
 
QStringList _python_qprocess_environment()
{
    QStringList env(QProcess::systemEnvironment());
    // Absolute path to Tympan install directory
    QString cythonlibs_path(QCoreApplication::applicationDirPath());
    // Relative path from Tympan install directory to cython modules
    cythonlibs_path.append("/");
    cythonlibs_path.append(TYMPAN_REL_CYTHON_PATH);
    cythonlibs_path = QDir::toNativeSeparators(cythonlibs_path);
    // Set new PYTHONPATH
    QRegExp pythonpath_regexp("^PYTHONPATH=(.*)", Qt::CaseInsensitive);
    int pythonpath_index = env.indexOf(pythonpath_regexp);
    QString pythonpath;
    if (pythonpath_index > 0)
    {
        pythonpath = env[pythonpath_index];
        // Check the presence of cython libs in the PYTHONPATH
        if (pythonpath != "PYTHONPATH=")
        {
#if TY_PLATFORM == TY_PLATFORM_WIN32 || TY_PLATFORM == TY_PLATFORM_WIN64
            pythonpath.append(";");
#else
            pythonpath.append(":");
#endif
        }
        pythonpath.append(cythonlibs_path);
        env.removeAt(pythonpath_index);
    }
    else
    {
        pythonpath = "PYTHONPATH=";
        pythonpath.append(cythonlibs_path);
    }
    env.append(pythonpath);
#if TY_PLATFORM == TY_PLATFORM_WIN32 || TY_PLATFORM == TY_PLATFORM_WIN64
    // Add path to dynamic libraries needed by Tympan and thus needed by pytam (cython library)
    QRegExp path_regexp("^Path=(.*)", Qt::CaseInsensitive);
    int path_index = env.indexOf(path_regexp);
    QString path = env[path_index];
    QRegExp equal_regexp("=", Qt::CaseInsensitive); // Position of the "=" symbol in the path QString
    int equal_index = path.indexOf(equal_regexp) + 1;
    QString application_path(QCoreApplication::applicationDirPath());
    application_path = QDir::toNativeSeparators(application_path);
    path.insert(equal_index, application_path + ";"); // Insert the application path right after "PATH =".
    env.removeAt(path_index);
    env.append(path);
#endif
    return env;
}
 
QString _get_python_interp()
{
#if TY_PLATFORM == TY_PLATFORM_WIN32 || TY_PLATFORM == TY_PLATFORM_WIN64
    QStringList env(QProcess::systemEnvironment());
    // TYMPAN_PYTHON_INTERP environment variable must be set to the path to
    // python 3 interpreter (ex: "C:\Python34\python.exe")
    int python_interp_idx = env.indexOf(QRegExp("^TYMPAN_PYTHON_INTERP=(.*)"));
    if (python_interp_idx < 0)
    {
        throw tympan::invalid_data(
            "Can't access python interpreter. TYMPAN_PYTHON_INTERP environment variable is not set.");
    }
    QString python_interp_path = env.at(python_interp_idx).split('=')[1].remove("\"");
    QFile python_interp(python_interp_path);
    if (!python_interp.exists())
    {
        throw tympan::invalid_data("Can't access python interpreter. TYMPAN_PYTHON_INTERP environment "
                                   "variable is not correctly set.");
    }
    return python_interp_path;
#else
    return QString("python3");
#endif
}
 
std::string _read_environment_variables(QStringList env)
{
    std::string variables = "\nVariables d'environnement:\n";
    int pythonpath_index = env.indexOf(QRegExp("^PYTHONPATH=(.*)", Qt::CaseInsensitive));
    if (pythonpath_index >= 0)
    {
        variables += env[pythonpath_index].toStdString() + "\n";
    }
    else
    {
        variables += "PYTHONPATH absente\n";
    }
#if TY_PLATFORM == TY_PLATFORM_WIN32 || TY_PLATFORM == TY_PLATFORM_WIN64
    int path_index = env.indexOf(QRegExp("^Path=(.*)", Qt::CaseInsensitive));
    if (path_index >= 0)
    {
        variables += env[path_index].toStdString() + "\n";
    }
    else
    {
        variables += "Path absente\n";
    }
    int python_interp_index = env.indexOf(QRegExp("^TYMPAN_PYTHON_INTERP=(.*)"));
    if (python_interp_index >= 0)
    {
        variables += env[python_interp_index].toStdString() + "\n";
    }
    else
    {
        variables += "TYMPAN_PYTHON_INTERP absente\n";
    }
#endif
    return variables;
}
 
bool must_keep_tmp_files()
{
    QStringList appli_env(QProcess::systemEnvironment());
    int tympan_debug_idx = appli_env.indexOf(QRegExp("^TYMPAN_DEBUG=(.*)"));
    if (tympan_debug_idx >= 0)
    {
        QString debug_option = appli_env[tympan_debug_idx].split('=')[1];
        if (debug_option.contains("keep_tmp_files", Qt::CaseInsensitive))
        {
            return true;
        }
    }
    return false;
}
 
bool init_tmp_file(QTemporaryFile& tmp_file, bool keep_file)
{
    if (!tmp_file.open())
    {
        return false;
    }
    tmp_file.close();
    // Prevent from automatic file removal
    if (keep_file)
        tmp_file.setAutoRemove(false);
    return true;
}
 
bool python(QStringList args, std::string& error_msg)
{
    OMessageManager& logger = *OMessageManager::get();
    // Start chrono
    OChronoTime startTime;
    logger.debug("Lancement du script python: %s", args.join(" ").toStdString().c_str());
    QProcess python;
    float comp_duration(0.);
    bool comp_finished(false);
    // Set PYTHONPATH to python subprocess
    QStringList env(_python_qprocess_environment());
    python.setEnvironment(env);
    // Since scripts passed to QProcess are not launched through cmd.exe
    // under windows, we have to give QProcess the path to the python interpreter
    QString python_interp;
    try
    {
        python_interp = _get_python_interp();
    }
    catch (const tympan::invalid_data&)
    {
        error_msg = "L'interpreteur python n'a pas pu etre trouve.\nVeuillez verifier que la variable "
                    "d'environnement TYMPAN_PYTHON_INTERP est correctement positionnee\n";
        error_msg.append(_read_environment_variables(env));
        return false;
    }
    python.start(python_interp, args);
    do
    {
        comp_finished = python.waitForFinished(COMPUTATION_TIMEOUT);
        if (comp_finished)
        {
            break;
        }
        if (python.error() == QProcess::Timedout)
        {
            // Computation still running
            comp_duration += (COMPUTATION_TIMEOUT / 1000);
            logger.info("Le script python s'execute encore apres %.3f secondes", comp_duration);
            continue;
        }
        else
        {
            // Will have a bad exit status and will be handled below
            break;
        }
    } while (!comp_finished);
 
    QString std_error(python.readAllStandardError());
    int exit_code = python.exitCode();
    if (python.exitStatus() != QProcess::NormalExit || exit_code != 0)
    {
        error_msg = "Le sous-process python s'est terminé avec le code d'erreur ";
        error_msg.append(std::to_string(static_cast<long long>(exit_code)));
        error_msg.append("\n");
        error_msg.append(std_error.toStdString());
        error_msg.append(_read_environment_variables(env));
        error_msg.append("Veuillez lire tympan.log pour plus d'information.\n");
        logger.error(error_msg.c_str());
        return false;
    }
    else
    {
        logger.info("Le sous-processus Python s'est terminé correctement");
        if (!std_error.isEmpty())
            logger.warning(std_error.toStdString().c_str());
    }
 
    // Compute and display computation time
    OChronoTime endTime;
    OChronoTime duration = endTime - startTime;
    unsigned long second = duration.getTime() / 1000;
    unsigned long millisecond = duration.getTime() - second * 1000;
    logger.info("Temps de calcul : %02ld,%03ld sec.  (%ld msec.)", second, millisecond, duration.getTime());
    return true;
}