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, 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):
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)
