calamares/src/libcalamares/PythonJob.cpp

/* === This file is part of Calamares - <http://github.com/calamares> ===
 *
 *   Copyright 2014, Teo Mrnjavac <teo@kde.org>
 *
 *   Calamares 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.
 *
 *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
 */

#include "PythonJob.h"

#include "PythonHelper.h"
#include "utils/Logger.h"
#include "GlobalStorage.h"
#include "JobQueue.h"

#include <QDir>

#undef slots
#include <boost/python.hpp>
#include <boost/python/args.hpp>

#include "PythonJobApi.h"


namespace bp = boost::python;

BOOST_PYTHON_FUNCTION_OVERLOADS( mount_overloads,
                                 CalamaresPython::mount,
                                 2, 4 );
BOOST_PYTHON_FUNCTION_OVERLOADS( chroot_call_str_overloads,
                                 CalamaresPython::chroot_call,
                                 1, 3 );
BOOST_PYTHON_FUNCTION_OVERLOADS( chroot_call_list_overloads,
                                 CalamaresPython::chroot_call,
                                 1, 3 );
BOOST_PYTHON_MODULE( libcalamares )
{
    bp::scope().attr( "ORGANIZATION_NAME" ) = CALAMARES_ORGANIZATION_NAME;
    bp::scope().attr( "ORGANIZATION_DOMAIN" ) = CALAMARES_ORGANIZATION_DOMAIN;
    bp::scope().attr( "APPLICATION_NAME" ) = CALAMARES_APPLICATION_NAME;
    bp::scope().attr( "VERSION" ) = CALAMARES_VERSION;
    bp::scope().attr( "VERSION_SHORT" ) = CALAMARES_VERSION_SHORT;

    bp::class_< CalamaresPython::PythonJobInterface >( "Job", bp::init< Calamares::PythonJob* >() )
        .def_readonly( "module_name", &CalamaresPython::PythonJobInterface::moduleName )
        .def_readonly( "pretty_name", &CalamaresPython::PythonJobInterface::prettyName )
        .def_readonly( "working_path", &CalamaresPython::PythonJobInterface::workingPath )
        .def_readonly( "configuration", &CalamaresPython::PythonJobInterface::configuration )
        .def( "setprogress", &CalamaresPython::PythonJobInterface::setprogress );

    bp::class_< Calamares::GlobalStorage >( "GlobalStorage", bp::init<>() )
        .def( "contains",   &Calamares::GlobalStorage::python_contains )
        .def( "count",      &Calamares::GlobalStorage::count )
        .def( "insert",     &Calamares::GlobalStorage::python_insert )
        .def( "keys",       &Calamares::GlobalStorage::python_keys )
        .def( "remove",     &Calamares::GlobalStorage::python_remove )
        .def( "value",      &Calamares::GlobalStorage::python_value );

    // libcalamares.utils submodule starts here
    bp::object submodule( bp::borrowed( PyImport_AddModule( "utils" ) ) );
    bp::scope().attr( "utils" ) = submodule;
    bp::scope utilsScope = submodule;
    Q_UNUSED( utilsScope );

    bp::def( "debug", &CalamaresPython::debug );
    bp::def( "mount",
             &CalamaresPython::mount,
             mount_overloads( bp::args( "device_path",
                                        "mount_point",
                                        "filesystem_name",
                                        "options" ),
                              "Runs the mount utility with the specified parameters.\n"
                              "Returns the program's exit code, or:\n"
                              "-1 = QProcess crash\n"
                              "-2 = QProcess cannot start\n"
                              "-3 = bad arguments" ) );
    bp::def( "chroot_call",
             static_cast< int (*)( const std::string&,
                                   const std::string&,
                                   int ) >( &CalamaresPython::chroot_call ),
             chroot_call_str_overloads( bp::args( "command",
                                                  "stdin",
                                                  "timeout" ),
                                        "Runs the specified command in the chroot of the target system.\n"
                                        "Returns the program's exit code, or:\n"
                                        "-1 = QProcess crash\n"
                                        "-2 = QProcess cannot start\n"
                                        "-3 = bad arguments\n"
                                        "-4 = QProcess timeout" ) );
    bp::def( "chroot_call",
             static_cast< int (*)( const bp::list&,
                                   const std::string&,
                                   int ) >( &CalamaresPython::chroot_call ),
             chroot_call_list_overloads( bp::args( "args",
                                                   "stdin",
                                                   "timeout" ),
                                         "Runs the specified command in the chroot of the target system.\n"
                                         "Returns the program's exit code, or:\n"
                                         "-1 = QProcess crash\n"
                                         "-2 = QProcess cannot start\n"
                                         "-3 = bad arguments\n"
                                         "-4 = QProcess timeout" ) );
}


