ncclient:NETCONF Python client

MSG_DELIM = ']]>]]>'

TICK = 0.1

class SSHSession(Session):

    def __init__(self, capabilities):

        Session.__init__(self, capabilities)

        self._host_keys = paramiko.HostKeys()

        self._expecting_close = False

        self._buffer = StringIO() # for incoming data

        # parsing-related, see _parse()

        self._parsing_pos = 0

    def _parse(self):

        '''Messages ae delimited by MSG_DELIM. The buffer could have grown by a

        maximum of BUF_SIZE bytes everytime this method is called. Retains state

        delim = MSG_DELIM

        n = len(delim) - 1

        expect = self._parsing_state

        self._buffer = buf

        self._parsing_state = expect

        self._parsing_pos = self._buffer.tell()

    def load_system_host_keys(self, filename=None):

        if filename is None:

            filename = os.path.expanduser('~/.ssh/known_hosts')

                    pass

            return

        self._system_host_keys.load(filename)

    def load_host_keys(self, filename):

        self._host_keys.load(filename)

    def add_host_key(self, key):

        self._host_keys.add(key)

    def save_host_keys(self, filename):

        f = open(filename, 'w')

        for host, keys in self._host_keys.iteritems():

            for keytype, key in keys.iteritems():

                f.write('%s %s %s\n' % (host, keytype, key.get_base64()))

    def close(self):

        self._expecting_close = True

        if self._transport.is_active():

            self._transport.close()

        self._connected = False

    def connect(self, host, port=830, timeout=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(host, port):

            if socktype == socket.SOCK_STREAM:

        sock.connect(addr)

        t = self._transport = paramiko.Transport(sock)

        t.set_log_channel(logger.name)

        try:

            t.start_client()

        except paramiko.SSHException:

            raise SSHError('Negotiation failed')

        # host key verification

        server_key = t.get_remote_server_key()

        known_host = self._host_keys.check(host, server_key) or \

                        self._system_host_keys.check(host, server_key)

        if key_filename is None:

            key_filenames = []

        elif isinstance(key_filename, basestring):

            key_filenames = [ key_filename ]

        else:

            key_filenames = key_filename

        self._auth(username, password, key_filenames, allow_agent, look_for_keys)

        self._connected = True # there was no error authenticating

        c = self._channel = self._transport.open_session()

        c.set_name('netconf')

        c.invoke_subsystem('netconf')

        self._post_connect()

    # on the lines of paramiko.SSHClient._auth()

    def _auth(self, username, password, key_filenames, allow_agent,

              look_for_keys):

        saved_exception = None

        for key_filename in key_filenames:

            for cls in (paramiko.RSAKey, paramiko.DSSKey):

                try:

                except Exception as e:

                    saved_exception = e

                    logger.debug(e)

        if allow_agent:

            for key in paramiko.Agent().get_keys():

                try:

                except Exception as e:

                    saved_exception = e

                    logger.debug(e)

        keyfiles = []

        if look_for_keys:

            rsa_key = os.path.expanduser('~/.ssh/id_rsa')

                keyfiles.append((paramiko.RSAKey, rsa_key))

            if os.path.isfile(dsa_key):

                keyfiles.append((paramiko.DSSKey, dsa_key))

        for cls, filename in keyfiles:

            try:

                key = cls.from_private_key_file(filename, password)

            except Exception as e:

                saved_exception = e

                logger.debug(e)

        if password is not None:

            try:

                self._transport.auth_password(username, password)

            except Exception as e:

                saved_exception = e

                logger.debug(e)

        if saved_exception is not None:

            # need pep-3134 to do this right

            raise SSHAuthenticationError(repr(saved_exception))

        raise SSHAuthenticationError('No authentication methods available')

    def run(self):

        chan = self._channel

        chan.setblocking(0)

        try:

            while True:

                # select on a paramiko ssh channel object does not ever return

                # the socket api

                r, w, e = select([chan], [], [], TICK)

                # will wakeup evey TICK seconds to check if something

            self.close()

            if not (isinstance(e, SessionCloseError) and self._expecting_close):

                self._dispatch_error(e)

    @property

    def transport(self):

        return self._transport

    @property

    def can_pipeline(self):

        if 'Cisco' in self._transport.remote_version: