WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/vm/Manager.cpp

+{
     this->script_path_ = script_path;
     this->io_service_.post(boost::bind(&Manager::StartHandler, this));
+}
-void Manager::SendResponse(std::string plugin_name, unsigned int request_id, std::string response)
+void Manager::CallOutput(std::string output)
+{
+    if (this->current_plugin_name_ != "")
+    {
-    for (unsigned int n = 0; n < this->plugins_.size(); n++)
+        for (unsigned int n = 0; n < this->plugins_.size(); n++)
-    {
+        {
-        if (this->plugins_[n]->GetName() == plugin_name)
+            if (this->plugins_[n]->GetName() == this->current_plugin_name_)
-        {
+            {
-            this->plugins_[n]->ExecutionResult(response, request_id);
+                this->plugins_[n]->CallOutput(this->current_request_id_, output);
-            return;
+                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));
+}
-void Manager::CallHandler(std::string plugin_name, unsigned int request_id, std::string name, ArgumentListPointer arguments)
+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->SendResponse(plugin_name, request_id, "No such function found, " + name);
+        this->CallOutput("No such function found, " + name);
+        this->current_plugin_name_ = "";
+        this->current_request_id_ = 0;
-        return;
+        return false;
+    }
     //LOG.Debug("Call: " + name);
     Value result = this->functions_[name]->Call(this->context_->Global(), arguments->size(), arguments->data());
     if (result.IsEmpty())
     {
-        this->SendResponse(plugin_name, request_id, this->FormatException(try_catch));
+        this->CallOutput(this->FormatException(try_catch));
+        this->current_plugin_name_ = "";
+        this->current_request_id_ = 0;
-        return;
+        return false;
     }
-    v8::String::AsciiValue response(result->ToString());
+    //v8::String::AsciiValue response(result->ToString());
+    //this->CallOutput(plugin_name, request_id, std::string(*response));
-    this->SendResponse(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_);
+    }
     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->SendResponse(plugin_name, request_id, this->FormatException(try_catch));
+        this->CallOutput(this->FormatException(try_catch));
     }
     else
     {
         Value result = script->Run();
         if (result.IsEmpty())
         {
-            this->SendResponse(plugin_name, request_id, this->FormatException(try_catch));
+            this->CallOutput(this->FormatException(try_catch));
         }
         else
+        {
-            v8::String::AsciiValue response(result->ToString());
+            //v8::String::AsciiValue response(result->ToString());
-            this->SendResponse(plugin_name, request_id, std::string(*response));
+            //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_);

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/vm/Manager.cpp @ 1663 – Rev 1644 → 1647