Upload Kmake

lib/internal/cluster/child.js

@@ -0,0 +1,308 @@
+'use strict';
+
+const {
+  ArrayPrototypeJoin,
+  FunctionPrototype,
+  ObjectAssign,
+  ReflectApply,
+  SafeMap,
+  SafeSet,
+} = primordials;
+
+const assert = require('internal/assert');
+const path = require('path');
+const EventEmitter = require('events');
+const { owner_symbol } = require('internal/async_hooks').symbols;
+const Worker = require('internal/cluster/worker');
+const { internal, sendHelper } = require('internal/cluster/utils');
+const { exitCodes: { kNoFailure } } = internalBinding('errors');
+const { TIMEOUT_MAX } = require('internal/timers');
+const { setInterval, clearInterval } = require('timers');
+
+const cluster = new EventEmitter();
+const handles = new SafeMap();
+const indexes = new SafeMap();
+const noop = FunctionPrototype;
+
+module.exports = cluster;
+
+cluster.isWorker = true;
+cluster.isMaster = false; // Deprecated alias. Must be same as isPrimary.
+cluster.isPrimary = false;
+cluster.worker = null;
+cluster.Worker = Worker;
+
+cluster._setupWorker = function() {
+  const worker = new Worker({
+    id: +process.env.NODE_UNIQUE_ID | 0,
+    process: process,
+    state: 'online',
+  });
+
+  cluster.worker = worker;
+
+  process.once('disconnect', () => {
+    worker.emit('disconnect');
+
+    if (!worker.exitedAfterDisconnect) {
+      // Unexpected disconnect, primary exited, or some such nastiness, so
+      // worker exits immediately.
+      process.exit(kNoFailure);
+    }
+  });
+
+  process.on('internalMessage', internal(worker, onmessage));
+  send({ act: 'online' });
+
+  function onmessage(message, handle) {
+    if (message.act === 'newconn')
+      onconnection(message, handle);
+    else if (message.act === 'disconnect')
+      ReflectApply(_disconnect, worker, [true]);
+  }
+};
+
+// `obj` is a net#Server or a dgram#Socket object.
+cluster._getServer = function(obj, options, cb) {
+  let address = options.address;
+
+  // Resolve unix socket paths to absolute paths
+  if (options.port < 0 && typeof address === 'string' &&
+      process.platform !== 'win32')
+    address = path.resolve(address);
+
+  const indexesKey = ArrayPrototypeJoin(
+    [
+      address,
+      options.port,
+      options.addressType,
+      options.fd,
+    ], ':');
+
+  let indexSet = indexes.get(indexesKey);
+
+  if (indexSet === undefined) {
+    indexSet = { nextIndex: 0, set: new SafeSet() };
+    indexes.set(indexesKey, indexSet);
+  }
+  const index = indexSet.nextIndex++;
+  indexSet.set.add(index);
+
+  const message = {
+    act: 'queryServer',
+    index,
+    data: null,
+    ...options,
+  };
+
+  message.address = address;
+
+  // Set custom data on handle (i.e. tls tickets key)
+  if (obj._getServerData)
+    message.data = obj._getServerData();
+
+  send(message, (reply, handle) => {
+    if (typeof obj._setServerData === 'function')
+      obj._setServerData(reply.data);
+
+    if (handle) {
+      // Shared listen socket
+      shared(reply, { handle, indexesKey, index }, cb);
+    } else {
+      // Round-robin.
+      rr(reply, { indexesKey, index }, cb);
+    }
+  });
+
+  obj.once('listening', () => {
+    // short-lived sockets might have been closed
+    if (!indexes.has(indexesKey)) {
+      return;
+    }
+    cluster.worker.state = 'listening';
+    const address = obj.address();
+    message.act = 'listening';
+    message.port = (address?.port) || options.port;
+    send(message);
+  });
+};
+
+function removeIndexesKey(indexesKey, index) {
+  const indexSet = indexes.get(indexesKey);
+  if (!indexSet) {
+    return;
+  }
+
+  indexSet.set.delete(index);
+  if (indexSet.set.size === 0) {
+    indexes.delete(indexesKey);
+  }
+}
+
+// Shared listen socket.
+function shared(message, { handle, indexesKey, index }, cb) {
+  const key = message.key;
+  // Monkey-patch the close() method so we can keep track of when it's
+  // closed. Avoids resource leaks when the handle is short-lived.
+  const close = handle.close;
+
+  handle.close = function() {
+    send({ act: 'close', key });
+    handles.delete(key);
+    removeIndexesKey(indexesKey, index);
+    return ReflectApply(close, handle, arguments);
+  };
+  assert(handles.has(key) === false);
+  handles.set(key, handle);
+  cb(message.errno, handle);
+}
+
+// Round-robin. Master distributes handles across workers.
+function rr(message, { indexesKey, index }, cb) {
+  if (message.errno)
+    return cb(message.errno, null);
+
+  let key = message.key;
+
+  let fakeHandle = null;
+
+  function ref() {
+    fakeHandle ||= setInterval(noop, TIMEOUT_MAX);
+  }
+
+  function unref() {
+    if (fakeHandle) {
+      clearInterval(fakeHandle);
+      fakeHandle = null;
+    }
+  }
+
+  function listen(backlog) {
+    // TODO(bnoordhuis) Send a message to the primary that tells it to
+    // update the backlog size. The actual backlog should probably be
+    // the largest requested size by any worker.
+    return 0;
+  }
+
+  function close() {
+    // lib/net.js treats server._handle.close() as effectively synchronous.
+    // That means there is a time window between the call to close() and
+    // the ack by the primary process in which we can still receive handles.
+    // onconnection() below handles that by sending those handles back to
+    // the primary.
+    if (key === undefined)
+      return;
+    unref();
+    // If the handle is the last handle in process,
+    // the parent process will delete the handle when worker process exits.
+    // So it is ok if the close message get lost.
+    // See the comments of https://github.com/nodejs/node/pull/46161
+    send({ act: 'close', key });
+    handles.delete(key);
+    removeIndexesKey(indexesKey, index);
+    key = undefined;
+  }
+
+  function getsockname(out) {
+    if (key)
+      ObjectAssign(out, message.sockname);
+
+    return 0;
+  }
+
+  // Faux handle. net.Server is not associated with handle,
+  // so we control its state(ref or unref) by setInterval.
+  const handle = { close, listen, ref, unref };
+  handle.ref();
+  if (message.sockname) {
+    handle.getsockname = getsockname;  // TCP handles only.
+  }
+
+  assert(handles.has(key) === false);
+  handles.set(key, handle);
+  cb(0, handle);
+}
+
+// Round-robin connection.
+function onconnection(message, handle) {
+  const key = message.key;
+  const server = handles.get(key);
+  let accepted = server !== undefined;
+
+  if (accepted && server[owner_symbol]) {
+    const self = server[owner_symbol];
+    if (self.maxConnections != null &&
+        self._connections >= self.maxConnections &&
+        !self.dropMaxConnection) {
+      accepted = false;
+    }
+  }
+
+  send({ ack: message.seq, accepted });
+
+  if (accepted)
+    server.onconnection(0, handle);
+  else
+    handle.close();
+}
+
+function send(message, cb) {
+  return sendHelper(process, message, null, cb);
+}
+
+function _disconnect(primaryInitiated) {
+  this.exitedAfterDisconnect = true;
+  let waitingCount = 1;
+
+  function checkWaitingCount() {
+    waitingCount--;
+
+    if (waitingCount === 0) {
+      // If disconnect is worker initiated, wait for ack to be sure
+      // exitedAfterDisconnect is properly set in the primary, otherwise, if
+      // it's primary initiated there's no need to send the
+      // exitedAfterDisconnect message
+      if (primaryInitiated) {
+        process.disconnect();
+      } else {
+        send({ act: 'exitedAfterDisconnect' }, () => process.disconnect());
+      }
+    }
+  }
+
+  for (const handle of handles.values()) {
+    waitingCount++;
+
+    if (handle[owner_symbol])
+      handle[owner_symbol].close(checkWaitingCount);
+    else
+      handle.close(checkWaitingCount);
+  }
+
+  handles.clear();
+  checkWaitingCount();
+}
+
+// Extend generic Worker with methods specific to worker processes.
+Worker.prototype.disconnect = function() {
+  if (this.state !== 'disconnecting' && this.state !== 'destroying') {
+    this.state = 'disconnecting';
+    ReflectApply(_disconnect, this, []);
+  }
+
+  return this;
+};
+
+Worker.prototype.destroy = function() {
+  if (this.state === 'destroying')
+    return;
+
+  this.exitedAfterDisconnect = true;
+  if (!this.isConnected()) {
+    process.exit(kNoFailure);
+  } else {
+    this.state = 'destroying';
+    send({ act: 'exitedAfterDisconnect' }, () => process.disconnect());
+    process.once('disconnect', () => process.exit(kNoFailure));
+  }
+};