namespace Calamares {


PythonJob::PythonJob( const QString& scriptFile,
                      const QString& workingPath,
                      const QVariantMap& moduleConfiguration,
                      QObject* parent )
    : Job( parent )
    , m_scriptFile( scriptFile )
    , m_workingPath( workingPath )
    , m_configurationMap( moduleConfiguration )
{
}


PythonJob::~PythonJob()
{}


QString
PythonJob::prettyName() const
{
    return tr( "Run script %1" )
                .arg( QDir( m_workingPath ).dirName() +
                      QDir::separator() +
                      m_scriptFile );
}


JobResult
PythonJob::exec()
{
    // We assume m_scriptFile to be relative to m_workingPath.
    QDir workingDir( m_workingPath );
    if ( !workingDir.exists() ||
         !workingDir.isReadable() )
    {
        return JobResult::error( tr( "Bad working directory path" ),
                                 tr( "Working directory %1 for python job %2 is not readable." )
                                    .arg( m_workingPath )
                                    .arg( prettyName() ) );
    }

    QFileInfo scriptFI( workingDir.absoluteFilePath( m_scriptFile ) );
    if ( !scriptFI.exists() ||
         !scriptFI.isFile() ||
         !scriptFI.isReadable() )
    {
        return JobResult::error( tr( "Bad main script file" ),
                                 tr( "Main script file %1 for python job %2 is not readable." )
                                    .arg( scriptFI.absoluteFilePath() )
                                    .arg( prettyName() ) );
    }

    try
    {
        bp::object scriptNamespace = helper()->createCleanNamespace();

        bp::object calamaresModule = bp::import( "libcalamares" );
        bp::dict calamaresNamespace = bp::extract< bp::dict >( calamaresModule.attr( "__dict__" ) );

        calamaresNamespace[ "job" ] = CalamaresPython::PythonJobInterface( this );
        calamaresNamespace[ "globalstorage" ] = bp::ptr( JobQueue::instance()->globalStorage() );

        bp::object execResult = bp::exec_file( scriptFI.absoluteFilePath().toLocal8Bit().data(),
                                           scriptNamespace,
                                           scriptNamespace );

        bp::object entryPoint = scriptNamespace[ "run" ];

        bp::object runResult = entryPoint();

        //QString message = QString::fromStdString( bp::extract< std::string >( entryPoint() ) );
        if ( runResult.is_none() )
        {
            return JobResult::ok();
        }
        else // Something happened in the Python job
        {
            bp::tuple resultTuple = bp::extract< bp::tuple >( runResult );
            QString message = QString::fromStdString( bp::extract< std::string >( resultTuple[ 0 ] ) );
            QString description = QString::fromStdString( bp::extract< std::string >( resultTuple[ 1 ] ) );
            return JobResult::error( tr( "Job \"%1\" finished with error" )
                                        .arg( prettyName() ),
                                     QString( "<strong>%1</strong><br/>%2" )
                                        .arg( message )
                                        .arg( description ) );
        }
    }
    catch ( bp::error_already_set )
    {
        QString msg;
        if ( PyErr_Occurred() )
        {
            msg = helper()->handleLastError();
        }
        bp::handle_exception();
        PyErr_Clear();
        return JobResult::error( tr( "Boost.Python error in job \"%1\"" ).arg( prettyName() ),
                                 msg );
    }

    return JobResult::ok();
}


void
PythonJob::emitProgress( qreal progressValue )
{
    emit progress( progressValue );
}


CalamaresPython::Helper*
PythonJob::helper()
{
    return CalamaresPython::Helper::s_instance;

}


} // namespace Calamares