subprocess_util.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) 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 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) 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 Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <QFile>
#include <QCoreApplication>
#include <QProcess>
#include <QDir>
#include <QRegularExpression>
#include <QEventLoop>
#include <QTimer>
#include <QElapsedTimer>
#include <atomic>
 
#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
 
// flag global au TU (non exporté) + fonction publique pour le setter
static std::atomic_bool g_python_cancel_requested{false};
 
void python_request_cancel()
{
    g_python_cancel_requested.store(true, std::memory_order_relaxed);
}
 
bool python_cancel_was_requested()
{
    return g_python_cancel_requested.load(std::memory_order_relaxed);
}
 
// Returns the base directory for locating Cython libs and runtime deps.
// Priority: env TYMPAN_APP_DIR -> QCoreApplication::applicationDirPath() if available -> current working dir.
static QString _tympan_app_dir()
{
    const QProcessEnvironment pe = QProcessEnvironment::systemEnvironment();
    if (pe.contains("TYMPAN_INSTALL_PATH"))
    {
        return QDir::cleanPath(pe.value("TYMPAN_INSTALL_PATH"));
    }
    if (QCoreApplication::instance())
    {
        return QCoreApplication::applicationDirPath();
    }
    // Headless fallback: current working directory
    return QDir::currentPath();
}
 
QStringList _python_qprocess_environment()
{
    QStringList env(QProcess::systemEnvironment());
    // Absolute path to Tympan install directory
    QString cythonlibs_path(_tympan_app_dir());
    // 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
    QRegularExpression pythonpath_regexp("^PYTHONPATH=(.*)", QRegularExpression::CaseInsensitiveOption);
    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)
    QRegularExpression path_regexp("^Path=(.*)", QRegularExpression::CaseInsensitiveOption);
    int path_index = env.indexOf(path_regexp);
    QString path = env[path_index];
    QRegularExpression equal_regexp(
        "=",
        QRegularExpression::CaseInsensitiveOption); // Position of the "=" symbol in the path QString
    int equal_index = path.indexOf(equal_regexp) + 1;
    QString application_path(_tympan_app_dir());
    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()
{
    QStringList env(QProcess::systemEnvironment());
    // TYMPAN_PYTHON_INTERP environment variable must be set to the path to
    // python 3 interpreter (ex: "C:\Python3\python.exe")
    int python_interp_idx = env.indexOf(QRegularExpression("^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;
}
 
std::string _read_environment_variables(QStringList env)
{
    std::string variables = "\nVariables d'environnement:\n";
    int pythonpath_index =
        env.indexOf(QRegularExpression("^PYTHONPATH=(.*)", QRegularExpression::CaseInsensitiveOption));
    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(QRegularExpression("^Path=(.*)", QRegularExpression::CaseInsensitiveOption));
    if (path_index >= 0)
    {
        variables += env[path_index].toStdString() + "\n";
    }
    else
    {
        variables += "Path absente\n";
    }
    int python_interp_index = env.indexOf(QRegularExpression("^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(QRegularExpression("^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)
{
    g_python_cancel_requested.store(false, std::memory_order_relaxed);
    OMessageManager& logger = *OMessageManager::get();
 
    // Start stopwatch
    OChronoTime startTime;
    logger.debug("Lancement du script python: %s", args.join(" ").toStdString().c_str());
 
    QProcess python;
    float comp_duration = 0.0f;
 
    // Set PYTHONPATH for the Python subprocess
    QStringList env(_python_qprocess_environment());
    python.setEnvironment(env);
    python.setProcessChannelMode(QProcess::SeparateChannels); // also useful for stage B
 
    // Resolve 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;
    }
 
    // Start process
    python.start(python_interp, args);
 
    // Blocking monitoring loop: short polls + periodic logging + cooperative cancel
    const int poll_ms = 100; // short poll for responsive cancel
    bool terminate_sent = false;
    qint64 kill_deadline_ms = -1;
 
    QElapsedTimer elapsed;
    elapsed.start();
    qint64 last_log_ms = 0;
 
    while (true)
    {
        if (python.waitForFinished(poll_ms))
        {
            break; // finished (normal or error) → exit loop
        }
 
        // Periodic log (keeps previous behavior without relying on event loop)
        const qint64 now = elapsed.elapsed();
        if (now - last_log_ms >= static_cast<qint64>(COMPUTATION_TIMEOUT))
        {
            comp_duration = static_cast<float>(now) / 1000.0f;
            logger.info("Le script python s'execute encore apres %.0f secondes", comp_duration);
            last_log_ms = now;
        }
 
        // Cancellation path
        if (g_python_cancel_requested.load(std::memory_order_relaxed))
        {
            if (!terminate_sent)
            {
                logger.warning("Demande d'annulation reçue : envoi de terminate() au sous-processus Python.");
                python.terminate();
                terminate_sent = true;
                kill_deadline_ms = now + 1500; // grace period
            }
            else if (kill_deadline_ms >= 0 && now >= kill_deadline_ms &&
                     python.state() != QProcess::NotRunning)
            {
                logger.warning("Le sous-processus Python ne s'est pas terminé : kill().");
                python.kill();
                // After kill(), either it will finish or be forcefully ended on next poll
            }
        }
    }
 
    // --- Read outputs + status ---
    const QString std_error = python.readAllStandardError();
    const 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 += std::to_string(static_cast<long long>(exit_code));
        error_msg += "\n";
        error_msg += std_error.toStdString();
        error_msg += _read_environment_variables(env);
        error_msg += "Veuillez lire tympan.log pour plus d'information.\n";
        logger.error("%s", 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 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;
}