← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/sftp.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
 
2
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
12
13
#
13
14
# You should have received a copy of the GNU General Public License
14
15
# 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
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
"""Implementation of Transport over SFTP, using paramiko."""
18
19
 
23
24
# suite.  Those formats all date back to 0.7; so we should be able to remove
24
25
# these methods when we officially drop support for those formats.
25
26
 
26
 
import bisect
27
27
import errno
28
 
import itertools
29
28
import os
30
29
import random
 
30
import select
 
31
import socket
31
32
import stat
32
33
import sys
33
34
import time
34
 
import warnings
 
35
import urllib
 
36
import urlparse
35
37
 
36
38
from bzrlib import (
37
 
    config,
38
 
    debug,
39
39
    errors,
40
40
    urlutils,
41
41
    )
42
42
from bzrlib.errors import (FileExists,
43
 
                           NoSuchFile,
 
43
                           NoSuchFile, PathNotChild,
44
44
                           TransportError,
45
45
                           LockError,
46
46
                           PathError,
47
47
                           ParamikoNotPresent,
48
48
                           )
49
 
from bzrlib.osutils import fancy_rename
 
49
from bzrlib.osutils import pathjoin, fancy_rename, getcwd
 
50
from bzrlib.symbol_versioning import (
 
51
        deprecated_function,
 
52
        zero_nineteen,
 
53
        )
50
54
from bzrlib.trace import mutter, warning
51
55
from bzrlib.transport import (
52
 
    FileFileStream,
53
 
    _file_streams,
 
56
    local,
 
57
    register_urlparse_netloc_protocol,
 
58
    Server,
54
59
    ssh,
55
60
    ConnectedTransport,
56
61
    )
57
62
 
58
 
# Disable one particular warning that comes from paramiko in Python2.5; if
59
 
# this is emitted at the wrong time it tends to cause spurious test failures
60
 
# or at least noise in the test case::
61
 
#
62
 
# [1770/7639 in 86s, 1 known failures, 50 skipped, 2 missing features]
63
 
# test_permissions.TestSftpPermissions.test_new_files
64
 
# /var/lib/python-support/python2.5/paramiko/message.py:226: DeprecationWarning: integer argument expected, got float
65
 
#  self.packet.write(struct.pack('>I', n))
66
 
warnings.filterwarnings('ignore',
67
 
        'integer argument expected, got float',
68
 
        category=DeprecationWarning,
69
 
        module='paramiko.message')
70
 
 
71
63
try:
72
64
    import paramiko
73
65
except ImportError, e:
75
67
else:
76
68
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
77
69
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
78
 
                               SFTP_OK, CMD_HANDLE, CMD_OPEN)
 
70
                               CMD_HANDLE, CMD_OPEN)
79
71
    from paramiko.sftp_attr import SFTPAttributes
80
72
    from paramiko.sftp_file import SFTPFile
81
73
 
82
74
 
 
75
register_urlparse_netloc_protocol('sftp')
 
76
 
 
77
 
83
78
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
84
79
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
85
80
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
86
81
 
87
82
 
 
83
@deprecated_function(zero_nineteen)
 
84
def clear_connection_cache():
 
85
    """Remove all hosts from the SFTP connection cache.
 
86
 
 
87
    Primarily useful for test cases wanting to force garbage collection.
 
88
    We don't have a global connection cache anymore.
 
89
    """
 
90
 
88
91
class SFTPLock(object):
89
92
    """This fakes a lock in a remote location.
90
 
 
 
93
    
91
94
    A present lock is indicated just by the existence of a file.  This
92
 
    doesn't work well on all transports and they are only used in
 
95
    doesn't work well on all transports and they are only used in 
93
96
    deprecated storage formats.
94
97
    """
95
 
 
 
98
    
96
99
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
97
100
 
98
101
    def __init__(self, path, transport):
 
102
        assert isinstance(transport, SFTPTransport)
 
103
 
99
104
        self.lock_file = None
100
105
        self.path = path
101
106
        self.lock_path = path + '.write-lock'
107
112
        except FileExists:
108
113
            raise LockError('File %r already locked' % (self.path,))
109
114
 
 
115
    def __del__(self):
 
116
        """Should this warn, or actually try to cleanup?"""
 
117
        if self.lock_file:
 
118
            warning("SFTPLock %r not explicitly unlocked" % (self.path,))
 
119
            self.unlock()
 
120
 
110
121
    def unlock(self):
111
122
        if not self.lock_file:
112
123
            return
119
130
            pass
120
131
 
121
132
 
122
 
class _SFTPReadvHelper(object):
123
 
    """A class to help with managing the state of a readv request."""
124
 
 
125
 
    # See _get_requests for an explanation.
126
 
    _max_request_size = 32768
127
 
 
128
 
    def __init__(self, original_offsets, relpath, _report_activity):
129
 
        """Create a new readv helper.
130
 
 
131
 
        :param original_offsets: The original requests given by the caller of
132
 
            readv()
133
 
        :param relpath: The name of the file (if known)
134
 
        :param _report_activity: A Transport._report_activity bound method,
135
 
            to be called as data arrives.
136
 
        """
137
 
        self.original_offsets = list(original_offsets)
138
 
        self.relpath = relpath
139
 
        self._report_activity = _report_activity
140
 
 
141
 
    def _get_requests(self):
142
 
        """Break up the offsets into individual requests over sftp.
143
 
 
144
 
        The SFTP spec only requires implementers to support 32kB requests. We
145
 
        could try something larger (openssh supports 64kB), but then we have to
146
 
        handle requests that fail.
147
 
        So instead, we just break up our maximum chunks into 32kB chunks, and
148
 
        asyncronously requests them.
149
 
        Newer versions of paramiko would do the chunking for us, but we want to
150
 
        start processing results right away, so we do it ourselves.
151
 
        """
152
 
        # TODO: Because we issue async requests, we don't 'fudge' any extra
