/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: John Arbash Meinel
  • Date: 2006-09-06 20:54:07 UTC
  • mto: This revision was merged to the branch mainline in revision 1989.
  • Revision ID: john@arbash-meinel.com-20060906205407-7daa22adaea61492
Test that passing modes does the right thing for knits.

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