worker_threads#parentPort TypeScript Examples

parentPort?.on("message", (value: Message) => {
  switch (value.type) {
    case "infer":
      runInference(value);
      break;

    case "init":
      loadPort = value.loadPort;
      inferencePort = value.inferencePort;
      value.initPort.close();
      break;

    case "load":
      initModel(value.params);
      break;
  }
});

parentPort!.on('message', async ([e, data, id]) => {
  if (e === '@@sab') {
    return
  }

  if (!id) return ee.emit(e, ...data)

  if (pendingRequests.has(id)) {
    pendingRequests.get(id)(data)
    pendingRequests.delete(id)
    return
  }

  const listener = ee.listeners(e)[0]
  if (!listener) return
  const result = await listener(...data)
  send([e, result, id])
})

/**
 * 包装需要放到 worker 中执行的函数
 * 1. 当检查到当前文件不是 js 文件时会直接返回函数
 * 2. 当检查到在主线程时执行时，使用 Worker 包装并执行它
 * 3. 当检查到在 Worker 线程时，使用 expose 包装它然后执行
 * 注：目前是每次都创建新的 Worker，也许可以考虑支持复用 Worker
 * @param ep
 */
export function wrapWorkerFunc<T extends (...args: any[]) => any>(
  ep: T,
): Remote<T> {
  // return ep as Remote<T>
  if (path.extname(__filename) !== '.js') {
    return ep as Remote<T>
  }
  if (isMainThread) {
    return ((...args: any[]) => {
      const worker = new Worker(__filename)
      const fn = wrap<T>(nodeEndpoint(worker))
      return (fn(...args) as Promise<any>).finally(() => worker.unref())
    }) as Remote<T>
  }
  expose(ep, nodeEndpoint(parentPort!))
  return ep as Remote<T>
}

parentPort.on('message', (param: Array<{type: string, data: Uint8Array | string, abi?: any}>) => {
    try {
        const result = [];

        for (const row of param) {
            if (row.data === null) {
                return parentPort.postMessage({success: false, message: 'Empty data received on deserialize worker'});
            }

            if (row.abi) {
                const abiTypes = Serialize.getTypesFromAbi(Serialize.createInitialTypes(), row.abi);

                result.push(deserializeEosioType(row.type, row.data, abiTypes));
            } else {
                result.push(deserializeEosioType(row.type, row.data, eosjsTypes));
            }
        }

        return parentPort.postMessage({success: true, data: result});
    } catch (e) {
        return parentPort.postMessage({success: false, message: String(e)});
    }
});

requestListener = (req: http.IncomingMessage, res: http.ServerResponse): void => {
    const {authToken} = url.parse(req.url || '', true).query;

    if (!authToken) {
        throw new AuthenticationError('Failed to authenticate');
    }

    if (parentPort && parentPort.postMessage) {
        parentPort.postMessage(authToken);
    }

    res.writeHead(200);
    res.write(
        '<script type="text/javascript">window.close()</script>You are authenticated, you can close this tab now.',
        () => {
            res.end(() => process.exit());
        },
    );
}

// DO NOT import unnecessary module preventing from infinite spawned workers.

parentPort.on("message", (value) => {
  const data = value as workerMessage;
  if(data && data.type === "init"){
    const { id, url, prefetched, forceCache } = data;
    const youtube = new YouTube();
    youtube.init(url, prefetched, forceCache).then(() => {
      parentPort.postMessage({
        type: "initOk",
        data: youtube,
        id,
      } as workerInitSuccessMessage & {type:number});
    }).catch((er) => {
      parentPort.postMessage({
        type: "error",
        data: er,
        id,
      } as workerErrorMessage & {type:number});
    });
  }else if(data && data.type === "search"){
    const id = data.id;
    ytsr.default(data.keyword, {
      limit:12,
      gl: "JP",
      hl: "ja"
    }).then((result) => {
      parentPort.postMessage({
        type: "searchOk",
        data: result,
        id
      } as workerSearchSuccessMessage & {type:number})
    }).catch((er) => {
      parentPort.postMessage({
        type: "error",
        data: er,
        id
      } as workerErrorMessage & {type:number});
    });
  }
})

initWorker = () => {
  if (!parentPort || !workerData) {
    return;
  }

  const messagePort = parentPort;
  const { socketPort, pingTimeout, pingInterval }: TestResultEmitterWorkerData = workerData;

  const socket = io('http://localhost:' + socketPort + '/', {
    forceNew: true,
    reconnection: true
  });

  const socketOptions = { pingTimeout, pingInterval };

  Object.assign(socket, socketOptions);

  messagePort.on('message', (event: KarmaEvent) => {
    socket.emit(event.name, event);
  });
}

void postgresAdapter
    .init()
    .then(() => {
        DataStagingMapper.Instance.DeleteOlderThanRetention()
            .then(() => {
                DataStagingMapper.Instance.Vacuum()
                    .then(() => {
                        void PostgresAdapter.Instance.close()

                        if (parentPort) parentPort.postMessage('done');
                        else {
                            process.exit(0);
                        }
                    })
                    .catch((e) => {
                        void PostgresAdapter.Instance.close()

                        Logger.error(`unable to run staging cleaning job ${e}`);
                        process.exit(1);
                    });
            })
            .catch((e) => {
                void PostgresAdapter.Instance.close()

                Logger.error(`unable to run staging cleaning job ${e}`);
                process.exit(1);
            });
    })
    .catch((e) => {
        void PostgresAdapter.Instance.close()

        Logger.error(`unexpected error in staging clean thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    });

void postgresAdapter
    .init()
    .then(() => {
        EdgeMapper.Instance.RunEdgeLinker()
            .catch((e) => {
                Logger.error(`unable to run edge linker job ${e}`);
            })
            .finally(() => {
                void PostgresAdapter.Instance.close()

                if (parentPort) parentPort.postMessage('done');
                else {
                    process.exit(0);
                }
            })
    })
    .catch((e) => {
        void PostgresAdapter.Instance.close()

        Logger.error(`unexpected error in orphan edge linker thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    })

parentPort?.on('message', async (message) => {
    if (message?.command === 'getSysInfo') {
        const info = await getSysInfo();
        parentPort?.postMessage({
            type: 'sysInfo',
            info,
        });
    }

    if (message?.command === 'getUsageInfo') {
        const info = await getUsageInfo();
        parentPort?.postMessage({
            type: 'usageInfo',
            info,
        });
    }
})

emit = (action: string, ...args: any[]) => {
  const messageId = 'message:' + messageCounter++;

  let rejectFn: (reason?: any) => void;
  // promise waits for the message to resolve
  const promise = new Promise((resolve, reject) => {
    parent.once(messageId, resolve);
    rejectFn = reject;
  });

  try {
    // post the message
    parentPort.postMessage({ action, args: [messageId, ...args] });
  } catch (err) {
    rejectFn(err);
  }

  // return the promise
  return promise;
}

async function main(parentPort: MessagePort, workerData: WorkerData) {
  const { config, network, env } = workerData;
  const engine = await Engine.connect(
    {
      network: network.id,
      endpoint: config.endpoint,
      contract: config.engine,
    },
    env
  );
  const indexer = new Indexer(config, network, engine);
  await indexer.start();

  setTimeout(function () {
    indexer.insertNewHeads();
  });

  parentPort
    .on('message', async (block: any) => {
      parentPort.postMessage(true); // ack the request
      const blockData = await indexer.indexBlock(block.id);
      if (block.is_head) {
        indexer.notifyNewHeads(block.id, blockData);
      } else {
        indexer.insert(blockData);
      }
    })
    .on('close', () => {
      return; // TODO?
    });
}

parentPort?.once("message", (params: WorkerParam) => {
  const { entities, roles, appInfo } = params;

  const loggerCallback = (message: string) => {
    const messageData: WorkerResult = {
      message,
      done: false,
    };
    parentPort?.postMessage(messageData);
  };

  const logger = createWorkerLogger(loggerCallback);

  createDataServiceImpl(entities, roles, appInfo, logger)
    .then((modules) => {
      const results: WorkerResult = {
        done: true,
        modules,
      };
      parentPort?.postMessage(results);
      parentPort?.close();
    })
    .catch((error) => {
      const results: WorkerResult = {
        error: error,
        done: false,
      };

      parentPort?.postMessage(results);
      parentPort?.close();
    });
});

function checkHealth() {
  const { threadToWatchPid } = workerData;
  let healthTimeoutTimer: any;
  const healthTimer = setTimeout(() => {
    parentPort?.postMessage(true);
    healthTimeoutTimer = setTimeout(() => {
      process.kill(threadToWatchPid);
    }, 25000);
  }, 10000);
  parentPort?.on("message", () => {
    healthTimer.refresh();
    clearTimeout(healthTimeoutTimer);
  });
}

parentPort.on("message", (action) => {
  switch (action) {
    case "connect":
      console.log("goooo");
      soeClient.connect();
      break;

    default:
      break;
  }
});

async function setup() {
  new SOEServer(
    "test",
    1115,
    Buffer.from("F70IaxuU8C/w7FPXY1ibXw==", "base64"),
    0,
    false
  ).start(0, 0, 2, 512);
  parentPort.postMessage("started");
}

parentPort?.on(`message`, (message: httpServerMessage) => {
  const { type, requestId, data } = message;
  switch (type) {
    case "pingzone": {
      const res = pendingRequest[requestId];
      if (data === "pong") {
        res.writeHead(200, { "Content-Type": "text/json" });
        res.write(data);
      } else {
        res.writeHead(404, { "Content-Type": "text/json" });
      }
      res.end();
      delete pendingRequest[requestId];
      break;
    }
    case "ping":
      const res = pendingRequest[requestId];
      res.writeHead(200, { "Content-Type": "text/json" });
      res.write(data);
      res.end();
      delete pendingRequest[requestId];
      break;
    default:
      break;
  }
});

main(parentPort!, workerData as WorkerData);

async function setup() {
  await new LoginServer(1115).start();
  parentPort.postMessage("started");
}

send = (data: any) => parentPort!.postMessage(data)

soeClient.on("connect", () => {
  parentPort.postMessage("ok");
});

async function setup() {
  await new ZoneServer(
    1117,
    Buffer.from("F70IaxuU8C/w7FPXY1ibXw==", "base64")
  ).start();
  parentPort.postMessage("started");
}

function sendMessageToServer(type: string, requestId: number, data: any) {
  const message: httpServerMessage = {
    type: type,
    requestId: requestId,
    data: data,
  };
  parentPort?.postMessage(message);
}

void PostgresAdapter.Instance.init()
    .then(() => {
        void QueueFactory()
            .then((queue) => {
                const destination = new Writable({
                    objectMode: true,
                    write(chunk: any, encoding: string, callback: (error?: Error | null) => void) {
                        const stagingRecord = plainToClass(DataStaging, chunk as object);
                        ProcessData(stagingRecord)
                            .then((result) => {
                                if (result.isError) {
                                    Logger.error(`processing error: ${result.error?.error}`);
                                }
                                callback();
                            })
                            .catch((e) => {
                                Logger.error(`unable to process data from queue ${e}`);
                                callback();
                            });

                        return true;
                    },
                });

                destination.on('error', (e: Error) => {
                    void PostgresAdapter.Instance.close()

                    Logger.error(`unexpected error in processing queue thread ${e}`);
                    if (parentPort) parentPort.postMessage('done');
                    else {
                        process.exit(1);
                    }
                });

                queue.Consume(Config.process_queue, destination);
            })
            .catch((e) => {
                void PostgresAdapter.Instance.close()

                Logger.error(`unexpected error in processing queue thread ${e}`);
                if (parentPort) parentPort.postMessage('done');
                else {
                    process.exit(1);
                }
            });
    })
    .catch((e) => {
        void PostgresAdapter.Instance.close()

        Logger.error(`unexpected error in processing queue thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    });

void postgresAdapter
    .init()
    .then(() => {
        const exporterRepo = new ExporterRepository();

        const queue = new PQueue({concurrency: Config.export_data_concurrency});

        exporterRepo
            .where()
            .status('eq', 'processing')
            .list()
            .then((exporters) => {
                if (exporters.isError) Logger.error(`unable to list exporters ${exporters.error?.error}`);

                const tasks = [];

                for (const exporter of exporters.value) {
                    if (exporter) {
                        tasks.push(queue.add(() => exporter?.Restart(SuperUser)));
                    }
                }

                Promise.all(tasks)
                    .catch((e) => {
                        Logger.error(`unable to process exports ${e}`);
                    })
                    .finally(() => {
                        void PostgresAdapter.Instance.close();

                        if (parentPort) parentPort.postMessage('done');
                        else {
                            process.exit(0);
                        }
                    })
            })
            .catch((e) => {
                void PostgresAdapter.Instance.close()

                Logger.error(`unable to restart exports ${e}`)
                if (parentPort) parentPort.postMessage('done');
                else {
                    process.exit(1);
                }
            });

    })
    .catch((e) => {
        void PostgresAdapter.Instance.close()

        Logger.error(`unexpected error in export thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    });

void PostgresAdapter.Instance.init()
    .then(() => {
        void QueueFactory().then((queue) => {
            const destination = new Writable({
                objectMode: true,
                write(chunk: any, encoding: string, callback: (error?: Error | null) => void) {
                    const event = plainToClass(Event, chunk as object);
                    processFunction(event)
                        .then(() => {
                            callback();
                        })
                        .catch((e) => {
                            Logger.error(`unable to process event from queue ${e}`);
                            callback();
                        });
                },
            });

            destination.on('error', (e: Error) => {
                void PostgresAdapter.Instance.close();

                Logger.error(`unexpected error in processing queue thread ${e}`);
                if (parentPort) parentPort.postMessage('done');
                else {
                    process.exit(1);
                }
            });

            queue.Consume(Config.events_queue, destination);
        });
    })
    .catch((e) => {
        void PostgresAdapter.Instance.close();

        Logger.error(`unexpected error in events queue thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    });

void PostgresAdapter.Instance.init()
    .then(() => {
        const dataSourceRepo = new DataSourceRepository();

        void QueueFactory()
            .then((queue) => {
                const destination = new Writable({
                    objectMode: true,
                    write(chunk: any, encoding: string, callback: (error?: Error | null) => void) {
                        dataSourceRepo
                            .findByID(chunk as string)
                            .then((source) => {
                                if (source.isError) {
                                    Logger.error(`unable to fetch data source ${source.error?.error}`);
                                    callback();
                                    return;
                                }
                                source.value
                                    .Run()
                                    .then(() => {
                                        callback();
                                    })
                                    .catch((e) => {
                                        Logger.error(`unable to process event from queue ${e}`);
                                        callback();
                                    });
                            })
                            .catch((e) => {
                                Logger.error(`unable to process event from queue ${e}`);
                                callback();
                            });

                        return true;
                    },
                });

                destination.on('error', (e: Error) => {
                    void PostgresAdapter.Instance.close()

                    Logger.error(`unexpected error in data source queue thread ${e}`);
                    if (parentPort) parentPort.postMessage('done');
                    else {
                        process.exit(1);
                    }
                });

                queue.Consume(Config.data_sources_queue, destination);
            })
            .catch((e) => {
                void PostgresAdapter.Instance.close()

                Logger.error(`unexpected error in data source queue thread ${e}`);
                if (parentPort) parentPort.postMessage('done');
                else {
                    process.exit(1);
                }
            });
    })
    .catch((e) => {
        void PostgresAdapter.Instance.close()

        Logger.error(`unexpected error in data source queue thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    });

void postgresAdapter
    .init()
    .then(() => {
        QueueFactory()
            .then((queue) => {
                void postgresAdapter.Pool.connect((err, client, done) => {
                    const stream = client.query(new QueryStream(dataSourceMapper.listAllActiveStatement()));
                    const putPromises: Promise<boolean>[] = [];

                    stream.on('data', (data) => {
                        // we're simply putting the id on the queue here
                        putPromises.push(queue.Put(Config.data_sources_queue, plainToClass(DataSourceRecord, data as object).id));
                    });

                    stream.on('error', (e: Error) => {
                        Logger.error(`unexpected error in data source emitter thread ${e}`);
                        if (parentPort) parentPort.postMessage('done');
                        else {
                            process.exit(1);
                        }
                    });

                    stream.on('end', () => {
                        done();

                        Promise.all(putPromises)
                            .catch((e) => {
                                Logger.error(`unable to put data sources on queue ${e}`);
                            })
                            .finally(() => {
                                void PostgresAdapter.Instance.close();

                                if (parentPort) parentPort.postMessage('done');
                                else {
                                    process.exit(1);
                                }
                            })
                    });

                    stream.pipe(devnull({objectMode: true}));
                });
            })
            .catch((e) => {
                void PostgresAdapter.Instance.close();

                Logger.error(`unable to initiate data source emitter: ${e}`);
                if (parentPort) parentPort.postMessage('done');
                else {
                    process.exit(1);
                }
            });
    })
    .catch((e) => {
        void PostgresAdapter.Instance.close();

        Logger.error(`unexpected error in data source emitter thread ${e}`);
        if (parentPort) parentPort.postMessage('done');
        else {
            process.exit(1);
        }
    });

// handle message passing
parentPort.on('message', ({ action, args }) => parent.emit(action, ...args));