~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

Don't ignore bzrlib/plugins -- really bad idea because they can have bad 
old plugins lying around!

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
2
 
# Copyright (C) 2005, 2006 Canonical Ltd
3
 
#
 
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>, Canonical Ltd
 
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
#
 
7
 
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
#
 
12
 
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
17
"""Implementation of Transport over SFTP, using paramiko."""
19
18
 
20
 
# TODO: Remove the transport-based lock_read and lock_write methods.  They'll
21
 
# then raise TransportNotPossible, which will break remote access to any
22
 
# formats which rely on OS-level locks.  That should be fine as those formats
23
 
# are pretty old, but these combinations may have to be removed from the test
24
 
# suite.  Those formats all date back to 0.7; so we should be able to remove
25
 
# these methods when we officially drop support for those formats.
26
 
 
27
19
import errno
 
20
import getpass
28
21
import os
29
 
import random
30
 
import select
31
 
import socket
 
22
import re
32
23
import stat
33
24
import sys
 
25
import urllib
34
26
import time
35
 
import urllib
36
 
import urlparse
37
 
import weakref
 
27
import random
38
28
 
39
 
from bzrlib import (
40
 
    errors,
41
 
    urlutils,
42
 
    )
43
 
from bzrlib.errors import (FileExists,
44
 
                           NoSuchFile, PathNotChild,
 
29
from bzrlib.errors import (FileExists, 
 
30
                           TransportNotPossible, NoSuchFile, NonRelativePath,
45
31
                           TransportError,
46
 
                           LockError,
47
 
                           PathError,
48
 
                           ParamikoNotPresent,
49
 
                           )
50
 
from bzrlib.osutils import pathjoin, fancy_rename, getcwd
51
 
from bzrlib.trace import mutter, warning
52
 
from bzrlib.transport import (
53
 
    register_urlparse_netloc_protocol,
54
 
    Server,
55
 
    split_url,
56
 
    ssh,
57
 
    Transport,
58
 
    )
 
32
                           LockError)
 
33
from bzrlib.config import config_dir
 
34
from bzrlib.trace import mutter, warning, error
 
35
from bzrlib.transport import Transport, register_transport
59
36
 
60
37
try:
61
38
    import paramiko
62
 
except ImportError, e:
63
 
    raise ParamikoNotPresent(e)
 
39
except ImportError:
 
40
    error('The SFTP transport requires paramiko.')
 
41
    raise
64
42
else:
65
43
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
66
44
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
69
47
    from paramiko.sftp_file import SFTPFile
70
48
 
71
49
 
72
 
register_urlparse_netloc_protocol('sftp')
73
 
 
74
 
 
75
 
# This is a weakref dictionary, so that we can reuse connections
76
 
# that are still active. Long term, it might be nice to have some
77
 
# sort of expiration policy, such as disconnect if inactive for
78
 
# X seconds. But that requires a lot more fanciness.
79
 
_connected_hosts = weakref.WeakValueDictionary()
80
 
 
81
 
 
82
 
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
83
 
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
84
 
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
85
 
 
86
 
 
87
 
def clear_connection_cache():
88
 
    """Remove all hosts from the SFTP connection cache.
89
 
 
90
 
    Primarily useful for test cases wanting to force garbage collection.
91
 
    """
92
 
    _connected_hosts.clear()
93
 
 
 
50
SYSTEM_HOSTKEYS = {}
 
51
BZR_HOSTKEYS = {}
 
52
 
 
53
def load_host_keys():
 
54
    """
 
55
    Load system host keys (probably doesn't work on windows) and any
 
56
    "discovered" keys from previous sessions.
 
57
    """
 
58
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
59
    try:
 
60
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
61
    except Exception, e:
 
62
        mutter('failed to load system host keys: ' + str(e))
 
63
    bzr_hostkey_path = os.path.join(config_dir(), 'ssh_host_keys')
 
64
    try:
 
65
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
 
66
    except Exception, e:
 
67
        mutter('failed to load bzr host keys: ' + str(e))
 
68
        save_host_keys()
 
69
 
 
70
def save_host_keys():
 
71
    """
 
72
    Save "discovered" host keys in $(config)/ssh_host_keys/.
 
73
    """
 
74
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
75
    bzr_hostkey_path = os.path.join(config_dir(), 'ssh_host_keys')
 
76
    if not os.path.isdir(config_dir()):
 
77
        os.mkdir(config_dir())
 
78
    try:
 
79
        f = open(bzr_hostkey_path, 'w')
 
80
        f.write('# SSH host keys collected by bzr\n')
 
81
        for hostname, keys in BZR_HOSTKEYS.iteritems():
 
82
            for keytype, key in keys.iteritems():
 
83
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
 
84
        f.close()
 
85
    except IOError, e:
 
86
        mutter('failed to save bzr host keys: ' + str(e))
 
87
 
 
88
 
 
89
 
 
90
class SFTPTransportError (TransportError):
 
91
    pass
94
92
 
95
93
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
 
    
 
94
    """This fakes a lock in a remote location."""
103
95
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
104
 
 
105
96
    def __init__(self, path, transport):
106
97
        assert isinstance(transport, SFTPTransport)
107
98
 
110
101
        self.lock_path = path + '.write-lock'
111
102
        self.transport = transport
112
103
        try:
113
 
            # RBC 20060103 FIXME should we be using private methods here ?
114
 
            abspath = transport._remote_path(self.lock_path)
115
 
            self.lock_file = transport._sftp_open_exclusive(abspath)
 
104
            self.lock_file = transport._sftp_open_exclusive(self.lock_path)
116
105
        except FileExists:
117
106
            raise LockError('File %r already locked' % (self.path,))
118
107
 
119
108
    def __del__(self):
120
109
        """Should this warn, or actually try to cleanup?"""
121
110
        if self.lock_file:
122
 
            warning("SFTPLock %r not explicitly unlocked" % (self.path,))
 
111
            warn("SFTPLock %r not explicitly unlocked" % (self.path,))
123
112
            self.unlock()
124
113
 
125
114
    def unlock(self):
133
122
            # What specific errors should we catch here?
134
123
            pass
135
124
 
136
 
 
137
 
class SFTPUrlHandling(Transport):
138
 
    """Mix-in that does common handling of SSH/SFTP URLs."""
139
 
 
140
 
    def __init__(self, base):
141
 
        self._parse_url(base)
142
 
        base = self._unparse_url(self._path)
143
 
        if base[-1] != '/':
144
 
            base += '/'
145
 
        super(SFTPUrlHandling, self).__init__(base)
146
 
 
147
 
    def _parse_url(self, url):
148
 
        (self._scheme,
149
 
         self._username, self._password,
150
 
         self._host, self._port, self._path) = self._split_url(url)
151
 
 
152
 
    def _unparse_url(self, path):
153
 
        """Return a URL for a path relative to this transport.
154
 
        """
155
 
        path = urllib.quote(path)
156
 
        # handle homedir paths
157
 
        if not path.startswith('/'):
158
 
            path = "/~/" + path
159
 
        netloc = urllib.quote(self._host)
160
 
        if self._username is not None:
161
 
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
162
 
        if self._port is not None:
163
 
            netloc = '%s:%d' % (netloc, self._port)
164
 
        return urlparse.urlunparse((self._scheme, netloc, path, '', '', ''))
165
 
 
166
 
    def _split_url(self, url):
167
 
        (scheme, username, password, host, port, path) = split_url(url)
168
 
        ## assert scheme == 'sftp'
169
 
 
170
 
        # the initial slash should be removed from the path, and treated
171
 
        # as a homedir relative path (the path begins with a double slash
172
 
        # if it is absolute).
173
 
        # see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
174
 
        # RBC 20060118 we are not using this as its too user hostile. instead
175
 
        # we are following lftp and using /~/foo to mean '~/foo'.
176
 
        # handle homedir paths
177
 
        if path.startswith('/~/'):
178
 
            path = path[3:]
179
 
        elif path == '/~':
180
 
            path = ''
181
 
        return (scheme, username, password, host, port, path)
182
 
 
183
 
    def abspath(self, relpath):
