ncclient:NETCONF Python client

    set = add

NETCONF_NS = 'urn:ietf:params:xml:ns:netconf:base:1.0'

# 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 ..error import ClientError, NETCONFError

class ContentError(ClientError):

    pass

from . import NETCONF_NS

from .util import qualify as _

    return '<hello xmlns="%s">%s</hello>' % (NETCONF_NS, capabilities)

    root = ElementTree.fromstring(raw)

    if root.tag == _('hello'):

        for child in hello.getchildren():

            if child.tag == _('session-id'):

                id = int(child.text)

            elif child.tag == _('capabilities'):

                for cap in child.getiterator(_('capability')):

                    capabilities.add(cap.text)

# 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 xml.etree import cElementTree as ElementTree

from . import NETCONF_NS

from .util import qualify as _

def make(id, op):

    return '<rpc message-id="%s" xmlns="%s">%s</rpc>' % (id, NETCONF_NS, op)

#def parse(raw):

#    

#    class RootElementParser:

#        

#        def __init__(self):

#            self.id = 0

#            self.is_notification = False

#            

#        def start(self, tag, attrib):

#            if tag == _('rpc'):

#                self.id = int(attrib['message-id'])

#            elif tag == _('notification'):

#                self.is_notification = True

#    

#    target = RootElementParser()

#    parser = ElementTree.XMLTreeBuilder(target=target)

#    parser.feed(raw)

#    return target.id, target.is_notification

#

# 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 . import NETCONF_NS

def qualify(tag, ns=NETCONF_NS):

    return '{%s}%s' % (ns, tag)

from content import rpc

class SessionListener:

    def __init__(self):

        self._id2rpc = {}

        self._subscription_id = None # notifications are delivered to the rpc

                                    # that created the subscription

    def set_subscription(self, id):

        self._subscription = id

    def reply(self, raw):

        id, is_notification = rpc.parse(raw)

        if is_notification:

            self._id2rpc[self._subscription_id].event(raw)

        else:

            self._id2rpc[id]._deliver(raw)

            del self._id2rpc[id]

    def error(self, buf):

        pass

import content

from threading import Event

from listener import RPCReplyListener

    current_id = {}

    listeners = {}

    def do(self, async=False):

    def _deliver(self, reply):

    def has_reply(self):

        return self._event.isSet()

    def is_async(self):

        return self._async

    def listener(self):

        if RPC.listeners[self._sid] is None:

            RPC.listeners[self.sid] = listener.RPCReplyListener()

        return RPC.listeners[self._sid]

    @property

    def ok(self):

        pass

        RPC.current_id[self._session.id] = RPC.current_id.get(self._session.id, 0) + 1

        return RPC.current_id[self._sid]

    def __init__(self, id, raw):

        self._id = id

    @property

    def id(self):

        return self._id

class RPCError(NETCONFError):

from content import hello

from error import ClientError

from subject import Subject

class SessionError(ClientError):

    pass

    def client_capabilities(self):

        return self._client_capabilities

    def serve_capabilities(self):

        return self._server_capabilities

    def connected(self):

        return self._connected

    def id(self):

        return self._id    

    ### Methods for which subclasses should call super after they are done

    def _connect(self):

        self._connected = True

        # start the subclass' main loop

        self.start()

        # queue client's hello message for sending

        self.send(hello.make(self._client_capabilities))

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

        self._init_event.wait()

        # there may have been an error

        if self._error:

            self._close()

            raise self._error

    def _close(self):

        self._connected = False

        self._connect()

    def _close(self):

        self._channel.close()

        Session._close(self)

            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.listener')

class Subject:

    def __init__(self, listeners=[]):

        self._listeners = 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.append(listener)

    def remove_listener(self, listener):

        with self._lock:

            try:

                self._listeners.remove(listener)

            except ValueError:

                pass

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

        with self._lock:

            listeners = list(self._listeners)

        for l in listeners:

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

            try:

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

            except Exception as e:

                logger.warning(e)

class SessionListener:

    def __init__(self):

        self._id2rpc = {}

        self._subscription = None

    def reply(self, raw):

        reply = RPCReply(msg)

        id2rpc[reply.id]._deliver(reply)

    def error(self, buf):

        pass