WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom/src/VM/virtualmachine.cpp

+}
 VirtualMachine::~VirtualMachine()
+{
     stop();
+    myCommandThread.stop();
     ///FIXME: Verify that this works and does not cause segfaults
     for (map<int, SocketThread*>::iterator iter = mySocketThreads.begin(); iter != mySocketThreads.end(); iter++)
+    {
+        iter->second->stop();
+        delete iter->second;
+        //mySocketThreads.erase(iter);
+    }
+    mySocketThreads.clear();
+    for (map<int, IntervalThread*>::iterator iter = myIntervalThreads.begin(); iter != myIntervalThreads.end(); iter++)
+    {
+        iter->second->stop();
         delete iter->second;
-        mySocketThreads.erase(iter);
+        //myIntervalThreads.erase(iter);
     }
+    myIntervalThreads.clear();
 }
 void VirtualMachine::run()
+{
     myGlobal = ObjectTemplate::New();
+    myGlobal->Set(String::New("_quit"), FunctionTemplate::New(VirtualMachine::_quit));
+    myGlobal->Set(String::New("_print"), FunctionTemplate::New(VirtualMachine::_print));
-    myGlobal->Set(String::New("log"), FunctionTemplate::New(VirtualMachine_log));
+    myGlobal->Set(String::New("log"), FunctionTemplate::New(VirtualMachine::_log));
-    myGlobal->Set(String::New("sendCanMessage"), FunctionTemplate::New(VirtualMachine_sendCanMessage));
+    myGlobal->Set(String::New("sendCanMessage"), FunctionTemplate::New(VirtualMachine::_sendCanMessage));
-    myGlobal->Set(String::New("sendCanNMTMessage"), FunctionTemplate::New(VirtualMachine_sendCanNMTMessage));
+    myGlobal->Set(String::New("sendCanNMTMessage"), FunctionTemplate::New(VirtualMachine::_sendCanNMTMessage));
-    myGlobal->Set(String::New("loadScript"), FunctionTemplate::New(VirtualMachine_loadScript));
+    myGlobal->Set(String::New("loadScript"), FunctionTemplate::New(VirtualMachine::_loadScript));
-    myGlobal->Set(String::New("startIntervalThread"), FunctionTemplate::New(VirtualMachine_startIntervalThread));
+    myGlobal->Set(String::New("startIntervalThread"), FunctionTemplate::New(VirtualMachine::_startIntervalThread));
-    myGlobal->Set(String::New("stopIntervalThread"), FunctionTemplate::New(VirtualMachine_stopIntervalThread));
+    myGlobal->Set(String::New("stopIntervalThread"), FunctionTemplate::New(VirtualMachine::_stopIntervalThread));
-    myGlobal->Set(String::New("startSocketThread"), FunctionTemplate::New(VirtualMachine_startSocketThread));
+    myGlobal->Set(String::New("startSocketThread"), FunctionTemplate::New(VirtualMachine::_startSocketThread));
-    myGlobal->Set(String::New("stopSocketThread"), FunctionTemplate::New(VirtualMachine_stopSocketThread));
+    myGlobal->Set(String::New("stopSocketThread"), FunctionTemplate::New(VirtualMachine::_stopSocketThread));
-    myGlobal->Set(String::New("sendToSocketThread"), FunctionTemplate::New(VirtualMachine_sendToSocketThread));
+    myGlobal->Set(String::New("sendToSocketThread"), FunctionTemplate::New(VirtualMachine::_sendToSocketThread));
-    myGlobal->Set(String::New("uint2hex"), FunctionTemplate::New(VirtualMachine_uint2hex));
+    myGlobal->Set(String::New("uint2hex"), FunctionTemplate::New(VirtualMachine::_uint2hex));
     myContext = Context::New(NULL, myGlobal);
     if (loadScript("System/Base.js"))
+    {
         loadScript("System/Startup.js");
         loadScript("Autostart.js");
         Context::Scope contextScope(myContext);
-        myFunctionHandleNMTMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleNMTMessage")));
-        myFunctionOfflineCheck = Handle<Function>::Cast(myContext->Global()->Get(String::New("offlineCheck")));
-        myFunctionHandleMessage = Handle<Function>::Cast(myContext->Global()->Get(String::New("handleMessage")));
         myFunctionStartup = Handle<Function>::Cast(myContext->Global()->Get(String::New("startup")));
+    }
     else
+    {
         ///FIXME: We should probably exit the application here
     const int argc = 0;
     Handle<Value> argv[argc] = { };
     Handle<Value> result = myFunctionStartup->Call(myFunctionStartup, argc, argv);
-    mySemaphore.lock();
+    string commandPort = Settings::get("CommandPort");
+    if (commandPort != "")
+    {
+        myCommandThread.setSettings(stoi(commandPort), "Command console");
-    string expression;
+        myCommandThread.start();
+    }
+    else
+    {
+        SyslogStream &slog = SyslogStream::getInstance();
+        slog << "CommandPort is not defined, can not start Command console socket\n";
+    }
-    CanMessage canMessage;
+    mySemaphore.lock();
     while (true)
+    {
         while (myExpressions.size() > 0)
         {
-            expression = myExpressions.pop();
+            runExpression(myExpressions.pop());
+        }
-            runExpression(expression);
+        mySemaphore.wait();
-        }
+    }
-        while (myCanMessages.size() > 0)
+    mySemaphore.unlock();
+}
+void VirtualMachine::queueExpression(Expression expression)
-        {
+{
-            canMessage = myCanMessages.pop();
+    myExpressions.push(expression);
+    mySemaphore.broadcast();
+}
-            if (canMessage.getClassName() == "nmt")
+string VirtualMachine::formatException(TryCatch* tryCatch)
-            {
+{
+    string result;
-                expression = "handleNMTMessage(";
+    HandleScope handleScope;
-                expression += "'" + canMessage.getClassName() + "', ";
+    String::Utf8Value exception(tryCatch->Exception());
-                expression += "'" + canMessage.getCommandName() + "', ";
+    Handle<v8::Message> message = tryCatch->Message();
-                expression += canMessage.getJSONData();
+    string strException = *exception;
-                expression += ");";
+    if (message.IsEmpty())
+    {
-                runExpression(expression);
+        result += strException + "\n";
+    }
-            else
+    else
+    {
-                expression = "handleMessage(";
-                expression += "'" + canMessage.getClassName() + "', ";
-                expression += "'" + canMessage.getDirectionFlag() + "', ";
+        String::Utf8Value filename(message->GetScriptResourceName());
-                expression += "'" + canMessage.getModuleName() + "', ";
+        string strFilename = *filename;
-                expression += "" + itos(canMessage.getModuleId()) + ", ";
+        result += strFilename + ":" + itos(message->GetLineNumber()) + ": " + strException + "\n";
-                expression += "'" + canMessage.getCommandName() + "', ";
-                expression += canMessage.getJSONData();
+        String::Utf8Value sourceline(message->GetSourceLine());
-                expression += ");";
-                runExpression(expression);
+        string strSourceline = *sourceline;
-            }
-        }
-        mySemaphore.wait();
+        result += strSourceline + "\n";
-    }
+        string underline = rpad("", message->GetStartColumn(), ' ');
+        underline = rpad(underline, message->GetEndColumn(), '^');
-    mySemaphore.unlock();
+        result += underline + "\n";
+    }
-void VirtualMachine::queueCanMessage(CanMessage canMessage)
-{
-    myCanMessages.push(canMessage);
-    mySemaphore.broadcast();
+    return result;
-}
-void VirtualMachine::queueExpression(string expression)
-{
-    myExpressions.push(expression);
-    mySemaphore.broadcast();
+}
 bool VirtualMachine::loadScript(string scriptName)