184
 
        """Return the full url to the given relative path.
185
 
        
186
 
        @param relpath: the relative path or path components
187
 
        @type relpath: str or list
188
 
        """
189
 
        return self._unparse_url(self._remote_path(relpath))
 
125
class SFTPTransport (Transport):
 
126
    """
 
127
    Transport implementation for SFTP access.
 
128
    """
 
129
 
 
130
    _url_matcher = re.compile(r'^sftp://([^:@]*(:[^@]*)?@)?(.*?)(:[^/]+)?(/.*)?$')
190
131
    
191
 
    def _remote_path(self, relpath):
192
 
        """Return the path to be passed along the sftp protocol for relpath.
193
 
        
194
 
        :param relpath: is a urlencoded string.
195
 
        """
196
 
        return self._combine_paths(self._path, relpath)
197
 
 
198
 
 
199
 
class SFTPTransport(SFTPUrlHandling):
200
 
    """Transport implementation for SFTP access."""
201
 
 
202
 
    _do_prefetch = _default_do_prefetch
203
 
    # TODO: jam 20060717 Conceivably these could be configurable, either
204
 
    #       by auto-tuning at run-time, or by a configuration (per host??)
205
 
    #       but the performance curve is pretty flat, so just going with
206
 
    #       reasonable defaults.
207
 
    _max_readv_combine = 200
208
 
    # Having to round trip to the server means waiting for a response,
209
 
    # so it is better to download extra bytes.
210
 
    # 8KiB had good performance for both local and remote network operations
211
 
    _bytes_to_read_before_seek = 8192
212
 
 
213
 
    # The sftp spec says that implementations SHOULD allow reads
214
 
    # to be at least 32K. paramiko.readv() does an async request
215
 
    # for the chunks. So we need to keep it within a single request
216
 
    # size for paramiko <= 1.6.1. paramiko 1.6.2 will probably chop
217
 
    # up the request itself, rather than us having to worry about it
218
 
    _max_request_size = 32768
219
 
 
220
132
    def __init__(self, base, clone_from=None):
 
133
        assert base.startswith('sftp://')
221
134
        super(SFTPTransport, self).__init__(base)
 
135
        self._parse_url(base)
222
136
        if clone_from is None:
223
137
            self._sftp_connect()
224
138
        else:
243
157
        else:
244
158
            return SFTPTransport(self.abspath(offset), self)
245
159
 
246
 
    def _remote_path(self, relpath):
247
 
        """Return the path to be passed along the sftp protocol for relpath.
 
160
    def abspath(self, relpath):
 
161
        """
 
162
        Return the full url to the given relative path.
248
163
        
249
 
        relpath is a urlencoded string.
250
 
 
251
 
        :return: a path prefixed with / for regular abspath-based urls, or a
252
 
            path that does not begin with / for urls which begin with /~/.
 
164
        @param relpath: the relative path or path components
 
165
        @type relpath: str or list
253
166
        """
254
 
        # how does this work? 
255
 
        # it processes relpath with respect to 
256
 
        # our state:
257
 
        # firstly we create a path to evaluate: 
258
 
        # if relpath is an abspath or homedir path, its the entire thing
259
 
        # otherwise we join our base with relpath
260
 
        # then we eliminate all empty segments (double //'s) outside the first
261
 
        # two elements of the list. This avoids problems with trailing 
262
 
        # slashes, or other abnormalities.
263
 
        # finally we evaluate the entire path in a single pass
264
 
        # '.'s are stripped,
265
 
        # '..' result in popping the left most already 
266
 
        # processed path (which can never be empty because of the check for
267
 
        # abspath and homedir meaning that its not, or that we've used our
268
 
        # path. If the pop would pop the root, we ignore it.
269
 
 
270
 
        # Specific case examinations:
271
 
        # remove the special casefor ~: if the current root is ~/ popping of it
272
 
        # = / thus our seed for a ~ based path is ['', '~']
273
 
        # and if we end up with [''] then we had basically ('', '..') (which is
274
 
        # '/..' so we append '' if the length is one, and assert that the first
275
 
        # element is still ''. Lastly, if we end with ['', '~'] as a prefix for
276
 
        # the output, we've got a homedir path, so we strip that prefix before
277
 
        # '/' joining the resulting list.
278
 
        #
279
 
        # case one: '/' -> ['', ''] cannot shrink
280
 
        # case two: '/' + '../foo' -> ['', 'foo'] (take '', '', '..', 'foo')
281
 
        #           and pop the second '' for the '..', append 'foo'
282
 
        # case three: '/~/' -> ['', '~', ''] 
283
 
        # case four: '/~/' + '../foo' -> ['', '~', '', '..', 'foo'],
284
 
        #           and we want to get '/foo' - the empty path in the middle
285
 
        #           needs to be stripped, then normal path manipulation will 
286
 
        #           work.
287
 
        # case five: '/..' ['', '..'], we want ['', '']
288
 
        #            stripping '' outside the first two is ok
289
 
        #            ignore .. if its too high up
290
 
        #
291
 
        # lastly this code is possibly reusable by FTP, but not reusable by
292
 
        # local paths: ~ is resolvable correctly, nor by HTTP or the smart
293
 
        # server: ~ is resolved remotely.
294
 
        # 
295
 
        # however, a version of this that acts on self.base is possible to be
296
 
        # written which manipulates the URL in canonical form, and would be
297
 
        # reusable for all transports, if a flag for allowing ~/ at all was
298
 
        # provided.
 
167
        return self._unparse_url(self._abspath(relpath))
 
168
    
 
169
    def _abspath(self, relpath):
 
170
        """Return the absolute path segment without the SFTP URL."""
 
171
        # FIXME: share the common code across transports
299
172
        assert isinstance(relpath, basestring)
300
 
        relpath = urlutils.unescape(relpath)
301
 
 
302
 
        # case 1)
303
 
        if relpath.startswith('/'):
304
 
            # abspath - normal split is fine.
305
 
            current_path = relpath.split('/')
306
 
        elif relpath.startswith('~/'):
307
 
            # root is homedir based: normal split and prefix '' to remote the
308
 
            # special case
309
 
            current_path = [''].extend(relpath.split('/'))
310
 
        else:
311
 
            # root is from the current directory:
312
 
            if self._path.startswith('/'):
313
 
                # abspath, take the regular split
314
 
                current_path = []
315
 
            else:
316
 
                # homedir based, add the '', '~' not present in self._path
317
 
                current_path = ['', '~']
318
 
            # add our current dir
319
 
            current_path.extend(self._path.split('/'))
320
 
            # add the users relpath
321
 
            current_path.extend(relpath.split('/'))
322
 
        # strip '' segments that are not in the first one - the leading /.
323
 
        to_process = current_path[:1]
324
 
        for segment in current_path[1:]:
325
 
            if segment != '':
326
 
                to_process.append(segment)
327
 
 
328
 
        # process '.' and '..' segments into output_path.
329
 
        output_path = []
330
 
        for segment in to_process:
331
 
            if segment == '..':
332
 
                # directory pop. Remove a directory 
333
 
                # as long as we are not at the root
334
 
                if len(output_path) > 1:
335
 
                    output_path.pop()
336
 
                # else: pass
337
 
                # cannot pop beyond the root, so do nothing
338
 
            elif segment == '.':
339
 
                continue # strip the '.' from the output.
340
 
            else:
341
 
                # this will append '' to output_path for the root elements,
342
 
                # which is appropriate: its why we strip '' in the first pass.
343
 
                output_path.append(segment)
344
 
 
345
 
        # check output special cases:
346
 
        if output_path == ['']:
347
 
            # [''] -> ['', '']
348
 
            output_path = ['', '']
349
 
        elif output_path[:2] == ['', '~']:
350
 
            # ['', '~', ...] -> ...
351
 
            output_path = output_path[2:]
352
 
        path = '/'.join(output_path)
 
173
        relpath = [urllib.unquote(relpath)]
 
174
        basepath = self._path.split('/')
 
175
        if len(basepath) > 0 and basepath[-1] == '':
 
176
            basepath = basepath[:-1]
 
177
 
 
178
        for p in relpath:
 
179
            if p == '..':
 
180
                if len(basepath) == 0:
 
181
                    # In most filesystems, a request for the parent
 
182
                    # of root, just returns root.
 
183
                    continue
 
184
                basepath.pop()
 
185
            elif p == '.':
 
186
                continue # No-op
 
187
            else:
 
188
                basepath.append(p)
 
189
 
 
190
        path = '/'.join(basepath)
 
191
        # could still be a "relative" path here, but relative on the sftp server
353
192
        return path
354
193
 
355
194
    def relpath(self, abspath):
356
 
        scheme, username, password, host, port, path = self._split_url(abspath)
357
 
        error = []
358
 
        if (username != self._username):
359
 
            error.append('username mismatch')
360
 
        if (host != self._host):
361
 
            error.append('host mismatch')
362
 
        if (port != self._port):
363
 
            error.append('port mismatch')
364
 
        if (not path.startswith(self._path)):
365
 
            error.append('path mismatch')
366
 
        if error:
367
 
            extra = ': ' + ', '.join(error)
368
 
            raise PathNotChild(abspath, self.base, extra=extra)
369
 
        pl = len(self._path)
370
 
        return path[pl:].strip('/')
 
195
        # FIXME: this is identical to HttpTransport -- share it
 
196
        m = self._url_matcher.match(abspath)
 
197
        path = m.group(5)
 
198
        if not path.startswith(self._path):
 
199
            raise NonRelativePath('path %r is not under base URL %r'
 
200
                           % (abspath, self.base))
 
201
        pl = len(self.base)
 
202
        return abspath[pl:].lstrip('/')
371
203
 
372
204
    def has(self, relpath):
373
205
        """
