← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Andrew Bennetts
  • Date: 2007-08-08 06:23:16 UTC
  • mto: (2535.3.37 repo-refactor)
  • mto: This revision was merged to the branch mainline in revision 2713.
  • Revision ID: andrew.bennetts@canonical.com-20070808062316-1baiqpdwfzvznju1
Rename get_data_to_fetch_for_revision_ids as item_keys_introduced_by.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/sftp.py
1
 
# Copyright (C) 2005-2011, 2016 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
 
19
 
from __future__ import absolute_import
20
 
 
21
20
# TODO: Remove the transport-based lock_read and lock_write methods.  They'll
22
21
# then raise TransportNotPossible, which will break remote access to any
23
22
# formats which rely on OS-level locks.  That should be fine as those formats
25
24
# suite.  Those formats all date back to 0.7; so we should be able to remove
26
25
# these methods when we officially drop support for those formats.
27
26
 
28
 
import bisect
29
27
import errno
30
 
import itertools
31
28
import os
32
29
import random
 
30
import select
 
31
import socket
33
32
import stat
34
33
import sys
35
34
import time
36
 
import warnings
 
35
import urllib
 
36
import urlparse
37
37
 
38
38
from bzrlib import (
39
 
    config,
40
 
    debug,
41
39
    errors,
42
40
    urlutils,
43
41
    )
44
42
from bzrlib.errors import (FileExists,
45
 
                           NoSuchFile,
 
43
                           NoSuchFile, PathNotChild,
46
44
                           TransportError,
47
45
                           LockError,
48
46
                           PathError,
49
47
                           ParamikoNotPresent,
50
48
                           )
51
 
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
        )
52
54
from bzrlib.trace import mutter, warning
53
55
from bzrlib.transport import (
54
 
    FileFileStream,
55
 
    _file_streams,
 
56
    local,
 
57
    register_urlparse_netloc_protocol,
 
58
    Server,
56
59
    ssh,
57
60
    ConnectedTransport,
58
61
    )
59
62
 
60
 
# Disable one particular warning that comes from paramiko in Python2.5; if
61
 
# this is emitted at the wrong time it tends to cause spurious test failures
62
 
# or at least noise in the test case::
63
 
#
64
 
# [1770/7639 in 86s, 1 known failures, 50 skipped, 2 missing features]
65
 
# test_permissions.TestSftpPermissions.test_new_files
66
 
# /var/lib/python-support/python2.5/paramiko/message.py:226: DeprecationWarning: integer argument expected, got float
67
 
#  self.packet.write(struct.pack('>I', n))
68
 
warnings.filterwarnings('ignore',
69
 
        'integer argument expected, got float',
70
 
        category=DeprecationWarning,
71
 
        module='paramiko.message')
72
 
 
73
63
try:
74
64
    import paramiko
75
65
except ImportError, e:
77
67
else:
78
68
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
79
69
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
80
 
                               SFTP_OK, CMD_HANDLE, CMD_OPEN)
 
70
                               CMD_HANDLE, CMD_OPEN)
81
71
    from paramiko.sftp_attr import SFTPAttributes
82
72
    from paramiko.sftp_file import SFTPFile
83
73
 
84
74
 
 
75
register_urlparse_netloc_protocol('sftp')
 
76
 
 
77
 
85
78
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
86
79
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
87
80
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
88
81
 
89
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
 
90
91
class SFTPLock(object):
91
92
    """This fakes a lock in a remote location.
92
 
 
 
93
    
93
94
    A present lock is indicated just by the existence of a file.  This
94
 
    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 
95
96
    deprecated storage formats.
96
97
    """
97
 
 
 
98
    
98
99
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
99
100
 
100
101
    def __init__(self, path, transport):
 
102
        assert isinstance(transport, SFTPTransport)
 
103
 
101
104
        self.lock_file = None
102
105
        self.path = path
103
106
        self.lock_path = path + '.write-lock'
109
112
        except FileExists:
110
113
            raise LockError('File %r already locked' % (self.path,))
111
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
 
112
121
    def unlock(self):
113
122
        if not self.lock_file:
114
123
            return
121
130
            pass
122
131
 
