ncclient:NETCONF Python client

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

__version__ = "0.01"

class ncclientError(Exception): pass

class NETCONFError(ncclientError): 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.

from .. import ncclientError, NETCONFError

class ContentError(ncclientError): 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.

from threading import Lock

import logging

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

class Subject:

    'Thread-safe abstact class for event-dispatching subjects'

    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:

            for l in self._listeners:

                try:

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

                except Exception as e:

                    logger.warning(e)

if __name__=="__main__":

    logging.basicConfig(level=logging.DEBUG)

    class Listener:

        def reply(self, data):

            print data

        def error(self, err_info):

            print err_info

    subject = Subject()        

    subject.add_listener(Listener())

    subject.dispatch('reply', 'hello world')

    subject.dispatch('error', 'bye world')

    subject.dispatch('undefined', 'happy deliverin')

# 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 Event

class OperationError(NETCONFError): pass

class Operation(RPCRequest):

    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.

from listener import Listener

class RPC:

    pass

class RPCRequest(RPC):

    cur_msg_id = {}

    @cls

    def next_id(cls, session_id):

        cur_msg_id[session_id] = cur_msg_id.get(session_id, 0) + 1

        return cur_msg_id[session_id]

    def __init__(self):

        self._reply = None

        self._event = Event()

        self._async = None

    def get_reply(self, timeout=2.0):

        self._event.wait(timeout)

        if self._event.isSet():

            return self._reply

    def do(self, session, async=False):

        self._async = async

    @property

    def async(self):

        return self._async

class RPCReply(RPC):

    pass

class RPCError(OperationError):

    pass

class ReplyListener(Listener):

    def __init__(self):

        self._id2rpc = {}

    def reply(self, msg):

        # if all good:

        op = id2op[id]

        op._reply = parsed_msg

        # else:

        self._error = True

        op._event.set()

        pass

    def error(self, buf):

        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.

from content import Creator, Parser

from threading import Thread

from listener import Subject, Listener

class SessionError(ncclientError): pass

class Session(Thread, Subject, Listener):

    CLIENT, SERVER = range(2)

    def __init__(self, capabilities=None, listeners=[]):

        Thread.__init__(self, name='session')

        listeners.append(self)

        Subject.__init__(self, listeners=listeners)

        Thread.setDaemon(True)

        self._capabilities = {

            CLIENT: capabilities,

            SERVER: None # yet

        }

        self._id = None # session-id

        self._connected = False

        self._initialised = False

        self._error = False

        self._q = Queue.Queue()

    def _init(self, id, capabilities):

        self.id = id

        self.capabilities[SERVER] = capabilities

        self.initialised = True

    def _greet(self):

        hello = Creator()

        # ...

        self._q.add(hello)

    def _close(self):

        raise NotImplementedError

    def connect(self):

        raise NotImplementedError

    def send(self, message):

        'Blocks if session not initialised yet'

        while not (self.ready or self._error):

            time.sleep(0.1)

        if self._error:

            raise SessionError

        else:

            self._q.add(message)

    def run(self):

        raise NotImplementedError

    ### Listener methods - relevant for the initial greeting

    def reply(self, data, *args, **kwds):

        id, capabilities = None, None

        try:

            p = Parser()

            # ...

            self._init(id, capabilities)

        except:

            self._error = True

        finally:

            self.remove_listener(self)

    def error(self, data, *args, **kwds):

        self._close()

        self.remove_listener(self)

        self._error = True

    ### Properties

    @property

    def client_capabilities(self): return self._capabilities[CLIENT]

    @property

    def serve_capabilities(self): return self._capabilities[SERVER]

    @property

    def ready(self): return (self._connected and self._initialised)

    @property

    def id(self): return self._id

# 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

import paramiko

from select import select as select

from session import Session, SessionError

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

class SSHError(SessionError): pass

class SSHSession(Session):

    BUF_SIZE = 4096

    MSG_DELIM = ']]>>]]>'

    MSG_DELIM_LEN = len(MSG_DELIM)

    def __init__(self, capabilities, load_known_hosts=True,

                 missing_host_key_policy=paramiko.RejectPolicy):

        Session.__init__(self, capabilities)

        self._inBuf = ''

        self._outBuf = ''

        self._client = SSHClient()

        if load_known_hosts:

            self._client.load_system_host_keys()

        self._client.set_missing_host_key_policy(missing_host_key_policy)

    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.connected = True

        self._greet()

        self.start()

    def _close(self):

        self._channel.shutdown(2)

    def run(self):

        sock = self._channel

        sock.setblocking(0)

        q = self._q

        while True:

            (r, w, e) = select([sock], [sock], [], 60)

            if w:

                if not q.empty():

                   self._outBuffer += ( q.get() + MSG_DELIM )

                if self._outBuffer:

                    n = sock.send(self._outBuffer)

                    self._outBuffer = self._outBuffer[n:]

            if r:

                data = sock.recv(BUF_SIZE)

                if data:

                    self._inBuf += data

                    (before, _, after) = self._inBuf.partition(MSG_DELIM)

                    if after:

                        self.dispatch('reply', before)

                        self._inBuf = after

                else:

                    self.dispatch('error', self._inBuf)

class CallbackPolicy(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