lib/internal/cluster/primary.js

@@ -0,0 +1,362 @@
+'use strict';
+
+const {
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSome,
+  ObjectKeys,
+  ObjectValues,
+  SafeMap,
+  StringPrototypeStartsWith,
+} = primordials;
+const {
+  codes: {
+    ERR_SOCKET_BAD_PORT,
+  },
+} = require('internal/errors');
+
+const assert = require('internal/assert');
+const { fork } = require('child_process');
+const path = require('path');
+const EventEmitter = require('events');
+const RoundRobinHandle = require('internal/cluster/round_robin_handle');
+const SharedHandle = require('internal/cluster/shared_handle');
+const Worker = require('internal/cluster/worker');
+const { getInspectPort, isUsingInspector } = require('internal/util/inspector');
+const { internal, sendHelper } = require('internal/cluster/utils');
+const cluster = new EventEmitter();
+const intercom = new EventEmitter();
+const SCHED_NONE = 1;
+const SCHED_RR = 2;
+
+module.exports = cluster;
+
+const handles = new SafeMap();
+cluster.isWorker = false;
+cluster.isMaster = true; // Deprecated alias. Must be same as isPrimary.
+cluster.isPrimary = true;
+cluster.Worker = Worker;
+cluster.workers = {};
+cluster.settings = {};
+cluster.SCHED_NONE = SCHED_NONE;  // Leave it to the operating system.
+cluster.SCHED_RR = SCHED_RR;      // Primary distributes connections.
+
+let ids = 0;
+let initialized = false;
+
+// XXX(bnoordhuis) Fold cluster.schedulingPolicy into cluster.settings?
+let schedulingPolicy = process.env.NODE_CLUSTER_SCHED_POLICY;
+if (schedulingPolicy === 'rr')
+  schedulingPolicy = SCHED_RR;
+else if (schedulingPolicy === 'none')
+  schedulingPolicy = SCHED_NONE;
+else if (process.platform === 'win32') {
+  // Round-robin doesn't perform well on
+  // Windows due to the way IOCP is wired up.
+  schedulingPolicy = SCHED_NONE;
+} else
+  schedulingPolicy = SCHED_RR;
+
+cluster.schedulingPolicy = schedulingPolicy;
+
+cluster.setupPrimary = function(options) {
+  const settings = {
+    args: ArrayPrototypeSlice(process.argv, 2),
+    exec: process.argv[1],
+    execArgv: process.execArgv,
+    silent: false,
+    ...cluster.settings,
+    ...options,
+  };
+
+  // Tell V8 to write profile data for each process to a separate file.
+  // Without --logfile=v8-%p.log, everything ends up in a single, unusable
+  // file. (Unusable because what V8 logs are memory addresses and each
+  // process has its own memory mappings.)
+  if (ArrayPrototypeSome(settings.execArgv,
+                         (s) => StringPrototypeStartsWith(s, '--prof')) &&
+      !ArrayPrototypeSome(settings.execArgv,
+                          (s) => StringPrototypeStartsWith(s, '--logfile='))) {
+    settings.execArgv = [...settings.execArgv, '--logfile=v8-%p.log'];
+  }
+
+  cluster.settings = settings;
+
+  if (initialized === true)
+    return process.nextTick(setupSettingsNT, settings);
+
+  initialized = true;
+  schedulingPolicy = cluster.schedulingPolicy;  // Freeze policy.
+  assert(schedulingPolicy === SCHED_NONE || schedulingPolicy === SCHED_RR,
+         `Bad cluster.schedulingPolicy: ${schedulingPolicy}`);
+
+  process.nextTick(setupSettingsNT, settings);
+
+  process.on('internalMessage', (message) => {
+    if (message.cmd !== 'NODE_DEBUG_ENABLED')
+      return;
+
+    for (const worker of ObjectValues(cluster.workers)) {
+      if (worker.state === 'online' || worker.state === 'listening') {
+        process._debugProcess(worker.process.pid);
+      } else {
+        worker.once('online', function() {
+          process._debugProcess(this.process.pid);
+        });
+      }
+    }
+  });
+};
+
+// Deprecated alias must be same as setupPrimary
+cluster.setupMaster = cluster.setupPrimary;
+
+function setupSettingsNT(settings) {
+  cluster.emit('setup', settings);
+}
+
+function createWorkerProcess(id, env) {
+  const workerEnv = { ...process.env, ...env, NODE_UNIQUE_ID: `${id}` };
+  const execArgv = [...cluster.settings.execArgv];
+
+  if (cluster.settings.inspectPort === null) {
+    throw new ERR_SOCKET_BAD_PORT('Port', null, true);
+  }
+  if (isUsingInspector(cluster.settings.execArgv)) {
+    ArrayPrototypePush(execArgv, `--inspect-port=${getInspectPort(cluster.settings.inspectPort)}`);
+  }
+
+  return fork(cluster.settings.exec, cluster.settings.args, {
+    cwd: cluster.settings.cwd,
+    env: workerEnv,
+    serialization: cluster.settings.serialization,
+    silent: cluster.settings.silent,
+    windowsHide: cluster.settings.windowsHide,
+    execArgv: execArgv,
+    stdio: cluster.settings.stdio,
+    gid: cluster.settings.gid,
+    uid: cluster.settings.uid,
+  });
+}
+
+function removeWorker(worker) {
+  assert(worker);
+  delete cluster.workers[worker.id];
+
+  if (ObjectKeys(cluster.workers).length === 0) {
+    assert(handles.size === 0, 'Resource leak detected.');
+    intercom.emit('disconnect');
+  }
+}
+
+function removeHandlesForWorker(worker) {
+  assert(worker);
+
+  for (const { 0: key, 1: handle } of handles) {
+    if (handle.remove(worker))
+      handles.delete(key);
+  }
+}
+
+cluster.fork = function(env) {
+  cluster.setupPrimary();
+  const id = ++ids;
+  const workerProcess = createWorkerProcess(id, env);
+  const worker = new Worker({
+    id: id,
+    process: workerProcess,
+  });
+
+  worker.on('message', function(message, handle) {
+    cluster.emit('message', this, message, handle);
+  });
+
+  worker.process.once('exit', (exitCode, signalCode) => {
+    /*
+     * Remove the worker from the workers list only
+     * if it has disconnected, otherwise we might
+     * still want to access it.
+     */
+    if (!worker.isConnected()) {
+      removeHandlesForWorker(worker);
+      removeWorker(worker);
+    }
+
+    worker.exitedAfterDisconnect = !!worker.exitedAfterDisconnect;
+    worker.state = 'dead';
+    worker.emit('exit', exitCode, signalCode);
+    cluster.emit('exit', worker, exitCode, signalCode);
+  });
+
+  worker.process.once('disconnect', () => {
+    /*
+     * Now is a good time to remove the handles
+     * associated with this worker because it is
+     * not connected to the primary anymore.
+     */
+    removeHandlesForWorker(worker);
+
+    /*
+     * Remove the worker from the workers list only
+     * if its process has exited. Otherwise, we might
+     * still want to access it.
+     */
+    if (worker.isDead())
+      removeWorker(worker);
+
+    worker.exitedAfterDisconnect = !!worker.exitedAfterDisconnect;
+    worker.state = 'disconnected';
+    worker.emit('disconnect');
+    cluster.emit('disconnect', worker);
+  });
+
+  worker.process.on('internalMessage', internal(worker, onmessage));
+  process.nextTick(emitForkNT, worker);
+  cluster.workers[worker.id] = worker;
+  return worker;
+};
+
+function emitForkNT(worker) {
+  cluster.emit('fork', worker);
+}
+
+cluster.disconnect = function(cb) {
+  const workers = ObjectValues(cluster.workers);
+
+  if (workers.length === 0) {
+    process.nextTick(() => intercom.emit('disconnect'));
+  } else {
+    for (const worker of workers) {
+      if (worker.isConnected()) {
+        worker.disconnect();
+      }
+    }
+  }
+
+  if (typeof cb === 'function')
+    intercom.once('disconnect', cb);
+};
+
+const methodMessageMapping = {
+  close,
+  exitedAfterDisconnect,
+  listening,
+  online,
+  queryServer,
+};
+
+function onmessage(message, handle) {
+  const worker = this;
+
+  const fn = methodMessageMapping[message.act];
+
+  if (typeof fn === 'function')
+    fn(worker, message);
+}
+
+function online(worker) {
+  worker.state = 'online';
+  worker.emit('online');
+  cluster.emit('online', worker);
+}
+
+function exitedAfterDisconnect(worker, message) {
+  worker.exitedAfterDisconnect = true;
+  send(worker, { ack: message.seq });
+}
+
+function queryServer(worker, message) {
+  // Stop processing if worker already disconnecting
+  if (worker.exitedAfterDisconnect)
+    return;
+
+  const key = `${message.address}:${message.port}:${message.addressType}:` +
+              `${message.fd}:${message.index}`;
+  let handle = handles.get(key);
+
+  if (handle === undefined) {
+    let address = message.address;
+
+    // Find shortest path for unix sockets because of the ~100 byte limit
+    if (message.port < 0 && typeof address === 'string' &&
+        process.platform !== 'win32') {
+
+      address = path.relative(process.cwd(), address);
+
+      if (message.address.length < address.length)
+        address = message.address;
+    }
+
+    // UDP is exempt from round-robin connection balancing for what should
+    // be obvious reasons: it's connectionless. There is nothing to send to
+    // the workers except raw datagrams and that's pointless.
+    if (schedulingPolicy !== SCHED_RR ||
+        message.addressType === 'udp4' ||
+        message.addressType === 'udp6') {
+      handle = new SharedHandle(key, address, message);
+    } else {
+      handle = new RoundRobinHandle(key, address, message);
+    }
+
+    handles.set(key, handle);
+  }
+
+  handle.data ||= message.data;
+
+  // Set custom server data
+  handle.add(worker, (errno, reply, handle) => {
+    const { data } = handles.get(key);
+
+    if (errno)
+      handles.delete(key);  // Gives other workers a chance to retry.
+
+    send(worker, {
+      errno,
+      key,
+      ack: message.seq,
+      data,
+      ...reply,
+    }, handle);
+  });
+}
+
+function listening(worker, message) {
+  const info = {
+    addressType: message.addressType,
+    address: message.address,
+    port: message.port,
+    fd: message.fd,
+  };
+
+  worker.state = 'listening';
+  worker.emit('listening', info);
+  cluster.emit('listening', worker, info);
+}
+
+// Server in worker is closing, remove from list. The handle may have been
+// removed by a prior call to removeHandlesForWorker() so guard against that.
+function close(worker, message) {
+  const key = message.key;
+  const handle = handles.get(key);
+
+  if (handle && handle.remove(worker))
+    handles.delete(key);
+}
+
+function send(worker, message, handle, cb) {
+  return sendHelper(worker.process, message, handle, cb);
+}
+
+// Extend generic Worker with methods specific to the primary process.
+Worker.prototype.disconnect = function() {
+  this.exitedAfterDisconnect = true;
+  send(this, { act: 'disconnect' });
+  removeHandlesForWorker(this);
+  removeWorker(this);
+  return this;
+};
+
+Worker.prototype.destroy = function(signo) {
+  const signal = signo || 'SIGTERM';
+  this.process.kill(signal);
+};

