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

     # See the License for the specific language governing permissions and
     # limitations under the License.
     "TODO: docstring"
     "Transport layer"
     from session import Session, SessionListener
     from ssh import SSHSession
     from errors import *
     __all__ = [
         'Session',
         'SessionListener',
         'SSHSession',
         'TransportError',
         'AuthenticationError',
         'SessionCloseError',
         'SSHError',
         'SSHUnknownHostError',
         'SSHSession'
         'SSHUnknownHostError'
+    ]

     # See the License for the specific language governing permissions and
     # limitations under the License.
     "TODO: docstrings"
     from ncclient import NCClientError
     class TransportError(NCClientError):

     "All to do with NETCONF <hello> messages"
     from ncclient import content
     class HelloHandler:
         def __init__(self, init_cb, error_cb):
             self._init_cb = init_cb
             self._error_cb = error_cb
         def callback(self, root, raw):
             if content.unqualify(root[0]) == 'hello':
                 try:
                     id, capabilities = HelloHandler.parse(raw)
                 except Exception as e:
                     self._error_cb(e)
                 else:
                     self._init_cb(id, capabilities)
         def errback(self, err):
             self._error_cb(err)
         @staticmethod
         def build(capabilities):
             "Given a list of capability URI's returns encoded <hello> message"
             spec = {
                 'tag': content.qualify('hello'),
                 'subtree': [{
                     'tag': 'capabilities',
                     'subtree': # this is fun :-)
                         [{'tag': 'capability', 'text': uri} for uri in capabilities]
                     }]
+                }
             return content.dtree2xml(spec)
         @staticmethod
         def parse(raw):
             "Returns tuple of ('session-id', ['capability_uri', ...])"
             sid, capabilities = 0, []
             root = content.xml2ele(raw)
             for child in root.getchildren():
                 tag = content.unqualify(child.tag)
                 if tag == 'session-id':
                     sid = child.text
                 elif tag == 'capabilities':
                     for cap in child.getchildren():
                         if content.unqualify(cap.tag) == 'capability':
                             capabilities.append(cap.text)
             return sid, capabilities
     '''
     from ncclient.capabilities import CAPABILITIES
     from ncclient.transport.hello import HelloHandler
     from session import SessionListener
     print HelloHandler.build(CAPABILITIES)
     '''

     from Queue import Queue
     from threading import Thread, Lock, Event
     from ncclient import content
     from ncclient.capabilities import Capabilities
     from ncclient.content import parse_root
     from hello import HelloHandler
     import logging
     logger = logging.getLogger('ncclient.transport.session')
     class Session(Thread):
         "TODO: docstring"
         def __init__(self, capabilities):
             "Subclass constructor should call this"
             Thread.__init__(self)
             self.setDaemon(True)
             self._listeners = set() # TODO(?) weakref
             self.set_daemon(True)
             self._listeners = set() # 3.0's weakset ideal
             self._lock = Lock()
             self.setName('session')
             self.set_name('session')
             self._q = Queue()
             self._client_capabilities = capabilities
             self._server_capabilities = None # yet
-...
         def _dispatch_message(self, raw):
             "TODO: docstring"
             try:
                 root = parse_root(raw)
                 root = content.parse_root(raw)
             except Exception as e:
                 logger.error('error parsing dispatch message: %s' % e)
                 return
-...
             # callbacks
             def ok_cb(id, capabilities):
                 self._id = id
                 self._server_capabilities = Capabilities(capabilities)
                 self._server_capabilities = capabilities
                 init_event.set()
             def err_cb(err):
                 error[0] = err
-...
                          (self._id, self._server_capabilities))
         def add_listener(self, listener):
             "TODO: docstring"
             logger.debug('installing listener %r' % listener)
             if not isinstance(listener, SessionListener):
                 raise SessionError("Listener must be a SessionListener type")
             with self._lock:
                 self._listeners.add(listener)
         def remove_listener(self, listener):
             "TODO: docstring"
             logger.debug('discarding listener %r' % listener)
             with self._lock:
                 self._listeners.discard(listener)
         def get_listener_instance(self, cls):
             '''This is useful when we want to maintain one listener of a particular
             type per subject i.e. a multiton.
             '''
             with self._lock:
                 for listener in self._listeners:
                     if isinstance(listener, cls):
                         return listener
         def connect(self, *args, **kwds):
             "Subclass implements"
             raise NotImplementedError
         def run(self):
             "Subclass implements"
             raise NotImplementedError
         def send(self, message):
             "TODO: docstring"
             logger.debug('queueing %s' % message)
             self._q.put(message)
