/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: Canonical.com Patch Queue Manager
  • Date: 2006-09-05 13:41:59 UTC
  • mfrom: (1963.1.4 run-subprocess)
  • Revision ID: pqm@pqm.ubuntu.com-20060905134159-ac8e1b01ac29c518
(jam) run_bzr_subprocess can remove env vars

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.
477
 
        """
478
 
        helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
479
 
        return helper.request_and_yield_offsets(fp)
480
 
 
481
 
    def put_file(self, relpath, f, mode=None):
482
 
        """
483
 
        Copy the file-like object into the location.
 
277
        just reads until it gets all the stuff it wants
 
278
        """
 
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()
 
368
 
 
369
    def put(self, relpath, f, mode=None):
 
370
        """
 
371
        Copy the file-like or string object into the location.
484
372
 
485
373
        :param relpath: Location to put the contents, relative to base.
486
 
        :param f:       File-like object.
 
374
        :param f:       File-like or string object.
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
 
            # XXX: This doesn't truly help like we would like it to.
505
 
            #      The problem is that openssh strips sticky bits. So while we
506
 
            #      can properly set group write permission, we lose the group
507
 
            #      sticky bit. So it is probably best to stop chmodding, and
508
 
            #      just tell users that they need to set the umask correctly.
509
 
            #      The attr.st_mode = mode, in _sftp_open_exclusive
510
 
            #      will handle when the user wants the final mode to be more
511
 
            #      restrictive. And then we avoid a round trip. Unless
512
 
            #      paramiko decides to expose an async chmod()
513
 
 
514
 
            # This is designed to chmod() right before we close.
515
 
            # Because we set_pipelined() earlier, theoretically we might
516
 
            # avoid the round trip for fout.close()
517
392
            if mode is not None:
518
 
                self._get_sftp().chmod(tmp_abspath, mode)
 
393
                self._sftp.chmod(tmp_abspath, mode)
519
394
            fout.close()
520
395
            closed = True
521
396
            self._rename_and_overwrite(tmp_abspath, abspath)
522
 
            return length
523
397
        except Exception, e:
524
398
            # If we fail, try to clean up the temporary file
525
399
            # before we throw the exception
531
405
            try:
532
406
                if not closed:
533
407
                    fout.close()
534
 
                self._get_sftp().remove(tmp_abspath)
 
408
                self._sftp.remove(tmp_abspath)
535
409
            except:
536
410
                # raise the saved except
537
411
                raise e
538
412
            # raise the original with its traceback if we can.
539
413
            raise
540
414
 
541
 
    def _put_non_atomic_helper(self, relpath, writer, mode=None,
542
 
                               create_parent_dir=False,
543
 
                               dir_mode=None):
544
 
        abspath = self._remote_path(relpath)
545
 
 
546
 
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
547
 
        #       set the file mode at create time. If it does, use it.
548
 
        #       But for now, we just chmod later anyway.
549
 
 
550
 
        def _open_and_write_file():
551
 
            """Try to open the target file, raise error on failure"""
552
 
            fout = None
553
 
            try:
554
 
                try:
555
 
                    fout = self._get_sftp().file(abspath, mode='wb')
556
 
                    fout.set_pipelined(True)
557
 
                    writer(fout)
558
 
                except (paramiko.SSHException, IOError), e:
559
 
                    self._translate_io_exception(e, abspath,
560
 
                                                 ': unable to open')
561
 
 
562
 
                # This is designed to chmod() right before we close.
563
 
                # Because we set_pipelined() earlier, theoretically we might
564
 
                # avoid the round trip for fout.close()
565
 
                if mode is not None:
566
 
                    self._get_sftp().chmod(abspath, mode)
567
 
            finally:
568
 
                if fout is not None:
569
 
                    fout.close()
570
 
 
571
 
        if not create_parent_dir:
572
 
            _open_and_write_file()
573
 
            return
574
 
 
575
 
        # Try error handling to create the parent directory if we need to
576
 
        try:
577
 
            _open_and_write_file()
578
 
        except NoSuchFile:
579
 
            # Try to create the parent directory, and then go back to
580
 
            # writing the file
581
 
            parent_dir = os.path.dirname(abspath)
582
 
            self._mkdir(parent_dir, dir_mode)
583
 
            _open_and_write_file()
584
 
 
585
 
    def put_file_non_atomic(self, relpath, f, mode=None,
586
 
                            create_parent_dir=False,
587
 
                            dir_mode=None):
588
 
        """Copy the file-like object into the target location.
589
 
 
590
 
        This function is not strictly safe to use. It is only meant to
591
 
        be used when you already know that the target does not exist.
592
 
        It is not safe, because it will open and truncate the remote
593
 
        file. So there may be a time when the file has invalid contents.
594
 
 
595
 
        :param relpath: The remote location to put the contents.
596
 
        :param f:       File-like object.
597
 
        :param mode:    Possible access permissions for new file.
598
 
                        None means do not set remote permissions.
599
 
        :param create_parent_dir: If we cannot create the target file because
600
 
                        the parent directory does not exist, go ahead and
601
 
                        create it, and then try again.
602
 
        """
603
 
        def writer(fout):
604
 
            self._pump(f, fout)
605
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
606
 
                                    create_parent_dir=create_parent_dir,
607
 
                                    dir_mode=dir_mode)
608
 
 
609
 
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
610
 
                             create_parent_dir=False,
611
 
                             dir_mode=None):
612
 
        def writer(fout):
613
 
            fout.write(bytes)
614
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
615
 
                                    create_parent_dir=create_parent_dir,
616
 
                                    dir_mode=dir_mode)
617
 
 
618
415
    def iter_files_recursive(self):
619
416
        """Walk the relative paths of all files in this transport."""
620
 
        # progress is handled by list_dir
621
417
        queue = list(self.list_dir('.'))
622
418
        while queue:
623
419
            relpath = queue.pop(0)
628
424
            else:
629
425
                yield relpath
630
426
 
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
427
    def mkdir(self, relpath, mode=None):
661
428
        """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
 
429
        path = self._remote_path(relpath)
677
430
        try:
678
 
            handle = self._get_sftp().file(abspath, mode='wb')
679
 
            handle.set_pipelined(True)
 
431
            # In the paramiko documentation, it says that passing a mode flag 
 
432
            # will filtered against the server umask.
 
433
            # StubSFTPServer does not do this, which would be nice, because it is
 
434
            # what we really want :)
 
435
            # However, real servers do use umask, so we really should do it that way
 
436
            self._sftp.mkdir(path)
 
437
            if mode is not None:
 
438
                self._sftp.chmod(path, mode=mode)
680
439
        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)
 
440
            self._translate_io_exception(e, path, ': unable to mkdir',
 
441
                failure_exc=FileExists)
685
442
 
686
 
    def _translate_io_exception(self, e, path, more_info='',
 
443
    def _translate_io_exception(self, e, path, more_info='', 
687
444
                                failure_exc=PathError):
688
445
        """Translate a paramiko or IOError into a friendlier exception.
689
446
 
694
451
        :param failure_exc: Paramiko has the super fun ability to raise completely
695
452
                           opaque errors that just set "e.args = ('Failure',)" with
696
453
                           no more information.
697
 
                           If this parameter is set, it defines the exception
 
454
                           If this parameter is set, it defines the exception 
698
455
                           to raise in these cases.
699
456
        """
700
457
        # paramiko seems to generate detailless errors.
701
458
        self._translate_error(e, path, raise_generic=False)
702
 
        if getattr(e, 'args', None) is not None:
 
459
        if hasattr(e, 'args'):
703
460
            if (e.args == ('No such file or directory',) or
704
461
                e.args == ('No such file',)):
705
462
                raise NoSuchFile(path, str(e) + more_info)
706
 
            if (e.args == ('mkdir failed',) or
707
 
                e.args[0].startswith('syserr: File exists')):
 
463
            if (e.args == ('mkdir failed',)):
708
464
                raise FileExists(path, str(e) + more_info)
709
465
            # strange but true, for the paramiko server.
710
466
            if (e.args == ('Failure',)):
711
467
                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
468
            mutter('Raising exception with args %s', e.args)
719
 
        if getattr(e, 'errno', None) is not None:
 
469
        if hasattr(e, 'errno'):
720
470
            mutter('Raising exception with errno %s', e.errno)
721
471
        raise e
722
472
 
723
 
    def append_file(self, relpath, f, mode=None):
 
473
    def append(self, relpath, f, mode=None):
724
474
        """