+{
     SyslogStream &slog = SyslogStream::getInstance();
+    }
     string scriptSource = file_get_contents(scriptFileName);
     Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
     Context::Scope contextScope(myContext);
     TryCatch tryCatch;
     Handle<Script> script = Script::Compile(source, name);
     if (script.IsEmpty())
     {
-        printException(&tryCatch);
+        slog << formatException(&tryCatch);
         return false;
     }
     else
     {
         Handle<Value> result = script->Run();
         if (result.IsEmpty())
         {
-            printException(&tryCatch);
+            slog << formatException(&tryCatch);
             return false;
         }
         slog << "Loaded " + scriptName + "\n";
     }
     return true;
-}
-void VirtualMachine::callHandleNMTMessage(CanMessage canMessage)
-{
-    const int argc = 3;
-    string jsonData = canMessage.getJSONData();
-    Handle<Value> argv[argc] = {String::New(canMessage.getClassName().c_str()),
-                                String::New(canMessage.getCommandName().c_str()),
-                                String::New(jsonData.c_str()) };
-    Handle<Value> result = myFunctionHandleNMTMessage->Call(myFunctionHandleNMTMessage, argc, argv); // argc and argv are your standard arguments to a function
-}
-void VirtualMachine::callHandleMessage(CanMessage canMessage)
-{
-    const int argc = 6;
-    string jsonData = canMessage.getJSONData();
-    Handle<Value> argv[argc] = {String::New(canMessage.getClassName().c_str()),
-                                String::New(canMessage.getDirectionFlag().c_str()),
-                                String::New(canMessage.getModuleName().c_str()),
-                                Integer::New(canMessage.getModuleId()),
-                                String::New(canMessage.getCommandName().c_str()),
-                                String::New(jsonData.c_str()) };
-    Handle<Value> result = myFunctionHandleMessage->Call(myFunctionHandleMessage, argc, argv); // argc and argv are your standard arguments to a function
 }
 unsigned int VirtualMachine::startIntervalThread(unsigned int timeout)
 {
-    IntervalThread intervalThread(timeout);
+    IntervalThread *intervalThread = new IntervalThread(timeout);
-    myIntervalThreads[intervalThread.getId()] = intervalThread;
+    myIntervalThreads[intervalThread->getId()] = intervalThread;
-    myIntervalThreads[intervalThread.getId()].start();
+    myIntervalThreads[intervalThread->getId()]->start();
-    return intervalThread.getId();
+    return intervalThread->getId();
+}
 bool VirtualMachine::stopIntervalThread(unsigned int id)
 {
     if (myIntervalThreads.find(id) != myIntervalThreads.end())
+    {
+        delete myIntervalThreads[id];
         myIntervalThreads.erase(id);
         return true;
     }
     return false;
+}
 unsigned int VirtualMachine::startSocketThread(string address, int port, unsigned int reconnectTimeout)
