← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Michael Ellerman
  • Date: 2005-12-10 22:11:46 UTC
  • mto: This revision was merged to the branch mainline in revision 1528.
  • Revision ID: michael@ellerman.id.au-20051210221145-7765347ea4ca0093
Raise NoSuchFile when someone tries to add a non-existant file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/sftp.py
1
 
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
2
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>, Canonical Ltd
3
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
20
19
import errno
21
20
import getpass
22
21
import os
23
 
import random
24
22
import re
25
23
import stat
26
 
import subprocess
27
24
import sys
28
 
import time
29
25
import urllib
30
26
import urlparse
 
27
import time
 
28
import random
 
29
import subprocess
31
30
import weakref
32
31
 
33
 
from bzrlib.config import config_dir, ensure_config_dir_exists
34
 
from bzrlib.errors import (ConnectionError,
35
 
                           FileExists, 
 
32
from bzrlib.errors import (FileExists, 
36
33
                           TransportNotPossible, NoSuchFile, PathNotChild,
37
34
                           TransportError,
38
 
                           LockError, 
39
 
                           PathError,
40
 
                           ParamikoNotPresent,
41
 
                           )
42
 
from bzrlib.osutils import pathjoin, fancy_rename
 
35
                           LockError)
 
36
from bzrlib.config import config_dir
43
37
from bzrlib.trace import mutter, warning, error
44
 
from bzrlib.transport import (
45
 
    register_urlparse_netloc_protocol,
46
 
    Server,
47
 
    split_url,
48
 
    Transport,
49
 
    )
 
38
from bzrlib.transport import Transport, register_transport
50
39
import bzrlib.ui
51
 
import bzrlib.urlutils as urlutils
52
40
 
53
41
try:
54
42
    import paramiko
55
 
except ImportError, e:
56
 
    raise ParamikoNotPresent(e)
 
43
except ImportError:
 
44
    error('The SFTP transport requires paramiko.')
 
45
    raise
57
46
else:
58
47
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
59
48
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
62
51
    from paramiko.sftp_file import SFTPFile
63
52
    from paramiko.sftp_client import SFTPClient
64
53
 
65
 
 
66
 
register_urlparse_netloc_protocol('sftp')
67
 
 
68
 
 
69
 
def _ignore_sigint():
70
 
    # TODO: This should possibly ignore SIGHUP as well, but bzr currently
71
 
    # doesn't handle it itself.
72
 
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
73
 
    import signal
74
 
    signal.signal(signal.SIGINT, signal.SIG_IGN)
75
 
    
76
 
 
77
 
def os_specific_subprocess_params():
78
 
    """Get O/S specific subprocess parameters."""
79
 
    if sys.platform == 'win32':
80
 
        # setting the process group and closing fds is not supported on 
81
 
        # win32
82
 
        return {}
83
 
    else:
84
 
        # We close fds other than the pipes as the child process does not need 
85
 
        # them to be open.
86
 
        #
87
 
        # We also set the child process to ignore SIGINT.  Normally the signal
88
 
        # would be sent to every process in the foreground process group, but
89
 
        # this causes it to be seen only by bzr and not by ssh.  Python will
90
 
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
91
 
        # to release locks or do other cleanup over ssh before the connection
92
 
        # goes away.  
93
 
        # <https://launchpad.net/products/bzr/+bug/5987>
94
 
        #
95
 
        # Running it in a separate process group is not good because then it
96
 
        # can't get non-echoed input of a password or passphrase.
97
 
        # <https://launchpad.net/products/bzr/+bug/40508>
98
 
        return {'preexec_fn': _ignore_sigint,
99
 
                'close_fds': True,
100
 
                }
101
 
 
102
 
 
103
 
# don't use prefetch unless paramiko version >= 1.5.2 (there were bugs earlier)
104
 
_default_do_prefetch = False
105
 
if getattr(paramiko, '__version_info__', (0, 0, 0)) >= (1, 5, 5):
106
 
    _default_do_prefetch = True
107
 
 
 
54
if 'sftp' not in urlparse.uses_netloc: urlparse.uses_netloc.append('sftp')
 
55
 
 
56
 
 
57
_close_fds = True
 
58
if sys.platform == 'win32':
 
59
    # close_fds not supported on win32
 
60
    _close_fds = False
108
61
 
109
62
_ssh_vendor = None
110
63
def _get_ssh_vendor():
115
68
 
116
69
    _ssh_vendor = 'none'
117
70
 
118
 
    if 'BZR_SSH' in os.environ:
119
 
        _ssh_vendor = os.environ['BZR_SSH']
120
 
        if _ssh_vendor == 'paramiko':
121
 
            _ssh_vendor = 'none'
122
 
        return _ssh_vendor
123
 
 
124
71
    try:
125
72
        p = subprocess.Popen(['ssh', '-V'],
 
73
                             close_fds=_close_fds,
126
74
                             stdin=subprocess.PIPE,
127
75
                             stdout=subprocess.PIPE,
128
 
                             stderr=subprocess.PIPE,
129
 
                             **os_specific_subprocess_params())
 
76
                             stderr=subprocess.PIPE)
130
77
        returncode = p.returncode
131
78
        stdout, stderr = p.communicate()
132
79
    except OSError:
151
98
 
152
99
class SFTPSubprocess:
153
100
    """A socket-like object that talks to an ssh subprocess via pipes."""
154
 
    def __init__(self, hostname, vendor, port=None, user=None):
 
101
    def __init__(self, hostname, port=None, user=None):
 
102
        vendor = _get_ssh_vendor()
155
103
        assert vendor in ['openssh', 'ssh']
156
104
        if vendor == 'openssh':
157
105
            args = ['ssh',
171
119
                args.extend(['-l', user])
172
120
            args.extend(['-s', 'sftp', hostname])
173
121
 
174
 
        self.proc = subprocess.Popen(args,
 
122
        self.proc = subprocess.Popen(args, close_fds=_close_fds,
175
123
                                     stdin=subprocess.PIPE,
176
 
                                     stdout=subprocess.PIPE,
177
 
                                     **os_specific_subprocess_params())
 
124
                                     stdout=subprocess.PIPE)
178
125
 
179
126
    def send(self, data):
180
127
        return os.write(self.proc.stdin.fileno(), data)
181
128
 
182
 
    def recv_ready(self):
183
 
        # TODO: jam 20051215 this function is necessary to support the
184
 
        # pipelined() function. In reality, it probably should use
185
 
        # poll() or select() to actually return if there is data
186
 
        # available, otherwise we probably don't get any benefit
187
 
        return True
188
 
 
189
129
    def recv(self, count):
190
130
        return os.read(self.proc.stdout.fileno(), count)
191
131
 
195
135
        self.proc.wait()
196
136
 
197
137
 
198
 
class LoopbackSFTP(object):
199
 
    """Simple wrapper for a socket that pretends to be a paramiko Channel."""
200
 
 
201
 
    def __init__(self, sock):
202
 
        self.__socket = sock
203
 
 
204
 
    def send(self, data):
205
 
        return self.__socket.send(data)
206
 
 
207
 
    def recv(self, n):
208
 
        return self.__socket.recv(n)
209
 
 
210
 
    def recv_ready(self):
211
 
        return True
212
 
 
213
 
    def close(self):
214
 
        self.__socket.close()
215
 
 
216
 
 
217
138
SYSTEM_HOSTKEYS = {}
218
139
BZR_HOSTKEYS = {}
219
140
 
223
144
# X seconds. But that requires a lot more fanciness.
224
145
_connected_hosts = weakref.WeakValueDictionary()
225
146
 
226
 
def clear_connection_cache():
227
 
    """Remove all hosts from the SFTP connection cache.
228
 
 
229
 
    Primarily useful for test cases wanting to force garbage collection.
230
 
    """
231
 
    _connected_hosts.clear()
232
 
 
233
 
 
234
147
def load_host_keys():
235
148
    """
236
149
    Load system host keys (probably doesn't work on windows) and any
241
154
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
242
155
    except Exception, e:
243
156
        mutter('failed to load system host keys: ' + str(e))
244
 
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
157
    bzr_hostkey_path = os.path.join(config_dir(), 'ssh_host_keys')
245
158
    try:
246
159
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
247
160
    except Exception, e:
248
161
        mutter('failed to load bzr host keys: ' + str(e))
249
162
        save_host_keys()
250
163
 
251
 
 
252
164
def save_host_keys():
253
165
    """
254
166
    Save "discovered" host keys in $(config)/ssh_host_keys/.
255
167
    """
256
168
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
257
 
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
258
 
    ensure_config_dir_exists()
259
 
 
 
169
    bzr_hostkey_path = os.path.join(config_dir(), 'ssh_host_keys')
 
170
    if not os.path.isdir(config_dir()):
 
171
        os.mkdir(config_dir())
260
172
    try:
261
173
        f = open(bzr_hostkey_path, 'w')
262
174
        f.write('# SSH host keys collected by bzr\n')
279
191
        self.lock_path = path + '.write-lock'
280
192
        self.transport = transport
281
193
        try:
282
 
            # RBC 20060103 FIXME should we be using private methods here ?
283
 
            abspath = transport._remote_path(self.lock_path)
284
 
            self.lock_file = transport._sftp_open_exclusive(abspath)
 
194
            self.lock_file = transport._sftp_open_exclusive(self.lock_path)
285
195
        except FileExists:
286
196
            raise LockError('File %r already locked' % (self.path,))
287
197
 
288
198
    def __del__(self):
289
199
        """Should this warn, or actually try to cleanup?"""
290
200
        if self.lock_file:
291
 
            warning("SFTPLock %r not explicitly unlocked" % (self.path,))
 
201
            warn("SFTPLock %r not explicitly unlocked" % (self.path,))
292
202
            self.unlock()
293
203
 
294
204
    def unlock(self):
306
216
    """
307
217
    Transport implementation for SFTP access.
308
218
    """
309
 
    _do_prefetch = _default_do_prefetch
 
219
    _do_prefetch = False # Right now Paramiko's prefetch support causes things to hang
310
220
 
311
221
    def __init__(self, base, clone_from=None):
312
222
        assert base.startswith('sftp://')
313
223
        self._parse_url(base)
314
224
        base = self._unparse_url()
315
 
        if base[-1] != '/':
316
 
            base += '/'
317
225
        super(SFTPTransport, self).__init__(base)
318
226
        if clone_from is None:
319
227
            self._sftp_connect()
346
254
        @param relpath: the relative path or path components
347
255
        @type relpath: str or list
348
256
        """
349
 
        return self._unparse_url(self._remote_path(relpath))
 
257
        return self._unparse_url(self._abspath(relpath))
350
258
    
351
 
    def _remote_path(self, relpath):
352
 
        """Return the path to be passed along the sftp protocol for relpath.
353
 
        
354
 
        relpath is a urlencoded string.
355
 
        """
 
259
    def _abspath(self, relpath):
 
260
        """Return the absolute path segment without the SFTP URL."""
356
261
        # FIXME: share the common code across transports
357
262
        assert isinstance(relpath, basestring)
358
 
        relpath = urlutils.unescape(relpath).split('/')
 
263
        relpath = [urllib.unquote(relpath)]
359
264
        basepath = self._path.split('/')
360
265
        if len(basepath) > 0 and basepath[-1] == '':
361
266
            basepath = basepath[:-1]
373
278
                basepath.append(p)
374
279
 
375
280
        path = '/'.join(basepath)
 
281
        # could still be a "relative" path here, but relative on the sftp server
376
282
        return path
377
283
 
378
284
    def relpath(self, abspath):
390
296
            extra = ': ' + ', '.join(error)
391
297
            raise PathNotChild(abspath, self.base, extra=extra)
392
298
        pl = len(self._path)
393
 
        return path[pl:].strip('/')
 
299
        return path[pl:].lstrip('/')
394
300
 
395
301
    def has(self, relpath):
396
302
        """
397
303
        Does the target location exist?
398
304
        """
399
305
        try:
400
 
            self._sftp.stat(self._remote_path(relpath))
 
306
            self._sftp.stat(self._abspath(relpath))
401
307
            return True
402
308
        except IOError:
403
309
            return False
404
310
 
405
 
    def get(self, relpath):
 
311
    def get(self, relpath, decode=False):
406
312
        """
407
313
        Get the file at the given relative path.
408
314
 
409
315
        :param relpath: The relative path to the file
410
316
        """
411
317
        try:
412
 
            path = self._remote_path(relpath)
413
 
            f = self._sftp.file(path, mode='rb')
414
 
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
 
318
            path = self._abspath(relpath)
 
319
            f = self._sftp.file(path)
 
320
            if self._do_prefetch and hasattr(f, 'prefetch'):
415
321
                f.prefetch()
416
322
            return f
417
323
        except (IOError, paramiko.SSHException), e:
436
342
            f.prefetch()
437
343
        return f
438
344
 
439
 
    def put(self, relpath, f, mode=None):
 
345
    def put(self, relpath, f):
440
346
        """
441
347
        Copy the file-like or string object into the location.
442
348
 
443
349
        :param relpath: Location to put the contents, relative to base.
444
350
        :param f:       File-like or string object.
445
 
        :param mode: The final mode for the file
446
351
        """
447
 
        final_path = self._remote_path(relpath)
448
 
        self._put(final_path, f, mode=mode)
449
 
 
450
 
    def _put(self, abspath, f, mode=None):
451
 
        """Helper function so both put() and copy_abspaths can reuse the code"""
452
 
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
 
352
        final_path = self._abspath(relpath)
 
353
        tmp_relpath = '%s.tmp.%.9f.%d.%d' % (relpath, time.time(),
453
354
                        os.getpid(), random.randint(0,0x7FFFFFFF))
454
 
        fout = self._sftp_open_exclusive(tmp_abspath, mode=mode)
455
 
        closed = False
 
355
        tmp_abspath = self._abspath(tmp_relpath)
 
356
        fout = self._sftp_open_exclusive(tmp_relpath)
 
357
 
456
358
        try:
457
359
            try:
458
 
                fout.set_pipelined(True)
459
360
                self._pump(f, fout)
460
 
            except (IOError, paramiko.SSHException), e:
461
 
                self._translate_io_exception(e, tmp_abspath)
462
 
            if mode is not None:
463
 
                self._sftp.chmod(tmp_abspath, mode)
464
 
            fout.close()
465
 
            closed = True
466
 
            self._rename_and_overwrite(tmp_abspath, abspath)
 
361
            except (paramiko.SSHException, IOError), e:
 
362
                self._translate_io_exception(e, relpath, ': unable to write')
467
363
        except Exception, e:
468
364
            # If we fail, try to clean up the temporary file
469
365
            # before we throw the exception
470
366
            # but don't let another exception mess things up
471
 
            # Write out the traceback, because otherwise
472
 
            # the catch and throw destroys it
473
 
            import traceback
474
 
            mutter(traceback.format_exc())
475
367
            try:
476
 
                if not closed:
477
 
                    fout.close()
 
368
                fout.close()
478
369
                self._sftp.remove(tmp_abspath)
479
370
            except:
480
 
                # raise the saved except
481
 
                raise e
482
 
            # raise the original with its traceback if we can.
483
 
            raise
 
371
                pass
 
372
            raise e
 
373
        else:
 
374
            # sftp rename doesn't allow overwriting, so play tricks:
 
375
            tmp_safety = 'bzr.tmp.%.9f.%d.%d' % (time.time(), os.getpid(), random.randint(0, 0x7FFFFFFF))
 
376
            tmp_safety = self._abspath(tmp_safety)
 
377
            try:
 
378
                self._sftp.rename(final_path, tmp_safety)
 
379
                file_existed = True
 
380
            except:
 
381
                file_existed = False
 
382
            success = False
 
383
            try:
 
384
                try:
 
385
                    self._sftp.rename(tmp_abspath, final_path)
 
386
                except (paramiko.SSHException, IOError), e:
 
387
                    self._translate_io_exception(e, relpath, ': unable to rename')
 
388
                else:
 
389
                    success = True
 
390
            finally:
 
391
                if file_existed:
 
392
                    if success:
 
393
                        self._sftp.unlink(tmp_safety)
 
394
                    else:
 
395
                        self._sftp.rename(tmp_safety, final_path)
484
396
 
485
397
    def iter_files_recursive(self):
486
398
        """Walk the relative paths of all files in this transport."""
494
406
            else:
495
407
                yield relpath
496
408
 
497
 
    def mkdir(self, relpath, mode=None):
 
409
    def mkdir(self, relpath):
498
410
        """Create a directory at the given path."""
499
411
        try:
500
 
            path = self._remote_path(relpath)
501
 
            # In the paramiko documentation, it says that passing a mode flag 
502
 
            # will filtered against the server umask.
503
 
            # StubSFTPServer does not do this, which would be nice, because it is
504
 
            # what we really want :)
505
 
            # However, real servers do use umask, so we really should do it that way
 
412
            path = self._abspath(relpath)
506
413
            self._sftp.mkdir(path)
507
 
            if mode is not None:
508
 
                self._sftp.chmod(path, mode=mode)
509
414
        except (paramiko.SSHException, IOError), e:
510
 
            self._translate_io_exception(e, path, ': unable to mkdir',
 
415
            self._translate_io_exception(e, relpath, ': unable to mkdir',
511
416
                failure_exc=FileExists)
512
417
 
513
 
    def _translate_io_exception(self, e, path, more_info='', 
514
 
                                failure_exc=PathError):
 
418
    def _translate_io_exception(self, e, path, more_info='', failure_exc=NoSuchFile):
515
419
        """Translate a paramiko or IOError into a friendlier exception.
516
420
 
517
421
        :param e: The original exception
521
425
        :param failure_exc: Paramiko has the super fun ability to raise completely
522
426
                           opaque errors that just set "e.args = ('Failure',)" with
523
427
                           no more information.
524
 
                           If this parameter is set, it defines the exception 
525
 
                           to raise in these cases.
 
428
                           This sometimes means FileExists, but it also sometimes
 
429
                           means NoSuchFile
526
430
        """
527
431
        # paramiko seems to generate detailless errors.
528
432
        self._translate_error(e, path, raise_generic=False)
535
439
            # strange but true, for the paramiko server.
536
440
            if (e.args == ('Failure',)):
537
441
                raise failure_exc(path, str(e) + more_info)
538
 
            mutter('Raising exception with args %s', e.args)
539
 
        if hasattr(e, 'errno'):
540
 
            mutter('Raising exception with errno %s', e.errno)
541
442
        raise e
542
443
 
543
 
    def append(self, relpath, f, mode=None):
 
444
    def append(self, relpath, f):
544
445
        """
545
446
        Append the text in the file-like object into the final
546
447
        location.
547
448
        """
548
449
        try:
549
 
            path = self._remote_path(relpath)
 
450
            path = self._abspath(relpath)
550
451
            fout = self._sftp.file(path, 'ab')
551
 
            if mode is not None:
552
 
                self._sftp.chmod(path, mode)
553
 
            result = fout.tell()
554
452
            self._pump(f, fout)
555
 
            return result
556
453
        except (IOError, paramiko.SSHException), e:
557
454
            self._translate_io_exception(e, relpath, ': unable to append')
558
455
 
559
 
    def rename(self, rel_from, rel_to):
560
 
        """Rename without special overwriting"""
561
 
        try:
562
 
            self._sftp.rename(self._remote_path(rel_from),
563
 
                              self._remote_path(rel_to))
564
 
        except (IOError, paramiko.SSHException), e:
565
 
            self._translate_io_exception(e, rel_from,
566
 
                    ': unable to rename to %r' % (rel_to))
567
 
 
568
 
    def _rename_and_overwrite(self, abs_from, abs_to):
569
 
        """Do a fancy rename on the remote server.
570
 
        
571
 
        Using the implementation provided by osutils.
572
 
        """
573
 
        try:
574
 
            fancy_rename(abs_from, abs_to,
575
 
                    rename_func=self._sftp.rename,
576
 
                    unlink_func=self._sftp.remove)
577
 
        except (IOError, paramiko.SSHException), e:
578
 
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
 
456
    def copy(self, rel_from, rel_to):
 
457
        """Copy the item at rel_from to the location at rel_to"""
 
458
        path_from = self._abspath(rel_from)
 
459
        path_to = self._abspath(rel_to)
 
460
        self._copy_abspaths(path_from, path_to)
 
461
 
 
462
    def _copy_abspaths(self, path_from, path_to):
 
463
        """Copy files given an absolute path
 
464
 
 
465
        :param path_from: Path on remote server to read
 
466
        :param path_to: Path on remote server to write
 
467
        :return: None
 
468
 
 
469
        TODO: Should the destination location be atomically created?
 
470
              This has not been specified
 
471
        TODO: This should use some sort of remote copy, rather than
 
472
              pulling the data locally, and then writing it remotely
 
473
        """
 
474
        try:
 
475
            fin = self._sftp.file(path_from, 'rb')
 
476
            try:
 
477
                fout = self._sftp.file(path_to, 'wb')
 
478
                try:
 
479
                    fout.set_pipelined(True)
 
480
                    self._pump(fin, fout)
 
481
                finally:
 
482
                    fout.close()
 
483
            finally:
 
484
                fin.close()
 
485
        except (IOError, paramiko.SSHException), e:
 
486
            self._translate_io_exception(e, path_from, ': unable copy to: %r' % path_to)
 
487
 
 
488
    def copy_to(self, relpaths, other, pb=None):
 
489
        """Copy a set of entries from self into another Transport.
 
490
 
 
491
        :param relpaths: A list/generator of entries to be copied.
 
492
        """
 
493
        if isinstance(other, SFTPTransport) and other._sftp is self._sftp:
 
494
            # Both from & to are on the same remote filesystem
 
495
            # We can use a remote copy, instead of pulling locally, and pushing
 
496
 
 
497
            total = self._get_total(relpaths)
 
498
            count = 0
 
499
            for path in relpaths:
 
500
                path_from = self._abspath(relpath)
 
501
                path_to = other._abspath(relpath)
 
502
                self._update_pb(pb, 'copy-to', count, total)
 
503
                self._copy_abspaths(path_from, path_to)
 
504
                count += 1
 
505
            return count
 
506
        else:
 
507
            return super(SFTPTransport, self).copy_to(relpaths, other, pb=pb)
 
508
 
 
509
        # The dummy implementation just does a simple get + put
 
510
        def copy_entry(path):
 
511
            other.put(path, self.get(path))
 
512
 
 
513
        return self._iterate_over(relpaths, copy_entry, pb, 'copy_to', expand=False)
579
514
 
580
515
    def move(self, rel_from, rel_to):
581
516
        """Move the item at rel_from to the location at rel_to"""
582
 
        path_from = self._remote_path(rel_from)
583
 
        path_to = self._remote_path(rel_to)
584
 
        self._rename_and_overwrite(path_from, path_to)
 
517
        path_from = self._abspath(rel_from)
 
518
        path_to = self._abspath(rel_to)
 
519
        try:
 
520
            self._sftp.rename(path_from, path_to)
 
521
        except (IOError, paramiko.SSHException), e:
 
522
            self._translate_io_exception(e, path_from, ': unable to move to: %r' % path_to)
585
523
 
586
524
    def delete(self, relpath):
587
525
        """Delete the item at relpath"""
588
 
        path = self._remote_path(relpath)
 
526
        path = self._abspath(relpath)
589
527
        try:
590
528
            self._sftp.remove(path)
591
529
        except (IOError, paramiko.SSHException), e:
600
538
        Return a list of all files at the given location.
601
539
        """
602
540
        # does anything actually use this?
603
 
        path = self._remote_path(relpath)
 
541
        path = self._abspath(relpath)
604
542
        try:
605
543
            return self._sftp.listdir(path)
606
544
        except (IOError, paramiko.SSHException), e:
607
545
            self._translate_io_exception(e, path, ': failed to list_dir')
608
546
 
609
 
    def rmdir(self, relpath):
610
 
        """See Transport.rmdir."""
611
 
        path = self._remote_path(relpath)
612
 
        try:
613
 
            return self._sftp.rmdir(path)
614
 
        except (IOError, paramiko.SSHException), e:
615
 
            self._translate_io_exception(e, path, ': failed to rmdir')
616
 
 
617
547
    def stat(self, relpath):
618
548
        """Return the stat information for a file."""
619
 
        path = self._remote_path(relpath)
 
549
        path = self._abspath(relpath)
620
550
        try:
621
551
            return self._sftp.stat(path)
622
552
        except (IOError, paramiko.SSHException), e:
648
578
        # that we have taken the lock.
649
579
        return SFTPLock(relpath, self)
650
580
 
 
581
 
651
582
    def _unparse_url(self, path=None):
652
583
        if path is None:
653
584
            path = self._path
654
585
        path = urllib.quote(path)
655
 
        # handle homedir paths
656
 
        if not path.startswith('/'):
657
 
            path = "/~/" + path
 
586
        if path.startswith('/'):
 
587
            path = '/%2F' + path[1:]
 
588
        else:
 
589
            path = '/' + path
658
590
        netloc = urllib.quote(self._host)
659
591
        if self._username is not None:
660
592
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
661
593
        if self._port is not None:
662
594
            netloc = '%s:%d' % (netloc, self._port)
 
595
 
663
596
        return urlparse.urlunparse(('sftp', netloc, path, '', '', ''))
664
597
 
665
598
    def _split_url(self, url):
666
 
        (scheme, username, password, host, port, path) = split_url(url)
 
599
        if isinstance(url, unicode):
 
600
            url = url.encode('utf-8')
 
601
        (scheme, netloc, path, params,
 
602
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
667
603
        assert scheme == 'sftp'
 
604
        username = password = host = port = None
 
605
        if '@' in netloc:
 
606
            username, host = netloc.split('@', 1)
 
607
            if ':' in username:
 
608
                username, password = username.split(':', 1)
 
609
                password = urllib.unquote(password)
 
610
            username = urllib.unquote(username)
 
611
        else:
 
612
            host = netloc
 
613
 
 
614
        if ':' in host:
 
615
            host, port = host.rsplit(':', 1)
 
616
            try:
 
617
                port = int(port)
 
618
            except ValueError:
 
619
                # TODO: Should this be ConnectionError?
 
620
                raise TransportError('%s: invalid port number' % port)
 
621
        host = urllib.unquote(host)
 
622
 
 
623
        path = urllib.unquote(path)
668
624
 
669
625
        # the initial slash should be removed from the path, and treated
670
626
        # as a homedir relative path (the path begins with a double slash
671
627
        # if it is absolute).
672
628
        # see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
673
 
        # RBC 20060118 we are not using this as its too user hostile. instead
674
 
        # we are following lftp and using /~/foo to mean '~/foo'.
675
 
        # handle homedir paths
676
 
        if path.startswith('/~/'):
677
 
            path = path[3:]
678
 
        elif path == '/~':
679
 
            path = ''
 
629
        if path.startswith('/'):
 
630
            path = path[1:]
 
631
 
680
632
        return (username, password, host, port, path)
681
633
 
682
634
    def _parse_url(self, url):
700
652
            pass
701
653
        
702
654
        vendor = _get_ssh_vendor()
703
 
        if vendor == 'loopback':
704
 
            sock = socket.socket()
705
 
            sock.connect((self._host, self._port))
706
 
            self._sftp = SFTPClient(LoopbackSFTP(sock))
707
 
        elif vendor != 'none':
708
 
            sock = SFTPSubprocess(self._host, vendor, self._port,
709
 
                                  self._username)
 
655
        if vendor != 'none':
 
656
            sock = SFTPSubprocess(self._host, self._port, self._username)
710
657
            self._sftp = SFTPClient(sock)
711
658
        else:
712
659
            self._paramiko_connect()
720
667
 
721
668
        try:
722
669
            t = paramiko.Transport((self._host, self._port or 22))
723
 
            t.set_log_channel('bzr.paramiko')
724
670
            t.start_client()
725
671
        except paramiko.SSHException, e:
726
672
            raise ConnectionError('Unable to reach SSH host %s:%d' %
745
691
            save_host_keys()
746
692
        if server_key != our_server_key:
747
693
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
748
 
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
694
            filename2 = os.path.join(config_dir(), 'ssh_host_keys')
749
695
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
750
696
                (self._host, our_server_key_hex, server_key_hex),
751
697
                ['Try editing %s or %s' % (filename1, filename2)])
787
733
        if self._try_pkey_auth(transport, paramiko.DSSKey, username, 'id_dsa'):
788
734
            return
789
735
 
 
736
 
790
737
        if self._password:
791
738
            try:
792
739
                transport.auth_password(username, self._password)
829
776
            pass
830
777
        return False
831
778
 
832
 
    def _sftp_open_exclusive(self, abspath, mode=None):
 
779
    def _sftp_open_exclusive(self, relpath):
833
780
        """Open a remote path exclusively.
834
781
 
835
782
        SFTP supports O_EXCL (SFTP_FLAG_EXCL), which fails if
840
787
        WARNING: This breaks the SFTPClient abstraction, so it
841
788
        could easily break against an updated version of paramiko.
842
789
 
843
 
        :param abspath: The remote absolute path where the file should be opened
844
 
        :param mode: The mode permissions bits for the new file
 
790
        :param relpath: The relative path, where the file should be opened
845
791
        """
846
 
        path = self._sftp._adjust_cwd(abspath)
 
792
        path = self._sftp._adjust_cwd(self._abspath(relpath))
847
793
        attr = SFTPAttributes()
848
 
        if mode is not None:
849
 
            attr.st_mode = mode
850
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
 
794
        mode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
851
795
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
852
796
        try:
853
 
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
 
797
            t, msg = self._sftp._request(CMD_OPEN, path, mode, attr)
854
798
            if t != CMD_HANDLE:
855
799
                raise TransportError('Expected an SFTP handle')
856
800
            handle = msg.get_string()
857
 
            return SFTPFile(self._sftp, handle, 'wb', -1)
 
801
            return SFTPFile(self._sftp, handle, 'w', -1)
858
802
        except (paramiko.SSHException, IOError), e:
859
 
            self._translate_io_exception(e, abspath, ': unable to open',
 
803
            self._translate_io_exception(e, relpath, ': unable to open',
860
804
                failure_exc=FileExists)
861
805
 
862
 
 
863
 
# ------------- server test implementation --------------
864
 
import socket
865
 
import threading
866
 
 
867
 
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
868
 
 
869
 
STUB_SERVER_KEY = """
870
 
-----BEGIN RSA PRIVATE KEY-----
871
 
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
872
 
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
873
 
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
874
 
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
875
 
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
876
 
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
877
 
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
878
 
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
879
 
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
880
 
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
881
 
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
882
 
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
883
 
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
884
 
-----END RSA PRIVATE KEY-----
885
 
"""
886
 
    
887
 
 
888
 
class SingleListener(threading.Thread):
889
 
 
890
 
    def __init__(self, callback):
891
 
        threading.Thread.__init__(self)
892
 
        self._callback = callback
893
 
        self._socket = socket.socket()
894
 
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
895
 
        self._socket.bind(('localhost', 0))
896
 
        self._socket.listen(1)
897
 
        self.port = self._socket.getsockname()[1]
898
 
        self.stop_event = threading.Event()
899
 
 
900
 
    def run(self):
901
 
        s, _ = self._socket.accept()
902
 
        # now close the listen socket
903
 
        self._socket.close()
904
 
        try:
905
 
            self._callback(s, self.stop_event)
906
 
        except socket.error:
907
 
            pass #Ignore socket errors
908
 
        except Exception, x:
909
 
            # probably a failed test
910
 
            warning('Exception from within unit test server thread: %r' % x)
911
 
 
912
 
    def stop(self):
913
 
        self.stop_event.set()
914
 
        # use a timeout here, because if the test fails, the server thread may
915
 
        # never notice the stop_event.
916
 
        self.join(5.0)
917
 
 
918
 
 
919
 
class SFTPServer(Server):
920
 
    """Common code for SFTP server facilities."""
921
 
 
922
 
    def __init__(self):
923
 
        self._original_vendor = None
924
 
        self._homedir = None
925
 
        self._server_homedir = None
926
 
        self._listener = None
927
 
        self._root = None
928
 
        self._vendor = 'none'
929
 
        # sftp server logs
930
 
        self.logs = []
931
 
 
932
 
    def _get_sftp_url(self, path):
933
 
        """Calculate an sftp url to this server for path."""
934
 
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
935
 
 
936
 
    def log(self, message):
937
 
        """StubServer uses this to log when a new server is created."""
938
 
        self.logs.append(message)
939
 
 
940
 
    def _run_server(self, s, stop_event):
941
 
        ssh_server = paramiko.Transport(s)
942
 
        key_file = os.path.join(self._homedir, 'test_rsa.key')
943
 
        file(key_file, 'w').write(STUB_SERVER_KEY)
944
 
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
945
 
        ssh_server.add_server_key(host_key)
946
 
        server = StubServer(self)
947
 
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
948
 
                                         StubSFTPServer, root=self._root,
949
 
                                         home=self._server_homedir)
950
 
        event = threading.Event()
951
 
        ssh_server.start_server(event, server)
952
 
        event.wait(5.0)
953
 
        stop_event.wait(30.0)
954
 
    
955
 
    def setUp(self):
956
 
        global _ssh_vendor
957
 
        self._original_vendor = _ssh_vendor
958
 
        _ssh_vendor = self._vendor
959
 
        self._homedir = os.getcwd()
960
 
        if self._server_homedir is None:
961
 
            self._server_homedir = self._homedir
962
 
        self._root = '/'
963
 
        # FIXME WINDOWS: _root should be _server_homedir[0]:/
964
 
        self._listener = SingleListener(self._run_server)
965
 
        self._listener.setDaemon(True)
966
 
        self._listener.start()
967
 
 
968
 
    def tearDown(self):
969
 
        """See bzrlib.transport.Server.tearDown."""
970
 
        global _ssh_vendor
971
 
        self._listener.stop()
972
 
        _ssh_vendor = self._original_vendor
973
 
 
974
 
 
975
 
class SFTPFullAbsoluteServer(SFTPServer):
976
 
    """A test server for sftp transports, using absolute urls and ssh."""
977
 
 
978
 
    def get_url(self):
979
 
        """See bzrlib.transport.Server.get_url."""
980
 
        return self._get_sftp_url(urlutils.escape(self._homedir[1:]))
981
 
 
982
 
 
983
 
class SFTPServerWithoutSSH(SFTPServer):
984
 
    """An SFTP server that uses a simple TCP socket pair rather than SSH."""
985
 
 
986
 
    def __init__(self):
987
 
        super(SFTPServerWithoutSSH, self).__init__()
988
 
        self._vendor = 'loopback'
989
 
 
990
 
    def _run_server(self, sock, stop_event):
991
 
        class FakeChannel(object):
992
 
            def get_transport(self):
993
 
                return self
994
 
            def get_log_channel(self):
995
 
                return 'paramiko'
996
 
            def get_name(self):
997
 
                return '1'
998
 
            def get_hexdump(self):
999
 
                return False
1000
 
            def close(self):
1001
 
                pass
1002
 
 
1003
 
        server = paramiko.SFTPServer(FakeChannel(), 'sftp', StubServer(self), StubSFTPServer,
1004
 
                                     root=self._root, home=self._server_homedir)
1005
 
        server.start_subsystem('sftp', None, sock)
1006
 
        server.finish_subsystem()
1007
 
 
1008
 
 
1009
 
class SFTPAbsoluteServer(SFTPServerWithoutSSH):
1010
 
    """A test server for sftp transports, using absolute urls."""
1011
 
 
1012
 
    def get_url(self):
1013
 
        """See bzrlib.transport.Server.get_url."""
1014
 
        return self._get_sftp_url(urlutils.escape(self._homedir[1:]))
1015
 
 
1016
 
 
1017
 
class SFTPHomeDirServer(SFTPServerWithoutSSH):
1018
 
    """A test server for sftp transports, using homedir relative urls."""
1019
 
 
1020
 
    def get_url(self):
1021
 
        """See bzrlib.transport.Server.get_url."""
1022
 
        return self._get_sftp_url("~/")
1023
 
 
1024
 
 
1025
 
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
1026
 
    """A test servere for sftp transports, using absolute urls to non-home."""
1027
 
 
1028
 
    def setUp(self):
1029
 
        self._server_homedir = '/dev/noone/runs/tests/here'
1030
 
        super(SFTPSiblingAbsoluteServer, self).setUp()
1031
 
 
1032
 
 
1033
 
def get_test_permutations():
1034
 
    """Return the permutations to be used in testing."""
1035
 
    return [(SFTPTransport, SFTPAbsoluteServer),
1036
 
            (SFTPTransport, SFTPHomeDirServer),
1037
 
            (SFTPTransport, SFTPSiblingAbsoluteServer),
1038
 
            ]