153
 
        #       data.  I'm not 100% sure that is the best choice.
154
 
 
155
 
        # The first thing we do, is to collapse the individual requests as much
156
 
        # as possible, so we don't issues requests <32kB
157
 
        sorted_offsets = sorted(self.original_offsets)
158
 
        coalesced = list(ConnectedTransport._coalesce_offsets(sorted_offsets,
159
 
                                                        limit=0, fudge_factor=0))
160
 
        requests = []
161
 
        for c_offset in coalesced:
162
 
            start = c_offset.start
163
 
            size = c_offset.length
164
 
 
165
 
            # Break this up into 32kB requests
166
 
            while size > 0:
167
 
                next_size = min(size, self._max_request_size)
168
 
                requests.append((start, next_size))
169
 
                size -= next_size
170
 
                start += next_size
171
 
        if 'sftp' in debug.debug_flags:
172
 
            mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',
173
 
                self.relpath, len(sorted_offsets), len(coalesced),
174
 
                len(requests))
175
 
        return requests
176
 
 
177
 
    def request_and_yield_offsets(self, fp):
178
 
        """Request the data from the remote machine, yielding the results.
179
 
 
180
 
        :param fp: A Paramiko SFTPFile object that supports readv.
181
 
        :return: Yield the data requested by the original readv caller, one by
182
 
            one.
183
 
        """
184
 
        requests = self._get_requests()
185
 
        offset_iter = iter(self.original_offsets)
186
 
        cur_offset, cur_size = offset_iter.next()
187
 
        # paramiko .readv() yields strings that are in the order of the requests
188
 
        # So we track the current request to know where the next data is
189
 
        # being returned from.
190
 
        input_start = None
191
 
        last_end = None
192
 
        buffered_data = []
193
 
        buffered_len = 0
194
 
 
195
 
        # This is used to buffer chunks which we couldn't process yet
196
 
        # It is (start, end, data) tuples.
197
 
        data_chunks = []
198
 
        # Create an 'unlimited' data stream, so we stop based on requests,
199
 
        # rather than just because the data stream ended. This lets us detect
200
 
        # short readv.
201
 
        data_stream = itertools.chain(fp.readv(requests),
202
 
                                      itertools.repeat(None))
203
 
        for (start, length), data in itertools.izip(requests, data_stream):
204
 
            if data is None:
205
 
                if cur_coalesced is not None:
206
 
                    raise errors.ShortReadvError(self.relpath,
207
 
                        start, length, len(data))
208
 
            if len(data) != length:
209
 
                raise errors.ShortReadvError(self.relpath,
210
 
                    start, length, len(data))
211
 
            self._report_activity(length, 'read')
212
 
            if last_end is None:
213
 
                # This is the first request, just buffer it
214
 
                buffered_data = [data]
215
 
                buffered_len = length
216
 
                input_start = start
217
 
            elif start == last_end:
218
 
                # The data we are reading fits neatly on the previous
219
 
                # buffer, so this is all part of a larger coalesced range.
220
 
                buffered_data.append(data)
221
 
                buffered_len += length
222
 
            else:
223
 
                # We have an 'interrupt' in the data stream. So we know we are
224
 
                # at a request boundary.
225
 
                if buffered_len > 0:
226
 
                    # We haven't consumed the buffer so far, so put it into
227
 
                    # data_chunks, and continue.
228
 
                    buffered = ''.join(buffered_data)
229
 
                    data_chunks.append((input_start, buffered))
230
 
                input_start = start
231
 
                buffered_data = [data]
232
 
                buffered_len = length
233
 
            last_end = start + length
234
 
            if input_start == cur_offset and cur_size <= buffered_len:
235
 
                # Simplify the next steps a bit by transforming buffered_data
236
 
                # into a single string. We also have the nice property that
237
 
                # when there is only one string ''.join([x]) == x, so there is
238
 
                # no data copying.
239
 
                buffered = ''.join(buffered_data)
240
 
                # Clean out buffered data so that we keep memory
241
 
                # consumption low
242
 
                del buffered_data[:]
243
 
                buffered_offset = 0
244
 
                # TODO: We *could* also consider the case where cur_offset is in
245
 
                #       in the buffered range, even though it doesn't *start*
246
 
                #       the buffered range. But for packs we pretty much always
247
 
                #       read in order, so you won't get any extra data in the
248
 
                #       middle.
249
 
                while (input_start == cur_offset
250
 
                       and (buffered_offset + cur_size) <= buffered_len):
251
 
                    # We've buffered enough data to process this request, spit it
252
 
                    # out
253
 
                    cur_data = buffered[buffered_offset:buffered_offset + cur_size]
254
 
                    # move the direct pointer into our buffered data
255
 
                    buffered_offset += cur_size
256
 
                    # Move the start-of-buffer pointer
257
 
                    input_start += cur_size
258
 
                    # Yield the requested data
259
 
                    yield cur_offset, cur_data
260
 
                    cur_offset, cur_size = offset_iter.next()
261
 
                # at this point, we've consumed as much of buffered as we can,
262
 
                # so break off the portion that we consumed
263
 
                if buffered_offset == len(buffered_data):
264
 
                    # No tail to leave behind
265
 
                    buffered_data = []
266
 
                    buffered_len = 0
267
 
                else:
268
 
                    buffered = buffered[buffered_offset:]
269
 
                    buffered_data = [buffered]
270
 
                    buffered_len = len(buffered)
271
 
        # now that the data stream is done, close the handle
272
 
        fp.close()
273
 
        if buffered_len:
274
 
            buffered = ''.join(buffered_data)
275
 
            del buffered_data[:]
276
 
            data_chunks.append((input_start, buffered))
277
 
        if data_chunks:
278
 
            if 'sftp' in debug.debug_flags:
279
 
                mutter('SFTP readv left with %d out-of-order bytes',
280
 
                    sum(map(lambda x: len(x[1]), data_chunks)))
281
 
            # We've processed all the readv data, at this point, anything we
