tessl/pypi-junos-eznc

Junos 'EZ' automation library for remotely managing and automating Juniper Networks Junos devices through NETCONF protocol

—

Pending

Overview

Eval results

Files

Configuration Management

Name: tessl/pypi-junos-eznc
Author: tessl

Configuration management utilities for loading, committing, rolling back, and managing Junos device configurations. Supports multiple configuration formats, advanced commit options, database locking, and configuration comparison operations.

Capabilities

Config Utility Class

The Config utility provides comprehensive configuration management capabilities including loading configurations in multiple formats, committing changes with various options, and managing configuration database locks.

class Config:
    def __init__(self, dev):
        """
        Initialize Config utility bound to a device.
        
        Parameters:
        - dev (Device): Device object to bind to
        """

    def load(
        self,
        config_data,
        format='text',
        merge=False,
        overwrite=False,
        template_vars=None,
        path=None,
        ignore_warning=None,
        timeout=None
    ):
        """
        Load configuration data into the candidate configuration.
        
        Parameters:
        - config_data (str|dict): Configuration data to load
        - format (str): Configuration format ('text', 'set', 'xml', 'json')
        - merge (bool): Merge with existing configuration (default: True)
        - overwrite (bool): Overwrite existing configuration
        - template_vars (dict): Variables for Jinja2 template processing
        - path (str): Configuration hierarchy path for partial loads
        - ignore_warning (list): List of warnings to ignore
        - timeout (int): Load operation timeout
        
        Raises:
        - ConfigLoadError: Configuration load failed
        - LockError: Configuration database is locked
        """

    def commit(
        self,
        comment=None,
        confirm=None,
        timeout=None,
        full=False,
        detail=False,
        sync=False
    ):
        """
        Commit the candidate configuration.
        
        Parameters:
        - comment (str): Commit comment
        - confirm (int): Automatic rollback timeout in minutes
        - timeout (int): Commit operation timeout
        - full (bool): Perform full commit (bypass commit scripts)
        - detail (bool): Return detailed commit information
        - sync (bool): Synchronize commit across routing engines
        
        Returns:
        - bool: True if commit successful
        
        Raises:
        - CommitError: Commit operation failed
        - LockError: Configuration is locked by another user
        """

    def commit_check(self):
        """
        Check candidate configuration for errors without committing.
        
        Returns:
        - bool: True if configuration is valid
        
        Raises:
        - CommitError: Configuration has errors
        """

Configuration Database Operations

Operations for managing configuration database locks, comparing configurations, and rolling back to previous configurations.

def lock(self):
    """
    Lock the configuration database for exclusive access.
    
    Raises:
    - LockError: Unable to acquire configuration lock
    """

def unlock(self):
    """
    Unlock the configuration database.
    
    Raises:
    - UnlockError: Unable to release configuration lock
    """

def diff(self, rb_id=0, timeout=None):
    """
    Show differences between candidate and active configurations.
    
    Parameters:
    - rb_id (int): Rollback ID to compare against (0=current active)
    - timeout (int): Operation timeout
    
    Returns:
    - str: Configuration differences in unified diff format
    """

def rollback(self, rb_id=0, timeout=None):
    """
    Load a previous configuration as the candidate configuration.
    
    Parameters:
    - rb_id (int): Rollback configuration ID (0=current, 1=previous, etc.)
    - timeout (int): Rollback operation timeout
    
    Raises:
    - ConfigLoadError: Unable to load rollback configuration
    """

Rescue Configuration Management

Manage rescue configurations for device recovery scenarios, allowing save and restore operations for emergency configurations.

def rescue(self, action=None, timeout=None):
    """
    Manage rescue configuration operations.
    
    Parameters:
    - action (str): Rescue action ('save', 'get', 'delete')
        - 'save': Save current configuration as rescue
        - 'get': Load rescue configuration as candidate
        - 'delete': Delete rescue configuration
    - timeout (int): Operation timeout
    
    Returns:
    - bool: True if operation successful
    
    Raises:
    - RpcError: Rescue operation failed
    """

Configuration Binding

Bind the Config utility to a Device instance to enable configuration management operations.

# Binding Config utility to device
dev.bind(cu=Config)  # 'cu' is conventional name for Config utility

# Access bound utility
dev.cu.load(config_data)
dev.cu.commit()

Usage Examples

Basic Configuration Management

from jnpr.junos import Device
from jnpr.junos.utils.config import Config

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()

# Bind Config utility
dev.bind(cu=Config)

# Load configuration using set commands
config_data = '''
set interfaces ge-0/0/0 description "WAN Connection"
set interfaces ge-0/0/0 unit 0 family inet address 192.168.1.1/24
'''

dev.cu.load(config_data, format='set')

# Check configuration before committing
if dev.cu.commit_check():
    print("Configuration is valid")
    
    # Show what will change
    diff = dev.cu.diff()
    print("Configuration changes:")
    print(diff)
    
    # Commit with comment
    dev.cu.commit(comment='Added WAN interface configuration')
    print("Configuration committed successfully")
