python/VirtualMachine.cpp

Go to the documentation of this file.

/*
Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

This file is part of the TerraLib - a Framework for building GIS enabled
applications.

TerraLib is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.

TerraLib 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with TerraLib. See COPYING. If not, write to
TerraLib Team at <terralib-team@terralib.org>.
*/

/*!
\file terralib/vm/python/VirtualMachine.cpp

\brief Implementation of a virtual machine for the Python Programming
Language.

\author Matheus Cavassan Zaglia
*/

// TerraLib
#include "VirtualMachine.h"
#include "../../Defines.h"
#include "../../core/encoding/CharEncoding.h"
#include "../../core/filesystem/FileSystem.h"
#include "../../core/logger/Logger.h"
#include "../../core/translator/Translator.h"
#include "../../core/utils/Platform.h"
#include "../core/Exception.h"

// Qt
#include <QThread>

te::vm::python::VirtualMachineOutput::VirtualMachineOutput(
    te::vm::core::VirtualMachine* vm)
    : m_vm(vm)
{
}

void te::vm::python::VirtualMachineOutput::write(const std::string& str)
{
  m_vm->write(str.c_str());
}
te::vm::python::VirtualMachineInput::VirtualMachineInput(
    te::vm::core::VirtualMachine* vm)
    : m_vm(vm)
{
}

std::string te::vm::python::VirtualMachineInput::readline()
{
  return m_vm->readline();
}

te::vm::python::VirtualMachine::VirtualMachine()
    : m_stdin(this), m_stdout(this), m_stderr(this), m_readlineLoop(nullptr)
{
  Py_Initialize();

  boost::python::object main = boost::python::object(boost::python::handle<>(
      boost::python::borrowed(PyImport_AddModule("__main__"))));

  boost::python::object nspace = main.attr("__dict__");

  nspace["VirtualMachineInput"] =
      boost::python::class_<te::vm::python::VirtualMachineInput>(
          "VirtualMachineInput", boost::python::init<>())
          .def("readline", &te::vm::python::VirtualMachineInput::readline);
  nspace["VirtualMachineOutput"] =
      boost::python::class_<te::vm::python::VirtualMachineOutput>(
          "VirtualMachineOutput", boost::python::init<>())
          .def("write", &te::vm::python::VirtualMachineOutput::write);

  m_mainThreadState = PyEval_SaveThread();
}

te::vm::python::VirtualMachine::~VirtualMachine()
{
  PyEval_RestoreThread(m_mainThreadState);

  Py_Finalize();

  delete m_readlineLoop;
}

void te::vm::python::VirtualMachine::setFileName(QString file)
{
  m_filename = file.toUtf8().data();
}

void te::vm::python::VirtualMachine::execute()
{
  PyThreadState* state = Py_NewInterpreter();
  try
  {
    boost::python::import("sys").attr("stdin") = m_stdin;
    boost::python::import("sys").attr("stdout") = m_stdout;
    boost::python::import("sys").attr("stderr") = m_stderr;

    std::string bind_path;

#ifdef TERRALIB_MOD_BINDING_PYTHON_DIR
    std::string aux =
        "bindings/" + std::string(TERRALIB_MOD_BINDING_PYTHON_DIR);
    bind_path = te::core::FileSystem::absolutePath(
      te::core::FindInTerraLibPath(aux));
#endif

    std::string bin_path =
      te::core::FileSystem::absolutePath(te::core::FindInTerraLibPath("bin"));
    std::string lib_path =
      te::core::FileSystem::absolutePath(te::core::FindInTerraLibPath("lib"));

#if TE_PLATFORM == TE_PLATFORMCODE_MSWINDOWS
    std::replace(bind_path.begin(), bind_path.end(), '\\', '/');
    std::replace(bin_path.begin(), bin_path.end(), '\\', '/');
    std::replace(lib_path.begin(), lib_path.end(), '\\', '/');
#endif

    std::string py_binds = "sys.path.append('" + bind_path + "')\n" +
      "sys.path.append('" + bin_path + "')\n" +
      "sys.path.append('" + lib_path + "')\n" +
      "sys.path.append('" + bind_path +
      ((TE_PLATFORM == TE_PLATFORMCODE_MSWINDOWS) ? "\\..')" : "/..')");
    PyRun_SimpleString("import sys");
    PyRun_SimpleString(py_binds.c_str());
    PyRun_SimpleString(("exec(open('" + m_filename + "').read())").c_str());
  }
  catch(boost::python::error_already_set)
  {
    PyErr_Print();
  }
  Py_EndInterpreter(state);
}

void te::vm::python::VirtualMachine::write(const QString& str)
{
  emit output(str);
  QThread::currentThread()->usleep(1);
}

std::string te::vm::python::VirtualMachine::readline()
{
  emit requestReadline();
  m_readlineLoop = new QEventLoop();
  m_readlineLoop->exec();
  return m_readlineStr;
}

void te::vm::python::VirtualMachine::readline(QString msg)
{
  m_readlineStr = msg.toUtf8().data();
  m_readlineLoop->exit();
}

void te::vm::python::VirtualMachine::stop()
{
  PyErr_SetInterrupt();
  if(m_readlineLoop != nullptr && m_readlineLoop->isRunning())
    m_readlineLoop->exit();
  PyErr_CheckSignals();
}

std::string te::vm::python::VirtualMachine::getName() const
{
  return "Python";
}

std::string te::vm::python::VirtualMachine::getTitle() const
{
  std::string msg(
      TE_TR("TerraLib Virtual Machine for the Python Programming Language"));

  return msg;
}

std::string te::vm::python::VirtualMachine::getDescription() const
{
  std::string msg(TE_TR(
      "This Virtual Machine allows applications to execute python scripts."
      "\nAll the TerraLib API will be available for TerraLib programmers "
      "in the Python environment"));

  return msg;
}