← Back to branch summary

~bzr/ubuntu/lucid/bzr/beta-ppa

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Martin Pool
  • Date: 2010-07-02 07:29:40 UTC
  • mfrom: (129.1.7 packaging-karmic)
  • Revision ID: mbp@sourcefrog.net-20100702072940-hpzq5elg8wjve8rh
http://bugs.debian.org/452024
http://bugs.debian.org/464688
http://bugs.debian.org/523595
http://bugs.debian.org/526233
http://bugs.debian.org/537708
http://bugs.debian.org/555336
http://bugs.debian.org/555343
https://launchpad.net/bugs/249452
https://launchpad.net/bugs/385074
* PPA rebuild.
* PPA rebuild for Karmic.
* PPA rebuild for Jaunty.
* PPA rebuild for Hardy.
* From postinst, actually remove the example bash completion scripts.
  (LP: #249452)
* New upstream release.
* New upstream release.
* New upstream release.
* Revert change to Build-depends: Dapper does not have python-central.
  Should be python-support..
* Target ppa..
* Target ppa..
* Target ppa..
* Target ppa..
* New upstream release.
* Switch to dpkg-source 3.0 (quilt) format.
* Bump standards version to 3.8.4.
* Remove embedded copy of python-configobj. Closes: #555336
* Remove embedded copy of python-elementtree. Closes: #555343
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* debian/control: Fix obsolete-relation-form-in-source
  lintian warning. 
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Split out docs into bzr-doc package.
* New upstream release.
* Added John Francesco Ferlito to Uploaders.
* Fix install path to quick-reference guide
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to doc paths changing
* New upstream release.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to doc paths changing
* New upstream release.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to doc paths changing
* New upstream release.
* Fix FTBFS due to path changes, again, again.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to path changes.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Bump standards version to 3.8.3.
* Remove unused patch system.
* New upstream release.
* New upstream release.
* New upstream release.
* Fix copy and paste tab error in .install file
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
 + Fixes compatibility with Python 2.4. Closes: #537708
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream version.
* Bump standards version to 3.8.2.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Add python-pyrex to build-deps to ensure C extensions are always build.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Split documentation into bzr-doc package. ((LP: #385074)
* Multiple packaging changes to make us more linitan clean.
* New upstream release.
* Split documentation into bzr-doc package. ((LP: #385074)
* Multiple packaging changes to make us more linitan clean.
* New upstream release.
* Split documentation into bzr-doc package. ((LP: #385074)
* Multiple packaging changes to make us more linitan clean.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Fix API compatibility version. (Closes: #526233)
* New upstream release.
  + Fixes default format for upgrade command. (Closes: #464688)
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Add missing dependency on zlib development library. (Closes:
  #523595)
* Add zlib build-depends.
* Add zlib build-depends.
* Add zlib build-depends.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Move to section vcs.
* Bump standards version to 3.8.1.
* New upstream release.
* Remove temporary patch for missing .c files from distribution
* New upstream release.
* Remove temporary patch for missing .c files from distribution
* New upstream release.
* Remove temporary patch for missing .c files from distribution
* Add temporary patch for missing .c files from distribution
* Add temporary patch for missing .c files from distribution
* Add temporary patch for missing .c files from distribution
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Recommend ca-certificates. (Closes: #452024)
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Update watch file. bazaar now uses launchpad to host its sources.
* Remove patch for inventory root revision copy, applied upstream.
* New upstream release.
* New upstream release.
* New upstream release
* Force removal of files installed in error to /etc/bash_completion.d/
  (LP: #249452)
* New upstream release.
* New upstream release
* New upstream release.
* Bump standards version.
* Include patch for inventory root revision copy, required for bzr-svn.
* New upstream release.
* Remove unused lintian overrides.
* Correct the package version not to be native.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Final 1.5 release.
* New upstream release.
* New upstream release.
* New upstream release.
* Add myself as a co-maintainer.
* Add a Dm-Upload-Allowed: yes header.
* New upstream bugfix release.
* New upstream release.
* Final 1.3 release.
* New upstream release.
* First release candidate of the upcoming 1.3 release.
* Rebuild to fix the problem caused by a build with a broken python-central.
* New upstream release.
* Rebuild for dapper PPA.
* Apply Lamont's patches to fix build-dependencies on dapper.
  (See: https://bugs.launchpad.net/bzr/+bug/189915)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/sftp.py
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Implementation of Transport over SFTP, using paramiko."""
 
18
 
 
19
# TODO: Remove the transport-based lock_read and lock_write methods.  They'll
 
20
# then raise TransportNotPossible, which will break remote access to any
 
21
# formats which rely on OS-level locks.  That should be fine as those formats
 
22
# are pretty old, but these combinations may have to be removed from the test
 
23
# suite.  Those formats all date back to 0.7; so we should be able to remove
 
24
# these methods when we officially drop support for those formats.
 
25
 
 
26
import bisect
 
27
import errno
 
28
import itertools
 
29
import os
 
30
import random
 
31
import stat
 
32
import sys
 
33
import time
 
34
import urllib
 
35
import urlparse
 
36
import warnings
 
37
 
 
38
from bzrlib import (
 
39
    config,
 
40
    debug,
 
41
    errors,
 
42
    urlutils,
 
43
    )
 
44
from bzrlib.errors import (FileExists,
 
45
                           NoSuchFile, PathNotChild,
 
46
                           TransportError,
 
47
                           LockError,
 
48
                           PathError,
 
49
                           ParamikoNotPresent,
 
50
                           )
 
51
from bzrlib.osutils import pathjoin, fancy_rename, getcwd
 
52
from bzrlib.symbol_versioning import (
 
53
        deprecated_function,
 
54
        )
 
55
from bzrlib.trace import mutter, warning
 
56
from bzrlib.transport import (
 
57
    FileFileStream,
 
58
    _file_streams,
 
59
    local,
 
60
    Server,
 
61
    ssh,
 
62
    ConnectedTransport,
 
63
    )
 
64
 
 
65
# Disable one particular warning that comes from paramiko in Python2.5; if
 
66
# this is emitted at the wrong time it tends to cause spurious test failures
 
67
# or at least noise in the test case::
 
68
#
 
69
# [1770/7639 in 86s, 1 known failures, 50 skipped, 2 missing features]
 
70
# test_permissions.TestSftpPermissions.test_new_files
 
71
# /var/lib/python-support/python2.5/paramiko/message.py:226: DeprecationWarning: integer argument expected, got float
 
72
#  self.packet.write(struct.pack('>I', n))
 
73
warnings.filterwarnings('ignore',
 
74
        'integer argument expected, got float',
 
75
        category=DeprecationWarning,
 
76
        module='paramiko.message')
 
77
 
 
78
try:
 
79
    import paramiko
 
80
except ImportError, e:
 
81
    raise ParamikoNotPresent(e)
 
82
else:
 
83
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
 
84
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
 
85
                               CMD_HANDLE, CMD_OPEN)
 
86
    from paramiko.sftp_attr import SFTPAttributes
 
87
    from paramiko.sftp_file import SFTPFile
 
88
 
 
89
 
 
90
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
 
91
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
 
92
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
 
93
 
 
94
 
 
95
class SFTPLock(object):
 
96
    """This fakes a lock in a remote location.
 
97
 
 
98
    A present lock is indicated just by the existence of a file.  This
 
99
    doesn't work well on all transports and they are only used in
 
100
    deprecated storage formats.
 
101
    """
 
102
 
 
103
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
 
104
 
 
105
    def __init__(self, path, transport):
 
106
        self.lock_file = None
 
107
        self.path = path
 
108
        self.lock_path = path + '.write-lock'
 
109
        self.transport = transport
 
110
        try:
 
111
            # RBC 20060103 FIXME should we be using private methods here ?
 
112
            abspath = transport._remote_path(self.lock_path)
 
113
            self.lock_file = transport._sftp_open_exclusive(abspath)
 
114
        except FileExists:
 
115
            raise LockError('File %r already locked' % (self.path,))
 
116
 
 
117
    def __del__(self):
 
118
        """Should this warn, or actually try to cleanup?"""
 
119
        if self.lock_file:
 
120
            warning("SFTPLock %r not explicitly unlocked" % (self.path,))
 
121
            self.unlock()
 
122
 
 
123
    def unlock(self):
 
124
        if not self.lock_file:
 
125
            return
 
126
        self.lock_file.close()
 
127
        self.lock_file = None
 
128
        try:
 
129
            self.transport.delete(self.lock_path)
 
130
        except (NoSuchFile,):
 
131
            # What specific errors should we catch here?
 
132
            pass
 
133
 
 
134
 
 
135
class _SFTPReadvHelper(object):
 
136
    """A class to help with managing the state of a readv request."""
 
137
 
 
138
    # See _get_requests for an explanation.
 
139
    _max_request_size = 32768
 
140
 
 
141
    def __init__(self, original_offsets, relpath, _report_activity):
 
142
        """Create a new readv helper.
 
143
 
 
144
        :param original_offsets: The original requests given by the caller of
 
145
            readv()
 
146
        :param relpath: The name of the file (if known)
 
147
        :param _report_activity: A Transport._report_activity bound method,
 
148
            to be called as data arrives.
 
149
        """
 
150
        self.original_offsets = list(original_offsets)
 
151
        self.relpath = relpath
 
152
        self._report_activity = _report_activity
 
153
 
 
154
    def _get_requests(self):
 
155
        """Break up the offsets into individual requests over sftp.
 
156
 
 
157
        The SFTP spec only requires implementers to support 32kB requests. We
 
158
        could try something larger (openssh supports 64kB), but then we have to
 
159
        handle requests that fail.
 
160
        So instead, we just break up our maximum chunks into 32kB chunks, and
 
161
        asyncronously requests them.
 
162
        Newer versions of paramiko would do the chunking for us, but we want to
 
163
        start processing results right away, so we do it ourselves.
 
164
        """
 
165
        # TODO: Because we issue async requests, we don't 'fudge' any extra
 
166
        #       data.  I'm not 100% sure that is the best choice.
 
167
 
 
168
        # The first thing we do, is to collapse the individual requests as much
 
169
        # as possible, so we don't issues requests <32kB
 
170
        sorted_offsets = sorted(self.original_offsets)
 
171
        coalesced = list(ConnectedTransport._coalesce_offsets(sorted_offsets,
 
172
                                                        limit=0, fudge_factor=0))
 
173
        requests = []
 
174
        for c_offset in coalesced:
 
175
            start = c_offset.start
 
176
            size = c_offset.length
 
177
 
 
178
            # Break this up into 32kB requests
 
179
            while size > 0:
 
180
                next_size = min(size, self._max_request_size)
 
181
                requests.append((start, next_size))
 
182
                size -= next_size
 
183
                start += next_size
 
184
        if 'sftp' in debug.debug_flags:
 
185
            mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',
 
186
                self.relpath, len(sorted_offsets), len(coalesced),
 
187
                len(requests))
 
188
        return requests
 
189
 
 
190
    def request_and_yield_offsets(self, fp):
 
191
        """Request the data from the remote machine, yielding the results.
 
192
 
 
193
        :param fp: A Paramiko SFTPFile object that supports readv.
 
194
        :return: Yield the data requested by the original readv caller, one by
 
195
            one.
 
196
        """
 
197
        requests = self._get_requests()
 
198
        offset_iter = iter(self.original_offsets)
 
199
        cur_offset, cur_size = offset_iter.next()
 
200
        # paramiko .readv() yields strings that are in the order of the requests
 
201
        # So we track the current request to know where the next data is
 
202
        # being returned from.
 
203
        input_start = None
 
204
        last_end = None
 
205
        buffered_data = []
 
206
        buffered_len = 0
 
207
 
 
208
        # This is used to buffer chunks which we couldn't process yet
 
209
        # It is (start, end, data) tuples.
 
210
        data_chunks = []
 
211
        # Create an 'unlimited' data stream, so we stop based on requests,
 
212
        # rather than just because the data stream ended. This lets us detect
 
213
        # short readv.
 
214
        data_stream = itertools.chain(fp.readv(requests),
 
215
                                      itertools.repeat(None))
 
216
        for (start, length), data in itertools.izip(requests, data_stream):
 
217
            if data is None:
 
218
                if cur_coalesced is not None:
 
219
                    raise errors.ShortReadvError(self.relpath,
 
220
                        start, length, len(data))
 
221
            if len(data) != length:
 
222
                raise errors.ShortReadvError(self.relpath,
 
223
                    start, length, len(data))
 
224
            self._report_activity(length, 'read')
 
225
            if last_end is None:
 
226
                # This is the first request, just buffer it
 
227
                buffered_data = [data]
 
228
                buffered_len = length
 
229
                input_start = start
 
230
            elif start == last_end:
 
231
                # The data we are reading fits neatly on the previous
 
232
                # buffer, so this is all part of a larger coalesced range.
 
233
                buffered_data.append(data)
 
234
                buffered_len += length
 
235
            else:
 
236
                # We have an 'interrupt' in the data stream. So we know we are
 
237
                # at a request boundary.
 
238
                if buffered_len > 0:
 
239
                    # We haven't consumed the buffer so far, so put it into
 
240
                    # data_chunks, and continue.
 
241
                    buffered = ''.join(buffered_data)
 
242
                    data_chunks.append((input_start, buffered))
 
243
                input_start = start
 
244
                buffered_data = [data]
 
245
                buffered_len = length
 
246
            last_end = start + length
 
247
            if input_start == cur_offset and cur_size <= buffered_len:
 
248
                # Simplify the next steps a bit by transforming buffered_data
 
249
                # into a single string. We also have the nice property that
 
250
                # when there is only one string ''.join([x]) == x, so there is
 
251
                # no data copying.
 
252
                buffered = ''.join(buffered_data)
 
253
                # Clean out buffered data so that we keep memory
 
254
                # consumption low
 
255
                del buffered_data[:]
 
256
                buffered_offset = 0
 
257
                # TODO: We *could* also consider the case where cur_offset is in
 
258
                #       in the buffered range, even though it doesn't *start*
 
259
                #       the buffered range. But for packs we pretty much always
 
260
                #       read in order, so you won't get any extra data in the
 
261
                #       middle.
 
262
                while (input_start == cur_offset
 
263
                       and (buffered_offset + cur_size) <= buffered_len):
 
264
                    # We've buffered enough data to process this request, spit it
 
265
                    # out
 
266
                    cur_data = buffered[buffered_offset:buffered_offset + cur_size]
 
267
                    # move the direct pointer into our buffered data
 
268
                    buffered_offset += cur_size
 
269
                    # Move the start-of-buffer pointer
 
270
                    input_start += cur_size
 
271
                    # Yield the requested data
 
272
                    yield cur_offset, cur_data
 
273
                    cur_offset, cur_size = offset_iter.next()
 
274
                # at this point, we've consumed as much of buffered as we can,
 
275
                # so break off the portion that we consumed
 
276
                if buffered_offset == len(buffered_data):
 
277
                    # No tail to leave behind
 
278
                    buffered_data = []
 
279
                    buffered_len = 0
 
280
                else:
 
281
                    buffered = buffered[buffered_offset:]
 
282
                    buffered_data = [buffered]
 
283
                    buffered_len = len(buffered)
 
284
        if buffered_len:
 
285
            buffered = ''.join(buffered_data)
 
286
            del buffered_data[:]
 
287
            data_chunks.append((input_start, buffered))
 
288
        if data_chunks:
 
289
            if 'sftp' in debug.debug_flags:
 
290
                mutter('SFTP readv left with %d out-of-order bytes',
 
291
                    sum(map(lambda x: len(x[1]), data_chunks)))
 
292
            # We've processed all the readv data, at this point, anything we
 
293
            # couldn't process is in data_chunks. This doesn't happen often, so
 
294
            # this code path isn't optimized
 
295
            # We use an interesting process for data_chunks
 
296
            # Specifically if we have "bisect_left([(start, len, entries)],
 
297
            #                                       (qstart,)])
 
298
            # If start == qstart, then we get the specific node. Otherwise we
 
299
            # get the previous node
 
300
            while True:
 
301
                idx = bisect.bisect_left(data_chunks, (cur_offset,))
 
302
                if idx < len(data_chunks) and data_chunks[idx][0] == cur_offset:
 
303
                    # The data starts here
 
304
                    data = data_chunks[idx][1][:cur_size]
 
305
                elif idx > 0:
 
306
                    # The data is in a portion of a previous page
 
307
                    idx -= 1
 
308
                    sub_offset = cur_offset - data_chunks[idx][0]
 
309
                    data = data_chunks[idx][1]
 
310
                    data = data[sub_offset:sub_offset + cur_size]
 
311
                else:
 
312
                    # We are missing the page where the data should be found,
 
313
                    # something is wrong
 
314
                    data = ''
 
315
                if len(data) != cur_size:
 
316
                    raise AssertionError('We must have miscalulated.'
 
317
                        ' We expected %d bytes, but only found %d'
 
318
                        % (cur_size, len(data)))
 
319
                yield cur_offset, data
 
320
                cur_offset, cur_size = offset_iter.next()
 
321
 
 
322
 
 
323
class SFTPTransport(ConnectedTransport):
 
324
    """Transport implementation for SFTP access."""
 
325
 
 
326
    _do_prefetch = _default_do_prefetch
 
327
    # TODO: jam 20060717 Conceivably these could be configurable, either
 
328
    #       by auto-tuning at run-time, or by a configuration (per host??)
 
329
    #       but the performance curve is pretty flat, so just going with
 
330
    #       reasonable defaults.
 
331
    _max_readv_combine = 200
 
332
    # Having to round trip to the server means waiting for a response,
 
333
    # so it is better to download extra bytes.
 
334
    # 8KiB had good performance for both local and remote network operations
 
335
    _bytes_to_read_before_seek = 8192
 
336
 
 
337
    # The sftp spec says that implementations SHOULD allow reads
 
338
    # to be at least 32K. paramiko.readv() does an async request
 
339
    # for the chunks. So we need to keep it within a single request
 
340
    # size for paramiko <= 1.6.1. paramiko 1.6.2 will probably chop
 
341
    # up the request itself, rather than us having to worry about it
 
342
    _max_request_size = 32768
 
343
 
 
344
    def __init__(self, base, _from_transport=None):
 
345
        super(SFTPTransport, self).__init__(base,
 
346
                                            _from_transport=_from_transport)
 
347
 
 
348
    def _remote_path(self, relpath):
 
349
        """Return the path to be passed along the sftp protocol for relpath.
 
350
 
 
351
        :param relpath: is a urlencoded string.
 
352
        """
 
353
        relative = urlutils.unescape(relpath).encode('utf-8')
 
354
        remote_path = self._combine_paths(self._path, relative)
 
355
        # the initial slash should be removed from the path, and treated as a
 
356
        # homedir relative path (the path begins with a double slash if it is
 
357
        # absolute).  see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
 
358
        # RBC 20060118 we are not using this as its too user hostile. instead
 
359
        # we are following lftp and using /~/foo to mean '~/foo'
 
360
        # vila--20070602 and leave absolute paths begin with a single slash.
 
361
        if remote_path.startswith('/~/'):
 
362
            remote_path = remote_path[3:]
 
363
        elif remote_path == '/~':
 
364
            remote_path = ''
 
365
        return remote_path
 
366
 
 
367
    def _create_connection(self, credentials=None):
 
368
        """Create a new connection with the provided credentials.
 
369
 
 
370
        :param credentials: The credentials needed to establish the connection.
 
371
 
 
372
        :return: The created connection and its associated credentials.
 
373
 
 
374
        The credentials are only the password as it may have been entered
 
375
        interactively by the user and may be different from the one provided
 
376
        in base url at transport creation time.
 
377
        """
 
378
        if credentials is None:
 
379
            password = self._password
 
380
        else:
 
381
            password = credentials
 
382
 
 
383
        vendor = ssh._get_ssh_vendor()
 
384
        user = self._user
 
385
        if user is None:
 
386
            auth = config.AuthenticationConfig()
 
387
            user = auth.get_user('ssh', self._host, self._port)
 
388
        connection = vendor.connect_sftp(self._user, password,
 
389
                                         self._host, self._port)
 
390
        return connection, (user, password)
 
391
 
 
392
    def _get_sftp(self):
 
393
        """Ensures that a connection is established"""
 
394
        connection = self._get_connection()
 
395
        if connection is None:
 
396
            # First connection ever
 
397
            connection, credentials = self._create_connection()
 
398
            self._set_connection(connection, credentials)
 
399
        return connection
 
400
 
 
401
    def has(self, relpath):
 
402
        """
 
403
        Does the target location exist?
 
404
        """
 
405
        try:
 
406
            self._get_sftp().stat(self._remote_path(relpath))
 
407
            # stat result is about 20 bytes, let's say
 
408
            self._report_activity(20, 'read')
 
409
            return True
 
410
        except IOError:
 
411
            return False
 
412
 
 
413
    def get(self, relpath):
 
414
        """Get the file at the given relative path.
 
415
 
 
416
        :param relpath: The relative path to the file
 
417
        """
 
418
        try:
 
419
            # FIXME: by returning the file directly, we don't pass this
 
420
            # through to report_activity.  We could try wrapping the object
 
421
            # before it's returned.  For readv and get_bytes it's handled in
 
422
            # the higher-level function.
 
423
            # -- mbp 20090126
 
424
            path = self._remote_path(relpath)
 
425
            f = self._get_sftp().file(path, mode='rb')
 
426
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
 
427
                f.prefetch()
 
428
            return f
 
429
        except (IOError, paramiko.SSHException), e:
 
430
            self._translate_io_exception(e, path, ': error retrieving',
 
431
                failure_exc=errors.ReadError)
 
432
 
 
433
    def get_bytes(self, relpath):
 
434
        # reimplement this here so that we can report how many bytes came back
 
435
        f = self.get(relpath)
 
436
        try:
 
437
            bytes = f.read()
 
438
            self._report_activity(len(bytes), 'read')
 
439
            return bytes
 
440
        finally:
 
441
            f.close()
 
442
 
 
443
    def _readv(self, relpath, offsets):
 
444
        """See Transport.readv()"""
 
445
        # We overload the default readv() because we want to use a file
 
446
        # that does not have prefetch enabled.
 
447
        # Also, if we have a new paramiko, it implements an async readv()
 
448
        if not offsets:
 
449
            return
 
450
 
 
451
        try:
 
452
            path = self._remote_path(relpath)
 
453
            fp = self._get_sftp().file(path, mode='rb')
 
454
            readv = getattr(fp, 'readv', None)
 
455
            if readv:
 
456
                return self._sftp_readv(fp, offsets, relpath)
 
457
            if 'sftp' in debug.debug_flags:
 
458
                mutter('seek and read %s offsets', len(offsets))
 
459
            return self._seek_and_read(fp, offsets, relpath)
 
460
        except (IOError, paramiko.SSHException), e:
 
461
            self._translate_io_exception(e, path, ': error retrieving')
 
462
 
 
463
    def recommended_page_size(self):
 
464
        """See Transport.recommended_page_size().
 
465
 
 
466
        For SFTP we suggest a large page size to reduce the overhead
 
467
        introduced by latency.
 
468
        """
 
469
        return 64 * 1024
 
470
 
 
471
    def _sftp_readv(self, fp, offsets, relpath):
 
472
        """Use the readv() member of fp to do async readv.
 
473
 
 
474
        Then read them using paramiko.readv(). paramiko.readv()
 
475
        does not support ranges > 64K, so it caps the request size, and
 
476
        just reads until it gets all the stuff it wants.
 
477
        """
 
478
        helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
 
479
        return helper.request_and_yield_offsets(fp)
 
480
 
 
481
    def put_file(self, relpath, f, mode=None):
 
482
        """
 
483
        Copy the file-like object into the location.
 
484
 
 
485
        :param relpath: Location to put the contents, relative to base.
 
486
        :param f:       File-like object.
 
487
        :param mode: The final mode for the file
 
488
        """
 
489
        final_path = self._remote_path(relpath)
 
490
        return self._put(final_path, f, mode=mode)
 
491
 
 
492
    def _put(self, abspath, f, mode=None):
 
493
        """Helper function so both put() and copy_abspaths can reuse the code"""
 
494
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
 
495
                        os.getpid(), random.randint(0,0x7FFFFFFF))
 
496
        fout = self._sftp_open_exclusive(tmp_abspath, mode=mode)
 
497
        closed = False
 
498
        try:
 
499
            try:
 
500
                fout.set_pipelined(True)
 
501
                length = self._pump(f, fout)
 
502
            except (IOError, paramiko.SSHException), e:
 
503
                self._translate_io_exception(e, tmp_abspath)
 
504
            # XXX: This doesn't truly help like we would like it to.
 
505
            #      The problem is that openssh strips sticky bits. So while we
 
506
            #      can properly set group write permission, we lose the group
 
507
            #      sticky bit. So it is probably best to stop chmodding, and
 
508
            #      just tell users that they need to set the umask correctly.
 
509
            #      The attr.st_mode = mode, in _sftp_open_exclusive
 
510
            #      will handle when the user wants the final mode to be more
 
511
            #      restrictive. And then we avoid a round trip. Unless
 
512
            #      paramiko decides to expose an async chmod()
 
513
 
 
514
            # This is designed to chmod() right before we close.
 
515
            # Because we set_pipelined() earlier, theoretically we might
 
516
            # avoid the round trip for fout.close()
 
517
            if mode is not None:
 
518
                self._get_sftp().chmod(tmp_abspath, mode)
 
519
            fout.close()
 
520
            closed = True
 
521
            self._rename_and_overwrite(tmp_abspath, abspath)
 
522
            return length
 
523
        except Exception, e:
 
524
            # If we fail, try to clean up the temporary file
 
525
            # before we throw the exception
 
526
            # but don't let another exception mess things up
 
527
            # Write out the traceback, because otherwise
 
528
            # the catch and throw destroys it
 
529
            import traceback
 
530
            mutter(traceback.format_exc())
 
531
            try:
 
532
                if not closed:
 
533
                    fout.close()
 
534
                self._get_sftp().remove(tmp_abspath)
 
535
            except:
 
536
                # raise the saved except
 
537
                raise e
 
538
            # raise the original with its traceback if we can.
 
539
            raise
 
540
 
 
541
    def _put_non_atomic_helper(self, relpath, writer, mode=None,
 
542
                               create_parent_dir=False,
 
543
                               dir_mode=None):
 
544
        abspath = self._remote_path(relpath)
 
545
 
 
546
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
 
547
        #       set the file mode at create time. If it does, use it.
 
548
        #       But for now, we just chmod later anyway.
 
549
 
 
550
        def _open_and_write_file():
 
551
            """Try to open the target file, raise error on failure"""
 
552
            fout = None
 
553
            try:
 
554
                try:
 
555
                    fout = self._get_sftp().file(abspath, mode='wb')
 
556
                    fout.set_pipelined(True)
 
557
                    writer(fout)
 
558
                except (paramiko.SSHException, IOError), e:
 
559
                    self._translate_io_exception(e, abspath,
 
560
                                                 ': unable to open')
 
561
 
 
562
                # This is designed to chmod() right before we close.
 
563
                # Because we set_pipelined() earlier, theoretically we might
 
564
                # avoid the round trip for fout.close()
 
565
                if mode is not None:
 
566
                    self._get_sftp().chmod(abspath, mode)
 
567
            finally:
 
568
                if fout is not None:
 
569
                    fout.close()
 
570
 
 
571
        if not create_parent_dir:
 
572
            _open_and_write_file()
 
573
            return
 
574
 
 
575
        # Try error handling to create the parent directory if we need to
 
576
        try:
 
577
            _open_and_write_file()
 
578
        except NoSuchFile:
 
579
            # Try to create the parent directory, and then go back to
 
580
            # writing the file
 
581
            parent_dir = os.path.dirname(abspath)
 
582
            self._mkdir(parent_dir, dir_mode)
 
583
            _open_and_write_file()
 
584
 
 
585
    def put_file_non_atomic(self, relpath, f, mode=None,
 
586
                            create_parent_dir=False,
 
587
                            dir_mode=None):
 
588
        """Copy the file-like object into the target location.
 
589
 
 
590
        This function is not strictly safe to use. It is only meant to
 
591
        be used when you already know that the target does not exist.
 
592
        It is not safe, because it will open and truncate the remote
 
593
        file. So there may be a time when the file has invalid contents.
 
594
 
 
595
        :param relpath: The remote location to put the contents.
 
596
        :param f:       File-like object.
 
597
        :param mode:    Possible access permissions for new file.
 
598
                        None means do not set remote permissions.
 
599
        :param create_parent_dir: If we cannot create the target file because
 
600
                        the parent directory does not exist, go ahead and
 
601
                        create it, and then try again.
 
602
        """
 
603
        def writer(fout):
 
604
            self._pump(f, fout)
 
605
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
606
                                    create_parent_dir=create_parent_dir,
 
607
                                    dir_mode=dir_mode)
 
608
 
 
609
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
 
610
                             create_parent_dir=False,
 
611
                             dir_mode=None):
 
612
        def writer(fout):
 
613
            fout.write(bytes)
 
614
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
615
                                    create_parent_dir=create_parent_dir,
 
616
                                    dir_mode=dir_mode)
 
617
 
 
618
    def iter_files_recursive(self):
 
619
        """Walk the relative paths of all files in this transport."""
 
620
        # progress is handled by list_dir
 
621
        queue = list(self.list_dir('.'))
 
622
        while queue:
 
623
            relpath = queue.pop(0)
 
624
            st = self.stat(relpath)
 
625
            if stat.S_ISDIR(st.st_mode):
 
626
                for i, basename in enumerate(self.list_dir(relpath)):
 
627
                    queue.insert(i, relpath+'/'+basename)
 
628
            else:
 
629
                yield relpath
 
630
 
 
631
    def _mkdir(self, abspath, mode=None):
 
632
        if mode is None:
 
633
            local_mode = 0777
 
634
        else:
 
635
            local_mode = mode
 
636
        try:
 
637
            self._report_activity(len(abspath), 'write')
 
638
            self._get_sftp().mkdir(abspath, local_mode)
 
639
            self._report_activity(1, 'read')
 
640
            if mode is not None:
 
641
                # chmod a dir through sftp will erase any sgid bit set
 
642
                # on the server side.  So, if the bit mode are already
 
643
                # set, avoid the chmod.  If the mode is not fine but
 
644
                # the sgid bit is set, report a warning to the user
 
645
                # with the umask fix.
 
646
                stat = self._get_sftp().lstat(abspath)
 
647
                mode = mode & 0777 # can't set special bits anyway
 
648
                if mode != stat.st_mode & 0777:
 
649
                    if stat.st_mode & 06000:
 
650
                        warning('About to chmod %s over sftp, which will result'
 
651
                                ' in its suid or sgid bits being cleared.  If'
 
652
                                ' you want to preserve those bits, change your '
 
653
                                ' environment on the server to use umask 0%03o.'
 
654
                                % (abspath, 0777 - mode))
 
655
                    self._get_sftp().chmod(abspath, mode=mode)
 
656
        except (paramiko.SSHException, IOError), e:
 
657
            self._translate_io_exception(e, abspath, ': unable to mkdir',
 
658
                failure_exc=FileExists)
 
659
 
 
660
    def mkdir(self, relpath, mode=None):
 
661
        """Create a directory at the given path."""
 
662
        self._mkdir(self._remote_path(relpath), mode=mode)
 
663
 
 
664
    def open_write_stream(self, relpath, mode=None):
 
665
        """See Transport.open_write_stream."""
 
666
        # initialise the file to zero-length
 
667
        # this is three round trips, but we don't use this
 
668
        # api more than once per write_group at the moment so
 
669
        # it is a tolerable overhead. Better would be to truncate
 
670
        # the file after opening. RBC 20070805
 
671
        self.put_bytes_non_atomic(relpath, "", mode)
 
672
        abspath = self._remote_path(relpath)
 
673
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
 
674
        #       set the file mode at create time. If it does, use it.
 
675
        #       But for now, we just chmod later anyway.
 
676
        handle = None
 
677
        try:
 
678
            handle = self._get_sftp().file(abspath, mode='wb')
 
679
            handle.set_pipelined(True)
 
680
        except (paramiko.SSHException, IOError), e:
 
681
            self._translate_io_exception(e, abspath,
 
682
                                         ': unable to open')
 
683
        _file_streams[self.abspath(relpath)] = handle
 
684
        return FileFileStream(self, relpath, handle)
 
685
 
 
686
    def _translate_io_exception(self, e, path, more_info='',
 
687
                                failure_exc=PathError):
 
688
        """Translate a paramiko or IOError into a friendlier exception.
 
689
 
 
690
        :param e: The original exception
 
691
        :param path: The path in question when the error is raised
 
692
        :param more_info: Extra information that can be included,
 
693
                          such as what was going on
 
694
        :param failure_exc: Paramiko has the super fun ability to raise completely
 
695
                           opaque errors that just set "e.args = ('Failure',)" with
 
696
                           no more information.
 
697
                           If this parameter is set, it defines the exception
 
698
                           to raise in these cases.
 
699
        """
 
700
        # paramiko seems to generate detailless errors.
 
701
        self._translate_error(e, path, raise_generic=False)
 
702
        if getattr(e, 'args', None) is not None:
 
703
            if (e.args == ('No such file or directory',) or
 
704
                e.args == ('No such file',)):
 
705
                raise NoSuchFile(path, str(e) + more_info)
 
706
            if (e.args == ('mkdir failed',) or
 
707
                e.args[0].startswith('syserr: File exists')):
 
708
                raise FileExists(path, str(e) + more_info)
 
709
            # strange but true, for the paramiko server.
 
710
            if (e.args == ('Failure',)):
 
711
                raise failure_exc(path, str(e) + more_info)
 
712
            # Can be something like args = ('Directory not empty:
 
713
            # '/srv/bazaar.launchpad.net/blah...: '
 
714
            # [Errno 39] Directory not empty',)
 
715
            if (e.args[0].startswith('Directory not empty: ')
 
716
                or getattr(e, 'errno', None) == errno.ENOTEMPTY):
 
717
                raise errors.DirectoryNotEmpty(path, str(e))
 
718
            mutter('Raising exception with args %s', e.args)
 
719
        if getattr(e, 'errno', None) is not None:
 
720
            mutter('Raising exception with errno %s', e.errno)
 
721
        raise e
 
722
 
 
723
    def append_file(self, relpath, f, mode=None):
 
724
        """
 
725
        Append the text in the file-like object into the final
 
726
        location.
 
727
        """
 
728
        try:
 
729
            path = self._remote_path(relpath)
 
730
            fout = self._get_sftp().file(path, 'ab')
 
731
            if mode is not None:
 
732
                self._get_sftp().chmod(path, mode)
 
733
            result = fout.tell()
 
734
            self._pump(f, fout)
 
735
            return result
 
736
        except (IOError, paramiko.SSHException), e:
 
737
            self._translate_io_exception(e, relpath, ': unable to append')
 
738
 
 
739
    def rename(self, rel_from, rel_to):
 
740
        """Rename without special overwriting"""
 
741
        try:
 
742
            self._get_sftp().rename(self._remote_path(rel_from),
 
743
                              self._remote_path(rel_to))
 
744
        except (IOError, paramiko.SSHException), e:
 
745
            self._translate_io_exception(e, rel_from,
 
746
                    ': unable to rename to %r' % (rel_to))
 
747
 
 
748
    def _rename_and_overwrite(self, abs_from, abs_to):
 
749
        """Do a fancy rename on the remote server.
 
750
 
 
751
        Using the implementation provided by osutils.
 
752
        """
 
753
        try:
 
754
            sftp = self._get_sftp()
 
755
            fancy_rename(abs_from, abs_to,
 
756
                         rename_func=sftp.rename,
 
757
                         unlink_func=sftp.remove)
 
758
        except (IOError, paramiko.SSHException), e:
 
759
            self._translate_io_exception(e, abs_from,
 
760
                                         ': unable to rename to %r' % (abs_to))
 
761
 
 
762
    def move(self, rel_from, rel_to):
 
763
        """Move the item at rel_from to the location at rel_to"""
 
764
        path_from = self._remote_path(rel_from)
 
765
        path_to = self._remote_path(rel_to)
 
766
        self._rename_and_overwrite(path_from, path_to)
 
767
 
 
768
    def delete(self, relpath):
 
769
        """Delete the item at relpath"""
 
770
        path = self._remote_path(relpath)
 
771
        try:
 
772
            self._get_sftp().remove(path)
 
773
        except (IOError, paramiko.SSHException), e:
 
774
            self._translate_io_exception(e, path, ': unable to delete')
 
775
 
 
776
    def external_url(self):
 
777
        """See bzrlib.transport.Transport.external_url."""
 
778
        # the external path for SFTP is the base
 
779
        return self.base
 
780
 
 
781
    def listable(self):
 
782
        """Return True if this store supports listing."""
 
783
        return True
 
784
 
 
785
    def list_dir(self, relpath):
 
786
        """
 
787
        Return a list of all files at the given location.
 
788
        """
 
789
        # does anything actually use this?
 
790
        # -- Unknown
 
791
        # This is at least used by copy_tree for remote upgrades.
 
792
        # -- David Allouche 2006-08-11
 
793
        path = self._remote_path(relpath)
 
794
        try:
 
795
            entries = self._get_sftp().listdir(path)
 
796
            self._report_activity(sum(map(len, entries)), 'read')
 
797
        except (IOError, paramiko.SSHException), e:
 
798
            self._translate_io_exception(e, path, ': failed to list_dir')
 
799
        return [urlutils.escape(entry) for entry in entries]
 
800
 
 
801
    def rmdir(self, relpath):
 
802
        """See Transport.rmdir."""
 
803
        path = self._remote_path(relpath)
 
804
        try:
 
805
            return self._get_sftp().rmdir(path)
 
806
        except (IOError, paramiko.SSHException), e:
 
807
            self._translate_io_exception(e, path, ': failed to rmdir')
 
808
 
 
809
    def stat(self, relpath):
 
810
        """Return the stat information for a file."""
 
811
        path = self._remote_path(relpath)
 
812
        try:
 
813
            return self._get_sftp().stat(path)
 
814
        except (IOError, paramiko.SSHException), e:
 
815
            self._translate_io_exception(e, path, ': unable to stat')
 
816
 
 
817
    def lock_read(self, relpath):
 
818
        """
 
819
        Lock the given file for shared (read) access.
 
820
        :return: A lock object, which has an unlock() member function
 
821
        """
 
822
        # FIXME: there should be something clever i can do here...
 
823
        class BogusLock(object):
 
824
            def __init__(self, path):
 
825
                self.path = path
 
826
            def unlock(self):
 
827
                pass
 
828
        return BogusLock(relpath)
 
829
 
 
830
    def lock_write(self, relpath):
 
831
        """
 
832
        Lock the given file for exclusive (write) access.
 
833
        WARNING: many transports do not support this, so trying avoid using it
 
834
 
 
835
        :return: A lock object, which has an unlock() member function
 
836
        """
 
837
        # This is a little bit bogus, but basically, we create a file
 
838
        # which should not already exist, and if it does, we assume
 
839
        # that there is a lock, and if it doesn't, the we assume
 
840
        # that we have taken the lock.
 
841
        return SFTPLock(relpath, self)
 
842
 
 
843
    def _sftp_open_exclusive(self, abspath, mode=None):
 
844
        """Open a remote path exclusively.
 
845
 
 
846
        SFTP supports O_EXCL (SFTP_FLAG_EXCL), which fails if
 
847
        the file already exists. However it does not expose this
 
848
        at the higher level of SFTPClient.open(), so we have to
 
849
        sneak away with it.
 
850
 
 
851
        WARNING: This breaks the SFTPClient abstraction, so it
 
852
        could easily break against an updated version of paramiko.
 
853
 
 
854
        :param abspath: The remote absolute path where the file should be opened
 
855
        :param mode: The mode permissions bits for the new file
 
856
        """
 
857
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
 
858
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
 
859
        #       However, there is no way to set the permission mode at open
 
860
        #       time using the sftp_client.file() functionality.
 
861
        path = self._get_sftp()._adjust_cwd(abspath)
 
862
        # mutter('sftp abspath %s => %s', abspath, path)
 
863
        attr = SFTPAttributes()
 
864
        if mode is not None:
 
865
            attr.st_mode = mode
 
866
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
 
867
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
 
868
        try:
 
869
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
 
870
            if t != CMD_HANDLE:
 
871
                raise TransportError('Expected an SFTP handle')
 
872
            handle = msg.get_string()
 
873
            return SFTPFile(self._get_sftp(), handle, 'wb', -1)
 
874
        except (paramiko.SSHException, IOError), e:
 
875
            self._translate_io_exception(e, abspath, ': unable to open',
 
876
                failure_exc=FileExists)
 
877
 
 
878
    def _can_roundtrip_unix_modebits(self):
 
879
        if sys.platform == 'win32':
 
880
            # anyone else?
 
881
            return False
 
882
        else:
 
883
            return True
 
884
 
 
885
 
 
886
def get_test_permutations():
 
887
    """Return the permutations to be used in testing."""
 
888
    from bzrlib.tests import stub_sftp
 
889
    return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
 
890
            (SFTPTransport, stub_sftp.SFTPHomeDirServer),
 
891
            (SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
 
892
            ]