pinokiod 7.3.15 → 7.4.1

package/kernel/api/index.js

@@ -424,6 +424,9 @@ class Api {
     }
     this.running[id] = true
     this.done[id] = done
+    if (this.kernel && typeof this.kernel.markAppLaunchStarted === "function") {
+      this.kernel.markAppLaunchStarted(request.path)
+    }
   }
   isActionCandidate(action) {
     return (Array.isArray(action) && action.length > 0) || typeof action === "function"
@@ -509,6 +512,10 @@ class Api {
         let fullpath = path.resolve(cwd, ...args)
         return this.running[fullpath]
       },
+      ready: (...args) => {
+        let fullpath = path.resolve(cwd, ...args)
+        return this.kernel.isScriptReady(fullpath)
+      },
       name,
       self: script,
       port,
@@ -554,7 +561,7 @@ class Api {
     }
     return steps
   }
-  async stop(req, ondata) {
+  async stop(req, ondata, options = {}) {
     // 1. set the "stop" flag for the uri, so the next execution in the queue for the uri will NOT queue another task
     // 2. stream a message closing the socket
 
@@ -586,10 +593,11 @@ class Api {
 
 
     // stop all shell processes connected to the uri
-    if (req.params.id) {
-      this.kernel.shell.kill({ group: req.params.id })
-    } else {
-      this.kernel.shell.kill({ group: requestPath })
+    const stopGroups = new Set()
+    if (req.params.id) stopGroups.add(req.params.id)
+    stopGroups.add(requestPath)
+    for (const group of stopGroups) {
+      this.kernel.shell.kill({ group })
     }
 
     // if any process is in a "wait" state, resume it
@@ -608,12 +616,17 @@ class Api {
       this.waiter[requestPath].reject()
       delete this.waiter[requestPath]
     }
-    if (req.params.id) {
-      delete this.running[req.params.id]
-      delete this.kernel.memory.local[req.params.id]
-    } else {
-      delete this.running[requestPath]
-      delete this.kernel.memory.local[requestPath]
+    const stoppedKeys = new Set()
+    if (req.params.id) stoppedKeys.add(req.params.id)
+    stoppedKeys.add(requestPath)
+    for (const key of stoppedKeys) {
+      delete this.running[key]
+      delete this.kernel.memory.local[key]
+    }
+    if (this.kernel && typeof this.kernel.markAppLaunchStopped === "function") {
+      this.kernel.markAppLaunchStopped(requestPath, {
+        internal_completion: !!(options && options.internal_completion)
+      })
     }
     this.ondata({
       id: req.params.id || requestPath,
@@ -1083,6 +1096,10 @@ class Api {
         let fullpath = path.resolve(cwd, ...args)
         return this.running[fullpath]
       },
+      ready: (...args) => {
+        let fullpath = path.resolve(cwd, ...args)
+        return this.kernel.isScriptReady(fullpath)
+      },
       name,
       self: script,
       port,
@@ -1235,6 +1252,9 @@ class Api {
 
         this.kernel.memory.rpc[id].current = rpc.current
         this.kernel.memory.rpc[id].total = rpc.total
+        if (this.kernel && typeof this.kernel.markAppLaunchProgress === "function") {
+          this.kernel.markAppLaunchProgress(request.path, rpc.current, rpc.total)
+        }
 
 //        this.kernel.memory.rpc[request.path] = rpc
 //        this.kernel.memory.args[request.path] = args
@@ -1314,13 +1334,13 @@ class Api {
                     params: {
                       id: request.id
                     }
-                  })
+                  }, null, { internal_completion: true })
                 } else {
                   await this.stop({
                     params: {
                       uri: request.path
                     }
-                  })
+                  }, null, { internal_completion: true })
                 }
               }
               return { request, input: null, step: rpc.next, total: totalSteps, args }
@@ -1545,13 +1565,13 @@ class Api {
                   params: {
                     id: request.id
                   }
-                })
+                }, null, { internal_completion: true })
               } else {
                 await this.stop({
                   params: {
                     uri: request.path
                   }
-                })
+                }, null, { internal_completion: true })
               }
               return { request, input: result, step: rpc.next, total: totalSteps, args }
             }