+{
     SocketThread *socketThread = new SocketThread(address, port, reconnectTimeout);
     mySocketThreads[socketThread->getId()] = socketThread;
     mySocketThreads[socketThread->getId()]->start();
     return socketThread->getId();
+}
 bool VirtualMachine::stopSocketThread(unsigned int id)
 {
     if (mySocketThreads.find(id) != mySocketThreads.end())
+    {
         delete mySocketThreads[id];
         mySocketThreads.erase(id);
         return true;
+    }
     return false;
+}
 void VirtualMachine::sendToSocketThread(unsigned int id, string data)
 {
     if (mySocketThreads.find(id) != mySocketThreads.end())
     {
         mySocketThreads[id]->send(data);
     }
+}
+void VirtualMachine::disconnectCommandClient(unsigned int id)
+{
+    myCommandThread.disconnectClient(id);
+}
+void VirtualMachine::sendToCommandClient(unsigned int id, string data)
+{
+    myCommandThread.sendTo(id, data);
+}
+void VirtualMachine::print(unsigned int id, string data)
+{
+    if (id == 0)
+    {
+        SyslogStream &slog = SyslogStream::getInstance();
+        slog << data;
+    }
+    else
+    {
+        VirtualMachine &vm = VirtualMachine::getInstance();
+        vm.sendToCommandClient(id, data);
+    }
 }