374
206
        Does the target location exist?
375
207
        """
376
208
        try:
377
 
            self._sftp.stat(self._remote_path(relpath))
 
209
            self._sftp.stat(self._abspath(relpath))
378
210
            return True
379
211
        except IOError:
380
212
            return False
381
213
 
382
 
    def get(self, relpath):
 
214
    def get(self, relpath, decode=False):
383
215
        """
384
216
        Get the file at the given relative path.
385
217
 
386
218
        :param relpath: The relative path to the file
387
219
        """
388
220
        try:
389
 
            path = self._remote_path(relpath)
390
 
            f = self._sftp.file(path, mode='rb')
391
 
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
 
221
            path = self._abspath(relpath)
 
222
            f = self._sftp.file(path)
 
223
            try:
392
224
                f.prefetch()
 
225
            except AttributeError:
 
226
                # only works on paramiko 1.5.1 or greater
 
227
                pass
393
228
            return f
394
 
        except (IOError, paramiko.SSHException), e:
395
 
            self._translate_io_exception(e, path, ': error retrieving')
396
 
 
397
 
    def readv(self, relpath, offsets):
398
 
        """See Transport.readv()"""
399
 
        # We overload the default readv() because we want to use a file
400
 
        # that does not have prefetch enabled.
401
 
        # Also, if we have a new paramiko, it implements an async readv()
402
 
        if not offsets:
403
 
            return
404
 
 
 
229
        except (IOError, paramiko.SSHException), x:
 
230
            raise NoSuchFile('Error retrieving %s: %s' % (path, str(x)), x)
 
231
 
 
232
    def get_partial(self, relpath, start, length=None):
 
233
        """
 
234
        Get just part of a file.
 
235
 
 
236
        :param relpath: Path to the file, relative to base
 
237
        :param start: The starting position to read from
 
238
        :param length: The length to read. A length of None indicates
 
239
                       read to the end of the file.
 
240
        :return: A file-like object containing at least the specified bytes.
 
241
                 Some implementations may return objects which can be read
 
242
                 past this length, but this is not guaranteed.
 
243
        """
 
244
        # TODO: implement get_partial_multi to help with knit support
 
245
        f = self.get(relpath)
 
246
        f.seek(start)
405
247
        try:
406
 
            path = self._remote_path(relpath)
407
 
            fp = self._sftp.file(path, mode='rb')
408
 
            readv = getattr(fp, 'readv', None)
409
 
            if readv:
410
 
                return self._sftp_readv(fp, offsets, relpath)
411
 
            mutter('seek and read %s offsets', len(offsets))
412
 
            return self._seek_and_read(fp, offsets, relpath)
413
 
        except (IOError, paramiko.SSHException), e:
414
 
            self._translate_io_exception(e, path, ': error retrieving')
415
 
 
416
 
    def _sftp_readv(self, fp, offsets, relpath='<unknown>'):
417
 
        """Use the readv() member of fp to do async readv.
418
 
 
419
 
        And then read them using paramiko.readv(). paramiko.readv()
420
 
        does not support ranges > 64K, so it caps the request size, and
421
 
        just reads until it gets all the stuff it wants
422
 
        """
423
 
        offsets = list(offsets)
424
 
        sorted_offsets = sorted(offsets)
425
 
 
426
 
        # The algorithm works as follows:
427
 
        # 1) Coalesce nearby reads into a single chunk
428
 
        #    This generates a list of combined regions, the total size
429
 
        #    and the size of the sub regions. This coalescing step is limited
430
 
        #    in the number of nearby chunks to combine, and is allowed to
431
 
        #    skip small breaks in the requests. Limiting it makes sure that
432
 
        #    we can start yielding some data earlier, and skipping means we
433
 
        #    make fewer requests. (Beneficial even when using async)
434
 
        # 2) Break up this combined regions into chunks that are smaller
435
 
        #    than 64KiB. Technically the limit is 65536, but we are a
436
 
        #    little bit conservative. This is because sftp has a maximum
437
 
        #    return chunk size of 64KiB (max size of an unsigned short)
438
 
        # 3) Issue a readv() to paramiko to create an async request for
439
 
        #    all of this data
440
 
        # 4) Read in the data as it comes back, until we've read one
441
 
        #    continuous section as determined in step 1
442
 
        # 5) Break up the full sections into hunks for the original requested
443
 
        #    offsets. And put them in a cache
444
 
        # 6) Check if the next request is in the cache, and if it is, remove
445
 
        #    it from the cache, and yield its data. Continue until no more
446
 
        #    entries are in the cache.
447
 
        # 7) loop back to step 4 until all data has been read
448
 
        #
449
 
        # TODO: jam 20060725 This could be optimized one step further, by
450
 
        #       attempting to yield whatever data we have read, even before
451
 
        #       the first coallesced section has been fully processed.
452
 
 
453
 
        # When coalescing for use with readv(), we don't really need to
454
 
        # use any fudge factor, because the requests are made asynchronously
455
 
        coalesced = list(self._coalesce_offsets(sorted_offsets,
456
 
                               limit=self._max_readv_combine,
457
 
                               fudge_factor=0,
458
 
                               ))
459
 
        requests = []
460
 
        for c_offset in coalesced:
461
 
            start = c_offset.start
462
 
            size = c_offset.length
463
 
 
464
 
            # We need to break this up into multiple requests
465
 
            while size > 0:
466
 
                next_size = min(size, self._max_request_size)
467
 
                requests.append((start, next_size))
468
 
                size -= next_size
469
 
                start += next_size
470
 
 
471
 
        mutter('SFTP.readv() %s offsets => %s coalesced => %s requests',
472
 
                len(offsets), len(coalesced), len(requests))
473
 
 
474
 
        # Queue the current read until we have read the full coalesced section
475
 
        cur_data = []
476
 
        cur_data_len = 0
477
 
        cur_coalesced_stack = iter(coalesced)
478
 
        cur_coalesced = cur_coalesced_stack.next()
479
 
 
480
 
        # Cache the results, but only until they have been fulfilled
481
 
        data_map = {}
482
 
        # turn the list of offsets into a stack
483
 
        offset_stack = iter(offsets)
484
 
        cur_offset_and_size = offset_stack.next()
485
 
 
486
 
        for data in fp.readv(requests):
487
 
            cur_data += data
488
 
            cur_data_len += len(data)
489
 
 
490
 
            if cur_data_len < cur_coalesced.length:
491
 
                continue
492
 
            assert cur_data_len == cur_coalesced.length, \
493
 
                "Somehow we read too much: %s != %s" % (cur_data_len,
494
 
                                                        cur_coalesced.length)
495
 
            all_data = ''.join(cur_data)
496
 
            cur_data = []
497
 
            cur_data_len = 0
498
 
 
499
 
            for suboffset, subsize in cur_coalesced.ranges:
500
 
                key = (cur_coalesced.start+suboffset, subsize)
501
 
                data_map[key] = all_data[suboffset:suboffset+subsize]
502
 
 
503
 
            # Now that we've read some data, see if we can yield anything back
504
 
            while cur_offset_and_size in data_map:
505
 
                this_data = data_map.pop(cur_offset_and_size)
506
 
                yield cur_offset_and_size[0], this_data
507
 
                cur_offset_and_size = offset_stack.next()
508
 
 
509
 
            # We read a coalesced entry, so mark it as done
510
 
            cur_coalesced = None
511
 
            # Now that we've read all of the data for this coalesced section
512
 
            # on to the next
513
 
            cur_coalesced = cur_coalesced_stack.next()
514
 
 
515
 
        if cur_coalesced is not None:
516
 
            raise errors.ShortReadvError(relpath, cur_coalesced.start,
517
 
                cur_coalesced.length, len(data))
518
 
 
519
 
    def put_file(self, relpath, f, mode=None):
520
 
        """
