def setUp(self, mock_connect): mock_connect.side_effect = self._mock_manager self.dev = Device(host='1.1.1.1', user='******', password='******', gather_facts=False) self.dev.open() self.rpc = _RpcMetaExec(self.dev)
def setUp(self, mock_connect): mock_connect.side_effect = self._mock_manager self.dev = Device(host="1.1.1.1", user="******", password="******", gather_facts=False) self.dev.open() self.rpc = _RpcMetaExec(self.dev)
def __init__(self, *vargs, **kvargs): """ vargs[0] -- ALTERNATIVE for kvargs['host'] kvargs['host'] -- REQUIRED device hostname or ipaddress kvargs['user'] -- OPTIONAL login user-name, uses $USER if not provided kvargs['password'] -- OPTIONAL kvargs['passwd'] -- OPTIONAL login password. if not provided, assumed ssh-keys are enforced kvargs['port'] -- OPTIONAL device login port (defaults to 830) kvargs['gather_facts'] -- optional if :False: then the facts are not gathered on call to :open(): """ # private attributes try: self._hostname = vargs[0] if len(vargs) else kvargs['host'] except: raise ValueError("You must provide the 'host' value") self._port = kvargs.get('port', 830) # user will default to $USER self._auth_user = os.getenv('USER') # user can get updated by ssh_config self._sshconf_lkup() # but if user is explit from call, then use it. self._auth_user = kvargs.get('user') or self._auth_user self._auth_password = kvargs.get('password') or kvargs.get('passwd') self._gather_facts = kvargs.get('gather_facts', True) self._conn = None self._j2ldr = _Jinja2ldr self._manages = [] self._facts = {} # public attributes self.connected = False self.rpc = _RpcMetaExec(self)
def __init__(self, *vargs, **kvargs): """ Device object constructor. :param str vargs[0]: host-name or ipaddress. This is an alternative for **host** :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses $USER if not provided :param str passwd: *OPTIONAL* if not provided, assumed ssh-keys are enforced :param int port: *OPTIONAL* NETCONF port (defaults to 830) :param bool gather_facts: *OPTIONAL* For ssh mode default is ``True``. In case of console connection over telnet/serial it defaults to ``False``. If ``False`` and old-style fact gathering is in use then facts are not gathered on call to :meth:`open`. This argument is a no-op when new-style fact gathering is in use (the default.) :param str fact_style: *OPTIONAL* The style of fact gathering to use. Valid values are: 'new', 'old', or 'both'. The default is 'new'. The value 'both' is only present for debugging purposes. It will be removed in a future release. The value 'old' is only present to workaround bugs in new-style fact gathering. It will be removed in a future release. :param str mode: *OPTIONAL* mode, mode for console connection (telnet/serial) :param int baud: *OPTIONAL* baud, Used during serial console mode, default baud rate is 9600 :param int attempts: *OPTIONAL* attempts, for console connection. default is 10 :param bool auto_probe: *OPTIONAL* if non-zero then this enables auto_probe at time of :meth:`open` and defines the amount of time(sec) for the probe timeout :param str ssh_private_key_file: *OPTIONAL* The path to the SSH private key file. This can be used if you need to provide a private key rather than loading the key into the ssh-key-ring/environment. if your ssh-key requires a password, then you must provide it via **passwd** :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried. :param bool normalize: *OPTIONAL* default is ``False``. If ``True`` then the XML returned by :meth:`execute` will have whitespace normalized """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- hostname = vargs[0] if len(vargs) else kvargs.get('host') self._port = kvargs.get('port', 830) self._gather_facts = kvargs.get('gather_facts', True) self._normalize = kvargs.get('normalize', False) self._auto_probe = kvargs.get('auto_probe', self.__class__.auto_probe) self._fact_style = kvargs.get('fact_style', 'new') if self._fact_style != 'new': warnings.warn('fact-style %s will be removed in a future ' 'release.' % (self._fact_style), RuntimeWarning) if self.__class__.ON_JUNOS is True and hostname is None: # --------------------------------- # running on a Junos device locally # --------------------------------- self._auth_user = None self._auth_password = None self._hostname = 'localhost' self._ssh_private_key_file = None self._ssh_config = None else: # -------------------------- # making a remote connection # -------------------------- if hostname is None: raise ValueError("You must provide the 'host' value") self._hostname = hostname # user will default to $USER self._auth_user = os.getenv('USER') self._conf_auth_user = None self._conf_ssh_private_key_file = None # user can get updated by ssh_config self._ssh_config = kvargs.get('ssh_config') self._sshconf_lkup() # but if user or private key is explicit from call, then use it. self._auth_user = kvargs.get('user') or self._conf_auth_user or \ self._auth_user self._ssh_private_key_file = kvargs.get('ssh_private_key_file') \ or self._conf_ssh_private_key_file self._auth_password = kvargs.get( 'password') or kvargs.get('passwd') # ----------------------------- # initialize instance variables # ------------------------------ self._conn = None self._j2ldr = _Jinja2ldr self._manages = [] self._ofacts = {} # public attributes self.connected = False self.rpc = _RpcMetaExec(self) if self._fact_style == 'old': self.facts = self.ofacts else: self.facts = _FactCache(self)
def setUp(self): self.dev = Device(host='1.1.1.1') self.rpc = _RpcMetaExec(self.dev)
def __init__(self, **kvargs): """ NoobDevice object constructor. :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses root if not provided :param str passwd: *OPTIONAL* in console connection for device at zeroized state password is not required :param int port: *OPTIONAL* port, default is telnet port `23` :param int baud: *OPTIONAL* baud, default baud rate is 9600 :param str mode: *OPTIONAL* mode, mode of connection (telnet/serial/ssh) default is telnet :param int timeout: *OPTIONAL* timeout, default is 0.5 :param int attempts: *OPTIONAL* attempts, default is 10 :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried it will be used by SCP class. So its assumed ssh is enabled by the time we use SCP functionality. :param bool gather_facts: *OPTIONAL* default is ``False``. If ``False`` then the facts are not gathered on call to :meth:`open` """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- self._tty = None self._facts = {} self.connected = False self._skip_logout = False self.results = dict(changed=False, failed=False, errmsg=None) # hostname is not required in serial mode connection self._hostname = kvargs.get('host') self._auth_user = kvargs.get('user', 'root') self._auth_password = kvargs.get( 'password', '') or kvargs.get( 'passwd', '') self._port = kvargs.get('port', '23') self._baud = kvargs.get('baud', '9600') self._mode = kvargs.get('mode', 'telnet') self._timeout = kvargs.get('timeout', '0.5') # self.timeout needed by PyEZ utils self.timeout = self._timeout self._attempts = kvargs.get('attempts', 10) self.gather_facts = kvargs.get('gather_facts', False) self.rpc = _RpcMetaExec(self) from jnpr.junos import Device if sys.version < '3': self.cli = lambda cmd, format='text', warning=True: \ Device.cli.im_func(self, cmd, format, warning) self._sshconf_path = lambda: Device._sshconf_lkup.im_func(self) self.facts_refresh = lambda exception_on_failure=False: \ Device.facts_refresh.im_func(self, exception_on_failure) else: self.cli = lambda cmd, format='text', warning=True: \ Device.cli(self, cmd, format, warning) self._sshconf_path = lambda: Device._sshconf_lkup(self) self.facts_refresh = lambda exception_on_failure=False: \ Device.facts_refresh(self, exception_on_failure) self._ssh_config = kvargs.get('ssh_config')
def __init__(self, *vargs, **kvargs): """ Device object constructor. :param str vargs[0]: host-name or ipaddress. This is an alternative for **host** :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses $USER if not provided :param str passwd: *OPTIONAL* if not provided, assumed ssh-keys are enforced :param int port: *OPTIONAL* NETCONF port (defaults to 830) :param bool gather_facts: *OPTIONAL* default is ``True``. If ``False`` then the facts are not gathered on call to :meth:`open` :param bool auto_probe: *OPTIONAL* if non-zero then this enables auto_probe at time of :meth:`open` and defines the amount of time(sec) for the probe timeout :param str ssh_private_key_file: *OPTIONAL* The path to the SSH private key file. This can be used if you need to provide a private key rather than loading the key into the ssh-key-ring/environment. if your ssh-key requires a password, then you must provide it via **passwd** """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- hostname = vargs[0] if len(vargs) else kvargs.get('host') self._port = kvargs.get('port', 830) self._gather_facts = kvargs.get('gather_facts', True) self._auto_probe = kvargs.get('auto_probe', self.__class__.auto_probe) if self.__class__.ON_JUNOS is True and hostname is None: # --------------------------------- # running on a Junos device locally # --------------------------------- self._auth_user = None self._auth_password = None self._hostname = 'localhost' else: # -------------------------- # making a remote connection # -------------------------- if hostname is None: raise ValueError("You must provide the 'host' value") self._hostname = hostname # user will default to $USER self._auth_user = os.getenv('USER') # user can get updated by ssh_config self._sshconf_lkup() # but if user is explit from call, then use it. self._auth_user = kvargs.get('user') or self._auth_user self._auth_password = kvargs.get('password') or kvargs.get( 'passwd') if not hasattr(self, '_ssh_private_key_file'): self._ssh_private_key_file = kvargs.get('ssh_private_key_file') # ----------------------------- # initialize instance variables # ------------------------------ self._conn = None self._j2ldr = _Jinja2ldr self._manages = [] self._facts = {} # public attributes self.connected = False self.rpc = _RpcMetaExec(self)
def __init__(self, **kvargs): """ NoobDevice object constructor. :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses root if not provided :param str passwd: *OPTIONAL* in console connection for device at zeroized state password is not required :param int port: *OPTIONAL* port, defaults to '23' for telnet mode and '/dev/ttyUSB0' for serial. :param int baud: *OPTIONAL* baud, default baud rate is 9600 :param str mode: *OPTIONAL* mode, mode of connection (telnet/serial) default is telnet :param int timeout: *OPTIONAL* timeout, default is 0.5 :param int attempts: *OPTIONAL* attempts, default is 10 :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried it will be used by SCP class. So its assumed ssh is enabled by the time we use SCP functionality. :param bool gather_facts: *OPTIONAL* Defaults to ``False``. If ``False`` and old-style fact gathering is in use then facts are not gathered on call to :meth:`open`. This argument is a no-op when new-style fact gathering is in use (the default.) :param str fact_style: *OPTIONAL* The style of fact gathering to use. Valid values are: 'new', 'old', or 'both'. The default is 'new'. The value 'both' is only present for debugging purposes. It will be removed in a future release. The value 'old' is only present to workaround bugs in new-style fact gathering. It will be removed in a future release. :param bool console_has_banner: *OPTIONAL* default is ``False``. If ``False`` then in case of a hung state, <close-session/> rpc is sent to the console. If ``True``, after sleep(5), a new-line is sent """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- self._tty = None self._ofacts = {} self.connected = False self._skip_logout = False self.results = dict(changed=False, failed=False, errmsg=None) # hostname is not required in serial mode connection self._hostname = kvargs.get('host') self._auth_user = kvargs.get('user', 'root') self._auth_password = kvargs.get( 'password', '') or kvargs.get( 'passwd', '') self._port = kvargs.get('port', '23') self._baud = kvargs.get('baud', '9600') self._mode = kvargs.get('mode', 'telnet') self._timeout = kvargs.get('timeout', '0.5') self._normalize = kvargs.get('normalize', False) self._norm_transform = lambda: JXML.normalize_xslt.encode('UTF-8') self.transform = self._norm_transform # self.timeout needed by PyEZ utils #self.timeout = self._timeout self._attempts = kvargs.get('attempts', 10) self._gather_facts = kvargs.get('gather_facts', False) self._fact_style = kvargs.get('fact_style', 'new') if self._fact_style != 'new': warnings.warn('fact-style %s will be removed in a future release.' % (self._fact_style), RuntimeWarning) self.console_has_banner = kvargs.get('console_has_banner', False) self.rpc = _RpcMetaExec(self) self._ssh_config = kvargs.get('ssh_config') self._manages = [] self.junos_dev_handler = JunosDeviceHandler(device_params= {'name': 'junos', 'local': False}) if self._fact_style == 'old': self.facts = self.ofacts else: self.facts = _FactCache(self)
def __init__(self, *vargs, **kvargs): """ Device object constructor. :param str vargs[0]: host-name or ipaddress. This is an alternative for **host** :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses $USER if not provided :param str passwd: *OPTIONAL* if not provided, assumed ssh-keys are enforced :param int port: *OPTIONAL* NETCONF port (defaults to 830) :param bool gather_facts: *OPTIONAL* default is ``True``. If ``False`` then the facts are not gathered on call to :meth:`open` :param bool auto_probe: *OPTIONAL* if non-zero then this enables auto_probe at time of :meth:`open` and defines the amount of time(sec) for the probe timeout :param str ssh_private_key_file: *OPTIONAL* The path to the SSH private key file. This can be used if you need to provide a private key rather than loading the key into the ssh-key-ring/environment. if your ssh-key requires a password, then you must provide it via **passwd** :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried. :param bool normalize: *OPTIONAL* default is ``False``. If ``True`` then the XML returned by :meth:`execute` will have whitespace normalized """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- hostname = vargs[0] if len(vargs) else kvargs.get('host') self._port = kvargs.get('port', 830) self._gather_facts = kvargs.get('gather_facts', True) self._normalize = kvargs.get('normalize', False) self._auto_probe = kvargs.get('auto_probe', self.__class__.auto_probe) if self.__class__.ON_JUNOS is True and hostname is None: # --------------------------------- # running on a Junos device locally # --------------------------------- self._auth_user = None self._auth_password = None self._hostname = 'localhost' self._ssh_private_key_file = None self._ssh_config = None else: # -------------------------- # making a remote connection # -------------------------- if hostname is None: raise ValueError("You must provide the 'host' value") self._hostname = hostname # user will default to $USER self._auth_user = os.getenv('USER') self._conf_auth_user = None self._conf_ssh_private_key_file = None # user can get updated by ssh_config self._ssh_config = kvargs.get('ssh_config') self._sshconf_path = self._sshconf_lkup() # but if user or private key is explit from call, then use it. self._auth_user = kvargs.get('user') or self._conf_auth_user or self._auth_user self._ssh_private_key_file = kvargs.get('ssh_private_key_file') or self._conf_ssh_private_key_file self._auth_password = kvargs.get('password') or kvargs.get('passwd') # ----------------------------- # initialize instance variables # ------------------------------ self._conn = None self._j2ldr = _Jinja2ldr self._manages = [] self._facts = {} # public attributes self.connected = False self.rpc = _RpcMetaExec(self)
def __init__(self, **kvargs): """ NoobDevice object constructor. :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses root if not provided :param str passwd: *OPTIONAL* in console connection for device at zeroized state password is not required :param int port: *OPTIONAL* port, defaults to '23' for telnet mode and '/dev/ttyUSB0' for serial. :param int baud: *OPTIONAL* baud, default baud rate is 9600 :param str mode: *OPTIONAL* mode, mode of connection (telnet/serial) default is telnet :param int timeout: *OPTIONAL* timeout, default is 0.5 :param int attempts: *OPTIONAL* attempts, default is 10 :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried it will be used by SCP class. So its assumed ssh is enabled by the time we use SCP functionality. :param bool gather_facts: *OPTIONAL* Defaults to ``False``. If ``False`` and old-style fact gathering is in use then facts are not gathered on call to :meth:`open`. This argument is a no-op when new-style fact gathering is in use (the default.) :param str fact_style: *OPTIONAL* The style of fact gathering to use. Valid values are: 'new', 'old', or 'both'. The default is 'new'. The value 'both' is only present for debugging purposes. It will be removed in a future release. The value 'old' is only present to workaround bugs in new-style fact gathering. It will be removed in a future release. :param bool console_has_banner: *OPTIONAL* default is ``False``. If ``False`` then in case of a hung state, <close-session/> rpc is sent to the console. If ``True``, after sleep(5), a new-line is sent """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- self._tty = None self._ofacts = {} self.connected = False self._skip_logout = False self.results = dict(changed=False, failed=False, errmsg=None) # hostname is not required in serial mode connection self._hostname = kvargs.get('host') self._auth_user = kvargs.get('user', 'root') self._auth_password = kvargs.get('password', '') or kvargs.get( 'passwd', '') self._port = kvargs.get('port', '23') self._baud = kvargs.get('baud', '9600') self._mode = kvargs.get('mode', 'telnet') self._timeout = kvargs.get('timeout', '0.5') self._normalize = kvargs.get('normalize', False) self._norm_transform = lambda: JXML.normalize_xslt.encode('UTF-8') self.transform = self._norm_transform # self.timeout needed by PyEZ utils #self.timeout = self._timeout self._attempts = kvargs.get('attempts', 10) self._gather_facts = kvargs.get('gather_facts', False) self._fact_style = kvargs.get('fact_style', 'new') if self._fact_style != 'new': warnings.warn( 'fact-style %s will be removed in a future release.' % (self._fact_style), RuntimeWarning) self.console_has_banner = kvargs.get('console_has_banner', False) self.rpc = _RpcMetaExec(self) self._ssh_config = kvargs.get('ssh_config') self._manages = [] self.junos_dev_handler = JunosDeviceHandler(device_params={ 'name': 'junos', 'local': False }) if self._fact_style == 'old': self.facts = self.ofacts else: self.facts = _FactCache(self)
def __init__(self, **kvargs): """ NoobDevice object constructor. :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses root if not provided :param str passwd: *OPTIONAL* in console connection for device at zeroized state password is not required :param int port: *OPTIONAL* port, defaults to '23' for telnet mode and '/dev/ttyUSB0' for serial. :param int baud: *OPTIONAL* baud, default baud rate is 9600 :param str mode: *OPTIONAL* mode, mode of connection (telnet/serial) default is telnet :param int timeout: *OPTIONAL* timeout, default is 0.5 :param int attempts: *OPTIONAL* attempts, default is 10 :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried it will be used by SCP class. So its assumed ssh is enabled by the time we use SCP functionality. :param bool gather_facts: *OPTIONAL* default is ``False``. If ``False`` then the facts are not gathered on call to :meth:`open` """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- self._tty = None self._facts = {} self.connected = False self._skip_logout = False self.results = dict(changed=False, failed=False, errmsg=None) # hostname is not required in serial mode connection self._hostname = kvargs.get('host') self._auth_user = kvargs.get('user', 'root') self._auth_password = kvargs.get( 'password', '') or kvargs.get( 'passwd', '') self._port = kvargs.get('port', '23') self._baud = kvargs.get('baud', '9600') self._mode = kvargs.get('mode', 'telnet') self._timeout = kvargs.get('timeout', '0.5') self._normalize = kvargs.get('normalize', False) self._norm_transform = lambda: JXML.normalize_xslt.encode('UTF-8') self.transform = self._norm_transform # self.timeout needed by PyEZ utils #self.timeout = self._timeout self._attempts = kvargs.get('attempts', 10) self.gather_facts = kvargs.get('gather_facts', False) self.rpc = _RpcMetaExec(self) self._ssh_config = kvargs.get('ssh_config') self._manages = [] self.junos_dev_handler = JunosDeviceHandler(device_params= {'name': 'junos', 'local': False})
def __init__(self, **kvargs): """ NoobDevice object constructor. :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses root if not provided :param str passwd: *OPTIONAL* in console connection for device at zeroized state password is not required :param int port: *OPTIONAL* port, defaults to '23' for telnet mode and '/dev/ttyUSB0' for serial. :param int baud: *OPTIONAL* baud, default baud rate is 9600 :param str mode: *OPTIONAL* mode, mode of connection (telnet/serial) default is telnet :param int timeout: *OPTIONAL* timeout, default is 0.5 :param int attempts: *OPTIONAL* attempts, default is 10 :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried it will be used by SCP class. So its assumed ssh is enabled by the time we use SCP functionality. :param bool gather_facts: *OPTIONAL* Defaults to ``False``. If ``False`` and old-style fact gathering is in use then facts are not gathered on call to :meth:`open`. This argument is a no-op when new-style fact gathering is in use (the default.) :param str fact_style: *OPTIONAL* The style of fact gathering to use. Valid values are: 'new', 'old', or 'both'. The default is 'new'. The value 'both' is only present for debugging purposes. It will be removed in a future release. The value 'old' is only present to workaround bugs in new-style fact gathering. It will be removed in a future release. :param bool console_has_banner: *OPTIONAL* default is ``False``. If ``False`` then in case of a hung state, <close-session/> rpc is sent to the console. If ``True``, after sleep(5), a new-line is sent """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- self._tty = None self._ofacts = {} self.connected = False self._skip_logout = False self.results = dict(changed=False, failed=False, errmsg=None) # hostname is not required in serial mode connection self._hostname = kvargs.get("host") self._auth_user = kvargs.get("user", "root") self._conf_auth_user = None self._conf_ssh_private_key_file = None self._auth_password = kvargs.get("password", "") or kvargs.get( "passwd", "") self.cs_user = kvargs.get("cs_user") self.cs_passwd = kvargs.get("cs_passwd") self._port = kvargs.get("port", "22" if self.cs_user else "23") self._mode = kvargs.get("mode", None if self.cs_user else "telnet") self._baud = kvargs.get("baud", "9600") if self._hostname: self._ssh_config = kvargs.get("ssh_config") self._sshconf_lkup() self._ssh_private_key_file = (kvargs.get("ssh_private_key_file") or self._conf_ssh_private_key_file) self._timeout = kvargs.get("timeout", "0.5") self._normalize = kvargs.get("normalize", False) self._attempts = kvargs.get("attempts", 10) self._gather_facts = kvargs.get("gather_facts", False) self._fact_style = kvargs.get("fact_style", "new") self._huge_tree = kvargs.get("huge_tree", False) if self._fact_style != "new": warnings.warn( "fact-style %s will be removed in " "a future release." % (self._fact_style), RuntimeWarning, ) self.console_has_banner = kvargs.get("console_has_banner", False) self.rpc = _RpcMetaExec(self) self._manages = [] self.junos_dev_handler = JunosDeviceHandler(device_params={ "name": "junos", "local": False }) self._conn = None self._j2ldr = _Jinja2ldr if self._fact_style == "old": self.facts = self.ofacts else: self.facts = _FactCache(self)
def __init__(self, **kvargs): """ NoobDevice object constructor. :param str host: **REQUIRED** host-name or ipaddress of target device :param str user: *OPTIONAL* login user-name, uses root if not provided :param str passwd: *OPTIONAL* in console connection for device at zeroized state password is not required :param int port: *OPTIONAL* port, default is telnet port `23` :param int baud: *OPTIONAL* baud, default baud rate is 9600 :param str mode: *OPTIONAL* mode, mode of connection (telnet/serial/ssh) default is telnet :param int timeout: *OPTIONAL* timeout, default is 0.5 :param int attempts: *OPTIONAL* attempts, default is 10 :param str ssh_config: *OPTIONAL* The path to the SSH configuration file. This can be used to load SSH information from a configuration file. By default ~/.ssh/config is queried it will be used by SCP class. So its assumed ssh is enabled by the time we use SCP functionality. :param bool gather_facts: *OPTIONAL* default is ``False``. If ``False`` then the facts are not gathered on call to :meth:`open` """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- self._tty = None self._facts = {} self.connected = False self._skip_logout = False self.results = dict(changed=False, failed=False, errmsg=None) # hostname is not required in serial mode connection self._hostname = kvargs.get('host') self._auth_user = kvargs.get('user', 'root') self._auth_password = kvargs.get('password', '') or kvargs.get( 'passwd', '') self._port = kvargs.get('port', '23') self._baud = kvargs.get('baud', '9600') self._mode = kvargs.get('mode', 'telnet') self._timeout = kvargs.get('timeout', '0.5') self._attempts = kvargs.get('attempts', 10) self.gather_facts = kvargs.get('gather_facts', False) self.rpc = _RpcMetaExec(self) from jnpr.junos import Device if sys.version < '3': self.cli = lambda cmd, format='text', warning=True: \ Device.cli.im_func(self, cmd, format, warning) self._sshconf_path = lambda: Device._sshconf_lkup.im_func(self) self.facts_refresh = lambda exception_on_failure=False: \ Device.facts_refresh.im_func(self, exception_on_failure) else: self.cli = lambda cmd, format='text', warning=True: \ Device.cli(self, cmd, format, warning) self._sshconf_path = lambda: Device._sshconf_lkup(self) self.facts_refresh = lambda exception_on_failure=False: \ Device.facts_refresh(self, exception_on_failure) self._ssh_config = kvargs.get('ssh_config')
def __init__(self, *vargs, **kvargs): """ vargs[0] -- ALTERNATIVE for kvargs['host'] kvargs['host'] -- REQUIRED for off-box device hostname or ipaddress kvargs['user'] -- OPTIONAL login user-name, uses $USER if not provided kvargs['password'] -- OPTIONAL kvargs['passwd'] -- OPTIONAL login password. if not provided, assumed ssh-keys are enforced kvargs['port'] -- OPTIONAL device login port (defaults to 830) kvargs['gather_facts'] -- optional if :False: then the facts are not gathered on call to :open(): kvargs['auto_probe'] -- OPTIONAL if non-zero then this enables auto_probe at time of :open(): and defines the amount of time/seconds for the probe timeout """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- hostname = vargs[0] if len(vargs) else kvargs.get('host') self._port = kvargs.get('port', 830) self._gather_facts = kvargs.get('gather_facts', True) self._auto_probe = kvargs.get('auto_probe', self.__class__.auto_probe) if self.__class__.ON_JUNOS is True and hostname is None: # --------------------------------- # running on a Junos device locally # --------------------------------- self._auth_user = None self._auth_password = None self._hostname = 'localhost' else: # -------------------------- # making a remote connection # -------------------------- if hostname is None: raise ValueError("You must provide the 'host' value") self._hostname = hostname # user will default to $USER self._auth_user = os.getenv('USER') # user can get updated by ssh_config self._sshconf_lkup() # but if user is explit from call, then use it. self._auth_user = kvargs.get('user') or self._auth_user self._auth_password = kvargs.get('password') or kvargs.get( 'passwd') # ----------------------------- # initialize instance variables # ------------------------------ self._conn = None self._j2ldr = _Jinja2ldr self._manages = [] self._facts = {} # public attributes self.connected = False self.rpc = _RpcMetaExec(self)
def __init__(self, *vargs, **kvargs): """ vargs[0] -- ALTERNATIVE for kvargs['host'] kvargs['host'] -- REQUIRED for off-box device hostname or ipaddress kvargs['user'] -- OPTIONAL login user-name, uses $USER if not provided kvargs['password'] -- OPTIONAL kvargs['passwd'] -- OPTIONAL login password. if not provided, assumed ssh-keys are enforced kvargs['port'] -- OPTIONAL device login port (defaults to 830) kvargs['gather_facts'] -- optional if :False: then the facts are not gathered on call to :open(): kvargs['auto_probe'] -- OPTIONAL if non-zero then this enables auto_probe at time of :open(): and defines the amount of time/seconds for the probe timeout """ # ---------------------------------------- # setup instance connection/open variables # ---------------------------------------- hostname = vargs[0] if len(vargs) else kvargs.get('host') self._port = kvargs.get('port', 830) self._gather_facts = kvargs.get('gather_facts', True) self._auto_probe = kvargs.get('auto_probe', self.__class__.auto_probe) if self.__class__.ON_JUNOS is True and hostname is None: # --------------------------------- # running on a Junos device locally # --------------------------------- self._auth_user = None self._auth_password = None self._hostname = 'localhost' else: # -------------------------- # making a remote connection # -------------------------- if hostname is None: raise ValueError("You must provide the 'host' value") self._hostname = hostname # user will default to $USER self._auth_user = os.getenv('USER') # user can get updated by ssh_config self._sshconf_lkup() # but if user is explit from call, then use it. self._auth_user = kvargs.get('user') or self._auth_user self._auth_password = kvargs.get('password') or kvargs.get('passwd') self._ssh_key = kvargs.get('ssh_key') # ----------------------------- # initialize instance variables # ------------------------------ self._conn = None self._j2ldr = _Jinja2ldr self._manages = [] self._facts = {} # public attributes self.connected = False self.rpc = _RpcMetaExec(self)