tessl/pypi-ncclient

Python library for NETCONF clients with support for SSH, TLS, and device-specific operations

—

Pending

Overview

Eval results

Files

Device Support

Name: tessl/pypi-ncclient
Author: tessl

Device-specific handlers providing optimizations and vendor-specific functionality for major network equipment manufacturers. Handlers customize NETCONF behavior, add vendor extensions, and optimize operations for specific device capabilities.

Capabilities

Device Handler Creation

Factory function for creating appropriate device handlers based on device parameters.

def make_device_handler(device_params, ignore_errors=None):
    """
    Create device handler for vendor-specific functionality.
    
    Parameters:
    - device_params: dict, device configuration with 'name' key
                    or custom 'handler' class
    - ignore_errors: list, error patterns to ignore
    
    Returns:
    DeviceHandler: Device-specific handler instance
    """

Base Device Handler

Default handler providing standard NETCONF behavior without vendor-specific customizations.

class DefaultDeviceHandler:
    """Default device handler for standard NETCONF devices."""
    
    def __init__(self, device_params, ignore_errors=None):
        """
        Initialize default device handler.
        
        Parameters:
        - device_params: dict, device parameters
        - ignore_errors: list, error patterns to ignore
        """
    
    def add_additional_ssh_connect_params(self, params):
        """Add device-specific SSH connection parameters."""
    
    def add_additional_netconf_params(self, params):
        """Add device-specific NETCONF parameters."""
    
    def add_additional_operations(self):
        """
        Add vendor-specific operations.
        
        Returns:
        dict: Mapping of operation names to operation classes
        """
    
    def perform_qualify_check(self):
        """Perform device qualification checks."""
    
    def handle_connection_exceptions(self, sshsession):
        """Handle device-specific connection exceptions."""

Cisco Device Handlers

Device handlers for Cisco network equipment with platform-specific optimizations.

class NexusDeviceHandler(DefaultDeviceHandler):
    """Cisco Nexus device handler with NXOS optimizations."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize Nexus device handler."""

class IosxrDeviceHandler(DefaultDeviceHandler):
    """Cisco IOS XR device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize IOS XR device handler."""

class IosxeDeviceHandler(DefaultDeviceHandler):
    """Cisco IOS XE device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize IOS XE device handler."""

class CsrDeviceHandler(DefaultDeviceHandler):
    """Cisco Cloud Services Router device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize CSR device handler."""

Juniper Device Handler

Device handler for Juniper Networks equipment with Junos-specific functionality.

class JunosDeviceHandler(DefaultDeviceHandler):
    """Juniper Junos device handler with platform optimizations."""
    
    def __init__(self, device_params, ignore_errors=None):
        """
        Initialize Junos device handler.
        
        Parameters:
        - device_params: dict, may include 'local' key for local connections
        - ignore_errors: list, error patterns to ignore
        """
    
    def add_additional_operations(self):
        """
        Add Junos-specific operations.
        
        Returns:
        dict: Junos vendor operations
        """

Huawei Device Handlers

Device handlers for Huawei network equipment supporting multiple data models.

class HuaweiDeviceHandler(DefaultDeviceHandler):
    """Huawei device handler for traditional data models."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize Huawei device handler."""

class HuaweiyangDeviceHandler(DefaultDeviceHandler):
    """Huawei device handler for YANG-based data models."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize Huawei YANG device handler."""

Other Vendor Handlers

Device handlers for additional network equipment vendors.

class H3cDeviceHandler(DefaultDeviceHandler):
    """H3C (Hewlett Packard Enterprise) device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize H3C device handler."""

class HpcomwareDeviceHandler(DefaultDeviceHandler):
    """HP Comware device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize HP Comware device handler."""

class AluDeviceHandler(DefaultDeviceHandler):
    """Nokia/Alcatel-Lucent device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize ALU device handler."""

class SrosDeviceHandler(DefaultDeviceHandler):
    """Nokia Service Router Operating System device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize SR OS device handler."""

class EricssonDeviceHandler(DefaultDeviceHandler):
    """Ericsson device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize Ericsson device handler."""

class CienaDeviceHandler(DefaultDeviceHandler):
    """Ciena device handler."""
    
    def __init__(self, device_params, ignore_errors=None):
        """Initialize Ciena device handler."""