725
475
        Append the text in the file-like object into the final
726
476
        location.
727
477
        """
728
478
        try:
729
479
            path = self._remote_path(relpath)
730
 
            fout = self._get_sftp().file(path, 'ab')
 
480
            fout = self._sftp.file(path, 'ab')
731
481
            if mode is not None:
732
 
                self._get_sftp().chmod(path, mode)
 
482
                self._sftp.chmod(path, mode)
733
483
            result = fout.tell()
734
484
            self._pump(f, fout)
735
485
            return result
739
489
    def rename(self, rel_from, rel_to):
740
490
        """Rename without special overwriting"""
741
491
        try:
742
 
            self._get_sftp().rename(self._remote_path(rel_from),
 
492
            self._sftp.rename(self._remote_path(rel_from),
743
493
                              self._remote_path(rel_to))
744
494
        except (IOError, paramiko.SSHException), e:
745
495
            self._translate_io_exception(e, rel_from,
747
497
 
748
498
    def _rename_and_overwrite(self, abs_from, abs_to):
749
499
        """Do a fancy rename on the remote server.
750
 
 
 
500
        
751
501
        Using the implementation provided by osutils.
752
502
        """
753
503
        try:
754
 
            sftp = self._get_sftp()
755
504
            fancy_rename(abs_from, abs_to,
756
 
                         rename_func=sftp.rename,
757
 
                         unlink_func=sftp.remove)
 
505
                    rename_func=self._sftp.rename,
 
506
                    unlink_func=self._sftp.remove)
758
507
        except (IOError, paramiko.SSHException), e:
759
 
            self._translate_io_exception(e, abs_from,
760
 
                                         ': unable to rename to %r' % (abs_to))
 
508
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
761
509
 
762
510
    def move(self, rel_from, rel_to):
763
511
        """Move the item at rel_from to the location at rel_to"""
769
517
        """Delete the item at relpath"""
770
518
        path = self._remote_path(relpath)
771
519
        try:
772
 
            self._get_sftp().remove(path)
 
520
            self._sftp.remove(path)
773
521
        except (IOError, paramiko.SSHException), e:
774
522
            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
 
 
 
523
            
781
524
    def listable(self):
782
525
        """Return True if this store supports listing."""
783
526
        return True
792
535
        # -- David Allouche 2006-08-11
793
536
        path = self._remote_path(relpath)
794
537
        try:
795
 
            entries = self._get_sftp().listdir(path)
796
 
            self._report_activity(sum(map(len, entries)), 'read')
 
538
            entries = self._sftp.listdir(path)
797
539
        except (IOError, paramiko.SSHException), e:
798
540
            self._translate_io_exception(e, path, ': failed to list_dir')
799
541
        return [urlutils.escape(entry) for entry in entries]
802
544
        """See Transport.rmdir."""
803
545
        path = self._remote_path(relpath)
804
546
        try:
805
 
            return self._get_sftp().rmdir(path)
 
547
            return self._sftp.rmdir(path)
806
548
        except (IOError, paramiko.SSHException), e:
807
549
            self._translate_io_exception(e, path, ': failed to rmdir')
808
550
 
810
552
        """Return the stat information for a file."""
811
553
        path = self._remote_path(relpath)
812
554
        try:
813
 
            return self._get_sftp().lstat(path)
 
555
            return self._sftp.stat(path)
814
556
        except (IOError, paramiko.SSHException), e:
815
557
            self._translate_io_exception(e, path, ': unable to stat')
816
558
 
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
559
    def lock_read(self, relpath):
840
560
        """
841
561
        Lock the given file for shared (read) access.
862
582
        # that we have taken the lock.
863
583
        return SFTPLock(relpath, self)
864
584
 
 
585
    def _unparse_url(self, path=None):
 
586
        if path is None:
 
587
            path = self._path
 
588
        path = urllib.quote(path)
 
589
        # handle homedir paths
 
590
        if not path.startswith('/'):
 
591
            path = "/~/" + path
 
