~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-07-22 18:09:04 UTC
  • mfrom: (2485.8.63 bzr.connection.sharing)
  • Revision ID: pqm@pqm.ubuntu.com-20070722180904-wy7y7oyi32wbghgf
Transport connection sharing

Show diffs side-by-side

added added

removed removed

Lines of Context:
34
34
import time
35
35
import urllib
36
36
import urlparse
37
 
import weakref
38
37
 
39
38
from bzrlib import (
40
39
    errors,
48
47
                           ParamikoNotPresent,
49
48
                           )
50
49
from bzrlib.osutils import pathjoin, fancy_rename, getcwd
 
50
from bzrlib.symbol_versioning import (
 
51
        deprecated_function,
 
52
        zero_nineteen,
 
53
        )
51
54
from bzrlib.trace import mutter, warning
52
55
from bzrlib.transport import (
53
56
    local,
54
57
    register_urlparse_netloc_protocol,
55
58
    Server,
56
 
    split_url,
57
59
    ssh,
58
 
    Transport,
 
60
    ConnectedTransport,
59
61
    )
60
62
 
61
63
try:
73
75
register_urlparse_netloc_protocol('sftp')
74
76
 
75
77
 
76
 
# This is a weakref dictionary, so that we can reuse connections
77
 
# that are still active. Long term, it might be nice to have some
78
 
# sort of expiration policy, such as disconnect if inactive for
79
 
# X seconds. But that requires a lot more fanciness.
80
 
_connected_hosts = weakref.WeakValueDictionary()
81
 
 
82
 
 
83
78
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
84
79
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
85
80
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
86
81
 
87
82
 
 
83
@deprecated_function(zero_nineteen)
88
84
def clear_connection_cache():
89
85
    """Remove all hosts from the SFTP connection cache.
90
86
 
91
87
    Primarily useful for test cases wanting to force garbage collection.
 
88
    We don't have a global connection cache anymore.
92
89
    """
93
 
    _connected_hosts.clear()
94
 
 
95
90
 
96
91
class SFTPLock(object):
97
92
    """This fakes a lock in a remote location.
135
130
            pass
136
131
 
137
132
 
138
 
class SFTPUrlHandling(Transport):
139
 
    """Mix-in that does common handling of SSH/SFTP URLs."""
140
 
 
141
 
    def __init__(self, base):
142
 
        self._parse_url(base)
143
 
        base = self._unparse_url(self._path)
144
 
        if base[-1] != '/':
145
 
            base += '/'
146
 
        super(SFTPUrlHandling, self).__init__(base)
147
 
 
148
 
    def _parse_url(self, url):
149
 
        (self._scheme,
150
 
         self._username, self._password,
151
 
         self._host, self._port, self._path) = self._split_url(url)
152
 
 
153
 
    def _unparse_url(self, path):
154
 
        """Return a URL for a path relative to this transport.
155
 
        """
156
 
        path = urllib.quote(path)
157
 
        # handle homedir paths
158
 
        if not path.startswith('/'):
159
 
            path = "/~/" + path
160
 
        netloc = urllib.quote(self._host)
161
 
        if self._username is not None:
162
 
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
163
 
        if self._port is not None:
164
 
            netloc = '%s:%d' % (netloc, self._port)
165
 
        return urlparse.urlunparse((self._scheme, netloc, path, '', '', ''))
166
 
 
167
 
    def _split_url(self, url):
168
 
        (scheme, username, password, host, port, path) = split_url(url)
169
 
        ## assert scheme == 'sftp'
170
 
 
171
 
        # the initial slash should be removed from the path, and treated
172
 
        # as a homedir relative path (the path begins with a double slash
173
 
        # if it is absolute).
174
 
        # see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
175
 
        # RBC 20060118 we are not using this as its too user hostile. instead
176
 
        # we are following lftp and using /~/foo to mean '~/foo'.
177
 
        # handle homedir paths
178
 
        if path.startswith('/~/'):
179
 
            path = path[3:]
180
 
        elif path == '/~':
181
 
            path = ''
182
 
        return (scheme, username, password, host, port, path)
183
 
 
184
 
    def abspath(self, relpath):
185
 
        """Return the full url to the given relative path.