123
132
 
124
 
class _SFTPReadvHelper(object):
125
 
    """A class to help with managing the state of a readv request."""
126
 
 
127
 
    # See _get_requests for an explanation.
128
 
    _max_request_size = 32768
129
 
 
130
 
    def __init__(self, original_offsets, relpath, _report_activity):
131
 
        """Create a new readv helper.
132
 
 
133
 
        :param original_offsets: The original requests given by the caller of
134
 
            readv()
135
 
        :param relpath: The name of the file (if known)
136
 
        :param _report_activity: A Transport._report_activity bound method,
137
 
            to be called as data arrives.
138
 
        """
139
 
        self.original_offsets = list(original_offsets)
140
 
        self.relpath = relpath
141
 
        self._report_activity = _report_activity
142
 
 
143
 
    def _get_requests(self):
144
 
        """Break up the offsets into individual requests over sftp.
145
 
 
146
 
        The SFTP spec only requires implementers to support 32kB requests. We
147
 
        could try something larger (openssh supports 64kB), but then we have to
148
 
        handle requests that fail.
149
 
        So instead, we just break up our maximum chunks into 32kB chunks, and
150
 
        asyncronously requests them.
151
 
        Newer versions of paramiko would do the chunking for us, but we want to
152
 
        start processing results right away, so we do it ourselves.
153
 
        """
154
 
        # TODO: Because we issue async requests, we don't 'fudge' any extra
155
 
        #       data.  I'm not 100% sure that is the best choice.
156
 
 
157
 
        # The first thing we do, is to collapse the individual requests as much
158
 
        # as possible, so we don't issues requests <32kB
159
 
        sorted_offsets = sorted(self.original_offsets)
160
 
        coalesced = list(ConnectedTransport._coalesce_offsets(sorted_offsets,
161
 
                                                        limit=0, fudge_factor=0))
162
 
        requests = []
163
 
        for c_offset in coalesced:
164
 
            start = c_offset.start
165
 
            size = c_offset.length
166
 
 
167
 
            # Break this up into 32kB requests
168
 
            while size > 0:
169
 
                next_size = min(size, self._max_request_size)
170
 
                requests.append((start, next_size))
171
 
                size -= next_size
172
 
                start += next_size
173
 
        if 'sftp' in debug.debug_flags:
174
 
            mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',
175
 
                self.relpath, len(sorted_offsets), len(coalesced),
176
 
                len(requests))
177
 
        return requests
178
 
 
179
 
    def request_and_yield_offsets(self, fp):
180
 
        """Request the data from the remote machine, yielding the results.
181
 
 
182
 
        :param fp: A Paramiko SFTPFile object that supports readv.
183
 
        :return: Yield the data requested by the original readv caller, one by
184
 
            one.
185
 
        """
186
 
        requests = self._get_requests()
187
 
        offset_iter = iter(self.original_offsets)
188
 
        cur_offset, cur_size = offset_iter.next()
189
 
        # paramiko .readv() yields strings that are in the order of the requests
190
 
        # So we track the current request to know where the next data is
191
 
        # being returned from.
192
 
        input_start = None
193
 
        last_end = None
194
 
        buffered_data = []
195
 
        buffered_len = 0
196
 
 
197
 
        # This is used to buffer chunks which we couldn't process yet
198
 
        # It is (start, end, data) tuples.
199
 
        data_chunks = []
200
 
        # Create an 'unlimited' data stream, so we stop based on requests,
201
 
        # rather than just because the data stream ended. This lets us detect
202
 
        # short readv.
203
 
        data_stream = itertools.chain(fp.readv(requests),
204
 
                                      itertools.repeat(None))
205
 
        for (start, length), data in itertools.izip(requests, data_stream):
206
 
            if data is None:
207
 
                if cur_coalesced is not None:
208
 
                    raise errors.ShortReadvError(self.relpath,
209
 
                        start, length, len(data))
210
 
            if len(data) != length:
211
 
                raise errors.ShortReadvError(self.relpath,
212
 
                    start, length, len(data))
213
 
            self._report_activity(length, 'read')
214
 
            if last_end is None:
215
 
                # This is the first request, just buffer it