592
        netloc = urllib.quote(self._host)
 
593
        if self._username is not None:
 
594
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
595
        if self._port is not None:
 
596
            netloc = '%s:%d' % (netloc, self._port)
 
597
        return urlparse.urlunparse(('sftp', netloc, path, '', '', ''))
 
598
 
 
599
    def _split_url(self, url):
 
600
        (scheme, username, password, host, port, path) = split_url(url)
 
601
        assert scheme == 'sftp'
 
602
 
 
603
        # the initial slash should be removed from the path, and treated
 
604
        # as a homedir relative path (the path begins with a double slash
 
605
        # if it is absolute).
 
606
        # see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
 
607
        # RBC 20060118 we are not using this as its too user hostile. instead
 
608
        # we are following lftp and using /~/foo to mean '~/foo'.
 
609
        # handle homedir paths
 
610
        if path.startswith('/~/'):
 
611
            path = path[3:]
 
612
        elif path == '/~':
 
613
            path = ''
 
614
        return (username, password, host, port, path)
 
615
 
 
616
    def _parse_url(self, url):
 
617
        (self._username, self._password,
 
618
         self._host, self._port, self._path) = self._split_url(url)
 
619
 
 
620
    def _sftp_connect(self):
 
621
        """Connect to the remote sftp server.
 
622
        After this, self._sftp should have a valid connection (or
 
623
        we raise an TransportError 'could not connect').
 
624
 
 
625
        TODO: Raise a more reasonable ConnectionFailed exception
 
626
        """
 
627
        self._sftp = _sftp_connect(self._host, self._port, self._username,
 
628
                self._password)
 
629
 
865
630
    def _sftp_open_exclusive(self, abspath, mode=None):
866
631
        """Open a remote path exclusively.
867
632
 
876
641
        :param abspath: The remote absolute path where the file should be opened
877
642
        :param mode: The mode permissions bits for the new file
878
643
        """
879
 
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
880
 
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
881
 
        #       However, there is no way to set the permission mode at open
882
 
        #       time using the sftp_client.file() functionality.
883
 
        path = self._get_sftp()._adjust_cwd(abspath)
 
644
        path = self._sftp._adjust_cwd(abspath)
884
645
        # mutter('sftp abspath %s => %s', abspath, path)
885
646
        attr = SFTPAttributes()
886
647
        if mode is not None:
887
648
            attr.st_mode = mode
888
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
 
649
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
889
650
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
890
651
        try:
891
 
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
 
652
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
892
653
            if t != CMD_HANDLE:
893
654
                raise TransportError('Expected an SFTP handle')
894
655
            handle = msg.get_string()
895
 
            return SFTPFile(self._get_sftp(), handle, 'wb', -1)
 
656
            return SFTPFile(self._sftp, handle, 'wb', -1)
896
657
        except (paramiko.SSHException, IOError), e:
897
658
            self._translate_io_exception(e, abspath, ': unable to open',
898
659
                failure_exc=FileExists)
899
660
 
900
 
    def _can_roundtrip_unix_modebits(self):
901
 
        if sys.platform == 'win32':
902
 
            # anyone else?
903
 
            return False
904
 
        else:
905
 
            return True
 
661
 
 
662
# ------------- server test implementation --------------
 
663
import threading
 
664
 
 
665
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
 
666
 
 
667
STUB_SERVER_KEY = """
 
668
-----BEGIN RSA PRIVATE KEY-----
 
669
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
 
670
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
 
671
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
 
672
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
 
673
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
 
674
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
 
675
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
 
676
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
 
677
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
 
678
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
 
679
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
 
680
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
 
681
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
 
682
-----END RSA PRIVATE KEY-----
 
683
"""
 
684
 
 
685
 
 
686
class SocketListener(threading.Thread):
 
687
 
 
688
    def __init__(self, callback):
 
689
        threading.Thread.__init__(self)
 
690
        self._callback = callback
 
691
        self._socket = socket.socket()
 
692
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
693
        self._socket.bind(('localhost', 0))
 
694
        self._socket.listen(1)
 
695
        self.port = self._socket.getsockname()[1]
 
696
        self._stop_event = threading.Event()
 
697
 
 
698
    def stop(self):
 
