@atlaspack/workers 2.12.1-canary.3354

package/src/threads/ThreadsChild.js

@@ -0,0 +1,42 @@
+// @flow
+
+import type {
+  ChildImpl,
+  MessageHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {isMainThread, parentPort} from 'worker_threads';
+import nullthrows from 'nullthrows';
+import {setChild} from '../childState';
+import {Child} from '../child';
+import {
+  prepareForSerialization,
+  restoreDeserializedObject,
+} from '@atlaspack/core';
+
+export default class ThreadsChild implements ChildImpl {
+  onMessage: MessageHandler;
+  onExit: ExitHandler;
+
+  constructor(onMessage: MessageHandler, onExit: ExitHandler) {
+    if (isMainThread || !parentPort) {
+      throw new Error('Only create ThreadsChild instances in a worker!');
+    }
+
+    this.onMessage = onMessage;
+    this.onExit = onExit;
+    parentPort.on('message', data => this.handleMessage(data));
+    parentPort.on('close', this.onExit);
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    nullthrows(parentPort).postMessage(prepareForSerialization(data));
+  }
+}
+
+setChild(new Child(ThreadsChild));

package/src/threads/ThreadsWorker.js

@@ -0,0 +1,66 @@
+// @flow
+
+import type {
+  WorkerImpl,
+  MessageHandler,
+  ErrorHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {Worker} from 'worker_threads';
+import path from 'path';
+import {
+  prepareForSerialization,
+  restoreDeserializedObject,
+} from '@atlaspack/core';
+
+const WORKER_PATH = path.join(__dirname, 'ThreadsChild.js');
+
+export default class ThreadsWorker implements WorkerImpl {
+  execArgv: Object;
+  onMessage: MessageHandler;
+  onError: ErrorHandler;
+  onExit: ExitHandler;
+  worker: Worker;
+
+  constructor(
+    execArgv: Object,
+    onMessage: MessageHandler,
+    onError: ErrorHandler,
+    onExit: ExitHandler,
+  ) {
+    this.execArgv = execArgv;
+    this.onMessage = onMessage;
+    this.onError = onError;
+    this.onExit = onExit;
+  }
+
+  start(): Promise<void> {
+    this.worker = new Worker(WORKER_PATH, {
+      execArgv: this.execArgv,
+      env: process.env,
+    });
+
+    this.worker.on('message', data => this.handleMessage(data));
+    this.worker.on('error', this.onError);
+    this.worker.on('exit', this.onExit);
+
+    return new Promise<void>(resolve => {
+      this.worker.on('online', resolve);
+    });
+  }
+
+  stop(): Promise<void> {
+    // In node 12, this returns a promise, but previously it accepted a callback
+    // TODO: Pass a callback in earlier versions of Node
+    return Promise.resolve(this.worker.terminate());
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    this.worker.postMessage(prepareForSerialization(data));
+  }
+}

package/src/types.js

@@ -0,0 +1,68 @@
+// @flow
+import type {Diagnostic} from '@atlaspack/diagnostic';
+import type {FilePath} from '@atlaspack/types-internal';
+
+export type LocationCallRequest = {|
+  args: $ReadOnlyArray<mixed>,
+  location: string,
+  method?: string,
+|};
+
+export type HandleCallRequest = {|
+  args: $ReadOnlyArray<mixed>,
+  handle: number,
+|};
+
+export type CallRequest = LocationCallRequest | HandleCallRequest;
+
+export type WorkerRequest = {|
+  args: $ReadOnlyArray<any>,
+  awaitResponse?: boolean,
+  child?: ?number,
+  idx?: number,
+  location?: FilePath,
+  method?: ?string,
+  type: 'request',
+  handle?: number,
+|};
+
+export type WorkerDataResponse = {|
+  idx?: number,
+  child?: number,
+  type: 'response',
+  contentType: 'data',
+  content: string,
+|};
+
+export type WorkerErrorResponse = {|
+  idx?: number,
+  child?: number,
+  type: 'response',
+  contentType: 'error',
+  content: Diagnostic | Array<Diagnostic>,
+|};
+
+export type WorkerResponse = WorkerDataResponse | WorkerErrorResponse;
+export type WorkerMessage = WorkerRequest | WorkerResponse;
+
+export type MessageHandler = (data: WorkerMessage) => void;
+export type ErrorHandler = (err: Error) => void;
+export type ExitHandler = (code: number) => void;
+export interface WorkerImpl {
+  constructor(
+    execArgv: Object,
+    onMessage: MessageHandler,
+    onError: ErrorHandler,
+    onExit: ExitHandler,
+  ): void;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  send(data: WorkerMessage): void;
+}
+
+export interface ChildImpl {
+  constructor(onMessage: MessageHandler, onExit: ExitHandler): void;
+  send(data: WorkerMessage): void;
+}
+
+export type BackendType = 'threads' | 'process' | 'web';

package/src/web/WebChild.js

@@ -0,0 +1,53 @@
+// @flow
+/* eslint-env worker*/
+
+import type {
+  ChildImpl,
+  MessageHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {setChild} from '../childState';
+import {Child} from '../child';
+import {
+  prepareForSerialization,
+  restoreDeserializedObject,
+} from '@atlaspack/core';
+
+export default class WebChild implements ChildImpl {
+  onMessage: MessageHandler;
+  onExit: ExitHandler;
+
+  constructor(onMessage: MessageHandler, onExit: ExitHandler) {
+    if (
+      !(
+        typeof WorkerGlobalScope !== 'undefined' &&
+        self instanceof WorkerGlobalScope
+      )
+    ) {
+      throw new Error('Only create WebChild instances in a worker!');
+    }
+
+    this.onMessage = onMessage;
+    this.onExit = onExit;
+    self.addEventListener('message', ({data}: MessageEvent) => {
+      if (data === 'stop') {
+        this.onExit(0);
+        self.postMessage('stopped');
+      }
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    });
+    self.postMessage('online');
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    self.postMessage(prepareForSerialization(data));
+  }
+}
+
+setChild(new Child(WebChild));

package/src/web/WebWorker.js

@@ -0,0 +1,88 @@
+// @flow
+
+import type {
+  WorkerImpl,
+  MessageHandler,
+  ErrorHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {
+  prepareForSerialization,
+  restoreDeserializedObject,
+} from '@atlaspack/core';
+import {makeDeferredWithPromise} from '@atlaspack/utils';
+
+let id = 0;
+
+export default class WebWorker implements WorkerImpl {
+  execArgv: Object;
+  onMessage: MessageHandler;
+  onError: ErrorHandler;
+  onExit: ExitHandler;
+  worker: Worker;
+  stopping: ?Promise<void>;
+
+  constructor(
+    execArgv: Object,
+    onMessage: MessageHandler,
+    onError: ErrorHandler,
+    onExit: ExitHandler,
+  ) {
+    this.execArgv = execArgv;
+    this.onMessage = onMessage;
+    this.onError = onError;
+    this.onExit = onExit;
+  }
+
+  start(): Promise<void> {
+    // $FlowFixMe[incompatible-call]
+    this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
+      name: `Atlaspack Worker ${id++}`,
+      type: 'module',
+    });
+
+    let {deferred, promise} = makeDeferredWithPromise();
+
+    this.worker.onmessage = ({data}) => {
+      if (data === 'online') {
+        deferred.resolve();
+        return;
+      }
+
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    };
+    this.worker.onerror = this.onError;
+    // Web workers can't crash or intentionally stop on their own, apart from stop() below
+    // this.worker.on('exit', this.onExit);
+
+    return promise;
+  }
+
+  stop(): Promise<void> {
+    if (!this.stopping) {
+      this.stopping = (async () => {
+        this.worker.postMessage('stop');
+        let {deferred, promise} = makeDeferredWithPromise();
+        this.worker.addEventListener('message', ({data}: MessageEvent) => {
+          if (data === 'stopped') {
+            deferred.resolve();
+          }
+        });
+        await promise;
+        this.worker.terminate();
+        this.onExit(0);
+      })();
+    }
+    return this.stopping;
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    this.worker.postMessage(prepareForSerialization(data));
+  }
+}

package/test/cpuCount.test.js

@@ -0,0 +1,19 @@
+import assert from 'assert';
+import os from 'os';
+
+import getCores, {detectRealCores} from '../src/cpuCount';
+
+describe('cpuCount', function () {
+  it('Should be able to detect real cpu count', () => {
+    // Windows not supported as getting the cpu count takes a couple seconds...
+    if (os.platform() === 'win32') return;
+
+    let cores = detectRealCores();
+    assert(cores > 0);
+  });
+
+  it('getCores should return more than 0', () => {
+    let cores = getCores(true);
+    assert(cores > 0);
+  });
+});

package/test/integration/workerfarm/console.js

@@ -0,0 +1,15 @@
+const WorkerFarm = require('../../../src/WorkerFarm').default;
+
+function run() {
+  if (WorkerFarm.isWorker()) {
+    // Only test this behavior in workers. Logging in the main process will
+    // always work.
+    console.log('one');
+    console.info('two');
+    console.warn('three');
+    console.error('four');
+    console.debug('five');
+  }
+}
+
+exports.run = run;

package/test/integration/workerfarm/echo.js

@@ -0,0 +1,5 @@
+function run(_, data) {
+  return data;
+}
+
+exports.run = run;

package/test/integration/workerfarm/ipc-pid.js

@@ -0,0 +1,18 @@
+const WorkerFarm = require('../../../src/WorkerFarm').default;
+
+function run(api) {
+  let result = [process.pid];
+  return new Promise((resolve, reject) => {
+    api.callMaster({
+      location: require.resolve('./master-process-id.js'),
+      args: []
+    })
+      .then(pid => {
+        result.push(pid);
+        resolve(result);
+      })
+      .catch(reject);
+  });
+}
+
+exports.run = run;

package/test/integration/workerfarm/ipc.js

@@ -0,0 +1,10 @@
+const WorkerFarm = require('../../../src/WorkerFarm').default;
+
+function run(api, a, b) {
+  return api.callMaster({
+    location: require.resolve('./master-sum.js'),
+    args: [a, b]
+  });
+}
+
+exports.run = run;

package/test/integration/workerfarm/logging.js

@@ -0,0 +1,19 @@
+const WorkerFarm = require('../../../src/WorkerFarm').default;
+const Logger = require('@atlaspack/logger').default;
+
+function run() {
+  if (WorkerFarm.isWorker()) {
+    // Only test this behavior in workers. Logging in the main process will
+    // always work.
+    Logger.info({
+      origin: 'logging-worker',
+      message: 'omg it works'
+    });
+    Logger.error({
+      origin: 'logging-worker',
+      message: 'errors objects dont work yet'
+    });
+  }
+}
+
+exports.run = run;

package/test/integration/workerfarm/master-process-id.js

@@ -0,0 +1,3 @@
+module.exports = function() {
+  return process.pid;
+};

package/test/integration/workerfarm/master-sum.js

@@ -0,0 +1,3 @@
+module.exports = function(a, b) {
+  return a + b;
+};

package/test/integration/workerfarm/ping.js

@@ -0,0 +1,5 @@
+function run() {
+  return 'pong';
+}
+
+exports.run = run;

package/test/integration/workerfarm/resolve-shared-reference.js

@@ -0,0 +1,5 @@
+function run(workerApi, ref) {
+  return ref === workerApi.resolveSharedReference(workerApi.getSharedReference(ref));
+}
+
+exports.run = run;

package/test/integration/workerfarm/reverse-handle.js

@@ -0,0 +1,5 @@
+function run(workerApi, handle) {
+  return workerApi.runHandle(handle, []);
+}
+
+exports.run = run;

package/test/integration/workerfarm/shared-reference.js

@@ -0,0 +1,6 @@
+function run(workerApi, ref) {
+  let sharedReference = workerApi.getSharedReference(ref);
+  return sharedReference || 'Shared reference does not exist';
+}
+
+exports.run = run;