/*
*
* Copyright (C) 2010 Mattias Runge
*
* 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 "Manager.h"
#include <fstream>
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
namespace atom {
namespace vm {
Manager::Pointer Manager::instance_;
Manager::Manager() : LOG("vm::Manager")
{
}
Manager::~Manager()
{
this->io_service_.stop();
this->plugins_.clear();
this->context_.Dispose();
for (ImportFunctionList::iterator it = this->functions_.begin(); it != this->functions_.end(); it++)
{
it->second.Dispose();
}
}
void Manager::Create()
{
Manager::instance_ = Manager::Pointer(new Manager());
}
Manager::Pointer Manager::Instance()
{
return Manager::instance_;
}
void Manager::Delete()
{
Manager::instance_.reset();
}
v8::Persistent<v8::Context>& Manager::GetContext()
{
return this->context_;
}
void Manager::AddPlugin(Plugin::Pointer plugin)
{
this->plugins_.push_back(plugin);
}
void Manager::Start(std::string script_path)
{
this->script_path_ = script_path;
this->io_service_.post(boost::bind(&Manager::StartHandler, this));
}
void Manager::CallOutput(std::string output)
{
if (this->current_plugin_name_ != "")
{
for (unsigned int n = 0; n < this->plugins_.size(); n++)
{
if (this->plugins_[n]->GetName() == this->current_plugin_name_)
{
this->plugins_[n]->CallOutput(this->current_request_id_, output);
return;
}
}
}
else
{
LOG.Info(output);
}
}
Value Manager::Export_Log(const v8::Arguments& args)
{
v8::Context::Scope context_scope(Manager::Instance()->GetContext());
//LOG.Debug(std::string(__FUNCTION__) + " called!");
if (args.Length() < 1)
{
Manager::instance_->LOG.Error(std::string(__FUNCTION__) + ": To few arguments to log.");
return v8::Undefined();
}
v8::String::AsciiValue str(args[0]);
Manager::instance_->CallOutput(*str);
return v8::Undefined();
}
void Manager::Call(std::string plugin_name, unsigned int request_id, std::string name, ArgumentListPointer arguments)
{
this->io_service_.post(boost::bind(&Manager::CallHandler, this, plugin_name, request_id, name, arguments));
}
void Manager::Execute(std::string plugin_name, unsigned int request_id, std::string code)
{
this->io_service_.post(boost::bind(&Manager::ExecuteHandler, this, plugin_name, request_id, code));
}
bool Manager::CallHandler(std::string plugin_name, unsigned int request_id, std::string name, ArgumentListPointer arguments)
{
v8::Context::Scope context_scope(this->context_);
v8::TryCatch try_catch;
this->current_plugin_name_ = plugin_name;
this->current_request_id_ = request_id;
if (this->functions_.find(name) == this->functions_.end())
{
this->CallOutput("No such function found, " + name);
this->current_plugin_name_ = "";
this->current_request_id_ = 0;
return false;
}
//LOG.Debug("Call: " + name);
Value result = this->functions_[name]->Call(this->context_->Global(), arguments->size(), arguments->data());
if (result.IsEmpty())
{
this->CallOutput(this->FormatException(try_catch));
this->current_plugin_name_ = "";
this->current_request_id_ = 0;
return false;
}
//v8::String::AsciiValue response(result->ToString());
//this->CallOutput(plugin_name, request_id, std::string(*response));
this->current_plugin_name_ = "";
this->current_request_id_ = 0;
return true;
}
void Manager::StartHandler()
{
v8::Handle<v8::ObjectTemplate> raw_template = v8::ObjectTemplate::New();
raw_template->Set(v8::String::New("Log"), v8::FunctionTemplate::New(Manager::Export_Log));
for (unsigned int c = 0; c < this->plugins_.size(); c++)
{
ExportFunctionList export_functions = this->plugins_[c]->GetExportFunctions();
for (ExportFunctionList::iterator it = export_functions.begin(); it != export_functions.end(); it++)
{
raw_template->Set(v8::String::New(it->first.data()), v8::FunctionTemplate::New(it->second));
}
}
this->context_ = v8::Context::New(NULL, raw_template);
v8::Context::Scope context_scope(this->context_);
for (unsigned int c = 0; c < this->plugins_.size(); c++)
{
this->LoadScript("plugin/" + this->plugins_[c]->GetName() + ".js");
}
this->object_template_ = v8::Persistent<v8::ObjectTemplate>::New(raw_template);
for (unsigned int c = 0; c < this->plugins_.size(); c++)
{
this->plugins_[c]->InitializeDone();
}
LOG.Info("VM initialized.");
}
bool Manager::ImportFunction(std::string functionname)
{
v8::Context::Scope context_scope(this->context_);
v8::TryCatch try_catch;
v8::Handle<v8::String> process_name = v8::String::New(functionname.data());
v8::Handle<v8::Value> process_val = this->context_->Global()->Get(process_name);
if (!process_val->IsFunction())
{
LOG.Error(functionname + " was not found to be a function!");
return false;
}
v8::Handle<v8::Function> process_fun = v8::Handle<v8::Function>::Cast(process_val);
this->functions_[functionname] = v8::Persistent<v8::Function>::New(process_fun);
return true;
}
bool Manager::LoadScript(std::string scriptname)
{
for (unsigned int n = 0; n < this->loaded_scripts_.size(); n++)
{
if (this->loaded_scripts_[n] == scriptname)
{
LOG.Info(scriptname + " is already loaded.");
return true;
}
}
std::string path = this->script_path_ + scriptname;
std::ifstream file(path.data());
if (!file.is_open())
{
file.close();
LOG.Warning("Could not load " + scriptname + ".");
return false;
}
std::string code = "";
std::string line;
while (!file.eof())
{
std::getline(file, line);
if (file.eof())
{
break;
}
code += line + "\n";
}
code += "\n";
file.close();
v8::Context::Scope context_scope(this->context_);
v8::TryCatch try_catch;
v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(code.data(), code.length()),
v8::String::New(scriptname.data(), scriptname.length()));
if (script.IsEmpty())
{
LOG.Error(this->FormatException(try_catch));
return false;
}
else
{
Value result = script->Run();
if (result.IsEmpty())
{
LOG.Error(this->FormatException(try_catch));
return false;
}
}
this->loaded_scripts_.push_back(scriptname);
LOG.Info("Loaded " + scriptname + " successfully.");
return true;
}
void Manager::ExecuteHandler(std::string plugin_name, unsigned int request_id, std::string code)
{
std::string scriptname = "execute_" + plugin_name + ".js";
v8::Context::Scope context_scope(this->context_);
v8::TryCatch try_catch;
v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(code.data(), code.length()),
v8::String::New(scriptname.data(), scriptname.length()));
this->current_plugin_name_ = plugin_name;
this->current_request_id_ = request_id;
if (script.IsEmpty())
{
this->CallOutput(this->FormatException(try_catch));
}
else
{
Value result = script->Run();
if (result.IsEmpty())
{
this->CallOutput(this->FormatException(try_catch));
}
else
{
//v8::String::AsciiValue response(result->ToString());
//this->CallOutput(std::string(*response));
}
}
this->current_plugin_name_ = "";
this->current_request_id_ = 0;
}
std::string Manager::FormatException(v8::TryCatch& try_catch)
{
v8::Context::Scope context_scope(this->context_);
std::string result;
v8::HandleScope handle_scope;
v8::String::Utf8Value exception(try_catch.Exception());
v8::Handle<v8::Message> message = try_catch.Message();
if (message.IsEmpty())
{
result = *exception;
}
else
{
v8::String::Utf8Value filename(message->GetScriptResourceName());
result = std::string(*filename) + ":" + boost::lexical_cast<std::string>(message->GetLineNumber()) + ": " + std::string(*exception);
/*v8::String::Utf8Value sourceline(message->GetSourceLine());
string strSourceline = *sourceline;
result += strSourceline + "\n";
string underline = rpad("", message->GetStartColumn(), ' ');
underline = rpad(underline, message->GetEndColumn(), '^');
result += underline + "\n";*/
}
return result;
}
}; // namespace vm
}; // namespace atom