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

n8n node to interact with network devices (Cisco, MikroTik, Arista, Extreme Networks, Dell, Juniper, HP, Aruba, Ubiquiti, Palo Alto, Fortinet - ISP, data center, campus, and edge)

"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 paloalto_1 = require("./paloalto");
const ciena_1 = require("./ciena");
const fortinet_1 = require("./fortinet");
const ericsson_1 = require("./ericsson");
const device_specific_jump_host_connection_1 = require("./device-specific-jump-host-connection");
const vyos_1 = require("./vyos");
const huawei_1 = require("./huawei");
const arista_1 = require("./arista");
const hp_1 = require("./hp");
const ubiquiti_1 = require("./ubiquiti");
const mikrotik_1 = require("./mikrotik");
const extreme_1 = require("./extreme");
const dell_1 = require("./dell");
const versa_1 = require("./versa");
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,
    'paloalto_panos': paloalto_1.PaloAltoConnection,
    'ciena_saos': ciena_1.CienaSaosConnection,
    'fortinet_fortios': fortinet_1.FortinetConnection,
    'ericsson_ipos': ericsson_1.EricssonConnection,
    'ericsson_mltn': ericsson_1.EricssonMinilinkConnection,
    'linux': linux_1.LinuxConnection,
    'generic': base_connection_1.BaseConnection,
    'vyos': vyos_1.VyosConnection,
    'huawei_vrp': huawei_1.HuaweiConnection,
    'arista_eos': arista_1.AristaConnection,
    'hp_procurve': hp_1.HPProcurveConnection,
    'aruba_os': hp_1.ArubaOsConnection,
    'aruba_aoscx': hp_1.ArubaAosCxConnection,
    'ubiquiti_edgeswitch': ubiquiti_1.UbiquitiEdgeSwitchConnection,
    'ubiquiti_edgerouter': ubiquiti_1.UbiquitiEdgeRouterConnection,
    'ubiquiti_unifi': ubiquiti_1.UbiquitiUnifiSwitchConnection,
    'mikrotik_routeros': mikrotik_1.MikrotikRouterOsConnection,
    'mikrotik_switchos': mikrotik_1.MikrotikSwitchOsConnection,
    'extreme_exos': extreme_1.ExtremeExosConnection,
    'dell_os10': dell_1.DellOS10Connection,
    'versa_flexvnf': versa_1.VersaFlexVNFConnection,
};
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(', ')}`);
        }
        const deviceConnection = new ConnectionClass(credentials);
        if (credentials.useJumpHost && credentials.jumpHostHost && credentials.jumpHostPort && credentials.jumpHostUsername && credentials.jumpHostAuthMethod) {
            return new device_specific_jump_host_connection_1.DeviceSpecificJumpHostConnection(credentials, deviceConnection);
        }
        return deviceConnection;
    }
    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',
            'paloalto_panos': 'Palo Alto PAN-OS',
            'ciena_saos': 'Ciena SAOS',
            'fortinet_fortios': 'Fortinet FortiOS',
            'ericsson_ipos': 'Ericsson IPOS',
            'ericsson_mltn': 'Ericsson MiniLink',
            'linux': 'Linux Server',
            'generic': 'Generic SSH',
            'vyos': 'VyOS',
            'huawei_vrp': 'Huawei VRP',
            'arista_eos': 'Arista EOS',
            'hp_procurve': 'HP ProCurve',
            'aruba_os': 'Aruba OS (Mobility Controllers)',
            'aruba_aoscx': 'Aruba AOS-CX',
            'ubiquiti_edgeswitch': 'Ubiquiti EdgeSwitch',
            'ubiquiti_edgerouter': 'Ubiquiti EdgeRouter',
            'ubiquiti_unifi': 'Ubiquiti UniFi Switch',
            'mikrotik_routeros': 'MikroTik RouterOS',
            'mikrotik_switchos': 'MikroTik SwitchOS',
            'extreme_exos': 'Extreme Networks ExtremeXOS',
            'dell_os10': 'Dell EMC OS10',
            'versa_flexvnf': 'Versa FlexVNF',
        };
        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: 'Palo Alto PAN-OS',
                value: 'paloalto_panos',
                description: 'Palo Alto Networks firewalls'
            },
            {
                name: 'Ciena SAOS',
                value: 'ciena_saos',
                description: 'Ciena SAOS switches and platforms'
            },
            {
                name: 'Fortinet FortiOS',
                value: 'fortinet_fortios',
                description: 'Fortinet FortiOS firewalls and security appliances'
            },
            {
                name: 'Ericsson IPOS',
                value: 'ericsson_ipos',
                description: 'Ericsson IPOS devices'
            },
            {
                name: 'Ericsson MiniLink',
                value: 'ericsson_mltn',
                description: 'Ericsson MiniLink devices'
            },
            {
                name: 'Linux Server',
                value: 'linux',
                description: 'Linux servers and appliances'
            },
            {
                name: 'Generic SSH',
                value: 'generic',
                description: 'Generic SSH connection'
            },
            {
                name: 'VyOS',
                value: 'vyos',
                description: 'VyOS routers'
            },
            {
                name: 'Huawei VRP (NE Series)',
                value: 'huawei_vrp',
                description: 'Huawei NE/AR/S series running VRP (incl. NE8000).',
            },
            {
                name: 'Arista EOS',
                value: 'arista_eos',
                description: 'Arista EOS switches (data center)',
            },
            {
                name: 'HP ProCurve',
                value: 'hp_procurve',
                description: 'HP ProCurve switches',
            },
            {
                name: 'Aruba OS',
                value: 'aruba_os',
                description: 'Aruba OS Mobility Controllers (wireless)',
            },
            {
                name: 'Aruba AOS-CX',
                value: 'aruba_aoscx',
                description: 'Aruba AOS-CX switches (modern campus)',
            },
            {
                name: 'Ubiquiti EdgeSwitch',
                value: 'ubiquiti_edgeswitch',
                description: 'Ubiquiti EdgeSwitch series',
            },
            {
                name: 'Ubiquiti EdgeRouter',
                value: 'ubiquiti_edgerouter',
                description: 'Ubiquiti EdgeRouter series (EdgeOS)',
            },
            {
                name: 'Ubiquiti UniFi Switch',
                value: 'ubiquiti_unifi',
                description: 'Ubiquiti UniFi switches',
            },
            {
                name: 'MikroTik RouterOS',
                value: 'mikrotik_routeros',
                description: 'MikroTik routers (ISP/WISP)',
            },
            {
                name: 'MikroTik SwitchOS',
                value: 'mikrotik_switchos',
                description: 'MikroTik switches',
            },
            {
                name: 'Extreme Networks ExtremeXOS',
                value: 'extreme_exos',
                description: 'Extreme ExtremeXOS switches (campus/data center)',
            },
            {
                name: 'Dell EMC OS10',
                value: 'dell_os10',
                description: 'Dell EMC OS10 switches (data center/campus)',
            },
            {
                name: 'Versa FlexVNF',
                value: 'versa_flexvnf',
                description: 'Versa Networks FlexVNF (SD-WAN/NFV)',
            },
        ];
    }
    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('ciena') || output.includes('saos')) {
                return 'ciena_saos';
            }
            if (output.includes('fortinet') || output.includes('fortios') ||
                output.includes('fortigate')) {
                return 'fortinet_fortios';
            }
            if (output.includes('palo alto') || output.includes('pan-os') ||
                output.includes('panos') || output.includes('paloalto')) {
                return 'paloalto_panos';
            }
            if (output.includes('ericsson') || output.includes('ipos')) {
                return 'ericsson_ipos';
            }
            if (output.includes('minilink')) {
                return 'ericsson_mltn';
            }
            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';
            }
            if (output.includes('huawei') ||
                output.includes('vrp') ||
                output.includes('versatile routing platform') ||
                output.includes('ne8000')) {
                return 'huawei_vrp';
            }
            if (output.includes('arista') || output.includes('arista eos')) {
                return 'arista_eos';
            }
            if (output.includes('procurve') || output.includes('hp switch')) {
                return 'hp_procurve';
            }
            if (output.includes('aruba')) {
                if (output.includes('arubaos') || output.includes('mobility controller') ||
                    output.includes('mobility master')) {
                    return 'aruba_os';
                }
                else if (output.includes('aos-cx') || output.includes('aoscx')) {
                    return 'aruba_aoscx';
                }
                return 'aruba_aoscx';
            }
            if (output.includes('ubiquiti') || output.includes('ubnt')) {
                if (output.includes('edgerouter') || output.includes('edgeos')) {
                    return 'ubiquiti_edgerouter';
                }
                else if (output.includes('edgeswitch')) {
                    return 'ubiquiti_edgeswitch';
                }
                else if (output.includes('unifi')) {
                    return 'ubiquiti_unifi';
                }
                return 'ubiquiti_edgeswitch';
            }
            if (output.includes('mikrotik') || output.includes('routeros')) {
                if (output.includes('switchos')) {
                    return 'mikrotik_switchos';
                }
                return 'mikrotik_routeros';
            }
            if (output.includes('extremexos') || output.includes('extreme networks') ||
                output.includes('exos')) {
                return 'extreme_exos';
            }
            if (output.includes('dell') && (output.includes('os10') || output.includes('dellos10'))) {
                return 'dell_os10';
            }
            if (output.includes('versa') || output.includes('flexvnf')) {
                return 'versa_flexvnf';
            }
            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