282
 
            # couldn't process is in data_chunks. This doesn't happen often, so
283
 
            # this code path isn't optimized
284
 
            # We use an interesting process for data_chunks
285
 
            # Specifically if we have "bisect_left([(start, len, entries)],
286
 
            #                                       (qstart,)])
287
 
            # If start == qstart, then we get the specific node. Otherwise we
288
 
            # get the previous node
289
 
            while True:
290
 
                idx = bisect.bisect_left(data_chunks, (cur_offset,))
291
 
                if idx < len(data_chunks) and data_chunks[idx][0] == cur_offset:
292
 
                    # The data starts here
293
 
                    data = data_chunks[idx][1][:cur_size]
294
 
                elif idx > 0:
295
 
                    # The data is in a portion of a previous page
296
 
                    idx -= 1
297
 
                    sub_offset = cur_offset - data_chunks[idx][0]
298
 
                    data = data_chunks[idx][1]
299
 
                    data = data[sub_offset:sub_offset + cur_size]
300
 
                else:
301
 
                    # We are missing the page where the data should be found,
302
 
                    # something is wrong
303
 
                    data = ''
304
 
                if len(data) != cur_size:
305
 
                    raise AssertionError('We must have miscalulated.'
306
 
                        ' We expected %d bytes, but only found %d'
307
 
                        % (cur_size, len(data)))
308
 
                yield cur_offset, data
309
 
                cur_offset, cur_size = offset_iter.next()
310
 
 
311
 
 
312
133
class SFTPTransport(ConnectedTransport):
313
134
    """Transport implementation for SFTP access."""
314
135
 
330
151
    # up the request itself, rather than us having to worry about it
331
152
    _max_request_size = 32768
332
153
 
 
154
    def __init__(self, base, _from_transport=None):
 
155
        assert base.startswith('sftp://')
 
156
        super(SFTPTransport, self).__init__(base,
 
157
                                            _from_transport=_from_transport)
 
158
 
333
159
    def _remote_path(self, relpath):
334
160
        """Return the path to be passed along the sftp protocol for relpath.
335
 
 
 
161
        
336
162
        :param relpath: is a urlencoded string.
337
163
        """
338
 
        remote_path = self._parsed_url.clone(relpath).path
 
164
        relative = urlutils.unescape(relpath).encode('utf-8')
 
165
        remote_path = self._combine_paths(self._path, relative)
339
166
        # the initial slash should be removed from the path, and treated as a
340
167
        # homedir relative path (the path begins with a double slash if it is
341
168
        # absolute).  see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
360
187
        in base url at transport creation time.
361
188
        """
362
189
        if credentials is None:
363
 
            password = self._parsed_url.password
 
190
            password = self._password
364
191
        else:
365
192
            password = credentials
366
193
 
367
194
        vendor = ssh._get_ssh_vendor()
368
 
        user = self._parsed_url.user
369
 
        if user is None:
370
 
            auth = config.AuthenticationConfig()
371
 
            user = auth.get_user('ssh', self._parsed_url.host,
372
 
                self._parsed_url.port)
373
 
        connection = vendor.connect_sftp(self._parsed_url.user, password,
374
 
            self._parsed_url.host, self._parsed_url.port)
375
 
        return connection, (user, password)
376
 
 
377
 
    def disconnect(self):
378
 
        connection = self._get_connection()
379
 
        if connection is not None:
380
 
            connection.close()
 
195
        connection = vendor.connect_sftp(self._user, password,
 
196
                                         self._host, self._port)
 
197
        return connection, password
381
198
 
382
199
    def _get_sftp(self):
383
200
        """Ensures that a connection is established"""
388
205
            self._set_connection(connection, credentials)
389
206
        return connection
390
207
 
 
208
 
 
209
    def should_cache(self):
 
210
        """
 
211
        Return True if the data pulled across should be cached locally.
 
212
        """
 
213
        return True
 
214
 
391
215
    def has(self, relpath):
392
216
        """
393
217
        Does the target location exist?
394
218
        """
395
219
        try:
396
220
            self._get_sftp().stat(self._remote_path(relpath))
397
 
            # stat result is about 20 bytes, let's say
398
 
            self._report_activity(20, 'read')
399
221
            return True
400
222
        except IOError:
401
223
            return False
402
224
 
403
225
    def get(self, relpath):
404
 
        """Get the file at the given relative path.
 
226
        """
 
227
        Get the file at the given relative path.
405
228
 
406
229
        :param relpath: The relative path to the file
407
230
        """
415
238
            self._translate_io_exception(e, path, ': error retrieving',
416
239
                failure_exc=errors.ReadError)
417
240
 
418
 
    def get_bytes(self, relpath):
419
 
        # reimplement this here so that we can report how many bytes came back
420
 
        f = self.get(relpath)
421
 
        try:
422
 
            bytes = f.read()
423
 
            self._report_activity(len(bytes), 'read')
424
 
            return bytes
425
 
        finally:
426
 
            f.close()
427
 
 
428
 
    def _readv(self, relpath, offsets):
 
241
    def readv(self, relpath, offsets):
429
242
        """See Transport.readv()"""
430
243
        # We overload the default readv() because we want to use a file
431
244
        # that does not have prefetch enabled.
439
252
            readv = getattr(fp, 'readv', None)
440
253
            if readv:
441
254
                return self._sftp_readv(fp, offsets, relpath)
442
 
            if 'sftp' in debug.debug_flags:
443
 
                mutter('seek and read %s offsets', len(offsets))
 
255
            mutter('seek and read %s offsets', len(offsets))
444
256
            return self._seek_and_read(fp, offsets, relpath)
445
257
        except (IOError, paramiko.SSHException), e:
446
258
            self._translate_io_exception(e, path, ': error retrieving')
447
259
 
448
 
    def recommended_page_size(self):
449
 
        """See Transport.recommended_page_size().
450
 
 
451
 
        For SFTP we suggest a large page size to reduce the overhead
452
 
        introduced by latency.
453
 
        """
