Objectifying Cisco Network Devices in Python with Netmiko

Posted on Mon 09 December 2024 in Networking

Managing network devices programmatically has become a crucial skill for network engineers. By objectifying network devices and their components, you can simplify operations, make your code modular, and automate tedious tasks. In this blog post, we’ll explore how to objectify a Cisco network device using Python and Netmiko, focusing on representing device storage with clear and reusable properties.

Why Objectify a Network Device?

Objectifying a network device means modeling it as a Python class that encapsulates all its properties and operations. This approach offers several benefits:

  • Modularity: Keep code organized and reusable.
  • Scalability: Easily manage multiple devices.
  • Maintainability: Isolate and fix issues in one place.
  • Extensibility: Add features without breaking existing functionality.

The Plan

We’ll create two classes:

  1. CiscoDevice: Represents a Cisco network device and its operations.
  2. Storage: Encapsulates storage-related properties, such as bytes_free and bytes_total.

Using Netmiko, the CiscoDevice class will connect to a Cisco device and fetch its storage information by parsing the output of the dir bootflash: command.

Implementation

Step 1: Define the Storage Class

The Storage class represents storage information on a network device, making it reusable and self-contained.

class Storage:
    def __init__(self, bytes_free=0, bytes_total=0):
        self.bytes_free = bytes_free
        self.bytes_total = bytes_total

    def __repr__(self):
        return f"<Storage(bytes_free={self.bytes_free}, bytes_total={self.bytes_total})>"

Step 2: Define the CiscoDevice Class

The CiscoDevice class handles device connection and operations, including fetching storage details.

from netmiko import ConnectHandler

class CiscoDevice:
    def __init__(self, name, ip, username, password):
        self.name = name
        self.ip = ip
        self.username = username
        self.password = password
        self.connection = None
        self.storage = None  # Will hold an instance of Storage

    def connect(self):
        """Establish a Netmiko connection."""
        try:
            self.connection = ConnectHandler(
                device_type="cisco_ios",
                host=self.ip,
                username=self.username,
                password=self.password,
            )
            print(f"Connected to {self.name} ({self.ip})")
        except Exception as e:
            raise Exception(f"Failed to connect to {self.name} ({self.ip}): {e}")

    def disconnect(self):
        """Close the Netmiko connection."""
        if self.connection:
            self.connection.disconnect()
            self.connection = None
            print(f"Disconnected from {self.name} ({self.ip})")

    def fetch_storage(self):
        """Fetch storage details from the device."""
        if not self.connection:
            raise Exception("Not connected to device")
        try:
            output = self.connection.send_command("dir bootflash:")
            if "bytes free" in output:
                # Parse the last line for storage details
                parts = output.splitlines()[-1].split()
                bytes_free = int(parts[3].strip("("))  # Extract free space
                bytes_total = int(parts[0])            # Extract total space
                self.storage = Storage(bytes_free=bytes_free, bytes_total=bytes_total)
                print(f"Storage fetched for {self.name}: {self.storage}")
            else:
                raise Exception("Failed to parse storage information")
        except Exception as e:
            raise Exception(f"Error fetching storage for {self.name}: {e}")

    def __repr__(self):
        return f"<CiscoDevice(name={self.name}, ip={self.ip}, storage={self.storage})>"

Step 3: Putting It All Together

Here’s an example script that demonstrates connecting to a device and fetching its storage details.

if __name__ == "__main__":
    # Instantiate a CiscoDevice object
    device = CiscoDevice(
        name="Router1",
        ip="192.168.1.1",
        username="admin",
        password="password",
    )

    # Connect to the device and fetch storage details
    try:
        device.connect()
        device.fetch_storage()
    finally:
        # Disconnect from the device
        device.disconnect()

    # Print the device details
    print(device)

Expected Output

Here’s what you might see when running the script:

Connected to Router1 (192.168.1.1)
Storage fetched for Router1: <Storage(bytes_free=23456789, bytes_total=50000000)>
Disconnected from Router1 (192.168.1.1)
<CiscoDevice(name=Router1, ip=192.168.1.1, storage=<Storage(bytes_free=23456789, bytes_total=50000000)>)>

Key Benefits of This Approach

  1. Encapsulation:

    • The Storage class cleanly separates storage details from the main CiscoDevice logic.

  2. Scalability:

    • Easily extend the CiscoDevice class to support additional features like fetching model, OS version, or other device-specific attributes.

  3. Error Handling:

    • Handle connection and command execution errors gracefully, ensuring the script doesn't crash.

  4. Reusability:

    • The Storage class can be reused in other contexts requiring storage information.

Final Thoughts

By objectifying a Cisco network device and its storage, we’ve created a modular and reusable framework that simplifies device management. This approach not only saves time but also reduces errors and makes your code easier to maintain.

Since we’ve now objectified the storage, we can easily run logic against it for advanced operations. For example, you could test if a new IOS file will fit on the device before attempting to upload it. This might look something like:

if device.storage.bytes_free > new_ios_file_size:
    print("Sufficient storage space available. Proceeding with upload...")
else:
    print("Insufficient storage space. Cleanup required before upload.")

This capability allows for more intelligent automation, helping you handle edge cases and reduce manual interventions.

What tasks would you like to automate next? Let us know in the comments or reach out on BlogByNuX! If you’re interested in extending this script to fetch other device details, manage configurations, or implement dynamic decision-making, stay tuned for upcoming posts.

Happy automating! 🚀

Python Netmiko Automation Cisco