699
        # called from outside this thread
 
700
        self._stop_event.set()
 
701
        # use a timeout here, because if the test fails, the server thread may
 
702
        # never notice the stop_event.
 
703
        self.join(5.0)
 
704
        self._socket.close()
 
705
 
 
706
    def run(self):
 
707
        while True:
 
708
            readable, writable_unused, exception_unused = \
 
709
                select.select([self._socket], [], [], 0.1)
 
710
            if self._stop_event.isSet():
 
711
                return
 
712
            if len(readable) == 0:
 
713
                continue
 
714
            try:
 
715
                s, addr_unused = self._socket.accept()
 
716
                # because the loopback socket is inline, and transports are
 
717
                # never explicitly closed, best to launch a new thread.
 
718
                threading.Thread(target=self._callback, args=(s,)).start()
 
719
            except socket.error, x:
 
720
                sys.excepthook(*sys.exc_info())
 
721
                warning('Socket error during accept() within unit test server'
 
722
                        ' thread: %r' % x)
 
723
            except Exception, x:
 
724
                # probably a failed test; unit test thread will log the
 
725
                # failure/error
 
726
                sys.excepthook(*sys.exc_info())
 
727
                warning('Exception from within unit test server thread: %r' % 
 
728
                        x)
 
729
 
 
730
 
 
731
class SocketDelay(object):
 
732
    """A socket decorator to make TCP appear slower.
 
733
 
 
734
    This changes recv, send, and sendall to add a fixed latency to each python
 
735
    call if a new roundtrip is detected. That is, when a recv is called and the
 
736
    flag new_roundtrip is set, latency is charged. Every send and send_all
 
737
    sets this flag.
 
738
 
 
739
    In addition every send, sendall and recv sleeps a bit per character send to
 
740
    simulate bandwidth.
 
741
 
 
742
    Not all methods are implemented, this is deliberate as this class is not a
 
743
    replacement for the builtin sockets layer. fileno is not implemented to
 
744
    prevent the proxy being bypassed. 
 
745
    """
 
746
 
 
747
    simulated_time = 0
 
748
    _proxied_arguments = dict.fromkeys([
 
749
        "close", "getpeername", "getsockname", "getsockopt", "gettimeout",
 
750
        "setblocking", "setsockopt", "settimeout", "shutdown"])
 
751
 
 
752
    def __init__(self, sock, latency, bandwidth=1.0, 
 
753
                 really_sleep=True):
 
754
        """ 
 
755
        :param bandwith: simulated bandwith (MegaBit)
 
756
        :param really_sleep: If set to false, the SocketDelay will just
 
757
        increase a counter, instead of calling time.sleep. This is useful for
 
758
        unittesting the SocketDelay.
 
759
        """
 
760
        self.sock = sock
 
761
        self.latency = latency
 
762
        self.really_sleep = really_sleep
 
763
        self.time_per_byte = 1 / (bandwidth / 8.0 * 1024 * 1024) 
 
764
        self.new_roundtrip = False
 
765
 
 
766
    def sleep(self, s):
 
767
        if self.really_sleep:
 
768
            time.sleep(s)
 
769
        else:
 
770
            SocketDelay.simulated_time += s
 
771
 
 
772
    def __getattr__(self, attr):
 
773
        if attr in SocketDelay._proxied_arguments:
 
774
            return getattr(self.sock, attr)
 
775
        raise AttributeError("'SocketDelay' object has no attribute %r" %
 
776
                             attr)
 
777
 
 
778
    def dup(self):
 
779
        return SocketDelay(self.sock.dup(), self.latency, self.time_per_byte,
 
780
                           self._sleep)
 
781
 
 
782
    def recv(self, *args):
 
783
        data = self.sock.recv(*args)
 
784
        if data and self.new_roundtrip:
 
785
            self.new_roundtrip = False
 
786
            self.sleep(self.latency)
 
787
        self.sleep(len(data) * self.time_per_byte)
 
788
        return data
 
789
 
 
790
    def sendall(self, data, flags=0):
 
791
        if not self.new_roundtrip:
 
792
            self.new_roundtrip = True
 
793
            self.sleep(self.latency)
 
794
        self.sleep(len(data) * self.time_per_byte)
 
