feat: 使用单独目录部署。

Reviewed-on: #7

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": []
+}

.vscode/settings.json

@@ -1,5 +1,6 @@
 {
   "cSpell.words": [
+    "Mutex",
     "Repos",
     "amqp",
     "boardcat",

config.yml.example

@@ -16,5 +16,9 @@ db:
     prefix: fennec
   rabbitmq:
     uri: 'amqp://fennec:fennec@192.168.31.194:5672'
+  etcd:
+    hosts:
+      - 'http://192.168.31.194:2379'
+
 workspaces:
   root: '/Users/ivanli/Projects/fennec/workspaces'

ecosystem.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  apps: [
+    {
+      name: 'fennec-be',
+      script: 'npm',
+      args: 'run start:prod',
+      watch: false,
+      ignore_watch: ['node_modules'],
+      log_date_format: 'MM-DD HH:mm:ss.SSS Z',
+      env: {},
+      max_restarts: 5,
+    },
+  ],
+};

package.json

@@ -1,8 +1,8 @@
 {
   "name": "fennec-be",
-  "version": "0.0.1",
+  "version": "0.1.1",
-  "description": "",
+  "description": "a ci/cd project.",
-  "author": "",
+  "author": "Ivan Li\b<ivanli2048@gmail.com>",
   "private": true,
   "license": "UNLICENSED",
   "scripts": {
@@ -22,26 +22,27 @@
   },
   "dependencies": {
     "@golevelup/nestjs-rabbitmq": "^1.16.1",
-    "@nestjs/bull": "^0.3.1",
+    "@nestjs-lib/auth": "^0.2.1",
     "@nestjs/common": "^7.5.1",
     "@nestjs/config": "^0.6.2",
     "@nestjs/core": "^7.5.1",
     "@nestjs/graphql": "^7.9.8",
     "@nestjs/platform-express": "^7.5.1",
     "@nestjs/typeorm": "^7.1.5",
-    "@types/bull": "^3.15.0",
+    "@types/amqplib": "^0.8.0",
     "@types/ramda": "^0.27.38",
     "apollo-server-express": "^2.19.2",
     "bcrypt": "^5.0.0",
     "body-parser": "^1.19.0",
-    "bull": "^3.20.1",
     "class-transformer": "^0.3.2",
     "class-validator": "^0.13.1",
     "debug": "^4.3.1",
     "graphql": "^15.5.0",
     "graphql-tools": "^7.0.2",
     "ioredis": "^4.25.0",
+    "jose": "^3.14.0",
     "js-yaml": "^4.0.0",
+    "nestjs-etcd": "^0.2.0",
     "nestjs-pino": "^1.4.0",
     "nestjs-redis": "^1.2.8",
     "observable-to-async-generator": "^1.0.1-rc",
@@ -95,6 +96,9 @@
     "collectCoverageFrom": [
       "**/*.(t|j)s"
     ],
+    "moduleNameMapper": {
+      "^jose/(.*)$": "<rootDir>/../node_modules/jose/dist/node/cjs/$1"
+    },
     "coverageDirectory": "../coverage",
     "testEnvironment": "node"
   }

src/app.module.ts

@@ -1,3 +1,4 @@
+import { CommonsModule } from './commons/commons.module';
 import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { GraphQLModule } from '@nestjs/graphql';
@@ -12,13 +13,13 @@ import { PipelineTasksModule } from './pipeline-tasks/pipeline-tasks.module';
 import configuration from './commons/config/configuration';
 import { RedisModule } from 'nestjs-redis';
 import { WebhooksModule } from './webhooks/webhooks.module';
-import { RawBodyMiddleware } from './commons/middlewares/raw-body.middleware';
+import { RawBodyMiddleware } from './commons/middleware/raw-body.middleware';
 import { GiteaWebhooksController } from './webhooks/gitea-webhooks.controller';
-import { ParseBodyMiddleware } from './commons/middlewares/parse-body.middleware';
+import { ParseBodyMiddleware } from './commons/middleware/parse-body.middleware';
-import { BullModule } from '@nestjs/bull';
 import { LoggerModule } from 'nestjs-pino';
-
+import { EtcdModule } from 'nestjs-etcd';
 import pinoPretty from 'pino-pretty';
+import { fromPairs, map, pipe, toPairs } from 'ramda';
 
 @Module({
   imports: [
@@ -63,16 +64,21 @@ import pinoPretty from 'pino-pretty';
         playground: true,
         autoSchemaFile: true,
         installSubscriptionHandlers: true,
-      }),
+        context: ({ req, connection, ...args }) => {
-      inject: [ConfigService],
+          return connection ? { req: connection.context } : { req };
-    }),
+        },
-    BullModule.forRootAsync({
+        subscriptions: {
-      imports: [ConfigModule],
+          onConnect: (connectionParams: Record<string, string>) => {
-      useFactory: (configService: ConfigService) => ({
+            const connectionParamsWithLowerKeys = pipe(
-        redis: {
+              toPairs,
-          host: configService.get<string>('db.redis.host', 'localhost'),
+              map(([key, value]) => [key.toLowerCase(), value]),
-          port: configService.get<number>('db.redis.port', undefined),
+              fromPairs,
-          password: configService.get<string>('db.redis.password', undefined),
+            )(connectionParams);
+
+            return {
+              headers: connectionParamsWithLowerKeys,
+            };
+          },
         },
       }),
       inject: [ConfigService],
@@ -91,7 +97,15 @@ import pinoPretty from 'pino-pretty';
       }),
       inject: [ConfigService],
     }),
+    EtcdModule.forRootAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        hosts: configService.get<string>('db.etcd.hosts', 'localhost:2379'),
+      }),
+      inject: [ConfigService],
+    }),
     WebhooksModule,
+    CommonsModule,
   ],
   controllers: [AppController],
   providers: [AppService, AppResolver],

src/commons/commons.module.ts

@@ -1,8 +1,11 @@
 import { Module } from '@nestjs/common';
 import { PasswordConverter } from './services/password-converter';
+import { RedisMutexModule } from './redis-mutex/redis-mutex.module';
+import { AuthModule } from '@nestjs-lib/auth';
 
 @Module({
+  imports: [RedisMutexModule, AuthModule],
   providers: [PasswordConverter],
-  exports: [PasswordConverter],
+  exports: [PasswordConverter, RedisMutexModule, AuthModule],
 })
 export class CommonsModule {}

src/commons/exceptions/application.exception.ts

