update config and structure for daemon

Author: tacxou

backends.example/01ad/config.yml

@@ -4,16 +4,16 @@ description: 'Backend for AD'
 active: 0
 actions:
   CHANGEPWD:
-      exec: "changepasswd"
+      script: "changepasswd"
       onError: 'stop'
   RESETPWD:
-      exec: "resetpasswd"
+      script: "resetpasswd"
       onError: 'stop'
-  ADDIDENT:
-      exec: 'dummy.sh'
-  UPDATEIDENT:
-      exec: 'dummy.sh'
+  IDENTITY_CREATE:
+      script: 'dummy.sh'
+  IDENTITY_UPDATE:
+      script: 'dummy.sh'
   DELIDENT:
-      exec: 'dummy.sh'
+      script: 'dummy.sh'
   PING:
-      exec: 'ping.sh'
+      script: 'ping.sh'

src/_common/backend-initializer/config.initializer.ts

@@ -28,7 +28,7 @@ export default async function configInitializer(backendsPath: string): Promise<B
     const config = YAML.parse(data);
 
     try {
-      config.path = path.dirname(file);
+      if (!config.path) config.path = path.dirname(file);
       const schema = plainToInstance(BackendConfigDto, config);
       await validateOrReject(schema, {
         whitelist: true,

src/backend-runner/_dto/backend-config.dto.ts

@@ -1,21 +1,21 @@
-import { IsString, IsEnum, IsNumber, IsNotEmpty } from 'class-validator';
+import { IsString, IsEnum, IsBoolean, IsNotEmpty } from 'class-validator';
 
 export enum ActionType {
-  // noinspection JSUnusedGlobalSymbols
-  LISTBACKEND = 'LISTBACKEND',
-  CHANGEPWD = 'CHANGEPWD',
-  RESETPWD = 'RESETPWD',
-  ADDIDENT = 'ADDIDENT',
-  UPDATEIDENT = 'UPDATEIDENT',
-  DELIDENT = 'DELIDENT',
+  LIST_BACKENDS = 'LIST_BACKENDS',
+  IDENTITY_CREATE = 'IDENTITY_CREATE',
+  IDENTITY_UPDATE = 'IDENTITY_UPDATE',
+  IDENTITY_DELETE = 'IDENTITY_DELETE',
+  IDENTITY_PASSWORD_RESET = 'IDENTITY_PASSWORD_RESET',
+  IDENTITY_PASSWORD_CHANGE = 'IDENTITY_PASSWORD_CHANGE',
 }
 
 export class BackendActionDto {
   @IsString()
-  public exec: string;
+  @IsNotEmpty()
+  public script: string;
 
   @IsString()
-  @IsEnum(['pass', 'failed'])
+  @IsEnum(['continue', 'stop'])
   public onError: string;
 }
 
@@ -25,15 +25,19 @@ export class BackendConfigDto {
   public name: string;
 
   @IsString()
-  public description: string;
+  public description?: string;
 
+  /**
+   * Path to the backend script
+   * If not set, it will be the directory of the config file
+   */
   @IsString()
+  @IsNotEmpty()
   public path: string;
 
-  @IsNumber()
+  @IsBoolean()
   @IsNotEmpty()
-  @IsEnum([0, 1])
-  public active: number;
+  public active: boolean;
 
   public actions: Record<ActionType, BackendActionDto>;
 }

src/backend-runner/_executors/catch-all.executor.ts

@@ -0,0 +1,15 @@
+import { BackendRunnerService } from '../backend-runner.service';
+import { ExecutorInterface } from '../executors.interface';
+
+export class ListBackendsExecutor implements ExecutorInterface {
+  public constructor(public service: BackendRunnerService) {}
+
+  public async execute({}): Promise<void> {
+    this.service.logger.log('execute LISTBACKEND');
+    return {
+      status: 0,
+      jobId: job.id,
+      data: this.service.backendsConfig,
+    };
+  }
+}

src/backend-runner/_executors/list-backends.executor.ts

@@ -0,0 +1,16 @@
+/**
+ * BackendCodesEnum
+ * 
+ * @description Enum for backend codes
+ * @see https://tldp.org/LDP/abs/html/exitcodes.html
+ * @see https://www.linuxdoc.org/LDP/abs/html/exitcodes.html
+ * @see https://www.gnu.org/software/libc/manual/html_node/Exit-Status.html
+ */
+export enum BackendCodesEnum {
+    OK = 0,
+    GENERIC_ERROR = 1<<0,
+    GENERIC_STOPPED = 1<<1,
+    CONNECTION_ERROR = 1<<2,
+    INVALID_LOGIN = 1<<3,
+    INVALID_CREDENTIALS = 1<<4,
+}

src/backend-runner/_interfaces/backend-codes.enum.ts

@@ -1,6 +1,12 @@
 export interface BackendResultInterface {
   backend: string;
   status: number;
-  output?: string;
-  error?: string;
+  output?: BackendResultInfoInterface;
+  error?: BackendResultInfoInterface;
 }
+
+export interface BackendResultInfoInterface {
+  status: number;
+  message?: string;
+  data?: object;
+}

src/backend-runner/_interfaces/backend-result.interface.ts

@@ -0,0 +1,11 @@
+import { BackendResultInterface } from "./backend-result.interface";
+
+export interface WorkerResultInterface {
+    jobId: string;
+    status: number;
+    data: WorkerResultInfoInterface;
+}
+
+export interface WorkerResultInfoInterface {
+    [backendName: string]: Partial<BackendResultInterface>;
+}

src/backend-runner/_interfaces/worker-result.interface.ts

@@ -1,4 +1,4 @@
-import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { Injectable, Logger, OnModuleInit, OnApplicationBootstrap } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { Job, Worker } from 'bullmq';
 import { ActionType, BackendConfigDto } from './_dto/backend-config.dto';
@@ -7,32 +7,47 @@ import executorTask from '../_common/tasks/executor.task';
 import { BackendResultInterface } from './_interfaces/backend-result.interface';
 import { ExecutorConfigInterface } from '~/_common/interfaces/executor-config.interface';
 import { join } from 'path';
+import { ExecutorInterface } from './executors.interface';
+import { ListBackendsExecutor } from './_executors/list-backends.executor';
 
 @Injectable()
-export class BackendRunnerService implements OnModuleInit {
-  private readonly backendsConfig: BackendConfigDto[] = [];
-  private readonly logger = new Logger(BackendRunnerService.name);
+export class BackendRunnerService implements OnApplicationBootstrap, OnModuleInit {
+  private readonly _backendsConfig: BackendConfigDto[] = [];
+  private readonly _logger = new Logger(BackendRunnerService.name);
+
+  protected executors: Map<string, ExecutorInterface> = new Map<string, ExecutorInterface>();
 
   public constructor(private readonly config: ConfigService) {
-    this.backendsConfig = this.config.get<BackendConfigDto[]>('backendsConfig');
+    this._backendsConfig = this.config.get<BackendConfigDto[]>('backendsConfig');
+  }
+
+  public get backendsConfig() {
+    return this._backendsConfig;
+  }
+
+  public get logger() {
+    return this._logger;
   }
 
   public async onModuleInit() {
-    this.logger.log('BackendRunnerService initialized');
+    this.executors.set(ActionType.LIST_BACKENDS, new ListBackendsExecutor(this));
+    this.logger.log('OnModuleInit initialized 🔴');
+  }
 
+  public async onApplicationBootstrap() {
     const worker = new Worker(
       this.config.get<string>('nameQueue'),
       async (job) => {
         let status = 0;
         const data = [];
-        for await (const backend of this.backendsConfig) {
+        for await (const backend of this._backendsConfig) {
           switch (job.name) {
-            case ActionType.LISTBACKEND: {
+            case ActionType.LIST_BACKENDS: {
               return await this.listBackends(job);
             }
 
             default: {
-              if (backend.active !== 1) {
+              if (!backend.active) {
                 this.logger.warn(`backend ${backend.name} is not active`);
                 continue;
               }
@@ -59,24 +74,44 @@ export class BackendRunnerService implements OnModuleInit {
       },
     );
     await worker.run();
+    this.logger.log('OnApplicationBootstrap initialized 🔴');
   }
 
   public async listBackends(job: Job) {
     this.logger.log('execute LISTBACKEND');
     return {
       status: 0,
       jobId: job.id,
-      data: this.backendsConfig,
+      data: this._backendsConfig,
     };
   }
 
   public async executeBackend(job: Job, backend: BackendConfigDto): Promise<BackendResultInterface> {
     const process = await executorTask(join(backend.path, 'bin', backend.actions[job.name].exec), job, {
       ...this.config.get<ExecutorConfigInterface>('backendExecutorConfig'),
     });
-    return {
-      backend: backend.name,
-      ...process,
-    };
+    try {
+      if (process.status !== 0) {
+        return {
+          backend: backend.name,
+          status: process.status,
+          error: JSON.parse(process.output),
+        };
+      }
+      return {
+        backend: backend.name,
+        status: process.status,
+        output: JSON.parse(process.output),
+      };
+    } catch (e) {
+      return {
+        backend: backend.name,
+        status: process.status,
+        error: {
+          status: process.status,
+          message: process.error,
+        },
+      };
+    }
   }
 }

src/backend-runner/backend-runner.service.ts

@@ -0,0 +1,14 @@
+import { BackendRunnerService } from './backend-runner.service';
+
+export interface ExecutorExecuteOptionsInterface {}
+
+export interface ExecutorExecuteResponseInterface {
+    jobId: string;
+    status: number;
+}
+
+export interface ExecutorInterface {
+  readonly service: BackendRunnerService;
+
+  execute(context: ExecutorExecuteOptionsInterface): Promise<ExecutorExecuteResponseInterface>;
+}