[taler-wallet-core] 01/03: splitting syncWorker with the factory so the former do not require nodejs runtime

[gnunet]

This is an automated email from the git hooks/post-receive script.

sebasjm pushed a commit to branch master
in repository wallet-core.

commit bf0cb6ab135c2a6d58a0684c17a565ed8422d5a4
Author: Sebastian <sebasjm@gmail.com>
AuthorDate: Sun Jan 16 17:33:21 2022 -0300

    splitting syncWorker with the factory so the former do not require nodejs 
runtime
---
 .../src/crypto/workers/cryptoImplementation.ts     |  63 +++-------
 .../src/crypto/workers/synchronousWorker.ts        | 130 +--------------------
 ...ronousWorker.ts => synchronousWorkerFactory.ts} | 123 +++----------------
 packages/taler-wallet-core/src/index.ts            |   1 +
 4 files changed, 34 insertions(+), 283 deletions(-)

diff --git 
a/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts 
b/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts
index f9dcc649..bff2e0eb 100644
--- a/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts
+++ b/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts
@@ -25,54 +25,24 @@
  */
 
 // FIXME: Crypto should not use DB Types!
-import { DenominationRecord, WireFee } from "../../db.js";
-
 import {
-  buildSigPS,
-  CoinDepositPermission,
-  DenomKeyType,
-  ExchangeProtocolVersion,
-  FreshCoin,
-  hashDenomPub,
-  RecoupRefreshRequest,
+  AmountJson, Amounts, BenchmarkResult, buildSigPS,
+  CoinDepositPermission, createEddsaKeyPair, createHashContext, decodeCrock,
+  DenomKeyType, DepositInfo, eddsaGetPublic, eddsaSign, eddsaVerify,
+  encodeCrock, ExchangeProtocolVersion,
+  FreshCoin, hash, hashDenomPub, kdf, keyExchangeEcdheEddsa,
+  // Logger,
+  MakeSyncSignatureRequest, PlanchetCreationRequest, PlanchetCreationResult,
+  randomBytes, RecoupRefreshRequest,
   RecoupRequest,
-  RefreshPlanchetInfo,
-  TalerSignaturePurpose,
-} from "@gnu-taler/taler-util";
-// FIXME: These types should be internal to the wallet!
-import {
-  BenchmarkResult,
-  PlanchetCreationResult,
-  PlanchetCreationRequest,
-  DepositInfo,
-  MakeSyncSignatureRequest,
-} from "@gnu-taler/taler-util";
-import { AmountJson, Amounts } from "@gnu-taler/taler-util";
-import * as timer from "../../util/timer.js";
-import {
-  encodeCrock,
-  decodeCrock,
-  createEddsaKeyPair,
-  hash,
-  rsaBlind,
-  eddsaVerify,
-  eddsaSign,
-  rsaUnblind,
-  stringToBytes,
-  createHashContext,
-  keyExchangeEcdheEddsa,
-  setupRefreshPlanchet,
-  rsaVerify,
+  RefreshPlanchetInfo, rsaBlind, rsaUnblind, rsaVerify, setupRefreshPlanchet,
   setupRefreshTransferPub,
   setupTipPlanchet,
-  setupWithdrawPlanchet,
-  eddsaGetPublic,
+  setupWithdrawPlanchet, stringToBytes, TalerSignaturePurpose, Timestamp, 
timestampTruncateToSecond
 } from "@gnu-taler/taler-util";
