@naanlang/naan 1.6.0 → 1.7.1

package/frameworks/browser/worker.nlg

@@ -2,7 +2,7 @@
  * worker.nlg
  * Naanlib/frameworks/browser
  *
- * Manage NaaN instances.
+ * Manage web-based NaaN instances.
  *
  * NaaN instances are managed by a top/bottom pair of of objects. InBot (INstance BOTtom) objects
  * reside in the same JavaScript environment (node/browser) as their worker and communicate with the
@@ -24,7 +24,8 @@
  *
  * Create a remote interface for a single execution instance, returning the object. This provides
  * instance access to zero or more InTops via IMP connections. The tops subscribe to receive
- * notifications/responses.
+ * notifications/responses. This runs in the main thread and communicates with the worker via the
+ * standard JS messaging interface.
  *
  * Options:
  *  {
@@ -32,7 +33,6 @@
  *      type:       <string>                    // target category, e.g. "Local"
  *      startup:    <dictionary>                // startup options
  *      workerID:   <string>                    // initialize worker with this
- *      workerGUID: <string>                    // initialize worker with this
  *      topOriginID:  <string>                  // so top can route to us through IMP
  *  }
  *
@@ -49,7 +49,7 @@ closure InBot(worker, options, local inbot)
     inbot.workerID = options.workerID
     inbot.worker = worker
 
