def _ev_bad_passwd():
self.state = self._ST_BAD_PASSWD
self.write('\n')
self._badpasswd += 1
if self._badpasswd == 2:
# raise RuntimeError("Bad username/password")
raise EzErrors.ConnectAuthError(self, "Bad username/password")
def open(self, *vargs, **kvargs):
"""
Opens a connection to the device using existing login/auth
information.
:param bool gather_facts:
If set to ``True``/``False`` will override the device
instance value for only this open process
:param bool auto_probe:
If non-zero then this enables auto_probe and defines the amount
of time/seconds for the probe timeout
:param bool normalize:
If set to ``True``/``False`` will override the device
instance value for only this open process
:returns Device: Device instance (*self*).
:raises ProbeError:
When **auto_probe** is ``True`` and the probe activity
exceeds the timeout
:raises ConnectAuthError:
When provided authentication credentials fail to login
:raises ConnectRefusedError:
When the device does not have NETCONF enabled
:raises ConnectTimeoutError:
When the the :meth:`Device.timeout` value is exceeded
during the attempt to connect to the remote device
:raises ConnectError:
When an error, other than the above, occurs. The
originating ``Exception`` is assigned as ``err._orig``
and re-raised to the caller.
"""
auto_probe = kvargs.get('auto_probe', self._auto_probe)
if auto_probe is not 0:
if not self.probe(auto_probe):
raise EzErrors.ProbeError(self)
try:
ts_start = datetime.datetime.now()
# we want to enable the ssh-agent if-and-only-if we are
# not given a password or an ssh key file.
# in this condition it means we want to query the agent
# for available ssh keys
allow_agent = bool((self._auth_password is None) and
(self._ssh_private_key_file is None))
# open connection using ncclient transport
self._conn = netconf_ssh.connect(
host=self._hostname,
port=self._port,
username=self._auth_user,
password=self._auth_password,
hostkey_verify=False,
key_filename=self._ssh_private_key_file,
allow_agent=allow_agent,
ssh_config=self._sshconf_lkup(),
device_params={'name': 'junos', 'local': False})
self._conn._session.add_listener(DeviceSessionListener(self))
except NcErrors.AuthenticationError as err:
# bad authentication credentials
raise EzErrors.ConnectAuthError(self)
except NcErrors.SSHError as err:
# this is a bit of a hack for now, since we want to
# know if the connection was refused or we simply could
# not open a connection due to reachability. so using
# a timestamp to differentiate the two conditions for now
# if the diff is < 3 sec, then assume the host is
# reachable, but NETCONF connection is refushed.
ts_err = datetime.datetime.now()
diff_ts = ts_err - ts_start
if diff_ts.seconds < 3:
raise EzErrors.ConnectRefusedError(self)
# at this point, we assume that the connection
# has timeed out due to ip-reachability issues
if str(err).find('not open') > 0:
raise EzErrors.ConnectTimeoutError(self)
else:
# otherwise raise a generic connection
# error for now. tag the new exception
# with the original for debug
cnx = EzErrors.ConnectError(self)
cnx._orig = err
raise cnx
except socket.gaierror:
# invalid DNS name, so unreachable
raise EzErrors.ConnectUnknownHostError(self)
except Exception as err:
# anything else, we will re-raise as a
# generic ConnectError
cnx_err = EzErrors.ConnectError(self)
cnx_err._orig = err
raise cnx_err
self.connected = True
self._nc_transform = self.transform
self._norm_transform = lambda: JXML.normalize_xslt.encode('UTF-8')
normalize = kvargs.get('normalize', self._normalize)
if normalize is True:
self.transform = self._norm_transform
gather_facts = kvargs.get('gather_facts', self._gather_facts)
if gather_facts is True:
self.facts_refresh()
return self
def open(self, *vargs, **kvargs):
"""
opens a connection to the device using existing login/auth
information.
kvargs['gather_facts']:
If set to True/False will override the device instance value
for only this open process
kvargs['auto_probe']:
if non-zero then this enables auto_probe and defines the amount
of time/seconds for the probe timeout
"""
auto_probe = kvargs.get('auto_probe', self._auto_probe)
if auto_probe is not 0:
if not self.probe(auto_probe):
raise EzErrors.ProbeError(self)
try:
ts_start = datetime.datetime.now()
# open connection using ncclient transport
self._conn = netconf_ssh.connect(host=self._hostname,
port=self._port,
username=self._auth_user,
password=self._auth_password,
hostkey_verify=False,
device_params={'name': 'junos'})
except NcErrors.AuthenticationError as err:
# bad authentication credentials
raise EzErrors.ConnectAuthError(self)
except NcErrors.SSHError as err:
# this is a bit of a hack for now, since we want to
# know if the connection was refused or we simply could
# not open a connection due to reachability. so using
# a timestamp to differentiate the two conditions for now
# if the diff is < 3 sec, then assume the host is
# reachable, but NETCONF connection is refushed.
ts_err = datetime.datetime.now()
diff_ts = ts_err - ts_start
if diff_ts.seconds < 3:
raise EzErrors.ConnectRefusedError(self)
# at this point, we assume that the connection
# has timeed out due to ip-reachability issues
if err.message.find('not open') > 0:
raise EzErrors.ConnectTimeoutError(self)
else:
# otherwise raise a generic connection
# error for now. tag the new exception
# with the original for debug
cnx = EzErrors.ConnectError(self)
cnx._orig = err
raise cnx
except socket.gaierror:
# invalid DNS name, so unreachable
raise EzErrors.ConnectUnknownHostError(self)
except Exception as err:
# anything else, we will re-raise as a
# generic ConnectError
cnx_err = EzErrors.ConnectError(self)
cnx_err._orig = err
raise cnx_err
self.connected = True
gather_facts = kvargs.get('gather_facts', self._gather_facts)
if gather_facts is True:
self.facts_refresh()
return self
