edon 0.0.27

Library embedding Nodejs (libnode) within Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

void (function () {
  // This is a shim that adds in the functionality 
  // which will possibly be added into libnode later
  const { Worker } = require("node:worker_threads");

  const cjsWorker = /*javascript*/`
    const module = require("node:module");
    const process = require("node:process");
    const { parentPort, workerData } = require("node:worker_threads");

    let active = true;

    process
      ._linkedBinding("edon:worker")
      .onEvent(workerData, async (action, payload, done) => {
        if (!active) {
          // TODO return error
          // This shouldn't happen though it's nice just in case
          throw new Error("Context shutting down");
        }
        // Do each action asynchronously
        setTimeout(async () => {
          switch (action) {
            // NodejsWorkerEvent::Eval
            case 0: {
              done(eval(payload));
              break;
            }
            // NodejsWorkerEvent::EvalTypeScript
            case 1: {
              done(eval(module.stripTypeScriptTypes(payload)));
              break;
            }
            // NodejsWorkerEvent::Require
            case 2: {
              require(payload);
              done();
              break;
            }
            // NodejsWorkerEvent::Import
            case 3: {
              await import(payload);
              done();
              break;
            }
          }
        }, 0);
      });

    parentPort.once("message", async () => {
      active = false;
      process.stdout.end();
      process.stderr.end();
      parentPort.postMessage(null);
    });

    parentPort.postMessage(null);
  `

  const workers = {}

  // Handle requests from the host
  process
    ._linkedBinding("edon:main")
    .onEvent(async (action, payload, done) => {
      switch (action) {
        // NodejsMainEvent::StopMain
        case 0: {
          for (const worker of Object.values(workers)) {
            const onend = new Promise(res => worker.once('message', res))
            worker.postMessage(null)
            await onend
            const onclose = new Promise(res => worker.once('exit', res))
            await worker.terminate()
            await onclose
          }
          // Flush promises
          await new Promise(res => setTimeout(res, 0))
          done()
          break
        }  
        // NodejsMainEvent::Eval
        case 1: {
          done(eval(payload));
          break;
        }
        // NodejsMainEvent::EvalTypeScript
        case 2: {
          done(eval(module.stripTypeScriptTypes(payload)));
          break;
        }
        // NodejsMainEvent::Require
        case 3: {
          require(payload);
          done();
          break;
        }
        // NodejsMainEvent::Import
        case 4: {
          await import(payload);
          done();
          break;
        }
        // NodejsMainEvent::StartWorker
        case 5: {
          const [argv, tx_worker] = payload

          let worker = new Worker(cjsWorker, {
            argv,
            workerData: tx_worker,
            eval: true,
            stderr: true,
            stdout: true,
            stdin: false,
          })

          worker.ref()
          workers[worker.threadId] = worker
          worker.stdout.on('data', d => process.stdout.write(d))
          worker.stderr.on('data', d => process.stderr.write(d))

          await new Promise(res => worker.once('message', res))
          done(`${worker.threadId}`)
          break
        }
        // NodejsMainEvent::StopWorker
        case 6: {
          if (workers[payload]) {
            const onend = new Promise(res => workers[payload].once('message', res))
            workers[payload].postMessage(null)
            await onend
            await workers[payload].terminate()
            delete workers[payload]
          }
          done()
          break
        }        
      }
    });
})();