186
 
        
187
 
        @param relpath: the relative path or path components
188
 
        @type relpath: str or list
189
 
        """
190
 
        return self._unparse_url(self._remote_path(relpath))
191
 
    
192
 
    def _remote_path(self, relpath):
193
 
        """Return the path to be passed along the sftp protocol for relpath.
194
 
        
195
 
        :param relpath: is a urlencoded string.
196
 
        """
197
 
        return self._combine_paths(self._path, relpath)
198
 
 
199
 
 
200
 
class SFTPTransport(SFTPUrlHandling):
 
133
class SFTPTransport(ConnectedTransport):
201
134
    """Transport implementation for SFTP access."""
202
135
 
203
136
    _do_prefetch = _default_do_prefetch
218
151
    # up the request itself, rather than us having to worry about it
219
152
    _max_request_size = 32768
220
153
 
221
 
    def __init__(self, base, clone_from=None):
222
 
        super(SFTPTransport, self).__init__(base)
223
 
        if clone_from is None:
224
 
            self._sftp_connect()
 
154
    def __init__(self, base, _from_transport=None):
 
155
        assert base.startswith('sftp://')
 
156
        super(SFTPTransport, self).__init__(base,
 
157
                                            _from_transport=_from_transport)
 
158
 
 
159
    def _remote_path(self, relpath):
 
160
        """Return the path to be passed along the sftp protocol for relpath.
 
161
        
 
162
        :param relpath: is a urlencoded string.
 
163
        """
 
164
        relative = urlutils.unescape(relpath).encode('utf-8')
 
165
        remote_path = self._combine_paths(self._path, relative)
 
166
        # the initial slash should be removed from the path, and treated as a
 
167
        # homedir relative path (the path begins with a double slash if it is
 
168
        # absolute).  see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
 
169
        # RBC 20060118 we are not using this as its too user hostile. instead
 
170
        # we are following lftp and using /~/foo to mean '~/foo'
 
171
        # vila--20070602 and leave absolute paths begin with a single slash.
 
172
        if remote_path.startswith('/~/'):
 
173
            remote_path = remote_path[3:]
 
174
        elif remote_path == '/~':
 
175
            remote_path = ''
 
176
        return remote_path
 
177
 
 
178
    def _create_connection(self, credentials=None):
 
179
        """Create a new connection with the provided credentials.
 
180
 
 
181
        :param credentials: The credentials needed to establish the connection.
 
182
 
 
183
        :return: The created connection and its associated credentials.
 
184
 
 
185
        The credentials are only the password as it may have been entered
 
186
        interactively by the user and may be different from the one provided
 
187
        in base url at transport creation time.
 
188
        """
 
189
        if credentials is None:
 
190
            password = self._password
225
191
        else:
226
 
            # use the same ssh connection, etc
227
 
            self._sftp = clone_from._sftp
228
 
        # super saves 'self.base'
229
 
    
 
192
            password = credentials
 
193
 
 
194
        vendor = ssh._get_ssh_vendor()
 
195
        connection = vendor.connect_sftp(self._user, password,
 
196
                                         self._host, self._port)
 
197
        return connection, password
 
198
 
 
199
    def _get_sftp(self):
 
200
        """Ensures that a connection is established"""
 
201
        connection = self._get_connection()
 
202
        if connection is None:
 
203
            # First connection ever
 
204
            connection, credentials = self._create_connection()
 
205
            self._set_connection(connection, credentials)
 
206
        return connection
 
207
 
 
208
 
230
209
    def should_cache(self):
231
210
        """
