/brz/remove-bazaar

    urlutils,

    )

from ..errors import (FileExists,

from ..osutils import fancy_rename

from ..sixish import (

    zip,

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

        # 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):

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

                try:

                    cur_offset, cur_size = next(offset_iter)

        if user is None:

            auth = config.AuthenticationConfig()

            user = auth.get_user('ssh', self._parsed_url.host,

        connection = vendor.connect_sftp(self._parsed_url.user, password,

        return connection, (user, password)

 

    def disconnect(self):

            return f

        except (IOError, paramiko.SSHException) as e:

            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

    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:

            st = self.stat(relpath)

            if stat.S_ISDIR(st.st_mode):

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

            else:

                yield relpath

 

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

                # with the umask fix.

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

                if mode != stat.st_mode & 0o777:

                    if stat.st_mode & 0o6000:

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

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

        except (paramiko.SSHException, IOError) as e:

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

 

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

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

        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))

            if e.args == ('Operation unsupported',):

                raise errors.TransportNotPossible()

        """Rename without special overwriting"""

        try:

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

        except (IOError, paramiko.SSHException) as e:

            self._translate_io_exception(e, rel_from,

 

    def _rename_and_overwrite(self, abs_from, abs_to):

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

        """See Transport.readlink."""

        path = self._remote_path(relpath)

        try:

        except (IOError, paramiko.SSHException) as e:

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

 

        """See Transport.symlink."""

        try:

            conn = self._get_sftp()

        except (IOError, paramiko.SSHException) as e:

            self._translate_io_exception(e, link_name,

                                         ': unable to create symlink to %r' % (source))

        class BogusLock(object):

            def __init__(self, path):

                self.path = path

            def unlock(self):

                pass

            def __exit__(self, exc_type, exc_val, exc_tb):

                return False

            def __enter__(self):

                pass

        return BogusLock(relpath)

        if mode is not None:

            attr.st_mode = mode

        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE

        try:

            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)

            if t != CMD_HANDLE:

            return SFTPFile(self._get_sftp(), handle, 'wb', -1)

        except (paramiko.SSHException, IOError) as e:

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

 

    def _can_roundtrip_unix_modebits(self):

        if sys.platform == 'win32':