mirror of
https://github.com/dadosfera/maestro.git
synced 2026-11-16 16:49:08 +00:00
280 lines
7.2 KiB
TypeScript
280 lines
7.2 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
Inject,
|
|
InternalServerErrorException,
|
|
OnModuleInit,
|
|
} from '@nestjs/common';
|
|
import { ClientGrpc, Payload } from '@nestjs/microservices';
|
|
import {
|
|
PipelineServicesNames,
|
|
PipelinesServiceInterface,
|
|
} from '@victorradael/protospack';
|
|
import { lastValueFrom } from 'rxjs';
|
|
import {
|
|
objectCamelToSnake,
|
|
objectSnakeToCamel,
|
|
} from 'src/utils/CaseConverter';
|
|
import {
|
|
ICreatePipelineDto,
|
|
IGetPipelineLogsRequest,
|
|
IIdRequest,
|
|
IUpdatePipelineRequest,
|
|
} from './interfaces';
|
|
import { DadosferaLogger } from 'dadosfera-logs';
|
|
|
|
export class PipelinesClientService implements OnModuleInit {
|
|
private pipelineService: PipelinesServiceInterface;
|
|
logger: any;
|
|
constructor(
|
|
@Inject(DadosferaLogger)
|
|
dadosferaLogger: DadosferaLogger,
|
|
@Inject('PIPELINES_PACKAGE') private readonly grpcClient: ClientGrpc,
|
|
) {
|
|
this.logger = dadosferaLogger.logger;
|
|
}
|
|
|
|
onModuleInit() {
|
|
this.pipelineService =
|
|
this.grpcClient.getService<PipelinesServiceInterface>(
|
|
PipelineServicesNames.PipelineService,
|
|
);
|
|
}
|
|
|
|
async create(@Payload() createPipelineDto: ICreatePipelineDto) {
|
|
this.logger.info('PipelinesClientService - Create');
|
|
const createPipelineResponse = await lastValueFrom(
|
|
this.pipelineService.Create(objectSnakeToCamel(createPipelineDto)),
|
|
)
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((error: { details: string }) => {
|
|
if (error.details.includes('INVALID_REQUEST')) {
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const [errorType, message] = error.details.split('|');
|
|
throw new BadRequestException(message);
|
|
}
|
|
throw new InternalServerErrorException(error.details);
|
|
});
|
|
|
|
return createPipelineResponse;
|
|
}
|
|
|
|
async findAll(data: IIdRequest) {
|
|
this.logger.info('PipelinesClientService - FindAll');
|
|
const findAllPipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService.FindAll(objectSnakeToCamel(data)).subscribe({
|
|
next(x) {
|
|
resolve(x.pipelines);
|
|
},
|
|
error(err) {
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
// console.log('done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return findAllPipelineResponse;
|
|
}
|
|
|
|
async findOne(data: IIdRequest) {
|
|
this.logger.info('PipelinesClientService - FindOne');
|
|
|
|
const findOnePipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService.FindOne(objectSnakeToCamel(data)).subscribe({
|
|
next(x) {
|
|
resolve(x);
|
|
},
|
|
error(err) {
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
// console.log('done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return findOnePipelineResponse;
|
|
}
|
|
|
|
async update(UpdatePipelineRequest: IUpdatePipelineRequest) {
|
|
this.logger.info('PipelinesClientService - Update');
|
|
|
|
const updatePipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService
|
|
.Update(objectSnakeToCamel(UpdatePipelineRequest))
|
|
.subscribe({
|
|
next(x) {
|
|
resolve(x);
|
|
},
|
|
error(err) {
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
//console.log('done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return updatePipelineResponse;
|
|
}
|
|
|
|
async remove(data: IIdRequest) {
|
|
this.logger.info('PipelinesClientService - Remove');
|
|
|
|
const removePipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService.remove(objectSnakeToCamel(data)).subscribe({
|
|
next(x) {
|
|
resolve(objectCamelToSnake(x));
|
|
},
|
|
error(err) {
|
|
this.logger.error('Observable Error');
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
this.logger.info('Done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return removePipelineResponse;
|
|
}
|
|
|
|
async getPipelineLogsMessages(data: IGetPipelineLogsRequest) {
|
|
this.logger.info('PipelinesClientService - GetPipelineLogsMessages');
|
|
|
|
const logsPipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService.getPipelineLogs(data).subscribe({
|
|
next(x) {
|
|
resolve(x);
|
|
},
|
|
error(err) {
|
|
this.logger.error('Observable Error');
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
this.logger.info('Done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return logsPipelineResponse;
|
|
}
|
|
|
|
async getPipelineStatus(data) {
|
|
this.logger.info('PipelinesClientService - GetPipelineStatus');
|
|
|
|
const statusPipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService
|
|
.getPipelineStatus(objectSnakeToCamel(data))
|
|
.subscribe({
|
|
next(x) {
|
|
const statusArray = x.status.sort((a, b) => {
|
|
if (a.id < b.id) {
|
|
return 1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
});
|
|
resolve({ status: statusArray });
|
|
},
|
|
error(err) {
|
|
this.logger.error('Observable Error');
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
this.logger.info('Done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return statusPipelineResponse;
|
|
}
|
|
|
|
async runPipeline({ id, info }: IIdRequest) {
|
|
this.logger.info('PipelinesClientService - RunPipeline');
|
|
const statusPipelineResponse = await new Promise((resolve, reject) => {
|
|
this.pipelineService
|
|
.triggerPipeline(objectSnakeToCamel({ id, info }))
|
|
.subscribe({
|
|
next(x) {
|
|
if (x.status == false) {
|
|
reject(
|
|
'This pipeline is not ready yet to execute, Try again later!',
|
|
);
|
|
}
|
|
resolve(x);
|
|
},
|
|
error(err) {
|
|
this.logger.error('Observable Error');
|
|
reject(err);
|
|
},
|
|
complete() {
|
|
this.logger.info('Done');
|
|
},
|
|
});
|
|
})
|
|
.then((res) => {
|
|
this.logger.info('Done');
|
|
return res;
|
|
})
|
|
.catch((err) => {
|
|
this.logger.error(err.message);
|
|
throw new Error(err);
|
|
});
|
|
|
|
return statusPipelineResponse;
|
|
}
|
|
}
|