1
// Copyright (c) 2017-2022 Cloudflare, Inc.
2
// Licensed under the Apache 2.0 license found in the LICENSE file or at:
3
//     https://opensource.org/licenses/Apache-2.0
4
// Copyright Joyent and Node contributors. All rights reserved. MIT license.
5
 
6
// Usage of `any` is required because types/node is using it...
7
/* eslint-disable @typescript-eslint/no-explicit-any */
8
 
9
import type {
10
  Cluster as _Cluster,
11
  Worker as _Worker,
12
  ClusterSettings,
13
  WorkerOptions,
14
} from 'node:cluster';
15
import { EventEmitter } from 'node-internal:events';
16
import { ERR_METHOD_NOT_IMPLEMENTED } from 'node-internal:internal_errors';
17
 
18
export const SCHED_NONE = 1;
19
export const SCHED_RR = 2;
20
 
21
export const isMaster = true;
22
export const isPrimary = true;
23
export const isWorker = false;
24
 
25
export const schedulingPolicy = SCHED_RR;
26
export const settings: ClusterSettings = {};
27
export const workers: NodeJS.Dict<Worker> = {};
28
 
29
export function fork(_env?: unknown): Worker {
30
  throw new ERR_METHOD_NOT_IMPLEMENTED('cluster.fork');
31
}
32
 
33
export function disconnect(_callback?: () => void): void {
34
  throw new ERR_METHOD_NOT_IMPLEMENTED('cluster.disconnect');
35
}
36
 
37
export function setupPrimary(_settings?: ClusterSettings): void {
38
  throw new ERR_METHOD_NOT_IMPLEMENTED('cluster.setupPrimary');
39
}
40
 
41
export function setupMaster(_settings?: ClusterSettings): void {
42
  throw new ERR_METHOD_NOT_IMPLEMENTED('cluster.setupWorker');
43
}
44
 
45
export const _events: unknown[] = [];
46
export const _eventsCount = 0;
47
export const _maxListeners = 0;
48
 
49
export class Worker extends EventEmitter implements _Worker {
50
  _connected: boolean = false;
51
  id = 0;
52
 
53
  constructor(_options?: WorkerOptions) {
54
    super();
55
  }
56
 
57
  get process(): any {
58
    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
59
    return globalThis.process as any;
60
  }
61
  get exitedAfterDisconnect(): boolean {
62
    return this._connected;
63
  }
64
  isConnected(): boolean {
65
    return this._connected;
66
  }
67
  isDead(): boolean {
68
    return true;
69
  }
70
  send(
71
    _message: any,
72
    _sendHandle?: any,
73
    _options?: any,
74
    _callback?: any
75
  ): boolean {
76
    return false;
77
  }
78
  kill(_signal?: string): void {
79
    this._connected = false;
80
  }
81
  destroy(_signal?: string): void {
82
    this._connected = false;
83
  }
84
  disconnect(): this {
85
    this._connected = false;
86
    return this;
87
  }
88
}
89
 
90
export class Cluster extends EventEmitter implements _Cluster {
91
  Worker = Worker;
92
  isMaster = isMaster;
93
  isPrimary = isPrimary;
94
  isWorker = isWorker;
95
  SCHED_NONE = SCHED_NONE;
96
  SCHED_RR = SCHED_RR;
97
  schedulingPolicy = SCHED_RR;
98
  settings = settings;
99
  workers = workers;
100
  setupPrimary(settings?: ClusterSettings): void {
101
    setupPrimary(settings);
102
  }
103
  setupMaster(settings?: ClusterSettings): void {
104
    setupMaster(settings);
105
  }
106
  disconnect(): void {
107
    disconnect();
108
  }
109
  fork(env?: any): Worker {
110
    return fork(env);
111
  }
112
}
113
 
114
export default new Cluster();