lib/internal/cluster/round_robin_handle.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const {
+  ArrayIsArray,
+  Boolean,
+  SafeMap,
+} = primordials;
+
+const assert = require('internal/assert');
+const net = require('net');
+const { sendHelper } = require('internal/cluster/utils');
+const { append, init, isEmpty, peek, remove } = require('internal/linkedlist');
+const { constants } = internalBinding('tcp_wrap');
+
+module.exports = RoundRobinHandle;
+
+function RoundRobinHandle(key, address, { port, fd, flags, backlog, readableAll, writableAll }) {
+  this.key = key;
+  this.all = new SafeMap();
+  this.free = new SafeMap();
+  this.handles = init({ __proto__: null });
+  this.handle = null;
+  this.server = net.createServer(assert.fail);
+
+  if (fd >= 0)
+    this.server.listen({ fd, backlog });
+  else if (port >= 0) {
+    this.server.listen({
+      port,
+      host: address,
+      // Currently, net module only supports `ipv6Only` option in `flags`.
+      ipv6Only: Boolean(flags & constants.UV_TCP_IPV6ONLY),
+      backlog,
+    });
+  } else
+    this.server.listen({
+      path: address,
+      backlog,
+      readableAll,
+      writableAll,
+    });  // UNIX socket path.
+  this.server.once('listening', () => {
+    this.handle = this.server._handle;
+    this.handle.onconnection = (err, handle) => this.distribute(err, handle);
+    this.server._handle = null;
+    this.server = null;
+  });
+}
+
+RoundRobinHandle.prototype.add = function(worker, send) {
+  assert(this.all.has(worker.id) === false);
+  this.all.set(worker.id, worker);
+
+  const done = () => {
+    if (this.handle.getsockname) {
+      const out = {};
+      this.handle.getsockname(out);
+      // TODO(bnoordhuis) Check err.
+      send(null, { sockname: out }, null);
+    } else {
+      send(null, null, null);  // UNIX socket.
+    }
+
+    this.handoff(worker);  // In case there are connections pending.
+  };
+
+  if (this.server === null)
+    return done();
+
+  // Still busy binding.
+  this.server.once('listening', done);
+  this.server.once('error', (err) => {
+    send(err.errno, null);
+  });
+};
+
+RoundRobinHandle.prototype.remove = function(worker) {
+  const existed = this.all.delete(worker.id);
+
+  if (!existed)
+    return false;
+
+  this.free.delete(worker.id);
+
+  if (this.all.size !== 0)
+    return false;
+
+  while (!isEmpty(this.handles)) {
+    const handle = peek(this.handles);
+    handle.close();
+    remove(handle);
+  }
+
+  this.handle.close();
+  this.handle = null;
+  return true;
+};
+
+RoundRobinHandle.prototype.distribute = function(err, handle) {
+  // If `accept` fails just skip it (handle is undefined)
+  if (err) {
+    return;
+  }
+  append(this.handles, handle);
+  // eslint-disable-next-line node-core/no-array-destructuring
+  const [ workerEntry ] = this.free; // this.free is a SafeMap
+
+  if (ArrayIsArray(workerEntry)) {
+    const { 0: workerId, 1: worker } = workerEntry;
+    this.free.delete(workerId);
+    this.handoff(worker);
+  }
+};
+
+RoundRobinHandle.prototype.handoff = function(worker) {
+  if (!this.all.has(worker.id)) {
+    return;  // Worker is closing (or has closed) the server.
+  }
+
+  const handle = peek(this.handles);
+
+  if (handle === null) {
+    this.free.set(worker.id, worker);  // Add to ready queue again.
+    return;
+  }
+
+  remove(handle);
+
+  const message = { act: 'newconn', key: this.key };
+
+  sendHelper(worker.process, message, handle, (reply) => {
+    if (reply.accepted)
+      handle.close();
+    else
+      this.distribute(0, handle);  // Worker is shutting down. Send to another.
+
+    this.handoff(worker);
+  });
+};