else:
    print("Configuration has errors")

dev.close()

XML Configuration Loading

from jnpr.junos import Device
from jnpr.junos.utils.config import Config

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

# Load XML configuration
xml_config = '''
<configuration>
    <interfaces>
        <interface>
            <name>ge-0/0/1</name>
            <description>LAN Connection</description>
            <unit>
                <name>0</name>
                <family>
                    <inet>
                        <address>
                            <name>10.0.1.1/24</name>
                        </address>
                    </inet>
                </family>
            </unit>
        </interface>
    </interfaces>
</configuration>
'''

dev.cu.load(xml_config, format='xml')
dev.cu.commit(comment='Added LAN interface via XML')

dev.close()

Configuration with Template Variables

from jnpr.junos import Device
from jnpr.junos.utils.config import Config

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

# Configuration template with variables
config_template = '''
set interfaces {{ interface }} description "{{ description }}"
set interfaces {{ interface }} unit 0 family inet address {{ ip_address }}
'''

# Load configuration with template variables
dev.cu.load(
    config_template,
    format='set',
    template_vars={
        'interface': 'ge-0/0/2',
        'description': 'Template Interface',
        'ip_address': '10.0.2.1/24'
    }
)

dev.cu.commit(comment='Interface configured using template')

dev.close()

Advanced Commit Operations

from jnpr.junos import Device
from jnpr.junos.utils.config import Config

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

# Load some configuration
config = 'set system host-name new-hostname'
dev.cu.load(config, format='set')

# Commit with confirm (auto-rollback) for safety
dev.cu.commit(
    comment='Hostname change with auto-rollback',
    confirm=5  # Auto-rollback in 5 minutes if not confirmed
)

print("Configuration committed with 5-minute auto-rollback")

# To confirm the commit and prevent rollback
# dev.cu.commit()

dev.close()

Configuration Database Locking

from jnpr.junos import Device
from jnpr.junos.utils.config import Config
from jnpr.junos.exception import LockError

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

try:
    # Lock configuration database
    dev.cu.lock()
    print("Configuration database locked")
    
    # Load and commit configuration
    config = 'set system location building "Main Office"'
    dev.cu.load(config, format='set')
    dev.cu.commit(comment='Updated system location')
    
except LockError:
    print("Configuration is locked by another user")
finally:
    # Always unlock when done
    try:
        dev.cu.unlock()
        print("Configuration database unlocked")
    except:
        pass

dev.close()

Configuration Rollback

from jnpr.junos import Device
from jnpr.junos.utils.config import Config

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

# View current configuration differences
current_diff = dev.cu.diff()
print("Current candidate configuration:")
print(current_diff)

# Rollback to previous configuration
dev.cu.rollback(rb_id=1)  # Load the previous committed configuration

# Show what the rollback would change
rollback_diff = dev.cu.diff()
print("Changes from rollback:")
print(rollback_diff)

# Commit the rollback
dev.cu.commit(comment='Rolled back to previous configuration')

dev.close()

Rescue Configuration Operations

from jnpr.junos import Device
from jnpr.junos.utils.config import Config

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

# Save current configuration as rescue configuration
dev.cu.rescue(action='save')
print("Current configuration saved as rescue")

# Later, if needed, load rescue configuration
dev.cu.rescue(action='get')
print("Rescue configuration loaded as candidate")

# Check what rescue configuration contains
diff = dev.cu.diff()
print("Rescue configuration differences:")
print(diff)

# Commit rescue configuration
dev.cu.commit(comment='Restored from rescue configuration')

dev.close()

Error Handling

from jnpr.junos import Device
from jnpr.junos.utils.config import Config
from jnpr.junos.exception import ConfigLoadError, CommitError, LockError

dev = Device(host='router1.example.com', user='admin', passwd='secret')
dev.open()
dev.bind(cu=Config)

try:
    # Attempt to load invalid configuration
    invalid_config = 'set interfaces invalid-interface-name unit 0'
    dev.cu.load(invalid_config, format='set')
    
except ConfigLoadError as e:
    print(f"Configuration load error: {e}")

try:
    # Attempt to commit configuration with errors
    dev.cu.commit()
    
except CommitError as e:
    print(f"Commit error: {e}")
    print("Error details:", e.rpc_error)

except LockError as e:
    print(f"Lock error: {e}")

dev.close()

Types

# Configuration data types
ConfigData = str | dict  # Configuration in text, set, XML, or JSON format
ConfigFormat = str  # 'text', 'set', 'xml', 'json'

# Template variable types
TemplateVars = dict[str, any]  # Variables for Jinja2 template processing

# Commit options
CommitOptions = dict[str, any]  # Dictionary of commit parameters

# Configuration comparison result
ConfigDiff = str  # Unified diff format configuration differences

# Rollback ID type
RollbackId = int  # Configuration rollback identifier (0=current, 1=previous, etc.)

Install with Tessl CLI