/brz/remove-bazaar

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

 

"""Implementation of Transport over SFTP, using paramiko."""

 

# TODO: Remove the transport-based lock_read and lock_write methods.  They'll

# then raise TransportNotPossible, which will break remote access to any

# formats which rely on OS-level locks.  That should be fine as those formats

import stat

import sys

import time

import warnings

 

    config,

    debug,

    errors,

    urlutils,

    )

    FileFileStream,

    _file_streams,

    ssh,

    ConnectedTransport,

    )

# /var/lib/python-support/python2.5/paramiko/message.py:226: DeprecationWarning: integer argument expected, got float

#  self.packet.write(struct.pack('>I', n))

warnings.filterwarnings('ignore',

 

try:

    import paramiko

    raise ParamikoNotPresent(e)

else:

    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,

                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,

    from paramiko.sftp_attr import SFTPAttributes

    from paramiko.sftp_file import SFTPFile

 

 

 

 

class SFTPLock(object):

        except FileExists:

            raise LockError('File %r already locked' % (self.path,))

 

    def unlock(self):

        if not self.lock_file:

            return

        # as possible, so we don't issues requests <32kB

        sorted_offsets = sorted(self.original_offsets)

        coalesced = list(ConnectedTransport._coalesce_offsets(sorted_offsets,

        requests = []

        for c_offset in coalesced:

            start = c_offset.start

                start += next_size

        if 'sftp' in debug.debug_flags:

            mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',

        return requests

 

    def request_and_yield_offsets(self, fp):

        """

        requests = self._get_requests()

        offset_iter = iter(self.original_offsets)

        # paramiko .readv() yields strings that are in the order of the requests

        # So we track the current request to know where the next data is

        # being returned from.

        # short readv.

        data_stream = itertools.chain(fp.readv(requests),

                                      itertools.repeat(None))

            if data is None:

                if cur_coalesced is not None:

                    raise errors.ShortReadvError(self.relpath,

            if len(data) != length:

                raise errors.ShortReadvError(self.relpath,

            self._report_activity(length, 'read')

            if last_end is None:

                # This is the first request, just buffer it

                if buffered_len > 0:

                    # We haven't consumed the buffer so far, so put it into

                    # data_chunks, and continue.

                    data_chunks.append((input_start, buffered))

                input_start = start

                buffered_data = [data]

                # into a single string. We also have the nice property that

                # when there is only one string ''.join([x]) == x, so there is

                # no data copying.

                # Clean out buffered data so that we keep memory

                # consumption low

                del buffered_data[:]

                    input_start += cur_size

                    # Yield the requested data

                    yield cur_offset, cur_data

                # at this point, we've consumed as much of buffered as we can,

                # so break off the portion that we consumed

                if buffered_offset == len(buffered_data):

                    buffered = buffered[buffered_offset:]

                    buffered_data = [buffered]

                    buffered_len = len(buffered)

        if buffered_len:

            del buffered_data[:]

            data_chunks.append((input_start, buffered))

        if data_chunks:

            if 'sftp' in debug.debug_flags:

                mutter('SFTP readv left with %d out-of-order bytes',

            # We've processed all the readv data, at this point, anything we

            # couldn't process is in data_chunks. This doesn't happen often, so

            # this code path isn't optimized

                    data = ''

                if len(data) != cur_size:

                    raise AssertionError('We must have miscalulated.'

                yield cur_offset, data

 

 

class SFTPTransport(ConnectedTransport):

    """Transport implementation for SFTP access."""

 

    # TODO: jam 20060717 Conceivably these could be configurable, either

    #       by auto-tuning at run-time, or by a configuration (per host??)

    #       but the performance curve is pretty flat, so just going with

    # up the request itself, rather than us having to worry about it

    _max_request_size = 32768

 

    def _remote_path(self, relpath):

        """Return the path to be passed along the sftp protocol for relpath.

 

        :param relpath: is a urlencoded string.

        """

        # the initial slash should be removed from the path, and treated as a

        # homedir relative path (the path begins with a double slash if it is

        # absolute).  see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt

        in base url at transport creation time.

        """

        if credentials is None:

        else:

            password = credentials

 

        vendor = ssh._get_ssh_vendor()

        if user is None:

            auth = config.AuthenticationConfig()

        return connection, (user, password)

 

    def _get_sftp(self):

        """Ensures that a connection is established"""

        connection = self._get_connection()

        :param relpath: The relative path to the file

        """

        try:

            path = self._remote_path(relpath)

            f = self._get_sftp().file(path, mode='rb')

            return f

            self._translate_io_exception(e, path, ': error retrieving',

 

    def get_bytes(self, relpath):

        # reimplement this here so that we can report how many bytes came back

            bytes = f.read()

            self._report_activity(len(bytes), 'read')

            return bytes

 

    def _readv(self, relpath, offsets):

        """See Transport.readv()"""

            if 'sftp' in debug.debug_flags:

                mutter('seek and read %s offsets', len(offsets))

            return self._seek_and_read(fp, offsets, relpath)

            self._translate_io_exception(e, path, ': error retrieving')

 

    def recommended_page_size(self):

    def _put(self, abspath, f, mode=None):

        """Helper function so both put() and copy_abspaths can reuse the code"""

        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),

        fout = self._sftp_open_exclusive(tmp_abspath, mode=mode)

        closed = False

        try:

            try:

                fout.set_pipelined(True)

                length = self._pump(f, fout)

                self._translate_io_exception(e, tmp_abspath)

            # XXX: This doesn't truly help like we would like it to.

            #      The problem is that openssh strips sticky bits. So while we

            closed = True

            self._rename_and_overwrite(tmp_abspath, abspath)

            return length

            # If we fail, try to clean up the temporary file

            # before we throw the exception

            # but don't let another exception mess things up

                    fout = self._get_sftp().file(abspath, mode='wb')

                    fout.set_pipelined(True)

                    writer(fout)

                    self._translate_io_exception(e, abspath,

                                                 ': unable to open')

 

                                    create_parent_dir=create_parent_dir,

                                    dir_mode=dir_mode)

 

                             create_parent_dir=False,

                             dir_mode=None):

        def writer(fout):

        self._put_non_atomic_helper(relpath, writer, mode=mode,

                                    create_parent_dir=create_parent_dir,

                                    dir_mode=dir_mode)

            st = self.stat(relpath)

            if stat.S_ISDIR(st.st_mode):

                for i, basename in enumerate(self.list_dir(relpath)):

            else:

                yield relpath

 

    def _mkdir(self, abspath, mode=None):

        if mode is None:

        else:

            local_mode = mode

        try:

                # the sgid bit is set, report a warning to the user

                # with the umask fix.

                stat = self._get_sftp().lstat(abspath)

                        warning('About to chmod %s over sftp, which will result'

                                ' in its suid or sgid bits being cleared.  If'

                                ' you want to preserve those bits, change your '

                                ' environment on the server to use umask 0%03o.'

                    self._get_sftp().chmod(abspath, mode=mode)

            self._translate_io_exception(e, abspath, ': unable to mkdir',

 

    def mkdir(self, relpath, mode=None):

        """Create a directory at the given path."""

        # api more than once per write_group at the moment so

        # it is a tolerable overhead. Better would be to truncate

        # the file after opening. RBC 20070805

        abspath = self._remote_path(relpath)

        # TODO: jam 20060816 paramiko doesn't publicly expose a way to

        #       set the file mode at create time. If it does, use it.

        try:

            handle = self._get_sftp().file(abspath, mode='wb')

            handle.set_pipelined(True)

            self._translate_io_exception(e, abspath,

                                         ': unable to open')

        _file_streams[self.abspath(relpath)] = handle

        self._translate_error(e, path, raise_generic=False)

        if getattr(e, 'args', None) is not None:

            if (e.args == ('No such file or directory',) or

                raise NoSuchFile(path, str(e) + more_info)

            if (e.args == ('mkdir failed',) or

                raise FileExists(path, str(e) + more_info)

            # strange but true, for the paramiko server.

            if (e.args == ('Failure',)):

            # '/srv/bazaar.launchpad.net/blah...: '

            # [Errno 39] Directory not empty',)

            if (e.args[0].startswith('Directory not empty: ')

                raise errors.DirectoryNotEmpty(path, str(e))

            mutter('Raising exception with args %s', e.args)

        if getattr(e, 'errno', None) is not None:

            mutter('Raising exception with errno %s', e.errno)

            result = fout.tell()

            self._pump(f, fout)

            return result

            self._translate_io_exception(e, relpath, ': unable to append')

 

    def rename(self, rel_from, rel_to):

        """Rename without special overwriting"""

        try:

            self._get_sftp().rename(self._remote_path(rel_from),

            self._translate_io_exception(e, rel_from,

 

    def _rename_and_overwrite(self, abs_from, abs_to):

        """Do a fancy rename on the remote server.

            fancy_rename(abs_from, abs_to,

                         rename_func=sftp.rename,

                         unlink_func=sftp.remove)

            self._translate_io_exception(e, abs_from,

                                         ': unable to rename to %r' % (abs_to))

 

        path = self._remote_path(relpath)

        try:

            self._get_sftp().remove(path)

            self._translate_io_exception(e, path, ': unable to delete')

 

    def external_url(self):

        # the external path for SFTP is the base

        return self.base

 

        try:

            entries = self._get_sftp().listdir(path)

            self._report_activity(sum(map(len, entries)), 'read')

            self._translate_io_exception(e, path, ': failed to list_dir')

        return [urlutils.escape(entry) for entry in entries]

 

        path = self._remote_path(relpath)

        try:

            return self._get_sftp().rmdir(path)

            self._translate_io_exception(e, path, ': failed to rmdir')

 

    def stat(self, relpath):

        path = self._remote_path(relpath)

        try:

            return self._get_sftp().lstat(path)

            self._translate_io_exception(e, path, ': unable to stat')

 

    def readlink(self, relpath):

        """See Transport.readlink."""

        path = self._remote_path(relpath)

        try: