def general_result(): task_name = "napalm_ping" confirmation_result = create_result(result_content="All pings executed") timeouted = create_result( TIMEOUT_MESSAGE, host="R3", destination=IP_6, failed=True, exception=ConnectionException(f"Cannot connect to {IP_6}"), ) general_result = AggregatedResult(task_name) general_result["R1"] = create_multi_result( results=[ confirmation_result, ping_r1_1.create_nornir_result(), ping_r1_2.create_nornir_result(), ], task_name=task_name, ) general_result["R2"] = create_multi_result( results=[confirmation_result, ping_r2.create_nornir_result()], task_name=task_name, ) general_result["R3"] = create_multi_result( results=[ confirmation_result, ping_r3.create_nornir_result(), timeouted ], task_name=task_name, ) return general_result
def send_command_non_blocking(self, command, timeout=60, throw_exception=True): logging.debug('Executing commands:\n %s' % command) if not self.ssh: raise ConnectionException('Device not open') stdin, stdout, stderr = self.ssh.exec_command(command, timeout=timeout) output = ''.join(stdout.readlines()) error = ''.join(stderr.readlines()) if len(error) > 0: msg = '%s:%s' % (command, error) logging.debug('error:' + msg) if throw_exception: raise CommandErrorException(msg) regex = re.compile('ERROR:') if len(regex.findall(output)) > 0: msg = '%s:%s' % (command, output) logging.debug('error:' + msg) if throw_exception: raise CommandErrorException(msg) return output[:-1], error[:-1] # Remove last newline charater.
def open(self): """Implementation of NAPALM method open.""" if self.transport not in TRANSPORTS: raise TypeError('invalid transport specified') klass = TRANSPORTS[self.transport] try: connection = klass( self.hostname, port=self.port, path=self.path, username=self.username, password=self.password, timeout=self.timeout, ) if self.device is None: self.device = EapiNode(connection, enablepwd=self.enablepwd) sw_version = self.device.run_commands(['show version'])[0].get( 'softwareImageVersion', "0.0.0") if LooseVersion(sw_version) < LooseVersion("0.14.1"): raise NotImplementedError( "MOS Software Version 0.14.1 or better required") # This is to get around user mismatch in API/FileCopy if self._ssh is None: self._ssh = ConnectHandler(device_type='cisco_ios', ip=self.hostname, username=self.username, password=self.password) self._ssh.enable() except ConnectionError as ce: raise ConnectionException(ce.message)
def timeouted_multiresult(): task_name = "failed_task" r = create_result( TIMEOUT_MESSAGE, failed=True, exception=ConnectionException("Cannot connect to 1.2.3.4"), ) return create_multi_result([r], task_name=task_name)
def open(self): """Open a connection to the device.""" try: if self.transport == 'ssh': device_type = 'huawei' else: raise ConnectionException("Unknown transport: {}".format(self.transport)) self.device = ConnectHandler(device_type=device_type, host=self.hostname, username=self.username, password=self.password, **self.netmiko_optional_args) # self.device.enable() except NetMikoTimeoutException: raise ConnectionException('Cannot connect to {}'.format(self.hostname))
def open(self): try: self.api = connect(host=self.hostname, username=self.username, password=self.password, timeout=self.timeout) except (TrapError, FatalError, ConnectionError, MultiTrapError) as exc: raise ConnectionException( 'Could not connect to {}:{} - [{!r}]'.format( self.hostname, self.port, exc))
def close(self): """Mark the connection to the device as closed.""" delete_result, code = self._delete_token() if delete_result: self.up = False return True else: raise ConnectionException('Cannot connect to {}. Error {}'.format( self.hostname, code))
def open(self): try: self.device = ConnectHandler( device_type="linux", host=self.hostname, username=self.username, password=self.password, **self.netmiko_optional_args ) except NetMikoTimeoutException: raise ConnectionException("Cannot connect to {}".format(self.hostname))
def open(self): self.device = ConnectHandler(device_type='vyos', host=self.hostname, username=self.username, password=self.password, **self.netmiko_optional_args) try: self._scp_client = SCPConn(self.device) except: raise ConnectionException("Failed to open connection ")
def open(self): try: if self.api_key: self.device = pan.xapi.PanXapi(hostname=self.hostname, api_key=self.api_key) else: self.device = pan.xapi.PanXapi(hostname=self.hostname, api_username=self.username, api_password=self.password) except ConnectionException as e: raise ConnectionException(str(e))
def _open_ssh(self): try: self.ssh_device = ConnectHandler(device_type='paloalto_panos', ip=self.hostname, username=self.username, password=self.password, **self.netmiko_optional_args) except ConnectionException as e: raise ConnectionException(str(e)) self.ssh_connection = True
def _send_command(self, command): try: if isinstance(command, list): for cmd in command: output = self.device.send_command(cmd) if "% Invalid" not in output: break else: output = self.device.send_command(command) return output except (socket.error, EOFError) as e: raise ConnectionException(str(e))
def open(self): """ Implementation of NAPALM method 'open' to open a connection to the device. """ try: self.session_info = dict(s=pyaoscx.session.login( self.base_url, self.username, self.password), url=self.base_url) self.isAlive = True except ConnectionError as error: # Raised if device not available or HTTPS REST is not enabled raise ConnectionException(str(error))
def open(self): """Implementation of NAPALM method open.""" try: self.device = EXOS(hostname=self.hostname, username=self.username, password=self.password, port=self.port, timeout=self.timeout) self.device.open() except Exception: raise ConnectionException("Unable to connect to {0}".format( self.hostname))
def open(self): try: self.device = NXOSDevice(host=self.hostname, username=self.username, password=self.password, timeout=self.timeout, port=self.port, transport=self.transport, verify=self.ssl_verify, api_format="jsonrpc") self._send_command('show hostname') except (NXAPIConnectionError, NXAPIAuthError): # unable to open connection raise ConnectionException('Cannot connect to {}'.format(self.hostname))
def open(self): try: self.device = NXOSDevice(self.hostname, self.username, self.password, timeout=self.timeout, port=self.port, transport=self.transport) self.device.show('show hostname') self.up = True except (CLIError, ValueError): # unable to open connection raise ConnectionException('Cannot connect to {}'.format( self.hostname))
def open(self): """Connect with the device.""" try: self.device = ConnectHandler( device_type="cisco_ios_telnet", ip=self.hostname, port=self.port, username=self.username, password=self.password, timeout=self.timeout, verbose=True, ) except Exception: raise ConnectionException( "Cannot connect to switch: %s:%s" % (self.hostname, self.port) )
def open(self): """ Open a connection to the device. This method can be used to verify if the device is reachable and credentials are valid before moving on to other, more complex, requests. """ auth_result, code = self._authenticate() if auth_result: self.up = True return True else: self.up = False raise ConnectionException('Cannot connect to {}. Error {}'.format( self.hostname, code))
def delete_token(self): """Delete auth token.""" full_url = self.base_url + "/tokenservices/{}".format(self.token) try: token_delete_request = self.session.delete(full_url, auth=(self.username, self.password), timeout=self.timeout, verify=False) if token_delete_request.status_code is 204: self.session.headers.pop('X-Auth-Token', None) return (True, None) else: return (False, token_delete_request.status_code) except requests.exceptions.RequestException as e: raise ConnectionException(py23_compat.text_type(e))
def open(self): method = self.optional_args.get('login_method', 'plain') method = getattr(librouteros.login, method) try: self.api = connect( host=self.hostname, username=self.username, password=self.password, port=self.port, timeout=self.timeout, login_method=method, ssl_wrapper=self.ssl_wrapper, ) except (TrapError, FatalError, socket.timeout, socket.error, MultiTrapError) as exc: # pylint: disable=raise-missing-from raise ConnectionException(f"Could not connect to {self.hostname}:{self.port} - [{exc!r}]")
def send_command_std(self, command, timeout=60, throw_exception=True): logging.debug('Executing commands:\n %s' % command) if not self.ssh: raise ConnectionException('Device not open') chan = self.ssh.get_transport().open_session() chan.settimeout(timeout) chan.exec_command(command) retcode = chan.recv_exit_status() logging.debug('Command exited with code %d' % retcode) error_chan = chan.makefile_stderr() output_chan = chan.makefile() error = '' output = '' for e in error_chan.read(): error = error + self._read_wrapper(e) logging.debug("stderr: " + error) for o in output_chan.read(): output = output + self._read_wrapper(o) logging.debug("stdout: " + output) # Ignore stty error happen in some devices if "stty: standard input: Inappropriate ioctl for device" in error: error = error.replace( 'stty: standard input: Inappropriate ioctl for device\n', '') if len(error) > 0 and retcode != 0: msg = '%s:%s' % (command, error) logging.debug('error:' + msg) if throw_exception: raise CommandErrorException(msg) regex = re.compile('ERROR:') if len(regex.findall(output)) > 0: msg = '%s:%s' % (command, output) logging.debug('error:' + msg) if throw_exception: raise CommandErrorException(msg) return output[:-1], error[: -1], retcode # Remove last newline charater.
def open(self): """Establish connection with the network device.""" log.debug( "Establishing the connection over gRPC as %s@%s:%d", self.username, self.hostname, self.port, ) kwargs = {} if self.tls_key and self.tls_server_name: kwargs = {"creds": self.tls_key, "options": self.tls_server_name} self.driver = CiscoGRPCClient(self.hostname, self.port, self.timeout, self.username, self.password, **kwargs) log.debug('Executing "show clock" to check the connection') try: self._execute("showcmdtextoutput", "show clock", format="text") except NapalmException as err: raise ConnectionException(err)
def open(self): """Open a connection to the device.""" try: device_type = 'cisco_ios' if self.transport == "telnet": device_type = "cisco_ios_telnet" self.device = ConnectHandler(device_type=device_type, host=self.hostname, username=self.username, password=self.password, **self.netmiko_optional_args) self.default_clipaging_status = self._get_clipaging_status() if self.disable_paging and self.default_clipaging_status == 'enable': self.device.disable_paging(command="disable clipaging") except NetMikoTimeoutException: raise ConnectionException('Cannot connect to {}'.format(self.hostname))
def open(self): """Implementation of NAPALM method open.""" try: connection = self.transport_class(host=self.hostname, username=self.username, password=self.password, timeout=self.timeout, **self.eapi_kwargs) if self.device is None: self.device = EapiNode(connection, enablepwd=self.enablepwd) sw_version = self.device.run_commands(["show version"])[0].get( "softwareImageVersion", "0.0.0") if LooseVersion(sw_version) < LooseVersion("0.17.9"): raise NotImplementedError( "MOS Software Version 0.17.9 or better required") self._version = LooseVersion(sw_version) except ConnectionError as ce: raise ConnectionException(ce.message)
def open(self): """Implement the NAPALM method open (mandatory)""" try: device_type = "cisco_ios" #if self.transport == "telnet": # device_type = "hios_telnet" self.device = ConnectHandler( device_type=device_type, host=self.hostname, username=self.username, password=self.password, session_log="log", **self.netmiko_optional_args ) # ensure in enable mode self.device.enable() except Exception: raise ConnectionException("Cannot connect to switch: %s:%s" % (self.hostname, self.port))
def get_resp(self, endpoint="", data=None, params={}, throw=True, returnObject=False): """Get response from device and returne parsed json.""" full_url = self.base_url + endpoint f = None try: if data is not None: f = self.session.post(full_url, data=data, auth=(self.username, self.password), headers=self.headers, timeout=self.timeout, params=params, verify=False) else: f = self.session.get(full_url, auth=(self.username, self.password), headers=self.headers, timeout=self.timeout, params=params, verify=False) if (f.status_code != 200): if throw: errMsg = "Operation returned an error: {}".format( f.status_code) raise CommandErrorException(errMsg) else: return False if returnObject: return f else: return f.text except requests.exceptions.RequestException as e: if throw: raise ConnectionException(py23_compat.text_type(e)) else: return False
def get_auth_token(self): """ Authenticate with user and password to get an auth token.""" full_url = self.base_url + "/tokenservices" try: token_request = self.session.post(full_url, auth=(self.username, self.password), data="", timeout=self.timeout, verify=False) if token_request.status_code is 204 and 'X-Auth-Token' in token_request.headers.keys( ): self.token = token_request.headers['X-Auth-Token'] self.session.headers.update( {'X-Auth-Token': token_request.headers['X-Auth-Token']}) return (True, None) else: return (False, token_request.status_code) except requests.exceptions.RequestException as e: raise ConnectionException(py23_compat.text_type(e))
def _process_optional_args(self, optional_args): self.enablepwd = optional_args.pop("enable_password", "") self.config_timeout = optional_args.pop("config_timeout", 300) transport = optional_args.get( "transport", optional_args.get("eos_transport", "https")) try: self.transport_class = pyeapi.client.TRANSPORTS[transport] except KeyError: raise ConnectionException("Unknown transport: {}".format( self.transport)) init_args = inspect.getfullargspec(self.transport_class.__init__)[0] init_args.pop(0) # Remove "self" init_args.append( "enforce_verification") # Not an arg for unknown reason filter_args = ["host", "username", "password", "timeout"] self.eapi_kwargs = { k: v for k, v in optional_args.items() if k in init_args and k not in filter_args }
def open(self): """ Opens a connection to the device. """ try: self.device = ConnectHandler( device_type='ruckus_fastiron', ip=self.hostname, # saves device parameters port=self.port, username=self.username, password=self.password, timeout=self.timeout, verbose=True) self.device.session_preparation() # image_type = self.device.send_command("show version") # find the image type # if image_type.find("SPS") != -1: # self.image_type = "Switch" # else: # self.image_type = "Router" except Exception: raise ConnectionException("Cannot connect to switch: %s:%s" % (self.hostname, self.port))
def get_resp(self, endpoint="", data=None): """Get response from device and returne parsed json.""" full_url = self.base_url + endpoint f = None try: if data is not None: f = self.session.post(full_url, data=data, headers=self.headers, timeout=self.timeout, verify=False) else: f = self.session.get(full_url, headers=self.headers, timeout=self.timeout, verify=False) if (f.status_code != 200): raise CommandErrorException( "Operation returned an error: {}".format(f.status_code)) return f.json() except requests.exceptions.RequestException as e: raise ConnectionException(py23_compat.text_type(e))