/ - Diff - ncclient:NETCONF Python client - Greek Research and Technology Network's projects

Revision 6c70b245

     #: Same as :meth:`connect_ssh`
     connect = connect_ssh
     class RAISE:
         ALL = 0
         ERRORS = 1
         NONE = 2
     class Manager(object):
         """API for NETCONF operations.
-...
             self._session = session
             self._async_mode = False
             self._timeout = None
             self._raise_mode = 'all'
         def __enter__(self):
             return self
-...
             else:
                 return op(self.session,
                           async=self._async_mode,
                           raising=self._raise_mode,
                           timeout=self.timeout).request
                           timeout=self.timeout,
                           raise_mode=self._raise_mode).request
         def locked(self, target):
             """Returns a context manager for the *with* statement.
-...
         def set_async_mode(self, bool=True):
             self._async_mode = bool
         def set_raise_mode(self, choice='all'):
             self._raise_mode = choice
         def set_raise_mode(self, mode):
             assert(choice in ('all', 'errors', 'none'))
             self._raise_mode = mode
         async_mode = property(fget=lambda self: self._async_mode, fset=set_async_mode)

         # subclass of :class:`RPCReply`.
         REPLY_CLS = RPCReply
         def __init__(self, session, async=False, timeout=None):
         def __init__(self, session, async=False, timeout=None, raise_mode='none'):
             self._session = session
             try:
                 for cap in self.DEPENDS:
-...
                 pass
             self._async = async
             self._timeout = timeout
             self._raise_mode = raise_mode
             # keeps things simple instead of having a class attr that has to be locked
             self._id = uuid1().urn
             # RPCReplyListener itself makes sure there isn't more than one instance -- i.e. multiton
             self._listener = RPCReplyListener(session)
             self._listener.register(self._id, self)
             self._reply = None
-...
                 self._event.wait(self._timeout)
                 if self._event.isSet():
                     if self._error:
                         # Error that prevented reply delivery
                         raise self._error
                     self._reply.parse()
                     if self._reply.error is not None:
                         # <rpc-error>'s [ RPCError ]
                         if self._raise_mode == "all":
                             raise self._reply._error
                         elif (self._raise_mode == "errors" and
                               self._reply.error.type == "error"):
                             raise self._reply.error
                     return self._reply
                 else:
                     raise TimeoutExpiredError
-...
             """Subclasses implement this method. Here, the operation is constructed
             in :ref:`dtree`, and the result of :meth:`_request` returned."""
             return self._request(self.SPEC)
         #def _delivery_hook(self):
         #    """Subclasses can implement this method. Will be called after
         #    initialising the :attr:`reply` or :attr:`error` attribute and before
         #    setting the :attr:`event`"""
         #    pass
         def _assert(self, capability):
             """Subclasses can use this method to verify that a capability is available
             with the NETCONF server, before making a request that requires it. A
-...
             if async and not session.can_pipeline:
                 raise UserWarning('Asynchronous mode not supported for this device/session')
         def set_raise_mode(self, choice):
         def set_raise_mode(self, mode):
             assert(choice in ('all', 'errors', 'none'))
             self._raise = choice
             self._raise_mode = mode
         def set_timeout(self, timeout):
             """Set the timeout for synchronous waiting defining how long the RPC

Also available in: Unified diff