232
211
        Return True if the data pulled across should be cached locally.
233
212
        """
234
213
        return True
235
214
 
236
 
    def clone(self, offset=None):
237
 
        """
238
 
        Return a new SFTPTransport with root at self.base + offset.
239
 
        We share the same SFTP session between such transports, because it's
240
 
        fairly expensive to set them up.
241
 
        """
242
 
        if offset is None:
243
 
            return SFTPTransport(self.base, self)
244
 
        else:
245
 
            return SFTPTransport(self.abspath(offset), self)
246
 
 
247
 
    def _remote_path(self, relpath):
248
 
        """Return the path to be passed along the sftp protocol for relpath.
249
 
        
250
 
        relpath is a urlencoded string.
251
 
 
252
 
        :return: a path prefixed with / for regular abspath-based urls, or a
253
 
            path that does not begin with / for urls which begin with /~/.
254
 
        """
255
 
        # how does this work? 
256
 
        # it processes relpath with respect to 
257
 
        # our state:
258
 
        # firstly we create a path to evaluate: 
259
 
        # if relpath is an abspath or homedir path, its the entire thing
260
 
        # otherwise we join our base with relpath
261
 
        # then we eliminate all empty segments (double //'s) outside the first
262
 
        # two elements of the list. This avoids problems with trailing 
263
 
        # slashes, or other abnormalities.
264
 
        # finally we evaluate the entire path in a single pass
265
 
        # '.'s are stripped,
266
 
        # '..' result in popping the left most already 
267
 
        # processed path (which can never be empty because of the check for
268
 
        # abspath and homedir meaning that its not, or that we've used our
269
 
        # path. If the pop would pop the root, we ignore it.
270
 
 
271
 
        # Specific case examinations:
272
 
        # remove the special casefor ~: if the current root is ~/ popping of it
273
 
        # = / thus our seed for a ~ based path is ['', '~']
274
 
        # and if we end up with [''] then we had basically ('', '..') (which is
275
 
        # '/..' so we append '' if the length is one, and assert that the first
276
 
        # element is still ''. Lastly, if we end with ['', '~'] as a prefix for
277
 
        # the output, we've got a homedir path, so we strip that prefix before
278
 
        # '/' joining the resulting list.
279
 
        #
280
 
        # case one: '/' -> ['', ''] cannot shrink
281
 
        # case two: '/' + '../foo' -> ['', 'foo'] (take '', '', '..', 'foo')
282
 
        #           and pop the second '' for the '..', append 'foo'
283
 
        # case three: '/~/' -> ['', '~', ''] 
284
 
        # case four: '/~/' + '../foo' -> ['', '~', '', '..', 'foo'],
285
 
        #           and we want to get '/foo' - the empty path in the middle
286
 
        #           needs to be stripped, then normal path manipulation will 
287
 
        #           work.
288
 
        # case five: '/..' ['', '..'], we want ['', '']
289
 
        #            stripping '' outside the first two is ok
290
 
        #            ignore .. if its too high up
291
 
        #
292
 
        # lastly this code is possibly reusable by FTP, but not reusable by
293
 
        # local paths: ~ is resolvable correctly, nor by HTTP or the smart
294
 
        # server: ~ is resolved remotely.
295
 
        # 
296
 
        # however, a version of this that acts on self.base is possible to be
297
 
        # written which manipulates the URL in canonical form, and would be
298
 
        # reusable for all transports, if a flag for allowing ~/ at all was
299
 
        # provided.
300
 
        assert isinstance(relpath, basestring)
301
 
        relpath = urlutils.unescape(relpath)
302
 
 
303
 
        # case 1)
304
 
        if relpath.startswith('/'):
305
 
            # abspath - normal split is fine.
306
 
            current_path = relpath.split('/')
307
 
        elif relpath.startswith('~/'):
308
 
            # root is homedir based: normal split and prefix '' to remote the
309
 
            # special case
310
 
            current_path = [''].extend(relpath.split('/'))
311
 
        else:
312
 
            # root is from the current directory:
313
 
            if self._path.startswith('/'):
314
 
                # abspath, take the regular split
315
 
                current_path = []
316
 
            else:
317
 
                # homedir based, add the '', '~' not present in self._path
318
 
                current_path = ['', '~']
319
 
            # add our current dir
320
 
            current_path.extend(self._path.split('/'))
321
 
            # add the users relpath
322
 
            current_path.extend(relpath.split('/'))
323
 
        # strip '' segments that are not in the first one - the leading /.
324
 
        to_process = current_path[:1]
325
 
        for segment in current_path[1:]:
326
 
            if segment != '':
327
 
                to_process.append(segment)
328
 
 
329
 
        # process '.' and '..' segments into output_path.
330
 
        output_path = []
331
 
        for segment in to_process:
332
 
            if segment == '..':
333
 
                # directory pop. Remove a directory 
334
 
                # as long as we are not at the root
335
 
                if len(output_path) > 1:
336
 
                    output_path.pop()
337
 
                # else: pass
338
 
                # cannot pop beyond the root, so do nothing
339
 
            elif segment == '.':
340
 
                continue # strip the '.' from the output.
341
 
            else:
342
 
                # this will append '' to output_path for the root elements,
343
 
                # which is appropriate: its why we strip '' in the first pass.
344
 
                output_path.append(segment)
345
 
 
346
 
        # check output special cases:
347
 
        if output_path == ['']:
348
 
            # [''] -> ['', '']
349
 
            output_path = ['', '']
350
 
        elif output_path[:2] == ['', '~']:
351
 
            # ['', '~', ...] -> ...
352
 
            output_path = output_path[2:]
353
 
        path = '/'.join(output_path)
354
 
        return path
355
 
 
356
 
    def relpath(self, abspath):
357
 
        scheme, username, password, host, port, path = self._split_url(abspath)
358
 
        error = []
359
 
        if (username != self._username):
360
 
            error.append('username mismatch')
361
 
        if (host != self._host):
362
 
            error.append('host mismatch')
363
 
        if (port != self._port):
364
 
            error.append('port mismatch')
365
 
        if (not path.startswith(self._path)):
366
 
            error.append('path mismatch')
367
 
        if error:
368
 
            extra = ': ' + ', '.join(error)
369
 
            raise PathNotChild(abspath, self.base, extra=extra)
370
 
        pl = len(self._path)
371
 
        return path[pl:].strip('/')
372
 
 
373
215
    def has(self, relpath):
374
216
        """
