@naanlang/naan 1.4.4 → 1.6.0

package/frameworks/node/ws_client.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2023-2024 by Richard C. Zulch
+ * Copyright (c) 2023-2026 by Richard C. Zulch
  *
  */
 
@@ -13,7 +13,7 @@
 /*
  * WebSocket
  *
- * Create a WebSocket client connection object using the existing HTTPS connection.
+ * Create a WebSocket client connection object.
  *
  * Required:
  *      host:       <string>                    // host:port

package/frameworks/project/build.nlg

@@ -1217,7 +1217,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
             error = Error("Builder: cannot read main file", error)
         else {
             `(error, executor) = track.spawn(build.runway.spawn.0, "${rules.name} ${build.version}", {
-                workerID: "Run-${build.buildnum}"
+                workerID: "Run-${build.version}+${build.buildnum}"
                 startup: {
                     initcmds: maintext
                     dirpath: fs.path.resolve("/", fs.rootpath, build.destpath)

package/frameworks/project/projects.nlg

@@ -296,7 +296,7 @@ closure projConnector(projman, projtype, local connector, watch) {
  *
  * Nide.proj/
  *      nide_cliser.cfg                 - JSON definition of the project (see below)
- *      NaanIDE_version.txt             - [default] substitution file defining 1.4.4+1 etc.
+ *      NaanIDE_version.txt             - [default] substitution file defining 1.6.0+1 etc.
  *      NaanIDE_version_builds.txt      - [default] contains current build number as decimal string
  *      build/                          - [optional] default build output location
  *      NaanIDE.lic                     - [optional] defines Zulch Laboratories, Inc. and other license info
@@ -692,6 +692,7 @@ closure projConfig(projman, where, projID, local procon, fs, configpath) {
             erase: true
             overwrite: true
             follow: true
+            cacheControl: publish.cacheControlFiles
         })
     }
 

package/frameworks/running/debugnub.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2021-2024 by Richard C. Zulch
+ * Copyright (c) 2021-2026 by Richard C. Zulch
  *
  */
 
@@ -33,7 +33,6 @@ closure DebugNub(local nub, debug, paused) {
     nub.codemgr = CodeManager()
     nub.exenable = true
     nub.watches = []
-    nub.contIDs = new(weakmap)
     nub.stacks = { }
     nub.usage = { }
 
@@ -405,8 +404,17 @@ closure DebugNub(local nub, debug, paused) {
     // Get the location of a procdef.
     
     nub.procLoc = function procLoc(procdef, task, local comp, position) {
-        if !task
+        if !task {
+            if nub.procLocs[procdef]
+                return                                                      // use the cached value
             task = rrrest(procdef)
+            if task {
+                if !nub.procLocs
+                    nub.procLocs = new(weakmap)                             // make sure we have a weakmap
+                nub.procLocs[procdef] = procLoc(procdef, task)              // cache a new location
+                return
+            }
+        }
         comp = nub.codemgr.procComponent(procdef)
         position = comp.textpos(procdef, task)
         {
@@ -424,8 +432,11 @@ closure DebugNub(local nub, debug, paused) {
     
     nub.getContID = function getContID(cont, local contID, frames) {
         contID = nub.contIDs[cont]
-        if !contID
+        if !contID {
+            if !nub.contIDs
+                nub.contIDs = new(weakmap)                                  // make sure we have a weakmap
             nub.contIDs[cont] = contID = UUID()
+        }
         frames = cont.stacktrace().toarray
         if frames.slice(-1).0 == `interrupt
             frames.pop()
@@ -580,6 +591,8 @@ closure DebugNub(local nub, debug, paused) {
             frames = new(nub.stacks[contID])
         else
             frames = new(debug.frames)
+        if !array(frames)
+            return (false)                                                  // invalid frames array
         loop {
             if frames.length == 0
                 break

package/frameworks/running/executors.nlg

@@ -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,10 +566,10 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
             return (false)                                                  // already destroyed
         crValue = cancelResult
         maxcount = 0
-        parallel.available = false
+        state.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()
         }
@@ -584,7 +589,7 @@ closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crVa
 /*
  * ExecutorTracker
  *
- *     Track Naan execution instances.
+ * Track Naan execution instances.
  *
  */
 
@@ -667,7 +672,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 +695,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 +708,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")