gauge-ts
Version:
Typescript runner for Gauge
299 lines (298 loc) • 12.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.stop = exports.start = void 0;
const node_os_1 = require("node:os");
const node_path_1 = require("node:path");
const grpc_js_1 = require("@grpc/grpc-js");
const services_grpc_pb_1 = require("./gen/services_grpc_pb");
const constants_1 = require("@grpc/grpc-js/build/src/constants");
const _1 = require(".");
const messages_pb_1 = require("./gen/messages_pb");
const spec_pb_1 = require("./gen/spec_pb");
const ImplLoader_1 = require("./loaders/ImplLoader");
const StaticLoader_1 = require("./loaders/StaticLoader");
const StepRegistry_1 = require("./models/StepRegistry");
const CacheFileProcessor_1 = require("./processors/CacheFileProcessor");
const ExecutionEndingProcessor_1 = require("./processors/ExecutionEndingProcessor");
const ExecutionStartingProcessor_1 = require("./processors/ExecutionStartingProcessor");
const RefactorProcessor_1 = require("./processors/RefactorProcessor");
const ScenarioExecutionEndingProcessor_1 = require("./processors/ScenarioExecutionEndingProcessor");
const ScenarioExecutionStartingProcessor_1 = require("./processors/ScenarioExecutionStartingProcessor");
const SpecExecutionEndingProcessor_1 = require("./processors/SpecExecutionEndingProcessor");
const SpecExecutionStartingProcessor_1 = require("./processors/SpecExecutionStartingProcessor");
const StepExecutionEndingProcessor_1 = require("./processors/StepExecutionEndingProcessor");
const StepExecutionProcessor_1 = require("./processors/StepExecutionProcessor");
const StepExecutionStartingProcessor_1 = require("./processors/StepExecutionStartingProcessor");
const StepNameProcessor_1 = require("./processors/StepNameProcessor");
const StepPositionsProcessor_1 = require("./processors/StepPositionsProcessor");
const StubImplementationCodeProcessor_1 = require("./processors/StubImplementationCodeProcessor");
const ValidationProcessor_1 = require("./processors/ValidationProcessor");
const ParameterParsingChain_1 = require("./processors/params/ParameterParsingChain");
const Util_1 = require("./utils/Util");
class RunnerServer {
static cacheFileProcessor;
static executionEndingProcessor;
static executionStartingProcessor;
static refactorProcessor;
static scenarioExecutionEndingProcessor;
static scenarioExecutionStartingProcessor;
static specExecutionEndingProcessor;
static specExecutionStartingProcessor;
static stepExecutionEndingProcessor;
static stepExecutionProcessor;
static stepExecutionStartingProcessor;
static stepNameProcessor;
static stepPositionsProcessor;
static stubImplementationCodeProcessor;
static validationProcessor;
static parameterParsingChain;
constructor(loader) {
RunnerServer.parameterParsingChain = new ParameterParsingChain_1.ParameterParsingChain();
loader.loadImplementations();
RunnerServer.cacheFileProcessor = new CacheFileProcessor_1.CacheFileProcessor(loader);
RunnerServer.executionEndingProcessor = new ExecutionEndingProcessor_1.ExecutionEndingProcessor();
RunnerServer.executionStartingProcessor = new ExecutionStartingProcessor_1.ExecutionStartingProcessor();
RunnerServer.refactorProcessor = new RefactorProcessor_1.RefactorProcessor();
RunnerServer.scenarioExecutionEndingProcessor =
new ScenarioExecutionEndingProcessor_1.ScenarioExecutionEndingProcessor();
RunnerServer.scenarioExecutionStartingProcessor =
new ScenarioExecutionStartingProcessor_1.ScenarioExecutionStartingProcessor();
RunnerServer.specExecutionEndingProcessor =
new SpecExecutionEndingProcessor_1.SpecExecutionEndingProcessor();
RunnerServer.specExecutionStartingProcessor =
new SpecExecutionStartingProcessor_1.SpecExecutionStartingProcessor();
RunnerServer.stepExecutionEndingProcessor =
new StepExecutionEndingProcessor_1.StepExecutionEndingProcessor();
RunnerServer.stepExecutionProcessor = new StepExecutionProcessor_1.StepExecutionProcessor(RunnerServer.parameterParsingChain);
RunnerServer.stepExecutionStartingProcessor =
new StepExecutionStartingProcessor_1.StepExecutionStartingProcessor();
RunnerServer.stepNameProcessor = new StepNameProcessor_1.StepNameProcessor();
RunnerServer.stepPositionsProcessor = new StepPositionsProcessor_1.StepPositionsProcessor();
RunnerServer.stubImplementationCodeProcessor =
new StubImplementationCodeProcessor_1.StubImplementationCodeProcessor();
RunnerServer.validationProcessor = new ValidationProcessor_1.ValidationProcessor();
}
validateStep(call, callback) {
try {
callback(null, RunnerServer.validationProcessor.process(call.request));
}
catch (error) {
callback(createRpcError(error), null);
}
}
initializeSuiteDataStore(_call, callback) {
try {
_1.DataStoreFactory.getSuiteDataStore().clear();
const loader = new ImplLoader_1.ImplLoader(RunnerServer.parameterParsingChain);
loader
.loadImplementations()
.then(() => callback(null, this.getEmptExecutionResponse()))
.catch((err) => {
callback(createRpcError(err), null);
});
}
catch (error) {
callback(createRpcError(error), null);
}
}
startExecution(call, callback) {
RunnerServer.executionStartingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
initializeSpecDataStore(call, callback) {
try {
_1.DataStoreFactory.getSpecDataStore().clear();
callback(null, this.getEmptExecutionResponse());
}
catch (error) {
callback(createRpcError(error), null);
}
}
startSpecExecution(call, callback) {
RunnerServer.specExecutionStartingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
initializeScenarioDataStore(call, callback) {
try {
_1.DataStoreFactory.getScenarioDataStore().clear();
callback(null, this.getEmptExecutionResponse());
}
catch (error) {
callback(createRpcError(error), null);
}
}
startScenarioExecution(call, callback) {
RunnerServer.scenarioExecutionStartingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
startStepExecution(call, callback) {
RunnerServer.stepExecutionStartingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
executeStep(call, callback) {
RunnerServer.stepExecutionProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
finishStepExecution(call, callback) {
RunnerServer.stepExecutionEndingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
finishScenarioExecution(call, callback) {
RunnerServer.scenarioExecutionEndingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
finishSpecExecution(call, callback) {
RunnerServer.specExecutionEndingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
finishExecution(call, callback) {
RunnerServer.executionEndingProcessor
.process(call.request)
.then((res) => callback(null, res))
.catch((error) => callback(createRpcError(error), null));
}
cacheFile(call, callback) {
try {
RunnerServer.cacheFileProcessor.process(call.request);
callback(null, new messages_pb_1.Empty());
}
catch (error) {
callback(createRpcError(error), null);
}
}
getStepName(call, callback) {
try {
callback(null, RunnerServer.stepNameProcessor.process(call.request));
}
catch (error) {
callback(createRpcError(error), null);
}
}
getGlobPatterns(call, callback) {
try {
const patterns = Util_1.Util.getImplDirs().map((dir) => {
return dir.split(node_path_1.sep).concat(["**", "*.ts"]).join("/");
});
const res = new messages_pb_1.ImplementationFileGlobPatternResponse();
res.setGlobpatternsList(patterns);
callback(null, res);
}
catch (error) {
callback(createRpcError(error), null);
}
}
getStepNames(call, callback) {
try {
const res = new messages_pb_1.StepNamesResponse();
res.setStepsList(StepRegistry_1.default.getStepTexts());
callback(null, res);
}
catch (error) {
callback(createRpcError(error), null);
}
}
getStepPositions(call, callback) {
try {
callback(null, RunnerServer.stepPositionsProcessor.process(call.request));
}
catch (error) {
callback(createRpcError(error), null);
}
}
getImplementationFiles(call, callback) {
try {
const res = new messages_pb_1.ImplementationFileListResponse();
res.setImplementationfilepathsList(Util_1.Util.getListOfFiles());
callback(null, res);
}
catch (error) {
callback(createRpcError(error), null);
}
}
implementStub(call, callback) {
try {
callback(null, RunnerServer.stubImplementationCodeProcessor.process(call.request));
}
catch (error) {
callback(createRpcError(error), null);
}
}
refactor(call, callback) {
try {
callback(null, RunnerServer.refactorProcessor.process(call.request));
}
catch (error) {
callback(createRpcError(error), null);
}
}
kill(_call, callback) {
callback(null, new messages_pb_1.Empty());
setTimeout(() => {
(0, exports.stop)();
process.exit(0);
}, 100);
}
getEmptExecutionResponse() {
const res = new messages_pb_1.ExecutionStatusResponse();
const result = new spec_pb_1.ProtoExecutionResult();
result.setFailed(false);
res.setExecutionresult(result);
return res;
// eslint-disable-next-line padded-blocks
}
}
exports.default = RunnerServer;
function createRpcError(error) {
return {
code: constants_1.Status.INTERNAL,
message: error.message,
stack: error.stack ?? "",
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
details: `${error.message}${node_os_1.EOL}${error.stack ?? ""}`,
};
}
let serverInstance = null;
const start = (host = "127.0.0.1:0", server = new grpc_js_1.Server(), runnerService = new RunnerServer(new StaticLoader_1.default())) => {
serverInstance = server;
server.addService(services_grpc_pb_1.RunnerService, runnerService);
let port = null;
server.bindAsync(host, grpc_js_1.ServerCredentials.createInsecure(), (err, boundPort) => {
if (err) {
throw err;
}
port = boundPort;
console.debug(`Listening on port:${port}`);
});
};
exports.start = start;
const stop = (server = serverInstance) => {
if (!serverInstance) {
console.debug("Server is not running.");
return;
}
server?.tryShutdown((err) => {
if (err) {
console.error("Error shutting down the server:", err);
}
else {
serverInstance = null;
}
});
};
exports.stop = stop;