795
        return self.sock.sendall(data, flags)
 
796
 
 
797
    def send(self, data, flags=0):
 
798
        if not self.new_roundtrip:
 
799
            self.new_roundtrip = True
 
800
            self.sleep(self.latency)
 
801
        bytes_sent = self.sock.send(data, flags)
 
802
        self.sleep(bytes_sent * self.time_per_byte)
 
803
        return bytes_sent
 
804
 
 
805
 
 
806
class SFTPServer(Server):
 
807
    """Common code for SFTP server facilities."""
 
808
 
 
809
    def __init__(self):
 
810
        self._original_vendor = None
 
811
        self._homedir = None
 
812
        self._server_homedir = None
 
813
        self._listener = None
 
814
        self._root = None
 
815
        self._vendor = ssh.ParamikoVendor()
 
816
        # sftp server logs
 
817
        self.logs = []
 
818
        self.add_latency = 0
 
819
 
 
820
    def _get_sftp_url(self, path):
 
821
        """Calculate an sftp url to this server for path."""
 
822
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
 
823
 
 
824
    def log(self, message):
 
825
        """StubServer uses this to log when a new server is created."""
 
826
        self.logs.append(message)
 
827
 
 
828
    def _run_server_entry(self, sock):
 
829
        """Entry point for all implementations of _run_server.
 
830
        
 
831
        If self.add_latency is > 0.000001 then sock is given a latency adding
 
832
        decorator.
 
833
        """
 
834
        if self.add_latency > 0.000001:
 
835
            sock = SocketDelay(sock, self.add_latency)
 
836
        return self._run_server(sock)
 
837
 
 
838
    def _run_server(self, s):
 
839
        ssh_server = paramiko.Transport(s)
 
840
        key_file = pathjoin(self._homedir, 'test_rsa.key')
 
841
        f = open(key_file, 'w')
 
842
        f.write(STUB_SERVER_KEY)
 
843
        f.close()
 
844
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
 
845
        ssh_server.add_server_key(host_key)
 
846
        server = StubServer(self)
 
847
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
 
848
                                         StubSFTPServer, root=self._root,
 
849
                                         home=self._server_homedir)
 
850
        event = threading.Event()
 
851
        ssh_server.start_server(event, server)
 
852
        event.wait(5.0)
 
853
    
 
854
    def setUp(self):
 
855
        self._original_vendor = ssh._ssh_vendor
 
856
        ssh._ssh_vendor = self._vendor
 
857
        if sys.platform == 'win32':
 
858
            # Win32 needs to use the UNICODE api
 
859
            self._homedir = getcwd()
 
860
        else:
 
861
            # But Linux SFTP servers should just deal in bytestreams
 
862
            self._homedir = os.getcwd()
 
863
        if self._server_homedir is None:
 
864
            self._server_homedir = self._homedir
 
865
        self._root = '/'
 
866
        if sys.platform == 'win32':
 
867
            self._root = ''
 
868
        self._listener = SocketListener(self._run_server_entry)
 
869
        self._listener.setDaemon(True)
 
870
        self._listener.start()
 
871
 
 
872
    def tearDown(self):
 
873
        """See bzrlib.transport.Server.tearDown."""
 
874
        self._listener.stop()
 
875
        ssh._ssh_vendor = self._original_vendor
 
876
 
 
877
    def get_bogus_url(self):
 
878
        """See bzrlib.transport.Server.get_bogus_url."""
 
879
        # this is chosen to try to prevent trouble with proxies, wierd dns, etc
 
880
        # we bind a random socket, so that we get a guaranteed unused port
 
881
        # we just never listen on that port
 
882
        s = socket.socket()
 
883
        s.bind(('localhost', 0))
 
884
        return 'sftp://%s:%s/' % s.getsockname()
 
885
 
 
886
 
 
887
class SFTPFullAbsoluteServer(SFTPServer):
 
888
    """A test server for sftp transports, using absolute urls and ssh."""
 
889
 
 
890
    def get_url(self):
 
891
        """See bzrlib.transport.Server.get_url."""
 
892
        return self._get_sftp_url(urlutils.escape(self._homedir[1:]))
 
893
 
 
894
 
 
895
class SFTPServerWithoutSSH(SFTPServer):
 