521
 
        Copy the file-like object into the location.
 
248
            f.prefetch()
 
249
        except AttributeError:
 
250
            # only works on paramiko 1.5.1 or greater
 
251
            pass
 
252
        return f
 
253
 
 
254
    def put(self, relpath, f):
 
255
        """
 
256
        Copy the file-like or string object into the location.
522
257
 
523
258
        :param relpath: Location to put the contents, relative to base.
524
 
        :param f:       File-like object.
525
 
        :param mode: The final mode for the file
 
259
        :param f:       File-like or string object.
526
260
        """
527
 
        final_path = self._remote_path(relpath)
528
 
        self._put(final_path, f, mode=mode)
529
 
 
530
 
    def _put(self, abspath, f, mode=None):
531
 
        """Helper function so both put() and copy_abspaths can reuse the code"""
532
 
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
 
261
        final_path = self._abspath(relpath)
 
262
        tmp_relpath = '%s.tmp.%.9f.%d.%d' % (relpath, time.time(),
533
263
                        os.getpid(), random.randint(0,0x7FFFFFFF))
534
 
        fout = self._sftp_open_exclusive(tmp_abspath, mode=mode)
535
 
        closed = False
 
264
        tmp_abspath = self._abspath(tmp_relpath)
 
265
        fout = self._sftp_open_exclusive(tmp_relpath)
 
266
 
536
267
        try:
537
268
            try:
538
 
                fout.set_pipelined(True)
539
269
                self._pump(f, fout)
540
 
            except (IOError, paramiko.SSHException), e:
541
 
                self._translate_io_exception(e, tmp_abspath)
542
 
            # XXX: This doesn't truly help like we would like it to.
543
 
            #      The problem is that openssh strips sticky bits. So while we
544
 
            #      can properly set group write permission, we lose the group
545
 
            #      sticky bit. So it is probably best to stop chmodding, and
546
 
            #      just tell users that they need to set the umask correctly.
547
 
            #      The attr.st_mode = mode, in _sftp_open_exclusive
548
 
            #      will handle when the user wants the final mode to be more 
549
 
            #      restrictive. And then we avoid a round trip. Unless 
550
 
            #      paramiko decides to expose an async chmod()
551
 
 
552
 
            # This is designed to chmod() right before we close.
553
 
            # Because we set_pipelined() earlier, theoretically we might 
554
 
            # avoid the round trip for fout.close()
555
 
            if mode is not None:
556
 
                self._sftp.chmod(tmp_abspath, mode)
557
 
            fout.close()
558
 
            closed = True
559
 
            self._rename_and_overwrite(tmp_abspath, abspath)
 
270
            except IOError, e:
 
271
                self._translate_io_exception(e, relpath)
 
272
            except paramiko.SSHException, x:
 
273
                raise SFTPTransportError('Unable to write file %r' % (path,), x)
560
274
        except Exception, e:
561
275
            # If we fail, try to clean up the temporary file
562
276
            # before we throw the exception
563
277
            # but don't let another exception mess things up
564
 
            # Write out the traceback, because otherwise
565
 
            # the catch and throw destroys it
566
 
            import traceback
567
 
            mutter(traceback.format_exc())
568
278
            try:
569
 
                if not closed:
570
 
                    fout.close()
 
279
                fout.close()
571
280
                self._sftp.remove(tmp_abspath)
572
281
            except:
573
 
                # raise the saved except
574
 
                raise e
575
 
            # raise the original with its traceback if we can.
576
 
            raise
577
 
 
578
 
    def _put_non_atomic_helper(self, relpath, writer, mode=None,
579
 
                               create_parent_dir=False,
580
 
                               dir_mode=None):
581
 
        abspath = self._remote_path(relpath)
582
 
 
583
 
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
584
 
        #       set the file mode at create time. If it does, use it.
585
 
        #       But for now, we just chmod later anyway.
586
 
 
587
 
        def _open_and_write_file():
588
 
            """Try to open the target file, raise error on failure"""
589
 
            fout = None
590
 
            try:
591
 
                try:
592
 
                    fout = self._sftp.file(abspath, mode='wb')
593
 
                    fout.set_pipelined(True)
594
 
                    writer(fout)
595
 
                except (paramiko.SSHException, IOError), e:
596
 
                    self._translate_io_exception(e, abspath,
597
 
                                                 ': unable to open')
598
 
 
599
 
                # This is designed to chmod() right before we close.
600
 
                # Because we set_pipelined() earlier, theoretically we might 
601
 
                # avoid the round trip for fout.close()
602
 
                if mode is not None:
603
 
                    self._sftp.chmod(abspath, mode)
604
 
            finally:
605
 
                if fout is not None:
606
 
                    fout.close()
607
 
 
608
 
        if not create_parent_dir:
609
 
            _open_and_write_file()
610
 
            return
611
 
 
612
 
        # Try error handling to create the parent directory if we need to
613
 
        try:
614
 
            _open_and_write_file()
615
 
        except NoSuchFile:
616
 
            # Try to create the parent directory, and then go back to
617
 
            # writing the file
618
 
            parent_dir = os.path.dirname(abspath)
619
 
            self._mkdir(parent_dir, dir_mode)
620
 
            _open_and_write_file()
621
 
 
622
 
    def put_file_non_atomic(self, relpath, f, mode=None,
623
 
                            create_parent_dir=False,
624
 
                            dir_mode=None):
625
 
        """Copy the file-like object into the target location.
626
 
 
627
 
        This function is not strictly safe to use. It is only meant to
628
 
        be used when you already know that the target does not exist.
629
 
        It is not safe, because it will open and truncate the remote
630
 
        file. So there may be a time when the file has invalid contents.
631
 
 
632
 
        :param relpath: The remote location to put the contents.
633
 
        :param f:       File-like object.
634
 
        :param mode:    Possible access permissions for new file.
635
 
                        None means do not set remote permissions.
636
 
        :param create_parent_dir: If we cannot create the target file because
637
 
                        the parent directory does not exist, go ahead and
638
 
                        create it, and then try again.
639
 
        """
640
 
        def writer(fout):
641
 
            self._pump(f, fout)
642
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
643
 
                                    create_parent_dir=create_parent_dir,
644
 
                                    dir_mode=dir_mode)
645
 
 
646
 
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
647
 
                             create_parent_dir=False,
648
 
                             dir_mode=None):
649
 
        def writer(fout):
650
 
            fout.write(bytes)
651
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
652
 
                                    create_parent_dir=create_parent_dir,
653
 
                                    dir_mode=dir_mode)
 
282
                pass
 
283
            raise e
 
284
        else:
 
285
            # sftp rename doesn't allow overwriting, so play tricks:
 
286
            tmp_safety = 'bzr.tmp.%.9f.%d.%d' % (time.time(), os.getpid(), random.randint(0, 0x7FFFFFFF))
 
287
            tmp_safety = self._abspath(tmp_safety)
 
288
            try:
 
289
                self._sftp.rename(final_path, tmp_safety)
 
290
                file_existed = True
 
291
            except:
 