-    inbot.instanceID = UUID()
+    inbot.instanceID = App.imp.getUUID("InBot(${options.name}) instanceID")
     inbot.sender = App.imp.register(inbot, {
         name: options.name
         type: options.type
@@ -133,9 +133,9 @@ closure InBot(worker, options, local inbot)
     // A message was received from the worker.
     //
     inbot.worker.addEventListener("message", function(e, local msg) {
-        msg = new(e.data)
-        if msg.scope == "naan-imp-web" {
-            inbot.impconn.dispatch(msg.data)
+        msg = e.data
+        if msg.scope == "naan-imp-out" {
+            inbot.impconn.dispatch(new(msg.data))
             return
         }
         if msg.scope != "naan-env-web"
@@ -148,10 +148,10 @@ closure InBot(worker, options, local inbot)
                     state: false                                            // resume state, if we have any
                     altcmd: options.startup.initcmds
                     workerID: options.workerID
-                    workerGUID: options.workerGUID
                     metadata: {
                         mainInstanceID: App.imp.us.instanceID
                         name: options.name
+                        maintext: options.startup.maintext.concat("\n")
                     }
                 })
             inbot.started = true
@@ -164,15 +164,29 @@ closure InBot(worker, options, local inbot)
     // The worker had an error.
     //
     inbot.worker.addEventListener("error", function(e) {
-        debuglog("worker error:", e.message)
+        debuglog("worker error:", e.message, "in", e.filename, "at", e.lineno)
         notifyAll({
             id: "error"
-            data: e.message
+            data: {
+                message: e.message
+                filename: e.filename
+                lineno: e.lineno
+            }
         })
         inbot.worker = false
         destroy()
     })
     
+    // close
+    //
+    // Close and remove our IMP resources, but leave the worker alone.
+    //
+    inbot.close = function close() {
+        inbot.impconn.destroy()
+        inbot.impconn = false
+        App.imp.unregister(inbot.instanceID)
+    }
+
     // destroy
     //
     // Ensure the worker is destroyed and notify everyone.
@@ -185,13 +199,9 @@ closure InBot(worker, options, local inbot)
         notifyAll({
             id: "terminated"
         })
-        inbot.impconn.close()
-        inbot.impconn = false
-        App.imp.unregister(inbot.instanceID)
+        close()
     }
 
-    // register our connects *after* the receivers are configured above
-
     // finis
 
     inbot
@@ -199,41 +209,77 @@ closure InBot(worker, options, local inbot)
 
 
 /*
- * NubBot
+ * MewBot
+ *
+ * Create a remote InBot interface for the Main WEb browser thread.
+ *
+ */
+
+closure MewBot(exec, options, local mewbot, inbot_impReceive)
+{
+    global(App)
+    mewbot = InBot(exec, options)
+    mewbot.dispatcher = require("naanlib:frameworks/running/taskexec.nlg").TaskDispatcher()
+    inbot_impReceive = mewbot.impReceive
+
+    // impReceive
+    //
+    // Received a message from InTop.
+    //
+    mewbot.impReceive = function impReceive(message, sourceID) {
+        if message.id == "targetin"
+            mewbot.dispatcher(message.data, function(reply) {
+                mewbot.sender(sourceID, {
+                    id: "targetout",
+                    data: reply
+                })
+            })
+        else
+            inbot_impReceive(message, sourceID)
+    }
+
+    // finis
+
+    mewbot
+}
+
+
+/*
+ * WowBot
  *
- * Create a remote interface like InBot, but also provide messaging support for WebWorkerNub inside
- * the worker.
+ * Create a remote InBot interface for WebWorkerNub running in the worker. This forwards remoting
+ * messages to the worker so they can be handled in the correct place.
  *
  */
 
-closure NubBot(worker, options, local nubbot)
+closure WowBot(worker, options, local wowbot)
 {
     global(App)
-    nubbot = InBot(worker, options)
+    wowbot = InBot(worker, options)
 
     App.imp.addEventListener("active", function(event, info) {
-        if info.ourID == nubbot.instanceID {
-            nubbot.workerDestID = info.destID                               // handshake completed
-            nubbot.notifyAll({                                              // send to tops
+        if info.ourID == wowbot.instanceID {
+            wowbot.workerDestID = info.destID                               // handshake completed
+            wowbot.notifyAll({                                              // send to tops
                 id: "workerDestID"
-                workerDestID: nubbot.workerDestID
+                workerDestID: wowbot.workerDestID
             })
         }
     })
 
-    nubbot.impconn = App.imp.responder(function(data) {
-        nubbot.worker.postMessage({                                         // send to worker
-            scope: "naan-imp-web"                                           // scoped for WorkerNub
+    wowbot.impconn = App.imp.responder(function(data) {
+        wowbot.worker.postMessage({                                         // send IMP messages to worker
+            scope: "naan-imp-in"                                            // scoped for WebWorkerNub
             data: data
         })
         list(false, { sent: true })
     }, {
-        ourID: nubbot.instanceID
+        ourID: wowbot.instanceID
     })
 
     // finis
 
-    nubbot
+    wowbot
 };
 
 
@@ -245,11 +291,13 @@ closure NubBot(worker, options, local nubbot)
  */
 
 function workInit(local manifest) {
-    manifest = `(InBot, NubBot, workInit)
+    manifest = `(InBot, MewBot, WowBot, workInit)
 
     Naan.module.build(module.id, "worker", function(modobj, compobj) {
         require("./browser.nlg")
         compobj.manifest = manifest
         modobj.exports.InBot = InBot
+        modobj.exports.MewBot = MewBot
+        modobj.exports.WowBot = WowBot
     })
 } ();

package/frameworks/browser/workers.nlg

@@ -314,7 +314,7 @@ closure ScopedServiceWorker(pubID, pubVersion, callback, local scoper, result) {
     //
     //     Destroy the service worker.
     
-    worker.destroy = function destroy() {
+    scoper.destroy = function destroy() {
         scoper.serv.unregister()
         scoper.serv = false
     }

package/frameworks/browser/ws_client.nlg

@@ -13,107 +13,43 @@
 /*
  * WebSocket
  *
- * Create a WebSocket client connection object.
+ * Create a WebSocket client connection object, returning a tuple.
  *
- * Optional, default Host:
- *      host:       <string>                    // host:port
+ * Required:
+ *      urlstr:     <string>
  *
  * Options:
  *  {
  *      wss:        <boolean>                   // true to use secure connection
+ *      query:      <string>                    // query string starting with ?
  *      onopen:     <proc>(e)                   // connection has opened
  *      onmessage:  <proc>(e, message)          // message received
  *      onerror:    <proc>(e)                   // error occurred
  *      onclose:    <proc>(e)                   // connection has closed
- *      query:      <string>                    // query string starting with ? for insecure connections
- *      querys:     <string>                    // query string starting with ? for secure connections
  *  }
  *
  */
 
-closure WebSocket(host, options, local wsock) {
-    global(window)
-    wsock = new(object, this)
-    options = new(options) || { }
-    if !host {
-        host = window.location.host
-        options.wss = window.location.protocol == "https:"
+closure WebSocket(urlstr, options, local url, ws) {
+    try {
+        url = xnew(js.w.URL, urlstr)
+    } catch {
+        return (list(Error("invalid URL ${urlstr}", exception)))
     }
-
-    // connect
-    //
-    // Connect with the host if not already connected, returning a result tuple.
-    //
-    wsock.connect = closure connect(local url, pending) {
-        if wsock.ws
-            return (list(false, { open: true }))
-        if options.wss
-            url = "wss://${host}${options.querys||''}"
-        else
-            url = "ws://${host}${options.query||''}"
-        wsock.ws = xnew(window.WebSocket, url)
-        pending = new(nonce)
-    
-        // onopen
-        // The WebSocket connection is now open.
-        wsock.ws.onopen = closure onopen(e) {
-            pending.signal(list(false, { ok: true }))
-            options.onopen(e)
-        }
-
-        // onmessage
-        // A message was received from the worker via WebSockets.
-        wsock.ws.onmessage = closure onmessage(e, local message) {
-            try {
-                message = new(JSONparse(e.data))
-            } catch {
-                debuglog("can't decode incoming ws message:", exception)
-                options.onerror(Error("can't decode incoming message:", exception))
-                return
-            }
-            options.onmessage(e, message)
-        }
-        
-        // onerror
-        // An error occurred on the WebSocket connection.
-        wsock.ws.onerror = closure onerror(e, local error) {
-            error = Error("websocket failed", e)
-            options.onerror(e, error)
-            pending.signal(list(error))                                     // ensure connect completes
-        }
-        
-        // onclose
-        // The WebSocket connection was closed.
-        wsock.ws.onclose = closure onclose(e) {
-            options.onclose(e, e.code, e.reason)
-            pending.signal(list(Error("connection closed")))                // ensure connect completes
-            wsock.ws = false
-        }
-        
-        pending.wait()
-    }
-  
-    // send
-    //
-    //     Send a message dictionary.
-    //
-    wsock.send = function send(message) {
-        wsock.ws.send(JSONstringify(message))
-    }
-        
-    // close
-    //
-    //     Close the connection.
-    //
-    wsock.close = function close(reason) {
-        if !reason
-            reason = 1000                                                   // normal close
-        wsock.ws.close(reason)
-    }
-
-    // finis
-
-    wsock
+    options = merge({
+        query: url.search || ''
+        wss: url.protocol == "https:"
+    }, options)
+    if options.wss
+        url = "wss://${url.host}${options.query}"
+    else
+        url = "ws://${url.host}${options.query}"
+    ws = xnew(window.WebSocket, url)
+    ws.onopen = options.onopen
+    ws.onmessage = options.onmessage
+    ws.onerror = options.onerror
+    ws.onclose = options.onclose
+    list(false, ws)
 };
 
 

package/frameworks/client/apiclient.nlg

@@ -19,7 +19,7 @@ serviceMod;;
 /*
  * APIClient
  *
- * Make an API client object.
+ * Make an API client object. If you want websockets, and you do, call connect() on the object.
  *
  * Options:
  *  {
@@ -46,18 +46,20 @@ closure APIClient(imp, options, local client, url, guid) {
     client.requester = clirRequester()
 
     //
-    // wsopen
+    // connect
     //
 
-    client.wsopen = function wsopen(error) {
-        if !client.wesc {
+    client.connect = function connect(error) {
+        if !client.wesc
             client.wesc = WebSocketClient(options, imp)
-            `(error) = client.wesc.connect()
-            if error
-                ErrorDebuglog("APIClient: cannot connect to", url)
+        `(error) = client.wesc.connect()
+        if error {
+            ErrorDebuglog("APIClient: cannot connect to", url, error)
+            return (list(error))
         }
+        client.serverID = client.wesc.serverID                              // serverID
+        list(false, { connected: true })
     }
-    wsopen()
 
     // clientRequest() - append our guid to the headers
 
@@ -178,10 +180,12 @@ closure APIClient(imp, options, local client, url, guid) {
     // Close down the client and release all resources.
     //
     client.destroy = closure destroy() {
-        debuglog("client destroy websocket")
+        debuglog("API client destroyed")                                    // ### not pretty, but uncommon
         client.wesc.destroy()
         client.wesc = false
     }
+    
+    // finis
 
     client
 };
@@ -197,104 +201,129 @@ closure APIClient(imp, options, local client, url, guid) {
  *  {
  *      url:            <string>                // hostname or URL of the remote server
  *      guid:           <string>                // shared secret for access to remote server
- *      instanceID:     <string>                // UUID for our client; can be persisted by caller
  *  }
  *
  */
 
-closure WebSocketClient(options, imp, local wesc, ws) {
+closure WebSocketClient(options, imp, local wesc, ws, pending) {
     global(js)
     wesc = new(object, this)
+    
+
+    // reconnect
+    //
+    // Attempt to reconnect if needed, returning false on success or an error tuple otherwise.
+    //
+    function reconnect() {
+        if !ws || wesc.fatal || pending {
+            connect()                                                       // try to connect
+            if wesc.fatal
+                return (list(wesc.fatal))
+        }
+        false
+    }
 
     // connect
     //
     // Establish a websocket connection with the host.
     //
-    wesc.connect = closure connect(local url, pending) {
-        if ws && !wesc.fatal
-            return(list(false, { connected: true }))
-        if wesc.fatal
-            debuglog("WebSocketClient reopen")
-        wesc.fatal = false
-        try {
-            url = xnew(js.w.URL, options.url)
-        } catch {
-            return(list(Error("invalid URL ${options.url}", exception)))
+    wesc.connect = closure connect(local url, result, error) {
+        if ws {
+            if pending
+                return (pending.wait())                                     // connect in process
+            if !wesc.fatal
+                return(list(false, { connected: true }))                    // already open
         }
-        if url.protocol == "https:"
-            url.protocol = "wss:"
-        else
-            url.protocol = "ws:"
-        ws = xnew(js.w.WebSocket, url.href)
-        pending = new(nonce)
-    
+
         // onopen
         // The WebSocket connection is now open.
-        ws.onopen = function onopen(e, local error) {
-            wesc.impconn = imp.requester(function(data) {
-                if wesc.fatal                                               // raw send function
-                    return (list(wesc.fatal))
-                ws.send(js.w.JSON.stringify(data))
+        function onopen(e) {
+            if wesc.impconn {
+                result = wesc.impconn.reopen()
+                pending.signal(result)
+                return
+            }
+            wesc.impconn = imp.requester(function(data, local error, text) {
+                if !pending && reconnect()                                  // !pending means not opening/reopening
+                    return                                                  // failed to reconnect
+                `(error, text) = JsonStringify(data)
+                if error
+                    return (list(error))
+                ws.send(text)
                 list(false, { sent: true })
             }, {
                 secret: options.guid
                 label: "api-server"
-                wesc: wesc
             })
-            if error
-                pending.signal(list(error))
-            else
+            wesc.impconn.addEventListener("active", function (event, info) {
+                wesc.serverID = info.destID                                 // serverID we connected to
                 pending.signal(list(false, { ok: true }))
+                pending = false
+            })
         }
-    
+
         // onmessage
         // A message was received via WebSockets.
-        ws.onmessage = function onmessage(e, local error, message) {
+        function onmessage(e, local error, message) {
             `(error, message) = JsonParse(e.data)
             if !error {
                 message = new(message)
                 if wesc.impconn.dispatch(message)
                     return
             }
-            debuglog("socket message:", e.data)
+            pending.signal(list(Error("incompatible responder")))
+            pending = false
+            debuglog("socket message:", e.data)                             // unexpected incoming data
         }
-    
+
         // onerror
         // An error occurred on the WebSocket connection.
         // This can happen in normal operation when the connection times out.
-        ws.onerror = function onerror(e) {
+        function onerror(e) {
             if !wesc.fatal
                 wesc.fatal = Error("websocket failed", e)
             pending.signal(list(wesc.fatal))
+            pending = false
         }
         
         // onclose
         // The WebSocket connection was closed.
-        ws.onclose = function onclose(e) {
+        function onclose(e) {
             // if e.code != 1000 && e.code != 1001 && e.code != 1005 && e.code != 1006
-                debuglog("WebSocketClient: closed:", e.code, e.reason)
+                debuglog("WebSocketClient: closed:", e.code, e.reason)      // ### not pretty to see this
             ws = false
             if !wesc.fatal
                 wesc.fatal = Error("websocket closed", e.code, e.reason)
             pending.signal(list(wesc.fatal))
-            wesc.impconn.close({
-                code: e.code
-                reason: e.reason
-            })
-            wesc.impconn = false
+            pending = false
         }
 
-        pending.wait()
+        `(error, ws) = call(clirWebsocket(), options.url, {
+            onopen: onopen.proc
+            onmessage: onmessage.proc
+            onerror: onerror.proc
+            onclose: onclose.proc
+        })
+        if error
+            return (list(wesc.fatal = error))                               // failed to even get started
+
+        if wesc.fatal
+            debuglog("WebSocketClient reopen")                              // ### not pretty to see this
+        wesc.fatal = false
+        pending = new(nonce)
+        result = pending.wait(10000, list(Error("IMP connection timeout")))
+        pending = false
+        result
     }
-    
+
     // close
     //
     // Close the connection, but can be opened again with connect().
     //
     wesc.close = function close() {
-        if !ws
-            return
-        ws.close(1000)                                                      // 1000: normal close
+        if ws
+            ws.close(1000)                                                  // 1000: normal close
+        ws = false
     }
     
     // destroy
@@ -303,23 +332,27 @@ closure WebSocketClient(options, imp, local wesc, ws) {
     //
     wesc.destroy = function destroy() {
         close()
+        wesc.impconn.destroy()
+        wesc.impconn = false
     }
 
     // send
     //
-    // Send a message.
+    // Send a message, returning result tuple.
     //
     wesc.send = closure send(data) {
-        if wesc.fatal
-            return (wesc.fatal)
+        if reconnect()
+            return                                                          // failed to reconnect
         wesc.impconn.send(data)
     }
 
     // sendRaw
     //
-    // Send a message with reconnect but no routing.
+    // Send a message with reconnect but no routing. Returns a result tuple.
     //
     wesc.sendRaw = closure sendRaw(data) {
+        if reconnect()
+            return                                                          // failed to reconnect
         ws.send(data)
     }
 

package/frameworks/client/client.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2020-2025 by Richard C. Zulch
+ * Copyright (c) 2020-2026 by Richard C. Zulch
  *
  */
 
@@ -31,6 +31,26 @@ function clirRequester() {
 };
 
 
+/*
+ * clirWebsocket
+ *
+ *     Return an appropriate Websocket client based on our environment.
+ *
+ */
+
+clirWebsocketApi = false;
+
+function clirWebsocket() {
+    if !clirWebsocketApi {
+        if js.w
+            clirWebsocketApi = require("naanlib:frameworks/browser/ws_client.nlg").WebSocket
+        else
+            clirWebsocketApi = require("naanlib:frameworks/node/ws_client.nlg").WebSocket
+    }
+    clirWebsocketApi
+};
+
+
 /*
  * clirInit
  *
@@ -40,7 +60,7 @@ function clirRequester() {
  */
 
 function clirInit(local manifest) {
-    manifest = `(clirRequester, clirInit)
+    manifest = `(clirRequester, clirWebsocket, clirInit)
 
     Naan.module.build(module.id, "client", function(modobj, compobj) {
         require("../common/").LiveImport()