feat: 🎸 async executors on be

Author: agroupp

apps/cli-daemon/src/app/app.module.ts

@@ -2,14 +2,20 @@ import { Global, Module } from '@nestjs/common';
 
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { ExecutorsModule } from './executors/executors.module';
 import { GeneratorsModule } from './generators/generators.module';
 import { SessionService } from './session/session.service';
 import { WorkspaceModule } from './workspace/workspace.module';
 import { WorkspaceManagerModule } from './workspace-manager/workspace-manager.module';
 
 @Global()
 @Module({
-  imports: [WorkspaceModule, GeneratorsModule, WorkspaceManagerModule],
+  imports: [
+    WorkspaceModule,
+    GeneratorsModule,
+    WorkspaceManagerModule,
+    ExecutorsModule,
+  ],
   controllers: [AppController],
   providers: [AppService, SessionService],
   exports: [SessionService],

apps/cli-daemon/src/app/executors/child-process.ts

@@ -0,0 +1,42 @@
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
+
+import { TaskStatus } from '@angular-cli-gui/shared/data';
+import { Logger } from '@nestjs/common';
+
+import { StringBuffer } from './string-buffer';
+import { spawnedProcessCommandLine } from './utils';
+
+const STD_OUT_BUFFER_SIZE = 100;
+const STD_ERR_BUFFER_SIZE = 20;
+
+export class ChildProcess {
+  private readonly logger = new Logger(
+    `Child process "${spawnedProcessCommandLine(this.spawnedProcess)}"`
+  );
+  private readonly stdOutBuffer = new StringBuffer(STD_OUT_BUFFER_SIZE);
+  private readonly stdErrBuffer = new StringBuffer(STD_ERR_BUFFER_SIZE);
+  private exitCode?: number | null;
+
+  get status(): TaskStatus {
+    return {
+      stdOut: this.stdOutBuffer.data,
+      stdErr: this.stdErrBuffer.data,
+      isRunning: this.exitCode === undefined,
+      exitCode: this.exitCode,
+    };
+  }
+
+  constructor(readonly spawnedProcess: ChildProcessWithoutNullStreams) {
+    this.logger.verbose(`Spawned with PID: ${spawnedProcess.pid}`);
+    spawnedProcess.stdout.on('data', (data: Buffer) =>
+      this.stdOutBuffer.add(data)
+    );
+    spawnedProcess.stderr.on('data', (data: Buffer) =>
+      this.stdErrBuffer.add(data)
+    );
+    spawnedProcess.on('close', (code) => {
+      this.exitCode = code;
+      this.logger.verbose(`Terminated with code ${code}`);
+    });
+  }
+}

apps/cli-daemon/src/app/executors/child-processes.ts

@@ -0,0 +1,13 @@
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
+
+import { ChildProcess } from './child-process';
+
+export class ChildProcesses extends Map<number, ChildProcess> {
+  add(spawnedProcess: ChildProcessWithoutNullStreams): void {
+    if (!spawnedProcess.pid) {
+      return;
+    }
+
+    this.set(spawnedProcess.pid, new ChildProcess(spawnedProcess));
+  }
+}

apps/cli-daemon/src/app/executors/executors.controller.spec.ts

@@ -0,0 +1,25 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { createExecutorsServiceMock } from '../../../testing';
+
+import { ExecutorsController } from './executors.controller';
+import { ExecutorsService } from './executors.service';
+
+describe('ExecutorsController', () => {
+  let controller: ExecutorsController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ExecutorsController],
+      providers: [
+        { provide: ExecutorsService, useValue: createExecutorsServiceMock() },
+      ],
+    }).compile();
+
+    controller = module.get<ExecutorsController>(ExecutorsController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

apps/cli-daemon/src/app/executors/executors.controller.ts

@@ -0,0 +1,65 @@
+import {
+  Command,
+  KillDto,
+  RunTaskResponse,
+  Task,
+  TaskStatus,
+} from '@angular-cli-gui/shared/data';
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Post,
+  Query,
+} from '@nestjs/common';
+
+import { ExecutorsService } from './executors.service';
+
+@Controller('executors')
+export class ExecutorsController {
+  constructor(private readonly executorsService: ExecutorsService) {}
+
+  @Post()
+  async run(@Body() commandDto: Command): Promise<RunTaskResponse> {
+    const command: string = commandDto.command;
+    const args = this.readArgsFromDto(commandDto);
+    const pid = await this.executorsService.execAsync([command].concat(args));
+
+    return { pid };
+  }
+
+  @Get('status')
+  getTaskStatus(@Query('pid') pid: number): TaskStatus {
+    if (!pid) {
+      throw new BadRequestException('PID was not provided');
+    }
+
+    return this.executorsService.readTaskStatus(pid);
+  }
+
+  @Delete()
+  killTask(@Body() killDto: KillDto): void {
+    this.executorsService.killTask(killDto.pid);
+  }
+
+  private readArgsFromDto(commandDto: Command): string[] {
+    const args: string[] = [];
+
+    for (const key in commandDto) {
+      if (key === 'command') {
+        continue;
+      }
+
+      args.push(`--${key}`, commandDto[key]?.toString());
+    }
+
+    return args;
+  }
+
+  @Get()
+  readAllTasks(): Task[] {
+    return this.executorsService.readAllTasks();
+  }
+}

apps/cli-daemon/src/app/executors/executors.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { ExecutorsController } from './executors.controller';
+import { ExecutorsService } from './executors.service';
+
+@Module({
+  controllers: [ExecutorsController],
+  providers: [ExecutorsService],
+  exports: [ExecutorsService],
+})
+export class ExecutorsModule {}

apps/cli-daemon/src/app/executors/executors.service.spec.ts

@@ -0,0 +1,25 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { createSessionServiceMock } from '../../../testing';
+import { SessionService } from '../session/session.service';
+
+import { ExecutorsService } from './executors.service';
+
+describe('ExecutorsService', () => {
+  let service: ExecutorsService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        ExecutorsService,
+        { provide: SessionService, useValue: createSessionServiceMock() },
+      ],
+    }).compile();
+
+    service = module.get<ExecutorsService>(ExecutorsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

apps/cli-daemon/src/app/executors/executors.service.ts

@@ -0,0 +1,117 @@
+import {
+  ChildProcessWithoutNullStreams,
+  execSync,
+  spawn,
+} from 'node:child_process';
+import { resolve as pathResolve } from 'node:path';
+import process from 'node:process';
+
+import { Task, TaskStatus } from '@angular-cli-gui/shared/data';
+import {
+  Global,
+  Injectable,
+  InternalServerErrorException,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common';
+
+import { SessionService } from '../session/session.service';
+
+import { ChildProcesses } from './child-processes';
+import { spawnedProcessCommandLine } from './utils';
+
+const NG = 'npx ng';
+
+@Global()
+@Injectable()
+export class ExecutorsService {
+  private readonly logger = new Logger(ExecutorsService.name);
+  private childProcesses = new ChildProcesses();
+
+  constructor(private readonly sessionService: SessionService) {
+    process.on('SIGINT', () => this.destroy());
+    process.on('SIGTERM', () => this.destroy());
+  }
+
+  async execAsync(args: string[]): Promise<number> {
+    try {
+      const childProcess = await this.childProcessSpawn(args);
+      this.childProcesses.add(childProcess);
+
+      return childProcess.pid as number;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (err: any) {
+      this.logger.error(err.message);
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+
+  readTaskStatus(pid: number): TaskStatus {
+    const childProcess = this.childProcesses.get(pid);
+
+    if (!childProcess) {
+      throw new NotFoundException(`Process with pid: ${pid} was not found`);
+    }
+
+    return childProcess.status;
+  }
+
+  killTask(pid: number): void {
+    const childProcess = this.childProcesses.get(pid);
+
+    if (!childProcess) {
+      throw new NotFoundException(`Process with pid: ${pid} was not found`);
+    }
+
+    this.kill(pid);
+  }
+
+  readAllTasks(): Task[] {
+    const tasks: Task[] = [];
+
+    for (const [pid, childProcess] of this.childProcesses.entries()) {
+      const { isRunning, exitCode } = childProcess.status;
+      const commandLine = spawnedProcessCommandLine(
+        childProcess.spawnedProcess
+      );
+      tasks.push({ pid, isRunning, exitCode, commandLine });
+    }
+
+    return tasks;
+  }
+
+  private destroy(): void {
+    this.logger.log('Application destroy hook');
+  }
+
+  private childProcessSpawn(
+    args: string[]
+  ): Promise<ChildProcessWithoutNullStreams> {
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn(NG, args, {
+        cwd: pathResolve(this.sessionService.cwd),
+        env: process.env,
+        shell: true,
+      });
+
+      childProcess.on('error', (err) => reject(err));
+
+      if (childProcess.pid) {
+        resolve(childProcess);
+      }
+    });
+  }
+
+  private kill(pid: number): void {
+    switch (process.platform) {
+      case 'win32':
+        execSync(`taskkill /pid ${pid} /T /F`);
+        break;
+      case 'darwin':
+        throw new Error('Not yet implemented');
+        break;
+      default:
+        throw new Error('Not yet implemented');
+    }
+  }
+}

apps/cli-daemon/src/app/executors/string-buffer.ts

@@ -0,0 +1,34 @@
+import { TerminalRecord } from '@angular-cli-gui/shared/data';
+
+import { stringToArray } from '../utils';
+
+export class StringBuffer {
+  private _data: TerminalRecord[] = [];
+  private counter = 1;
+
+  get data(): TerminalRecord[] {
+    return this._data.slice(0);
+  }
+
+  constructor(private readonly bufferSize?: number) {}
+
+  add(data: Buffer): void {
+    const dataStrings = stringToArray(data.toString('utf8'));
+
+    this._data = this._data.concat(
+      dataStrings.map((s) => ({
+        id: this.counter++,
+        timestamp: Date.now(),
+        content: s,
+      }))
+    );
+
+    if (this.bufferSize && this._data.length > this.bufferSize) {
+      this._data.splice(0, this._data.length - this.bufferSize);
+    }
+  }
+
+  clear(): void {
+    this._data = [];
+  }
+}

apps/cli-daemon/src/app/executors/utils/index.ts

@@ -0,0 +1 @@
+export * from './spawned-process-cmd-line';