@naanlang/naan 1.5.0 → 1.7.0

package/frameworks/running/executors.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2020-2024 by Richard C. Zulch
+ * Copyright (c) 2020-2026 by Richard C. Zulch
  *
  */
 
@@ -65,7 +65,7 @@ closure ExecutorBase(track, type, name, local exec) {
                 exec.reverseDispatch = require("./taskexec.nlg").TaskDispatcher(function(data) {
                     data.reverse = true
                     exec.PostMessage(data)
-                }, exec.contexts[data.contextID].coder)
+                }, exec.contexts[data.contextID].coder, "execReceived")
             data.reverse = false
             exec.reverseDispatch(data)
             return
@@ -73,7 +73,7 @@ closure ExecutorBase(track, type, name, local exec) {
         pending = exec.pending[data.xid]
         if !pending {                                                       // not waiting on message
             if data.xmsg == "xready"
-                exec.pending.ready = true
+                exec.inst_ready = true
             if data.xmsg == "xattention"
                 { }
             return
@@ -99,7 +99,7 @@ closure ExecutorBase(track, type, name, local exec) {
     // Communication has failed.
     //
     exec.execFailed = closure execFailed(error, local xid, pending) {
-        exec.pending.error = error
+        exec.inst_error = error
         for `(xid, pending) in exec.pending
             pending.signal(list(error))
     }
@@ -112,7 +112,7 @@ closure ExecutorBase(track, type, name, local exec) {
     exec.execClosed = closure execClosed(error, local xid, pending) {
         for `(xid, pending) in exec.pending {
             pending.signal(list(error))
-            pending[xid] = undefined
+            exec.pending[xid] = undefined
         }
     }
         
@@ -127,7 +127,7 @@ closure ExecutorBase(track, type, name, local exec) {
         retries = 0
         ms = milliseconds()
         delta = 1
-        while !exec.pending.ready {
+        while !exec.inst_ready {
             `(error) = exec.PostMessage({
                 xmsg: "xstart"
             })
@@ -135,8 +135,8 @@ closure ExecutorBase(track, type, name, local exec) {
                 return (Error("exec.context failed", error))
             if ++retries > 100
                 return (list(Error("timeout creating remote context", type, name)))
-            if exec.pending.error
-                return (list(Error("cannot create remote context", exec.pending.error)))
+            if exec.inst_error
+                return (list(Error("cannot create remote context", exec.inst_error)))
             sleep(delta)
             if delta < 100
                 delta *= 2 }
@@ -338,7 +338,7 @@ closure ExecutorContext(exec, state, coder, local context, util) {
  *
  */
 
-closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crValue) {
+closure ExecutorParallel(track, options, local maxcount, parallel, state, exqueue, crValue) {
     global()
     options = merge({
         spawnLoc: "Local"
@@ -348,9 +348,10 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
     maxcount = options.maxcount
     exqueue = []                                                            // waiting for execution
     parallel = new(object, this)
-    parallel.workers = []                                                   // array of worker executors
+    parallel.state = state = new(nonce)                                     // volatile state
     parallel.contexts = new(weakmap)                                        // map workers to contexts
-    parallel.available = []                                                 // array of available workers
+    state.workers = []                                                      // array of worker executors
+    state.available = []                                                    // array of available workers
 
     // acquireWorker
     //
@@ -359,31 +360,31 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
     // returns { wait: true }.
     
     closure acquireWorker(local workdex, name, worker, context, result) {
-        if parallel.available.length > 0
-            return (list(false, parallel.available.pop()))
-        workdex = parallel.workers.length
+        if state.available.length > 0
+            return (list(false, state.available.pop()))
+        workdex = state.workers.length
         if workdex >= maxcount
             return (list(false, { wait: true }))
-        parallel.workers[workdex] = false                                   // reserve our spot
+        state.workers[workdex] = false                             // reserve our spot
         name = options.basename.concat("-", workdex+1)
         worker = track.spawn(options.spawnLoc, name, {
             workerID: "ExecutorParallel"
         })
         if worker.0 {
-            parallel.workers.splice(workdex, 1)
+            state.workers.splice(workdex, 1)
             debuglog("execParallel: cannot spawn worker:", ErrorString(worker.0))
             return (list(worker.0))
         }
         worker = worker.1
         context = worker.context()
         if context.0 {
-            parallel.workers.splice(workdex, 1)
+            state.workers.splice(workdex, 1)
             worker.destroy()
             debuglog("execParallel: cannot create worker context:", ErrorString(context.0))
             return (list(context.0))
         }
         context = context.1
-        parallel.workers[workdex] = worker
+        state.workers[workdex] = worker
         parallel.contexts[worker] = context
         if tuple(options.initeval) {
             result = apply(context.eval, options.initeval)
@@ -398,7 +399,7 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
     // Release the specified worker to the pool.
     
     closure releaseWorker(worker) {
-        parallel.available.push(worker)
+        state.available.push(worker)
     }
 
     // execNext
@@ -414,7 +415,7 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
         if exqueue.length > 0 {
             `(error, worker) = acquireWorker()
             if error {
-                if maxcount > 0 && parallel.workers.length == 0 {
+                if maxcount > 0 && state.workers.length == 0 {
                     exqueue = []
                     throw("execParallel: cannot allocate any workers at all") }
                 return                                                      // one failed, so try again later
@@ -448,8 +449,10 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
     //
 
     parallel.eval = closure evalf(expr, put, get, local pending) {
-        if maxcount == 0
+        if maxcount == 0 || !parallel.state {
+            destroy(list(Error("volatile execution terminated")))           // in case of no state
             return (crValue)                                                // already destroyed
+        }
         pending = new(nonce)
         exqueue.push({
             eval: list(expr, put, get)
@@ -516,8 +519,10 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
     //
     
     parallel.rpc = closure rpc(proc, args, local pending) {
-        if maxcount == 0
+        if maxcount == 0 || !parallel.state {
+            destroy(list(Error("volatile execution terminated")))           // in case of no state
             return (crValue)                                                // already destroyed
+        }
         pending = new(nonce)
         exqueue.push({
             proc: proc
@@ -539,11 +544,11 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
 
     parallel.status = function status(local output, worker) {
         output = []
-        for worker in parallel.workers {
+        for worker in state.workers {
             output.push({
                 name: worker.name
                 type: worker.type
-                state: if parallel.available.indexOf(worker) >= 0
+                state: if state.available.indexOf(worker) >= 0
                     "idle" else "active"
                 status: worker.xstatus
             })
@@ -561,13 +566,13 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
             return (false)                                                  // already destroyed
         crValue = cancelResult
         maxcount = 0
-        parallel.available = false
-        parallel.contexts = false
-        while parallel.workers.length > 0 {
-            worker = parallel.workers.pop()
+        while state.workers.length > 0 {
+            worker = state.workers.pop()
             parallel.contexts[worker] = false
             worker.destroy()
         }
+        state.available = false
+        parallel.contexts = false
         while exqueue.length > 0 {
             next = exqueue.pop()
             next.pending.signal(crValue)
@@ -584,7 +589,7 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
 /*
  * ExecutorTracker
  *
- *     Track Naan execution instances.
+ * Track Naan execution instances.
  *
  */
 
@@ -599,8 +604,10 @@ closure ExecutorTracker(local xtrak) {
     // Notify the watchers by calling a named procedure
     
     closure notify(changes, local watch) {
-        for watch in xtrak.watchers
-            call(watch, changes)
+        future(function(){
+            for watch in xtrak.watchers
+                call(watch, changes)
+        }, 10)
     }
 
     // add
@@ -667,7 +674,7 @@ closure ExecutorTracker(local xtrak) {
     // register
     // Register an executor type.
     
-    xtrak.register = function register(maker, type) {
+    xtrak.register = function register(type, maker) {
         xtrak.makers[type] = maker
     }
     
@@ -690,262 +697,11 @@ closure ExecutorTracker(local xtrak) {
         ExecutorParallel(xtrak, options)
     }
     
-    xtrak.register(execLambda, "Lambda")
-    
     // finis
     xtrak
 };
 
 
-/*
- * execLambda
- *
- *     Make a Lambda executor connected through web sockets.
- *
- */
-
-closure execLambda(track, url, name, workerID, local target, nlregex, clientID, serverID) {
-    global(js)
-    target = ExecutorBase(track, "Lambda", name)
-    clientID = "DebugWorkers"
-    serverID = "Workers"
-    nlregex = RegExp("\\n", "g")
-    if !workerID
-        workerID = "myAwsDebugWorker"
-    target.workerID = workerID
-    target.msgQueue = []
-    
-    // connect
-    // Connect with the host if not already connected.
-    function connect() {
-        if !target.ws
-            target.ws = xnew(js.w.WebSocket, "wss://8h5htw8bfj.execute-api.us-east-1.amazonaws.com/dev")
-    
-        // onopen
-        // The WebSocket connection is now open.
-        target.ws.onopen = function onopen(e) {
-            target.msgCounter = 1
-            sendControl("spawn", {
-                reset: true
-                options: {
-                }
-            })
-        }
-
-        // onmessage
-        // A message was received from the worker via WebSockets.
-        
-        target.ws.onmessage = function onmessage(e) {
-            if target.msgQueue
-                target.msgQueue.push(e.data)
-            else
-                target.doMessage(e.data)
-        }
-        
-        // onerror
-        // An error occurred on the WebSocket connection.
-        target.ws.onerror = function onerror(e) {
-            target.debugWrite("connection error: ".concat(e.toString()), 3)
-        }
-        
-        // onclose
-        // The WebSocket connection was closed.
-        target.ws.onclose = function onclose(e) {
-            target.debugWrite("connection closed: ".concat(e.code, " ", e.reason), 3)
-            target.ws = false
-        }
-    }
-    
-    //
-    // doOneMessage
-    //
-    //     Process the specified undecoded message.
-    function doOneMessage(message, local msg) {
-        if message.respOp == "msgarray" {
-            for msg in message.payload
-                doOneMessage(msg)
-        } else if message.respOp == "msgout" {
-            msg = message.payload
-            if msg.id == "textout" {
-                target.written = true
-                target.term.Write(msg.text.replace(nlregex, "\r\n")) }
-            else if msg.id == "debugtext" {
-                target.written = true
-                target.debugWrite(msg.text, msg.level) }
-            else if msg.id == "msgout"
-                target.listener(msg.data)
-            else if msg.id == "started"
-                { }
-            else if msg.id == "typed"
-                target.term.Write(msg.text.replace(nlregex, "\r\n"))
-            else if msg.id == "status"
-                target.statusCB(target, msg.status)
-            else
-                debuglog("unknown AWS worker message:", msg.id)
-        } else if message.respOp == "error"
-            debuglog("worker controller error:", ErrorString(message.payload[0]))
-        else if message.respOp == "linked"
-            future(function termLinked(){
-                if !target.written
-                    target.term.WriteLn("(reconnected)")
-            }, 1000).run()
-        else
-            debuglog("unknown AWS response message:", message.respOp)
-    }
-        
-    //
-    // doMessage
-    //
-    //     Process the specified undecoded message.
-    target.doMessage = function doMessage(text, local message) {
-        try {
-            message = new(js.w.JSON.parse(text))
-            if message.connectionId && string(message.message)
-                target.debugWrite("AWS response: ".concat(message.message), 3)
-            else if message.clientID != clientID || message.serverID != serverID || message.workerID != target.workerID
-                debuglog("AWS response doesn't match:", message.clientID, message.serverID, message.workerID)
-            else
-                doOneMessage(message)
-        } catch {
-            if true
-                return (debuglog("can't decode incoming ws message:", exception))
-        }
-    }
-
-    //
-    // sendControl
-    //
-    //     Send a message to the worker controller.
-
-    target.sendControl = function sendControl(workerOp, payload) {
-        target.ws.send(js.w.JSON.stringify({
-            clientID: clientID
-            serverID: serverID
-            workerID: target.workerID
-            workerOp: workerOp
-            payload: payload
-            msgCounter: target.msgCounter++
-        }))
-    }
-    
-    //
-    // send
-    //
-    //     Send a message to the worker.
-    
-    target.send = function send(msg) {
-        // msg.save = true                                                  // save state for this invocation
-        sendControl("msgin", msg)
-    }
-
-    //
-    // oninterrupt
-    //
-
-    function oninterrupt() {
-        send({                                                              // send interrupt to worker
-            id: "interrupt"
-        })
-    }
-
-    //
-    // onreturn
-    //
-
-    function onreturn(local text) {
-        text = target.term.TakeText()
-        send({                                                              // send user-entered text to worker
-            id: "keyline",
-            text: text,
-            typed: "\x1b[90m\x1b[3m".concat(text, "\x1b[0m\n")              // dark-grey, italic
-        })
-    }
-
-    //
-    // target.PostMessage
-    //
-    //     Post a message to the target.
-    //
-
-    target.PostMessage = function PostMessage(data, local result) {
-        result = connect()
-        if result.0
-            return (result)
-        target.ws.send({                                                    // send user-entered text to worker
-            id: "msgin",
-            data: data
-        })
-        list(false, { posted: true })
-    }
-    
-    //
-    // target.debugWrite
-    //
-    //     Write a debug message to the repl.
-    //
-    
-    target.debugWrite = function(text, level) {
-        if (level >= 5)
-            target.term.WriteLn(text, target.term.Cyan)                     // cyan for builtin logging
-        else if (level >= 4)
-            target.term.WriteLn(text, target.term.Blue)                     // blue for Naan function logging
-        else if (level >= 3)
-            target.term.WriteLn(text, target.term.Red)                      // light red for warnings
-        else if (level >= 2)
-            target.term.WriteLn(text, target.term.Green)                    // green for Naan.debug.debuglog logging
-        else
-            target.term.WriteLn(text, target.term.Red+target.term.Bold)     // heavy red for errors
-    }
-
-    //
-    // termAttach
-    //
-    //     A terminal was attached to our instance.
-    
-    target.termAttach = function termAttach(repl, db, statusCB, local msg) {
-        connect()                                                           // ensure we are connected
-        target.term = repl
-        target.debugger = db
-        target.statusCB = statusCB
-        if target.termSaved {
-            target.term.StateLoad(target.termSaved)
-            target.termSaved = false }
-        else
-            target.term.Reset()
-        while target.msgQueue.length > 0 {
-            for msg in target.msgQueue.splice(0)                            // all current messages
-                target.doMessage(msg)
-        }
-        target.msgQueue = false
-        target.term.On("interrupt", oninterrupt.proc)
-        target.term.On("return", onreturn.proc)
-        target.term.Focus()
-    }
-        
-    //
-    // termDetach
-    //
-    //     The terminal is being deattached from our instance.
-    
-    target.termDetach = function termDetach(repl) {
-        target.term.On("interrupt")
-        target.term.On("return")
-        target.msgQueue = []
-        target.termSaved = target.term.StateSave()
-        target.statusCB = false
-        target.debugger = false
-        target.term = false
-    }
-    
-    track.add(target)
-    connect()                                                               // connect right away to start receiving messages
-
-    // finis
-
-    list(false, target)
-};
-
-
 /*
  * execInit
  *
@@ -954,8 +710,7 @@ closure execLambda(track, url, name, workerID, local target, nlregex, clientID,
  */
 
 function execInit(local manifest) {
-    manifest = `(ExecutorBase, ExecutorContext, ExecutorParallel, ExecutorTracker, execLambda,
-        execInit)
+    manifest = `(ExecutorBase, ExecutorContext, ExecutorParallel, ExecutorTracker, execInit)
 
     Naan.module.build(module.id, "executors", function(modobj, compobj) {
         require("./running.nlg")