class SSHDetect(object):
"""
The SSHDetect class tries to automatically guess the device type running on the SSH remote end.
Be careful that the kwargs 'device_type' must be set to 'autodetect', otherwise it won't work at
all.
Parameters
----------
*args : list
The same *args that you might provide to the netmiko.ssh_dispatcher.ConnectHandler.
*kwargs : dict
The same *kwargs that you might provide to the netmiko.ssh_dispatcher.ConnectHandler.
Attributes
----------
connection : netmiko.terminal_server.TerminalServer
A basic connection to the remote SSH end.
potential_matches: dict
Dict of (device_type, accuracy) that is populated through an interaction with the
remote end.
Methods
-------
autodetect()
Try to determine the device type.
"""
def __init__(self, *args, **kwargs):
"""
Constructor of the SSHDetect class
"""
if kwargs["device_type"] != "autodetect":
raise ValueError("The connection device_type must be 'autodetect'")
self.connection = ConnectHandler(*args, **kwargs)
# Call the _test_channel_read() in base to clear initial data
output = BaseConnection._test_channel_read(self.connection)
self.initial_buffer = output
self.potential_matches = {}
self._results_cache = {}
def autodetect(self):
"""
Try to guess the best 'device_type' based on patterns defined in SSH_MAPPER_BASE
Returns
-------
best_match : str or None
The device type that is currently the best to use to interact with the device
"""
for device_type, autodetect_dict in SSH_MAPPER_BASE.items():
tmp_dict = autodetect_dict.copy()
call_method = tmp_dict.pop("dispatch")
autodetect_method = getattr(self, call_method)
accuracy = autodetect_method(**tmp_dict)
if accuracy:
self.potential_matches[device_type] = accuracy
if accuracy >= 99: # Stop the loop as we are sure of our match
best_match = sorted(self.potential_matches.items(), key=lambda t: t[1],
reverse=True)
self.connection.disconnect()
return best_match[0][0]
if not self.potential_matches:
self.connection.disconnect()
return None
best_match = sorted(self.potential_matches.items(), key=lambda t: t[1], reverse=True)
self.connection.disconnect()
return best_match[0][0]
def _send_command(self, cmd=""):
"""
Handle reading/writing channel directly. It is also sanitizing the output received.
Parameters
----------
cmd : str, optional
The command to send to the remote device (default : "", just send a new line)
Returns
-------
output : str
The output from the command sent
"""
self.connection.write_channel(cmd + "\n")
time.sleep(1)
output = self.connection._read_channel_timing()
output = self.connection.strip_ansi_escape_codes(output)
output = self.connection.strip_backspaces(output)
return output
def _send_command_wrapper(self, cmd):
"""
Send command to the remote device with a caching feature to avoid sending the same command
twice based on the SSH_MAPPER_BASE dict cmd key.
Parameters
----------
cmd : str
The command to send to the remote device after checking cache.
Returns
-------
response : str
The response from the remote device.
"""
cached_results = self._results_cache.get(cmd)
if not cached_results:
response = self._send_command(cmd)
self._results_cache[cmd] = response
return response
else:
return cached_results
def _autodetect_std(self, cmd="", search_patterns=None, re_flags=re.I, priority=99):
"""
Standard method to try to auto-detect the device type. This method will be called for each
device_type present in SSH_MAPPER_BASE dict ('dispatch' key). It will attempt to send a
command and match some regular expression from the ouput for each entry in SSH_MAPPER_BASE
('cmd' and 'search_pattern' keys).
Parameters
----------
cmd : str
The command to send to the remote device after checking cache.
search_patterns : list
A list of regular expression to look for in the command's output (default: None).
re_flags: re.flags, optional
Any flags from the python re module to modify the regular expression (default: re.I).
priority: int, optional
The confidence the match is right between 0 and 99 (default: 99).
"""
invalid_responses = [
r'% Invalid input detected',
r'syntax error, expecting',
r'Error: Unrecognized command',
r'%Error'
]
if not cmd or not search_patterns:
return 0
try:
response = self._send_command_wrapper(cmd)
# Look for error conditions in output
for pattern in invalid_responses:
match = re.search(pattern, response, flags=re.I)
if match:
return 0
for pattern in search_patterns:
match = re.search(pattern, response, flags=re_flags)
if match:
return priority
except Exception:
return 0
return 0
class SSHDetect(object):
"""
The SSHDetect class tries to automatically guess the device type running on the SSH remote end.
Be careful that the kwargs 'device_type' must be set to 'autodetect', otherwise it won't work at
all.
Parameters
----------
*args : list
The same *args that you might provide to the netmiko.ssh_dispatcher.ConnectHandler.
*kwargs : dict
The same *kwargs that you might provide to the netmiko.ssh_dispatcher.ConnectHandler.
Attributes
----------
connection : netmiko.terminal_server.TerminalServerSSH
A basic connection to the remote SSH end.
potential_matches: dict
Dict of (device_type, accuracy) that is populated through an interaction with the
remote end.
Methods
-------
autodetect()
Try to determine the device type.
"""
def __init__(self, *args: Any, **kwargs: Any) -> None:
"""
Constructor of the SSHDetect class
"""
if kwargs["device_type"] != "autodetect":
raise ValueError("The connection device_type must be 'autodetect'")
# Always set cmd_verify to False for autodetect
kwargs["global_cmd_verify"] = False
self.connection = ConnectHandler(*args, **kwargs)
# Call the _test_channel_read() in base to clear initial data
output = BaseConnection._test_channel_read(self.connection)
self.initial_buffer = output
self.potential_matches: Dict[str, int] = {}
self._results_cache: Dict[str, str] = {}
def autodetect(self) -> Union[str, None]:
"""
Try to guess the best 'device_type' based on patterns defined in SSH_MAPPER_BASE
Returns
-------
best_match : str or None
The device type that is currently the best to use to interact with the device
"""
for device_type, autodetect_dict in SSH_MAPPER_BASE:
tmp_dict = autodetect_dict.copy()
call_method = tmp_dict.pop("dispatch")
assert isinstance(call_method, str)
autodetect_method = getattr(self, call_method)
accuracy = autodetect_method(**tmp_dict)
if accuracy:
self.potential_matches[device_type] = accuracy
if accuracy >= 99: # Stop the loop as we are sure of our match
best_match = sorted(self.potential_matches.items(),
key=lambda t: t[1],
reverse=True)
# WLC needs two different auto-dectect solutions
if "cisco_wlc_85" in best_match[0]:
best_match[0] = ("cisco_wlc", 99)
self.connection.disconnect()
return best_match[0][0]
if not self.potential_matches:
self.connection.disconnect()
return None
best_match = sorted(self.potential_matches.items(),
key=lambda t: t[1],
reverse=True)
self.connection.disconnect()
return best_match[0][0]
def _send_command(self, cmd: str = "") -> str:
"""
Handle reading/writing channel directly. It is also sanitizing the output received.
Parameters
----------
cmd : str, optional
The command to send to the remote device (default : "", just send a new line)
Returns
-------
output : str
The output from the command sent
"""
self.connection.write_channel(cmd + "\n")
time.sleep(1)
output = self.connection.read_channel_timing()
output = self.connection.strip_backspaces(output)
return output
def _send_command_wrapper(self, cmd: str) -> str:
"""
Send command to the remote device with a caching feature to avoid sending the same command
twice based on the SSH_MAPPER_BASE dict cmd key.
Parameters
----------
cmd : str
The command to send to the remote device after checking cache.
Returns
-------
response : str
The response from the remote device.
"""
cached_results = self._results_cache.get(cmd)
if not cached_results:
response = self._send_command(cmd)
self._results_cache[cmd] = response
return response
else:
return cached_results
def _autodetect_remote_version(self,
search_patterns: Optional[List[str]] = None,
re_flags: int = re.IGNORECASE,
priority: int = 99,
**kwargs: Any) -> int:
"""
Method to try auto-detect the device type, by matching a regular expression on the reported
remote version of the SSH server.
Parameters
----------
search_patterns : list
A list of regular expression to look for in the reported remote SSH version
(default: None).
re_flags: re.flags, optional
Any flags from the python re module to modify the regular expression (default: re.I).
priority: int, optional
The confidence the match is right between 0 and 99 (default: 99).
"""
invalid_responses = [r"^$"]
if not search_patterns:
return 0
try:
remote_conn = self.connection.remote_conn
assert isinstance(remote_conn, paramiko.Channel)
assert remote_conn.transport is not None
remote_version = remote_conn.transport.remote_version
for pattern in invalid_responses:
match = re.search(pattern, remote_version, flags=re.I)
if match:
return 0
for pattern in search_patterns:
match = re.search(pattern, remote_version, flags=re_flags)
if match:
return priority
except Exception:
return 0
return 0
def _autodetect_std(
self,
cmd: str = "",
search_patterns: Optional[List[str]] = None,
re_flags: int = re.IGNORECASE,
priority: int = 99,
) -> int:
"""
Standard method to try to auto-detect the device type. This method will be called for each
device_type present in SSH_MAPPER_BASE dict ('dispatch' key). It will attempt to send a
command and match some regular expression from the ouput for each entry in SSH_MAPPER_BASE
('cmd' and 'search_pattern' keys).
Parameters
----------
cmd : str
The command to send to the remote device after checking cache.
search_patterns : list
A list of regular expression to look for in the command's output (default: None).
re_flags: re.flags, optional
Any flags from the python re module to modify the regular expression (default: re.I).
priority: int, optional
The confidence the match is right between 0 and 99 (default: 99).
"""
invalid_responses = [
r"% Invalid input detected",
r"syntax error, expecting",
r"Error: Unrecognized command",
r"%Error",
r"command not found",
r"Syntax Error: unexpected argument",
r"% Unrecognized command found at",
]
if not cmd or not search_patterns:
return 0
try:
# _send_command_wrapper will use already cached results if available
response = self._send_command_wrapper(cmd)
# Look for error conditions in output
for pattern in invalid_responses:
match = re.search(pattern, response, flags=re.I)
if match:
return 0
for pattern in search_patterns:
match = re.search(pattern, response, flags=re_flags)
if match:
return priority
except Exception:
return 0
return 0
