ncclient:NETCONF Python client

'''

NOTES

=====

- operations complete

- make operational again

- LockContext

- op specfic reply objects

- manager testing and augmenting

parse into dicts??

'''

    'urn:ietf:params:netconf:base:1.0',

    'urn:ietf:params:netconf:capability:writable-running:1.0',

    'urn:ietf:params:netconf:capability:candidate:1.0',

    'urn:ietf:params:netconf:capability:confirmed-commit:1.0',

    'urn:ietf:params:netconf:capability:rollback-on-error:1.0',

    'urn:ietf:params:netconf:capability:startup:1.0',

    'urn:ietf:params:netconf:capability:url:1.0',

    'urn:ietf:params:netconf:capability:validate:1.0',

    'urn:ietf:params:netconf:capability:xpath:1.0',

    'urn:ietf:params:netconf:capability:notification:1.0',

    'urn:ietf:params:netconf:capability:interleave:1.0'

])

        # some etree versions don't include xml decl with utf-8

        if encoding == 'utf-8':

            return ((u'<?xml version="1.0" encoding="utf-8"?>'

        if ET.iselement(spec):

            return spec

        elif isinstance(spec, basestring):

            return ET.XML(spec)

        # assume isinstance(spec, dict)

        elif 'tag' in spec:

            ele.text = str(spec.get('text', ''))

            if isinstance(children, dict): children = [children]

                ET.SubElement(ele, TreeBuilder.build(child))

from threading import Thread, Lock

    fp = StringIO(raw[:1024]) # this is a guess but start element beyond 1024 bytes would be a bit absurd

        try:

            root = parse_root(raw)

        except Exception as e:

            logger.error('error parsing dispatch message: %s' % e)

            return

        name = name.replace('_', '-')

    def get(self, *args, **kwds):

        g = operations.Get(self._session)

        reply = g.request(*args, **kwds)

        if reply.errors:

            raise RPCError(reply.errors)

        else:

            return reply.data

    def get_config(self, *args, **kwds):

        gc = operations.GetConfig(self._session)

        reply = gc.request(*args, **kwds)

        if reply.errors:

            raise RPCError(reply.errors)

        else:

            return reply.data

    def locked(self, target='running'):

        return LockContext(self._session, target)

from ncclient.capabilities import URI

import util

class DeleteConfig(RPC): # x

        'tag': 'delete-config',

        'children': [ { 'tag': 'target', 'children': None } ]

    def request(self, target=None, target_url=None):

        spec = DeleteConfig.SPEC.copy()

        spec['children'][0]['children'] = util.store_or_url(target, target_url)

        return self._request(spec)

class CopyConfig(RPC): # x

        'tag': 'copy-config',

            { 'tag': 'source', 'children': {'tag': None } },

            { 'tag': 'target', 'children': {'tag': None } }

    def request(self, source=None, source_url=None, target=None, target_url=None):

        spec = CopyConfig.SPEC.copy()

        spec['children'][0]['children'] = util.store_or_url(source, source_url)

        spec['children'][1]['children'] = util.store_or_url(target, target_url)

        return self._request(spec)

class Validate(RPC): # xxxxx

    DEPENDS = [':validate']

    SPEC = {

        'tag': 'validate',

        'children': []

    }

    def request(self, source=None, config=None):

        #self.either_or(source, config)

        #

        #if source is None and config is None:

        #    raise OperationError('Insufficient parameters')

        #if source is not None and config is not None:

        #    raise OperationError('Too many parameters')

        #spec = Validate.SPEC.copy()

        #

        util.one_of(source, capability)

        if source is not None:

            spec['children'].append({

                'tag': 'source',

                'children': {'tag': source}

                })

        #

        #else:

        #    if isinstance(config, dict):

        #        if config['tag'] != 'config':

        #            child['tag'] = 'config'

        #            child['children'] = config

        #        else:

        #            child = config

        #    elif isinstance(config, Element):

        #        pass

        #    else:

        #        from xml.etree import cElementTree as ET

        #        ele = ET.XML(unicode(config))

        #        if __(ele.tag) != 'config':

        #            pass

        #        else:

        #            pass

        #    spec['children'].append(child)

        #

        return self._request(spec)

class Commit(RPC): # x

    DEPENDS = [':candidate']

    SPEC = {'tag': 'commit', 'children': [] }

    def _parse_hook(self):

        pass

    def request(self, confirmed=False, timeout=None):

        spec = SPEC.copy()

        if confirmed:

            self._assert(':confirmed-commit')

            children = spec['children']

            children.append({'tag': 'confirmed'})

            if timeout is not None:

                children.append({

                    'tag': 'confirm-timeout',

                    'text': timeout

                })

class DiscardChanges(RPC): # x

    DEPENDS = [':candidate']

class Lock(RPC): # x

        if target=='candidate':

            self._assert(':candidate')

class Unlock(RPC): # x

        if target=='candidate':

            self._assert(':candidate')

class LockContext:

    def __init__(self, session, target='running'):

        self.session = session

        self.target = target

    def __enter__(self):

        Lock(self.session).request(self.target)

        return self

    def __exit__(self, t, v, tb):

        Unlock(self.session).request(self.target)

        return False

from ncclient.rpc import RPC, RPCReply

    if type == 'subtree':

        filter['children'] = [criteria]

    elif type == 'xpath':

    return filter

class Get(RPC): # xx

    REPLY_CLS = GetReply

        spec = Get.SPEC.copy()

            #if filter[0] == 'xpath':

            #    self._assert(':xpath')

class GetReply(RPCReply):

    def parse(self):

        RPCReply.parse(self)

class GetConfig(RPC): # xx

    REPLY_CLS = GetConfigReply

    def request(self, source=None, source_url=None, filter=None):

        self._one_of(source, source_url)

        spec = GetConfig.SPEC.copy()

        if source is not None:

            spec['children'][0]['children']['tag'] = source

        if source_url is not None:

            #self._assert(':url')

            spec['children'][0]['children']['tag'] = 'url'

            spec['children'][0]['children']['text'] = source_url        

            #if filter[0] == 'xpath':

            #    self._assert(':xpath')

class GetReply(RPCReply):

    def parse(self):

        RPCReply.parse(self)

class CloseSession(RPC): # x

class KillSession(RPC): # x

        'children': { 'tag': 'session-id', 'text': None}

        spec = KillSession.SPEC.copy()

#!/usr/bin/env python

'boilerplate'

from ncclient import OperationError

class MissingCapabilityError(OperationError):

    pass

def one_of(self, *args):

    for i, arg in enumerate(args):

        if arg is not None:

            for argh in args[i+1:]:

                if argh is not None:

                    raise OperationError('Too many parameters')

            else:

                return

    raise OperationError('Insufficient parameters')

def assert_capability(key, capabilities):

    if key not in capabilities:

        raise MissingCapabilityError

def store_or_url(store, url):

    one_of(store, url)

    node = {}

    if store is not None:

        node['tag'] = store

    else:

        node['tag'] = 'url'

        node['text'] = url

    return node

from ncclient import RPCError

class ReplyTimeoutError(RPCError): pass

        ok = False

        else:

            # create RPCError objects from <rpc-error> elements

            errtags = _('rpc-error')

            for errtag in errtags:

                for err in root.getiterator(errtag): # a particular <rpc-error>

                    logger.debug('parsed [%s]' % errtag)

                    d = {}

                    for err_detail in err.getchildren(): # <error-type> etc..

                        tag = __(err_detail.tag)

                        d[tag] = (err_detail.text.strip() if tag != 'error-info'

                                  else ET.tostring(err_detail, 'utf-8'))

                    self._errors.append(RPCError(d))

                if self._errors:

                    break

        if self.ok:

            # TODO: store children in some way...

            pass

    DEPENDS = []

    REPLY_CLS = RPCReply

        try:

            for cap in self.DEPENDS:

                self.assert_capability(cap)

        except AttributeError:

            pass        

    def _request(self, op):

            self._reply_event.wait(self._timeout)

    def _assert(self, capability):

        if capability not in self._session.server_capabilities:

            raise MissingCapabilityError('Server does not support [%s]' % cap)

        self._reply = self.REPLY_CLS(raw)

from Queue import Queue

        self._q = Queue()

    def send(self, message):

        "TODO: docstring"

        logger.debug('queueing %s' % message)

        self._q.put(message)