← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: John Arbash Meinel
  • Date: 2006-01-23 22:33:23 UTC
  • mto: This revision was merged to the branch mainline in revision 1551.
  • Revision ID: john@arbash-meinel.com-20060123223323-16eb865383bf650a
From Jari Alto: Makefile fixes (clean target error suppression)

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>, Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Implementation of Transport over SFTP, using paramiko."""
 
18
 
 
19
import errno
 
20
import getpass
 
21
import os
 
22
import re
 
23
import stat
 
24
import sys
 
25
import urllib
 
26
import urlparse
 
27
import time
 
28
import random
 
29
import subprocess
 
30
import weakref
 
31
 
 
32
from bzrlib.config import config_dir, ensure_config_dir_exists
 
33
from bzrlib.errors import (ConnectionError,
 
34
                           FileExists, 
 
35
                           TransportNotPossible, NoSuchFile, PathNotChild,
 
36
                           TransportError,
 
37
                           LockError
 
38
                           )
 
39
from bzrlib.osutils import pathjoin, fancy_rename
 
40
from bzrlib.trace import mutter, warning, error
 
41
from bzrlib.transport import Transport, Server, urlescape
 
42
import bzrlib.ui
 
43
 
 
44
try:
 
45
    import paramiko
 
46
except ImportError:
 
47
    error('The SFTP transport requires paramiko.')
 
48
    raise
 
49
else:
 
50
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
 
51
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
 
52
                               CMD_HANDLE, CMD_OPEN)
 
53
    from paramiko.sftp_attr import SFTPAttributes
 
54
    from paramiko.sftp_file import SFTPFile
 
55
    from paramiko.sftp_client import SFTPClient
 
56
 
 
57
if 'sftp' not in urlparse.uses_netloc: urlparse.uses_netloc.append('sftp')
 
58
 
 
59
 
 
60
_close_fds = True
 
61
if sys.platform == 'win32':
 
62
    # close_fds not supported on win32
 
63
    _close_fds = False
 
64
 
 
65
_ssh_vendor = None
 
66
def _get_ssh_vendor():
 
67
    """Find out what version of SSH is on the system."""
 
68
    global _ssh_vendor
 
69
    if _ssh_vendor is not None:
 
70
        return _ssh_vendor
 
71
 
 
72
    _ssh_vendor = 'none'
 
73
 
 
74
    try:
 
75
        p = subprocess.Popen(['ssh', '-V'],
 
76
                             close_fds=_close_fds,
 
77
                             stdin=subprocess.PIPE,
 
78
                             stdout=subprocess.PIPE,
 
79
                             stderr=subprocess.PIPE)
 
80
        returncode = p.returncode
 
81
        stdout, stderr = p.communicate()
 
82
    except OSError:
 
83
        returncode = -1
 
84
        stdout = stderr = ''
 
85
    if 'OpenSSH' in stderr:
 
86
        mutter('ssh implementation is OpenSSH')
 
87
        _ssh_vendor = 'openssh'
 
88
    elif 'SSH Secure Shell' in stderr:
 
89
        mutter('ssh implementation is SSH Corp.')
 
90
        _ssh_vendor = 'ssh'
 
91
 
 
92
    if _ssh_vendor != 'none':
 
93
        return _ssh_vendor
 
94
 
 
95
    # XXX: 20051123 jamesh
 
96
    # A check for putty's plink or lsh would go here.
 
97
 
 
98
    mutter('falling back to paramiko implementation')
 
99
    return _ssh_vendor
 
100
 
 
101
 
 
102
class SFTPSubprocess:
 
103
    """A socket-like object that talks to an ssh subprocess via pipes."""
 
104
    def __init__(self, hostname, vendor, port=None, user=None):
 
105
        assert vendor in ['openssh', 'ssh']
 
106
        if vendor == 'openssh':
 
107
            args = ['ssh',
 
108
                    '-oForwardX11=no', '-oForwardAgent=no',
 
109
                    '-oClearAllForwardings=yes', '-oProtocol=2',
 
110
                    '-oNoHostAuthenticationForLocalhost=yes']
 
111
            if port is not None:
 
112
                args.extend(['-p', str(port)])
 
113
            if user is not None:
 
114
                args.extend(['-l', user])
 
115
            args.extend(['-s', hostname, 'sftp'])
 
116
        elif vendor == 'ssh':
 
117
            args = ['ssh', '-x']
 
118
            if port is not None:
 
119
                args.extend(['-p', str(port)])
 
120
            if user is not None:
 
121
                args.extend(['-l', user])
 
122
            args.extend(['-s', 'sftp', hostname])
 
123
 
 
124
        self.proc = subprocess.Popen(args, close_fds=_close_fds,
 
125
                                     stdin=subprocess.PIPE,
 
126
                                     stdout=subprocess.PIPE)
 
127
 
 
128
    def send(self, data):
 
129
        return os.write(self.proc.stdin.fileno(), data)
 
130
 
 
131
    def recv_ready(self):
 
132
        # TODO: jam 20051215 this function is necessary to support the
 
133
        # pipelined() function. In reality, it probably should use
 
134
        # poll() or select() to actually return if there is data
 
135
        # available, otherwise we probably don't get any benefit
 
136
        return True
 
137
 
 
138
    def recv(self, count):
 
139
        return os.read(self.proc.stdout.fileno(), count)
 
140
 
 
141
    def close(self):
 
142
        self.proc.stdin.close()
 
143
        self.proc.stdout.close()
 
144
        self.proc.wait()
 
145
 
 
146
 
 
147
SYSTEM_HOSTKEYS = {}
 
148
BZR_HOSTKEYS = {}
 
149
 
 
150
# This is a weakref dictionary, so that we can reuse connections
 
151
# that are still active. Long term, it might be nice to have some
 
152
# sort of expiration policy, such as disconnect if inactive for
 
153
# X seconds. But that requires a lot more fanciness.
 
154
_connected_hosts = weakref.WeakValueDictionary()
 
155
 
 
156
def load_host_keys():
 
157
    """
 