454
 
        return 64 * 1024
455
 
 
456
 
    def _sftp_readv(self, fp, offsets, relpath):
 
260
    def _sftp_readv(self, fp, offsets, relpath='<unknown>'):
457
261
        """Use the readv() member of fp to do async readv.
458
262
 
459
 
        Then read them using paramiko.readv(). paramiko.readv()
 
263
        And then read them using paramiko.readv(). paramiko.readv()
460
264
        does not support ranges > 64K, so it caps the request size, and
461
 
        just reads until it gets all the stuff it wants.
 
265
        just reads until it gets all the stuff it wants
462
266
        """
463
 
        helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
464
 
        return helper.request_and_yield_offsets(fp)
 
267
        offsets = list(offsets)
 
268
        sorted_offsets = sorted(offsets)
 
269
 
 
270
        # The algorithm works as follows:
 
271
        # 1) Coalesce nearby reads into a single chunk
 
272
        #    This generates a list of combined regions, the total size
 
273
        #    and the size of the sub regions. This coalescing step is limited
 
274
        #    in the number of nearby chunks to combine, and is allowed to
 
275
        #    skip small breaks in the requests. Limiting it makes sure that
 
276
        #    we can start yielding some data earlier, and skipping means we
 
277
        #    make fewer requests. (Beneficial even when using async)
 
278
        # 2) Break up this combined regions into chunks that are smaller
 
279
        #    than 64KiB. Technically the limit is 65536, but we are a
 
280
        #    little bit conservative. This is because sftp has a maximum
 
281
        #    return chunk size of 64KiB (max size of an unsigned short)
 
282
        # 3) Issue a readv() to paramiko to create an async request for
 
283
        #    all of this data
 
284
        # 4) Read in the data as it comes back, until we've read one
 
285
        #    continuous section as determined in step 1
 
286
        # 5) Break up the full sections into hunks for the original requested
 
287
        #    offsets. And put them in a cache
 
288
        # 6) Check if the next request is in the cache, and if it is, remove
 
289
        #    it from the cache, and yield its data. Continue until no more
 
290
        #    entries are in the cache.
 
291
        # 7) loop back to step 4 until all data has been read
 
292
        #
 
293
        # TODO: jam 20060725 This could be optimized one step further, by
 
294
        #       attempting to yield whatever data we have read, even before
 
295
        #       the first coallesced section has been fully processed.
 
296
 
 
297
        # When coalescing for use with readv(), we don't really need to
 
298
        # use any fudge factor, because the requests are made asynchronously
 
299
        coalesced = list(self._coalesce_offsets(sorted_offsets,
 
300
                               limit=self._max_readv_combine,
 
301
                               fudge_factor=0,
 
302
                               ))
 
303
        requests = []
 
304
        for c_offset in coalesced:
 
305
            start = c_offset.start
 
306
            size = c_offset.length
 
307
 
 
308
            # We need to break this up into multiple requests
 
309
            while size > 0:
 
310
                next_size = min(size, self._max_request_size)
 
311
                requests.append((start, next_size))
 
312
                size -= next_size
 
313
                start += next_size
 
314
 
 
315
        mutter('SFTP.readv() %s offsets => %s coalesced => %s requests',
 
316
                len(offsets), len(coalesced), len(requests))
 
317
 
 
318
        # Queue the current read until we have read the full coalesced section
 
319
        cur_data = []
 
320
        cur_data_len = 0
 
321
        cur_coalesced_stack = iter(coalesced)
 
322
        cur_coalesced = cur_coalesced_stack.next()
 
323
 
 
324
        # Cache the results, but only until they have been fulfilled
 
325
        data_map = {}
 
326
        # turn the list of offsets into a stack
 
327
        offset_stack = iter(offsets)
 
328
        cur_offset_and_size = offset_stack.next()
 
329
 
 
330
        for data in fp.readv(requests):
 
331
            cur_data += data
 
332
            cur_data_len += len(data)
 
333
 
 
334
            if cur_data_len < cur_coalesced.length:
 
335
                continue
 
336
            assert cur_data_len == cur_coalesced.length, \
 
337
                "Somehow we read too much: %s != %s" % (cur_data_len,
 
338
                                                        cur_coalesced.length)
 
339
            all_data = ''.join(cur_data)
 
340
            cur_data = []
 
341
            cur_data_len = 0
 
342
 
 
343
            for suboffset, subsize in cur_coalesced.ranges:
 
344
                key = (cur_coalesced.start+suboffset, subsize)
 
345
                data_map[key] = all_data[suboffset:suboffset+subsize]
 
346
 
 
347
            # Now that we've read some data, see if we can yield anything back
 
348
            while cur_offset_and_size in data_map:
 
349
                this_data = data_map.pop(cur_offset_and_size)
 
350
                yield cur_offset_and_size[0], this_data
 
351
                cur_offset_and_size = offset_stack.next()
 
352
 
 
353
            # We read a coalesced entry, so mark it as done
 
354
            cur_coalesced = None
 
355
            # Now that we've read all of the data for this coalesced section
 
356
            # on to the next
 
357
            cur_coalesced = cur_coalesced_stack.next()
 
358
 
 
359
        if cur_coalesced is not None:
 
360
            raise errors.ShortReadvError(relpath, cur_coalesced.start,
 
361
                cur_coalesced.length, len(data))
465
362
 
466
363
    def put_file(self, relpath, f, mode=None):
467
364
        """
472
369
        :param mode: The final mode for the file
473
370
        """
474
371
        final_path = self._remote_path(relpath)
475
 
        return self._put(final_path, f, mode=mode)
 
372
        self._put(final_path, f, mode=mode)
476
373
 
477
374
    def _put(self, abspath, f, mode=None):
478
375
        """Helper function so both put() and copy_abspaths can reuse the code"""
483
380
        try:
484
381
            try:
485
382
                fout.set_pipelined(True)
