Changeset 15430

Timestamp:

04/24/13 22:40:45 (12 years ago)

Author:

tbretz

Message:

Implemented the possibility to send an interrupt request (irq) to a runing JavaScript.

Location:

trunk/FACT++/src

Files:

• InterpreterV8.cc (modified) (4 diffs)
• InterpreterV8.h (modified) (4 diffs)
• RemoteControl.h (modified) (1 diff)
• StateMachineDimControl.cc (modified) (3 diffs)
• StateMachineDimControl.h (modified) (3 diffs)
• dimctrl.cc (modified) (3 diffs)

trunk/FACT++/src/InterpreterV8.cc

@@ -1474 +1474 @@
 }
 
-
 void InterpreterV8::JsHandleState(const std::string &server, const State &state)
 {
@@ -1524 +1523 @@
     if (!HandleException(exception, "dim.onchange"))
         V8::TerminateExecution(fThreadId);
+}
+
+Handle<Value> InterpreterV8::FuncSetInterrupt(const Arguments &args)
+{
+    if (args.Length()!=1)
+        return ThrowException(String::New("Number of arguments must be 1."));
+
+    if (!args[0]->IsNull() && !args[0]->IsUndefined() && !args[0]->IsFunction())
+        return ThrowException(String::New("Argument not a function, null or undefined."));
+
+    if (args[0]->IsNull() || args[0]->IsUndefined())
+    {
+        fInterruptCallback.Dispose();
+        return Undefined();
+    }
+
+    // Returns the value if the setter intercepts the request. Otherwise, returns an empty handle.
+    fInterruptCallback = Persistent<Object>::New(args[0]->ToObject());
+    return Undefined();
+}
+
+int InterpreterV8::JsHandleInterrupt(const EventImp &evt)
+{
+    const Locker locker;
+
+    if (fThreadId<0)
+        return -42;
+
+    if (fInterruptCallback.IsEmpty())
+        return -42;
+
+    const HandleScope handle_scope;
+
+    fInterruptCallback->CreationContext()->Enter();
+
+    // -------------------------------------------------------------------
+
+    TryCatch exception;
+
+    const string str = evt.GetString();
+
+    const size_t p = str.find_last_of('\n');
+
+    const string irq = p==string::npos?str:str.substr(0, p);
+    const string usr = p==string::npos?"nobody":str.substr(p+1);
+
+    Local<Value> irq_str = String::New(irq.c_str());
+    Local<Value> usr_str = String::New(usr.c_str());
+    Local<Value> date = Date::New(evt.GetJavaDate());
+
+    int32_t rc = -42;
+    if (!date.IsEmpty())
+    {
+        const int id = V8::GetCurrentThreadId();
+        fThreadIds.insert(id);
+
+        Handle<Value> args[] = { irq_str, date, usr_str };
+        Handle<Function> fun = Handle<Function>(Function::Cast(*fInterruptCallback));
+
+        const Handle<Value> val = fun->Call(fun, 3, args);
+
+        rc = !val.IsEmpty() && val->IsInt32() ? val->Int32Value() : 0;
+
+        fThreadIds.erase(id);
+    }
+
+    if (!HandleException(exception, "interrupt"))
+        V8::TerminateExecution(fThreadId);
+
+    return rc<10 || rc>255 ? -42 : rc;
 }
 
@@ -2342 +2411 @@
     dimctrl->Set(String::New("setState"),    FunctionTemplate::New(WrapSetState),  ReadOnly);
     dimctrl->Set(String::New("getState"),    FunctionTemplate::New(WrapGetState),  ReadOnly);
+    dimctrl->Set(String::New("setInterruptHandler"), FunctionTemplate::New(WrapSetInterrupt), ReadOnly);
 
     Handle<ObjectTemplate> v8 = ObjectTemplate::New();
@@ -2522 +2592 @@
     fStateCallbacks.clear();
 
+    // Now we can dispose the persistent interrupt handler
+    fInterruptCallback.Dispose();
+
     // Now we can dispose all persistent handles from reverse maps
     for (auto it=fReverseMap.begin(); it!=fReverseMap.end(); it++)

trunk/FACT++/src/InterpreterV8.h

@@ -46 +46 @@
     // List of all states already set
     std::vector<std::pair<int, std::string>> fStates;
+
+    // Interrupt handler
+    v8::Persistent<v8::Object> fInterruptCallback;
 
     static v8::Handle<v8::FunctionTemplate> fTemplateLocal;