158
    Load system host keys (probably doesn't work on windows) and any
 
159
    "discovered" keys from previous sessions.
 
160
    """
 
161
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
162
    try:
 
163
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
164
    except Exception, e:
 
165
        mutter('failed to load system host keys: ' + str(e))
 
166
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
167
    try:
 
168
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
 
169
    except Exception, e:
 
170
        mutter('failed to load bzr host keys: ' + str(e))
 
171
        save_host_keys()
 
172
 
 
173
def save_host_keys():
 
174
    """
 
175
    Save "discovered" host keys in $(config)/ssh_host_keys/.
 
176
    """
 
177
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
178
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
179
    ensure_config_dir_exists()
 
180
 
 
181
    try:
 
182
        f = open(bzr_hostkey_path, 'w')
 
183
        f.write('# SSH host keys collected by bzr\n')
 
184
        for hostname, keys in BZR_HOSTKEYS.iteritems():
 
185
            for keytype, key in keys.iteritems():
 
186
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
 
187
        f.close()
 
188
    except IOError, e:
 
189
        mutter('failed to save bzr host keys: ' + str(e))
 
190
 
 
191
 
 
192
class SFTPLock(object):
 
193
    """This fakes a lock in a remote location."""
 
194
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
 
195
    def __init__(self, path, transport):
 
196
        assert isinstance(transport, SFTPTransport)
 
197
 
 
198
        self.lock_file = None
 
199
        self.path = path
 
200
        self.lock_path = path + '.write-lock'
 
201
        self.transport = transport
 
202
        try:
 
203
            # RBC 20060103 FIXME should we be using private methods here ?
 
204
            abspath = transport._remote_path(self.lock_path)
 
205
            self.lock_file = transport._sftp_open_exclusive(abspath)
 
206
        except FileExists:
 
207
            raise LockError('File %r already locked' % (self.path,))
 
208
 
 
209
    def __del__(self):
 
210
        """Should this warn, or actually try to cleanup?"""
 
211
        if self.lock_file:
 
212
            warn("SFTPLock %r not explicitly unlocked" % (self.path,))
 
213
            self.unlock()
 
214
 
 
215
    def unlock(self):
 
216
        if not self.lock_file:
 
217
            return
 
218
        self.lock_file.close()
 
219
        self.lock_file = None
 
220
        try:
 
221
            self.transport.delete(self.lock_path)
 
222
        except (NoSuchFile,):
 
223
            # What specific errors should we catch here?
 
224
            pass
 
225
 
 
226
 
 
227
 
 
228
class SFTPTransport (Transport):
 
229
    """
 
230
    Transport implementation for SFTP access.
 
231
    """
 
232
    _do_prefetch = False # Right now Paramiko's prefetch support causes things to hang
 
233
 
 
234
    def __init__(self, base, clone_from=None):
 
235
        assert base.startswith('sftp://')
 
236
        self._parse_url(base)
 
237
        base = self._unparse_url()
 
238
        if base[-1] != '/':
 
239
            base = base + '/'
 
240
        super(SFTPTransport, self).__init__(base)
 
241
        if clone_from is None:
 
242
            self._sftp_connect()
 
243
        else:
 
244
            # use the same ssh connection, etc
 
245
            self._sftp = clone_from._sftp
 
246
        # super saves 'self.base'
 
247
    
 
248
    def should_cache(self):
 
249
        """
 
250
        Return True if the data pulled across should be cached locally.
 
251
        """
 
252
        return True
 
253
 
 
254
    def clone(self, offset=None):
 
255
        """
 
256
        Return a new SFTPTransport with root at self.base + offset.
 
257
        We share the same SFTP session between such transports, because it's
 
258
        fairly expensive to set them up.
 
259
        """
 
260
        if offset is None:
 
261
            return SFTPTransport(self.base, self)
 
262
        else:
 
263
            return SFTPTransport(self.abspath(offset), self)
 
264
 
 
265
    def abspath(self, relpath):
 
266
        """
 
267
        Return the full url to the given relative path.
 
268
        
 
269
        @param relpath: the relative path or path components
 
270
        @type relpath: str or list
 
271
        """
 
272
        return self._unparse_url(self._remote_path(relpath))
 
273
    
 
274
    def _remote_path(self, relpath):
 
275
        """Return the path to be passed along the sftp protocol for relpath.
 
276
        
 
277
        relpath is a urlencoded string.
 
278
        """
 
279
        # FIXME: share the common code across transports
 
280
        assert isinstance(relpath, basestring)
 
281
        relpath = urllib.unquote(relpath).split('/')
 
282
        basepath = self._path.split('/')
 
283
        if len(basepath) > 0 and basepath[-1] == '':
 
284
            basepath = basepath[:-1]
 
285
 
 
286
        for p in relpath:
 
287
            if p == '..':
 
288
                if len(basepath) == 0:
 
289
                    # In most filesystems, a request for the parent
 
290
                    # of root, just returns root.
 
291
                    continue
 
292
                basepath.pop()
 
293
            elif p == '.':
 
294
                continue # No-op
 
295
            else:
 
296
                basepath.append(p)
 
297
 
 
298
        path = '/'.join(basepath)
 
299
        return path
 
300
 
 
301
    def relpath(self, abspath):
 
302
        username, password, host, port, path = self._split_url(abspath)
 
303
        error = []
 
304
        if (username != self._username):
 
305
            error.append('username mismatch')
 
306
        if (host != self._host):
 
307
            error.append('host mismatch')
 
308
        if (port != self._port):
 
309
            error.append('port mismatch')
 
310
        if (not path.startswith(self._path)):
 
311
            error.append('path mismatch')
 
312
        if error:
 
313
            extra = ': ' + ', '.join(error)
 
314
            raise PathNotChild(abspath, self.base, extra=extra)
 
315
        pl = len(self._path)
 
316
        return path[pl:].strip('/')
 
317
 
 
318
    def has(self, relpath):
 
319
        """
 
320
        Does the target location exist?
 
321
        """
 
322
        try:
 
323
            self._sftp.stat(self._remote_path(relpath))
 
324
            return True
 
325
        except IOError:
 
326
            return False
 
327
 
 
328
    def get(self, relpath, decode=False):
 
329
        """
 
330
        Get the file at the given relative path.
 
331
 
 
332
        :param relpath: The relative path to the file
 
333
        """
 
334
        try:
 
335
            path = self._remote_path(relpath)
 
336
            f = self._sftp.file(path, mode='rb')
 
337
            if self._do_prefetch and hasattr(f, 'prefetch'):
 
338
                f.prefetch()
 
339
            return f
 
340
        except (IOError, paramiko.SSHException), e:
 
341
            self._translate_io_exception(e, path, ': error retrieving')
 
342
 
 
343
    def get_partial(self, relpath, start, length=None):
 
344
        """
 
345
        Get just part of a file.
 
346
 
 
347
        :param relpath: Path to the file, relative to base
 
348
        :param start: The starting position to read from
 
349
        :param length: The length to read. A length of None indicates
 
350
                       read to the end of the file.
 
351
        :return: A file-like object containing at least the specified bytes.
 
352
                 Some implementations may return objects which can be read
 
353
                 past this length, but this is not guaranteed.
 
354
        """
 
355
        # TODO: implement get_partial_multi to help with knit support
 
356
        f = self.get(relpath)
 
357
        f.seek(start)
 
358
        if self._do_prefetch and hasattr(f, 'prefetch'):
 
359
            f.prefetch()
 
360
        return f
 
361
 
 
362
    def put(self, relpath, f, mode=None):
 
363
        """
 
364
        Copy the file-like or string object into the location.
 
365
 
 
366
        :param relpath: Location to put the contents, relative to base.
 
367
        :param f:       File-like or string object.
 
368
        :param mode: The final mode for the file
 
369
        """
 
370
        final_path = self._remote_path(relpath)
 
371
        self._put(final_path, f, mode=mode)
 
372
 
 
373
    def _put(self, abspath, f, mode=None):
 
374
        """Helper function so both put() and copy_abspaths can reuse the code"""
 
375
        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
 
376
                        os.getpid(), random.randint(0,0x7FFFFFFF))
 
377
        fout = self._sftp_open_exclusive(tmp_abspath, mode=mode)
 
378
        closed = False
 
379
        try:
 
380
            try:
 
381
                fout.set_pipelined(True)
 
382
                self._pump(f, fout)
 
383
            except (IOError, paramiko.SSHException), e:
 
384
                self._translate_io_exception(e, tmp_abspath)
 
385
            if mode is not None:
 
386
                self._sftp.chmod(tmp_abspath, mode)
 
387
            fout.close()
 
388
            closed = True
 
389
            self._rename(tmp_abspath, abspath)
 
390
        except Exception, e:
 
391
            # If we fail, try to clean up the temporary file
 
392
            # before we throw the exception
 
393
            # but don't let another exception mess things up
 
394
            # Write out the traceback, because otherwise
 
395
            # the catch and throw destroys it
 
396
            import traceback
 
397
            mutter(traceback.format_exc())
 
398
            try:
 
399
                if not closed:
 
400
                    fout.close()
 
401
                self._sftp.remove(tmp_abspath)
 
402
            except:
 
403
                # raise the saved except
 
404
                raise e
 
405
            # raise the original with its traceback if we can.
 
406
            raise
 
407
 
 
408
    def iter_files_recursive(self):
 
409
        """Walk the relative paths of all files in this transport."""
 
410
        queue = list(self.list_dir('.'))
 
411
        while queue:
 
412
            relpath = urllib.quote(queue.pop(0))
 
413
            st = self.stat(relpath)
 
414
            if stat.S_ISDIR(st.st_mode):
 
415
                for i, basename in enumerate(self.list_dir(relpath)):
 
416
                    queue.insert(i, relpath+'/'+basename)
 
417
            else:
 
418
                yield relpath
 
419
 
 
420
    def mkdir(self, relpath, mode=None):
 
421
        """Create a directory at the given path."""
 
422
        try:
 
423
            path = self._remote_path(relpath)
 
424
            # In the paramiko documentation, it says that passing a mode flag 
 
425
            # will filtered against the server umask.
 
426
            # StubSFTPServer does not do this, which would be nice, because it is
 
427
            # what we really want :)
 
428
            # However, real servers do use umask, so we really should do it that way
 
429
            self._sftp.mkdir(path)
 
430
            if mode is not None:
 
431
                self._sftp.chmod(path, mode=mode)
 
432
        except (paramiko.SSHException, IOError), e:
 
433
            self._translate_io_exception(e, path, ': unable to mkdir',
 
434
                failure_exc=FileExists)
 
435
 
 
436
    def _translate_io_exception(self, e, path, more_info='', failure_exc=NoSuchFile):
 
437
        """Translate a paramiko or IOError into a friendlier exception.
 
438
 
 
439
        :param e: The original exception
 
440
        :param path: The path in question when the error is raised
 
441
        :param more_info: Extra information that can be included,
 
442
                          such as what was going on
 
443
        :param failure_exc: Paramiko has the super fun ability to raise completely
 
444
                           opaque errors that just set "e.args = ('Failure',)" with
 
445
                           no more information.
 
446
                           This sometimes means FileExists, but it also sometimes
 
447
                           means NoSuchFile
 
448
        """
 
449
        # paramiko seems to generate detailless errors.
 
450
        self._translate_error(e, path, raise_generic=False)
 
451
        if hasattr(e, 'args'):
 
452
            if (e.args == ('No such file or directory',) or
 
453
                e.args == ('No such file',)):
 
454
                raise NoSuchFile(path, str(e) + more_info)
 
455
            if (e.args == ('mkdir failed',)):
 
456
                raise FileExists(path, str(e) + more_info)
 
457
            # strange but true, for the paramiko server.
 
458
            if (e.args == ('Failure',)):
 
459
                raise failure_exc(path, str(e) + more_info)
 
460
            mutter('Raising exception with args %s', e.args)
 
461
        if hasattr(e, 'errno'):
 
462
            mutter('Raising exception with errno %s', e.errno)
 
463
        raise e
 
464
 
 
465
    def append(self, relpath, f):
 
466
        """
 
467
        Append the text in the file-like object into the final
 
468
        location.
 
469
        """
 
470
        try:
 
471
            path = self._remote_path(relpath)
 
472
            fout = self._sftp.file(path, 'ab')
 
473
            self._pump(f, fout)
 
474
        except (IOError, paramiko.SSHException), e:
 
475
            self._translate_io_exception(e, relpath, ': unable to append')
 
476
 
 
477
    def copy(self, rel_from, rel_to):
 
478
        """Copy the item at rel_from to the location at rel_to"""
 
479
        path_from = self._remote_path(rel_from)
 
480
        path_to = self._remote_path(rel_to)
 
481
        self._copy_abspaths(path_from, path_to)
 
482
 
 
483
    def _copy_abspaths(self, path_from, path_to, mode=None):
 
484
        """Copy files given an absolute path
 
485
 
 
486
        :param path_from: Path on remote server to read
 
487
        :param path_to: Path on remote server to write
 
488
        :return: None
 
489
 
 
490
        TODO: Should the destination location be atomically created?
 
491
              This has not been specified
 
492
        TODO: This should use some sort of remote copy, rather than
 
493
              pulling the data locally, and then writing it remotely
 
494
        """
 
495
        try:
 
496
            fin = self._sftp.file(path_from, 'rb')
 
497
            try:
 
498
                self._put(path_to, fin, mode=mode)
 
499
            finally:
 
500
                fin.close()
 
501
        except (IOError, paramiko.SSHException), e:
 
502
            self._translate_io_exception(e, path_from, ': unable copy to: %r' % path_to)
 
503
 
 
504
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
505
        """Copy a set of entries from self into another Transport.
 
506
 
 
507
        :param relpaths: A list/generator of entries to be copied.
 
508
        """
 
509
        if isinstance(other, SFTPTransport) and other._sftp is self._sftp:
 
510
            # Both from & to are on the same remote filesystem
 
511
            # We can use a remote copy, instead of pulling locally, and pushing
 
512
 
 
513
            total = self._get_total(relpaths)
 
514
            count = 0
 
515
            for path in relpaths:
 
516
                path_from = self._remote_path(relpath)
 
517
                path_to = other._remote_path(relpath)
 
518
                self._update_pb(pb, 'copy-to', count, total)
 
519
                self._copy_abspaths(path_from, path_to, mode=mode)
 
520
                count += 1
 
521
            return count
 
522
        else:
 
523
            return super(SFTPTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
524
 
 
525
    def _rename(self, abs_from, abs_to):
 
526
        """Do a fancy rename on the remote server.
 
527
        
 
528
        Using the implementation provided by osutils.
 
529
        """
 
530
        try:
 
531
            fancy_rename(abs_from, abs_to,
 
532
                    rename_func=self._sftp.rename,
 
533
                    unlink_func=self._sftp.remove)
 
534
        except (IOError, paramiko.SSHException), e:
 
535
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
 
536
 
 
537
    def move(self, rel_from, rel_to):
 
538
        """Move the item at rel_from to the location at rel_to"""
 
539
        path_from = self._remote_path(rel_from)
 
540
        path_to = self._remote_path(rel_to)
 
541
        self._rename(path_from, path_to)
 
542
 
 
543
    def delete(self, relpath):
 
544
        """Delete the item at relpath"""
 
545
        path = self._remote_path(relpath)
 
546
        try:
 
547
            self._sftp.remove(path)
 
548
        except (IOError, paramiko.SSHException), e:
 
549
            self._translate_io_exception(e, path, ': unable to delete')
 
550
            
 
551
    def listable(self):
 
552
        """Return True if this store supports listing."""
 
553
        return True
 
554
 
 
555
    def list_dir(self, relpath):
 
556
        """
 
557
        Return a list of all files at the given location.
 
558
        """
 
559
        # does anything actually use this?
 
560
        path = self._remote_path(relpath)
 
561
        try:
 
562
            return self._sftp.listdir(path)
 
563
        except (IOError, paramiko.SSHException), e:
 
564
            self._translate_io_exception(e, path, ': failed to list_dir')
 
565
 
 
566
    def stat(self, relpath):
 
567
        """Return the stat information for a file."""
 
568
        path = self._remote_path(relpath)
 
569
        try:
 
570
            return self._sftp.stat(path)
 
571
        except (IOError, paramiko.SSHException), e:
 
572
            self._translate_io_exception(e, path, ': unable to stat')
 
573
 
 
574
    def lock_read(self, relpath):
 
575
        """
 
576
        Lock the given file for shared (read) access.
 
577
        :return: A lock object, which has an unlock() member function
 
578
        """
 
579
        # FIXME: there should be something clever i can do here...
 
580
        class BogusLock(object):
 
581
            def __init__(self, path):
 
582
                self.path = path
 
583
            def unlock(self):
 
584
                pass
 
585
        return BogusLock(relpath)
 
586
 
 
587
    def lock_write(self, relpath):
 
588
        """
 
589
        Lock the given file for exclusive (write) access.
 
590
        WARNING: many transports do not support this, so trying avoid using it
 
591
 
 
592
        :return: A lock object, which has an unlock() member function
 
593
        """
 
594
        # This is a little bit bogus, but basically, we create a file
 
595
        # which should not already exist, and if it does, we assume
 
596
        # that there is a lock, and if it doesn't, the we assume
 
597
        # that we have taken the lock.
 
598
        return SFTPLock(relpath, self)
 
599
 
 
600
 
 
601
    def _unparse_url(self, path=None):
 
602
        if path is None:
 
603
            path = self._path
 
604
        path = urllib.quote(path)
 
605
        if path.startswith('/'):
 
606
            path = '/%2F' + path[1:]
 
607
        else:
 
608
            path = '/' + path
 
609
        netloc = urllib.quote(self._host)
 
610
        if self._username is not None:
 
611
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
612
        if self._port is not None:
 
613
            netloc = '%s:%d' % (netloc, self._port)
 
614
 
 
615
        return urlparse.urlunparse(('sftp', netloc, path, '', '', ''))
 
616
 
 
617
    def _split_url(self, url):
 
618
        if isinstance(url, unicode):
 
619
            url = url.encode('utf-8')
 
620
        (scheme, netloc, path, params,
 
621
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
622
        assert scheme == 'sftp'
 
623
        username = password = host = port = None
 
624
        if '@' in netloc:
 
625
            username, host = netloc.split('@', 1)
 
626
            if ':' in username:
 
627
                username, password = username.split(':', 1)
 
628
                password = urllib.unquote(password)
 
629
            username = urllib.unquote(username)
 
630
        else:
 
631
            host = netloc
 
632
 
 
633
        if ':' in host:
 
634
            host, port = host.rsplit(':', 1)
 
635
            try:
 
636
                port = int(port)
 
637
            except ValueError:
 
638
                # TODO: Should this be ConnectionError?
 
639
                raise TransportError('%s: invalid port number' % port)
 
640
        host = urllib.unquote(host)
 
641
 
 
642
        path = urllib.unquote(path)
 
643
 
 
644
        # the initial slash should be removed from the path, and treated
 
645
        # as a homedir relative path (the path begins with a double slash
 
646
        # if it is absolute).
 
647
        # see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
 
648
        if path.startswith('/'):
 
649
            path = path[1:]
 
650
 
 
651
        return (username, password, host, port, path)
 
652
 
 
653
    def _parse_url(self, url):
 
654
        (self._username, self._password,
 
655
         self._host, self._port, self._path) = self._split_url(url)
 
656
 
 
657
    def _sftp_connect(self):
 
658
        """Connect to the remote sftp server.
 
659
        After this, self._sftp should have a valid connection (or
 
660
        we raise an TransportError 'could not connect').
 
661
 
 
662
        TODO: Raise a more reasonable ConnectionFailed exception
 
663
        """
 
664
        global _connected_hosts
 
665
 
 
666
        idx = (self._host, self._port, self._username)
 
667
        try:
 
668
            self._sftp = _connected_hosts[idx]
 
669
            return
 
670
        except KeyError:
 
671
            pass
 
672
        
 
673
        vendor = _get_ssh_vendor()
 
674
        if vendor != 'none':
 
675
            sock = SFTPSubprocess(self._host, vendor, self._port,
 
676
                                  self._username)
 
677
            self._sftp = SFTPClient(sock)
 
678
        else:
 
679
            self._paramiko_connect()
 
680
 
 
681
        _connected_hosts[idx] = self._sftp
 
682
 
 
683
    def _paramiko_connect(self):
 
684
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
685
        
 
686
        load_host_keys()
 
687
 
 
688
        try:
 
689
            t = paramiko.Transport((self._host, self._port or 22))
 
690
            t.start_client()
 
691
        except paramiko.SSHException, e:
 
692
            raise ConnectionError('Unable to reach SSH host %s:%d' %
 
693
                                  (self._host, self._port), e)
 
694
            
 
695
        server_key = t.get_remote_server_key()
 
696
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
 
697
        keytype = server_key.get_name()
 
698
        if SYSTEM_HOSTKEYS.has_key(self._host) and SYSTEM_HOSTKEYS[self._host].has_key(keytype):
 
699
            our_server_key = SYSTEM_HOSTKEYS[self._host][keytype]
 
700
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
701
        elif BZR_HOSTKEYS.has_key(self._host) and BZR_HOSTKEYS[self._host].has_key(keytype):
 
702
            our_server_key = BZR_HOSTKEYS[self._host][keytype]
 
703
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
704
        else:
 
705
            warning('Adding %s host key for %s: %s' % (keytype, self._host, server_key_hex))
 
706
            if not BZR_HOSTKEYS.has_key(self._host):
 
707
                BZR_HOSTKEYS[self._host] = {}
 
708
            BZR_HOSTKEYS[self._host][keytype] = server_key
 
709
            our_server_key = server_key
 
710
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
711
            save_host_keys()
 
712
        if server_key != our_server_key:
 
713
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
 
714
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
715
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
 
716
                (self._host, our_server_key_hex, server_key_hex),
 
717
                ['Try editing %s or %s' % (filename1, filename2)])
 
718
 
 
719
        self._sftp_auth(t)
 
720
        
 
721
        try:
 
722
            self._sftp = t.open_sftp_client()
 
723
        except paramiko.SSHException, e:
 
724
            raise ConnectionError('Unable to start sftp client %s:%d' %
 
725
                                  (self._host, self._port), e)
 
726
 
 
727
    def _sftp_auth(self, transport):
 
728
        # paramiko requires a username, but it might be none if nothing was supplied
 
729
        # use the local username, just in case.
 
730
        # We don't override self._username, because if we aren't using paramiko,
 
731
        # the username might be specified in ~/.ssh/config and we don't want to
 
732
        # force it to something else
 
733
        # Also, it would mess up the self.relpath() functionality
 
734
        username = self._username or getpass.getuser()
 
735
 
 
736
        # Paramiko tries to open a socket.AF_UNIX in order to connect
 
737
        # to ssh-agent. That attribute doesn't exist on win32 (it does in cygwin)
 
738
        # so we get an AttributeError exception. For now, just don't try to
 
739
        # connect to an agent if we are on win32
 
740
        if sys.platform != 'win32':
 
741
            agent = paramiko.Agent()
 
742
            for key in agent.get_keys():
 
743
                mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
 
744
                try:
 
745
                    transport.auth_publickey(username, key)
 
746
                    return
 
747
                except paramiko.SSHException, e:
 
748
                    pass
 
749
        
 
750
        # okay, try finding id_rsa or id_dss?  (posix only)
 
751
        if self._try_pkey_auth(transport, paramiko.RSAKey, username, 'id_rsa'):
 
752
            return
 
753
        if self._try_pkey_auth(transport, paramiko.DSSKey, username, 'id_dsa'):
 
754
            return
 
755
 
 
756
        if self._password:
 
757
            try:
 
758
                transport.auth_password(username, self._password)
 
759
                return
 
760
            except paramiko.SSHException, e:
 
761
                pass
 
762
 
 
763
            # FIXME: Don't keep a password held in memory if you can help it
 
764
            #self._password = None
 
765
 
 
766
        # give up and ask for a password
 
767
        password = bzrlib.ui.ui_factory.get_password(
 
768
                prompt='SSH %(user)s@%(host)s password',
 
769
                user=username, host=self._host)
 
770
        try:
 
771
            transport.auth_password(username, password)
 
772
        except paramiko.SSHException, e:
 
773
            raise ConnectionError('Unable to authenticate to SSH host as %s@%s' %
 
774
                                  (username, self._host), e)
 
775
 
 
776
    def _try_pkey_auth(self, transport, pkey_class, username, filename):
 
777
        filename = os.path.expanduser('~/.ssh/' + filename)
 
778
        try:
 
779
            key = pkey_class.from_private_key_file(filename)
 
780
            transport.auth_publickey(username, key)
 
781
            return True
 
782
        except paramiko.PasswordRequiredException:
 
783
            password = bzrlib.ui.ui_factory.get_password(
 
784
                    prompt='SSH %(filename)s password',
 
785
                    filename=filename)
 
786
            try:
 
787
                key = pkey_class.from_private_key_file(filename, password)
 
788
                transport.auth_publickey(username, key)
 
789
                return True
 
790
            except paramiko.SSHException:
 
791
                mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
 
792
        except paramiko.SSHException:
 
793
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
 
794
        except IOError:
 
795
            pass
 
796
        return False
 
797
 
 
798
    def _sftp_open_exclusive(self, abspath, mode=None):
 
799
        """Open a remote path exclusively.
 
800
 
 
801
        SFTP supports O_EXCL (SFTP_FLAG_EXCL), which fails if
 
802
        the file already exists. However it does not expose this
 
803
        at the higher level of SFTPClient.open(), so we have to
 
804
        sneak away with it.
 
805
 
 
806
        WARNING: This breaks the SFTPClient abstraction, so it
 
807
        could easily break against an updated version of paramiko.
 
808
 
 
809
        :param abspath: The remote absolute path where the file should be opened
 
810
        :param mode: The mode permissions bits for the new file
 
811
        """
 
812
        path = self._sftp._adjust_cwd(abspath)
 
813
        attr = SFTPAttributes()
 
814
        if mode is not None:
 
815
            attr.st_mode = mode
 
816
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
 
817
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
 
818
        try:
 
819
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
 
820
            if t != CMD_HANDLE:
 
821
                raise TransportError('Expected an SFTP handle')
 
822
            handle = msg.get_string()
 
823
            return SFTPFile(self._sftp, handle, 'wb', -1)
 
824
        except (paramiko.SSHException, IOError), e:
 
825
            self._translate_io_exception(e, abspath, ': unable to open',
 
826
                failure_exc=FileExists)
 
827
 
 
828
 
 
829
# ------------- server test implementation --------------
 
830
import socket
 
831
import threading
 
832
 
 
833
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
 
834
 
 
835
STUB_SERVER_KEY = """
 
836
-----BEGIN RSA PRIVATE KEY-----
 
837
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
 
838
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
 
839
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
 
840
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
 
841
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
 
842
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
 
843
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
 
844
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
 
845
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
 
846
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
 
847
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
 
848
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
 
849
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
 
850
-----END RSA PRIVATE KEY-----
 
851
"""
 
852
    
 
853
 
 
854
class SingleListener(threading.Thread):
 
855
 
 
856
    def __init__(self, callback):
 
857
        threading.Thread.__init__(self)
 
858
        self._callback = callback
 
859
        self._socket = socket.socket()
 
860
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
861
        self._socket.bind(('localhost', 0))
 
862
        self._socket.listen(1)
 
863
        self.port = self._socket.getsockname()[1]
 
864
        self.stop_event = threading.Event()
 
865
 
 
866
    def run(self):
 
867
        s, _ = self._socket.accept()
 
868
        # now close the listen socket
 
869
        self._socket.close()
 
870
        self._callback(s, self.stop_event)
 
871
    
 
872
    def stop(self):
 
873
        self.stop_event.set()
 
874
        # We should consider waiting for the other thread
 
875
        # to stop, because otherwise we get spurious
 
876
        #   bzr: ERROR: Socket exception: Connection reset by peer (54)
 
877
        # because the test suite finishes before the thread has a chance
 
878
        # to close. (Especially when only running a few tests)
 
879
        
 
880
        
 
881
class SFTPServer(Server):
 
882
    """Common code for SFTP server facilities."""
 
883
 
 
884
    def _get_sftp_url(self, path):
 
885
        """Calculate a sftp url to this server for path."""
 
886
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
 
887
 
 
888
    def __init__(self):
 
889
        self._original_vendor = None
 
890
        self._homedir = None
 
891
        self._server_homedir = None
 
892
        self._listener = None
 
893
        self._root = None
 
894
        # sftp server logs
 
895
        self.logs = []
 
896
 
 
897
    def log(self, message):
 
898
        """What to do here? do we need this? Its for the StubServer.."""
 
899
        self.logs.append(message)
 
900
 
 
901
    def _run_server(self, s, stop_event):
 
902
        ssh_server = paramiko.Transport(s)
 
903
        key_file = os.path.join(self._homedir, 'test_rsa.key')
 
904
        file(key_file, 'w').write(STUB_SERVER_KEY)
 
905
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
 
906
        ssh_server.add_server_key(host_key)
 
907
        server = StubServer(self)
 
908
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
 
909
                                         StubSFTPServer, root=self._root,
 
910
                                         home=self._server_homedir)
 
911
        event = threading.Event()
 
912
        ssh_server.start_server(event, server)
 
913
        event.wait(5.0)
 
914
        stop_event.wait(30.0)
 
915
 
 
916
    def setUp(self):
 
917
        """See bzrlib.transport.Server.setUp."""
 
918
        # XXX: 20051124 jamesh
 
919
        # The tests currently pop up a password prompt when an external ssh
 
920
        # is used.  This forces the use of the paramiko implementation.
 
921
        global _ssh_vendor
 
922
        self._original_vendor = _ssh_vendor
 
923
        _ssh_vendor = 'none'
 
924
        self._homedir = os.getcwdu()
 
925
        if self._server_homedir is None:
 
926
            self._server_homedir = self._homedir
 
927
        self._root = '/'
 
928
        # FIXME WINDOWS: _root should be _server_homedir[0]:/
 
929
        self._listener = SingleListener(self._run_server)
 
930
        self._listener.setDaemon(True)
 
931
        self._listener.start()
 
932
 
 
933
    def tearDown(self):
 
934
        """See bzrlib.transport.Server.tearDown."""
 
935
        global _ssh_vendor
 
936
        self._listener.stop()
 
937
        _ssh_vendor = self._original_vendor
 
938
 
 
939
 
 
940
class SFTPAbsoluteServer(SFTPServer):
 
941
    """A test server for sftp transports, using absolute urls."""
 
942
 
 
943
    def get_url(self):
 
944
        """See bzrlib.transport.Server.get_url."""
 
945
        return self._get_sftp_url("%%2f%s" % 
 
946
                urlescape(self._homedir[1:]))
 
947
 
 
948
 
 
949
class SFTPHomeDirServer(SFTPServer):
 
950
    """A test server for sftp transports, using homedir relative urls."""
 
951
 
 
952
    def get_url(self):
 
953
        """See bzrlib.transport.Server.get_url."""
 
954
        return self._get_sftp_url("")
 
955
 
 
956
 
 
957
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
 
958
    """A test servere for sftp transports, using absolute urls to non-home."""
 
959
 
 
960
    def setUp(self):
 
961
        self._server_homedir = '/dev/noone/runs/tests/here'
 
962
        super(SFTPSiblingAbsoluteServer, self).setUp()
 
963
 
 
964
 
 
965
def get_test_permutations():
 
966
    """Return the permutations to be used in testing."""
 
967
    return [(SFTPTransport, SFTPAbsoluteServer),
 
968
            (SFTPTransport, SFTPHomeDirServer),
 
969
            (SFTPTransport, SFTPSiblingAbsoluteServer),
 
970
            ]