486
 
                length = self._pump(f, fout)
 
383
                self._pump(f, fout)
487
384
            except (IOError, paramiko.SSHException), e:
488
385
                self._translate_io_exception(e, tmp_abspath)
489
386
            # XXX: This doesn't truly help like we would like it to.
492
389
            #      sticky bit. So it is probably best to stop chmodding, and
493
390
            #      just tell users that they need to set the umask correctly.
494
391
            #      The attr.st_mode = mode, in _sftp_open_exclusive
495
 
            #      will handle when the user wants the final mode to be more
496
 
            #      restrictive. And then we avoid a round trip. Unless
 
392
            #      will handle when the user wants the final mode to be more 
 
393
            #      restrictive. And then we avoid a round trip. Unless 
497
394
            #      paramiko decides to expose an async chmod()
498
395
 
499
396
            # This is designed to chmod() right before we close.
500
 
            # Because we set_pipelined() earlier, theoretically we might
 
397
            # Because we set_pipelined() earlier, theoretically we might 
501
398
            # avoid the round trip for fout.close()
502
399
            if mode is not None:
503
400
                self._get_sftp().chmod(tmp_abspath, mode)
504
401
            fout.close()
505
402
            closed = True
506
403
            self._rename_and_overwrite(tmp_abspath, abspath)
507
 
            return length
508
404
        except Exception, e:
509
405
            # If we fail, try to clean up the temporary file
510
406
            # before we throw the exception
545
441
                                                 ': unable to open')
546
442
 
547
443
                # This is designed to chmod() right before we close.
548
 
                # Because we set_pipelined() earlier, theoretically we might
 
444
                # Because we set_pipelined() earlier, theoretically we might 
549
445
                # avoid the round trip for fout.close()
550
446
                if mode is not None:
551
447
                    self._get_sftp().chmod(abspath, mode)
602
498
 
603
499
    def iter_files_recursive(self):
604
500
        """Walk the relative paths of all files in this transport."""
605
 
        # progress is handled by list_dir
606
501
        queue = list(self.list_dir('.'))
607
502
        while queue:
608
503
            relpath = queue.pop(0)
619
514
        else:
620
515
            local_mode = mode
621
516
        try:
622
 
            self._report_activity(len(abspath), 'write')
623
517
            self._get_sftp().mkdir(abspath, local_mode)
624
 
            self._report_activity(1, 'read')
625
518
            if mode is not None:
626
 
                # chmod a dir through sftp will erase any sgid bit set
627
 
                # on the server side.  So, if the bit mode are already
628
 
                # set, avoid the chmod.  If the mode is not fine but
629
 
                # the sgid bit is set, report a warning to the user
630
 
                # with the umask fix.
631
 
                stat = self._get_sftp().lstat(abspath)
632
 
                mode = mode & 0777 # can't set special bits anyway
633
 
                if mode != stat.st_mode & 0777:
634
 
                    if stat.st_mode & 06000:
635
 
                        warning('About to chmod %s over sftp, which will result'
636
 
                                ' in its suid or sgid bits being cleared.  If'
637
 
                                ' you want to preserve those bits, change your '
638
 
                                ' environment on the server to use umask 0%03o.'
639
 
                                % (abspath, 0777 - mode))
640
 
                    self._get_sftp().chmod(abspath, mode=mode)
 
519
                self._get_sftp().chmod(abspath, mode=mode)
641
520
        except (paramiko.SSHException, IOError), e:
642
521
            self._translate_io_exception(e, abspath, ': unable to mkdir',
643
522
                failure_exc=FileExists)
646
525
        """Create a directory at the given path."""
647
526
        self._mkdir(self._remote_path(relpath), mode=mode)
648
527
 
649
 
    def open_write_stream(self, relpath, mode=None):
650
 
        """See Transport.open_write_stream."""
651
 
        # initialise the file to zero-length
652
 
        # this is three round trips, but we don't use this
653
 
        # api more than once per write_group at the moment so
654
 
        # it is a tolerable overhead. Better would be to truncate
655
 
        # the file after opening. RBC 20070805
656
 
        self.put_bytes_non_atomic(relpath, "", mode)
657
 
        abspath = self._remote_path(relpath)
658
 
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
659
 
        #       set the file mode at create time. If it does, use it.
660
 
        #       But for now, we just chmod later anyway.
661
 
        handle = None
662
 
        try:
663
 
            handle = self._get_sftp().file(abspath, mode='wb')
664
 
            handle.set_pipelined(True)
665
 
        except (paramiko.SSHException, IOError), e:
666
 
            self._translate_io_exception(e, abspath,
667
 
                                         ': unable to open')
668
 
        _file_streams[self.abspath(relpath)] = handle
669
 
        return FileFileStream(self, relpath, handle)
670
 
 
671
528
    def _translate_io_exception(self, e, path, more_info='',
672
529
                                failure_exc=PathError):
673
530
        """Translate a paramiko or IOError into a friendlier exception.
679
536
        :param failure_exc: Paramiko has the super fun ability to raise completely
680
537
                           opaque errors that just set "e.args = ('Failure',)" with
681
538
                           no more information.
682
 
                           If this parameter is set, it defines the exception
 
539
                           If this parameter is set, it defines the exception 
683
540
                           to raise in these cases.
684
541
        """
685
542
        # paramiko seems to generate detailless errors.
688
545
            if (e.args == ('No such file or directory',) or
689
546
                e.args == ('No such file',)):
690
547
                raise NoSuchFile(path, str(e) + more_info)
691
 
            if (e.args == ('mkdir failed',) or
692
 
                e.args[0].startswith('syserr: File exists')):
 
548
            if (e.args == ('mkdir failed',)):
693
549
                raise FileExists(path, str(e) + more_info)
694
550
            # strange but true, for the paramiko server.
695
551
            if (e.args == ('Failure',)):
696
552
                raise failure_exc(path, str(e) + more_info)