216
 
                buffered_data = [data]
217
 
                buffered_len = length
218
 
                input_start = start
219
 
            elif start == last_end:
220
 
                # The data we are reading fits neatly on the previous
221
 
                # buffer, so this is all part of a larger coalesced range.
222
 
                buffered_data.append(data)
223
 
                buffered_len += length
224
 
            else:
225
 
                # We have an 'interrupt' in the data stream. So we know we are
226
 
                # at a request boundary.
227
 
                if buffered_len > 0:
228
 
                    # We haven't consumed the buffer so far, so put it into
229
 
                    # data_chunks, and continue.
230
 
                    buffered = ''.join(buffered_data)
231
 
                    data_chunks.append((input_start, buffered))
232
 
                input_start = start
233
 
                buffered_data = [data]
234
 
                buffered_len = length
235
 
            last_end = start + length
236
 
            if input_start == cur_offset and cur_size <= buffered_len:
237
 
                # Simplify the next steps a bit by transforming buffered_data
238
 
                # into a single string. We also have the nice property that
239
 
                # when there is only one string ''.join([x]) == x, so there is
240
 
                # no data copying.
241
 
                buffered = ''.join(buffered_data)
242
 
                # Clean out buffered data so that we keep memory
243
 
                # consumption low
244
 
                del buffered_data[:]
245
 
                buffered_offset = 0
246
 
                # TODO: We *could* also consider the case where cur_offset is in
247
 
                #       in the buffered range, even though it doesn't *start*
248
 
                #       the buffered range. But for packs we pretty much always
249
 
                #       read in order, so you won't get any extra data in the
250
 
                #       middle.
251
 
                while (input_start == cur_offset
252
 
                       and (buffered_offset + cur_size) <= buffered_len):
253
 
                    # We've buffered enough data to process this request, spit it
254
 
                    # out
255
 
                    cur_data = buffered[buffered_offset:buffered_offset + cur_size]
256
 
                    # move the direct pointer into our buffered data
257
 
                    buffered_offset += cur_size
258
 
                    # Move the start-of-buffer pointer
259
 
                    input_start += cur_size
260
 
                    # Yield the requested data
261
 
                    yield cur_offset, cur_data
262
 
                    cur_offset, cur_size = offset_iter.next()
263
 
                # at this point, we've consumed as much of buffered as we can,
264
 
                # so break off the portion that we consumed
265
 
                if buffered_offset == len(buffered_data):
266
 
                    # No tail to leave behind
267
 
                    buffered_data = []
268
 
                    buffered_len = 0
269
 
                else:
270
 
                    buffered = buffered[buffered_offset:]
271
 
                    buffered_data = [buffered]
272
 
                    buffered_len = len(buffered)
273
 
        # now that the data stream is done, close the handle
274
 
        fp.close()
275
 
        if buffered_len:
276
 
            buffered = ''.join(buffered_data)
277
 
            del buffered_data[:]
278
 
            data_chunks.append((input_start, buffered))
279
 
        if data_chunks:
280
 
            if 'sftp' in debug.debug_flags:
281
 
                mutter('SFTP readv left with %d out-of-order bytes',
282
 
                    sum(map(lambda x: len(x[1]), data_chunks)))
283
 
            # We've processed all the readv data, at this point, anything we
284
 
            # couldn't process is in data_chunks. This doesn't happen often, so
285
 
            # this code path isn't optimized
286
 
            # We use an interesting process for data_chunks
287
 
            # Specifically if we have "bisect_left([(start, len, entries)],
288
 
            #                                       (qstart,)])
289
 
            # If start == qstart, then we get the specific node. Otherwise we
290
 
            # get the previous node
291
 
            while True:
292
 
                idx = bisect.bisect_left(data_chunks, (cur_offset,))
293
 
                if idx < len(data_chunks) and data_chunks[idx][0] == cur_offset:
294
 
                    # The data starts here
295
 
                    data = data_chunks[idx][1][:cur_size]
296
 
                elif idx > 0:
297
 
                    # The data is in a portion of a previous page
298
 
                    idx -= 1
299
 
                    sub_offset = cur_offset - data_chunks[idx][0]
