Refactoring the code

[selfuryon]

Hello!
I want to make the module refactoring.

The first thing I want to separate the connection and the class which knows how to work with device.
The second thing I want to use the Strategy pattern instead of Inheritance due to lack of isolation.

Common class structure:

• IOConnection as an interface for working for a particular connection
  • As examples of a particular connection are SSHConnection and Telnet Connection
• DeviceStream adds some logic to basic IOConnection: it understands the end of the output: it recognizes the prompt
• LayerManager manages all levels of layers or terminal modes
• Layer is an entity for working with a particular layer or terminal mode
• Particular set of device type classes (like CiscoIOS, JuniperJunOS) for working with devices. They contain a set of strategy class instances

Try to show the concept of these changes.

Public factory method:

# Public Factory function for creating netdev classes
def create(device_type, connection_type, *args, **kwargs):
	# Create IOConnection separately
	if connection_type == "ssh":
		IOConnection = SSHConnectiom(*args, **kwargs) # As Example for SSHConnection

	# Create DeviceStream and all needed instances for a particular device
	device_stream = DeviceStream(IOConnection)

	# Create Device separately
	if device_type == "cisco_ios":
		layer_manager = LayerManager(device_stream, cisco_checker)
			.add_layer(UserExecMode())
			.add_layer(PrivilegeExecMode())
			.add_layer(ConfigMode())
		return Cisco_IOS(layer_manager)

IOConnection is an abstract class with a public interface which can be used by all particular device type classes.

class IOConnection(abc.ABC):
    """ Abstract IO Connection class"""

    async def connect(self):
        """ Establish Connection """
        pass

    async def disconnect(self):
        pass

    def send(self, cmd):
        """ Send command to stream """
        pass

    async def read(self):
        """ Read from stream """
        pass

IOConnection can be implemented in SSHConnection, TelnetConnection and SerialConnection.

DeviceStream adds some logic to IOConnection. It understands the end of the output for commands: it understands the prompt

class DeviceStream():
	""" Class which know how to work with the device in a stream mode """

	def __init__ (self, IOConnection, prompt_pattern = r"", ):
		self._conn = IOConnection
		self._prompt_pattern = prompt_pattern

	async def send(self, cmd_list):
		pass

	async def read_until(self, pattern, re_flags, until_prompt=True):
		pass

Device type classes are particular classes for working with network devices.

class CiscoIOS():
	""" Abstract Device type"""

	def __init__ (device_stream, layer_manager):
		self._device_stream = device_stream
		self._layer_manager = layer_manager


	async def send_command(self, cmd_list, terminal_mode):
		""" Go to specific terminal mode and run list of commands in there"""
		self._layer_manager.switch_to_layer(terminal_mode)
		self.device_stream(cmd_list)

	async def send_config_set(self, cmd_list):
		""" Go to configuration mode and run list of commands in there"""
		self._layer_manager.switch_to_layer('config_mode')
		self.device_stream(cmd_list)
		self._layer_manager.switch_to_layer('privilege exec')

We have universal class LayerManager for working with terminal modes:

class LayerManager():

    def __init__(self, device_stream, checker_closure):
    	self._device_stream = device_stream
    	self._checker_closure = checker_closure
    	self._current_layer = None

    def add_layer(layer):
    	self._layers[layer.name] = layer
    	return self

    def switch_to_layer(layer_name):
    	if self._current_layer is None:
    		self._current_layer = self.checker_closure()
    	if self._current_layer == layer_name:
    		return
    	# switching to layer

    def commit_transaction():
    	layer = get_layer(self._current_layer)
    	if layer.transactional:
    		layer.committer()

    def get_layer(layer_name):
    	pass

Specific function for checking the cisco like terminal modes:

def cisco_checker(device_stream):
	if ')#':
		return 'config'
	elif '#':
		return 'privilege'
	elif '>':
		return 'user_exec'
	else:
		raise Exeption()

We have universal class Layer for working with particular layer/terminal mode:

class Layer():

	def __init__(name, device_stream, enter, exit, transactional=False, commiter=None):
		self._name = name 
		self._device_stream = device_stream
		self._enter_closure = enter
		self._exit_closure = exit
		self._committer_closure = committer
		self.transactional = transactional

	async def enter(cmd):
		pass

	async def exit(cmd):
		pass

	@atribute
	def get_name():
		return self._name

And cisco like layers:

class ConfigMode(Layer):

	def __init__(name, device_stream, enter, exit, transactional=False, commiter=None):
		super().__init()

	async def enter(cmd='conf t'):
		self._device_stream.send_command(cmd)

	async def exit(cmd='end'):
		self._device_stream.send_command(cmd)

	@atribute
	def get_name():
		return self._name