-import { randomBytes } from "@gnu-taler/taler-util";
-import { kdf } from "@gnu-taler/taler-util";
-import { Timestamp, timestampTruncateToSecond } from "@gnu-taler/taler-util";
-
-import { Logger } from "@gnu-taler/taler-util";
+import bigint from "big-integer";
+import { DenominationRecord, WireFee } from "../../db.js";
+import * as timer from "../../util/timer.js";
 import {
   CreateRecoupRefreshReqRequest,
   CreateRecoupReqRequest,
@@ -80,11 +50,10 @@ import {
   DerivedTipPlanchet,
   DeriveRefreshSessionRequest,
   DeriveTipRequest,
-  SignTrackTransactionRequest,
+  SignTrackTransactionRequest
 } from "../cryptoTypes.js";
-import bigint from "big-integer";
 
-const logger = new Logger("cryptoImplementation.ts");
+// const logger = new Logger("cryptoImplementation.ts");
 
 function amountToBuffer(amount: AmountJson): Uint8Array {
   const buffer = new ArrayBuffer(8 + 4 + 12);
@@ -161,7 +130,7 @@ async function myEddsaSign(
 export class CryptoImplementation {
   static enableTracing = false;
 
-  constructor(private primitiveWorker?: PrimitiveWorker) {}
+  constructor(private primitiveWorker?: PrimitiveWorker) { }
 
   /**
    * Create a pre-coin of the given denomination to be withdrawn from then 
given
diff --git a/packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts 
b/packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts
index 9de28dbe..4d341718 100644
--- a/packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts
+++ b/packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts
@@ -14,135 +14,16 @@
  GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
  */
 
+import { Logger } from "@gnu-taler/taler-util";
 import {
   CryptoImplementation,
-  PrimitiveWorker,
+  PrimitiveWorker
 } from "./cryptoImplementation.js";
 
-import { CryptoWorkerFactory } from "./cryptoApi.js";
-import { CryptoWorker } from "./cryptoWorkerInterface.js";
 
-import child_process from "child_process";
-import type internal from "stream";
-import { OpenedPromise, openPromise } from "../../index.js";
-import { j2s, Logger } from "@gnu-taler/taler-util";
 
 const logger = new Logger("synchronousWorker.ts");
 
-class MyPrimitiveWorker implements PrimitiveWorker {
-  proc: child_process.ChildProcessByStdio<
-    internal.Writable,
-    internal.Readable,
-    null
-  >;
-  requests: Array<{
-    p: OpenedPromise<any>;
-    req: any;
-  }> = [];
-
-  constructor() {
-    const stdoutChunks: Buffer[] = [];
-    this.proc = child_process.spawn("taler-crypto-worker", {
-      //stdio: ["pipe", "pipe", "inherit"],
-      stdio: ["pipe", "pipe", "inherit"],
-      detached: true,
-    });
-    this.proc.on("close", function (code) {
-      logger.error("child process exited");
-    });
-    (this.proc.stdout as any).unref();
-    (this.proc.stdin as any).unref();
-    this.proc.unref();
-
-    this.proc.stdout.on("data", (x) => {
-      // console.log("got chunk", x.toString("utf-8"));
-      if (x instanceof Buffer) {
-        const nlIndex = x.indexOf("\n");
-        if (nlIndex >= 0) {
-          const before = x.slice(0, nlIndex);
-          const after = x.slice(nlIndex + 1);
-          stdoutChunks.push(after);
-          const str = Buffer.concat([...stdoutChunks, before]).toString(
-            "utf-8",
-          );
-          const req = this.requests.shift()!;
-          if (this.requests.length === 0) {
-            this.proc.unref();
-          }
-          //logger.info(`got response: ${str}`);
-          req.p.resolve(JSON.parse(str));
-        } else {
-          stdoutChunks.push(x);
-        }
-      } else {
-        throw Error(`unexpected data chunk type (${typeof x})`);
-      }
-    });
-  }
-
-  async setupRefreshPlanchet(req: {
-    transfer_secret: string;
-    coin_index: number;
-  }): Promise<{
-    coin_pub: string;
-    coin_priv: string;
-    blinding_key: string;
-  }> {
-    return this.queueRequest({
-      op: "setup_refresh_planchet",
-      args: req,
-    });
-  }
-
-  async queueRequest(req: any): Promise<any> {
-    const p = openPromise<any>();
-    if (this.requests.length === 0) {
-      this.proc.ref();
-    }
-    this.requests.push({ req, p });
-    this.proc.stdin.write(JSON.stringify(req) + "\n");
-    return p.promise;
-  }
-
-  async eddsaVerify(req: {
-    msg: string;
-    sig: string;
-    pub: string;
-  }): Promise<{ valid: boolean }> {
-    return this.queueRequest({
-      op: "eddsa_verify",
-      args: req,
-    });
-  }
-
-  async eddsaSign(req: {
-    msg: string;
-    priv: string;
-  }): Promise<{ sig: string }> {
-    return this.queueRequest({
-      op: "eddsa_sign",
-      args: req,
-    });
-  }
-}
-
-/**
- * The synchronous crypto worker produced by this factory doesn't run in the
- * background, but actually blocks the caller until the operation is done.
- */
-export class SynchronousCryptoWorkerFactory implements CryptoWorkerFactory {
-  startWorker(): CryptoWorker {
-    if (typeof require === "undefined") {
-      throw Error("cannot make worker, require(...) not defined");
-    }
-    return new SynchronousCryptoWorker();
-  }
-
-  getConcurrency(): number {
-    return 1;
-  }
-}
-
 /**
  * Worker implementation that uses node subprocesses.
  */
@@ -157,14 +38,9 @@ export class SynchronousCryptoWorker {
    */
   onerror: undefined | ((m: any) => void);
 
-  primitiveWorker: PrimitiveWorker;
-
-  constructor() {
+  constructor(private primitiveWorker?: PrimitiveWorker) {
     this.onerror = undefined;
     this.onmessage = undefined;
-    if (process.env["TALER_WALLET_PRIMITIVE_WORKER"]) {
-      this.primitiveWorker = new MyPrimitiveWorker();
-    }
   }
 
   /**
diff --git a/packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts 
b/packages/taler-wallet-core/src/crypto/workers/synchronousWorkerFactory.ts
similarity index 58%
copy from packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts
copy to 
packages/taler-wallet-core/src/crypto/workers/synchronousWorkerFactory.ts
index 9de28dbe..ca63c768 100644
--- a/packages/taler-wallet-core/src/crypto/workers/synchronousWorker.ts
+++ b/packages/taler-wallet-core/src/crypto/workers/synchronousWorkerFactory.ts
@@ -15,7 +15,6 @@
  */
 
 import {
-  CryptoImplementation,
   PrimitiveWorker,
 } from "./cryptoImplementation.js";
 
@@ -25,9 +24,10 @@ import { CryptoWorker } from "./cryptoWorkerInterface.js";
 import child_process from "child_process";
 import type internal from "stream";
 import { OpenedPromise, openPromise } from "../../index.js";
-import { j2s, Logger } from "@gnu-taler/taler-util";
+import { Logger } from "@gnu-taler/taler-util";
+import { SynchronousCryptoWorker } from "./synchronousWorker.js";
 
-const logger = new Logger("synchronousWorker.ts");
+const logger = new Logger("synchronousWorkerFactory.ts");
 
 class MyPrimitiveWorker implements PrimitiveWorker {
   proc: child_process.ChildProcessByStdio<
@@ -47,7 +47,7 @@ class MyPrimitiveWorker implements PrimitiveWorker {
       stdio: ["pipe", "pipe", "inherit"],
       detached: true,
     });
-    this.proc.on("close", function (code) {
+    this.proc.on("close", (): void => {
       logger.error("child process exited");
     });
     (this.proc.stdout as any).unref();
@@ -65,7 +65,10 @@ class MyPrimitiveWorker implements PrimitiveWorker {
           const str = Buffer.concat([...stdoutChunks, before]).toString(
             "utf-8",
           );
-          const req = this.requests.shift()!;
+          const req = this.requests.shift();
+          if (!req) {
+            throw Error("request was undefined")
+          }
           if (this.requests.length === 0) {
             this.proc.unref();
           }
@@ -100,7 +103,7 @@ class MyPrimitiveWorker implements PrimitiveWorker {
       this.proc.ref();
     }
     this.requests.push({ req, p });
-    this.proc.stdin.write(JSON.stringify(req) + "\n");
+    this.proc.stdin.write(`${JSON.stringify(req)}\n`);
     return p.promise;
   }
 
@@ -135,114 +138,16 @@ export class SynchronousCryptoWorkerFactory implements 
CryptoWorkerFactory {
     if (typeof require === "undefined") {
       throw Error("cannot make worker, require(...) not defined");
     }
-    return new SynchronousCryptoWorker();
-  }
-
-  getConcurrency(): number {
-    return 1;
-  }
-}
-
-/**
- * Worker implementation that uses node subprocesses.
- */
-export class SynchronousCryptoWorker {
-  /**
-   * Function to be called when we receive a message from the worker thread.
-   */
-  onmessage: undefined | ((m: any) => void);
-
-  /**
-   * Function to be called when we receive an error from the worker thread.
-   */
-  onerror: undefined | ((m: any) => void);
-
-  primitiveWorker: PrimitiveWorker;
 
-  constructor() {
-    this.onerror = undefined;
-    this.onmessage = undefined;
+    let primitiveWorker;
     if (process.env["TALER_WALLET_PRIMITIVE_WORKER"]) {
-      this.primitiveWorker = new MyPrimitiveWorker();
+      primitiveWorker = new MyPrimitiveWorker();
     }
-  }
 
-  /**
-   * Add an event listener for either an "error" or "message" event.
-   */
-  addEventListener(event: "message" | "error", fn: (x: any) => void): void {
-    switch (event) {
-      case "message":
-        this.onmessage = fn;
-        break;
-      case "error":
-        this.onerror = fn;
-        break;
-    }
-  }
-
-  private dispatchMessage(msg: any): void {
-    if (this.onmessage) {
-      this.onmessage({ data: msg });
-    }
+    return new SynchronousCryptoWorker(primitiveWorker);
   }
 
-  private async handleRequest(
-    operation: string,
-    id: number,
-    args: string[],
-  ): Promise<void> {
-    const impl = new CryptoImplementation(this.primitiveWorker);
-
-    if (!(operation in impl)) {
-      console.error(`crypto operation '${operation}' not found`);
-      return;
-    }
-
-    let result: any;
-    try {
-      result = await (impl as any)[operation](...args);
-    } catch (e) {
-      logger.error("error during operation", e);
-      return;
-    }
-
-    try {
-      setTimeout(() => this.dispatchMessage({ result, id }), 0);
-    } catch (e) {
-      logger.error("got error during dispatch", e);
-    }
-  }
-
-  /**
-   * Send a message to the worker thread.
-   */
-  postMessage(msg: any): void {
-    const args = msg.args;
-    if (!Array.isArray(args)) {
-      console.error("args must be array");
-      return;
-    }
-    const id = msg.id;
-    if (typeof id !== "number") {
-      console.error("RPC id must be number");
-      return;
-    }
-    const operation = msg.operation;
-    if (typeof operation !== "string") {
-      console.error("RPC operation must be string");
-      return;
-    }
-
-    this.handleRequest(operation, id, args).catch((e) => {
-      console.error("Error while handling crypto request:", e);
-    });
-  }
-
-  /**
-   * Forcibly terminate the worker thread.
-   */
-  terminate(): void {
-    // This is a no-op.
+  getConcurrency(): number {
+    return 1;
   }
 }
diff --git a/packages/taler-wallet-core/src/index.ts 
b/packages/taler-wallet-core/src/index.ts
index 5489bd5a..179ba6b8 100644
--- a/packages/taler-wallet-core/src/index.ts
+++ b/packages/taler-wallet-core/src/index.ts
@@ -36,6 +36,7 @@ export * from "./db-utils.js";
 export { CryptoImplementation } from 
"./crypto/workers/cryptoImplementation.js";
 export type { CryptoWorker } from "./crypto/workers/cryptoWorkerInterface.js";
 export { CryptoWorkerFactory, CryptoApi } from "./crypto/workers/cryptoApi.js";
+export { SynchronousCryptoWorker } from "./crypto/workers/synchronousWorker.js"
 
 export * from "./pending-types.js";
 

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.