@@ -1631,6 +1651,9 @@ class Api {
             this.queue(response.request, response.rawrpc, response.input, response.step, response.total, cwd, args)
           } else {
             let id = response.request.id || response.request.path
+            if (this.kernel && typeof this.kernel.markAppLaunchReady === "function") {
+              this.kernel.markAppLaunchReady(response.request.path)
+            }
             if (response.request.caller) {
               if (this.done[response.request.path]) {
                 this.done[response.request.path]({
@@ -1655,6 +1678,9 @@ class Api {
 //        this.kernel.refresh(true)
       } catch (e) {
         this.clearResolvedAction(request)
+        if (this.kernel && typeof this.kernel.markAppLaunchFailed === "function") {
+          this.kernel.markAppLaunchFailed(request.path, e)
+        }
         ondata({ raw: e.toString() })
       }
     }, concurrency)
@@ -1838,8 +1864,72 @@ class Api {
 
           // 3. Check if the resolved endpoint has the requested action attribute and resolve it to steps.
           if (this.isActionCandidate(action)) {
+            const emitLaunchRequirementsControl = (result) => {
+              if (!result || !result.action || result.action === "continue") {
+                return
+              }
+              this.ondata({
+                id: request.id || request.path,
+                type: "launch.requirements.control",
+                data: result
+              })
+            }
+            let launchOperation = null
+            const releaseLaunchOperation = () => {
+              if (launchOperation && this.kernel && typeof this.kernel.endLaunchOperation === "function") {
+                this.kernel.endLaunchOperation(launchOperation)
+              }
+              launchOperation = null
+            }
+            const shouldCheckLaunchRequirements = !request.skip_requirements &&
+              this.kernel &&
+              typeof this.kernel.ensureLaunchRequirements === "function" &&
+              (typeof this.kernel.hasLaunchRequirementConfig === "function"
+                ? await this.kernel.hasLaunchRequirementConfig(request.path)
+                : true)
+            if (shouldCheckLaunchRequirements && request.path && this.kernel && typeof this.kernel.beginLaunchOperation === "function") {
+              launchOperation = this.kernel.beginLaunchOperation(request.path, { request })
+            }
+            if (shouldCheckLaunchRequirements) {
+              let requirementResult
+              try {
+                requirementResult = await this.kernel.ensureLaunchRequirements(request.path, {
+                  request,
+                  owner: launchOperation
+                })
+              } catch (e) {
+                releaseLaunchOperation()
+                if (e && (e.cancelled || e.blocked_reason)) {
+                  const control = {
+                    action: e.cancelled ? "cancelled" : "blocked",
+                    app_id: e.app_id || "",
+                    reason: e.blocked_reason || ""
+                  }
+                  emitLaunchRequirementsControl(control)
+                  return {
+                    request,
+                    launch_requirements: control
+                  }
+                }
+                this.ondata({
+                  id: request.id || request.path,
+                  type: "error",
+                  data: e && e.stack ? e.stack : String(e || "Launch requirements failed"),
+                })
+                return
+              }
+              if (requirementResult && requirementResult.action && requirementResult.action !== "continue") {
+                releaseLaunchOperation()
+                emitLaunchRequirementsControl(requirementResult)
+                return {
+                  request,
+                  launch_requirements: requirementResult
+                }
+              }
+            }
 
             this.setRunning(request, done)
+            releaseLaunchOperation()
 
             // set DNS
 
@@ -1865,6 +1955,9 @@ class Api {
             } catch (e) {
               this.clearResolvedAction(request)
               delete this.running[this.requestId(request)]
+              if (this.kernel && typeof this.kernel.markAppLaunchFailed === "function") {
+                this.kernel.markAppLaunchFailed(request.path, e)
+              }
               this.ondata({
                 id: request.id || request.path,
                 type: "error",
@@ -1876,6 +1969,9 @@ class Api {
             if (!Array.isArray(steps) || steps.length === 0) {
               this.clearResolvedAction(request)
               delete this.running[this.requestId(request)]
+              if (this.kernel && typeof this.kernel.markAppLaunchFailed === "function") {
+                this.kernel.markAppLaunchFailed(request.path, new Error(`missing or invalid attribute: ${actionKey}`))
+              }
               this.ondata({
                 id: request.id || request.path,
                 type: "error",

package/kernel/api/script/index.js

@@ -160,6 +160,16 @@ class Script {
       ondata({ raw: `\r\nStopped ${uri}\r\n` })
     }
   }
+  async ready(req, ondata, kernel) {
+    const params = req && req.params
+    let uri = this.currentPath(req)
+    if (typeof params === "string") {
+      uri = params
+    } else if (params && typeof params === "object") {
+      uri = params.uri || params.path || params.script || uri
+    }
+    return kernel.isScriptReady(kernel.resolveReadyScriptPath(uri, req && req.cwd))
+  }
   async run(req, ondata, kernel) {
     /*
       {

package/kernel/autolaunch.js

@@ -0,0 +1,111 @@
+const path = require('path')
+const Environment = require('./environment')
+
+class Autolaunch {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.kernel.autolaunch_status = this.startupStatus()
+  }
+  startupStatus() {
+    return this.kernel.launchRequirements && typeof this.kernel.launchRequirements.startupHomeStatus === "function"
+      ? this.kernel.launchRequirements.startupHomeStatus()
+      : (this.kernel.autolaunch_status || { running: false, apps: {} })
+  }
+  setStatus(status) {
+    const nextStatus = this.kernel.launchRequirements && typeof this.kernel.launchRequirements.replaceStartupHomeStatus === "function"
+      ? this.kernel.launchRequirements.replaceStartupHomeStatus(status)
+      : status
+    this.kernel.autolaunch_status = nextStatus
+    return nextStatus
+  }
+  async collectCandidates() {
+    const apis = this.kernel.i && Array.isArray(this.kernel.i.api) ? this.kernel.i.api : []
+    const candidates = []
+    for (const api of apis) {
+      if (!api || !api.path) {
+        continue
+      }
+      const envPath = path.resolve(this.kernel.api.userdir, api.path)
+      const env = await Environment.get(envPath, this.kernel)
+      const script = Environment.getScriptAutolaunch(env)
+      if (!script || !Environment.getScriptAutolaunchEnabled(env)) {
+        continue
+      }
+      const autolaunchPath = path.resolve(this.kernel.api.userdir, api.path, script)
+      const exists = !!(autolaunchPath && await this.kernel.exists(autolaunchPath))
+      const dependencies = Environment.getScriptRequirements(env)
+      candidates.push({
+        id: api.path,
+        title: api.title || api.path,
+        script,
+        autolaunchPath,
+        dependencies,
+        exists
+      })
+    }
+    return candidates
+  }
+  async runScheduler() {
+    const startedAt = Date.now()
+    const candidates = await this.collectCandidates()
+    const status = this.kernel.launchRequirements && typeof this.kernel.launchRequirements.seedStartupHomeStatus === "function"
+      ? await this.kernel.launchRequirements.seedStartupHomeStatus(candidates, startedAt)
+      : this.setStatus({
+          running: true,
+          started_at: startedAt,
+          apps: {}
+        })
+    this.kernel.autolaunch_status = status
+    for (const candidate of candidates) {
+      if (!status.apps[candidate.id]) {
+        status.apps[candidate.id] = {
+          id: candidate.id,
+          title: candidate.title,
+          script: candidate.script,
+          launch_path: candidate.autolaunchPath,
+          state: "pending",
+          dependencies: candidate.dependencies,
+          waiting_for: candidate.dependencies,
+          startup_root: true
+        }
+      }
+      if (!candidate.exists) {
+        status.apps[candidate.id].state = "blocked"
+        status.apps[candidate.id].blocked_reason = candidate.script ? "Launch script does not exist" : "No launch script selected"
+        status.apps[candidate.id].waiting_for = []
+      }
+      status.apps[candidate.id].startup_root = true
+    }
+    const launchable = candidates.filter((candidate) => {
+      const row = status.apps[candidate.id]
+      if (!row || !candidate.exists) {
+        if (!candidate.exists) {
+          console.log("SCRIPT DOES NOT EXIST. Ignoring.", candidate.autolaunchPath)
+        }
+        return false
+      }
+      return row.state !== "blocked"
+    })
+    await Promise.all(launchable.map((candidate) => {
+      return this.kernel.api.process({
+        uri: candidate.autolaunchPath,
+        input: {},
+        startup: true
+      }).catch((err) => {
+        console.warn('[Kernel.init] startup process failed:', err && err.message ? err.message : err)
+        const row = status.apps[candidate.id]
+        if (row && row.state !== "ready") {
+          delete status.apps[candidate.id]
+        }
+      })
+    }))
+    status.running = false
+    status.completed_at = Date.now()
+    setTimeout(() => {
+      this.kernel.launch_complete = true
+      console.log("SETTING launch complete", this.kernel.launch_complete)
+    }, 2000)
+  }
+}
+
+module.exports = Autolaunch