lib/internal/cluster/shared_handle.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const {
+  SafeMap,
+} = primordials;
+
+const assert = require('internal/assert');
+const dgram = require('internal/dgram');
+const net = require('net');
+
+module.exports = SharedHandle;
+
+function SharedHandle(key, address, { port, addressType, fd, flags }) {
+  this.key = key;
+  this.workers = new SafeMap();
+  this.handle = null;
+  this.errno = 0;
+
+  let rval;
+  if (addressType === 'udp4' || addressType === 'udp6')
+    rval = dgram._createSocketHandle(address, port, addressType, fd, flags);
+  else
+    rval = net._createServerHandle(address, port, addressType, fd, flags);
+
+  if (typeof rval === 'number')
+    this.errno = rval;
+  else
+    this.handle = rval;
+}
+
+SharedHandle.prototype.add = function(worker, send) {
+  assert(!this.workers.has(worker.id));
+  this.workers.set(worker.id, worker);
+  send(this.errno, null, this.handle);
+};
+
+SharedHandle.prototype.remove = function(worker) {
+  if (!this.workers.has(worker.id))
+    return false;
+
+  this.workers.delete(worker.id);
+
+  if (this.workers.size !== 0)
+    return false;
+
+  this.handle.close();
+  this.handle = null;
+  return true;
+};