@@ -1,11 +1,11 @@
+import { pick } from 'ramda';
+
 export class ApplicationException extends Error {
   code: number;
   error: Error;
 
   constructor(
-    message:
+    message: string | { error?: Error; message?: string | any; code?: number },
-      | string
-      | { error?: Error; message?: string | object; code?: number },
   ) {
     if (message instanceof Object) {
       super();
@@ -18,4 +18,8 @@ export class ApplicationException extends Error {
       super((message as unknown) as any);
     }
   }
+
+  toJSON() {
+    return pick(['code', 'message'], this);
+  }
 }

src/commons/filters/all.exception-filter.ts

@@ -6,13 +6,18 @@ import {
   HttpStatus,
 } from '@nestjs/common';
 import { ApolloError } from 'apollo-server-errors';
+import { PinoLogger, InjectPinoLogger } from 'nestjs-pino';
 
 @Catch(HttpException)
 export class HttpExceptionFilter implements ExceptionFilter {
+  constructor(
+    @InjectPinoLogger(HttpExceptionFilter.name)
+    private readonly logger: PinoLogger,
+  ) {}
   catch(exception: HttpException, host: ArgumentsHost) {
     switch (host.getType<'http' | 'graphql' | string>()) {
       case 'graphql': {
-        const message = exception.message;
+        const errorName = exception.message;
         const extensions: Record<string, any> = {};
         const err = exception.getResponse();
         if (typeof err === 'string') {
@@ -21,8 +26,10 @@ export class HttpExceptionFilter implements ExceptionFilter {
           Object.assign(extensions, (err as any).extension);
           extensions.message = (err as any).message;
         }
+        extensions.error = errorName;
+        this.logger.error(extensions);
         return new ApolloError(
-          message,
+          extensions.message,
           exception.getStatus().toString(),
           extensions,
         );

src/commons/redis-mutex/redis-mutex.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { RedisMutexService } from './redis-mutex.service';
+import { RedisModule } from 'nestjs-redis';
+
+@Module({
+  imports: [RedisModule],
+  providers: [RedisMutexService],
+  exports: [RedisMutexService],
+})
+export class RedisMutexModule {}

src/commons/redis-mutex/redis-mutex.service.spec.ts

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

src/commons/redis-mutex/redis-mutex.service.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+import { RedisService } from 'nestjs-redis';
+import * as uuid from 'uuid';
+import { ApplicationException } from '../exceptions/application.exception';
+
+export interface RedisMutexOption {
+  /**
+   * seconds
+   */
+  expires?: number;
+  /**
+   * seconds
+   */
+  timeout?: number | null;
+  /**
+   * milliseconds
+   */
+  retryDelay?: number;
+}
+
+@Injectable()
+export class RedisMutexService {
+  constructor(private readonly redisClient: RedisService) {}
+
+  public async lock(
+    key: string,
+    { expires = 100, timeout = 10, retryDelay = 100 }: RedisMutexOption = {
+      expires: 100,
+      timeout: 10,
+      retryDelay: 100,
+    },
+  ) {
+    const redisKey = `${'mutex-lock'}:${key}`;
+    const redis = this.redisClient.getClient();
+    const value = uuid.v4();
+    const timeoutAt = timeout ? Date.now() + timeout * 1000 : null;
+
+    while (
+      !(await redis
+        .set(redisKey, value, 'EX', expires, 'NX')
+        .then(() => true)
+        .catch(() => false))
+    ) {
+      if (timeoutAt && timeoutAt > Date.now()) {
+        throw new ApplicationException('lock timeout');
+      }
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+    }
+
+    const renewTimer = setInterval(() => {
+      redis.expire(redisKey, expires);
+    }, (expires * 1000) / 2);
+
+    return async () => {
+      clearInterval(renewTimer);
+      await redis.eval(
+        `
+      if redis.call("get", KEYS[1]) == ARGV[1]
+      then
+          return redis.call("del", KEYS[1])
+      else
+          return 0
+      end
+    `,
+        1,
+        redisKey,
+        value,
+      );
+    };
+  }
+}

src/commons/services/base-db.service.ts

@@ -53,8 +53,22 @@ export class BaseDbService<Entity extends AppBaseEntity> extends TypeormHelper {
   async isDuplicateEntityForUpdate<Dto extends Entity>(
     id: string,
     dto: Partial<Dto>,
+    extendsFields?: Array<keyof Dto & string>,
+  ): Promise<false | never>;
+  async isDuplicateEntityForUpdate<Dto extends Entity>(
+    old: Entity,
+    dto: Partial<Dto>,
+    extendsFields?: Array<keyof Dto & string>,
+  ): Promise<false | never>;
+  async isDuplicateEntityForUpdate<Dto extends Entity>(
+    id: string | Entity,
+    dto: Partial<Dto>,
     extendsFields: Array<keyof Dto & string> = [],
   ): Promise<false | never> {
+    if (typeof id !== 'string') {
+      dto = Object.assign({}, id, dto);
+      id = id.id;
+    }
     const qb = this.repository.createQueryBuilder('entity');
     const compareFields = this.getCompareFields(dto, [
       ...this.uniqueFields,

src/main.ts

@@ -1,3 +1,4 @@
+import { PinoLogger } from 'nestjs-pino';
 import { ValidationPipe } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { NestFactory } from '@nestjs/core';
@@ -14,7 +15,8 @@ async function bootstrap() {
       transform: true,
     }),
   );
-  app.useGlobalFilters(new HttpExceptionFilter());
+  const httpExceptionFilterLogger = await app.resolve(PinoLogger);
+  app.useGlobalFilters(new HttpExceptionFilter(httpExceptionFilterLogger));
   await app.listen(configService.get<number>('http.port'));
 }
 bootstrap();

src/pipeline-tasks/enums/task-statuses.enum.ts

@@ -11,3 +11,5 @@ registerEnumType(TaskStatuses, {
   name: 'TaskStatuses',
   description: '任务状态',
 });
+
+export const terminalTaskStatuses = [TaskStatuses.success, TaskStatuses.failed];

src/pipeline-tasks/models/pipeline-task-event.ts

@@ -1,13 +1,25 @@
+import { Field, ObjectType } from '@nestjs/graphql';
 import { PipelineUnits } from '../enums/pipeline-units.enum';
 import { TaskStatuses } from '../enums/task-statuses.enum';
+import { Type } from 'class-transformer';
 
+@ObjectType()
 export class PipelineTaskEvent {
+  @Field()
   taskId: string;
+  @Field()
   pipelineId: string;
+  @Field()
   projectId: string;
+  @Field(() => PipelineUnits, { nullable: true })
   unit: PipelineUnits | null;
+  @Field()
+  @Type(() => Date)
   emittedAt: Date;
+  @Field()
   message: string;
+  @Field()
   messageType: 'stdout' | 'stderr' | 'stdin';
+  @Field(() => TaskStatuses)
   status: TaskStatuses;
 }

src/pipeline-tasks/models/work-unit-metadata.model.ts

@@ -1,9 +1,16 @@
-import { InputType, ObjectType } from '@nestjs/graphql';
+import { Field, InputType, Int, ObjectType } from '@nestjs/graphql';
+import { Type } from 'class-transformer';
+import { IsInstance, isInstance, ValidateNested } from 'class-validator';
 import { WorkUnit } from './work-unit.model';
 
 @InputType('WorkUnitMetadataInput')
 @ObjectType()
 export class WorkUnitMetadata {
+  @Field(() => Int)
   version = 1;
+
+  @Type(() => WorkUnit)
+  @IsInstance(WorkUnit, { each: true })
+  @ValidateNested({ each: true })
   units: WorkUnit[];
 }

src/pipeline-tasks/models/work-unit.model.ts

@@ -1,4 +1,5 @@
 import { Field, InputType, ObjectType } from '@nestjs/graphql';
+import { IsNotEmpty } from 'class-validator';
 import {
   PipelineUnits,
   PipelineUnits as PipelineUnitTypes,
@@ -9,5 +10,7 @@ import {
 export class WorkUnit {
   @Field(() => PipelineUnits)
   type: PipelineUnitTypes;
+
+  @IsNotEmpty({ each: true })
   scripts: string[];
 }

src/pipeline-tasks/pipeline-task-flush.service.spec.ts

@@ -0,0 +1,88 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { Test, TestingModule } from '@nestjs/testing';
+import { RedisService } from 'nestjs-redis';
+import { PipelineTaskFlushService } from './pipeline-task-flush.service';
+import { PipelineTaskEvent } from './models/pipeline-task-event';
+import { TaskStatuses } from './enums/task-statuses.enum';
+import {
+  EXCHANGE_PIPELINE_TASK_TOPIC,
+  ROUTE_PIPELINE_TASK_DONE,
+} from './pipeline-tasks.constants';
+
+describe('PipelineTaskFlushService', () => {
+  let service: PipelineTaskFlushService;
+  let redisService: RedisService;
+  let amqpConnection: AmqpConnection;
+
+  beforeEach(async () => {
+    const redisClient = {
+      rpush: jest.fn(() => Promise.resolve()),
+      lrange: jest.fn(() => Promise.resolve()),
+      expire: jest.fn(() => Promise.resolve()),
+    };
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        PipelineTaskFlushService,
+        {
+          provide: RedisService,
+          useValue: {
+            getClient() {
+              return redisClient;
+            },
+          },
+        },
+        {
+          provide: AmqpConnection,
+          useValue: {
+            request: jest.fn(() => Promise.resolve()),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<PipelineTaskFlushService>(PipelineTaskFlushService);
+    redisService = module.get<RedisService>(RedisService);
+    amqpConnection = module.get<AmqpConnection>(AmqpConnection);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('write', () => {
+    const amqpMsg = {
+      properties: { headers: { sender: 'test' } },
+    } as any;
+    it('normal', async () => {
+      const testEvent = new PipelineTaskEvent();
+      testEvent.taskId = 'test';
+      testEvent.status = TaskStatuses.working;
+      const rpush = jest.spyOn(redisService.getClient(), 'rpush');
+      const request = jest.spyOn(amqpConnection, 'request');
+      await service.write(testEvent, amqpMsg);
+      expect(rpush).toBeCalledTimes(1);
+      expect(rpush.mock.calls[0][0]).toEqual('p-task:log:test');
+      expect(rpush.mock.calls[0][1]).toEqual(JSON.stringify(testEvent));
+      expect(request).toBeCalledTimes(1);
+    });
+    it('event for which task done', async () => {
+      const testEvent = new PipelineTaskEvent();
+      testEvent.taskId = 'test';
+      testEvent.status = TaskStatuses.success;
+      const rpush = jest.spyOn(redisService.getClient(), 'rpush');
+      const request = jest.spyOn(amqpConnection, 'request');
+      await service.write(testEvent, amqpMsg);
+      expect(rpush).toBeCalledTimes(1);
+      expect(request).toBeCalledTimes(1);
+      expect(request.mock.calls[0][0]).toMatchObject({
+        exchange: EXCHANGE_PIPELINE_TASK_TOPIC,
+        routingKey: ROUTE_PIPELINE_TASK_DONE,
+        payload: {
+          taskId: 'test',
+          status: TaskStatuses.success,
+          runOn: 'test',
+        },
+      });
+    });
+  });
+});

src/pipeline-tasks/pipeline-task-flush.service.ts

@@ -0,0 +1,66 @@
+import { AmqpConnection, RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
+import { Injectable } from '@nestjs/common';
+import { ConsumeMessage } from 'amqplib';
+import { deserialize } from 'class-transformer';
+import { RedisService } from 'nestjs-redis';
+import { isNil } from 'ramda';
+import { getSelfInstanceQueueKey } from '../commons/utils/rabbit-mq';
+import { PipelineTaskEvent } from './models/pipeline-task-event';
+import {
+  EXCHANGE_PIPELINE_TASK_TOPIC,
+  ROUTE_PIPELINE_TASK_DONE,
+} from './pipeline-tasks.constants';
+import {
+  EXCHANGE_PIPELINE_TASK_FANOUT,
+  ROUTE_PIPELINE_TASK_LOG,
+  QUEUE_WRITE_PIPELINE_TASK_LOG,
+} from './pipeline-tasks.constants';
+
+@Injectable()
+export class PipelineTaskFlushService {
+  constructor(
+    private readonly redisService: RedisService,
+    private readonly amqpConnection: AmqpConnection,
+  ) {}
+
+  @RabbitSubscribe({
+    exchange: EXCHANGE_PIPELINE_TASK_FANOUT,
+    routingKey: ROUTE_PIPELINE_TASK_LOG,
+    queue: getSelfInstanceQueueKey(QUEUE_WRITE_PIPELINE_TASK_LOG),
+    queueOptions: {
+      autoDelete: true,
+      durable: true,
+    },
+  })
+  async write(message: PipelineTaskEvent, amqpMsg: ConsumeMessage) {
+    const client = this.redisService.getClient();
+    await client.rpush(this.getKey(message.taskId), JSON.stringify(message));
+    await client.expire(this.getKey(message.taskId), 600); // ten minutes
+    if (isNil(message.unit)) {
+      try {
+        await this.amqpConnection.request({
+          exchange: EXCHANGE_PIPELINE_TASK_TOPIC,
+          routingKey: ROUTE_PIPELINE_TASK_DONE,
+          payload: {
+            taskId: message.taskId,
+            status: message.status,
+            runOn: amqpMsg.properties.headers.sender,
+          },
+        });
+      } catch (error) {
+        console.log(error);
+      }
+    }
+  }
+
+  async read(taskId: string) {
+    const raw = await this.redisService
+      .getClient()
+      .lrange(this.getKey(taskId), 0, -1);
+    return raw.map((it) => deserialize(PipelineTaskEvent, it));
+  }
+
+  private getKey(taskId: string) {
+    return `p-task:log:${taskId}`;
+  }
+}

src/pipeline-tasks/pipeline-task.entity.ts

@@ -36,4 +36,7 @@ export class PipelineTask extends AppBaseEntity {
 
   @Column({ nullable: true })
   endedAt?: Date;
+
+  @Column({ nullable: true })
+  runOn: string;
 }

src/pipeline-tasks/pipeline-task.logger.spec.ts

@@ -0,0 +1,74 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PipelineTaskLogger } from './pipeline-task.logger';
+import { PipelineTaskEvent } from './models/pipeline-task-event';
+import { take, timeout } from 'rxjs/operators';
+
+describe('PipelineTaskRunner', () => {
+  let logger: PipelineTaskLogger;
+  let module: TestingModule;
+
+  beforeEach(async () => {
+    module = await Test.createTestingModule({
+      providers: [PipelineTaskLogger],
+    }).compile();
+
+    logger = module.get(PipelineTaskLogger);
+  });
+
+  it('should be defined', () => {
+    expect(logger).toBeDefined();
+  });
+
+  describe('getMessage$', () => {
+    it('normal', async () => {
+      const event = new PipelineTaskEvent();
+      event.taskId = 'test';
+      const emittedAt = new Date();
+      event.emittedAt = emittedAt.toISOString() as any;
+      const message$ = logger.getMessage$('test');
+
+      let receiveEvent;
+      message$.pipe(take(1)).subscribe((value) => (receiveEvent = value));
+      await logger.handleEvent(event);
+      expect(receiveEvent).toMatchObject({
+        ...event,
+        emittedAt,
+      });
+    });
+    it('no match', async () => {
+      const event = new PipelineTaskEvent();
+      event.taskId = 'test';
+      const message$ = logger.getMessage$('other');
+      setTimeout(() => {
+        logger.handleEvent(event);
+      });
+      expect(message$.pipe(take(1), timeout(100)).toPromise()).rejects.toMatch(
+        'timeout',
+      );
+    });
+    it('multiple subscribers', async () => {
+      const event = new PipelineTaskEvent();
+      event.taskId = 'test';
+      const message$ = logger.getMessage$('test');
+      const message2$ = logger.getMessage$('test');
+      setTimeout(() => {
+        logger.handleEvent(event);
+      });
+      expect(message$.pipe(take(1), timeout(100)).toPromise()).resolves.toEqual(
+        event,
+      );
+      expect(
+        message2$.pipe(take(1), timeout(100)).toPromise(),
+      ).resolves.toEqual(event);
+    });
+  });
+
+  describe('onModuleDestroy', () => {
+    it('complete observable when destroying module', async () => {
+      logger.onModuleDestroy();
+      await expect(
+        (logger as any).message$.toPromise(),
+      ).resolves.toBeUndefined();
+    });
+  });
+});

src/pipeline-tasks/pipeline-task.logger.ts

@@ -0,0 +1,37 @@
+import { RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
+import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { plainToClass } from 'class-transformer';
+import { Observable, Subject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { PipelineTaskEvent } from './models/pipeline-task-event';
+import {
+  EXCHANGE_PIPELINE_TASK_FANOUT,
+  QUEUE_HANDLE_PIPELINE_TASK_LOG_EVENT,
+  ROUTE_PIPELINE_TASK_LOG,
+} from './pipeline-tasks.constants';
+
+@Injectable()
+export class PipelineTaskLogger implements OnModuleDestroy {
+  private readonly messageSubject = new Subject<PipelineTaskEvent>();
+  private readonly message$: Observable<PipelineTaskEvent> = this.messageSubject.pipe();
+
+  @RabbitSubscribe({
+    exchange: EXCHANGE_PIPELINE_TASK_FANOUT,
+    routingKey: ROUTE_PIPELINE_TASK_LOG,
+    queue: QUEUE_HANDLE_PIPELINE_TASK_LOG_EVENT,
+    queueOptions: {
+      autoDelete: true,
+    },
+  })
+  async handleEvent(message: PipelineTaskEvent) {
+    this.messageSubject.next(plainToClass(PipelineTaskEvent, message));
+  }
+
+  getMessage$(taskId: string) {
+    return this.message$.pipe(filter((event) => event.taskId === taskId));
+  }
+
+  onModuleDestroy() {
+    this.messageSubject.complete();
+  }
+}

src/pipeline-tasks/pipeline-task.runner.spec.ts

@@ -8,6 +8,7 @@ import { TaskStatuses } from './enums/task-statuses.enum';
 import { getLoggerToken, PinoLogger } from 'nestjs-pino';
 import { PipelineTaskRunner } from './pipeline-task.runner';
 import { WorkUnitMetadata } from './models/work-unit-metadata.model';
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
 describe('PipelineTaskRunner', () => {
   let runner: PipelineTaskRunner;
   let reposService: ReposService;
@@ -31,6 +32,10 @@ describe('PipelineTaskRunner', () => {
           useValue: () => undefined,
         },
         PipelineTaskRunner,
+        {
+          provide: AmqpConnection,
+          useValue: {},
+        },
       ],
     }).compile();
 
@@ -140,7 +145,7 @@ describe('PipelineTaskRunner', () => {
         await runner.doTask(task);
 
         expect(checkout).toBeCalledTimes(1);
-        expect(doTaskUnit).toBeCalledTimes(2);
+        expect(doTaskUnit).toBeCalledTimes(1);
         expect(emitEvent).toBeCalledTimes(2);
       });
 

src/pipeline-tasks/pipeline-task.runner.ts

@@ -5,15 +5,36 @@ import { ApplicationException } from '../commons/exceptions/application.exceptio
 import { PipelineUnits } from './enums/pipeline-units.enum';
 import { TaskStatuses } from './enums/task-statuses.enum';
 import { InjectPinoLogger, PinoLogger } from 'nestjs-pino';
-import { RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
+import {
+  AmqpConnection,
+  RabbitRPC,
+  RabbitSubscribe,
+} from '@golevelup/nestjs-rabbitmq';
 import { PipelineTaskEvent } from './models/pipeline-task-event';
 import { last } from 'ramda';
 import { Inject } from '@nestjs/common';
+import {
+  EXCHANGE_PIPELINE_TASK_TOPIC,
+  QUEUE_PIPELINE_TASK_KILL,
+  ROUTE_PIPELINE_TASK_KILL,
+} from './pipeline-tasks.constants';
+import {
+  EXCHANGE_PIPELINE_TASK_FANOUT,
+  ROUTE_PIPELINE_TASK_LOG,
+} from './pipeline-tasks.constants';
+import {
+  getInstanceName,
+  getSelfInstanceQueueKey,
+  getSelfInstanceRouteKey,
+} from '../commons/utils/rabbit-mq';
+import { rm, unlink } from 'fs/promises';
+import { rename } from 'fs/promises';
 
 type Spawn = typeof spawn;
 
 export class PipelineTaskRunner {
   readonly processes = new Map<string, ChildProcessWithoutNullStreams>();
+  readonly stopTaskIds = new Set<string>();
 
   constructor(
     private readonly reposService: ReposService,
@@ -21,6 +42,7 @@ export class PipelineTaskRunner {
     private readonly logger: PinoLogger,
     @Inject('spawn')
     private readonly spawn: Spawn,
+    private readonly amqpConnection: AmqpConnection,
   ) {}
   @RabbitSubscribe({
     exchange: 'new-pipeline-task',
@@ -35,19 +57,27 @@ export class PipelineTaskRunner {
       this.logger.error({ task, err }, err.message);
     }
   }
-  @RabbitSubscribe({
+  @RabbitRPC({
-    exchange: 'stop-pipeline-task',
+    exchange: EXCHANGE_PIPELINE_TASK_TOPIC,
-    routingKey: 'mac',
+    routingKey: getSelfInstanceRouteKey(ROUTE_PIPELINE_TASK_KILL),
-    queue: 'mac.stop-pipeline-task',
+    queue: getSelfInstanceQueueKey(QUEUE_PIPELINE_TASK_KILL),
+    queueOptions: {
+      autoDelete: true,
+      durable: true,
+    },
   })
   async onStopTask(task: PipelineTask) {
     this.logger.info({ task }, 'on stop task [%s].', task.id);
+    this.stopTaskIds.add(task.id);
     const process = this.processes.get(task.id);
     if (process) {
       this.logger.info({ task }, 'send signal SIGINT to child process.');
       process.kill('SIGINT');
 
       setTimeout(() => {
+        setTimeout(() => {
+          this.stopTaskIds.delete(task.id);
+        }, 10_000);
         if (process === this.processes.get(task.id)) {
           this.logger.info({ task }, 'send signal SIGKILL to child process.');
           process.kill('SIGKILL');
@@ -63,6 +93,7 @@ export class PipelineTaskRunner {
     } else {
       this.logger.info({ task }, 'child process is not running.');
     }
+    return true;
   }
 
   async doTask(task: PipelineTask) {
@@ -81,7 +112,7 @@ export class PipelineTaskRunner {
 
     this.logger.info('running task [%s].', task.id);
     try {
-      const workspaceRoot = await this.checkout(task);
+      let workspaceRoot = await this.checkout(task);
       const units = task.units
         .filter((unit) => unit !== PipelineUnits.checkout)
         .map(
@@ -92,6 +123,22 @@ export class PipelineTaskRunner {
         );
       this.logger.info({ units }, 'begin run units.');
       for (const unit of units) {
+        if (unit.type === PipelineUnits.deploy) {
+          const oldRoot = workspaceRoot;
+          workspaceRoot = this.reposService.getDeployRoot(task);
+          if (oldRoot !== workspaceRoot) {
+            await rm(workspaceRoot, { force: true, recursive: true });
+            await rename(oldRoot, workspaceRoot);
+          }
+
+          await this.emitEvent(
+            task,
+            unit.type,
+            TaskStatuses.success,
+            `[deploy] change deploy folder content success`,
+            'stdout',
+          );
+        }
         await this.doTaskUnit(unit.type, unit.scripts, task, workspaceRoot);
       }
       await this.emitEvent(
@@ -132,6 +179,9 @@ export class PipelineTaskRunner {
     try {
       for (const script of scripts) {
         this.logger.debug('begin runScript %s', script);
+        if (this.stopTaskIds.has(task.id)) {
+          throw new ApplicationException('Task is be KILLED');
+        }
         await this.runScript(script, workspaceRoot, task, unit);
         this.logger.debug('end runScript %s', script);
       }
@@ -181,6 +231,7 @@ export class PipelineTaskRunner {
         'checkout failed.',
         'stderr',
       );
+      throw err;
     }
   }
 
@@ -201,6 +252,19 @@ export class PipelineTaskRunner {
       messageType,
       status,
     };
+    this.amqpConnection
+      .publish(EXCHANGE_PIPELINE_TASK_FANOUT, ROUTE_PIPELINE_TASK_LOG, event, {
+        headers: {
+          sender: getInstanceName(),
+        },
+      })
+      .catch((error) => {
+        this.logger.error(
+          { error, event },
+          'send event message to queue failed. %s',
+          error.message,
+        );
+      });
   }
 
   async runScript(
@@ -246,6 +310,9 @@ export class PipelineTaskRunner {
         if (code === 0) {
           return resolve();
         }
+        if (this.stopTaskIds.has(task.id)) {
+          throw reject(new ApplicationException('Task is be KILLED'));
+        }
         return reject(new ApplicationException('exec script failed'));
       });
     });

src/pipeline-tasks/pipeline-tasks.constants.ts

@@ -0,0 +1,9 @@
+export const EXCHANGE_PIPELINE_TASK_TOPIC = 'pipeline-task.topic';
+export const EXCHANGE_PIPELINE_TASK_FANOUT = 'pipeline-task.fanout';
+export const ROUTE_PIPELINE_TASK_LOG = 'pipeline-task-log';
+export const QUEUE_HANDLE_PIPELINE_TASK_LOG_EVENT = 'pipeline-task-log';
+export const QUEUE_WRITE_PIPELINE_TASK_LOG = 'write-pipeline-task-log';
+export const ROUTE_PIPELINE_TASK_DONE = 'pipeline-task-done';
+export const QUEUE_PIPELINE_TASK_DONE = 'pipeline-task-done';
+export const ROUTE_PIPELINE_TASK_KILL = 'pipeline-task-kill';
+export const QUEUE_PIPELINE_TASK_KILL = 'pipeline-task-kill';

src/pipeline-tasks/pipeline-tasks.module.ts

@@ -10,13 +10,20 @@ import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { PipelineTaskRunner } from './pipeline-task.runner';
 import { spawn } from 'child_process';
+import {
+  EXCHANGE_PIPELINE_TASK_FANOUT,
+  EXCHANGE_PIPELINE_TASK_TOPIC,
+} from './pipeline-tasks.constants';
+import { PipelineTaskLogger } from './pipeline-task.logger';
+import { PipelineTaskFlushService } from './pipeline-task-flush.service';
+import { CommonsModule } from '../commons/commons.module';
 
 @Module({
   imports: [
+    CommonsModule,
     TypeOrmModule.forFeature([PipelineTask, Pipeline]),
     RedisModule,
     ReposModule,
-
     RabbitMQModule.forRootAsync(RabbitMQModule, {
       imports: [ConfigModule],
       useFactory: (configService: ConfigService) => ({
@@ -27,20 +34,23 @@ import { spawn } from 'child_process';
             type: 'fanout',
             options: {
               durable: true,
+              autoDelete: true,
             },
           },
           {
-            name: 'stop-pipeline-task',
+            name: EXCHANGE_PIPELINE_TASK_FANOUT,
-            type: 'fanout',
-            options: {
-              durable: true,
-            },
-          },
-          {
-            name: 'update-pipeline-task',
             type: 'fanout',
             options: {
               durable: false,
+              autoDelete: true,
+            },
+          },
+          {
+            name: EXCHANGE_PIPELINE_TASK_TOPIC,
+            type: 'topic',
+            options: {
+              durable: false,
+              autoDelete: true,
             },
           },
         ],
@@ -52,10 +62,12 @@ import { spawn } from 'child_process';
     PipelineTasksService,
     PipelineTasksResolver,
     PipelineTaskRunner,
+    PipelineTaskLogger,
     {
       provide: 'spawn',
       useValue: spawn,
     },
+    PipelineTaskFlushService,
   ],
   exports: [PipelineTasksService],
 })

src/pipeline-tasks/pipeline-tasks.resolver.spec.ts

@@ -1,4 +1,6 @@
+import { JwtService } from '@nestjs-lib/auth';
 import { Test, TestingModule } from '@nestjs/testing';
+import { PipelineTaskLogger } from './pipeline-task.logger';
 import { PipelineTasksResolver } from './pipeline-tasks.resolver';
 import { PipelineTasksService } from './pipeline-tasks.service';
 
@@ -13,6 +15,14 @@ describe('PipelineTasksResolver', () => {
           provide: PipelineTasksService,
           useValue: {},
         },
+        {
+          provide: PipelineTaskLogger,
+          useValue: {},
+        },
+        {
+          provide: JwtService,
+          useValue: {},
+        },
       ],
     }).compile();
 

src/pipeline-tasks/pipeline-tasks.resolver.ts

@@ -2,29 +2,37 @@ import { Resolver, Args, Mutation, Subscription, Query } from '@nestjs/graphql';
 import { PipelineTask } from './pipeline-task.entity';
 import { PipelineTasksService } from './pipeline-tasks.service';
 import { CreatePipelineTaskInput } from './dtos/create-pipeline-task.input';
-import { PipelineTaskLogMessage } from './models/pipeline-task-log-message.module';
 import { PipelineTaskLogArgs } from './dtos/pipeline-task-log.args';
 import { plainToClass } from 'class-transformer';
+import { PipelineTaskLogger } from './pipeline-task.logger';
+import { observableToAsyncIterable } from '@graphql-tools/utils';
+import { PipelineTaskEvent } from './models/pipeline-task-event';
+import { Roles, AccountRole } from '@nestjs-lib/auth';
 
+@Roles(AccountRole.admin, AccountRole.super)
 @Resolver()
 export class PipelineTasksResolver {
-  constructor(private readonly service: PipelineTasksService) {}
+  constructor(
+    private readonly service: PipelineTasksService,
+    private readonly taskLogger: PipelineTaskLogger,
+  ) {}
 
   @Mutation(() => PipelineTask)
   async createPipelineTask(@Args('task') taskDto: CreatePipelineTaskInput) {
     return await this.service.addTask(taskDto);
   }
 
-  @Subscription(() => PipelineTaskLogMessage, {
+  @Subscription(() => PipelineTaskEvent, {
     resolve: (value) => {
-      const data = plainToClass(PipelineTaskLogMessage, value);
+      const data = plainToClass(PipelineTaskEvent, value);
       return data;
     },
   })
-  async pipelineTaskLog(@Args() args: PipelineTaskLogArgs) {
+  async pipelineTaskEvent(@Args() args: PipelineTaskLogArgs) {
-    // const task = await this.service.findTaskById(args.taskId);
+    const task = await this.service.findTaskById(args.taskId);
-    // const asyncIterator = this.logsService.watchLogs(task);
+    return observableToAsyncIterable<PipelineTaskEvent>(
-    // return asyncIterator;
+      this.taskLogger.getMessage$(task.id),
+    );
   }
 
   @Subscription(() => PipelineTask, {
@@ -49,5 +57,7 @@ export class PipelineTasksResolver {
   @Mutation(() => Boolean)
   async stopPipelineTask(@Args('id') id: string) {
     const task = await this.service.findTaskById(id);
+    await this.service.stopTask(task);
+    return true;
   }
 }

src/pipeline-tasks/pipeline-tasks.service.spec.ts

@@ -4,26 +4,15 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 import { PipelineTask } from './pipeline-task.entity';
 import { Pipeline } from '../pipelines/pipeline.entity';
 import { Repository } from 'typeorm';
-import { Queue } from 'bull';
 import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { PipelineTaskFlushService } from './pipeline-task-flush.service';
+import { getLoggerToken, PinoLogger } from 'nestjs-pino';
 
 describe('PipelineTasksService', () => {
   let service: PipelineTasksService;
   let module: TestingModule;
   let taskRepository: Repository<PipelineTask>;
   let pipelineRepository: Repository<Pipeline>;
-  const getBasePipeline = () =>
-    ({
-      id: 'test',
-      name: '测试流水线',
-      branch: 'master',
-      workUnitMetadata: {},
-      project: {
-        id: 'test-project',
-      },
-    } as Pipeline);
-  let redisClient;
-  let taskQueue: Queue;
 
   beforeEach(async () => {
     module = await Test.createTestingModule({
@@ -41,6 +30,14 @@ describe('PipelineTasksService', () => {
           provide: AmqpConnection,
           useValue: {},
         },
+        {
+          provide: PipelineTaskFlushService,
+          useValue: {},
+        },
+        {
+          provide: getLoggerToken(PipelineTasksService.name),
+          useValue: new PinoLogger({}),
+        },
       ],
     }).compile();
 

src/pipeline-tasks/pipeline-tasks.service.ts

@@ -1,11 +1,23 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { PipelineTask } from './pipeline-task.entity';
 import { Repository } from 'typeorm';
 import { CreatePipelineTaskInput } from './dtos/create-pipeline-task.input';
 import { Pipeline } from '../pipelines/pipeline.entity';
 import debug from 'debug';
-import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { AmqpConnection, RabbitRPC } from '@golevelup/nestjs-rabbitmq';
+import {
+  EXCHANGE_PIPELINE_TASK_TOPIC,
+  QUEUE_PIPELINE_TASK_DONE,
+  ROUTE_PIPELINE_TASK_DONE,
+} from './pipeline-tasks.constants';
+import { PipelineTaskFlushService } from './pipeline-task-flush.service';
+import { find, isNil, propEq } from 'ramda';
+import { PipelineTaskLogs } from './models/pipeline-task-logs.model';
+import { TaskStatuses, terminalTaskStatuses } from './enums/task-statuses.enum';
+import { InjectPinoLogger, PinoLogger } from 'nestjs-pino';
+import { getAppInstanceRouteKey } from '../commons/utils/rabbit-mq';
+import { ROUTE_PIPELINE_TASK_KILL } from './pipeline-tasks.constants';
 
 const log = debug('fennec:pipeline-tasks:service');
 
@@ -17,6 +29,9 @@ export class PipelineTasksService {
     @InjectRepository(Pipeline)
     private readonly pipelineRepository: Repository<Pipeline>,
     private readonly amqpConnection: AmqpConnection,
+    private readonly eventFlushService: PipelineTaskFlushService,
+    @InjectPinoLogger(PipelineTasksService.name)
+    private readonly logger: PinoLogger,
   ) {}
   async addTask(dto: CreatePipelineTaskInput) {
     const pipeline = await this.pipelineRepository.findOneOrFail({
@@ -51,10 +66,93 @@ export class PipelineTasksService {
   }
 
   async listTasksByCommitHash(hash: string) {
-    return await this.repository.find({ commit: hash });
+    return await this.repository.find({
+      where: { commit: hash },
+      order: { createdAt: 'DESC' },
+    });
   }
 
   getRedisTokens(pipeline: Pipeline): [string, string] {
     return [`pipeline-${pipeline.id}:lck`, `pipeline-${pipeline.id}:tasks`];
   }
+
+  @RabbitRPC({
+    exchange: EXCHANGE_PIPELINE_TASK_TOPIC,
+    routingKey: ROUTE_PIPELINE_TASK_DONE,
+    queue: QUEUE_PIPELINE_TASK_DONE,
+    queueOptions: {
+      autoDelete: true,
+      durable: true,
+    },
+  })
+  async updateByEvent({ taskId, runOn }: { taskId: string; runOn: string }) {
+    try {
+      const [events, task] = await Promise.all([
+        this.eventFlushService.read(taskId),
+        this.findTaskById(taskId),
+      ]);
+      this.logger.info('[updateByEvent] start. taskId: %s', taskId);
+
+      for (const event of events) {
+        if (isNil(event.unit)) {
+          if (
+            event.status !== TaskStatuses.pending &&
+            task.status === TaskStatuses.pending
+          ) {
+            task.startedAt = event.emittedAt;
+          } else if (terminalTaskStatuses.includes(event.status)) {
+            task.endedAt = event.emittedAt;
+          }
+          task.status = event.status;
+        } else {
+          let l: PipelineTaskLogs = find<PipelineTaskLogs>(
+            propEq('unit', event.unit),
+            task.logs,
+          );
+
+          if (isNil(l)) {
+            l = {
+              unit: event.unit,
+              startedAt: event.emittedAt,
+              endedAt: null,
+              logs: event.message,
+              status: event.status,
+            };
+
+            task.logs.push(l);
+          } else {
+            l.logs += event.message;
+          }
+
+          if (terminalTaskStatuses.includes(event.status)) {
+            l.endedAt = event.emittedAt;
+          }
+          l.status = event.status;
+        }
+      }
+      task.runOn = runOn;
+      await this.repository.update({ id: taskId }, task);
+      this.logger.info('[updateByEvent] success. taskId: %s', taskId);
+      return task;
+    } catch (error) {
+      this.logger.error(
+        { error },
+        '[updateByEvent] failed. taskId: %s',
+        taskId,
+      );
+    }
+  }
+
+  async stopTask(task: PipelineTask) {
+    if (isNil(task.runOn)) {
+      throw new BadRequestException(
+        "the task have not running instance on database. field 'runOn' is nil",
+      );
+    }
+    await this.amqpConnection.request({
+      exchange: EXCHANGE_PIPELINE_TASK_TOPIC,
+      routingKey: getAppInstanceRouteKey(ROUTE_PIPELINE_TASK_KILL, task.runOn),
+      payload: task,
+    });
+  }
 }

src/pipelines/commit-logs.resolver.spec.ts

@@ -1,3 +1,4 @@
+import { JwtService } from '@nestjs-lib/auth';
 import { Test, TestingModule } from '@nestjs/testing';
 import { PipelineTasksService } from '../pipeline-tasks/pipeline-tasks.service';
 import { CommitLogsResolver } from './commit-logs.resolver';
@@ -18,6 +19,10 @@ describe('CommitLogsResolver', () => {
           provide: PipelineTasksService,
           useValue: {},
         },
+        {
+          provide: JwtService,
+          useValue: {},
+        },
       ],
     }).compile();
 

src/pipelines/commit-logs.resolver.ts

@@ -1,3 +1,4 @@
+import { Roles, AccountRole } from '@nestjs-lib/auth';
 import { Query } from '@nestjs/graphql';
 import {
   Args,
@@ -10,6 +11,7 @@ import { PipelineTasksService } from '../pipeline-tasks/pipeline-tasks.service';
 import { Commit, LogFields } from '../repos/dtos/log-list.model';
 import { PipelinesService } from './pipelines.service';
 
+@Roles(AccountRole.admin, AccountRole.super)
 @Resolver(() => Commit)
 export class CommitLogsResolver {
   constructor(

src/pipelines/dtos/create-pipeline.input.ts

@@ -1,11 +1,13 @@
+import { Type } from 'class-transformer';
 import { InputType } from '@nestjs/graphql';
 import { WorkUnitMetadata } from '../../pipeline-tasks/models/work-unit-metadata.model';
 import {
-  IsObject,
+  IsInstance,
   IsOptional,
   IsString,
   IsUUID,
   MaxLength,
+  ValidateNested,
 } from 'class-validator';
 
 @InputType({ isAbstract: true })
@@ -21,7 +23,9 @@ export class CreatePipelineInput {
   @MaxLength(32)
   name: string;
 
+  @Type(() => WorkUnitMetadata)
   @IsOptional()
-  @IsObject()
+  @ValidateNested()
+  @IsInstance(WorkUnitMetadata)
   workUnitMetadata: WorkUnitMetadata;
 }

src/pipelines/dtos/update-pipeline.input.ts

@@ -1,7 +1,9 @@
-import { InputType } from '@nestjs/graphql';
+import { InputType, OmitType } from '@nestjs/graphql';
 import { CreatePipelineInput } from './create-pipeline.input';
 
 @InputType()
-export class UpdatePipelineInput extends CreatePipelineInput {
+export class UpdatePipelineInput extends OmitType(CreatePipelineInput, [
+  'projectId',
+]) {
   id: string;
 }

src/pipelines/pipelines.module.ts

@@ -8,9 +8,11 @@ import { PipelineTasksModule } from '../pipeline-tasks/pipeline-tasks.module';
 import { ReposModule } from '../repos/repos.module';
 import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
 import { ConfigModule, ConfigService } from '@nestjs/config';
+import { CommonsModule } from '../commons/commons.module';
 
 @Module({
   imports: [
+    CommonsModule,
     TypeOrmModule.forFeature([Pipeline]),
     PipelineTasksModule,
     RabbitMQModule.forRootAsync(RabbitMQModule, {

src/pipelines/pipelines.resolver.spec.ts

@@ -1,3 +1,4 @@
+import { JwtService } from '@nestjs-lib/auth';
 import { Test, TestingModule } from '@nestjs/testing';
 import { PipelinesResolver } from './pipelines.resolver';
 import { PipelinesService } from './pipelines.service';
@@ -13,6 +14,10 @@ describe('PipelinesResolver', () => {
           provide: PipelinesService,
           useValue: {},
         },
+        {
+          provide: JwtService,
+          useValue: {},
+        },
       ],
     }).compile();
 

src/pipelines/pipelines.resolver.ts

@@ -4,7 +4,9 @@ import { UpdatePipelineInput } from './dtos/update-pipeline.input';
 import { Pipeline } from './pipeline.entity';
 import { PipelinesService } from './pipelines.service';
 import { ListPipelineArgs } from './dtos/list-pipelines.args';
+import { Roles, AccountRole } from '@nestjs-lib/auth';
 
+@Roles(AccountRole.admin, AccountRole.super)
 @Resolver()
 export class PipelinesResolver {
   constructor(private readonly service: PipelinesService) {}
@@ -21,14 +23,14 @@ export class PipelinesResolver {
   @Mutation(() => Pipeline)
   async createPipeline(
     @Args('pipeline', { type: () => CreatePipelineInput })
-    dto: UpdatePipelineInput,
+    dto: CreatePipelineInput,
   ) {
     return await this.service.create(dto);
   }
 
   @Mutation(() => Pipeline)
   async updatePipeline(
-    @Args('Pipeline', { type: () => UpdatePipelineInput })
+    @Args('pipeline', { type: () => UpdatePipelineInput })
     dto: UpdatePipelineInput,
   ) {
     const tmp = await this.service.update(dto);

src/pipelines/pipelines.service.ts

@@ -14,6 +14,8 @@ import {
 import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
 import { Commit } from '../repos/dtos/log-list.model';
 import { getAppInstanceRouteKey } from '../commons/utils/rabbit-mq';
+import { ApplicationException } from '../commons/exceptions/application.exception';
+import { plainToClass } from 'class-transformer';
 
 @Injectable()
 export class PipelinesService extends BaseDbService<Pipeline> {
@@ -42,8 +44,8 @@ export class PipelinesService extends BaseDbService<Pipeline> {
   }
 
   async update(dto: UpdatePipelineInput) {
-    await this.isDuplicateEntityForUpdate(dto.id, dto);
     const old = await this.findOne(dto.id);
+    await this.isDuplicateEntityForUpdate(old, dto);
     return await this.repository.save(this.repository.merge(old, dto));
   }
 
@@ -55,22 +57,22 @@ export class PipelinesService extends BaseDbService<Pipeline> {
       exchange: EXCHANGE_REPO,
       routingKey: getAppInstanceRouteKey(ROUTE_FETCH, appInstance),
       payload: pipeline,
-      timeout: 30_000,
+      timeout: 120_000,
     });
   }
   async listCommits(pipeline: Pipeline) {
     return await this.amqpConnection
-      .request<Commit[]>({
+      .request<[Error, Commit[]]>({
         exchange: EXCHANGE_REPO,
         routingKey: ROUTE_LIST_COMMITS,
         payload: pipeline,
-        timeout: 10_000,
+        timeout: 30_000,
       })
-      .then((list) =>
+      .then(([error, list]) => {
-        list.map((item) => {
+        if (error) {
-          item.date = new Date(item.date);
+          throw new ApplicationException(error);
-          return item;
+        }
-        }),
+        return plainToClass(Commit, list);
-      );
+      });
   }
 }

src/projects/projects.constants.ts

@@ -0,0 +1,3 @@
+export const EXCHANGE_PROJECT_TOPIC = 'project.topic';
+export const EXCHANGE_PROJECT_FANOUT = 'project.fanout';
+export const ROUTE_PROJECT_CHANGE = 'project-change';

src/projects/projects.module.ts

@@ -3,9 +3,33 @@ import { ProjectsService } from './projects.service';
 import { ProjectsResolver } from './projects.resolver';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Project } from './project.entity';
+import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { EXCHANGE_PROJECT_FANOUT } from './projects.constants';
+import { CommonsModule } from '../commons/commons.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Project])],
+  imports: [
+    CommonsModule,
+    TypeOrmModule.forFeature([Project]),
+    RabbitMQModule.forRootAsync(RabbitMQModule, {
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        uri: configService.get<string>('db.rabbitmq.uri'),
+        exchanges: [
+          {
+            name: EXCHANGE_PROJECT_FANOUT,
+            type: 'fanout',
+            options: {
+              durable: false,
+              autoDelete: true,
+            },
+          },
+        ],
+      }),
+      inject: [ConfigService],
+    }),
+  ],
   providers: [ProjectsService, ProjectsResolver],
   exports: [ProjectsService],
 })

src/projects/projects.resolver.spec.ts

@@ -1,3 +1,4 @@
+import { JwtService } from '@nestjs-lib/auth';
 import { Test, TestingModule } from '@nestjs/testing';
 import { ProjectsResolver } from './projects.resolver';
 import { ProjectsService } from './projects.service';
@@ -13,6 +14,10 @@ describe('ProjectsResolver', () => {
           provide: ProjectsService,
           useValue: {},
         },
+        {
+          provide: JwtService,
+          useValue: {},
+        },
       ],
     }).compile();
 

src/projects/projects.resolver.ts

@@ -1,9 +1,11 @@
+import { AccountRole, Roles } from '@nestjs-lib/auth';
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import { CreateProjectInput } from './dtos/create-project.input';
 import { UpdateProjectInput } from './dtos/update-project.input';
 import { Project } from './project.entity';
 import { ProjectsService } from './projects.service';
 
+@Roles(AccountRole.admin, AccountRole.super)
 @Resolver(() => Project)
 export class ProjectsResolver {
   constructor(private readonly service: ProjectsService) {}
@@ -20,7 +22,7 @@ export class ProjectsResolver {
   @Mutation(() => Project)
   async createProject(
     @Args('project', { type: () => CreateProjectInput })
-    dto: UpdateProjectInput,
+    dto: CreateProjectInput,
   ) {
     return await this.service.create(dto);
   }

src/projects/projects.service.spec.ts

@@ -2,6 +2,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { ProjectsService } from './projects.service';
 import { getRepositoryToken } from '@nestjs/typeorm';
 import { Project } from './project.entity';
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
 
 describe('ProjectsService', () => {
   let service: ProjectsService;
@@ -14,6 +15,10 @@ describe('ProjectsService', () => {
           provide: getRepositoryToken(Project),
           useValue: {},
         },
+        {
+          provide: AmqpConnection,
+          useValue: {},
+        },
       ],
     }).compile();
 

src/projects/projects.service.ts

@@ -5,6 +5,11 @@ import { Repository } from 'typeorm';
 import { CreateProjectInput } from './dtos/create-project.input';
 import { Project } from './project.entity';
 import { UpdateProjectInput } from './dtos/update-project.input';
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import {
+  EXCHANGE_PROJECT_FANOUT,
+  ROUTE_PROJECT_CHANGE,
+} from './projects.constants';
 
 @Injectable()
 export class ProjectsService extends BaseDbService<Project> {
@@ -12,6 +17,7 @@ export class ProjectsService extends BaseDbService<Project> {
   constructor(
     @InjectRepository(Project)
     readonly repository: Repository<Project>,
+    private readonly amqpConnection: AmqpConnection,
   ) {
     super(repository);
   }
@@ -28,7 +34,12 @@ export class ProjectsService extends BaseDbService<Project> {
   async update(dto: UpdateProjectInput) {
     await this.isDuplicateEntityForUpdate(dto.id, dto);
     const old = await this.findOne(dto.id);
-    return await this.repository.save(this.repository.merge(old, dto));
+    const project = await this.repository.save(this.repository.merge(old, dto));
+    this.amqpConnection.publish(EXCHANGE_PROJECT_FANOUT, ROUTE_PROJECT_CHANGE, [
+      project,
+      old,
+    ]);
+    return project;
   }
 
   async remove(id: string) {

src/repos/dtos/log-list.model.ts

@@ -1,10 +1,12 @@
 import { ObjectType, Field } from '@nestjs/graphql';
+import { Type } from 'class-transformer';
 import { LogResult, DefaultLogFields } from 'simple-git';
 import { PipelineTask } from '../../pipeline-tasks/pipeline-task.entity';
 
 @ObjectType()
 export class Commit {
   hash: string;
+  @Type(() => Date)
   date: Date;
   message: string;
   refs: string;

src/repos/repos.constants.ts

@@ -3,3 +3,4 @@ export const ROUTE_FETCH = 'fetch';
 export const ROUTE_LIST_COMMITS = 'list-commits';
 export const QUEUE_LIST_COMMITS = 'list-commits';
 export const QUEUE_FETCH = 'repo-fetch';
+export const QUEUE_REFRESH_REPO = 'refresh-repo';

src/repos/repos.module.ts

@@ -7,12 +7,14 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
 import { ProjectsModule } from '../projects/projects.module';
 import { EXCHANGE_REPO } from './repos.constants';
 import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
+import { CommonsModule } from '../commons/commons.module';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([Project]),
     ConfigModule,
     ProjectsModule,
+    CommonsModule,
     RabbitMQModule.forRootAsync(RabbitMQModule, {
       imports: [ConfigModule],
       useFactory: (configService: ConfigService) => ({

src/repos/repos.service.spec.ts

@@ -12,6 +12,7 @@ import { readFile } from 'fs/promises';
 import { getLoggerToken, PinoLogger } from 'nestjs-pino';
 import { Nack } from '@golevelup/nestjs-rabbitmq';
 import { getInstanceName } from '../commons/utils/rabbit-mq';
+import { RedisMutexService } from '../commons/redis-mutex/redis-mutex.service';
 
 const getTest1Project = () =>
   ({
@@ -52,6 +53,14 @@ describe('ReposService', () => {
           provide: getLoggerToken(ReposService.name),
           useValue: new PinoLogger({}),
         },
+        {
+          provide: RedisMutexService,
+          useValue: {
+            lock: jest.fn(() =>
+              Promise.resolve(() => Promise.resolve(undefined)),
+            ),
+          },
+        },
       ],
     }).compile();
 

src/repos/repos.service.ts

@@ -11,13 +11,14 @@ import { Project } from '../projects/project.entity';
 import { ListBranchesArgs } from './dtos/list-branches.args';
 import { ConfigService } from '@nestjs/config';
 import { Commit } from './dtos/log-list.model';
-import { Nack, RabbitRPC } from '@golevelup/nestjs-rabbitmq';
+import { Nack, RabbitRPC, RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
 import { Pipeline } from '../pipelines/pipeline.entity';
-import { InjectPinoLogger, Logger } from 'nestjs-pino';
+import { InjectPinoLogger, PinoLogger } from 'nestjs-pino';
 import {
   EXCHANGE_REPO,
   QUEUE_FETCH,
   QUEUE_LIST_COMMITS,
+  QUEUE_REFRESH_REPO,
   ROUTE_FETCH,
   ROUTE_LIST_COMMITS,
 } from './repos.constants';
@@ -26,6 +27,13 @@ import {
   getInstanceName,
   getSelfInstanceRouteKey,
 } from '../commons/utils/rabbit-mq';
+import { ApplicationException } from '../commons/exceptions/application.exception';
+import {
+  EXCHANGE_PROJECT_FANOUT,
+  ROUTE_PROJECT_CHANGE,
+} from '../projects/projects.constants';
+import { RedisMutexService } from '../commons/redis-mutex/redis-mutex.service';
+import { rm } from 'fs/promises';
 
 const DEFAULT_REMOTE_NAME = 'origin';
 const INFO_PATH = '@info';
@@ -36,7 +44,8 @@ export class ReposService {
     private readonly projectRepository: Repository<Project>,
     private readonly configService: ConfigService,
     @InjectPinoLogger(ReposService.name)
-    private readonly logger: Logger,
+    private readonly logger: PinoLogger,
+    private readonly redisMutexService: RedisMutexService,
   ) {}
 
   getWorkspaceRoot(project: Project): string {
@@ -47,6 +56,14 @@ export class ReposService {
     );
   }
 
+  getDeployRoot(task: PipelineTask) {
+    return join(
+      this.configService.get<string>('workspaces.root'),
+      encodeURIComponent(task.pipeline.project.name),
+      encodeURIComponent(`deploy-${task.pipeline.name}`),
+    );
+  }
+
   async getGit(
     project: Project,
     workspaceRoot?: string,
@@ -129,7 +146,7 @@ export class ReposService {
       autoDelete: true,
     },
   })
-  async listCommits(pipeline: Pipeline): Promise<Commit[] | Nack> {
+  async listCommits(pipeline: Pipeline): Promise<[Error, Commit[]?]> {
     const git = await this.getGit(pipeline.project, undefined, {
       fetch: false,
     });
@@ -140,20 +157,23 @@ export class ReposService {
         `remotes/origin/${pipeline.branch}`,
         '--',
       ]);
-      return data.all.map(
+      return [
-        (it) =>
+        null,
-          ({
+        data.all.map(
-            ...it,
+          (it) =>
-            date: new Date(it.date),
+            ({
-          } as Commit),
+              ...it,
-      );
+              date: new Date(it.date),
+            } as Commit),
+        ),
+      ];
     } catch (error) {
       this.logger.error(
         { error, pipeline },
         '[listCommits] %s',
         error?.message,
       );
-      return new Nack();
+      return [new ApplicationException(error)];
     }
   }
 
@@ -166,6 +186,9 @@ export class ReposService {
     },
   })
   async fetch(pipeline: Pipeline): Promise<string | null | Nack> {
+    const unlock = await this.redisMutexService.lock(
+      `repo-project-${pipeline.projectId}`,
+    );
     try {
       const git = await this.getGit(pipeline.project, undefined, {
         fetch: false,
@@ -175,6 +198,43 @@ export class ReposService {
     } catch (error) {
       this.logger.error({ error, pipeline }, '[fetch] %s', error?.message);
       return new Nack();
+    } finally {
+      await unlock();
+    }
+  }
+
+  @RabbitSubscribe({
+    exchange: EXCHANGE_PROJECT_FANOUT,
+    routingKey: ROUTE_PROJECT_CHANGE,
+    queue: QUEUE_REFRESH_REPO,
+    queueOptions: {
+      autoDelete: true,
+      durable: true,
+    },
+  })
+  async refreshRepo([project]: [Project]) {
+    this.logger.info({ project }, '[refreshRepo] start');
+    const unlock = await this.redisMutexService.lock(
+      `repo-project-${project.id}`,
+      {
+        timeout: null,
+      },
+    );
+    try {
+      const path = join(
+        this.configService.get<string>('workspaces.root'),
+        encodeURIComponent(project.name),
+      );
+      await rm(path, { recursive: true });
+      this.logger.info({ project }, '[refreshRepo] success');
+    } catch (error) {
+      this.logger.error(
+        { project, error },
+        '[refreshRepo] failed. $s',
+        error.message,
+      );
+    } finally {
+      await unlock();
     }
   }
 }

tsconfig.json

@@ -7,6 +7,7 @@
     "experimentalDecorators": true,
     "allowSyntheticDefaultImports": true,
     "target": "es2017",
+    "lib": ["ES2021"],
     "sourceMap": true,
     "outDir": "./dist",
     "baseUrl": "./",