300
 
                    data = data_chunks[idx][1]
301
 
                    data = data[sub_offset:sub_offset + cur_size]
302
 
                else:
303
 
                    # We are missing the page where the data should be found,
304
 
                    # something is wrong
305
 
                    data = ''
306
 
                if len(data) != cur_size:
307
 
                    raise AssertionError('We must have miscalulated.'
308
 
                        ' We expected %d bytes, but only found %d'
309
 
                        % (cur_size, len(data)))
310
 
                yield cur_offset, data
311
 
                cur_offset, cur_size = offset_iter.next()
312
 
 
313
 
 
314
133
class SFTPTransport(ConnectedTransport):
315
134
    """Transport implementation for SFTP access."""
316
135
 
332
151
    # up the request itself, rather than us having to worry about it
333
152
    _max_request_size = 32768
334
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
 
335
159
    def _remote_path(self, relpath):
336
160
        """Return the path to be passed along the sftp protocol for relpath.
337
 
 
 
161
        
338
162
        :param relpath: is a urlencoded string.
339
163
        """
340
 
        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)
341
166
        # the initial slash should be removed from the path, and treated as a
342
167
        # homedir relative path (the path begins with a double slash if it is
343
168
        # absolute).  see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
362
187
        in base url at transport creation time.
363
188
        """
364
189
        if credentials is None:
365
 
            password = self._parsed_url.password
 
190
            password = self._password
366
191
        else:
367
192
            password = credentials
368
193
 
369
194
        vendor = ssh._get_ssh_vendor()
370
 
        user = self._parsed_url.user
371
 
        if user is None:
372
 
            auth = config.AuthenticationConfig()
373
 
            user = auth.get_user('ssh', self._parsed_url.host,
374
 
                self._parsed_url.port)
375
 
        connection = vendor.connect_sftp(self._parsed_url.user, password,
376
 
            self._parsed_url.host, self._parsed_url.port)
377
 
        return connection, (user, password)
378
 
 
379
 
    def disconnect(self):
380
 
        connection = self._get_connection()
381
 
        if connection is not None:
382
 
            connection.close()
 
195
        connection = vendor.connect_sftp(self._user, password,
 
196
                                         self._host, self._port)
 
197
        return connection, password
383
198
 
384
199
    def _get_sftp(self):
385
200
        """Ensures that a connection is established"""
390
205
            self._set_connection(connection, credentials)
391
206
        return connection
392
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
 
393
215
    def has(self, relpath):
394
216
        """
395
217
        Does the target location exist?
396
218
        """
397
219
        try:
398
220
            self._get_sftp().stat(self._remote_path(relpath))
399
 
            # stat result is about 20 bytes, let's say
400
 
            self._report_activity(20, 'read')
401
221
            return True
402
222
        except IOError:
403
223
            return False
404
224
 
405
225
    def get(self, relpath):
406
 
        """Get the file at the given relative path.
 
226
        """
 
227
        Get the file at the given relative path.
407
228
 
408
229
        :param relpath: The relative path to the file
409
230
        """
417
238
            self._translate_io_exception(e, path, ': error retrieving',
418
239
                failure_exc=errors.ReadError)
419
240
 
420
 
    def get_bytes(self, relpath):
421
 
        # reimplement this here so that we can report how many bytes came back
422
 
        f = self.get(relpath)
423
 
        try:
424
 
            bytes = f.read()
425
 
            self._report_activity(len(bytes), 'read')
426
 
            return bytes
427
 
        finally:
428
 
            f.close()
429
 
 
430
 
    def _readv(self, relpath, offsets):
 
241
    def readv(self, relpath, offsets):
431
242
        """See Transport.readv()"""
432
243
        # We overload the default readv() because we want to use a file
433
244
        # that does not have prefetch enabled.
441
252
            readv = getattr(fp, 'readv', None)
442
253
            if readv:
443
254
                return self._sftp_readv(fp, offsets, relpath)
444
 
            if 'sftp' in debug.debug_flags:
445
 
                mutter('seek and read %s offsets', len(offsets))
 
255
            mutter('seek and read %s offsets', len(offsets))
446
256
            return self._seek_and_read(fp, offsets, relpath)
