export function spawnWorker () {
  let worker = cluster.fork();

  if (!memshared.store['workerIds']) {
    memshared.store['workerIds'] = [];
  }

  // push worker id to shared workers list.
  memshared.store['workerIds'].push(worker.process.pid);

  // push worker to workers list
  workers.push(worker);

  enableProcessCommunication(worker);

  // auto-spawn a new worker on failure
  worker.on("exit", () => {
    console.warn("worker", process.pid, "died. Respawn.")

    // remove workerId from shared store
    spliceOne(memshared.store['workerIds'], memshared.store['workerIds'].indexOf(process.pid));

    // remove worker from workers list.
    spliceOne(workers, workers.indexOf(worker));

    // spawn new worker as a replacement for this one
    spawnWorker();
  });

  return worker;
}

 private static forkListenerProcesses (numberOfCores: number): void {
   for (let i = 0; i < numberOfCores; i++) {
     cluster.fork()
   }
   cluster.on('exit', (worker, code, signal) => {
     logger.info(`Worker ${worker.process.pid} exited with ${code ? code : signal}`)
   })
 }

  /**
   * Start crawling
   */
  protected async crawl(): Promise<void> {
    await this.crawlUrl(this.getStartingUrl(), this.worker);

    for (let i = 1; i < numCPUs; i++) {
      cluster.fork();
    }

    await this.crawlUrlData();
  }

  function spawnMore() {
    let worker;
    if (options.worker) {
      worker = child.fork(options.worker, options.workerArgs);
      log.debug("Spawning worker %s as child process: %j %j",
                pid(worker), options.worker, options.workerArgs);
    } else {
      worker = cluster.fork();
      log.debug("Spawning worker in cluster:", pid(worker));
    }

    startTimes[pid(worker)] = Date.now();
    if (!options.worker) {
      worker.on("listening", (addr) =>
                log.info("Process", pid(worker), "is now listening on",
                         addr.address + ":" + addr.port));
    }

    // Enable Erlang mode
    worker.on("exit", (code, signal) => {
      const lifetime = Date.now() - startTimes[pid(worker)];
      let replacement;
      delete startTimes[pid(worker)];

      if (worker.suicide) {
        log.info("Worker", pid(worker), "terminated voluntarily.");
        return;
      }

      log.info("Process", pid(worker), "terminated with signal", signal,
                  "code", code + "; restarting.");

      if (lifetime < options.failureThreshold) {
        failures++;
      } else {
        failures = 0;
      }

      if (failures > options.retryThreshold) {
        log.warn(failures + " consecutive failures; pausing for",
                 options.retryDelay + "ms before respawning.");
      }

      setTimeout(() => {
        replacement = spawnMore();
        replacement.on("online", () =>
                       log.info("Process", replacement.process.pid,
                                "has successfully replaced", pid(worker)));
      }, (failures > options.retryThreshold) ? options.retryDelay : 0);
    });

    return worker;
  }

    cluster.on( 'exit', function( deadWorker, code, signal ) {
        const worker = cluster.fork();

        // Note the process IDs
        const newPID = worker.process.pid;
        const oldPID = deadWorker.process.pid;

        console.log( `Cluster ${worker.process.pid} died` );
        console.log( `Attempting to restart failed cluster` );

        // Log the event
        console.log( `worker ${oldPID} died` );
        console.log( `worker ${newPID} born` );
    });

   function forkOne(){
      let worker = cluster.fork();

      worker.send({
        config,
        clientConfig,
        flags
      });

      worker.on('disconnect', () => {
         worker.kill('SIGTERM');
         forkOne();
      });
   }

async function createWorkers(serverName: string, queueName: string): Promise<cluster.Worker[]> {
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    return new Promise<cluster.Worker[]>(((resolve, reject) => {
        const onlineWorkers: cluster.Worker[] = [];
        cluster.on('online', (worker: cluster.Worker) => {
            onlineWorkers.push(worker);
            if (onlineWorkers.length === numCPUs) {
                resolve(onlineWorkers);
            }
        });
    }));
}

async function main() {
    if (cluster.isMaster) {
        // tslint:disable-next-line
        console.log(`Master ${process.pid} is running`);

        // Fork workers.
        for (let i = 0; i < numCPUs; i++) {
            cluster.fork();
        }

        cluster.on("exit", (worker, code, signal) => {
            // tslint:disable-next-line
            console.log(`worker ${worker.process.pid} died`);
        });
    } else {
        const db = await dbClient.connect();
        Container.set(Db, db);

        // Workers can share any TCP connection
        // In this case it is an HTTP server
        const playground = {
            settings: {
                "editor.cursorShape": "line",
            } as any,
        };

        const server = new ApolloServer({
            schema,
            playground,
        });

        server.listen(config.PORT, () =>
            // tslint:disable-next-line
            console.log(
                `Dictionary service is running on http://localhost:${
                    config.PORT
                }`,
            ),
        );

        // tslint:disable-next-line
        console.log(`Worker ${process.pid} started`);
    }
}

/**
 * Spawn workers
 */
function spawn(callback: any): void {
	// Count the machine's CPUs
	const cpuCount = os.cpus().length;

	const progress = new ProgressBar(cpuCount, 'Starting workers');

	// Create a worker for each CPU
	for (let i = 0; i < cpuCount; i++) {
		const worker = cluster.fork();
		worker.on('message', message => {
			if (message === 'ready') {
				progress.increment();
			}
		});
	}

	// On all workers started
	progress.on('complete', () => {
		callback();
	});
}

  const spawn = () => {
    const worker = clusterFork(env);
    remoteBus.target = createProcessBus(family, worker, localBus);

    worker.on("disconnect", () => {
      remoteBus.target = undefined;

      // add timeout in case the worker is crashing repeatedly
      setTimeout(spawn, 1000);
    });
  };