@runium/core 0.0.9 → 0.1.1

package/src/task.ts

@@ -1,381 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,29 +0,0 @@
-{
-  "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"
-  ]
-}