375
217
        Does the target location exist?
376
218
        """
377
219
        try:
378
 
            self._sftp.stat(self._remote_path(relpath))
 
220
            self._get_sftp().stat(self._remote_path(relpath))
379
221
            return True
380
222
        except IOError:
381
223
            return False
388
230
        """
389
231
        try:
390
232
            path = self._remote_path(relpath)
391
 
            f = self._sftp.file(path, mode='rb')
 
233
            f = self._get_sftp().file(path, mode='rb')
392
234
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
393
235
                f.prefetch()
394
236
            return f
406
248
 
407
249
        try:
408
250
            path = self._remote_path(relpath)
409
 
            fp = self._sftp.file(path, mode='rb')
 
251
            fp = self._get_sftp().file(path, mode='rb')
410
252
            readv = getattr(fp, 'readv', None)
411
253
            if readv:
412
254
                return self._sftp_readv(fp, offsets, relpath)
555
397
            # Because we set_pipelined() earlier, theoretically we might 
556
398
            # avoid the round trip for fout.close()
557
399
            if mode is not None:
558
 
                self._sftp.chmod(tmp_abspath, mode)
 
400
                self._get_sftp().chmod(tmp_abspath, mode)
559
401
            fout.close()
560
402
            closed = True
561
403
            self._rename_and_overwrite(tmp_abspath, abspath)