-...
         @property
         def id(self):
             "`session-id` if session is initialized, :const:`None` otherwise"
             return self._id
         @property
         def can_pipeline(self):
             return True
     class SessionListener(object):
         def callback(self, root, raw):
             raise NotImplementedError
         def errback(self, ex):
             raise NotImplementedError
     class HelloHandler(SessionListener):
         def __init__(self, init_cb, error_cb):
             self._init_cb = init_cb
             self._error_cb = error_cb
         def callback(self, root, raw):
             if content.unqualify(root[0]) == 'hello':
                 try:
                     id, capabilities = HelloHandler.parse(raw)
                 except Exception as e:
                     self._error_cb(e)
                 else:
                     self._init_cb(id, capabilities)
         def errback(self, err):
             self._error_cb(err)
         @staticmethod
         def build(capabilities):
             "Given a list of capability URI's returns <hello> message XML string"
             spec = {
                 'tag': content.qualify('hello'),
                 'subtree': [{
                     'tag': 'capabilities',
                     'subtree': # this is fun :-)
                         [{'tag': 'capability', 'text': uri} for uri in capabilities]
                     }]
+                }
             return content.dtree2xml(spec)
         @staticmethod
         def parse(raw):
             "Returns tuple of (session-id (str), capabilities (Capabilities)"
             sid, capabilities = 0, []
             root = content.xml2ele(raw)
             for child in root.getchildren():
                 tag = content.unqualify(child.tag)
                 if tag == 'session-id':
                     sid = child.text
                 elif tag == 'capabilities':
                     for cap in child.getchildren():
                         if content.unqualify(cap.tag) == 'capability':
                             capabilities.append(cap.text)
             return sid, Capabilities(capabilities)

     class SSHSession(Session):
         def __init__(self, *args, **kwds):
             Session.__init__(self, *args, **kwds)
         "A NETCONF SSH session, per :rfc: 4742"
         def __init__(self, capabilities):
             Session.__init__(self, capabilities)
             self._host_keys = paramiko.HostKeys()
             self._system_host_keys = paramiko.HostKeys()
             self._transport = None
-...
             self._parsing_state = expect
             self._parsing_pos = self._buffer.tell()
         def expect_close(self):
             self._expecting_close = True
         def load_system_host_keys(self, filename=None):
             if filename is None:
                 filename = os.path.expanduser('~/.ssh/known_hosts')
-...
         def save_host_keys(self, filename):
             f = open(filename, 'w')
             for hostname, keys in self._host_keys.iteritems():
             for host, keys in self._host_keys.iteritems():
                 for keytype, key in keys.iteritems():
                     f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
                     f.write('%s %s %s\n' % (host, keytype, key.get_base64()))
             f.close()
         def close(self):
             self.expect_close()
             self._expecting_close = True
             if self._transport.is_active():
                 self._transport.close()
             self._connected = False
         def connect(self, hostname, port=830, timeout=None,
         def connect(self, host, port=830, timeout=None,
                     unknown_host_cb=None, username=None, password=None,
                     key_filename=None, allow_agent=True, look_for_keys=True):
             assert(username is not None)
             for (family, socktype, proto, canonname, sockaddr) in \
             socket.getaddrinfo(hostname, port):
                 if socktype==socket.SOCK_STREAM:
             socket.getaddrinfo(host, port):
                 if socktype == socket.SOCK_STREAM:
                     af = family
                     addr = sockaddr
                     break
             else:
                 raise SSHError('No suitable address family for %s' % hostname)
                 raise SSHError('No suitable address family for %s' % host)
             sock = socket.socket(af, socket.SOCK_STREAM)
             sock.settimeout(timeout)
             sock.connect(addr)
-...
             # host key verification
             server_key = t.get_remote_server_key()
             known_host = self._host_keys.check(hostname, server_key) or \
                             self._system_host_keys.check(hostname, server_key)
             known_host = self._host_keys.check(host, server_key) or \
                             self._system_host_keys.check(host, server_key)
             if unknown_host_cb is None:
                 unknown_host_cb = lambda *args: False
             if not known_host and not unknown_host_cb(hostname, server_key):
                     raise SSHUnknownHostError(hostname, server_key)
             if not known_host and not unknown_host_cb(host, server_key):
                     raise SSHUnknownHostError(host, server_key)
             if key_filename is None:
                 key_filenames = []
-...
         @property
         def transport(self):
             '''Get underlying paramiko transport object; this is provided so methods
             like set_keepalive can be called on it. See paramiko.Transport
             documentation for details.
             '''
             return self._transport
         @property

ncclient:NETCONF Python client

Revision 583c11f6