697
 
            # Can be something like args = ('Directory not empty:
698
 
            # '/srv/bazaar.launchpad.net/blah...: '
699
 
            # [Errno 39] Directory not empty',)
700
 
            if (e.args[0].startswith('Directory not empty: ')
701
 
                or getattr(e, 'errno', None) == errno.ENOTEMPTY):
702
 
                raise errors.DirectoryNotEmpty(path, str(e))
703
 
            if e.args == ('Operation unsupported',):
704
 
                raise errors.TransportNotPossible()
705
553
            mutter('Raising exception with args %s', e.args)
706
554
        if getattr(e, 'errno', None) is not None:
707
555
            mutter('Raising exception with errno %s', e.errno)
734
582
 
735
583
    def _rename_and_overwrite(self, abs_from, abs_to):
736
584
        """Do a fancy rename on the remote server.
737
 
 
 
585
        
738
586
        Using the implementation provided by osutils.
739
587
        """
740
588
        try:
759
607
            self._get_sftp().remove(path)
760
608
        except (IOError, paramiko.SSHException), e:
761
609
            self._translate_io_exception(e, path, ': unable to delete')
762
 
 
 
610
            
763
611
    def external_url(self):
764
612
        """See bzrlib.transport.Transport.external_url."""
765
613
        # the external path for SFTP is the base
780
628
        path = self._remote_path(relpath)
781
629
        try:
782
630
            entries = self._get_sftp().listdir(path)
783
 
            self._report_activity(sum(map(len, entries)), 'read')
784
631
        except (IOError, paramiko.SSHException), e:
785
632
            self._translate_io_exception(e, path, ': failed to list_dir')
786
633
        return [urlutils.escape(entry) for entry in entries]
797
644
        """Return the stat information for a file."""
798
645
        path = self._remote_path(relpath)
799
646
        try:
800
 
            return self._get_sftp().lstat(path)
 
647
            return self._get_sftp().stat(path)
801
648
        except (IOError, paramiko.SSHException), e:
802
649
            self._translate_io_exception(e, path, ': unable to stat')
803
650
 
804
 
    def readlink(self, relpath):
805
 
        """See Transport.readlink."""
806
 
        path = self._remote_path(relpath)
807
 
        try:
808
 
            return self._get_sftp().readlink(path)
809
 
        except (IOError, paramiko.SSHException), e:
810
 
            self._translate_io_exception(e, path, ': unable to readlink')
811
 
 
812
 
    def symlink(self, source, link_name):
813
 
        """See Transport.symlink."""
814
 
        try:
815
 
            conn = self._get_sftp()
816
 
            sftp_retval = conn.symlink(source, link_name)
817
 
            if SFTP_OK != sftp_retval:
818
 
                raise TransportError(
819
 
                    '%r: unable to create symlink to %r' % (link_name, source),
820
 
                    sftp_retval
821
 
                )
822
 
        except (IOError, paramiko.SSHException), e:
823
 
            self._translate_io_exception(e, link_name,
824
 
                                         ': unable to create symlink to %r' % (source))
825
 
 
826
651
    def lock_read(self, relpath):
827
652
        """
828
653
        Lock the given file for shared (read) access.
865
690
        """
866
691
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
867
692
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
868
 
        #       However, there is no way to set the permission mode at open
 
693
        #       However, there is no way to set the permission mode at open 
869
694
        #       time using the sftp_client.file() functionality.
870
695
        path = self._get_sftp()._adjust_cwd(abspath)
871
696
        # mutter('sftp abspath %s => %s', abspath, path)
872
697
        attr = SFTPAttributes()
873
698
        if mode is not None:
874
699
            attr.st_mode = mode
875
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
 
700
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
876
701
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
877
702
        try:
878
703
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
891
716
        else:
892
717
            return True
893
718
 
 
719
# ------------- server test implementation --------------
 
720
import threading
 
721
 
 
722
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
 
723
 
 
724
STUB_SERVER_KEY = """
 
725
-----BEGIN RSA PRIVATE KEY-----
 
726
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
 
727
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
 
728
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
 
729
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
 
730
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
 
731
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
 
732
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
 
733
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
 
734
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
 
735
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
 
736
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
 
737
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
 
738
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
 
739
-----END RSA PRIVATE KEY-----
 
740
"""
 
741
 
 
742
 
 
743
class SocketListener(threading.Thread):
 
744
 
 
745
    def __init__(self, callback):
 
746
        threading.Thread.__init__(self)
 
747
        self._callback = callback
 
748
        self._socket = socket.socket()
 
749
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
750
        self._socket.bind(('localhost', 0))
 
751
        self._socket.listen(1)
 
752
        self.port = self._socket.getsockname()[1]
 
753
        self._stop_event = threading.Event()
 
754
 
 
755
    def stop(self):
 
756
        # called from outside this thread
 
757
        self._stop_event.set()
 
758
        # use a timeout here, because if the test fails, the server thread may
 
759
        # never notice the stop_event.
 
760
        self.join(5.0)
 
761
        self._socket.close()
 
762
 
 
763
    def run(self):
 
764
        while True:
 
765
            readable, writable_unused, exception_unused = \
 
766
                select.select([self._socket], [], [], 0.1)
 
767
            if self._stop_event.isSet():
 
768
                return
 
769
            if len(readable) == 0:
 
770
                continue
 
771
            try:
 
772
                s, addr_unused = self._socket.accept()
 
773
                # because the loopback socket is inline, and transports are
 
774
                # never explicitly closed, best to launch a new thread.
 
775
                threading.Thread(target=self._callback, args=(s,)).start()
 
776
            except socket.error, x:
 
777
                sys.excepthook(*sys.exc_info())
 
778
                warning('Socket error during accept() within unit test server'
 
779
                        ' thread: %r' % x)
 
780
            except Exception, x:
 
781
                # probably a failed test; unit test thread will log the
 
782
                # failure/error
 
783
                sys.excepthook(*sys.exc_info())
 