896
    """An SFTP server that uses a simple TCP socket pair rather than SSH."""
 
897
 
 
898
    def __init__(self):
 
899
        super(SFTPServerWithoutSSH, self).__init__()
 
900
        self._vendor = ssh.LoopbackVendor()
 
901
 
 
902
    def _run_server(self, sock):
 
903
        # Re-import these as locals, so that they're still accessible during
 
904
        # interpreter shutdown (when all module globals get set to None, leading
 
905
        # to confusing errors like "'NoneType' object has no attribute 'error'".
 
906
        import socket, errno
 
907
        class FakeChannel(object):
 
908
            def get_transport(self):
 
909
                return self
 
910
            def get_log_channel(self):
 
911
                return 'paramiko'
 
912
            def get_name(self):
 
913
                return '1'
 
914
            def get_hexdump(self):
 
915
                return False
 
916
            def close(self):
 
917
                pass
 
918
 
 
919
        server = paramiko.SFTPServer(FakeChannel(), 'sftp', StubServer(self), StubSFTPServer,
 
920
                                     root=self._root, home=self._server_homedir)
 
921
        try:
 
922
            server.start_subsystem('sftp', None, sock)
 
923
        except socket.error, e:
 
924
            if (len(e.args) > 0) and (e.args[0] == errno.EPIPE):
 
925
                # it's okay for the client to disconnect abruptly
 
926
                # (bug in paramiko 1.6: it should absorb this exception)
 
927
                pass
 
928
            else:
 
929
                raise
 
930
        except Exception, e:
 
931
            import sys; sys.stderr.write('\nEXCEPTION %r\n\n' % e.__class__)
 
932
        server.finish_subsystem()
 
933
 
 
934
 
 
935
class SFTPAbsoluteServer(SFTPServerWithoutSSH):
 
936
    """A test server for sftp transports, using absolute urls."""
 
937
 
 
938
    def get_url(self):
 
939
        """See bzrlib.transport.Server.get_url."""
 
940
        if sys.platform == 'win32':
 
941
            return self._get_sftp_url(urlutils.escape(self._homedir))
 
942
        else:
 
943
            return self._get_sftp_url(urlutils.escape(self._homedir[1:]))
 
944
 
 
945
 
 
946
class SFTPHomeDirServer(SFTPServerWithoutSSH):
 
947
    """A test server for sftp transports, using homedir relative urls."""
 
948
 
 
949
    def get_url(self):
 
950
        """See bzrlib.transport.Server.get_url."""
 
951
        return self._get_sftp_url("~/")
 
952
 
 
953
 
 
954
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
 
955
    """A test servere for sftp transports, using absolute urls to non-home."""
 
956
 
 
957
    def setUp(self):
 
958
        self._server_homedir = '/dev/noone/runs/tests/here'
 
959
        super(SFTPSiblingAbsoluteServer, self).setUp()
 
960
 
 
961
 
 
962
def _sftp_connect(host, port, username, password):
 
963
    """Connect to the remote sftp server.
 
964
 
 
965
    :raises: a TransportError 'could not connect'.
 
966
 
 
967
    :returns: an paramiko.sftp_client.SFTPClient
 
968
 
 
969
    TODO: Raise a more reasonable ConnectionFailed exception
 
970
    """
 
971
    idx = (host, port, username)
 
972
    try:
 
973
        return _connected_hosts[idx]
 
974
    except KeyError:
 
975
        pass
 
976
    
 
977
    sftp = _sftp_connect_uncached(host, port, username, password)
 
978
    _connected_hosts[idx] = sftp
 
979
    return sftp
 
980
 
 
981
def _sftp_connect_uncached(host, port, username, password):
 
982
    vendor = ssh._get_ssh_vendor()
 
983
    sftp = vendor.connect_sftp(username, password, host, port)
 
984
    return sftp
906
985
 
907
986
 
908
987
def get_test_permutations():
909
988
    """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),
 
989
    return [(SFTPTransport, SFTPAbsoluteServer),
 
990
            (SFTPTransport, SFTPHomeDirServer),
 
991
            (SFTPTransport, SFTPSiblingAbsoluteServer),
914
992
            ]