build: trident-sync prepare

packages/ui/certd-server/src/modules/pipeline/auto/auto-register-cron.ts

@@ -0,0 +1,26 @@
+import { Autoload, Init, Inject, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { PipelineService } from '../service/pipeline-service';
+import { logger } from '../../../utils/logger';
+
+@Autoload()
+@Scope(ScopeEnum.Singleton)
+export class AutoRegisterCron {
+  @Inject()
+  pipelineService: PipelineService;
+
+  // @Inject()
+  // echoPlugin: EchoPlugin;
+
+  @Init()
+  async init() {
+    logger.info('加载定时trigger开始');
+    await this.pipelineService.onStartup();
+    // logger.info(this.echoPlugin, this.echoPlugin.test);
+    // logger.info('加载定时trigger完成');
+    //
+    // const meta = getClassMetadata(CLASS_KEY, this.echoPlugin);
+    // console.log('meta', meta);
+    // const metas = listPropertyDataFromClass(CLASS_KEY, this.echoPlugin);
+    // console.log('metas', metas);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/controller/access-controller.ts

@@ -0,0 +1,80 @@
+import {
+  ALL,
+  Body,
+  Controller,
+  Inject,
+  Post,
+  Provide,
+  Query,
+} from '@midwayjs/decorator';
+import { CrudController } from '../../../basic/crud-controller';
+import { AccessService } from '../service/access-service';
+
+/**
+ * 授权
+ */
+@Provide()
+@Controller('/api/pi/access')
+export class AccessController extends CrudController {
+  @Inject()
+  service: AccessService;
+
+  getService() {
+    return this.service;
+  }
+
+  @Post('/page')
+  async page(@Body(ALL) body) {
+    body.query = body.query ?? {};
+    body.query.userId = this.ctx.user.id;
+    return super.page(body);
+  }
+
+  @Post('/list')
+  async list(@Body(ALL) body) {
+    body.userId = this.ctx.user.id;
+    return super.list(body);
+  }
+
+  @Post('/add')
+  async add(@Body(ALL) bean) {
+    bean.userId = this.ctx.user.id;
+    return super.add(bean);
+  }
+
+  @Post('/update')
+  async update(@Body(ALL) bean) {
+    await this.service.checkUserId(bean.id, this.ctx.user.id);
+    return super.update(bean);
+  }
+  @Post('/info')
+  async info(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    return super.info(id);
+  }
+
+  @Post('/delete')
+  async delete(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    return super.delete(id);
+  }
+
+  @Post('/define')
+  async define(@Query('type') type) {
+    const provider = this.service.getDefineByType(type);
+    return this.ok(provider);
+  }
+
+  @Post('/accessTypeDict')
+  async getAccessTypeDict() {
+    const list = this.service.getDefineList();
+    const dict = [];
+    for (const item of list) {
+      dict.push({
+        value: item.name,
+        label: item.title,
+      });
+    }
+    return this.ok(dict);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/controller/dns-provider-controller.ts

@@ -0,0 +1,40 @@
+import {
+  ALL,
+  Controller,
+  Inject,
+  Post,
+  Provide,
+  Query,
+} from '@midwayjs/decorator';
+import { DnsProviderService } from '../service/dns-provider-service';
+import { BaseController } from '../../../basic/base-controller';
+
+/**
+ * 插件
+ */
+@Provide()
+@Controller('/api/pi/dnsProvider')
+export class DnsProviderController extends BaseController {
+  @Inject()
+  service: DnsProviderService;
+
+  @Post('/list')
+  async list(@Query(ALL) query) {
+    query.userId = this.ctx.user.id;
+    const list = this.service.getList();
+    return this.ok(list);
+  }
+
+  @Post('/dnsProviderTypeDict')
+  async getDnsProviderTypeDict() {
+    const list = this.service.getList();
+    const dict = [];
+    for (const item of list) {
+      dict.push({
+        value: item.name,
+        label: item.title,
+      });
+    }
+    return this.ok(dict);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/controller/history-controller.ts

@@ -0,0 +1,106 @@
+import {
+  ALL,
+  Body,
+  Controller,
+  Inject,
+  Post,
+  Provide,
+  Query,
+} from '@midwayjs/decorator';
+import { CrudController } from '../../../basic/crud-controller';
+import { PipelineEntity } from '../entity/pipeline';
+import { HistoryService } from '../service/history-service';
+import { HistoryLogService } from '../service/history-log-service';
+import { HistoryEntity } from '../entity/history';
+import { HistoryLogEntity } from '../entity/history-log';
+
+/**
+ * 证书
+ */
+@Provide()
+@Controller('/api/pi/history')
+export class HistoryController extends CrudController {
+  @Inject()
+  service: HistoryService;
+  @Inject()
+  logService: HistoryLogService;
+
+  getService() {
+    return this.service;
+  }
+
+  @Post('/page')
+  async page(@Body(ALL) body) {
+    body.query.userId = this.ctx.user.id;
+    return super.page(body);
+  }
+
+  @Post('/list')
+  async list(@Body(ALL) body) {
+    body.userId = this.ctx.user.id;
+    if (body.pipelineId == null) {
+      return this.ok([]);
+    }
+    const buildQuery = qb => {
+      qb.limit(10);
+    };
+    const listRet = await this.getService().list(
+      body,
+      { prop: 'id', asc: false },
+      buildQuery
+    );
+    return this.ok(listRet);
+  }
+
+  @Post('/add')
+  async add(@Body(ALL) bean: PipelineEntity) {
+    bean.userId = this.ctx.user.id;
+    return super.add(bean);
+  }
+
+  @Post('/update')
+  async update(@Body(ALL) bean) {
+    await this.service.checkUserId(bean.id, this.ctx.user.id);
+    return super.update(bean);
+  }
+
+  @Post('/save')
+  async save(@Body(ALL) bean: HistoryEntity) {
+    bean.userId = this.ctx.user.id;
+    if (bean.id > 0) {
+      await this.service.checkUserId(bean.id, this.ctx.user.id);
+    }
+    await this.service.save(bean);
+    return this.ok(bean.id);
+  }
+
+  @Post('/saveLog')
+  async saveLog(@Body(ALL) bean: HistoryLogEntity) {
+    bean.userId = this.ctx.user.id;
+    if (bean.id > 0) {
+      await this.service.checkUserId(bean.id, this.ctx.user.id);
+    }
+    await this.logService.save(bean);
+    return this.ok(bean.id);
+  }
+
+  @Post('/delete')
+  async delete(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    return super.delete(id);
+  }
+
+  @Post('/detail')
+  async detail(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    const detail = await this.service.detail(id);
+    return this.ok(detail);
+  }
+
+  @Post('/logs')
+  async logs(@Query('id') id) {
+    await this.logService.checkUserId(id, this.ctx.user.id);
+    const logInfo = await this.logService.info(id);
+    return this.ok(logInfo);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/controller/pipeline-controller.ts

@@ -0,0 +1,77 @@
+import {
+  ALL,
+  Body,
+  Controller,
+  Inject,
+  Post,
+  Provide,
+  Query,
+} from '@midwayjs/decorator';
+import { CrudController } from '../../../basic/crud-controller';
+import { PipelineService } from '../service/pipeline-service';
+import { PipelineEntity } from '../entity/pipeline';
+
+/**
+ * 证书
+ */
+@Provide()
+@Controller('/api/pi/pipeline')
+export class PipelineController extends CrudController {
+  @Inject()
+  service: PipelineService;
+
+  getService() {
+    return this.service;
+  }
+
+  @Post('/page')
+  async page(@Body(ALL) body) {
+    body.query.userId = this.ctx.user.id;
+    const buildQuery = qb => {
+      qb.where({});
+    };
+    return super.page({ ...body, buildQuery });
+  }
+
+  @Post('/add')
+  async add(@Body(ALL) bean: PipelineEntity) {
+    bean.userId = this.ctx.user.id;
+    return super.add(bean);
+  }
+
+  @Post('/update')
+  async update(@Body(ALL) bean) {
+    await this.service.checkUserId(bean.id, this.ctx.user.id);
+    return super.update(bean);
+  }
+
+  @Post('/save')
+  async save(@Body(ALL) bean: PipelineEntity) {
+    bean.userId = this.ctx.user.id;
+    if (bean.id > 0) {
+      await this.service.checkUserId(bean.id, this.ctx.user.id);
+    }
+    await this.service.save(bean);
+    return this.ok(bean.id);
+  }
+
+  @Post('/delete')
+  async delete(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    return super.delete(id);
+  }
+
+  @Post('/detail')
+  async detail(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    const detail = await this.service.detail(id);
+    return this.ok(detail);
+  }
+
+  @Post('/trigger')
+  async trigger(@Query('id') id) {
+    await this.service.checkUserId(id, this.ctx.user.id);
+    await this.service.trigger(id);
+    return this.ok({});
+  }
+}

packages/ui/certd-server/src/modules/pipeline/controller/plugin-controller.ts

@@ -0,0 +1,27 @@
+import {
+  ALL,
+  Controller,
+  Inject,
+  Post,
+  Provide,
+  Query,
+} from '@midwayjs/decorator';
+import { BaseController } from '../../../basic/base-controller';
+import { PluginService } from '../service/plugin-service';
+
+/**
+ * 插件
+ */
+@Provide()
+@Controller('/api/pi/plugin')
+export class PluginController extends BaseController {
+  @Inject()
+  service: PluginService;
+
+  @Post('/list')
+  async list(@Query(ALL) query) {
+    query.userId = this.ctx.user.id;
+    const list = this.service.getList();
+    return this.ok(list);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/entity/access.ts

@@ -0,0 +1,33 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+/**
+ * 授权配置
+ */
+@Entity('cd_access')
+export class AccessEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+  @Column({ name: 'user_id', comment: '用户id' })
+  userId: number;
+  @Column({ comment: '名称', length: 100 })
+  name: string;
+
+  @Column({ comment: '类型', length: 100 })
+  type: string;
+
+  @Column({ name: 'setting', comment: '设置', length: 1024, nullable: true })
+  setting: string;
+
+  @Column({
+    name: 'create_time',
+    comment: '创建时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createTime: Date;
+  @Column({
+    name: 'update_time',
+    comment: '修改时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  updateTime: Date;
+}

packages/ui/certd-server/src/modules/pipeline/entity/history-log.ts

@@ -0,0 +1,41 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('pi_history_log')
+export class HistoryLogEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'user_id', comment: '用户id' })
+  userId: number;
+
+  @Column({ name: 'pipeline_id', comment: '流水线' })
+  pipelineId: number;
+
+  @Column({ name: 'history_id', comment: '历史id' })
+  historyId: number;
+
+  @Column({
+    name: 'node_id',
+    comment: '任务节点id',
+    length: 100,
+    nullable: true,
+  })
+  nodeId: string;
+
+  @Column({ comment: '日志内容', length: 40960, nullable: true })
+  logs: string;
+
+  @Column({
+    name: 'create_time',
+    comment: '创建时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createTime: Date;
+
+  @Column({
+    name: 'update_time',
+    comment: '修改时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  updateTime: Date;
+}

packages/ui/certd-server/src/modules/pipeline/entity/history.ts

@@ -0,0 +1,38 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('pi_history')
+export class HistoryEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'user_id', comment: '用户id' })
+  userId: number;
+
+  @Column({ name: 'pipeline_id', comment: '流水线' })
+  pipelineId: number;
+  @Column({ comment: '运行状态', length: 40960, nullable: true })
+  pipeline: string;
+
+  @Column({ comment: '结果状态', length: 20, nullable: true })
+  status: string;
+
+  @Column({
+    name: 'end_time',
+    comment: '结束时间',
+    nullable: true,
+  })
+  endTime: Date;
+
+  @Column({
+    name: 'create_time',
+    comment: '创建时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createTime: Date;
+  @Column({
+    name: 'update_time',
+    comment: '修改时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  updateTime: Date;
+}

packages/ui/certd-server/src/modules/pipeline/entity/pipeline.ts

@@ -0,0 +1,52 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('pi_pipeline')
+export class PipelineEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'user_id', comment: '用户id' })
+  userId: number;
+
+  @Column({ name: 'title', comment: '标题' })
+  title: number;
+
+  @Column({ comment: '配置', length: 40960 })
+  content: string;
+
+  @Column({
+    name: 'keep_history_count',
+    comment: '历史记录保持数量',
+    nullable: true,
+  })
+  keepHistoryCount: number;
+
+  @Column({ comment: '备注', length: 100, nullable: true })
+  remark: string;
+
+  @Column({ comment: '状态', length: 100, nullable: true })
+  status: string;
+
+  @Column({ comment: '启用/禁用', nullable: true, default: false })
+  disabled: boolean;
+
+  @Column({
+    name: 'last_history_time',
+    comment: '最后一次执行时间',
+    nullable: true,
+  })
+  lastHistoryTime: number;
+
+  @Column({
+    name: 'create_time',
+    comment: '创建时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createTime: Date;
+  @Column({
+    name: 'update_time',
+    comment: '修改时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  updateTime: Date;
+}

packages/ui/certd-server/src/modules/pipeline/entity/storage.ts

@@ -0,0 +1,35 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('pi_storage')
+export class StorageEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'user_id', comment: '用户id' })
+  userId: number;
+
+  @Column({ name: 'scope', comment: '范围' })
+  scope: string;
+
+  @Column({ name: 'namespace', comment: '命名空间' })
+  namespace: string;
+
+  @Column({ comment: 'key', length: 100, nullable: true })
+  key: string;
+
+  @Column({ comment: 'value', length: 40960, nullable: true })
+  value: string;
+
+  @Column({
+    name: 'create_time',
+    comment: '创建时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  createTime: Date;
+  @Column({
+    name: 'update_time',
+    comment: '修改时间',
+    default: () => 'CURRENT_TIMESTAMP',
+  })
+  updateTime: Date;
+}

packages/ui/certd-server/src/modules/pipeline/entity/vo/history-detail.ts

@@ -0,0 +1,12 @@
+import { HistoryEntity } from '../history';
+import { HistoryLogEntity } from '../history-log';
+
+export class HistoryDetail {
+  history: HistoryEntity;
+  log: HistoryLogEntity;
+
+  constructor(history: HistoryEntity, log: HistoryLogEntity) {
+    this.history = history;
+    this.log = log;
+  }
+}

packages/ui/certd-server/src/modules/pipeline/entity/vo/pipeline-detail.ts

@@ -0,0 +1,13 @@
+import { PipelineEntity } from '../pipeline';
+import { HistoryEntity } from '../history';
+import { HistoryLogEntity } from '../history-log';
+
+export class PipelineDetail {
+  pipeline: PipelineEntity;
+  constructor(pipeline: PipelineEntity) {
+    this.pipeline = pipeline;
+  }
+
+  last: HistoryEntity;
+  logs: HistoryLogEntity[];
+}

packages/ui/certd-server/src/modules/pipeline/service/access-service.ts

@@ -0,0 +1,44 @@
+import { Provide, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseService } from '../../../basic/base-service';
+import { AccessEntity } from '../entity/access';
+import {
+  accessRegistry,
+  IAccessService,
+} from '@certd/pipeline';
+
+/**
+ * 授权
+ */
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class AccessService
+  extends BaseService<AccessEntity>
+  implements IAccessService
+{
+  @InjectEntityModel(AccessEntity)
+  repository: Repository<AccessEntity>;
+
+  getRepository() {
+    return this.repository;
+  }
+
+  async getById(id: any): Promise<any> {
+    const entity = await this.info(id);
+    // const access = accessRegistry.get(entity.type);
+    const setting = JSON.parse(entity.setting);
+    return {
+      id: entity.id,
+      ...setting,
+    };
+  }
+
+  getDefineList() {
+    return accessRegistry.getDefineList();
+  }
+
+  getDefineByType(type) {
+    return accessRegistry.getDefine(type);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/db-storage.ts

@@ -0,0 +1,47 @@
+import { IStorage } from '@certd/pipeline/src/core/storage';
+import { StorageService } from './storage-service';
+
+export class DbStorage implements IStorage {
+  /**
+   * 范围： user / pipeline / runtime / task
+   */
+  storageService: StorageService;
+  userId: number;
+  constructor(userId: number, storageService: StorageService) {
+    this.userId = userId;
+    this.storageService = storageService;
+  }
+
+  async get(
+    scope: string,
+    namespace: string,
+    key: string
+  ): Promise<string | null> {
+    const storageEntity = await this.storageService.get({
+      userId: this.userId,
+      scope: scope,
+      namespace: namespace,
+      key,
+    });
+
+    if (storageEntity != null) {
+      return storageEntity.value;
+    }
+    return null;
+  }
+
+  async set(
+    scope: string,
+    namespace: string,
+    key: string,
+    value: string
+  ): Promise<void> {
+    await this.storageService.set({
+      userId: this.userId,
+      scope: scope,
+      namespace: namespace,
+      key,
+      value,
+    });
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/dns-provider-service.ts

@@ -0,0 +1,9 @@
+import { Provide, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { dnsProviderRegistry } from '@certd/plugin-cert';
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class DnsProviderService {
+  getList() {
+    return dnsProviderRegistry.getDefineList();
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/history-log-service.ts

@@ -0,0 +1,27 @@
+import { Provide, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseService } from '../../../basic/base-service';
+import { HistoryLogEntity } from '../entity/history-log';
+
+/**
+ * 证书申请
+ */
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class HistoryLogService extends BaseService<HistoryLogEntity> {
+  @InjectEntityModel(HistoryLogEntity)
+  repository: Repository<HistoryLogEntity>;
+
+  getRepository() {
+    return this.repository;
+  }
+
+  async save(bean: HistoryLogEntity) {
+    if (bean.id > 0) {
+      await this.update(bean);
+    } else {
+      await this.add(bean);
+    }
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/history-service.ts

@@ -0,0 +1,81 @@
+import { Inject, Provide, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseService } from '../../../basic/base-service';
+import { HistoryEntity } from '../entity/history';
+import { PipelineEntity } from '../entity/pipeline';
+import { HistoryDetail } from '../entity/vo/history-detail';
+import { HistoryLogService } from './history-log-service';
+
+/**
+ * 证书申请
+ */
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class HistoryService extends BaseService<HistoryEntity> {
+  @InjectEntityModel(HistoryEntity)
+  repository: Repository<HistoryEntity>;
+  @Inject()
+  logService: HistoryLogService;
+  getRepository() {
+    return this.repository;
+  }
+
+  async save(bean: HistoryEntity) {
+    if (bean.id > 0) {
+      await this.update(bean);
+    } else {
+      await this.add(bean);
+    }
+  }
+
+  async detail(historyId: string) {
+    const entity = await this.info(historyId);
+    const log = await this.logService.info(historyId);
+    return new HistoryDetail(entity, log);
+  }
+
+  async start(pipeline: PipelineEntity) {
+    const bean = {
+      userId: pipeline.userId,
+      pipelineId: pipeline.id,
+      title: pipeline.title,
+      status: 'start',
+    };
+    const { id } = await this.add(bean);
+    //清除大于pipeline.keepHistoryCount的历史记录
+    this.clear(pipeline.id, pipeline.keepHistoryCount);
+    return id;
+  }
+
+  private async clear(pipelineId: number, keepCount = 30) {
+    const count = await this.repository.count({
+      where: {
+        pipelineId,
+      },
+    });
+    if (count <= keepCount) {
+      return;
+    }
+    let shouldDeleteCount = count - keepCount;
+    const deleteCountBatch = 100;
+    while (shouldDeleteCount > 0) {
+      const list = await this.repository.find({
+        select: {
+          id: true,
+        },
+        where: {
+          pipelineId,
+        },
+        order: {
+          id: 'ASC',
+        },
+        skip: 0,
+        take: deleteCountBatch,
+      });
+      await this.repository.remove(list);
+
+      shouldDeleteCount -= deleteCountBatch;
+    }
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/pipeline-service.ts

@@ -0,0 +1,241 @@
+import { Inject, Provide, Scope, ScopeEnum } from '@midwayjs/decorator';
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import { In, Repository } from 'typeorm';
+import { BaseService } from '../../../basic/base-service';
+import { PipelineEntity } from '../entity/pipeline';
+import { PipelineDetail } from '../entity/vo/pipeline-detail';
+import { Executor, Pipeline, RunHistory } from '@certd/pipeline';
+import { AccessService } from './access-service';
+import { DbStorage } from './db-storage';
+import { StorageService } from './storage-service';
+import { Cron } from '../../../plugins/cron/cron';
+import { HistoryService } from './history-service';
+import { HistoryEntity } from '../entity/history';
+import { HistoryLogEntity } from '../entity/history-log';
+import { HistoryLogService } from './history-log-service';
+import { logger } from '../../../utils/logger';
+
+/**
+ * 证书申请
+ */
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class PipelineService extends BaseService<PipelineEntity> {
+  @InjectEntityModel(PipelineEntity)
+  repository: Repository<PipelineEntity>;
+
+  @Inject()
+  accessService: AccessService;
+  @Inject()
+  storageService: StorageService;
+  @Inject()
+  historyService: HistoryService;
+  @Inject()
+  historyLogService: HistoryLogService;
+
+  @Inject()
+  cron: Cron;
+
+  getRepository() {
+    return this.repository;
+  }
+
+  async update(entity) {
+    await super.update(entity);
+
+    await this.registerTriggerById(entity.id);
+  }
+
+  private async registerTriggerById(pipelineId) {
+    if (pipelineId == null) {
+      return;
+    }
+    const info = await this.info(pipelineId);
+    if (info && !info.disabled) {
+      const pipeline = JSON.parse(info.content);
+      this.registerTriggers(pipeline);
+    }
+  }
+
+  /**
+   * 获取详情
+   * @param id
+   */
+  async detail(id) {
+    const pipeline = await this.info(id);
+    return new PipelineDetail(pipeline);
+  }
+
+  async save(bean: PipelineEntity) {
+    const pipeline = JSON.parse(bean.content);
+    bean.title = pipeline.title;
+    await this.addOrUpdate(bean);
+    await this.registerTriggerById(bean.id);
+  }
+
+  /**
+   * 应用启动后初始加载记录
+   */
+  async onStartup() {
+    const idEntityList = await this.repository.find({
+      select: {
+        id: true,
+      },
+      where: {
+        disabled: false,
+      },
+    });
+    const ids = idEntityList.map(item => {
+      return item.id;
+    });
+
+    //id 分段
+    const idsSpan = [];
+    let arr = [];
+    for (let i = 0; i < ids.length; i++) {
+      if (i % 20 === 0) {
+        arr = [];
+        idsSpan.push(arr);
+      }
+      arr.push(ids[i]);
+    }
+
+    //分段加载记录
+    for (const idArr of idsSpan) {
+      const list = await this.repository.findBy({
+        id: In(idArr),
+      });
+
+      for (const entity of list) {
+        const pipeline = JSON.parse(entity.content ?? '{}');
+        this.registerTriggers(pipeline);
+      }
+    }
+    logger.info('定时器数量：', this.cron.getList());
+  }
+
+  registerTriggers(pipeline?: Pipeline) {
+    if (pipeline?.triggers == null) {
+      return;
+    }
+    for (const trigger of pipeline.triggers) {
+      this.registerCron(pipeline.id, trigger);
+    }
+  }
+
+  async trigger(id) {
+    this.cron.register({
+      name: `pipeline.${id}.trigger.once`,
+      cron: null,
+      job: async () => {
+        await this.run(id, null);
+      },
+    });
+    logger.info('定时器数量：', this.cron.getList());
+  }
+
+  registerCron(pipelineId, trigger) {
+    let cron = trigger.props?.cron;
+    if (cron == null) {
+      return;
+    }
+    if(cron.startsWith("*")){
+      cron = "0"+ cron.substring(1,cron.length)
+      return
+    }
+    this.cron.register({
+      name: this.buildCronKey(pipelineId, trigger.id),
+      cron: cron,
+      job: async () => {
+        logger.info('定时任务触发：', pipelineId, trigger.id);
+        await this.run(pipelineId, trigger.id);
+      },
+    });
+  }
+
+  async run(id, triggerId) {
+    const entity: PipelineEntity = await this.info(id);
+    const pipeline = JSON.parse(entity.content);
+
+    if (!pipeline.stages || pipeline.stages.length === 0) {
+      return;
+    }
+
+    const triggerType = this.getTriggerType(triggerId, pipeline);
+    if (triggerType == null) {
+      return;
+    }
+
+    const onChanged = async (history: RunHistory) => {
+      //保存执行历史
+      await this.saveHistory(history);
+    };
+
+    const userId = entity.userId;
+    const historyId = await this.historyService.start(entity);
+
+    const executor = new Executor({
+      userId,
+      pipeline,
+      onChanged,
+      accessService: this.accessService,
+      storage: new DbStorage(userId, this.storageService),
+    });
+
+    await executor.run(historyId, triggerType);
+  }
+
+  private getTriggerType(triggerId, pipeline) {
+    let triggerType = 'user';
+    if (triggerId != null) {
+      //如果不是手动触发
+      //查找trigger
+      const found = this.findTrigger(pipeline, triggerId);
+      if (!found) {
+        //如果没有找到triggerId，说明被用户删掉了，这里再删除一次
+        this.cron.remove(this.buildCronKey(pipeline.id, triggerId));
+        triggerType = null;
+      } else {
+        logger.info('timer trigger:' + found.id, found.title, found.cron);
+        triggerType = 'timer';
+      }
+    }
+    return triggerType;
+  }
+
+  private buildCronKey(pipelineId, triggerId) {
+    return `pipeline.${pipelineId}.trigger.${triggerId}`;
+  }
+
+  private findTrigger(pipeline, triggerId) {
+    for (const trigger of pipeline.triggers) {
+      if (trigger.id === triggerId) {
+        return trigger;
+      }
+    }
+    return;
+  }
+
+  private async saveHistory(history: RunHistory) {
+    //修改pipeline状态
+    const pipelineEntity = new PipelineEntity();
+    pipelineEntity.id = parseInt(history.pipeline.id);
+    pipelineEntity.status = history.pipeline.status.status;
+    pipelineEntity.lastHistoryTime = history.pipeline.status.startTime;
+    await this.update(pipelineEntity);
+
+    const entity: HistoryEntity = new HistoryEntity();
+    entity.id = parseInt(history.id);
+    entity.userId = history.pipeline.userId;
+    entity.pipeline = JSON.stringify(history.pipeline);
+    await this.historyService.save(entity);
+
+    const logEntity: HistoryLogEntity = new HistoryLogEntity();
+    logEntity.id = entity.id;
+    logEntity.userId = entity.userId;
+    logEntity.pipelineId = entity.pipelineId;
+    logEntity.historyId = entity.id;
+    logEntity.logs = JSON.stringify(history.logs);
+    await this.historyLogService.addOrUpdate(logEntity);
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/plugin-service.ts

@@ -0,0 +1,15 @@
+import { Provide, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { pluginRegistry } from '@certd/pipeline';
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class PluginService {
+  getList() {
+    const collection = pluginRegistry.storage;
+    const list = [];
+    for (const key in collection) {
+      const Plugin = collection[key];
+      list.push({ ...Plugin.define, key });
+    }
+    return list;
+  }
+}

packages/ui/certd-server/src/modules/pipeline/service/storage-service.ts

@@ -0,0 +1,56 @@
+import { Provide, Scope, ScopeEnum } from "@midwayjs/decorator";
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseService } from '../../../basic/base-service';
+import { StorageEntity } from '../entity/storage';
+
+/**
+ */
+@Provide()
+@Scope(ScopeEnum.Singleton)
+export class StorageService extends BaseService<StorageEntity> {
+  @InjectEntityModel(StorageEntity)
+  repository: Repository<StorageEntity>;
+
+  getRepository() {
+    return this.repository;
+  }
+
+  async get(where: {
+    scope: any;
+    namespace: any;
+    userId: number;
+    key: string;
+  }) {
+    if (where.userId == null) {
+      throw new Error('userId 不能为空');
+    }
+    return await this.repository.findOne({
+      where,
+    });
+  }
+
+  async set(entity: {
+    id?: any;
+    scope: any;
+    namespace: any;
+    userId: number;
+    value: string;
+    key: string;
+  }) {
+    entity.id = null;
+    const query = { ...entity };
+    delete query.value;
+    const ret = await this.get(query);
+    if (ret != null) {
+      entity.id = ret.id;
+      if (ret.userId !== entity.userId) {
+        throw new Error('您没有权限修改此数据');
+      }
+      await this.repository.save(entity);
+    } else {
+      await this.repository.insert(entity);
+    }
+    return;
+  }
+}