784
                warning('Exception from within unit test server thread: %r' % 
 
785
                        x)
 
786
 
 
787
 
 
788
class SocketDelay(object):
 
789
    """A socket decorator to make TCP appear slower.
 
790
 
 
791
    This changes recv, send, and sendall to add a fixed latency to each python
 
792
    call if a new roundtrip is detected. That is, when a recv is called and the
 
793
    flag new_roundtrip is set, latency is charged. Every send and send_all
 
794
    sets this flag.
 
795
 
 
796
    In addition every send, sendall and recv sleeps a bit per character send to
 
797
    simulate bandwidth.
 
798
 
 
799
    Not all methods are implemented, this is deliberate as this class is not a
 
800
    replacement for the builtin sockets layer. fileno is not implemented to
 
801
    prevent the proxy being bypassed. 
 
802
    """
 
803
 
 
804
    simulated_time = 0
 
805
    _proxied_arguments = dict.fromkeys([
 
806
        "close", "getpeername", "getsockname", "getsockopt", "gettimeout",
 
807
        "setblocking", "setsockopt", "settimeout", "shutdown"])
 
808
 
 
809
    def __init__(self, sock, latency, bandwidth=1.0, 
 
810
                 really_sleep=True):
 
811
        """ 
 
812
        :param bandwith: simulated bandwith (MegaBit)
 
813
        :param really_sleep: If set to false, the SocketDelay will just
 
814
        increase a counter, instead of calling time.sleep. This is useful for
 
815
        unittesting the SocketDelay.
 
816
        """
 
817
        self.sock = sock
 
818
        self.latency = latency
 
819
        self.really_sleep = really_sleep
 
820
        self.time_per_byte = 1 / (bandwidth / 8.0 * 1024 * 1024) 
 
821
        self.new_roundtrip = False
 
822
 
 
823
    def sleep(self, s):
 
824
        if self.really_sleep:
 
825
            time.sleep(s)
 
826
        else:
 
827
            SocketDelay.simulated_time += s
 
828
 
 
829
    def __getattr__(self, attr):
 
830
        if attr in SocketDelay._proxied_arguments:
 
831
            return getattr(self.sock, attr)
 
832
        raise AttributeError("'SocketDelay' object has no attribute %r" %
 
833
                             attr)
 
834
 
 
835
    def dup(self):
 
836
        return SocketDelay(self.sock.dup(), self.latency, self.time_per_byte,
 
837
                           self._sleep)
 
838
 
 
839
    def recv(self, *args):
 
840
        data = self.sock.recv(*args)
 
841
        if data and self.new_roundtrip:
 
842
            self.new_roundtrip = False
 
843
            self.sleep(self.latency)
 
844
        self.sleep(len(data) * self.time_per_byte)
 
845
        return data
 
846
 
 
847
    def sendall(self, data, flags=0):
 
848
        if not self.new_roundtrip:
 
849
            self.new_roundtrip = True
 
850
            self.sleep(self.latency)
 
851
        self.sleep(len(data) * self.time_per_byte)
 
852
        return self.sock.sendall(data, flags)
 
853
 
 
854
    def send(self, data, flags=0):
 
855
        if not self.new_roundtrip:
 
856
            self.new_roundtrip = True
 
857
            self.sleep(self.latency)
 
858
        bytes_sent = self.sock.send(data, flags)
 
859
        self.sleep(bytes_sent * self.time_per_byte)
 
860
        return bytes_sent
 
861
 
 
862
 
 
863
class SFTPServer(Server):
 
864
    """Common code for SFTP server facilities."""
 
865
 
 
866
    def __init__(self, server_interface=StubServer):
 
867
        self._original_vendor = None
 
868
        self._homedir = None
 
869
        self._server_homedir = None
 
870
        self._listener = None
 
871
        self._root = None
 
872
        self._vendor = ssh.ParamikoVendor()
 
873
        self._server_interface = server_interface
 
874
        # sftp server logs
 
875
        self.logs = []
 
876
        self.add_latency = 0
 
877
 
 
878
    def _get_sftp_url(self, path):
 
879
        """Calculate an sftp url to this server for path."""
 
880
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
 
881
 
 
882
    def log(self, message):
 
883
        """StubServer uses this to log when a new server is created."""
 
884
        self.logs.append(message)
 
885
 
 
886
    def _run_server_entry(self, sock):
 
887
        """Entry point for all implementations of _run_server.
 
888
        
 
889
        If self.add_latency is > 0.000001 then sock is given a latency adding
 
890
        decorator.
 
891
        """
 
892
        if self.add_latency > 0.000001:
 
893
            sock = SocketDelay(sock, self.add_latency)
 
894
        return self._run_server(sock)
 
895
 
 
896
    def _run_server(self, s):
 
897
        ssh_server = paramiko.Transport(s)
 
898
        key_file = pathjoin(self._homedir, 'test_rsa.key')
 
899
        f = open(key_file, 'w')
 
900
        f.write(STUB_SERVER_KEY)
 
901
        f.close()
 
902
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
 
903
        ssh_server.add_server_key(host_key)
 
904
        server = self._server_interface(self)
 
905
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
 
906
                                         StubSFTPServer, root=self._root,
 
907
                                         home=self._server_homedir)
 
908
        event = threading.Event()
 
909
        ssh_server.start_server(event, server)
 
910
        event.wait(5.0)
 
911
    
 
912
    def setUp(self, backing_server=None):
 
913
        # XXX: TODO: make sftpserver back onto backing_server rather than local
 
914
        # disk.
 
915
        assert (backing_server is None or
 
916
                isinstance(backing_server, local.LocalURLServer)), (
 
917
            "backing_server should not be %r, because this can only serve the "
 
918
            "local current working directory." % (backing_server,))
 
919
        self._original_vendor = ssh._ssh_vendor_manager._cached_ssh_vendor
 
920
        ssh._ssh_vendor_manager._cached_ssh_vendor = self._vendor
 