570
412
            try:
571
413
                if not closed:
572
414
                    fout.close()
573
 
                self._sftp.remove(tmp_abspath)
 
415
                self._get_sftp().remove(tmp_abspath)
574
416
            except:
575
417
                # raise the saved except
576
418
                raise e
591
433
            fout = None
592
434
            try:
593
435
                try:
594
 
                    fout = self._sftp.file(abspath, mode='wb')
 
436
                    fout = self._get_sftp().file(abspath, mode='wb')
595
437
                    fout.set_pipelined(True)
596
438
                    writer(fout)
597
439
                except (paramiko.SSHException, IOError), e:
602
444
                # Because we set_pipelined() earlier, theoretically we might 
603
445
                # avoid the round trip for fout.close()
604
446
                if mode is not None:
605
 
                    self._sftp.chmod(abspath, mode)
 
447
                    self._get_sftp().chmod(abspath, mode)
606
448
            finally:
607
449
                if fout is not None:
608
450
                    fout.close()
672
514
        else:
673
515
            local_mode = mode
674
516
        try:
675
 
            self._sftp.mkdir(abspath, local_mode)
 
517
            self._get_sftp().mkdir(abspath, local_mode)
676
518
            if mode is not None:
677
 
                self._sftp.chmod(abspath, mode=mode)
 
519
                self._get_sftp().chmod(abspath, mode=mode)
678
520
        except (paramiko.SSHException, IOError), e:
679
521
            self._translate_io_exception(e, abspath, ': unable to mkdir',
680
522
                failure_exc=FileExists)
720
562
        """
721
563
        try:
722
564
            path = self._remote_path(relpath)
723
 
            fout = self._sftp.file(path, 'ab')
 
565
            fout = self._get_sftp().file(path, 'ab')
724
566
            if mode is not None:
725
 
                self._sftp.chmod(path, mode)
 
567
                self._get_sftp().chmod(path, mode)
726
568
            result = fout.tell()
727
569
            self._pump(f, fout)
728
570
            return result
732
574
    def rename(self, rel_from, rel_to):
733
575
        """Rename without special overwriting"""
734
576
        try:
735
 
            self._sftp.rename(self._remote_path(rel_from),
 
577
            self._get_sftp().rename(self._remote_path(rel_from),
736
578
                              self._remote_path(rel_to))
737
579
        except (IOError, paramiko.SSHException), e:
738
580
            self._translate_io_exception(e, rel_from,
744
586
        Using the implementation provided by osutils.
745
587
        """
746
588
        try:
 
589
            sftp = self._get_sftp()
747
590
            fancy_rename(abs_from, abs_to,
748
 
                    rename_func=self._sftp.rename,
749
 
                    unlink_func=self._sftp.remove)
 
591
                         rename_func=sftp.rename,
 
592
                         unlink_func=sftp.remove)
750
593
        except (IOError, paramiko.SSHException), e:
751
 
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
 
594
            self._translate_io_exception(e, abs_from,
 
595
                                         ': unable to rename to %r' % (abs_to))
752
596
 
753
597
    def move(self, rel_from, rel_to):
754
598
        """Move the item at rel_from to the location at rel_to"""
760
604
        """Delete the item at relpath"""
761
605
        path = self._remote_path(relpath)
762
606
        try:
763
 
            self._sftp.remove(path)
 
607
            self._get_sftp().remove(path)
764
608
        except (IOError, paramiko.SSHException), e:
765
609
            self._translate_io_exception(e, path, ': unable to delete')
766
610
            
783
627
        # -- David Allouche 2006-08-11
784
628
        path = self._remote_path(relpath)
785
629
        try:
786
 
            entries = self._sftp.listdir(path)
 
630
            entries = self._get_sftp().listdir(path)
787
631
        except (IOError, paramiko.SSHException), e:
788
632
            self._translate_io_exception(e, path, ': failed to list_dir')
789
633
        return [urlutils.escape(entry) for entry in entries]
792
636
        """See Transport.rmdir."""
793
637
        path = self._remote_path(relpath)
794
638
        try:
795
 
            return self._sftp.rmdir(path)
 
639
            return self._get_sftp().rmdir(path)
796
640
        except (IOError, paramiko.SSHException), e:
797
641
            self._translate_io_exception(e, path, ': failed to rmdir')
798
642
 
800
644
        """Return the stat information for a file."""
801
645
        path = self._remote_path(relpath)
802
646
        try:
803
 
            return self._sftp.stat(path)
 
647
            return self._get_sftp().stat(path)
804
648
        except (IOError, paramiko.SSHException), e:
805
649
            self._translate_io_exception(e, path, ': unable to stat')
806
650
 
830
674
        # that we have taken the lock.
831
675
        return SFTPLock(relpath, self)
832
676
 
833
 
    def _sftp_connect(self):
834
 
        """Connect to the remote sftp server.
835
 
        After this, self._sftp should have a valid connection (or
836
 
        we raise an TransportError 'could not connect').
837
 
 
838
 
        TODO: Raise a more reasonable ConnectionFailed exception
839
 
        """
840
 
        self._sftp = _sftp_connect(self._host, self._port, self._username,
841
 
                self._password)
842
 
 
843
677
    def _sftp_open_exclusive(self, abspath, mode=None):
844
678
        """Open a remote path exclusively.
845
679
 
858
692
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
859
693
        #       However, there is no way to set the permission mode at open 
860
694
        #       time using the sftp_client.file() functionality.
861
 
        path = self._sftp._adjust_cwd(abspath)
 
695
        path = self._get_sftp()._adjust_cwd(abspath)
862
696
        # mutter('sftp abspath %s => %s', abspath, path)
863
697
        attr = SFTPAttributes()
864
698
        if mode is not None:
866
700
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
867
701
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
868
702
        try:
869
 
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
 
703
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
870
704
            if t != CMD_HANDLE:
871
705
                raise TransportError('Expected an SFTP handle')
872
706
            handle = msg.get_string()
873
 
            return SFTPFile(self._sftp, handle, 'wb', -1)
 
707
            return SFTPFile(self._get_sftp(), handle, 'wb', -1)
874
708
        except (paramiko.SSHException, IOError), e:
875
709
            self._translate_io_exception(e, abspath, ': unable to open',
876
710
                failure_exc=FileExists)
1202
1036
        super(SFTPSiblingAbsoluteServer, self).setUp(backing_server)
1203
1037
 
1204
1038
 
1205
 
def _sftp_connect(host, port, username, password):
1206
 
    """Connect to the remote sftp server.
1207
 
 
1208
 
    :raises: a TransportError 'could not connect'.
1209
 
 
1210
 
    :returns: an paramiko.sftp_client.SFTPClient
1211
 
 
1212
 
    TODO: Raise a more reasonable ConnectionFailed exception
1213
 
    """
1214
 
    idx = (host, port, username)
1215
 
    try:
1216
 
        return _connected_hosts[idx]
1217
 
    except KeyError:
1218
 
        pass
1219
 
    
1220
 
    sftp = _sftp_connect_uncached(host, port, username, password)
1221
 
    _connected_hosts[idx] = sftp
1222
 
    return sftp
1223
 
 
1224
 
def _sftp_connect_uncached(host, port, username, password):
1225
 
    vendor = ssh._get_ssh_vendor()
1226
 
    sftp = vendor.connect_sftp(username, password, host, port)
1227
 
    return sftp
1228
 
 
1229
 
 
1230
1039
def get_test_permutations():
1231
1040
    """Return the permutations to be used in testing."""
1232
1041
    return [(SFTPTransport, SFTPAbsoluteServer),