lib/internal/cluster/utils.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const {
+  ReflectApply,
+  SafeMap,
+} = primordials;
+
+module.exports = {
+  sendHelper,
+  internal,
+};
+
+const callbacks = new SafeMap();
+let seq = 0;
+
+function sendHelper(proc, message, handle, cb) {
+  if (!proc.connected)
+    return false;
+
+  // Mark message as internal. See INTERNAL_PREFIX
+  // in lib/internal/child_process.js
+  message = { cmd: 'NODE_CLUSTER', ...message, seq };
+
+  if (typeof cb === 'function')
+    callbacks.set(seq, cb);
+
+  seq += 1;
+  return proc.send(message, handle);
+}
+
+// Returns an internalMessage listener that hands off normal messages
+// to the callback but intercepts and redirects ACK messages.
+function internal(worker, cb) {
+  return function onInternalMessage(message, handle) {
+    if (message.cmd !== 'NODE_CLUSTER')
+      return;
+
+    let fn = cb;
+
+    if (message.ack !== undefined) {
+      const callback = callbacks.get(message.ack);
+
+      if (callback !== undefined) {
+        fn = callback;
+        callbacks.delete(message.ack);
+      }
+    }
+
+    ReflectApply(fn, worker, arguments);
+  };
+}

lib/internal/cluster/worker.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const {
+  ObjectSetPrototypeOf,
+  ReflectApply,
+} = primordials;
+
+const EventEmitter = require('events');
+
+const { kEmptyObject } = require('internal/util');
+
+module.exports = Worker;
+
+// Common Worker implementation shared between the cluster primary and workers.
+function Worker(options) {
+  if (!(this instanceof Worker))
+    return new Worker(options);
+
+  ReflectApply(EventEmitter, this, []);
+
+  if (options === null || typeof options !== 'object')
+    options = kEmptyObject;
+
+  this.exitedAfterDisconnect = undefined;
+
+  this.state = options.state || 'none';
+  this.id = options.id | 0;
+
+  if (options.process) {
+    this.process = options.process;
+    this.process.on('error', (code, signal) =>
+      this.emit('error', code, signal),
+    );
+    this.process.on('message', (message, handle) =>
+      this.emit('message', message, handle),
+    );
+  }
+}
+
+ObjectSetPrototypeOf(Worker.prototype, EventEmitter.prototype);
+ObjectSetPrototypeOf(Worker, EventEmitter);
+
+Worker.prototype.kill = function() {
+  ReflectApply(this.destroy, this, arguments);
+};
+
+Worker.prototype.send = function() {
+  return ReflectApply(this.process.send, this.process, arguments);
+};
+
+Worker.prototype.isDead = function() {
+  return this.process.exitCode != null || this.process.signalCode != null;
+};
+
+Worker.prototype.isConnected = function() {
+  return this.process.connected;
+};