creevey 0.10.0-beta.3 → 0.10.0-beta.30

package/src/creevey.ts

@@ -5,14 +5,14 @@ import { Options } from './types.js';
 import { emitWorkerMessage } from './server/messages.js';
 import { isShuttingDown, shutdownWorkers } from './server/utils.js';
 import Logger from 'loglevel';
-import { logger } from './server/logger.js';
+import { logger, setRootName } from './server/logger.js';
 
 function shutdownOnException(reason: unknown): void {
   if (isShuttingDown.current) return;
 
   const error = reason instanceof Error ? (reason.stack ?? reason.message) : (reason as string);
 
-  logger.error(error);
+  logger().error(error);
 
   process.exitCode = -1;
   if (cluster.isWorker) emitWorkerMessage({ type: 'error', payload: { subtype: 'unknown', error } });
@@ -23,19 +23,25 @@ process.on('uncaughtException', shutdownOnException);
 process.on('unhandledRejection', shutdownOnException);
 // TODO SIGINT Stuck with selenium
 process.on('SIGINT', () => {
+  if (isShuttingDown.current) {
+    process.exit(-1);
+  }
   isShuttingDown.current = true;
 });
 
 const argv = minimist<Options>(process.argv.slice(2), {
-  string: ['browser', 'config', 'reporter', 'reportDir', 'screenDir', 'gridUrl', 'storybookUrl'],
-  boolean: ['debug', 'trace', 'ui', 'odiff'],
-  default: { port: 3000 },
-  alias: { port: 'p', config: 'c', debug: 'd', update: 'u' },
+  string: ['browser', 'config', 'reporter', 'reportDir', 'screenDir', 'gridUrl', 'storybookUrl', 'storybookPort'],
+  boolean: ['debug', 'trace', 'ui', 'odiff', 'noDocker'],
+  default: { port: '3000' },
+  alias: { port: 'p', config: 'c', debug: 'd', update: 'u', storybookStart: 's' },
 });
 
+if ('port' in argv && !isNaN(argv.port)) argv.port = Number(argv.port);
+if ('browser' in argv && argv.browser) setRootName(argv.browser);
+
 // eslint-disable-next-line @typescript-eslint/no-deprecated
 if (cluster.isPrimary && argv.reporter) {
-  logger.warn(`--reporter option has been removed please describe reporter in config file:
+  logger().warn(`--reporter option has been removed please describe reporter in config file:
     import { reporters } from 'mocha';
 
     const config = {
@@ -52,13 +58,13 @@ if (cluster.isPrimary && argv.reporter) {
 // @ts-expect-error: define log level for storybook
 global.LOGLEVEL = argv.trace ? 'trace' : argv.debug ? 'debug' : 'warn';
 if (argv.trace) {
-  logger.setDefaultLevel(Logger.levels.TRACE);
+  logger().setDefaultLevel(Logger.levels.TRACE);
   Logger.setDefaultLevel(Logger.levels.TRACE);
 } else if (argv.debug) {
-  logger.setDefaultLevel(Logger.levels.DEBUG);
+  logger().setDefaultLevel(Logger.levels.DEBUG);
   Logger.setDefaultLevel(Logger.levels.DEBUG);
 } else {
-  logger.setDefaultLevel(Logger.levels.INFO);
+  logger().setDefaultLevel(Logger.levels.INFO);
   Logger.setDefaultLevel(Logger.levels.INFO);
 }
 

package/src/server/config.ts

@@ -1,7 +1,8 @@
 import fs from 'fs';
 import path from 'path';
+import cluster from 'cluster';
 import { pathToFileURL } from 'url';
-import { loadStories as browserStoriesProvider } from './providers/browser.js';
+import { loadStories as hybridStoriesProvider } from './providers/hybrid.js';
 import { Config, BrowserConfig, BrowserConfigObject, Options, isDefined } from '../types.js';
 import { configExt, loadThroughTSX } from './utils.js';
 import { CreeveyReporter, TeamcityReporter } from './reporter.js';
@@ -9,25 +10,27 @@ import { logger } from './logger.js';
 
 export const defaultBrowser = 'chrome';
 
-export const defaultConfig: Omit<Config, 'gridUrl' | 'testsDir' | 'tsConfig' | 'webdriver'> = {
+export const defaultConfig: Omit<Config, 'gridUrl' | 'tsConfig' | 'webdriver'> = {
   disableTelemetry: false,
+  useWorkerQueue: false,
   useDocker: true,
-  dockerImage: 'aerokube/selenoid:latest-release',
+  dockerImage: 'aerokube/selenoid:latest-release', // TODO What about playwright?
   dockerImagePlatform: '',
   pullImages: true,
   failFast: false,
   storybookUrl: 'http://localhost:6006',
   screenDir: path.resolve('images'),
   reportDir: path.resolve('report'),
+  testsDir: path.resolve('src'),
   reporter: process.env.TEAMCITY_VERSION ? TeamcityReporter : CreeveyReporter,
-  storiesProvider: browserStoriesProvider,
+  storiesProvider: hybridStoriesProvider,
   maxRetries: 0,
   testTimeout: 30000,
-  diffOptions: { threshold: 0.05, includeAA: false },
-  odiffOptions: { threshold: 0.05, antialiasing: true },
+  diffOptions: { threshold: 0.1, includeAA: false },
+  odiffOptions: { threshold: 0.1, antialiasing: true },
   browsers: { [defaultBrowser]: true },
   hooks: {},
-  testsRegex: /\.creevey\.(t|j)s$/,
+  testsRegex: /\.creevey\.(m|c)?(t|j)s$/,
 };
 
 function normalizeBrowserConfig(name: string, config: BrowserConfig): BrowserConfigObject {
@@ -73,7 +76,7 @@ export async function readConfig(options: Options): Promise<Config> {
 
     if (!configData.webdriver) {
       const { SeleniumWebdriver } = await import('./selenium/webdriver.js');
-      logger.warn(
+      logger().warn(
         "Creevey supports `Selenium` and `Playwright` webdrivers. For backward compatibility `Selenium` is used by default, but it might changed in the future. Please explicitly specify one of webdrivers in your Creevey's config",
       );
       configData.webdriver = SeleniumWebdriver;
@@ -82,10 +85,29 @@ export async function readConfig(options: Options): Promise<Config> {
     Object.assign(userConfig, configData);
   }
 
+  if (userConfig.resolveStorybookUrl && !options.storybookUrl) {
+    userConfig.storybookUrl = await userConfig.resolveStorybookUrl();
+  }
+
+  if (options.noDocker) userConfig.useDocker = false;
   if (options.failFast != undefined) userConfig.failFast = Boolean(options.failFast);
   if (options.reportDir) userConfig.reportDir = path.resolve(options.reportDir);
   if (options.screenDir) userConfig.screenDir = path.resolve(options.screenDir);
   if (options.storybookUrl) userConfig.storybookUrl = options.storybookUrl;
+  if (options.storybookPort && cluster.isPrimary) {
+    const url = new URL(userConfig.storybookUrl);
+    url.port = options.storybookPort;
+    userConfig.storybookUrl = url.toString();
+  }
+  if (typeof options.storybookStart === 'string') userConfig.storybookAutorunCmd = options.storybookStart;
+
+  if (options.storybookStart && cluster.isPrimary) {
+    const { default: getPort } = await import('get-port');
+    const url = new URL(userConfig.storybookUrl);
+    const port = await getPort({ port: Number(url.port) });
+    url.port = `${port}`;
+    userConfig.storybookUrl = url.toString();
+  }
 
   // NOTE: Hack to pass typescript checking
   const config = userConfig as Config;

package/src/server/connection.ts

@@ -0,0 +1,26 @@
+import type { Config, Options } from '../types';
+import { waitOnUrl } from './utils.js';
+import { logger } from './logger.js';
+
+const RESPONSE_CHECK_TIMEOUT_MS = 10000;
+const RESPONSE_CHECK_INTERVAL_MS = 200;
+
+export function getStorybookUrl({ storybookUrl }: Config, { storybookStart }: Options): [string, string | undefined] {
+  if (storybookStart) {
+    const url = new URL(storybookUrl);
+    url.hostname = 'localhost';
+    return [url.toString(), storybookUrl];
+  }
+  return [storybookUrl, undefined];
+}
+
+export async function checkIsStorybookConnected(url: string) {
+  try {
+    await waitOnUrl(url, RESPONSE_CHECK_TIMEOUT_MS, RESPONSE_CHECK_INTERVAL_MS);
+    return true;
+  } catch (reason: unknown) {
+    const error = reason instanceof Error ? (reason.stack ?? reason.message) : (reason as string);
+    logger().error(error);
+    return false;
+  }
+}

package/src/server/docker.ts

@@ -1,4 +1,5 @@
 import tar from 'tar-stream';
+import Logger from 'loglevel';
 import { Writable } from 'stream';
 import Dockerode, { Container } from 'dockerode';
 import { DockerAuth } from '../types.js';
@@ -21,7 +22,7 @@ export async function pullImages(
   if (auth) args.authconfig = auth;
   if (platform) args.platform = platform;
 
-  logger.info('Pull docker images');
+  logger().info('Pull docker images');
   // TODO Replace with `import from`
   const { default: yoctoSpinner } = await import('yocto-spinner');
   for (const image of images) {
@@ -50,7 +51,7 @@ export async function pullImages(
         function onProgress(event: { id: string; status: string; progress?: string }): void {
           if (!/^[a-z0-9]{12}$/i.test(event.id)) return;
 
-          spinner.text = `${image}: [${event.id}] ${event.status} ${event.progress ? event.progress : ''}`;
+          spinner.text = `${image}: [${event.id}] ${event.status} ${event.progress ?? ''}`;
         }
       });
     });
@@ -61,7 +62,17 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
   const images = await docker.listImages({ filters: { label: [`creevey=${imageName}`] } });
 
   if (images.at(0)) {
-    logger.info(`Image ${imageName} already exists`);
+    await Promise.all(
+      (await docker.listContainers({ all: true, filters: { label: [`creevey=${imageName}`] } })).map(async (info) => {
+        const container = docker.getContainer(info.Id);
+        try {
+          await container.remove({ force: true });
+        } catch {
+          /* noop */
+        }
+      }),
+    );
+    logger().info(`Image ${imageName} already exists`);
     return;
   }
 
@@ -70,15 +81,20 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
   pack.finalize();
 
   const { default: yoctoSpinner } = await import('yocto-spinner');
-  const spinner = yoctoSpinner({ text: `${imageName}: Build start` }).start();
+  const spinner = yoctoSpinner({ text: `${imageName}: Build start` });
+  if (logger().getLevel() > Logger.levels.DEBUG) {
+    spinner.start();
+  }
+  let isFailed = false;
   await new Promise<void>((resolve, reject) => {
     void docker.buildImage(
       // @ts-expect-error Type incompatibility AsyncIterator and AsyncIterableIterator
       pack,
-      { t: imageName, labels: { creevey: imageName } },
+      // TODO Support buildkit decode grpc (version: '2')
+      { t: imageName, labels: { creevey: imageName }, version: '1' },
       (buildError: Error | null, stream) => {
         if (buildError || !stream) {
-          spinner.error(buildError?.message);
+          // spinner.error(buildError?.message);
           reject(buildError ?? new Error('Unknown error'));
           return;
         }
@@ -86,6 +102,8 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
         docker.modem.followProgress(stream, onFinished, onProgress);
 
         function onFinished(error: Error | null): void {
+          if (isFailed) return;
+
           if (error) {
             spinner.error(error.message);
             reject(error);
@@ -95,10 +113,23 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
           resolve();
         }
 
-        function onProgress(event: { id: string; status: string; progress?: string }): void {
-          if (!/^[a-z0-9]{12}$/i.test(event.id)) return;
-
-          spinner.text = `${imageName}: [${event.id}] ${event.status} ${event.progress ? event.progress : ''}`;
+        function onProgress(
+          event:
+            | { stream: string }
+            | { errorDetail: { code: number; message: string }; error: string }
+            | { id: string; aux: string }, // NOTE: Only with `version: '2'`
+        ): void {
+          if ('stream' in event) {
+            if (logger().getLevel() <= Logger.levels.DEBUG) {
+              logger().debug(event.stream.trim());
+            } else {
+              spinner.text = `${imageName}: [Build] - ${event.stream}`;
+            }
+          } else if ('errorDetail' in event) {
+            isFailed = true;
+            spinner.error(event.error);
+            reject(new Error(event.error));
+          }
         }
       },
     );
@@ -111,18 +142,6 @@ export async function runImage(
   options: Record<string, unknown>,
   debug: boolean,
 ): Promise<string> {
-  await Promise.all(
-    (await docker.listContainers({ all: true, filters: { ancestor: [image] } })).map(async (info) => {
-      const container = docker.getContainer(info.Id);
-      try {
-        await container.stop();
-      } catch {
-        /* noop */
-      }
-      await container.remove();
-    }),
-  );
-
   const hub = docker.run(image, args, debug ? process.stdout : new DevNull(), options, (error) => {
     if (error) throw error;
   });
@@ -132,8 +151,7 @@ export async function runImage(
       // eslint-disable-next-line @typescript-eslint/no-misused-promises
       subscribeOn('shutdown', async () => {
         try {
-          await container.stop();
-          await container.remove();
+          await container.remove({ force: true });
         } catch {
           /* noop */
         }

package/src/server/index.ts

@@ -1,13 +1,19 @@
 import cluster from 'cluster';
+import path from 'path';
+import { exec } from 'shelljs';
+import { getUserAgent } from 'package-manager-detector/detect';
+import { resolveCommand } from 'package-manager-detector/commands';
 import { readConfig, defaultBrowser } from './config.js';
 import { Options, Config, BrowserConfigObject, isWorkerMessage } from '../types.js';
 import { logger } from './logger.js';
 import { SeleniumWebdriver } from './selenium/webdriver.js';
 import { LOCALHOST_REGEXP } from './webdriver.js';
-import { isInsideDocker } from './utils.js';
-import { sendWorkerMessage } from './messages.js';
-import { playwrightDockerFile } from './playwright/docker-file.js';
+import { isInsideDocker, killTree, resolvePlaywrightBrowserType, shutdownWithError } from './utils.js';
+import { sendWorkerMessage, subscribeOn } from './messages.js';
 import { buildImage } from './docker.js';
+import { mkdir, writeFile } from 'fs/promises';
+import { getStorybookUrl, checkIsStorybookConnected } from './connection.js';
+import assert from 'assert';
 
 async function startWebdriverServer(browser: string, config: Config, options: Options): Promise<string | undefined> {
   if (config.webdriver === SeleniumWebdriver) {
@@ -25,16 +31,19 @@ async function startWebdriverServer(browser: string, config: Config, options: Op
   } else {
     if (config.gridUrl) return undefined;
 
-    // TODO start standalone playwright server (useDocker == false)
+    if (!config.useDocker) {
+      if (cluster.isPrimary) return undefined;
+
+      const { browserName } = config.browsers[browser] as BrowserConfigObject;
+      return `creevey://${resolvePlaywrightBrowserType(browserName)}.playwright`;
+    }
+
     const {
       default: { version },
     } = await import('playwright-core/package.json', { with: { type: 'json' } });
 
     if (cluster.isWorker) {
       // TODO Re-use dockerImage
-
-      // TODO Use https://hub.docker.com/r/playwright/chrome
-      // NOTE It will be possible to use `chrome` browserName
       const { startPlaywrightContainer } = await import('./playwright/docker.js');
       const { browserName } = config.browsers[browser] as BrowserConfigObject;
 
@@ -43,11 +52,18 @@ async function startWebdriverServer(browser: string, config: Config, options: Op
 
       return host;
     } else {
-      const browsers = [...new Set(Object.values(config.browsers).map((c) => (c as BrowserConfigObject).browserName))];
+      const { playwrightDockerFile } = await import('./playwright/docker-file.js');
+      const browsers = [
+        ...new Set(
+          Object.values(config.browsers).map(
+            (c) => [(c as BrowserConfigObject).browserName, (c as BrowserConfigObject).playwrightOptions] as const,
+          ),
+        ),
+      ];
       await Promise.all(
-        browsers.map(async (browserName) => {
+        browsers.map(async ([browserName, launchOptions]) => {
           const imageName = `creevey/${browserName}:v${version}`;
-          const dockerfile = playwrightDockerFile(browserName, version);
+          const dockerfile = playwrightDockerFile(browserName, version, launchOptions);
 
           await buildImage(imageName, dockerfile);
         }),
@@ -79,6 +95,10 @@ export default async function (options: Options): Promise<void> {
   const { browser = defaultBrowser, update, ui, port } = options;
   let gridUrl = cluster.isPrimary ? config.gridUrl : options.gridUrl;
 
+  // TODO Add package.json with `"type": "commonjs"` as workaround for esm packages to load `data.js`
+  await mkdir(config.reportDir, { recursive: true });
+  await writeFile(path.join(config.reportDir, 'package.json'), '{"type": "commonjs"}');
+
   // NOTE: We don't need docker nor selenoid for update option
   if (
     !(gridUrl || (Object.values(config.browsers) as BrowserConfigObject[]).every(({ gridUrl }) => gridUrl)) &&
@@ -87,6 +107,45 @@ export default async function (options: Options): Promise<void> {
     gridUrl = await startWebdriverServer(browser, config, options);
   }
 
+  if (cluster.isPrimary) {
+    const [localUrl, remoteUrl] = getStorybookUrl(config, options);
+    const pm = getUserAgent();
+    assert(pm, new Error('Failed to detect current package manager'));
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const { command, args } = resolveCommand(pm, 'run', ['storybook', 'dev'])!;
+
+    if (options.storybookStart) {
+      const storybookPort = new URL(localUrl).port;
+      const storybookCommand = `${config.storybookAutorunCmd ?? [command, ...args, '--ci'].join(' ')} -p ${storybookPort}`;
+
+      logger().info(`Start Storybook via \`${storybookCommand}\`, it should be accessible at:`);
+      logger().info(`Local - ${localUrl}`);
+      if (remoteUrl && localUrl != remoteUrl) logger().info(`On your network - ${remoteUrl}`);
+      logger().info('Waiting Storybook...');
+
+      const storybook = exec(storybookCommand, { async: true });
+      subscribeOn('shutdown', () => {
+        if (storybook.pid) void killTree(storybook.pid);
+      });
+    } else {
+      logger().info('Storybook should be started and be accessible at:');
+      logger().info(`Local - ${localUrl}`);
+      if (remoteUrl && localUrl != remoteUrl) logger().info(`On your network - ${remoteUrl}`);
+      logger().info(
+        'Tip: Creevey can start Storybook automatically by using `-s` option at the command line. (e.g., yarn/npm run creevey -s)',
+      );
+      logger().info('Waiting Storybook...');
+    }
+
+    const isConnected = await checkIsStorybookConnected(localUrl);
+    if (isConnected) {
+      logger().info('Storybook connected!\n');
+    } else {
+      logger().error('Storybook is not responding. Please start Storybook and restart Creevey');
+      shutdownWithError();
+    }
+  }
+
   switch (true) {
     case Boolean(update): {
       (await import('./update.js')).update(config, typeof update == 'string' ? update : undefined);
@@ -97,25 +156,25 @@ export default async function (options: Options): Promise<void> {
         try {
           await import('selenium-webdriver');
         } catch {
-          logger.error('Failed to start Creevey, missing required dependency: "selenium-webdriver"');
+          logger().error('Failed to start Creevey, missing required dependency: "selenium-webdriver"');
           process.exit(-1);
         }
       } else {
         try {
           await import('playwright-core');
         } catch {
-          logger.error('Failed to start Creevey, missing required dependency: "playwright-core"');
+          logger().error('Failed to start Creevey, missing required dependency: "playwright-core"');
           process.exit(-1);
         }
       }
-      logger.info('Starting Master Process');
+      logger().info('Starting Master Process');
 
       const resolveApi = (await import('./master/server.js')).start(config.reportDir, port, ui);
 
       return (await import('./master/start.js')).start(gridUrl, config, options, resolveApi);
     }
     default: {
-      logger.info(`Starting Worker for ${browser}`);
+      logger().info(`Starting Worker for ${browser}`);
 
       // NOTE: We assume that we pass `gridUrl` to worker CLI options
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/src/server/logger.ts

@@ -10,12 +10,16 @@ export const colors = {
   ERROR: chalk.red,
 };
 
+let rootName = 'Creevey';
+
 prefix.reg(Logger);
 prefix.apply(Logger, {
-  format(level, name = 'Creevey') {
+  format(level, name = rootName) {
     const levelColor = colors[level.toUpperCase() as keyof typeof colors];
     return `[${name}:${chalk.gray(process.pid)}] ${levelColor(level)} =>`;
   },
 });
 
-export const logger = Logger.getLogger('Creevey');
+export const setRootName = (newName: string) => (rootName = newName);
+
+export const logger = () => Logger.getLogger(rootName);

package/src/server/master/api.ts

@@ -26,7 +26,7 @@ export default function creeveyApi(runner: Runner): CreeveyApi {
 
     handleMessage(ws: WebSocket, message: WebSocket.Data) {
       if (typeof message != 'string') {
-        logger.info('unhandled message', message);
+        logger().info('unhandled message', message);
         return;
       }
 

package/src/server/master/pool.ts

@@ -1,18 +1,9 @@
-import cluster, { Worker as ClusterWorker } from 'cluster';
+import { Worker as ClusterWorker } from 'cluster';
 import { EventEmitter } from 'events';
-import {
-  Worker,
-  Config,
-  TestResult,
-  BrowserConfigObject,
-  WorkerMessage,
-  TestStatus,
-  isWorkerMessage,
-} from '../../types.js';
-import { sendTestMessage, sendShutdownMessage, subscribeOnWorker } from '../messages.js';
-import { isShuttingDown } from '../utils.js';
-
-const FORK_RETRIES = 5;
+import { Worker, Config, TestResult, BrowserConfigObject, TestStatus } from '../../types.js';
+import { sendTestMessage, subscribeOnWorker } from '../messages.js';
+import { gracefullyKill, isShuttingDown } from '../utils.js';
+import { WorkerQueue } from './queue.js';
 
 interface WorkerTest {
   id: string;
@@ -28,10 +19,12 @@ export default class Pool extends EventEmitter {
   private forcedStop = false;
   private failFast: boolean;
   private gridUrl?: string;
+  private storybookUrl: string;
   public get isRunning(): boolean {
     return this.workers.length !== this.freeWorkers.length;
   }
   constructor(
+    public scheduler: WorkerQueue,
     config: Config,
     private browser: string,
     gridUrl?: string,
@@ -42,14 +35,18 @@ export default class Pool extends EventEmitter {
     this.maxRetries = config.maxRetries;
     this.config = config.browsers[browser] as BrowserConfigObject;
     this.gridUrl = this.config.gridUrl ?? gridUrl;
+    this.storybookUrl = this.config.storybookUrl ?? config.storybookUrl;
   }
 
   async init(): Promise<void> {
     const poolSize = Math.max(1, this.config.limit ?? 1);
-    // TODO Init queue for workers to smooth browser starting load
-    this.workers = (await Promise.all(Array.from({ length: poolSize }).map(() => this.forkWorker()))).filter(
-      (workerOrError): workerOrError is Worker => workerOrError instanceof ClusterWorker,
-    );
+    this.workers = (
+      await Promise.all(
+        Array.from({ length: poolSize }).map(() =>
+          this.scheduler.forkWorker(this.browser, this.storybookUrl, this.gridUrl),
+        ),
+      )
+    ).filter((workerOrError): workerOrError is Worker => workerOrError instanceof ClusterWorker);
     if (this.workers.length != poolSize)
       throw new Error(`Can't instantiate workers for ${this.browser} due many errors`);
     this.workers.forEach((worker) => {
@@ -66,7 +63,7 @@ export default class Pool extends EventEmitter {
     return true;
   }
 
-  stop(): void {
+  stop() {
     if (!this.isRunning) {
       this.emit('stop');
       return;
@@ -76,7 +73,7 @@ export default class Pool extends EventEmitter {
     this.queue = [];
   }
 
-  process(): void {
+  process() {
     const worker = this.getFreeWorker();
     const test = this.queue.at(0);
 
@@ -99,7 +96,9 @@ export default class Pool extends EventEmitter {
 
     sendTestMessage(worker, { type: 'start', payload: test });
 
-    this.process();
+    setImmediate(() => {
+      this.process();
+    });
   }
 
   private sendStatus(message: { id: string; status: TestStatus; result?: TestResult }): void {
@@ -120,34 +119,12 @@ export default class Pool extends EventEmitter {
     return this.aliveWorkers.filter((worker) => !worker.isRunning);
   }
 
-  private async forkWorker(retry = 0): Promise<Worker | { error: string }> {
-    cluster.setupPrimary({
-      args: ['--browser', this.browser, ...(this.gridUrl ? ['--gridUrl', this.gridUrl] : []), ...process.argv.slice(2)],
-    });
-    const worker = cluster.fork();
-    const message = await new Promise((resolve: (value: WorkerMessage) => void) => {
-      const readyHandler = (message: unknown): void => {
-        if (!isWorkerMessage(message) || message.type == 'port') return;
-        worker.off('message', readyHandler);
-        resolve(message);
-      };
-      worker.on('message', readyHandler);
-    });
-
-    if (message.type != 'error') return worker;
-
-    this.gracefullyKill(worker);
-
-    if (retry == FORK_RETRIES) return message.payload;
-    return this.forkWorker(retry + 1);
-  }
-
   private exitHandler(worker: Worker): void {
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     worker.once('exit', async () => {
       if (isShuttingDown.current) return;
 
-      const workerOrError = await this.forkWorker();
+      const workerOrError = await this.scheduler.forkWorker(this.browser, this.storybookUrl, this.gridUrl);
 
       if (!(workerOrError instanceof ClusterWorker))
         throw new Error(`Can't instantiate worker for ${this.browser} due many errors`);
@@ -158,17 +135,6 @@ export default class Pool extends EventEmitter {
     });
   }
 
-  private gracefullyKill(worker: Worker): void {
-    worker.isShuttingDown = true;
-    const timeout = setTimeout(() => {
-      worker.kill();
-    }, 10000);
-    worker.on('exit', () => {
-      clearTimeout(timeout);
-    });
-    sendShutdownMessage(worker);
-  }
-
   private shouldRetry(test: WorkerTest): boolean {
     return test.retries < this.maxRetries && !this.forcedStop;
   }
@@ -200,7 +166,7 @@ export default class Pool extends EventEmitter {
         });
 
         if (message.payload.subtype == 'unknown') {
-          this.gracefullyKill(worker);
+          gracefullyKill(worker);
         }
 
         this.handleTestResult(worker, test, { status: 'failed', error: message.payload.error });