-bool VirtualMachine::runExpression(string expression)
+bool VirtualMachine::runExpression(Expression expression)
 {
     string scriptName = "runExpression";
+    string scriptData = expression.getScript();
+    scriptData = "setClientId(" + itos(expression.getTargetId()) + ");\n" + scriptData;
-    Handle<String> source =  String::New(expression.c_str(), expression.length());
+    Handle<String> source =  String::New(scriptData.c_str(), scriptData.length());
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
     Context::Scope contextScope(myContext);
     TryCatch tryCatch;
     Handle<Script> script = Script::Compile(source, name);
     if (script.IsEmpty())
+    {
-        printException(&tryCatch);
+        print(expression.getTargetId(), formatException(&tryCatch));
         return false;
+    }
     else
     {
         Handle<Value> result = script->Run();
         if (result.IsEmpty())
+        {
-            printException(&tryCatch);
+            print(expression.getTargetId(), formatException(&tryCatch));
             return false;
+        }
+        else if (expression.getTargetId() != 0)
+        {
+             String::AsciiValue ascii(result);
+             string resultString = *ascii;
+             if (resultString != "undefined")
+             {
+                print(expression.getTargetId(), resultString + "\n");
+             }
+        }
+    }
+    return true;
+}
+Handle<Value> VirtualMachine::_quit(const Arguments& args)
+{
+    VirtualMachine &vm = VirtualMachine::getInstance();
+    vm.disconnectCommandClient(args[0]->Uint32Value());
-    return true;
+    return Undefined();
+}
-void VirtualMachine::printException(TryCatch* tryCatch)
-{
-    SyslogStream &slog = SyslogStream::getInstance();
-    HandleScope handleScope;
-    String::Utf8Value exception(tryCatch->Exception());
-    Handle<v8::Message> message = tryCatch->Message();
-    string strException = *exception;
-    if (message.IsEmpty())
-    {
-        slog << strException + "\n\n";
-    }
-    else
-    {
-        String::Utf8Value filename(message->GetScriptResourceName());
-        string strFilename = *filename;
-        slog << strFilename + ":" + itos(message->GetLineNumber()) + ": " + strException + "\n";
-        String::Utf8Value sourceline(message->GetSourceLine());
-        string strSourceline = *sourceline;
-        slog << strSourceline + "\n";
-        string underline = rpad("", message->GetStartColumn(), ' ');
-        underline = rpad(underline, message->GetEndColumn(), '^');
-        slog << underline + "\n\n";
-    }
-}
-Handle<Value> VirtualMachine_log(const Arguments& args)
+Handle<Value> VirtualMachine::_log(const Arguments& args)
+{
     SyslogStream &slog = SyslogStream::getInstance();
     String::AsciiValue str(args[0]);
     slog << *str;
     return Undefined();
+}
+Handle<Value> VirtualMachine::_print(const Arguments& args)
+{
+    VirtualMachine &vm = VirtualMachine::getInstance();
+    String::AsciiValue str(args[1]);
+    vm.print(args[0]->Uint32Value(), *str);
+    return Undefined();
+}
-Handle<Value> VirtualMachine_sendCanMessage(const Arguments& args)
+Handle<Value> VirtualMachine::_sendCanMessage(const Arguments& args)
+{
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     canMan.sendMessage(canMessage);
     return Undefined();
+}
-Handle<Value> VirtualMachine_sendCanNMTMessage(const Arguments& args)
+Handle<Value> VirtualMachine::_sendCanNMTMessage(const Arguments& args)
+{
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     canMan.sendMessage(canMessage);
     return Undefined();
+}
-Handle<Value> VirtualMachine_loadScript(const Arguments& args)
+Handle<Value> VirtualMachine::_loadScript(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue str(args[0]);
     return Boolean::New(vm.loadScript(*str));
+}
-Handle<Value> VirtualMachine_startIntervalThread(const Arguments& args)
+Handle<Value> VirtualMachine::_startIntervalThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
+    return Integer::New(vm.startIntervalThread(args[0]->Uint32Value()));
+}
+Handle<Value> VirtualMachine::_stopIntervalThread(const Arguments& args)
+{
+    VirtualMachine &vm = VirtualMachine::getInstance();
+    return Boolean::New(vm.stopIntervalThread(args[0]->Uint32Value()));
+}
-    unsigned int timeout = args[0]->Uint32Value();
-    return Integer::New(vm.startIntervalThread(timeout));
-}
-Handle<Value> VirtualMachine_stopIntervalThread(const Arguments& args)
-{
-    VirtualMachine &vm = VirtualMachine::getInstance();
-    unsigned int id = args[0]->Uint32Value();
-    return Boolean::New(vm.stopIntervalThread(id));
-}
-Handle<Value> VirtualMachine_startSocketThread(const Arguments& args)
+Handle<Value> VirtualMachine::_startSocketThread(const Arguments& args)
 {
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue address(args[0]);
-    int port = args[1]->Uint32Value();
-    unsigned int reconnectTimeout = args[2]->Uint32Value();
-    return Integer::New(vm.startSocketThread(*address, port, reconnectTimeout));
+    return Integer::New(vm.startSocketThread(*address, args[1]->Uint32Value(), args[2]->Uint32Value()));
 }
-Handle<Value> VirtualMachine_stopSocketThread(const Arguments& args)
+Handle<Value> VirtualMachine::_stopSocketThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
-    unsigned int id = args[0]->Uint32Value();
-    return Boolean::New(vm.stopSocketThread(id));
+    return Boolean::New(vm.stopSocketThread(args[0]->Uint32Value()));
+}
-Handle<Value> VirtualMachine_sendToSocketThread(const Arguments& args)
+Handle<Value> VirtualMachine::_sendToSocketThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
-    unsigned int id = args[0]->Uint32Value();
     String::AsciiValue data(args[1]);
-    vm.sendToSocketThread(id, *data);
+    vm.sendToSocketThread(args[0]->Uint32Value(), *data);
     return Undefined();
+}
-Handle<Value> VirtualMachine_uint2hex(const Arguments& args)
+Handle<Value> VirtualMachine::_uint2hex(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
-    unsigned int id = args[0]->Uint32Value();
-    unsigned int length = args[1]->Uint32Value();
+    string hexId = uint2hex(args[0]->Uint32Value(), args[1]->Uint32Value());
-    string hexId = uint2hex(id, length);
     return String::New(hexId.c_str());
+}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/src/VM/virtualmachine.cpp @ 2117 – Rev 997 → 999