447
257
        except (IOError, paramiko.SSHException), e:
448
258
            self._translate_io_exception(e, path, ': error retrieving')
449
259
 
450
 
    def recommended_page_size(self):
451
 
        """See Transport.recommended_page_size().
452
 
 
453
 
        For SFTP we suggest a large page size to reduce the overhead
454
 
        introduced by latency.
455
 
        """
456
 
        return 64 * 1024
457
 
 
458
 
    def _sftp_readv(self, fp, offsets, relpath):
 
260
    def _sftp_readv(self, fp, offsets, relpath='<unknown>'):
459
261
        """Use the readv() member of fp to do async readv.
460
262
 
461
 
        Then read them using paramiko.readv(). paramiko.readv()
 
263
        And then read them using paramiko.readv(). paramiko.readv()
462
264
        does not support ranges > 64K, so it caps the request size, and
463
 
        just reads until it gets all the stuff it wants.
 
265
        just reads until it gets all the stuff it wants
464
266
        """
465
 
        helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
466
 
        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))
467
362
 
468
363
    def put_file(self, relpath, f, mode=None):
469
364
        """
474
369
        :param mode: The final mode for the file
475
370
        """
476
371
        final_path = self._remote_path(relpath)
477
 
        return self._put(final_path, f, mode=mode)
 
372
        self._put(final_path, f, mode=mode)
478
373
 
479
374
    def _put(self, abspath, f, mode=None):
480
375
        """Helper function so both put() and copy_abspaths can reuse the code"""
485
380
        try:
486
381
            try:
487
382
                fout.set_pipelined(True)
488
 
                length = self._pump(f, fout)
 
383
                self._pump(f, fout)
489
384
            except (IOError, paramiko.SSHException), e:
490
385
                self._translate_io_exception(e, tmp_abspath)
491
386
            # XXX: This doesn't truly help like we would like it to.
494
389
            #      sticky bit. So it is probably best to stop chmodding, and
495
390
            #      just tell users that they need to set the umask correctly.
496
391
            #      The attr.st_mode = mode, in _sftp_open_exclusive
497
 
            #      will handle when the user wants the final mode to be more
498
 
            #      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 
499
394
            #      paramiko decides to expose an async chmod()
500
395
 
501
396
            # This is designed to chmod() right before we close.
502
 
            # Because we set_pipelined() earlier, theoretically we might
 
397
            # Because we set_pipelined() earlier, theoretically we might 
503
398
            # avoid the round trip for fout.close()
504
399
            if mode is not None:
505
400
                self._get_sftp().chmod(tmp_abspath, mode)
506
401
            fout.close()
507
402
            closed = True
508
403
            self._rename_and_overwrite(tmp_abspath, abspath)
509
 
            return length
510
404
        except Exception, e:
511
405
            # If we fail, try to clean up the temporary file
512
406
            # before we throw the exception
547
441
                                                 ': unable to open')
548
442
 
549
443
                # This is designed to chmod() right before we close.
550
 
                # Because we set_pipelined() earlier, theoretically we might
 
444
                # Because we set_pipelined() earlier, theoretically we might 
551
445
                # avoid the round trip for fout.close()
552
446
                if mode is not None:
553
447
                    self._get_sftp().chmod(abspath, mode)
593
487
                                    create_parent_dir=create_parent_dir,
594
488
                                    dir_mode=dir_mode)
595
489
 
596
 
    def put_bytes_non_atomic(self, relpath, raw_bytes, mode=None,
 
490
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
597
491
                             create_parent_dir=False,
598
492
                             dir_mode=None):
599
 
        if not isinstance(raw_bytes, str):
600
 
            raise TypeError(
601
 
                'raw_bytes must be a plain string, not %s' % type(raw_bytes))
602
 
 
603
493
        def writer(fout):
604
 
            fout.write(raw_bytes)
 
494
            fout.write(bytes)
605
495
        self._put_non_atomic_helper(relpath, writer, mode=mode,
606
496
                                    create_parent_dir=create_parent_dir,
607
497
                                    dir_mode=dir_mode)
608
498
 
609
499
    def iter_files_recursive(self):