292
                file_existed = False
 
293
            try:
 
294
                self._sftp.rename(tmp_abspath, final_path)
 
295
            except IOError, e:
 
296
                self._translate_io_exception(e, relpath)
 
297
            except paramiko.SSHException, x:
 
298
                raise SFTPTransportError('Unable to rename into file %r' 
 
299
                                          % (path,), x)
 
300
            if file_existed:
 
301
                self._sftp.unlink(tmp_safety)
654
302
 
655
303
    def iter_files_recursive(self):
656
304
        """Walk the relative paths of all files in this transport."""
657
305
        queue = list(self.list_dir('.'))
658
306
        while queue:
659
 
            relpath = queue.pop(0)
 
307
            relpath = urllib.quote(queue.pop(0))
660
308
            st = self.stat(relpath)
661
309
            if stat.S_ISDIR(st.st_mode):
662
310
                for i, basename in enumerate(self.list_dir(relpath)):
664
312
            else:
665
313
                yield relpath
666
314
 
667
 
    def _mkdir(self, abspath, mode=None):
668
 
        if mode is None:
669
 
            local_mode = 0777
670
 
        else:
671
 
            local_mode = mode
672
 
        try:
673
 
            self._sftp.mkdir(abspath, local_mode)
674
 
            if mode is not None:
675
 
                self._sftp.chmod(abspath, mode=mode)
676
 
        except (paramiko.SSHException, IOError), e:
677
 
            self._translate_io_exception(e, abspath, ': unable to mkdir',
678
 
                failure_exc=FileExists)
679
 
 
680
 
    def mkdir(self, relpath, mode=None):
 
315
    def mkdir(self, relpath):
681
316
        """Create a directory at the given path."""
682
 
        self._mkdir(self._remote_path(relpath), mode=mode)
683
 
 
684
 
    def _translate_io_exception(self, e, path, more_info='', 
685
 
                                failure_exc=PathError):
686
 
        """Translate a paramiko or IOError into a friendlier exception.
687
 
 
688
 
        :param e: The original exception
689
 
        :param path: The path in question when the error is raised
690
 
        :param more_info: Extra information that can be included,
691
 
                          such as what was going on
692
 
        :param failure_exc: Paramiko has the super fun ability to raise completely
693
 
                           opaque errors that just set "e.args = ('Failure',)" with
694
 
                           no more information.
695
 
                           If this parameter is set, it defines the exception 
696
 
                           to raise in these cases.
697
 
        """
 
317
        try:
 
318
            path = self._abspath(relpath)
 
319
            self._sftp.mkdir(path)
 
320
        except IOError, e:
 
321
            self._translate_io_exception(e, relpath)
 
322
        except (IOError, paramiko.SSHException), x:
 
323
            raise SFTPTransportError('Unable to mkdir %r' % (path,), x)
 
324
 
 
325
    def _translate_io_exception(self, e, relpath):
698
326
        # paramiko seems to generate detailless errors.
699
 
        self._translate_error(e, path, raise_generic=False)
700
 
        if getattr(e, 'args', None) is not None:
701
 
            if (e.args == ('No such file or directory',) or
702
 
                e.args == ('No such file',)):
703
 
                raise NoSuchFile(path, str(e) + more_info)
704
 
            if (e.args == ('mkdir failed',)):
705
 
                raise FileExists(path, str(e) + more_info)
706
 
            # strange but true, for the paramiko server.
707
 
            if (e.args == ('Failure',)):
708
 
                raise failure_exc(path, str(e) + more_info)
709
 
            mutter('Raising exception with args %s', e.args)
710
 
        if getattr(e, 'errno', None) is not None:
711
 
            mutter('Raising exception with errno %s', e.errno)
712
 
        raise e
 
327
        if (e.errno == errno.ENOENT or
 
328
            e.args == ('No such file or directory',) or
 
329
            e.args == ('No such file',)):
 
330
            raise NoSuchFile(relpath)
 
331
        if (e.args == ('mkdir failed',)):
 
332
            raise FileExists(relpath)
 
333
        # strange but true, for the paramiko server.
 
334
        if (e.args == ('Failure',)):
 
335
            raise FileExists(relpath)
 
336
        raise
713
337
 
714
 
    def append_file(self, relpath, f, mode=None):
 
338
    def append(self, relpath, f):
715
339
        """
716
340
        Append the text in the file-like object into the final
717
341
        location.
718
342
        """
719
343
        try:
720
 
            path = self._remote_path(relpath)
 
344
            path = self._abspath(relpath)
721
345
            fout = self._sftp.file(path, 'ab')
722
 
            if mode is not None:
723
 
                self._sftp.chmod(path, mode)
724
 
            result = fout.tell()
725
346
            self._pump(f, fout)
726
 
            return result
727
 
        except (IOError, paramiko.SSHException), e:
728
 
            self._translate_io_exception(e, relpath, ': unable to append')
729
 
 
730
 
    def rename(self, rel_from, rel_to):
731
 
        """Rename without special overwriting"""
732
 
        try:
733
 
            self._sftp.rename(self._remote_path(rel_from),
734
 
                              self._remote_path(rel_to))
735
 
        except (IOError, paramiko.SSHException), e:
736
 
            self._translate_io_exception(e, rel_from,
737
 
                    ': unable to rename to %r' % (rel_to))
738
 
 
739
 
    def _rename_and_overwrite(self, abs_from, abs_to):
740
 
        """Do a fancy rename on the remote server.
741
 
        
742
 
        Using the implementation provided by osutils.
743
 
        """
744
 
        try:
745
 
            fancy_rename(abs_from, abs_to,
746
 
                    rename_func=self._sftp.rename,
747
 
                    unlink_func=self._sftp.remove)
748
 
        except (IOError, paramiko.SSHException), e:
749
 
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
 
347
        except (IOError, paramiko.SSHException), x:
 
348
            raise SFTPTransportError('Unable to append file %r' % (path,), x)
 
349
 
 
350
    def copy(self, rel_from, rel_to):
 
351
        """Copy the item at rel_from to the location at rel_to"""
 
352
        path_from = self._abspath(rel_from)
 
353
        path_to = self._abspath(rel_to)
 
354
        try:
 
355
            fin = self._sftp.file(path_from, 'rb')
 
356
            try:
 
357
                fout = self._sftp.file(path_to, 'wb')
 
358
                try:
 
359
                    fout.set_pipelined(True)
 
360
                    self._pump(fin, fout)
 
361
                finally:
 
362
                    fout.close()
 
363
            finally:
 
364
                fin.close()
 
365
        except (IOError, paramiko.SSHException), x:
 
366
            raise SFTPTransportError('Unable to copy %r to %r' % (path_from, path_to), x)
750
367
 
751
368
    def move(self, rel_from, rel_to):
752
369
        """Move the item at rel_from to the location at rel_to"""
753
 
        path_from = self._remote_path(rel_from)
754
 
        path_to = self._remote_path(rel_to)
755
 
        self._rename_and_overwrite(path_from, path_to)
 
370
        path_from = self._abspath(rel_from)
 
371
        path_to = self._abspath(rel_to)
 
372
        try:
 
373
            self._sftp.rename(path_from, path_to)
 
374
        except (IOError, paramiko.SSHException), x:
 
375
            raise SFTPTransportError('Unable to move %r to %r' % (path_from, path_to), x)
756
376
 
757
377
    def delete(self, relpath):
758
378
        """Delete the item at relpath"""
759
 
        path = self._remote_path(relpath)
 
379
        path = self._abspath(relpath)
760
380
        try:
761
381
            self._sftp.remove(path)
762
 
        except (IOError, paramiko.SSHException), e:
763
 
            self._translate_io_exception(e, path, ': unable to delete')
 
382
        except (IOError, paramiko.SSHException), x:
 
383
            raise SFTPTransportError('Unable to delete %r' % (path,), x)
764
384
            
765
385
    def listable(self):
766
386
        """Return True if this store supports listing."""
771
391
        Return a list of all files at the given location.
