n8n-nodes-netdevices/dist/nodes/NetDevices/utils/connection-dispatcher.js

n8n node to interact with network devices

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConnectionDispatcher = void 0;
exports.ConnectHandler = ConnectHandler;
exports.ConnectHandlerWithAutoDetect = ConnectHandlerWithAutoDetect;
const base_connection_1 = require("./base-connection");
const cisco_1 = require("./cisco");
const juniper_1 = require("./juniper");
const linux_1 = require("./linux");
const CONNECTION_CLASS_MAPPING = {
    'cisco_ios': cisco_1.CiscoConnection,
    'cisco_ios_xe': cisco_1.CiscoConnection,
    'cisco_ios_xr': cisco_1.CiscoIOSXRConnection,
    'cisco_nxos': cisco_1.CiscoConnection,
    'cisco_asa': cisco_1.CiscoConnection,
    'cisco_sg300': cisco_1.CiscoSG300Connection,
    'juniper_junos': juniper_1.JuniperConnection,
    'juniper_srx': juniper_1.JuniperConnection,
    'linux': linux_1.LinuxConnection,
    'generic': base_connection_1.BaseConnection
};
class ConnectionDispatcher {
    static createConnection(credentials) {
        const deviceType = credentials.deviceType.toLowerCase();
        const ConnectionClass = CONNECTION_CLASS_MAPPING[deviceType];
        if (!ConnectionClass) {
            throw new Error(`Unsupported device type: ${deviceType}. Supported types: ${Object.keys(CONNECTION_CLASS_MAPPING).join(', ')}`);
        }
        return new ConnectionClass(credentials);
    }
    static getSupportedDeviceTypes() {
        return Object.keys(CONNECTION_CLASS_MAPPING);
    }
    static isDeviceTypeSupported(deviceType) {
        return Object.keys(CONNECTION_CLASS_MAPPING).includes(deviceType.toLowerCase());
    }
    static getDeviceTypeDisplayName(deviceType) {
        const displayNames = {
            'cisco_ios': 'Cisco IOS',
            'cisco_ios_xe': 'Cisco IOS-XE',
            'cisco_ios_xr': 'Cisco IOS-XR',
            'cisco_nxos': 'Cisco NX-OS',
            'cisco_asa': 'Cisco ASA',
            'cisco_sg300': 'Cisco SG300',
            'juniper_junos': 'Juniper JunOS',
            'juniper_srx': 'Juniper SRX',
            'linux': 'Linux Server',
            'generic': 'Generic SSH'
        };
        return displayNames[deviceType.toLowerCase()] || deviceType;
    }
    static getDeviceTypeOptions() {
        return [
            {
                name: 'Cisco IOS',
                value: 'cisco_ios',
                description: 'Cisco IOS routers and switches'
            },
            {
                name: 'Cisco IOS-XE',
                value: 'cisco_ios_xe',
                description: 'Cisco IOS-XE devices'
            },
            {
                name: 'Cisco IOS-XR',
                value: 'cisco_ios_xr',
                description: 'Cisco IOS-XR routers (service provider)'
            },
            {
                name: 'Cisco NX-OS',
                value: 'cisco_nxos',
                description: 'Cisco Nexus switches'
            },
            {
                name: 'Cisco ASA',
                value: 'cisco_asa',
                description: 'Cisco ASA firewalls'
            },
            {
                name: 'Cisco SG300',
                value: 'cisco_sg300',
                description: 'Cisco SG300 series switches'
            },
            {
                name: 'Juniper JunOS',
                value: 'juniper_junos',
                description: 'Juniper routers and switches'
            },
            {
                name: 'Juniper SRX',
                value: 'juniper_srx',
                description: 'Juniper SRX firewalls'
            },
            {
                name: 'Linux Server',
                value: 'linux',
                description: 'Linux servers and appliances'
            },
            {
                name: 'Generic SSH',
                value: 'generic',
                description: 'Generic SSH connection'
            }
        ];
    }
    static async autoDetectDeviceType(credentials) {
        const tempCredentials = { ...credentials, deviceType: 'generic' };
        const connection = new base_connection_1.BaseConnection(tempCredentials);
        try {
            await connection.connect();
            const response = await connection.sendCommand('');
            const output = response.output.toLowerCase();
            if (output.includes('cisco') || output.includes('ios') || output.includes('nx-os')) {
                if (output.includes('nx-os') || output.includes('nexus')) {
                    return 'cisco_nxos';
                }
                else if (output.includes('asa')) {
                    return 'cisco_asa';
                }
                else if (output.includes('ios-xr') || output.includes('iosxr')) {
                    return 'cisco_ios_xr';
                }
                else if (output.includes('ios-xe')) {
                    return 'cisco_ios_xe';
                }
                else if (output.includes('sg300') || output.includes('small business')) {
                    return 'cisco_sg300';
                }
                else {
                    return 'cisco_ios';
                }
            }
            if (output.includes('junos') || output.includes('juniper')) {
                if (output.includes('srx')) {
                    return 'juniper_srx';
                }
                else {
                    return 'juniper_junos';
                }
            }
            if (output.includes('linux') || output.includes('ubuntu') ||
                output.includes('centos') || output.includes('redhat') ||
                output.includes('debian') || output.includes('bash') ||
                output.includes('$') || output.includes('~')) {
                return 'linux';
            }
            return null;
        }
        catch (error) {
            return null;
        }
        finally {
            await connection.disconnect();
        }
    }
}
exports.ConnectionDispatcher = ConnectionDispatcher;
function ConnectHandler(credentials) {
    return ConnectionDispatcher.createConnection(credentials);
}
async function ConnectHandlerWithAutoDetect(credentials) {
    const tempCredentials = { ...credentials, deviceType: 'generic' };
    const detectedType = await ConnectionDispatcher.autoDetectDeviceType(tempCredentials);
    if (!detectedType) {
        throw new Error('Could not auto-detect device type');
    }
    const finalCredentials = { ...credentials, deviceType: detectedType };
    return ConnectionDispatcher.createConnection(finalCredentials);
}
//# sourceMappingURL=connection-dispatcher.js.map