610
500
        """Walk the relative paths of all files in this transport."""
611
 
        # progress is handled by list_dir
612
501
        queue = list(self.list_dir('.'))
613
502
        while queue:
614
503
            relpath = queue.pop(0)
625
514
        else:
626
515
            local_mode = mode
627
516
        try:
628
 
            self._report_activity(len(abspath), 'write')
629
517
            self._get_sftp().mkdir(abspath, local_mode)
630
 
            self._report_activity(1, 'read')
631
518
            if mode is not None:
632
 
                # chmod a dir through sftp will erase any sgid bit set
633
 
                # on the server side.  So, if the bit mode are already
634
 
                # set, avoid the chmod.  If the mode is not fine but
635
 
                # the sgid bit is set, report a warning to the user
636
 
                # with the umask fix.
637
 
                stat = self._get_sftp().lstat(abspath)
638
 
                mode = mode & 0777 # can't set special bits anyway
639
 
                if mode != stat.st_mode & 0777:
640
 
                    if stat.st_mode & 06000:
641
 
                        warning('About to chmod %s over sftp, which will result'
642
 
                                ' in its suid or sgid bits being cleared.  If'
643
 
                                ' you want to preserve those bits, change your '
644
 
                                ' environment on the server to use umask 0%03o.'
645
 
                                % (abspath, 0777 - mode))
646
 
                    self._get_sftp().chmod(abspath, mode=mode)
 
519
                self._get_sftp().chmod(abspath, mode=mode)
647
520
        except (paramiko.SSHException, IOError), e:
648
521
            self._translate_io_exception(e, abspath, ': unable to mkdir',
649
522
                failure_exc=FileExists)
652
525
        """Create a directory at the given path."""
653
526
        self._mkdir(self._remote_path(relpath), mode=mode)
654
527
 
655
 
    def open_write_stream(self, relpath, mode=None):
656
 
        """See Transport.open_write_stream."""
657
 
        # initialise the file to zero-length
658
 
        # this is three round trips, but we don't use this
659
 
        # api more than once per write_group at the moment so
660
 
        # it is a tolerable overhead. Better would be to truncate
661
 
        # the file after opening. RBC 20070805
662
 
        self.put_bytes_non_atomic(relpath, "", mode)
663
 
        abspath = self._remote_path(relpath)
664
 
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
665
 
        #       set the file mode at create time. If it does, use it.
666
 
        #       But for now, we just chmod later anyway.
667
 
        handle = None
668
 
        try:
669
 
            handle = self._get_sftp().file(abspath, mode='wb')
670
 
            handle.set_pipelined(True)
671
 
        except (paramiko.SSHException, IOError), e:
672
 
            self._translate_io_exception(e, abspath,
673
 
                                         ': unable to open')
674
 
        _file_streams[self.abspath(relpath)] = handle
675
 
        return FileFileStream(self, relpath, handle)
676
 
 
677
528
    def _translate_io_exception(self, e, path, more_info='',
678
529
                                failure_exc=PathError):
679
530
        """Translate a paramiko or IOError into a friendlier exception.
685
536
        :param failure_exc: Paramiko has the super fun ability to raise completely
686
537
                           opaque errors that just set "e.args = ('Failure',)" with
687
538
                           no more information.
688
 
                           If this parameter is set, it defines the exception
 
539
                           If this parameter is set, it defines the exception 
689
540
                           to raise in these cases.
690
541
        """
691
542
        # paramiko seems to generate detailless errors.
694
545
            if (e.args == ('No such file or directory',) or
695
546
                e.args == ('No such file',)):
696
547
                raise NoSuchFile(path, str(e) + more_info)
697
 
            if (e.args == ('mkdir failed',) or
698
 
                e.args[0].startswith('syserr: File exists')):
 
548
            if (e.args == ('mkdir failed',)):
699
549
                raise FileExists(path, str(e) + more_info)
700
550
            # strange but true, for the paramiko server.
701
551
            if (e.args == ('Failure',)):
702
552
                raise failure_exc(path, str(e) + more_info)
703
 
            # Can be something like args = ('Directory not empty:
704
 
            # '/srv/bazaar.launchpad.net/blah...: '