772
392
        """
773
393
        # does anything actually use this?
774
 
        # -- Unknown
775
 
        # This is at least used by copy_tree for remote upgrades.
776
 
        # -- David Allouche 2006-08-11
777
 
        path = self._remote_path(relpath)
778
 
        try:
779
 
            entries = self._sftp.listdir(path)
780
 
        except (IOError, paramiko.SSHException), e:
781
 
            self._translate_io_exception(e, path, ': failed to list_dir')
782
 
        return [urlutils.escape(entry) for entry in entries]
783
 
 
784
 
    def rmdir(self, relpath):
785
 
        """See Transport.rmdir."""
786
 
        path = self._remote_path(relpath)
787
 
        try:
788
 
            return self._sftp.rmdir(path)
789
 
        except (IOError, paramiko.SSHException), e:
790
 
            self._translate_io_exception(e, path, ': failed to rmdir')
 
394
        path = self._abspath(relpath)
 
395
        try:
 
396
            return self._sftp.listdir(path)
 
397
        except (IOError, paramiko.SSHException), x:
 
398
            raise SFTPTransportError('Unable to list folder %r' % (path,), x)
791
399
 
792
400
    def stat(self, relpath):
793
401
        """Return the stat information for a file."""
794
 
        path = self._remote_path(relpath)
 
402
        path = self._abspath(relpath)
795
403
        try:
796
404
            return self._sftp.stat(path)
797
 
        except (IOError, paramiko.SSHException), e:
798
 
            self._translate_io_exception(e, path, ': unable to stat')
 
405
        except (IOError, paramiko.SSHException), x:
 
406
            raise SFTPTransportError('Unable to stat %r' % (path,), x)
799
407
 
800
408
    def lock_read(self, relpath):
801
409
        """
823
431
        # that we have taken the lock.
824
432
        return SFTPLock(relpath, self)
825
433
 
 
434
 
 
435
    def _unparse_url(self, path=None):
 
436
        if path is None:
 
437
            path = self._path
 
438
        host = self._host
 
439
        username = urllib.quote(self._username)
 
440
        if self._password:
 
441
            username += ':' + urllib.quote(self._password)
 
442
        if self._port != 22:
 
443
            host += ':%d' % self._port
 
444
        return 'sftp://%s@%s/%s' % (username, host, urllib.quote(path))
 
445
 
 
446
    def _parse_url(self, url):
 
447
        assert url[:7] == 'sftp://'
 
448
        m = self._url_matcher.match(url)
 
449
        if m is None:
 
450
            raise SFTPTransportError('Unable to parse SFTP URL %r' % (url,))
 
451
        self._username, self._password, self._host, self._port, self._path = m.groups()
 
452
        if self._username is None:
 
453
            self._username = getpass.getuser()
 
454
        else:
 
455
            if self._password:
 
456
                # username field is 'user:pass@' in this case, and password is ':pass'
 
457
                username_len = len(self._username) - len(self._password) - 1
 
458
                self._username = urllib.unquote(self._username[:username_len])
 
459
                self._password = urllib.unquote(self._password[1:])
 
460
            else:
 
461
                self._username = urllib.unquote(self._username[:-1])
 
462
        if self._port is None:
 
463
            self._port = 22
 
464
        else:
 
465
            self._port = int(self._port[1:])
 
466
        if (self._path is None) or (self._path == ''):
 
467
            self._path = ''
 
468
        else:
 
469
            # remove leading '/'
 
470
            self._path = urllib.unquote(self._path[1:])
 
471
 
826
472
    def _sftp_connect(self):
827
 
        """Connect to the remote sftp server.
828
 
        After this, self._sftp should have a valid connection (or
829
 
        we raise an TransportError 'could not connect').
830
 
 
831
 
        TODO: Raise a more reasonable ConnectionFailed exception
832
 
        """
833
 
        self._sftp = _sftp_connect(self._host, self._port, self._username,
834
 
                self._password)
835
 
 
836
 
    def _sftp_open_exclusive(self, abspath, mode=None):
 
473
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
474
        
 
475
        load_host_keys()
 
476
        
 
477
        try:
 
478
            t = paramiko.Transport((self._host, self._port))
 
479
            t.start_client()
 
480
        except paramiko.SSHException:
 
481
            raise SFTPTransportError('Unable to reach SSH host %s:%d' % (self._host, self._port))
 
482
            
 
483
        server_key = t.get_remote_server_key()
 
484
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
 
485
        keytype = server_key.get_name()
 
486
        if SYSTEM_HOSTKEYS.has_key(self._host) and SYSTEM_HOSTKEYS[self._host].has_key(keytype):
 
487
            our_server_key = SYSTEM_HOSTKEYS[self._host][keytype]
 
488
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
489
        elif BZR_HOSTKEYS.has_key(self._host) and BZR_HOSTKEYS[self._host].has_key(keytype):
 
490
            our_server_key = BZR_HOSTKEYS[self._host][keytype]
 
491
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
492
        else:
 
493
            warning('Adding %s host key for %s: %s' % (keytype, self._host, server_key_hex))
 
494
            if not BZR_HOSTKEYS.has_key(self._host):
 
495
                BZR_HOSTKEYS[self._host] = {}
 
496
            BZR_HOSTKEYS[self._host][keytype] = server_key
 
497
            our_server_key = server_key
 
498
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
499
            save_host_keys()
 
500
        if server_key != our_server_key:
 
501
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
 
502
            filename2 = os.path.join(config_dir(), 'ssh_host_keys')
 
503
            raise SFTPTransportError('Host keys for %s do not match!  %s != %s' % \
 
504
                (self._host, our_server_key_hex, server_key_hex),
 
505
                ['Try editing %s or %s' % (filename1, filename2)])
 
506
 
 
507
        self._sftp_auth(t, self._username, self._host)
 
508
        
 
509
        try:
 
510
            self._sftp = t.open_sftp_client()
 
511
        except paramiko.SSHException:
 
512
            raise BzrError('Unable to find path %s on SFTP server %s' % \
 
513
                (self._path, self._host))
 
514
 
 
515
    def _sftp_auth(self, transport, username, host):
 
516
        agent = paramiko.Agent()
 
517
        for key in agent.get_keys():
 
518
            mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
 
519
            try:
 
520
                transport.auth_publickey(self._username, key)
 
521
                return
 
522
            except paramiko.SSHException, e:
 
523
                pass
 
524
        
 
525
        # okay, try finding id_rsa or id_dss?  (posix only)
 
526
        if self._try_pkey_auth(transport, paramiko.RSAKey, 'id_rsa'):
 
527
            return
 
528
        if self._try_pkey_auth(transport, paramiko.DSSKey, 'id_dsa'):
 
529
            return
 
530
 
 
531
        if self._password:
 
532
            try:
 
533
                transport.auth_password(self._username, self._password)
 
534
                return
 
535
            except paramiko.SSHException, e:
 
536
                pass
 
537
 
 
538
        # give up and ask for a password
 
539
        # FIXME: shouldn't be implementing UI this deep into bzrlib
 
540
        enc = sys.stdout.encoding
 
541
        password = getpass.getpass('SSH %s@%s password: ' %
 
542
            (self._username.encode(enc, 'replace'), self._host.encode(enc, 'replace')))
 
543
        try:
 
544
            transport.auth_password(self._username, password)
 
545
        except paramiko.SSHException:
 
546
            raise SFTPTransportError('Unable to authenticate to SSH host as %s@%s' % \
 
547
                (self._username, self._host))
 
548
 
 
549
    def _try_pkey_auth(self, transport, pkey_class, filename):
 
550
        filename = os.path.expanduser('~/.ssh/' + filename)
 
551
        try:
 
552
            key = pkey_class.from_private_key_file(filename)
 
553
            transport.auth_publickey(self._username, key)
 
554
            return True
 
555
        except paramiko.PasswordRequiredException:
 
556
            # FIXME: shouldn't be implementing UI this deep into bzrlib
 
557
            enc = sys.stdout.encoding
 
558
            password = getpass.getpass('SSH %s password: ' % 
 
559
                (os.path.basename(filename).encode(enc, 'replace'),))
 
560
            try:
 
561
                key = pkey_class.from_private_key_file(filename, password)
 
562
                transport.auth_publickey(self._username, key)
 
563
                return True
 
564
            except paramiko.SSHException:
 
565
                mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
 