921
        if sys.platform == 'win32':
 
922
            # Win32 needs to use the UNICODE api
 
923
            self._homedir = getcwd()
 
924
        else:
 
925
            # But Linux SFTP servers should just deal in bytestreams
 
926
            self._homedir = os.getcwd()
 
927
        if self._server_homedir is None:
 
928
            self._server_homedir = self._homedir
 
929
        self._root = '/'
 
930
        if sys.platform == 'win32':
 
931
            self._root = ''
 
932
        self._listener = SocketListener(self._run_server_entry)
 
933
        self._listener.setDaemon(True)
 
934
        self._listener.start()
 
935
 
 
936
    def tearDown(self):
 
937
        """See bzrlib.transport.Server.tearDown."""
 
938
        self._listener.stop()
 
939
        ssh._ssh_vendor_manager._cached_ssh_vendor = self._original_vendor
 
940
 
 
941
    def get_bogus_url(self):
 
942
        """See bzrlib.transport.Server.get_bogus_url."""
 
943
        # this is chosen to try to prevent trouble with proxies, wierd dns, etc
 
944
        # we bind a random socket, so that we get a guaranteed unused port
 
945
        # we just never listen on that port
 
946
        s = socket.socket()
 
947
        s.bind(('localhost', 0))
 
948
        return 'sftp://%s:%s/' % s.getsockname()
 
949
 
 
950
 
 
951
class SFTPFullAbsoluteServer(SFTPServer):
 
952
    """A test server for sftp transports, using absolute urls and ssh."""
 
953
 
 
954
    def get_url(self):
 
955
        """See bzrlib.transport.Server.get_url."""
 
956
        homedir = self._homedir
 
957
        if sys.platform != 'win32':
 
958
            # Remove the initial '/' on all platforms but win32
 
959
            homedir = homedir[1:]
 
960
        return self._get_sftp_url(urlutils.escape(homedir))
 
961
 
 
962
 
 
963
class SFTPServerWithoutSSH(SFTPServer):
 
964
    """An SFTP server that uses a simple TCP socket pair rather than SSH."""
 
965
 
 
966
    def __init__(self):
 
967
        super(SFTPServerWithoutSSH, self).__init__()
 
968
        self._vendor = ssh.LoopbackVendor()
 
969
 
 
970
    def _run_server(self, sock):
 
971
        # Re-import these as locals, so that they're still accessible during
 
972
        # interpreter shutdown (when all module globals get set to None, leading
 
973
        # to confusing errors like "'NoneType' object has no attribute 'error'".
 
974
        class FakeChannel(object):
 
975
            def get_transport(self):
 
976
                return self
 
977
            def get_log_channel(self):
 
978
                return 'paramiko'
 
979
            def get_name(self):
 
980
                return '1'
 
981
            def get_hexdump(self):
 
982
                return False
 
983
            def close(self):
 
984
                pass
 
985
 
 
986
        server = paramiko.SFTPServer(FakeChannel(), 'sftp', StubServer(self), StubSFTPServer,
 
987
                                     root=self._root, home=self._server_homedir)
 
988
        try:
 
989
            server.start_subsystem('sftp', None, sock)
 
990
        except socket.error, e:
 
991
            if (len(e.args) > 0) and (e.args[0] == errno.EPIPE):
 
992
                # it's okay for the client to disconnect abruptly
 
993
                # (bug in paramiko 1.6: it should absorb this exception)
 
994
                pass
 
995
            else:
 
996
                raise
 
997
        except Exception, e:
 
998
            # This typically seems to happen during interpreter shutdown, so
 
999
            # most of the useful ways to report this error are won't work.
 
1000
            # Writing the exception type, and then the text of the exception,
 
1001
            # seems to be the best we can do.
 
1002
            import sys
 
1003
            sys.stderr.write('\nEXCEPTION %r: ' % (e.__class__,))
 
1004
            sys.stderr.write('%s\n\n' % (e,))
 
1005
        server.finish_subsystem()
 
1006
 
 
1007
 
 
1008
class SFTPAbsoluteServer(SFTPServerWithoutSSH):
 
1009
    """A test server for sftp transports, using absolute urls."""
 
1010
 
 
1011
    def get_url(self):
 
1012
        """See bzrlib.transport.Server.get_url."""
 
1013
        homedir = self._homedir
 
1014
        if sys.platform != 'win32':
 
1015
            # Remove the initial '/' on all platforms but win32
 
1016
            homedir = homedir[1:]
 
1017
        return self._get_sftp_url(urlutils.escape(homedir))
 
1018
 
 
1019
 
 
1020
class SFTPHomeDirServer(SFTPServerWithoutSSH):
 
1021
    """A test server for sftp transports, using homedir relative urls."""
 
1022
 
 
1023
    def get_url(self):
 
1024
        """See bzrlib.transport.Server.get_url."""
 
1025
        return self._get_sftp_url("~/")
 
1026
 
 
1027
 
 
1028
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
 
1029
    """A test server for sftp transports where only absolute paths will work.
 
1030
 
 
1031
    It does this by serving from a deeply-nested directory that doesn't exist.
 
1032
    """
 
1033
 
 
1034
    def setUp(self, backing_server=None):
 
1035
        self._server_homedir = '/dev/noone/runs/tests/here'
 
1036
        super(SFTPSiblingAbsoluteServer, self).setUp(backing_server)
 
1037
 
894
1038
 
895
1039
def get_test_permutations():
896
1040
    """Return the permutations to be used in testing."""
897
 
    from bzrlib.tests import stub_sftp
898
 
    return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
899
 
            (SFTPTransport, stub_sftp.SFTPHomeDirServer),
900
 
            (SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
 
1041
    return [(SFTPTransport, SFTPAbsoluteServer),
 
1042
            (SFTPTransport, SFTPHomeDirServer),
 
1043
            (SFTPTransport, SFTPSiblingAbsoluteServer),
901
1044
            ]