n8n/packages/cli/commands/execute.ts

173 lines
4.8 KiB
TypeScript
Raw Normal View History

2019-06-23 03:35:23 -07:00
import { promises as fs } from 'fs';
2019-08-28 06:28:47 -07:00
import { Command, flags } from '@oclif/command';
import {
UserSettings,
} from "n8n-core";
2019-06-23 03:35:23 -07:00
import {
ActiveExecutions,
2019-06-23 03:35:23 -07:00
Db,
GenericHelpers,
2019-06-23 03:35:23 -07:00
IWorkflowBase,
IWorkflowExecutionDataProcess,
2019-06-23 03:35:23 -07:00
LoadNodesAndCredentials,
NodeTypes,
WorkflowCredentials,
2019-06-23 03:35:23 -07:00
WorkflowHelpers,
WorkflowRunner,
2019-06-23 03:35:23 -07:00
} from "../src";
2019-08-28 06:28:47 -07:00
export class Execute extends Command {
static description = '\nExecutes a given workflow';
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
static examples = [
`$ n8n execute --id=5`,
`$ n8n execute --file=workflow.json`,
];
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
static flags = {
help: flags.help({ char: 'h' }),
file: flags.string({
description: 'path to a workflow file to execute',
}),
id: flags.string({
description: 'id of the workflow to execute',
}),
};
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
async run() {
const { flags } = this.parse(Execute);
// Start directly with the init of the database to improve startup time
const startDbInitPromise = Db.init();
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
// Load all node and credential types
const loadNodesAndCredentials = LoadNodesAndCredentials();
const loadNodesAndCredentialsPromise = loadNodesAndCredentials.init();
if (!flags.id && !flags.file) {
GenericHelpers.logOutput(`Either option "--id" or "--file" have to be set!`);
return;
}
if (flags.id && flags.file) {
GenericHelpers.logOutput(`Either "id" or "file" can be set never both!`);
return;
}
let workflowId: string | undefined;
let workflowData: IWorkflowBase | undefined = undefined;
if (flags.file) {
// Path to workflow is given
try {
workflowData = JSON.parse(await fs.readFile(flags.file, 'utf8'));
} catch (error) {
if (error.code === 'ENOENT') {
GenericHelpers.logOutput(`The file "${flags.file}" could not be found.`);
2019-06-23 03:35:23 -07:00
return;
}
2019-08-28 06:28:47 -07:00
throw error;
2019-06-23 03:35:23 -07:00
}
2019-08-28 06:28:47 -07:00
// Do a basic check if the data in the file looks right
// TODO: Later check with the help of TypeScript data if it is valid or not
if (workflowData === undefined || workflowData.nodes === undefined || workflowData.connections === undefined) {
GenericHelpers.logOutput(`The file "${flags.file}" does not contain valid workflow data.`);
return;
}
workflowId = workflowData.id!.toString();
}
// Wait till the database is ready
await startDbInitPromise;
if (flags.id) {
// Id of workflow is given
workflowId = flags.id;
workflowData = await Db.collections!.Workflow!.findOne(workflowId);
if (workflowData === undefined) {
GenericHelpers.logOutput(`The workflow with the id "${workflowId}" does not exist.`);
return;
}
}
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
// Make sure the settings exist
await UserSettings.prepareUserSettings();
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
// Wait till the n8n-packages have been read
await loadNodesAndCredentialsPromise;
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
// Add the found types to an instance other parts of the application can use
const nodeTypes = NodeTypes();
await nodeTypes.init(loadNodesAndCredentials.nodeTypes);
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
if (!WorkflowHelpers.isWorkflowIdValid(workflowId)) {
workflowId = undefined;
}
// Check if the workflow contains the required "Start" node
// "requiredNodeTypes" are also defined in editor-ui/views/NodeView.vue
const requiredNodeTypes = ['n8n-nodes-base.start'];
let startNodeFound = false;
for (const node of workflowData!.nodes) {
if (requiredNodeTypes.includes(node.type)) {
startNodeFound = true;
2019-06-23 03:35:23 -07:00
}
2019-08-28 06:28:47 -07:00
}
if (startNodeFound === false) {
// If the workflow does not contain a start-node we can not know what
// should be executed and with which data to start.
GenericHelpers.logOutput(`The workflow does not contain a "Start" node. So it can not be executed.`);
return Promise.resolve();
}
2019-06-23 03:35:23 -07:00
2019-08-28 06:28:47 -07:00
try {
const credentials = await WorkflowCredentials(workflowData!.nodes);
const runData: IWorkflowExecutionDataProcess = {
credentials,
executionMode: 'cli',
workflowData: workflowData!,
};
const workflowRunner = new WorkflowRunner();
const executionId = await workflowRunner.run(runData);
const activeExecutions = ActiveExecutions.getInstance();
const data = await activeExecutions.getPostExecutePromise(executionId);
if (data === undefined) {
throw new Error('Workflow did not return any data!');
2019-06-23 03:35:23 -07:00
}
2019-08-28 06:28:47 -07:00
if (data.data.resultData.error) {
this.log('Execution was NOT successfull:');
this.log('====================================');
this.log(JSON.stringify(data, null, 2));
// console.log(data.data.resultData.error);
const error = new Error(data.data.resultData.error.message);
error.stack = data.data.resultData.error.stack;
throw error;
2019-06-23 03:35:23 -07:00
}
2019-08-28 06:28:47 -07:00
this.log('Execution was successfull:');
this.log('====================================');
this.log(JSON.stringify(data, null, 2));
} catch (e) {
console.error('\nGOT ERROR');
console.log('====================================');
console.error(e.message);
console.error(e.stack);
this.exit(1);
return;
}
this.exit();
}
}