n8n-nodes-proxmox
Version:
n8n community node for Proxmox Virtual Environment (VE) API integration with VM, container, storage, and cluster management capabilities
220 lines (219 loc) • 9.99 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProxMox = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const cluster_descriptions_1 = require("./descriptions/cluster.descriptions");
const vm_descriptions_1 = require("./descriptions/vm.descriptions");
const container_descriptions_1 = require("./descriptions/container.descriptions");
const storage_descriptions_1 = require("./descriptions/storage.descriptions");
const backup_descriptions_1 = require("./descriptions/backup.descriptions");
const cluster_methods_1 = require("./methods/cluster.methods");
const vm_methods_1 = require("./methods/vm.methods");
const container_methods_1 = require("./methods/container.methods");
const storage_methods_1 = require("./methods/storage.methods");
const backup_methods_1 = require("./methods/backup.methods");
const logger_1 = require("./helpers/logger");
class ProxMox {
constructor() {
this.description = {
displayName: 'ProxMox VE',
name: 'proxMox',
icon: 'file:ProxMox.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Interact with ProxMox Virtual Environment API for managing VMs, containers, storage, and cluster operations',
defaults: {
name: 'ProxMox VE',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'proxMoxApi',
required: true,
},
],
requestDefaults: {
baseURL: '={{$credentials.host}}:{{$credentials.port}}/api2/json',
headers: {
Accept: 'application/json',
'Content-Type': 'application/json',
},
},
usableAsTool: true,
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Cluster',
value: 'cluster',
description: 'Manage cluster operations',
},
{
name: 'Virtual Machine',
value: 'vm',
description: 'Manage virtual machines (QEMU/KVM)',
},
{
name: 'Container',
value: 'container',
description: 'Manage LXC containers',
},
{
name: 'Storage',
value: 'storage',
description: 'Manage storage and file operations',
},
{
name: 'Backup',
value: 'backup',
description: 'Manage backups and restore operations',
},
],
default: 'vm',
required: true,
},
// Cluster operations
cluster_descriptions_1.clusterOperations,
...cluster_descriptions_1.clusterFields,
// VM operations
vm_descriptions_1.vmOperations,
...vm_descriptions_1.vmFields,
// Container operations
container_descriptions_1.containerOperations,
...container_descriptions_1.containerFields,
// Storage operations
storage_descriptions_1.storageOperations,
...storage_descriptions_1.storageFields,
// Backup operations
backup_descriptions_1.backupOperations,
...backup_descriptions_1.backupFields,
// Continue on Fail
{
displayName: 'Continue on Fail',
name: 'continueOnFail',
type: 'boolean',
default: false,
description: 'Whether to continue the workflow if this node fails',
},
],
};
}
async execute() {
console.log('\n\n========== PROXMOX NODE EXECUTION STARTED ==========');
try {
const items = this.getInputData();
console.log('Input data retrieved:', { itemCount: items.length });
const returnData = [];
const length = items.length;
console.log('Attempting to get resource parameter...');
const resource = this.getNodeParameter('resource', 0);
console.log('Resource parameter retrieved:', resource);
console.log('Attempting to get operation parameter...');
const operation = this.getNodeParameter('operation', 0);
console.log('Operation parameter retrieved:', operation);
logger_1.logger.info('node', `ProxMox node execution started`, {
resource,
operation,
itemCount: length,
});
for (let i = 0; i < length; i++) {
console.log(`Processing item ${i + 1}/${length}`);
try {
let responseData;
console.log(`Executing ${resource} - ${operation} operation`);
switch (resource) {
case 'cluster':
console.log('Calling executeClusterOperation...');
responseData = await cluster_methods_1.executeClusterOperation.call(this, operation, i);
break;
case 'vm':
console.log('Calling executeVmOperation...');
responseData = await vm_methods_1.executeVmOperation.call(this, operation, i);
break;
case 'container':
console.log('Calling executeContainerOperation...');
responseData = await container_methods_1.executeContainerOperation.call(this, operation, i);
break;
case 'storage':
console.log('Calling executeStorageOperation...');
responseData = await storage_methods_1.executeStorageOperation.call(this, operation, i);
break;
case 'backup':
console.log('Calling executeBackupOperation...');
responseData = await backup_methods_1.executeBackupOperation.call(this, operation, i);
break;
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The resource "${resource}" is not known!`, { itemIndex: i });
}
console.log('Operation completed successfully, processing response...');
// Handle array responses
if (Array.isArray(responseData)) {
responseData.forEach((item) => {
returnData.push({
json: item,
pairedItem: { item: i },
});
});
}
else {
returnData.push({
json: responseData,
pairedItem: { item: i },
});
}
}
catch (error) {
console.log('=== ERROR CAUGHT IN ITEM PROCESSING ===');
console.log('Error object:', error);
console.log('Error message:', error.message);
console.log('Error stack:', error.stack);
console.log('Error type:', typeof error);
console.log('Error constructor:', error.constructor.name);
logger_1.logger.error('node', `ProxMox node execution failed`, {
resource,
operation,
itemIndex: i,
error: error.message,
});
if (this.continueOnFail()) {
returnData.push({
json: {
error: error.message,
itemIndex: i,
resource,
operation,
},
pairedItem: { item: i },
});
continue;
}
throw error;
}
}
logger_1.logger.info('node', `ProxMox node execution completed`, {
resource,
operation,
itemCount: length,
resultCount: returnData.length,
});
console.log('========== PROXMOX NODE EXECUTION COMPLETED ==========\n\n');
return [returnData];
}
catch (globalError) {
console.log('ERROR in node execution:');
console.log(globalError);
if (this.continueOnFail()) {
console.log('Continue on fail is enabled, returning error as output');
return [[{ json: { error: globalError.message } }]];
}
throw globalError;
}
}
}
exports.ProxMox = ProxMox;