@@ -86 +89 @@
     v8::Handle<v8::Value> FuncGetServices(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncNewState(const v8::Arguments& args);
+    v8::Handle<v8::Value> FuncSetInterrupt(const v8::Arguments& args);
     //v8::Handle<v8::Value> FuncOpen(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncSubscription(const v8::Arguments& args);
@@ -142 +146 @@
     static v8::Handle<v8::Value> WrapGetDescription(const v8::Arguments &args){ if (This) return This->FuncGetDescription(args);else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapGetServices(const v8::Arguments &args){ if (This) return This->FuncGetServices(args);else return v8::Undefined(); }
+    static v8::Handle<v8::Value> WrapSetInterrupt(const v8::Arguments &args){ if (This) return This->FuncSetInterrupt(args);else return v8::Undefined(); }
     //static v8::Handle<v8::Value> WrapOpen(const v8::Arguments &args)     { if (This) return This->FuncOpen(args);     else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapSubscription(const v8::Arguments &args){ if (This) return This->FuncSubscription(args);else return v8::Undefined(); }
@@ -204 +209 @@
     virtual std::pair<uint64_t, EventImp *> JsGetEvent(const std::string &) { return std::make_pair(0, (EventImp*)0); };
 
+    int JsHandleInterrupt(const EventImp &);
     void JsHandleEvent(const EventImp &, uint64_t, const std::string &);
     void JsHandleState(const std::string &, const State &);

trunk/FACT++/src/RemoteControl.h

@@ -523 +523 @@
         fImp = &imp;
         fImp->SetStateCallback(bind(&InterpreterV8::JsHandleState, this, placeholders::_1, placeholders::_2));
+        fImp->SetInterruptHandler(bind(&InterpreterV8::JsHandleInterrupt, this, placeholders::_1));
     }
 };

trunk/FACT++/src/StateMachineDimControl.cc

@@ -130 +130 @@
     InterpreterV8::JsStop();
     return GetCurrentState();
+}
+
+int StateMachineDimControl::InterruptScript(const EventImp &evt)
+{
+    if (!fInterruptHandler)
+        return GetCurrentState();
+
+    string str = evt.GetString();
+
+    const size_t p = str.find_last_of('\n');
+    if (p!=string::npos)
+        str[p] = ':';
+
+    Info("Interrupt request received ["+str+"]");
+    return fInterruptHandler(evt);
 }
 
@@ -510 +525 @@
         (bind(&StateMachineDimControl::StopScript, this))
         ("Stop a runnning batch script or JavaScript");
+
+    AddEvent("INTERRUPT", "C")
+        (bind(&StateMachineDimControl::InterruptScript, this, placeholders::_1))
+        ("Send an interrupt request (IRQ) to a running JavaScript");
 }
 
@@ -565 +584 @@
         return !Dim::SendCommand("DIM_CONTROL/STOP", fUser);
 
+    if (conf.Has("interrupt"))
+        return !Dim::SendCommand("DIM_CONTROL/INTERRUPT", conf.Get<string>("interrupt")+"\n"+fUser);
+
     if (conf.Has("start"))
         return !Dim::SendCommand("DIM_CONTROL/START", conf.Get<string>("start")+" user='"+fUser+"'"+fArgumentsJS);

trunk/FACT++/src/StateMachineDimControl.h

@@ -36 +36 @@
     std::string fArgumentsJS;
 
+    std::function<int(const EventImp &)> fInterruptHandler;
+
     std::string Line(const std::string &txt, char fill);
 
@@ -46 +48 @@
     int StartScript(const EventImp &imp, const std::string &cmd);
     int StopScript();
+    int InterruptScript(const EventImp &imp);
 
     int HandleStateChange(const std::string &server, DimDescriptions *state);
@@ -72 +75 @@
     void SetStateCallback(const std::function<void(const std::string &, const State &)> &func) { fStateCallback = func; }
 
+    void SetInterruptHandler(const std::function<int(const EventImp &)> &func=std::function<int(const EventImp &)>()) { fInterruptHandler = func; }
+
 public:
     StateMachineDimControl(std::ostream &out=std::cout);

trunk/FACT++/src/dimctrl.cc

@@ -1 +1 @@
 #include "StateMachineDimControl.h"
+
+//#include <sys/stat.h>
 
 #include "RemoteControl.h"
@@ -43 +45 @@
     {
         control.add_options()
+            ("batch",   var<string>(), "Start a batch script with the given name at the given label (script.dim[:N]) on the dimctrl-server")
             ("start",   var<string>(), "Start a java script with the given name on the dimctrl-server")
-            ("batch",   var<string>(), "Start a batch script with the given name at the given label (script.dim[:N]) on the dimctrl-server")
             ("stop",    po_switch(),   "Stop a currently running script on the dimctrl-server")
+            ("interrupt", var<string>()->implicit_value(""), "Send an interrupt request (IRQ) to a running JavaScript.")
             ("restart", var<string>(), "Send 'EXIT 126' to the given server")
             ("msg",     var<string>(), "Send a message to the chat server.")
@@ -106 +109 @@
 int main(int argc, const char* argv[])
 {
+    //chmod(argv[0], 04775);
+
     Configuration conf(argv[0]);
     conf.SetPrintUsage(PrintUsage);