566
        except paramiko.SSHException:
 
567
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
 
568
        except IOError:
 
569
            pass
 
570
        return False
 
571
 
 
572
    def _sftp_open_exclusive(self, relpath):
837
573
        """Open a remote path exclusively.
838
574
 
839
575
        SFTP supports O_EXCL (SFTP_FLAG_EXCL), which fails if
844
580
        WARNING: This breaks the SFTPClient abstraction, so it
845
581
        could easily break against an updated version of paramiko.
846
582
 
847
 
        :param abspath: The remote absolute path where the file should be opened
848
 
        :param mode: The mode permissions bits for the new file
 
583
        :param relpath: The relative path, where the file should be opened
849
584
        """
850
 
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
851
 
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
852
 
        #       However, there is no way to set the permission mode at open 
853
 
        #       time using the sftp_client.file() functionality.
854
 
        path = self._sftp._adjust_cwd(abspath)
855
 
        # mutter('sftp abspath %s => %s', abspath, path)
 
585
        path = self._abspath(relpath)
856
586
        attr = SFTPAttributes()
857
 
        if mode is not None:
858
 
            attr.st_mode = mode
859
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
 
587
        mode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
860
588
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
861
589
        try:
862
 
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
 
590
            t, msg = self._sftp._request(CMD_OPEN, path, mode, attr)
863
591
            if t != CMD_HANDLE:
864
 
                raise TransportError('Expected an SFTP handle')
 
592
                raise SFTPTransportError('Expected an SFTP handle')
865
593
            handle = msg.get_string()
866
 
            return SFTPFile(self._sftp, handle, 'wb', -1)
867
 
        except (paramiko.SSHException, IOError), e:
868
 
            self._translate_io_exception(e, abspath, ': unable to open',
869
 
                failure_exc=FileExists)
870
 
 
871
 
    def _can_roundtrip_unix_modebits(self):
872
 
        if sys.platform == 'win32':
873
 
            # anyone else?
874
 
            return False
875
 
        else:
876
 
            return True
877
 
 
878
 
# ------------- server test implementation --------------
879
 
import threading
880
 
 
881
 
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
882
 
 
883
 
STUB_SERVER_KEY = """
884
 
-----BEGIN RSA PRIVATE KEY-----
885
 
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
886
 
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
887
 
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
888
 
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
889
 
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
890
 
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
891
 
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
892
 
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
893
 
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
894
 
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
895
 
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
896
 
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
897
 
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
898
 
-----END RSA PRIVATE KEY-----
899
 
"""
900
 
 
901
 
 
902
 
class SocketListener(threading.Thread):
903
 
 
904
 
    def __init__(self, callback):
905
 
        threading.Thread.__init__(self)
906
 
        self._callback = callback
907
 
        self._socket = socket.socket()
908
 
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
909
 
        self._socket.bind(('localhost', 0))
910
 
        self._socket.listen(1)
911
 
        self.port = self._socket.getsockname()[1]
912
 
        self._stop_event = threading.Event()
913
 
 
914
 
    def stop(self):
915
 
        # called from outside this thread
916
 
        self._stop_event.set()
917
 
        # use a timeout here, because if the test fails, the server thread may
918
 
        # never notice the stop_event.
919
 
        self.join(5.0)
920
 
        self._socket.close()
921
 
 
922
 
    def run(self):
923
 
        while True:
924
 
            readable, writable_unused, exception_unused = \
925
 
                select.select([self._socket], [], [], 0.1)
926
 
            if self._stop_event.isSet():
927
 
                return
928
 
            if len(readable) == 0:
929
 
                continue
930
 
            try:
931
 
                s, addr_unused = self._socket.accept()
932
 
                # because the loopback socket is inline, and transports are
933
 
                # never explicitly closed, best to launch a new thread.
934
 
                threading.Thread(target=self._callback, args=(s,)).start()
935
 
            except socket.error, x:
936
 
                sys.excepthook(*sys.exc_info())
937
 
                warning('Socket error during accept() within unit test server'
938
 
                        ' thread: %r' % x)
939
 
            except Exception, x:
940
 
                # probably a failed test; unit test thread will log the
941
 
                # failure/error
942
 
                sys.excepthook(*sys.exc_info())
943
 
                warning('Exception from within unit test server thread: %r' % 
944
 
                        x)
945
 
 
946
 
 
947
 
class SocketDelay(object):
948
 
    """A socket decorator to make TCP appear slower.
949
 
 
950
 
    This changes recv, send, and sendall to add a fixed latency to each python
951
 
    call if a new roundtrip is detected. That is, when a recv is called and the
952
 
    flag new_roundtrip is set, latency is charged. Every send and send_all
953
 
    sets this flag.
954
 
 
955
 
    In addition every send, sendall and recv sleeps a bit per character send to
956
 
    simulate bandwidth.
957
 
 
958
 
    Not all methods are implemented, this is deliberate as this class is not a
959
 
    replacement for the builtin sockets layer. fileno is not implemented to
960
 
    prevent the proxy being bypassed. 
961
 
    """
962
 
 
963
 
    simulated_time = 0
964
 
    _proxied_arguments = dict.fromkeys([
965
 
        "close", "getpeername", "getsockname", "getsockopt", "gettimeout",
966
 
        "setblocking", "setsockopt", "settimeout", "shutdown"])
967
 
 
968
 
    def __init__(self, sock, latency, bandwidth=1.0, 
969
 
                 really_sleep=True):
970
 
        """ 
971
 
        :param bandwith: simulated bandwith (MegaBit)
972
 
        :param really_sleep: If set to false, the SocketDelay will just
973
 
        increase a counter, instead of calling time.sleep. This is useful for
974
 
        unittesting the SocketDelay.
975
 
        """
976
 
        self.sock = sock
977
 
        self.latency = latency
978
 
        self.really_sleep = really_sleep
979
 
        self.time_per_byte = 1 / (bandwidth / 8.0 * 1024 * 1024) 
980
 
        self.new_roundtrip = False
981
 
 
982
 
    def sleep(self, s):
983
 
        if self.really_sleep:
984
 
            time.sleep(s)
985
 
        else:
986
 
            SocketDelay.simulated_time += s
987
 
 
988
 
    def __getattr__(self, attr):
989
 
        if attr in SocketDelay._proxied_arguments:
990
 
            return getattr(self.sock, attr)
991
 
        raise AttributeError("'SocketDelay' object has no attribute %r" %
992
 
                             attr)
993
 
 
994
 
    def dup(self):
995
 
        return SocketDelay(self.sock.dup(), self.latency, self.time_per_byte,
996
 
                           self._sleep)
997
 
 
998
 
    def recv(self, *args):
999
 
        data = self.sock.recv(*args)
1000
 
        if data and self.new_roundtrip:
1001
 
            self.new_roundtrip = False
1002
 
            self.sleep(self.latency)
1003
 
        self.sleep(len(data) * self.time_per_byte)
1004
 
        return data
1005
 
 
1006
 
    def sendall(self, data, flags=0):
1007
 
        if not self.new_roundtrip:
1008
 
            self.new_roundtrip = True
1009
 
            self.sleep(self.latency)
1010
 
        self.sleep(len(data) * self.time_per_byte)
1011
 
        return self.sock.sendall(data, flags)
1012
 
 
1013
 
    def send(self, data, flags=0):
1014
 
        if not self.new_roundtrip:
1015
 
            self.new_roundtrip = True
1016
 
            self.sleep(self.latency)
1017
 
        bytes_sent = self.sock.send(data, flags)
1018
 
        self.sleep(bytes_sent * self.time_per_byte)
1019
 
        return bytes_sent
1020
 
 
1021
 
 
1022
 
class SFTPServer(Server):
1023
 
    """Common code for SFTP server facilities."""
1024
 
 
1025
 
    def __init__(self, server_interface=StubServer):
1026
 
        self._original_vendor = None
1027
 
        self._homedir = None
1028
 
        self._server_homedir = None
1029
 
        self._listener = None
1030
 
        self._root = None
1031
 
        self._vendor = ssh.ParamikoVendor()
1032
 
        self._server_interface = server_interface
1033
 
        # sftp server logs
1034
 
        self.logs = []
