@runium/core 0.0.7 → 0.0.9

package/src/task.ts

@@ -0,0 +1,381 @@
+import {
+  ChildProcessWithoutNullStreams,
+  SpawnOptionsWithoutStdio,
+  spawn,
+} from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { createWriteStream, WriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+/**
+ * Task status
+ */
+export enum TaskStatus {
+  IDLE = 'idle',
+  STARTING = 'starting',
+  STARTED = 'started',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+  STOPPING = 'stopping',
+  STOPPED = 'stopped',
+}
+
+/**
+ * Task event
+ */
+export enum TaskEvent {
+  STATE_CHANGE = 'state-change',
+  STDOUT = 'stdout',
+  STDERR = 'stderr',
+}
+
+/**
+ * Base runium task state
+ */
+export interface RuniumTaskState {
+  status: TaskStatus;
+  timestamp: number;
+  iteration: number;
+  exitCode?: number;
+  error?: Error;
+  reason?: string;
+}
+
+/**
+ * Task options
+ */
+export interface TaskOptions {
+  command: string;
+  arguments?: string[];
+  shell?: boolean;
+  stopSignal?: string;
+  cwd?: string;
+  env?: { [key: string]: string | number | boolean };
+  ttl?: number;
+  log?: {
+    stdout?: string | null;
+    stderr?: string | null;
+  };
+}
+
+/**
+ * Task state
+ */
+export interface TaskState extends RuniumTaskState {
+  pid: number;
+}
+
+/**
+ * Runium task constructor
+ */
+export type RuniumTaskConstructor<
+  Options = unknown,
+  State extends RuniumTaskState = RuniumTaskState,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+> = new (options: any) => RuniumTask<Options, State>;
+
+/**
+ * Silent exit code
+ * use when stopping task without error
+ */
+export const SILENT_EXIT_CODE = -1;
+
+const MAX_LISTENERS_COUNT = 50;
+
+/**
+ * Base runium task class
+ */
+export abstract class RuniumTask<
+  Options = unknown,
+  State = RuniumTaskState,
+> extends EventEmitter {
+  protected constructor(protected options: Options) {
+    super();
+  }
+  abstract getOptions(): Options;
+  abstract getState(): State;
+  abstract start(): Promise<void>;
+  abstract stop(reason?: string): Promise<void>;
+  abstract restart(): Promise<void>;
+}
+
+/**
+ * Task class
+ */
+export class Task extends RuniumTask<TaskOptions, TaskState> {
+  protected state: TaskState = {
+    status: TaskStatus.IDLE,
+    pid: -1,
+    timestamp: Date.now(),
+    iteration: 0,
+  };
+  protected process: ChildProcessWithoutNullStreams | null = null;
+  protected stdoutStream: WriteStream | null = null;
+  protected stderrStream: WriteStream | null = null;
+  protected ttlTimer: NodeJS.Timeout | null = null;
+
+  constructor(protected readonly options: TaskOptions) {
+    super(options);
+    this.setMaxListeners(MAX_LISTENERS_COUNT);
+
+    this.options.env = {
+      ...process.env,
+      ...(options.env || {}),
+    } as TaskOptions['env'];
+    this.options.cwd = resolve(process.cwd(), options.cwd || '');
+  }
+
+  /**
+   * Get task state
+   */
+  getState(): TaskState {
+    return { ...this.state };
+  }
+
+  /**
+   * Get task options
+   */
+  getOptions(): TaskOptions {
+    return { ...this.options };
+  }
+
+  /**
+   * Check if task can start
+   */
+  protected canStart(): boolean {
+    const { status } = this.state;
+    return (
+      status !== TaskStatus.STARTED &&
+      status !== TaskStatus.STARTING &&
+      status !== TaskStatus.STOPPING
+    );
+  }
+
+  /**
+   * Start task
+   */
+  async start(): Promise<void> {
+    if (!this.canStart()) {
+      return;
+    }
+
+    this.updateState({
+      status: TaskStatus.STARTING,
+      iteration: this.state.iteration + 1,
+      pid: -1,
+      exitCode: undefined,
+      error: undefined,
+    });
+
+    try {
+      await this.initLogStreams();
+
+      const {
+        cwd,
+        command,
+        arguments: args = [],
+        env,
+        shell = true,
+      } = this.options;
+
+      this.process = spawn(command, args, {
+        cwd,
+        env: env as NodeJS.ProcessEnv,
+        shell,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      } as SpawnOptionsWithoutStdio);
+
+      this.addProcessListeners();
+      this.setTTLTimer();
+
+      this.updateState({
+        status: TaskStatus.STARTED,
+        pid: this.process!.pid,
+      });
+    } catch (error) {
+      this.onError(error as Error);
+    }
+  }
+
+  /**
+   * Check if task can stop
+   */
+  protected canStop(): boolean {
+    const { status } = this.state;
+    return !!this.process && status === TaskStatus.STARTED;
+  }
+
+  /**
+   * Stop task
+   * @param reason
+   */
+  async stop(reason: string = ''): Promise<void> {
+    if (!this.canStop()) {
+      return;
+    }
+
+    this.updateState({
+      status: TaskStatus.STOPPING,
+      reason,
+    });
+
+    return new Promise(resolve => {
+      const signal = this.options.stopSignal || 'SIGTERM';
+      this.process!.kill(signal as NodeJS.Signals);
+      this.process!.on('exit', () => {
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Restart task
+   */
+  async restart(): Promise<void> {
+    await this.stop('restart');
+    this.start();
+  }
+
+  /**
+   * Update task state
+   */
+  protected updateState(state: Partial<TaskState>): void {
+    const newState = { ...this.state, ...state, timestamp: Date.now() };
+    this.state = Object.fromEntries(
+      Object.entries(newState).filter(([_, value]) => {
+        return value !== undefined;
+      })
+    ) as unknown as TaskState;
+    this.emit(TaskEvent.STATE_CHANGE, this.getState());
+    this.emit(this.state.status, this.getState());
+  }
+
+  /**
+   * Initialize log streams
+   */
+  protected async initLogStreams(): Promise<void> {
+    const { stdout = null, stderr = null } = this.options.log || {};
+    if (stdout) {
+      const stdOutPath = resolve(stdout);
+      await mkdir(dirname(stdOutPath), { recursive: true });
+      this.stdoutStream = createWriteStream(stdout, {
+        flags: 'w',
+      });
+    }
+    if (stderr) {
+      const stdErrPath = resolve(stderr);
+      await mkdir(dirname(stdErrPath), { recursive: true });
+      this.stderrStream = createWriteStream(stderr, {
+        flags: 'w',
+      });
+    }
+  }
+
+  /**
+   * Set TTL timer
+   */
+  protected setTTLTimer(): void {
+    const { ttl } = this.options;
+    if (ttl && this.process) {
+      this.ttlTimer = setTimeout(() => {
+        this.stop('ttl');
+      }, ttl);
+    }
+  }
+
+  /**
+   * Add process listeners
+   */
+  protected addProcessListeners(): void {
+    if (!this.process) return;
+
+    this.process.stdout?.on('data', (data: Buffer) => this.onStdOutData(data));
+
+    this.process.stderr?.on('data', (data: Buffer) => this.onStdErrData(data));
+
+    this.process.on('exit', (code: number | null) => this.onExit(code));
+
+    this.process.on('error', (error: Error) => this.onError(error));
+  }
+
+  /**
+   * On standard output data
+   */
+  protected onStdOutData(data: Buffer): void {
+    const output = data.toString();
+    this.emit(TaskEvent.STDOUT, output);
+    if (this.stdoutStream) {
+      this.stdoutStream!.write(output);
+    }
+  }
+
+  /**
+   * On standard error data
+   */
+  protected onStdErrData(data: Buffer): void {
+    const output = data.toString();
+    this.emit(TaskEvent.STDERR, output);
+    if (this.stderrStream) {
+      this.stderrStream!.write(output);
+    }
+  }
+
+  /**
+   * On exit
+   */
+  protected onExit(code: number | null): void {
+    const exitCode = code !== null ? code : SILENT_EXIT_CODE;
+
+    this.updateState({
+      status:
+        exitCode === 0
+          ? TaskStatus.COMPLETED
+          : exitCode === SILENT_EXIT_CODE
+            ? TaskStatus.STOPPED
+            : TaskStatus.FAILED,
+      exitCode,
+    });
+
+    this.cleanup();
+  }
+
+  /**
+   * On error
+   */
+  protected onError(error: Error): void {
+    this.updateState({
+      status: TaskStatus.FAILED,
+      error,
+    });
+
+    this.cleanup();
+  }
+
+  /**
+   * Cleanup
+   */
+  protected cleanup(): void {
+    if (this.ttlTimer) {
+      clearTimeout(this.ttlTimer);
+      this.ttlTimer = null;
+    }
+
+    if (this.process) {
+      this.process.removeAllListeners();
+      this.process.stdout?.removeAllListeners();
+      this.process.stderr?.removeAllListeners();
+      this.process = null;
+    }
+
+    if (this.stdoutStream) {
+      this.stdoutStream.end();
+      this.stdoutStream = null;
+    }
+
+    if (this.stderrStream) {
+      this.stderrStream.end();
+      this.stderrStream = null;
+    }
+  }
+}

package/src/trigger.ts

@@ -0,0 +1,170 @@
+import { ProjectAction } from './project-config';
+
+/**
+ * Base runium trigger options
+ */
+export interface RuniumTriggerOptions {
+  id: string;
+  action: ProjectAction;
+  disabled?: boolean;
+}
+
+/**
+ * Base runium trigger project accessible interface
+ */
+export interface RuniumTriggerProjectAccessible {
+  processAction(action: ProjectAction): void;
+  on: NodeJS.EventEmitter['on'];
+  off: NodeJS.EventEmitter['off'];
+}
+
+/**
+ * Runium trigger constructor
+ */
+export type RuniumTriggerConstructor<Options extends RuniumTriggerOptions> =
+  new (
+    options: Options,
+    project: RuniumTriggerProjectAccessible
+  ) => RuniumTrigger<Options>;
+
+/**
+ * Base runium trigger class
+ */
+export abstract class RuniumTrigger<Options extends RuniumTriggerOptions> {
+  protected project: RuniumTriggerProjectAccessible;
+  protected id: string;
+  protected action: ProjectAction;
+  protected disabled: boolean;
+
+  constructor(options: Options, project: RuniumTriggerProjectAccessible) {
+    this.id = options.id;
+    this.action = options.action;
+    this.disabled = options.disabled ?? false;
+    this.project = project;
+  }
+
+  abstract enable(): void;
+  abstract disable(): void;
+
+  /**
+   * Get trigger id
+   */
+  getId(): string {
+    return this.id;
+  }
+
+  /**
+   * Check if trigger is disabled
+   */
+  isDisabled(): boolean {
+    return this.disabled;
+  }
+}
+
+/**
+ * Event trigger options
+ */
+export interface EventTriggerOptions extends RuniumTriggerOptions {
+  event: string;
+}
+
+/**
+ * Event trigger class
+ */
+export class EventTrigger extends RuniumTrigger<EventTriggerOptions> {
+  private readonly event: string;
+
+  constructor(
+    options: EventTriggerOptions,
+    project: RuniumTriggerProjectAccessible
+  ) {
+    super(options, project);
+    this.event = options.event;
+  }
+
+  enable(): void {
+    this.project.on(this.event, this.handler);
+    this.disabled = false;
+  }
+
+  disable(): void {
+    this.project.off(this.event, this.handler);
+    this.disabled = true;
+  }
+
+  private handler = () => {
+    this.project.processAction(this.action);
+  };
+}
+
+/**
+ * Interval trigger options
+ */
+export interface IntervalTriggerOptions extends RuniumTriggerOptions {
+  interval: number;
+}
+
+/**
+ * Interval trigger class
+ */
+export class IntervalTrigger extends RuniumTrigger<IntervalTriggerOptions> {
+  private readonly interval: number;
+  private intervalId: NodeJS.Timeout | null = null;
+
+  constructor(
+    options: IntervalTriggerOptions,
+    project: RuniumTriggerProjectAccessible
+  ) {
+    super(options, project);
+    this.interval = options.interval;
+  }
+
+  enable(): void {
+    this.intervalId = setInterval(() => {
+      this.project.processAction(this.action);
+    }, this.interval);
+    this.disabled = false;
+  }
+
+  disable(): void {
+    this.intervalId && clearInterval(this.intervalId);
+    this.disabled = true;
+    this.intervalId = null;
+  }
+}
+
+/**
+ * Timeout trigger options
+ */
+export interface TimeoutTriggerOptions extends RuniumTriggerOptions {
+  timeout: number;
+}
+
+/**
+ * Timeout trigger class
+ */
+export class TimeoutTrigger extends RuniumTrigger<TimeoutTriggerOptions> {
+  private readonly timeout: number;
+  private timeoutId: NodeJS.Timeout | null = null;
+
+  constructor(
+    options: TimeoutTriggerOptions,
+    project: RuniumTriggerProjectAccessible
+  ) {
+    super(options, project);
+    this.timeout = options.timeout;
+  }
+
+  enable(): void {
+    this.timeoutId = setTimeout(() => {
+      this.project.processAction(this.action);
+    }, this.timeout);
+    this.disabled = false;
+  }
+
+  disable(): void {
+    this.timeoutId && clearTimeout(this.timeoutId);
+    this.disabled = true;
+    this.timeoutId = null;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ES2022",
+    "module": "NodeNext",
+    "lib": [
+      "ES2022"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": false,
+    "strictNullChecks": true,
+    "removeComments": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}