ncclient:NETCONF Python client

__version__ = "0.01"

# Copyright 2009 Shikhar Bhushan

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#    http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

class ClientError(Exception):

    pass

class NETCONFError(ClientError):

    pass

from ncclient import rpc

import content

from listeners import session_listener_factory

    metadata = {

        'tag': 'rpc',

        'xmlns': 'urn:ietf:params:xml:ns:netconf:base:1.0',

        }

        listener = session_listener_factory(self._session)

        listener.register(self._id, self)

        session.add_listener(listener)

        pass

# Copyright 2009 Shikhar Bhushan

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#    http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

import logging

from weakref import WeakValueDictionary

import content

from session import SessionCloseError

logger = logging.getLogger('ncclient.listeners')

################################################################################

# {session-id: SessionListener}

session_listeners = WeakValueDictionary

def session_listener_factory(session):

    try:

        return session_listeners[session]

    except KeyError:

        session_listeners[session] = SessionListener()

        return session_listeners[session]

class SessionListener:

    def __init__(self):

        # {message-id: RPC}

        self._rpc = WeakValueDictionary()

        # if the session gets closed by remote endpoint,

        # need to know if it is an error event or was requested through

        # a NETCONF operation i.e. CloseSession

        self._expecting_close = False

        # other recognized names 

        self._recognized = []

    def __str__(self):

        return 'SessionListener'

    def expect_close(self):

        self._expecting_close = True

    def register(self, id, op):

        self._id2rpc[id] = op

    ### Events

    def reply(self, raw):

        try:

            id = content.parse_message_root(raw)

            if id is None:

                pass

            elif id == 'notification':

                self._id2rpc[self._sub_id]._notify(raw)

            else:

                self._id2rpc[id]._response_cb(raw)

        except Exception as e:

            logger.warning(e)

    def error(self, err):

        if err is SessionCloseError:

            logger.debug('session closed by remote endpoint, expecting_close=%s' %

                         self._expecting_close)

            if not self._expecting_close:

                raise err

################################################################################

class HelloListener:

    def __str__(self):

        return 'HelloListener'

    def __init__(self, session):

        self._session = session

    ### Events

    def reply(self, data):

        try:

            id, capabilities = content.Hello.parse(data)

            logger.debug('HelloListener: session_id: %s; capabilities: %s', id, capabilities)

            self._session.initialize(id, capabilities)

        except Exception as e:

            self._session.initialize_error(e)

    def error(self, err):

        self._session.initialize_error(err)

################################################################################

class DebugListener:

    def __str__(self): return 'DebugListener'

    def reply(self, raw): logger.debug('DebugListener:reply:\n%s' % raw)

    def error(self, err): logger.debug('DebugListener:error:\n%s' % err)

import content

from error import ClientError

from listeners import HelloListener

from subject import Subject

logger = logging.getLogger('ncclient.session')

class SessionError(ClientError): pass

class Session(Thread, Subject):

        Subject.__init__(self)

        self._error = None

        self._init_event = Event()

        # start the subclass' main loop

        listener = HelloListener(self)

        self.add_listener(listener)

        self.start()

        self.send(content.Hello.build(self._client_capabilities))

        # we expect server's hello message, wait for _init_event to be set

        self._init_event.wait()

        # there may have been an error

    def hello(self, id, capabilities):

        self._id, self._capabilities = id, Capabilities(capabilities)

        self._init_event.set()

    def hello_error(self, err):

        self._error = err

        self._init_event.set()

from session import Session, SessionError

class SessionCloseError(SessionError):

    def __str__(self):

        return 'RECEIVED: %s | UNSENT: %s' % (self._in_buf, self._out_buf)

    def __init__(self, in_buf, out_buf=None):

        SessionError.__init__(self)

        self._in_buf, self._out_buf = in_buf, out_buf

    BUF_SIZE = 4096

    MSG_DELIM = ']]>]]>'

        delim = SSHSession.MSG_DELIM

    #def load_host_keys(self, filename):

    #    self._client.load_host_keys(filename)

    #

    #def set_missing_host_key_policy(self, policy):

    #    self._client.set_missing_host_key_policy(policy)

    #

    #def connect(self, hostname, port=830, username=None, password=None,

    #            key_filename=None, timeout=None, allow_agent=True,

    #            look_for_keys=True):

    #    self._client.connect(hostname, port=port, username=username,

    #                        password=password, key_filename=key_filename,

    #                        timeout=timeout, allow_agent=allow_agent,

    #                        look_for_keys=look_for_keys)    

    #    transport = self._client.get_transport()

    #    self._channel = transport.open_session()

    #    self._channel.invoke_subsystem('netconf')

    #    self._channel.set_name('netconf')

    #    self._connected = True

    #    self._post_connect()

        self._transport = paramiko.Transport()

            while True:    

                    data = q.get() + SSHSession.MSG_DELIM

                    data = chan.recv(SSHSession.BUF_SIZE)

class MissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):

    def __init__(self, cb):

        self._cb = cb

    def missing_host_key(self, client, hostname, key):

        if not self._cb(hostname, key):

            raise SSHError

# Copyright 2009 Shikhar Bhushan

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#    http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

from threading import Lock

import logging

logger = logging.getLogger('ncclient.subject')

class Subject:

    def __init__(self, listeners=[]):

        self._listeners = set(listeners)

        self._lock = Lock()

    def has_listener(self, listener):

        with self._lock:

            return (listener in self._listeners)

    def add_listener(self, listener):

        with self._lock:

            self._listeners.add(listener)

    def remove_listener(self, listener):

        with self._lock:

            self._listeners.discard(listener)

    def dispatch(self, event, *args, **kwds):

        # holding the lock while doing callbacks could lead to a deadlock

        # if one of the above methods is called

        with self._lock:

            listeners = list(self._listeners)

        for l in listeners:

            try:

                logger.debug('dispatching [%s] to [%s]' % (event, l))

                getattr(l, event)(*args, **kwds)

            except Exception as e:

                logger.warning(e)