1035
 
        self.add_latency = 0
1036
 
 
1037
 
    def _get_sftp_url(self, path):
1038
 
        """Calculate an sftp url to this server for path."""
1039
 
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
1040
 
 
1041
 
    def log(self, message):
1042
 
        """StubServer uses this to log when a new server is created."""
1043
 
        self.logs.append(message)
1044
 
 
1045
 
    def _run_server_entry(self, sock):
1046
 
        """Entry point for all implementations of _run_server.
1047
 
        
1048
 
        If self.add_latency is > 0.000001 then sock is given a latency adding
1049
 
        decorator.
1050
 
        """
1051
 
        if self.add_latency > 0.000001:
1052
 
            sock = SocketDelay(sock, self.add_latency)
1053
 
        return self._run_server(sock)
1054
 
 
1055
 
    def _run_server(self, s):
1056
 
        ssh_server = paramiko.Transport(s)
1057
 
        key_file = pathjoin(self._homedir, 'test_rsa.key')
1058
 
        f = open(key_file, 'w')
1059
 
        f.write(STUB_SERVER_KEY)
1060
 
        f.close()
1061
 
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
1062
 
        ssh_server.add_server_key(host_key)
1063
 
        server = self._server_interface(self)
1064
 
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
1065
 
                                         StubSFTPServer, root=self._root,
1066
 
                                         home=self._server_homedir)
1067
 
        event = threading.Event()
1068
 
        ssh_server.start_server(event, server)
1069
 
        event.wait(5.0)
1070
 
    
1071
 
    def setUp(self):
1072
 
        self._original_vendor = ssh._ssh_vendor
1073
 
        ssh._ssh_vendor = self._vendor
1074
 
        if sys.platform == 'win32':
1075
 
            # Win32 needs to use the UNICODE api
1076
 
            self._homedir = getcwd()
1077
 
        else:
1078
 
            # But Linux SFTP servers should just deal in bytestreams
1079
 
            self._homedir = os.getcwd()
1080
 
        if self._server_homedir is None:
1081
 
            self._server_homedir = self._homedir
1082
 
        self._root = '/'
1083
 
        if sys.platform == 'win32':
1084
 
            self._root = ''
1085
 
        self._listener = SocketListener(self._run_server_entry)
1086
 
        self._listener.setDaemon(True)
1087
 
        self._listener.start()
1088
 
 
1089
 
    def tearDown(self):
1090
 
        """See bzrlib.transport.Server.tearDown."""
1091
 
        self._listener.stop()
1092
 
        ssh._ssh_vendor = self._original_vendor
1093
 
 
1094
 
    def get_bogus_url(self):
1095
 
        """See bzrlib.transport.Server.get_bogus_url."""
1096
 
        # this is chosen to try to prevent trouble with proxies, wierd dns, etc
1097
 
        # we bind a random socket, so that we get a guaranteed unused port
1098
 
        # we just never listen on that port
1099
 
        s = socket.socket()
1100
 
        s.bind(('localhost', 0))
1101
 
        return 'sftp://%s:%s/' % s.getsockname()
1102
 
 
1103
 
 
1104
 
class SFTPFullAbsoluteServer(SFTPServer):
1105
 
    """A test server for sftp transports, using absolute urls and ssh."""
1106
 
 
1107
 
    def get_url(self):
1108
 
        """See bzrlib.transport.Server.get_url."""
1109
 
        return self._get_sftp_url(urlutils.escape(self._homedir[1:]))
1110
 
 
1111
 
 
1112
 
class SFTPServerWithoutSSH(SFTPServer):
1113
 
    """An SFTP server that uses a simple TCP socket pair rather than SSH."""
1114
 
 
1115
 
    def __init__(self):
1116
 
        super(SFTPServerWithoutSSH, self).__init__()
1117
 
        self._vendor = ssh.LoopbackVendor()
1118
 
 
1119
 
    def _run_server(self, sock):
1120
 
        # Re-import these as locals, so that they're still accessible during
1121
 
        # interpreter shutdown (when all module globals get set to None, leading
1122
 
        # to confusing errors like "'NoneType' object has no attribute 'error'".
1123
 
        class FakeChannel(object):
1124
 
            def get_transport(self):
1125
 
                return self
1126
 
            def get_log_channel(self):
1127
 
                return 'paramiko'
1128
 
            def get_name(self):
1129
 
                return '1'
1130
 
            def get_hexdump(self):
1131
 
                return False
1132
 
            def close(self):
1133
 
                pass
1134
 
 
1135
 
        server = paramiko.SFTPServer(FakeChannel(), 'sftp', StubServer(self), StubSFTPServer,
1136
 
                                     root=self._root, home=self._server_homedir)
1137
 
        try:
1138
 
            server.start_subsystem('sftp', None, sock)
1139
 
        except socket.error, e:
1140
 
            if (len(e.args) > 0) and (e.args[0] == errno.EPIPE):
1141
 
                # it's okay for the client to disconnect abruptly
1142
 
                # (bug in paramiko 1.6: it should absorb this exception)
1143
 
                pass
1144
 
            else:
1145
 
                raise
1146
 
        except Exception, e:
1147
 
            import sys; sys.stderr.write('\nEXCEPTION %r\n\n' % e.__class__)
1148
 
        server.finish_subsystem()
1149
 
 
1150
 
 
1151
 
class SFTPAbsoluteServer(SFTPServerWithoutSSH):
1152
 
    """A test server for sftp transports, using absolute urls."""
1153
 
 
1154
 
    def get_url(self):
1155
 
        """See bzrlib.transport.Server.get_url."""
1156
 
        if sys.platform == 'win32':
1157
 
            return self._get_sftp_url(urlutils.escape(self._homedir))
1158
 
        else:
1159
 
            return self._get_sftp_url(urlutils.escape(self._homedir[1:]))
1160
 
 
1161
 
 
1162
 
class SFTPHomeDirServer(SFTPServerWithoutSSH):
1163
 
    """A test server for sftp transports, using homedir relative urls."""
1164
 
 
1165
 
    def get_url(self):
1166
 
        """See bzrlib.transport.Server.get_url."""
1167
 
        return self._get_sftp_url("~/")
1168
 
 
1169
 
 
1170
 
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
1171
 
    """A test servere for sftp transports, using absolute urls to non-home."""
1172
 
 
1173
 
    def setUp(self):
1174
 
        self._server_homedir = '/dev/noone/runs/tests/here'
1175
 
        super(SFTPSiblingAbsoluteServer, self).setUp()
1176
 
 
1177
 
 
1178
 
def _sftp_connect(host, port, username, password):
1179
 
    """Connect to the remote sftp server.
1180
 
 
1181
 
    :raises: a TransportError 'could not connect'.
1182
 
 
1183
 
    :returns: an paramiko.sftp_client.SFTPClient
1184
 
 
1185
 
    TODO: Raise a more reasonable ConnectionFailed exception
1186
 
    """
1187
 
    idx = (host, port, username)
1188
 
    try:
1189
 
        return _connected_hosts[idx]
1190
 
    except KeyError:
1191
 
        pass
1192
 
    
1193
 
    sftp = _sftp_connect_uncached(host, port, username, password)
1194
 
    _connected_hosts[idx] = sftp
1195
 
    return sftp
1196
 
 
1197
 
def _sftp_connect_uncached(host, port, username, password):
1198
 
    vendor = ssh._get_ssh_vendor()
1199
 
    sftp = vendor.connect_sftp(username, password, host, port)
1200
 
    return sftp
1201
 
 
1202
 
 
1203
 
def get_test_permutations():
1204
 
    """Return the permutations to be used in testing."""
1205
 
    return [(SFTPTransport, SFTPAbsoluteServer),
1206
 
            (SFTPTransport, SFTPHomeDirServer),
1207
 
            (SFTPTransport, SFTPSiblingAbsoluteServer),
1208
 
            ]
 
594
            return SFTPFile(self._sftp, handle, 'w', -1)
 
595
        except IOError, e:
 
596
            self._translate_io_exception(e, relpath)
 
597
        except paramiko.SSHException, x:
 
598
            raise SFTPTransportError('Unable to open file %r' % (path,), x)
 
599