@naanlang/naan 1.6.0 → 1.7.1

package/frameworks/browser/terminals.nlg

@@ -10,93 +10,24 @@
  *
  */
 
-/*
- * globals
- *
- */
-
-gWorkers;
-
-
-/*
- * ioctl terminal control and events
- *
- * Example "raw" mode:
- *
-    // rawTest
-    // echo typed keystrokes in BOLD until Control-C stops it.
-    //
-    closure rawTest(local dokey) {
-        dokey = xnew(function(msg, arg) {
-            if arg.key == "\x03" {
-                js.t.ioctl("raw", false)
-                js.t.ioctl_remove_listener("raw-key", dokey)
-            }
-            else
-                print("\x1b[1m${arg.key}\x1b[22m")
-        })
-        js.t.ioctl_add_listener("raw-key", dokey)
-        js.t.ioctl("raw", true)
-    };
-    
-    rawTest();
- *
- *
- * Example echo control:
- *
-    js.t.ioctl("echo", 0)                       // no echo at all
-    js.t.ioctl("echo", 1)                       // echo newlines (best for hiding REPL commands)
-    js.t.ioctl("echo", 2)                       // normal echo
-
-    js.t.ioctl("sane")                          // restore echo and raw
- *
- *
- * Example simulated keystrokes:
- *
-    future(function(){ js.t.ioctl("keystroke", "joe") }, 10);               // "joe" in keyboard buffer
- *
- *
- * Example terminal resize notification:
- *
-    doresize = xnew(function(msg, dim) { printline("(${dim.cols}, ${dim.rows})")})
-    js.t.ioctl_add_listener("term-resize", doresize);
- *
- *
- * Example terminal connection notification:
- *
-    // add removable listener:
-    listener = xnew(function(msg,arg) { debuglog("listener:", msg, arg) });
-    js.t.ioctl_add_listener("term-attach", listener);
-    js.t.ioctl_add_listener("term-detach", listener);
-
-    // remove the listeners:
-    js.t.ioctl_remove_listener("term-attach", listener);
-    js.t.ioctl_remove_listener("term-detach", listener);
- *
- * Note that js.t.ioctl(...) controls the *terminal* even if attached to a different instance. But
- * ioctl event listeners are attached to an *instance* regardless of what terminal is connected.
- * But in general it does the "right thing" for multiple terminals on a single instance, and when
- * switching among instances.
- *
- */
-
 
 /*
  * TermHost
  *
- *     Make an Nide API Server debugger target.
+ *     Make a debugger target on our Host NaanIDE Server or a remote one.
  *
  * Options:
  *  {
- *      type: <string>                          // target category, e.g. "Host", "api.yyy.com"
- *      workerID: <string>                      // kind of worker in server subsystem
- *      startup: <dictionary>                   // startup options
+ *      serverID:     <string>                  // target server if not our Host
+ *      type:       <string>                    // target category, e.g. "Remote", "api.yyy.com"
+ *      workerID:   <string>                    // kind of worker in server subsystem
+ *      startup:    <dictionary>                // startup options
  *  }
  *
  */
 
 closure TermHost(track, name, options,
-    local relay, error, destID, target, xc)
+    local relay, error, serverID, targetID, target, xc)
 {
     global(App)
 
@@ -105,15 +36,20 @@ closure TermHost(track, name, options,
     // Find the host instance name/type, or create new remote worker. The default for no name/type is
     // the server itself.
     //
-    function findHostInstance(relay, name, type, local error, found, dest, worker) {
-        `(error, found) = relay.clients()
-        if !error {
-            dest = found.find(function(item) { item.name == "NaanIDE Server" && item.type == "Server IMP" })
-            if !dest
-                error = Error("cannot locate host")
+    function findHostInstance(relay, name, type,
+        local error, found, dest, worker) {
+        if !serverID {
+            `(error, found) = relay.clients()
+            if !error {
+                dest = found.find(function(item) { item.name == "NaanIDE Server" && item.type == "Server IMP" })
+                if dest
+                    serverID = dest.destID
+                else
+                    error = Error("cannot locate host")
+            }
         }
         if !error
-            `(error, found) = relay.clients(dest.destID)
+            `(error, found) = relay.clients(serverID)
         if !error {
             if name && type {
                 dest = found.find(function(item) { item.name == name && item.type == type })
@@ -143,6 +79,7 @@ closure TermHost(track, name, options,
                     name: name
                     type: options.type
                     startup: options.startup
+                    rootPath: options.rootPath || undefined
                     topOriginID: App.imp.us.instanceID
                 })
             if error
@@ -162,10 +99,11 @@ closure TermHost(track, name, options,
         return (list(false, target))                                        // already exists
 
     relay = require("naanlib:frameworks/client/relaycon.nlg").RelayCon(App.imp)
+    serverID = options.serverID
     if options.workerID == "NideServer"                                     // server main thread
-        `(error, destID) = findHostInstance(relay)
+        `(error, targetID) = findHostInstance(relay)
     else
-        `(error, destID) = findHostInstance(relay, name, options.type)
+        `(error, targetID) = findHostInstance(relay, name, options.type)
     relay.close()
     if error
         return (list(error))
@@ -174,9 +112,10 @@ closure TermHost(track, name, options,
         name: name
         type: options.type
     })
-    target.workerID = options.workerID
+    target.serverID = serverID                                              // server instanceID
+    target.workerID = options.workerID                                      // worker on server instanceID
 
-    `(error) = target.open(destID)
+    `(error) = target.open(targetID)
     if error
         return (list(Error("cannot create InTop", error)))
 
@@ -193,19 +132,19 @@ closure TermHost(track, name, options,
  *
  * Options:
  *  {
- *      workerID: <string>                      // kind of worker in server subsystem
+ *      workerID:   <string>                    // kind of worker in server subsystem
  *                                              // "NaanIDE" for local IDE
- *      startup: <dictionary>                   // startup options
- *      type: <string>                          // (rare) target category, e.g. "Local"
+ *      startup:    <dictionary>                // startup options
+ *      type:       <string>                    // (rare) target category, e.g. "Local"
+ *      worker:     <xobject>                   // existing worker or window
+ *      naancont:   <xobject>                   // NaaN controller if vsite
  *  }
  *
  */
 
-closure TermLocal(track, name, options, local target, worker, inbot, error)
+closure TermLocal(track, name, options, local target, worker, wowbot, error)
 {
-    global(js, window, gWorkers)
-    if !dictionary(gWorkers)
-        gWorkers = {}
+    global(js, window)
     options = merge({
         type: "Local"
     }, options)
@@ -216,12 +155,18 @@ closure TermLocal(track, name, options, local target, worker, inbot, error)
         return (termIDE(track, name, options.workerID, js.t))               // connect to IDE execution instance itself
     }
 
-    target = findIDEtarget(track, name, options.workerID)
-    if target
-        return (list(false, target))                                        // already exists
+    target = findIDEtarget(track, name, options.workerID, options.title, options.naancont)
+    if target {                                                             // new naancont on existing target
+        target.updateController(options)
+        track.update(target)
+        return (list(false, target))
+    }
 
-    worker = xnew(window.Worker, "env_webworker.js")
-    inbot = NubBot(worker, {
+    if options.worker
+        worker = options.worker
+    else
+        worker = xnew(window.Worker, "env_webworker.js")
+    wowbot = WowBot(worker, {
         name: name
         type: options.workerID
         startup: options.startup
@@ -231,10 +176,95 @@ closure TermLocal(track, name, options, local target, worker, inbot, error)
         type: options.type
         workerID: options.workerID
     })
-    `(error) = target.open(inbot.instanceID)
+    `(error) = target.open(wowbot.instanceID)
     if error
         return (list(Error("cannot create InTop", error)))
 
+    target.title = options.title
+    target.naancont = options.naancont
+
+    // updateController
+    //
+    //     Our controller was replaced, meaning the window changed.
+    //
+    target.updateController = function updateController(newops) {
+        target.execReset()
+        target.statusPoll = false
+        wowbot.close()
+        if defined(newops, `worker) {
+            if worker
+                target.impReceive({
+                    id: "textout"
+                    text: "\x1b[90m\x1b[3m".concat("\ntarget replaced", "\x1b[0m\n")
+                })
+            worker = newops.worker
+        }
+        if defined(newops, `title)
+            target.title = newops.title
+        if defined(newops, `naancont)
+            target.naancont = newops.naancont
+        wowbot = WowBot(worker, {
+            name: name
+            type: options.workerID
+            startup: options.startup
+        })
+        target.open(wowbot.instanceID)
+    }
+
+    // targetClose
+    //
+    //     Mark the target window as closed.
+    //
+    target.targetClose = function targetClose() {
+        worker = false
+        target.execReset()
+        target.cleanup()
+        target.impReceive({
+            id: "textout"
+            text: "\x1b[90m\x1b[3m".concat("\nwindow closed", "\x1b[0m\n")
+        })
+        target.close()
+    }
+
+    // cleanup
+    //
+    //     InTop is destroying our worker.
+    //
+    target.cleanup = function cleanup() {
+        target.statusPoll = false
+        target.naancont = false
+    }
+
+    // setCheckStatus
+    //
+    //     Begin or end checking status on the worker to see if stopped responding. The challenge
+    // here is that we open vsite windows in the main thread, but there is no reliable event to learn
+    // when they are closed. The solution is to poll the window.closed variable, which is reliable.
+    // to learn more quickly if the window as closed, the child may also inform us, but this is not
+    // entirely reliable--just quick if accurate.
+    //
+    target.setCheckStatus = closure setCheckStatus(hidden, window) {
+        if !target.statusPoll
+            target.statusPoll = future(function childWindowClosePoll() {
+                while target.statusPoll {
+                    if window.closed {
+                        targetClose()
+                        target.statusPoll = false
+                        break
+                    } else
+                        sleep(1000)                                     // check 1x/second
+                }
+            }, 10)                                                      // start after 10 msec
+    }
+
+    // vsiteRefresh
+    //
+    //     The vsite upon which we are based has changed.
+    //
+    target.vsiteRefresh = function vsiteRefresh(url_origin) {
+        target.naancont.VsiteRefresh(url_origin)
+    }
+
     // finis
 
     list(false, target)
@@ -266,39 +296,33 @@ closure findIDEtarget(track, name, workerID, title, naancont, local target) {
  *
  *     Make an IDE debugger target. The Naan controller in this case, env_web.js, iterates through
  * all connected terminals so we just have to provide unique connection object for it to talk with.
- * This is used for both the IDE itself as well as any additional virtual website windows.
+ * This is used for just the IDE itself.
  *
  */
 
-closure termIDE(track, name, workerID, naancont, title, local target, connected) {
-    global(js, gWorkers)
-    target = findIDEtarget(track, name, workerID, title, naancont)
-    if target {                                                             // new naancont on existing target
-        if target.naancont && naancont !== target.naancont
-            target.targetClose()
-        target.updateController(naancont)
-        target.title = title
-        track.update(target)
-        return (target)
-    }
+closure termIDE(track, name, workerID, naancont, local target, connected) {
+    global(js)
+    target = findIDEtarget(track, name, workerID)
+    if target
+        return (list(false, target))
     target = require("../running/executors.nlg").ExecutorBase(track, "Local", name)
+    target.dispatcher = require("../running/taskexec.nlg").TaskDispatcher(false, false, "termIDE")
     target.name = name
-    target.title = title
     target.workerID = workerID
     target.naancont = naancont
+    target.jsterms = new(weakmap)
     naancont.ioctl_open(ioctl_callback.proc)
     connected = []
-    
-    // replyHook
+
+    // PostMessage
     //
-    //     Intercept the ReplyMessage function to see if we should handle it.
+    // Process a message through the dispatcher.
     //
-    function replyHook(data) {
-        if data._guid
-            gWorkers[data._guid].worker.postMessage({
-                id: "targetreceive"
-                data: data
-            })
+    target.PostMessage = function PostMessage(data) {
+        target.dispatcher(data, function(reply) {
+             target.execReceived(reply)
+        })
+        list(false, { posted: true })
     }
 
     // ioctl_callback
@@ -323,22 +347,16 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
         naancont.DispatchDebugger(data)
     }
 
-    // target.PostMessage
-    //
-    //     Post a message to the target, ourselves.
-    //
-    target.PostMessage = function PostMessage(data) {
-        naancont.DispatchMessage(data)
-        list(false, { posted: true })
-    }
-
     // termAttach
     //
     // Create a closure for an attaching terminal.
     //
     target.termAttach = closure termAttach(term, db, notify, local connection, jsterm, inbound) {
-        connection = new(object, this)
         jsterm = term.jsAcquire()                                           // termIDE must be direct
+        if target.jsterms[jsterm]
+            return                                                          // return existing connection
+        connection = new(object, this)
+        target.jsterms[jsterm] = connection
 
         function oninterrupt() {
             naancont.Interrupt(inbound)
@@ -350,11 +368,7 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
     
         function onstatus(status) {
             target.execSetStatus(status)
-            statusCB(target, status)
-        }
-    
-        function onmessageout(data) {
-            target.execReceived(data)
+            notify.execStatus(target, status)
         }
     
         function ondebugout(data) {
@@ -377,10 +391,13 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
         }
 
         connection.termDetach = function termDetach() {                     // disconnect the terminal
+            if !target.jsterms[jsterm]
+                return                                                      // already released
             db.detach(target)
             if inbound
                 naancont.Detach(inbound)
             connected = connected.filter(function(conn) { conn !== connection })
+            target.jsterms[jsterm] = undefined
             term.jsRelease()
         }
 
@@ -399,7 +416,6 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
                 OnMessage: jsterm.OnMessage
                 StateSave: jsterm.StateSave
                 OnStatus: onstatus.proc
-                OnMessageOut: onmessageout.proc
                 OnDebugOut: ondebugout.proc
             })
             naancont.Attach(inbound)
@@ -439,74 +455,6 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
         connection
     }
     
-    // updateController
-    //
-    //     Update the naan controller on this target, which means updating for all the terminals.
-    //
-    target.updateController = function updateController(newnc, local conn) {
-        naancont.ioctl_close()
-        naancont = newnc
-        naancont.ioctl_open(ioctl_callback.proc)
-        target.naancont = newnc
-        for conn in connected {
-            if naancont {
-                naancont.Attach(conn.inbound)                               // tell the controller about terminals
-                conn.db.attach(target)                                      // re-attach since remote changed
-                conn.termActive()
-            } else
-                conn.db.detach(target)                                      // nothing left to debug
-        }
-        target.execReset()                                                  // reset our parent class
-    }
-
-    // targetClose
-    //
-    //     Mark the target window as closed.
-    //
-    target.targetClose = function targetClose(local conn) {
-        for conn in connected {
-            conn.db.detach(target)
-            conn.WriteLn("\x1b[90m\x1b[3m".concat("\ntarget closed", "\x1b[0m"))
-        }
-        target.execReset()
-        naancont.ioctl_close()
-        target.naancont = naancont = false
-    }
-
-    // setCheckStatus
-    //
-    //     Begin or end checking status on the worker to see if stopped responding. The challenge
-    // here is that we open vsite windows in the main thread, but there is no reliable event to learn
-    // when they are closed. The solution is to start checking if the window is closed after it gets
-    // a visibilityChange event to hidden. This terminates when the window gets marked closed or when
-    // it becomes visible again--which is quite unlikely unless someone uses the explicit hide/show
-    // window methods.
-    //
-    target.setCheckStatus = closure setCheckStatus(hidden, window) {
-        if hidden {
-            if !target.statusPoll
-                target.statusPoll = future(function() {
-                    while target.statusPoll {
-                        if window.closed {
-                            targetClose()
-                            target.statusPoll = false
-                            break
-                        } else
-                            sleep(100)                                      // check 10x/second
-                    }
-                }, 10)                                                      // start after 10 msec
-        } else
-            target.statusPoll = false
-    }
-
-    // vsiteRefresh
-    //
-    //     The vsite upon which we are based has changed.
-    //
-    target.vsiteRefresh = function vsiteRefresh(url_origin) {
-        naancont.VsiteRefresh(url_origin)
-    }
-    
     // destroy
     //
     //     Destroy the execution instance.
@@ -516,7 +464,6 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
         track.delete(target)
     }
 
-    js.t.OnReplyHook(replyHook.proc)
     track.add(target)
 
     // finis
@@ -534,17 +481,19 @@ closure termIDE(track, name, workerID, naancont, title, local target, connected)
  */
 
 closure termInstallVirtualWatcher(track, naancont) {
-    global()
+    global(js)
 
     function watchVsites(msg, local error, target) {
         if msg.op == "VsiteOpen" {
-            `(error, target) = termIDE(track, msg.name, "NaanVsite", msg.naancont, msg.title)
+            `(error, target) = TermLocal(track, msg.name, {
+                workerID: "NaanVsite", worker: msg.window, title: msg.title, naancont: msg.naancont
+            })
             target.attention()
         }
         else if msg.op == "VsiteClose" {
             target = findIDEtarget(track, msg.name, "NaanVsite", msg.title, msg.naancont)
             if target
-                target.updateController()
+                target.updateController({ naancont: false })                // allow re-use of instance
         }
         else if msg.op == "VsiteVisibilityChange" {
             target = findIDEtarget(track, msg.name, "NaanVsite", msg.title, msg.naancont)
@@ -553,7 +502,7 @@ closure termInstallVirtualWatcher(track, naancont) {
         }
     }
     
-    require("../running/executors.nlg").TaskOnMessageHook(watchVsites)
+    js.t.OnMessage(watchVsites.proc)
 };
 
 
@@ -653,8 +602,8 @@ closure relayTab(destID, local comMod, relay, error, found, dest, xc, reterm, or
     if error
         return (list(Error("cannot get remote terminal", error)))
     originID = App.imp.us.instanceID
-    `(error, inbot) = xc.evalq(InBot(window, {
-        name: "inbot"
+    `(error, inbot) = xc.evalq(MewBot(window, {
+        name: "mewbot"
         type: reterm.workerID
         topOriginID: originID
     }), `(reterm, originID))