Vendor-Specific Operations

Extended RPC operations provided by device handlers for vendor-specific functionality.

Juniper Operations

# Available through JunosDeviceHandler
def compare_configuration(**kwargs):
    """Compare configuration versions (Junos)."""

def load_configuration(config, **kwargs):
    """Load configuration with Junos-specific options."""

def commit_configuration(**kwargs):
    """Commit with Junos-specific parameters."""

Cisco Operations

# Available through Nexus/IOS handlers  
def save_config(**kwargs):
    """Save running configuration (Cisco)."""

def action(action_xml):
    """Execute Cisco-specific action RPC."""

Nokia/ALU Operations

# Available through ALU/SROS handlers
def md_cli_raw_command(command):
    """Execute raw MD-CLI command (Nokia)."""

def classic_cli_raw_command(command):
    """Execute raw classic CLI command (Nokia)."""

Device Parameter Configuration

Device-specific parameters for customizing handler behavior and connection settings.

# Device parameter examples
device_params = {
    'name': 'junos',           # Device type identifier
    'local': True,             # Local connection (Junos)
    'handler': CustomHandler,   # Custom handler class
    'timeout': 60,             # Device-specific timeout
    'port': 22,                # SSH port override
    'hostkey_verify': False,   # SSH host key verification
}

Usage Examples

Basic Device Handler Usage

from ncclient import manager

# Automatic device detection
device_params = {'name': 'junos'}

with manager.connect_ssh(
    host='juniper-mx.example.com',
    username='netconf-user',
    password='netconf-pass',
    device_params=device_params
) as m:
    # Junos-specific operations available
    config = m.get_config(source='running')
    
    # Access vendor operations if available
    if hasattr(m, 'compare_configuration'):
        result = m.compare_configuration()

Cisco Nexus Device

from ncclient import manager

device_params = {'name': 'nexus'}

with manager.connect_ssh(
    host='nexus-switch.example.com',
    username='admin',
    password='admin',
    device_params=device_params
) as m:
    # Nexus-specific behavior and operations
    result = m.get_config(source='running')
    
    # Save configuration if supported
    if hasattr(m, 'save_config'):
        m.save_config()

Custom Device Handler

from ncclient import manager
from ncclient.devices.default import DefaultDeviceHandler

class MyCustomHandler(DefaultDeviceHandler):
    def add_additional_operations(self):
        # Add custom operations
        return {
            'custom_op': MyCustomOperation
        }
    
    def add_additional_ssh_connect_params(self, params):
        # Customize SSH parameters
        params['banner_timeout'] = 60
        params['auth_timeout'] = 30

# Use custom handler
device_params = {'handler': MyCustomHandler}

with manager.connect_ssh(
    host='custom-device.example.com',
    username='admin',
    password='admin', 
    device_params=device_params
) as m:
    # Custom operations available
    if hasattr(m, 'custom_op'):
        result = m.custom_op()

Multiple Device Types

from ncclient import manager

devices = [
    {'host': 'juniper.example.com', 'device_params': {'name': 'junos'}},
    {'host': 'cisco.example.com', 'device_params': {'name': 'nexus'}},
    {'host': 'huawei.example.com', 'device_params': {'name': 'huawei'}},
]

for device_config in devices:
    try:
        with manager.connect_ssh(
            host=device_config['host'],
            username='admin',
            password='admin',
            device_params=device_config['device_params']
        ) as m:
            print(f"Connected to {device_config['host']}")
            
            # Universal operations work on all devices
            config = m.get_config(source='running')
            print(f"Config length: {len(config.data_xml)}")
            
    except Exception as e:
        print(f"Failed to connect to {device_config['host']}: {e}")

Error Handling with Device Specifics

from ncclient import manager

# Device-specific error handling
ignore_errors = [
    'warning',
    'minor-error'
]

device_params = {
    'name': 'iosxr',
}

errors_params = {
    'ignore_errors': ignore_errors
}

with manager.connect_ssh(
    host='iosxr-router.example.com',
    username='cisco',
    password='cisco',
    device_params=device_params,
    errors_params=errors_params
) as m:
    # IOS XR specific operations with error handling
    try:
        result = m.edit_config(target='candidate', config=config_xml)
        m.commit()
    except Exception as e:
        print(f"Operation failed: {e}")

Install with Tessl CLI