Python SDN 101: Telnet Device Control
We began learning Python in the previous several articles. Why would a network engineer choose to acquire knowledge of this programming language? Our profession is developing and adapting to new technology; so, we must also adapt. Today's network engineer is not the same as he or she was 10 years ago. In 10 years' hence, SDN will undoubtedly disrupt our jobs; we can either surf the wave or perish under it. With this tutorial, we'll begin a Python SDN project to get you started with SDN.
Read More: SSH Tutorial for Python and how to connect to Cisco devices
SDN is coming about Python SDN 101: Telnet Device Control
For those unfamiliar with the term, SDN stands for Software-Defined Networking. With this technology, you get a collection of gadgets that are designed to make network engineers' lives easier. Forget about setting VLANs and ports; the program will take care of everything for you. It is not a basic centralized administration console; it has intelligence. You do not instruct an SDN platform to generate VLANs; you tell it to deploy a new site. It will manage the creation of new VLANs, the addition of routes, and the configuration of ports. As a result, I just came across this phrase on LinkedIn. To the CCIE, Python is going to replace you. While this is not entirely accurate, it demonstrates the potential power of SDN. It may lower the amount of jobs required of a network engineer, hence decreasing the number of network engineers required. If you do not learn how to deal with SDN, you can be certain that SDN will.
Introducing our Python SDN Project
The goal
Our objective with our Python SDN project is to provide tools capable of executing code on network devices. Our application will communicate with them, get information from them, and modify their settings. How you utilize it and what you do with it are entirely up to you. Through this and subsequent articles, we will develop something that is capable of performing the following tasks. Telnet and SSH are used to connect devices. Send configuration instructions and check their execution Execute troubleshooting commands and monitor their results Utilize SNMP to get device status and to make configuration changes. Syslog messages are received These are our system's weaponry. By the time our Python SDN project is complete, it will be able to fire with them. Which direction to go is entirely up to you. However, throughout these articles, we will put you in the proper route.Everything is on GitHub
GitHub is the leading platform for hosting source code for open-source projects. We have been developing this project step-by-step, and everything is documented on GitHub. Here you can get the code and browse to changes over time. Just follow our sdncore project.The anatomy of our Python SDN Project
Who starts in the right way is already halfway there. Thus, we need to create a convenient folder structure for our project. We can achieve this structure by adopting the best practices. Here is what the root of our project looks like.
Read More: SSH Tutorial for Python and how to connect to Cisco devices
Connecting to devices in Telnet with Python
SDN entails network management, and what kind of network would exist without network devices? We must first establish contact with them. Today, we're going to look at how Telnet makes this feasible. Telnet is a well-known protocol for non-encrypted terminal emulation. In other words, it enables you to interact with a target device just via text — and without employing any kind of encryption. Even though this is not the optimal solution, some networks may use it. Additionally, it is straightforward to comprehend and apply. It must be included in our project! Our emulation module for terminals We can start by creating avty module in our sdncore folder. As always, we create an empty __init__.py file, and we start by creating a sub-module called drivers. Here we add a new __init__.py file, a driver.py and a telnet.py.
Why all of that? With our vty module, we want to connect to a device regardless of the protocol – Telnet or SSH. Later on in this project, we will create a class that handles that connection. However, we need to implement the drivers to do that with Telnet and SSH. Today, we start by implementing the Telnet driver. The cherry on the cake is the driver.py files, it defines how a driver should be.
The driver
The first thing in our Python SDN project is the driver file. We are going to model our telnet driver according to how a driver should be, thus we need to define it first. The driver will handle the connection to the device, thus it must implement these features:- Open the connection to an IP and port, optionally with authentication
- Send text
- Receive text
- Close the connection
driver.py file is pretty simple.
class Driver:
def __init__(self, target, port, username, password):
raise NotImplementedError()
def open(self):
raise NotImplementedError()
def send_text(self, text):
raise NotImplementedError()
def read_until(self, text, timeout):
raise NotImplementedError()
def read_eof(self):
raise NotImplementedError()
def expect(self, expr_list, timeout):
raise NotImplementedError
def close(self):
raise NotImplementedError()
open(), you effectively start the connection. read_until() will read all text until a given string is found, while read_eof() will read as long as there is something to read (until end of file). Instead, expect() sits and wait until a given text (or list of text) appears.
A custom Error class
Our telnet script may rise some errors, while our SSH script may raise some others. We need to standardize this kind of error so that sdncore can handle them. For that, we add theDriverError class in the driver.py file.
class DriverError(Exception):
pass
The Telnet connection
Now it is time to define ourtelnet.py file. To connect to a device in telnet, we are going to use a standard python library: telnetlib. Using it, we need to write our own driver. Nothing too complex, the Telnet object from Telnet library has some built-in methods that resemble the ones we just prepared. We are going to require a few modules, then take a look at our constructor.
from telnetlib import Telnet as TelnetClient
from .driver import Driver, DriverError
import socket
class TelnetDriver(Driver):
def __init__(self, target, username='', password='', port=23,
username_finder='username: ', password_finder='password: '):
self.target = target
self.username = username
self.password = password
self.port = port
self.username_finder = username_finder
self.password_finder = password_finder
self._client = TelnetClient()
TelentClient. The fancy part is the username and password finders. We are going to use these parameters so that our client knows when it should send username and password. Here is the open() method that uses them.
def open(self):
self._client.open(self.target, self.port)
if self.username != '' or self.password != '':
self.expect(self.username_finder)
self.send_text(self.username)
self.expect(self.password_finder)
self.send_text(self.password
Tuning the other functions
We also need to redefine our other functions to rely on theTelnetClient. While doing so, we also need to convert any error that may arise into a DriverError.
def send_text(self, text):
try:
self._client.write(text.encode('ascii'))
return True
except socket.error:
raise DriverError("Connection closed while sending text")
def read_until(self, text, timeout=2):
try:
return self._client.read_until(text.encode('ascii'), timeout)
except EOFError:
raise DriverError("Connection closed without receiving EOF")
def read_eof(self, timeout=2):
return self._client.read_all()
def expect(self, expr_list, timeout=2):
try:
return self._client.expect(expr_list, timeout)
except EOFError:
raise DriverError("EOF was reached without finding the expected text")
def close(self):
self._client.close()
Testing our first Python SDN component
Now that we have our driver, we can test it. Right now we haven’t developed thevty module, so we need to try the driver itself. To do that, we need a device that will accept Telnet connections. Why not a GNS3 device? If you need help in setting it up, read our GNS3 Guide. If you don’t have the time for that, don’t worry. You can telnet on any website on port 80, like we are doing in this example.
Then, we can write a script that looks like this.
from sdncore.vty.drivers.telnet import TelnetDriver
td = TelnetDriver('ictshore.com', port=80)
td.open()
td.send_text('GET /\n')
print(td.read_eof())
td.close()
\n. This means hitting enter in the terminal, telling the device that we finished writing a command. Without that, the device will wait for some input but since no more is coming, it will eventually time out.
Comments
Post a Comment