705
 
            # [Errno 39] Directory not empty',)
706
 
            if (e.args[0].startswith('Directory not empty: ')
707
 
                or getattr(e, 'errno', None) == errno.ENOTEMPTY):
708
 
                raise errors.DirectoryNotEmpty(path, str(e))
709
 
            if e.args == ('Operation unsupported',):
710
 
                raise errors.TransportNotPossible()
711
553
            mutter('Raising exception with args %s', e.args)
712
554
        if getattr(e, 'errno', None) is not None:
713
555
            mutter('Raising exception with errno %s', e.errno)
740
582
 
741
583
    def _rename_and_overwrite(self, abs_from, abs_to):
742
584
        """Do a fancy rename on the remote server.
743
 
 
 
585
        
744
586
        Using the implementation provided by osutils.
745
587
        """
746
588
        try:
765
607
            self._get_sftp().remove(path)
766
608
        except (IOError, paramiko.SSHException), e:
767
609
            self._translate_io_exception(e, path, ': unable to delete')
768
 
 
 
610
            
769
611
    def external_url(self):
770
612
        """See bzrlib.transport.Transport.external_url."""
771
613
        # the external path for SFTP is the base
786
628
        path = self._remote_path(relpath)
787
629
        try:
788
630
            entries = self._get_sftp().listdir(path)
789
 
            self._report_activity(sum(map(len, entries)), 'read')
790
631
        except (IOError, paramiko.SSHException), e:
791
632
            self._translate_io_exception(e, path, ': failed to list_dir')
792
633
        return [urlutils.escape(entry) for entry in entries]
803
644
        """Return the stat information for a file."""
804
645
        path = self._remote_path(relpath)
805
646
        try:
806
 
            return self._get_sftp().lstat(path)
 
647
            return self._get_sftp().stat(path)
807
648
        except (IOError, paramiko.SSHException), e:
808
649
            self._translate_io_exception(e, path, ': unable to stat')
809
650
 
810
 
    def readlink(self, relpath):
811
 
        """See Transport.readlink."""
812
 
        path = self._remote_path(relpath)
813
 
        try:
814
 
            return self._get_sftp().readlink(path)
815
 
        except (IOError, paramiko.SSHException), e:
816
 
            self._translate_io_exception(e, path, ': unable to readlink')
817
 
 
818
 
    def symlink(self, source, link_name):
819
 
        """See Transport.symlink."""
820
 
        try:
821
 
            conn = self._get_sftp()
822
 
            sftp_retval = conn.symlink(source, link_name)
823
 
            if SFTP_OK != sftp_retval:
824
 
                raise TransportError(
825
 
                    '%r: unable to create symlink to %r' % (link_name, source),
826
 
                    sftp_retval
827
 
                )
828
 
        except (IOError, paramiko.SSHException), e:
829
 
            self._translate_io_exception(e, link_name,
830
 
                                         ': unable to create symlink to %r' % (source))
831
 
 
832
651
    def lock_read(self, relpath):
833
652
        """
834
653
        Lock the given file for shared (read) access.
871
690
        """
872
691
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
873
692
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
874
 
        #       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 
875
694
        #       time using the sftp_client.file() functionality.
876
695
        path = self._get_sftp()._adjust_cwd(abspath)
877
696
        # mutter('sftp abspath %s => %s', abspath, path)
878
697
        attr = SFTPAttributes()
879
698
        if mode is not None:
880
699
            attr.st_mode = mode
881
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
 
700
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
882
701
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
883
702
        try:
884
703
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
897
716
        else:
898
717
            return True
899
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
 
900
1038
 
901
1039
def get_test_permutations():
902
1040
    """Return the permutations to be used in testing."""
903
 
    from bzrlib.tests import stub_sftp
904
 
    return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
905
 
            (SFTPTransport, stub_sftp.SFTPHomeDirServer),
906
 
            (SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
 
1041
    return [(SFTPTransport, SFTPAbsoluteServer),
 
1042
            (SFTPTransport, SFTPHomeDirServer),
 
1043
            (SFTPTransport, SFTPSiblingAbsoluteServer),
907
1044
            ]