~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: 2006-05-19 06:14:38 UTC
  • mfrom: (1704.2.23 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060519061438-6300caf3926c3cff
(mbp) small fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
 
2
# Copyright (C) 2005, 2006 Canonical Ltd
 
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
 
#
 
8
 
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
12
# GNU General Public License for more details.
12
 
#
 
13
 
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
"""Implementation of Transport over SFTP, using paramiko."""
18
19
 
19
 
# TODO: Remove the transport-based lock_read and lock_write methods.  They'll
20
 
# then raise TransportNotPossible, which will break remote access to any
21
 
# formats which rely on OS-level locks.  That should be fine as those formats
22
 
# are pretty old, but these combinations may have to be removed from the test
23
 
# suite.  Those formats all date back to 0.7; so we should be able to remove
24
 
# these methods when we officially drop support for those formats.
25
 
 
26
 
import bisect
27
20
import errno
28
 
import itertools
 
21
import getpass
29
22
import os
30
23
import random
 
24
import re
31
25
import stat
 
26
import subprocess
32
27
import sys
33
28
import time
34
29
import urllib
35
30
import urlparse
36
 
import warnings
 
31
import weakref
37
32
 
38
 
from bzrlib import (
39
 
    config,
40
 
    debug,
41
 
    errors,
42
 
    urlutils,
43
 
    )
44
 
from bzrlib.errors import (FileExists,
45
 
                           NoSuchFile, PathNotChild,
 
33
from bzrlib.config import config_dir, ensure_config_dir_exists
 
34
from bzrlib.errors import (ConnectionError,
 
35
                           FileExists, 
 
36
                           TransportNotPossible, NoSuchFile, PathNotChild,
46
37
                           TransportError,
47
 
                           LockError,
 
38
                           LockError, 
48
39
                           PathError,
49
40
                           ParamikoNotPresent,
50
41
                           )
51
 
from bzrlib.osutils import pathjoin, fancy_rename, getcwd
52
 
from bzrlib.symbol_versioning import (
53
 
        deprecated_function,
54
 
        )
55
 
from bzrlib.trace import mutter, warning
 
42
from bzrlib.osutils import pathjoin, fancy_rename
 
43
from bzrlib.trace import mutter, warning, error
56
44
from bzrlib.transport import (
57
 
    FileFileStream,
58
 
    _file_streams,
59
 
    local,
 
45
    register_urlparse_netloc_protocol,
60
46
    Server,
61
 
    ssh,
62
 
    ConnectedTransport,
 
47
    Transport,
 
48
    urlescape,
63
49
    )
64
 
 
65
 
# Disable one particular warning that comes from paramiko in Python2.5; if
66
 
# this is emitted at the wrong time it tends to cause spurious test failures
67
 
# or at least noise in the test case::
68
 
#
69
 
# [1770/7639 in 86s, 1 known failures, 50 skipped, 2 missing features]
70
 
# test_permissions.TestSftpPermissions.test_new_files
71
 
# /var/lib/python-support/python2.5/paramiko/message.py:226: DeprecationWarning: integer argument expected, got float
72
 
#  self.packet.write(struct.pack('>I', n))
73
 
warnings.filterwarnings('ignore',
74
 
        'integer argument expected, got float',
75
 
        category=DeprecationWarning,
76
 
        module='paramiko.message')
 
50
import bzrlib.ui
77
51
 
78
52
try:
79
53
    import paramiko
85
59
                               CMD_HANDLE, CMD_OPEN)
86
60
    from paramiko.sftp_attr import SFTPAttributes
87
61
    from paramiko.sftp_file import SFTPFile
88
 
 
89
 
 
90
 
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
91
 
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
92
 
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
 
62
    from paramiko.sftp_client import SFTPClient
 
63
 
 
64
 
 
65
register_urlparse_netloc_protocol('sftp')
 
66
 
 
67
 
 
68
def _ignore_sigint():
 
69
    # TODO: This should possibly ignore SIGHUP as well, but bzr currently
 
70
    # doesn't handle it itself.
 
71
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
 
72
    import signal
 
73
    signal.signal(signal.SIGINT, signal.SIG_IGN)
 
74
    
 
75
 
 
76
def os_specific_subprocess_params():
 
77
    """Get O/S specific subprocess parameters."""
 
78
    if sys.platform == 'win32':
 
79
        # setting the process group and closing fds is not supported on 
 
80
        # win32
 
81
        return {}
 
82
    else:
 
83
        # We close fds other than the pipes as the child process does not need 
 
84
        # them to be open.
 
85
        #
 
86
        # We also set the child process to ignore SIGINT.  Normally the signal
 
87
        # would be sent to every process in the foreground process group, but
 
88
        # this causes it to be seen only by bzr and not by ssh.  Python will
 
89
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
 
90
        # to release locks or do other cleanup over ssh before the connection
 
91
        # goes away.  
 
92
        # <https://launchpad.net/products/bzr/+bug/5987>
 
93
        #
 
94
        # Running it in a separate process group is not good because then it
 
95
        # can't get non-echoed input of a password or passphrase.
 
96
        # <https://launchpad.net/products/bzr/+bug/40508>
 
97
        return {'preexec_fn': _ignore_sigint,
 
98
                'close_fds': True,
 
99
                }
 
100
 
 
101
 
 
102
# don't use prefetch unless paramiko version >= 1.5.2 (there were bugs earlier)
 
103
_default_do_prefetch = False
 
104
if getattr(paramiko, '__version_info__', (0, 0, 0)) >= (1, 5, 5):
 
105
    _default_do_prefetch = True
 
106
 
 
107
 
 
108
_ssh_vendor = None
 
109
def _get_ssh_vendor():
 
110
    """Find out what version of SSH is on the system."""
 
111
    global _ssh_vendor
 
112
    if _ssh_vendor is not None:
 
113
        return _ssh_vendor
 
114
 
 
115
    _ssh_vendor = 'none'
 
116
 
 
117
    if 'BZR_SSH' in os.environ:
 
118
        _ssh_vendor = os.environ['BZR_SSH']
 
119
        if _ssh_vendor == 'paramiko':
 
120
            _ssh_vendor = 'none'
 
121
        return _ssh_vendor
 
122
 
 
123
    try:
 
124
        p = subprocess.Popen(['ssh', '-V'],
 
125
                             stdin=subprocess.PIPE,
 
126
                             stdout=subprocess.PIPE,
 
127
                             stderr=subprocess.PIPE,
 
128
                             **os_specific_subprocess_params())
 
129
        returncode = p.returncode
 
130
        stdout, stderr = p.communicate()
 
131
    except OSError:
 
132
        returncode = -1
 
133
        stdout = stderr = ''
 
134
    if 'OpenSSH' in stderr:
 
135
        mutter('ssh implementation is OpenSSH')
 
136
        _ssh_vendor = 'openssh'
 
137
    elif 'SSH Secure Shell' in stderr:
 
138
        mutter('ssh implementation is SSH Corp.')
 
139
        _ssh_vendor = 'ssh'
 
140
 
 
141
    if _ssh_vendor != 'none':
 
142
        return _ssh_vendor
 
143
 
 
144
    # XXX: 20051123 jamesh
 
145
    # A check for putty's plink or lsh would go here.
 
146
 
 
147
    mutter('falling back to paramiko implementation')
 
148
    return _ssh_vendor
 
149
 
 
150
 
 
151
class SFTPSubprocess:
 
152
    """A socket-like object that talks to an ssh subprocess via pipes."""
 
153
    def __init__(self, hostname, vendor, port=None, user=None):
 
154
        assert vendor in ['openssh', 'ssh']
 
155
        if vendor == 'openssh':
 
156
            args = ['ssh',
 
157
                    '-oForwardX11=no', '-oForwardAgent=no',
 
158
                    '-oClearAllForwardings=yes', '-oProtocol=2',
 
159
                    '-oNoHostAuthenticationForLocalhost=yes']
 
160
            if port is not None:
 
161
                args.extend(['-p', str(port)])
 
162
            if user is not None:
 
163
                args.extend(['-l', user])
 
164
            args.extend(['-s', hostname, 'sftp'])
 
165
        elif vendor == 'ssh':
 
166
            args = ['ssh', '-x']
 
167
            if port is not None:
 
168
                args.extend(['-p', str(port)])
 
169
            if user is not None:
 
170
                args.extend(['-l', user])
 
171
            args.extend(['-s', 'sftp', hostname])
 
172
 
 
173
        self.proc = subprocess.Popen(args,
 
174
                                     stdin=subprocess.PIPE,
 
175
                                     stdout=subprocess.PIPE,
 
176
                                     **os_specific_subprocess_params())
 
177
 
 
178
    def send(self, data):
 
179
        return os.write(self.proc.stdin.fileno(), data)
 
180
 
 
181
    def recv_ready(self):
 
182
        # TODO: jam 20051215 this function is necessary to support the
 
183
        # pipelined() function. In reality, it probably should use
 
184
        # poll() or select() to actually return if there is data
 
185
        # available, otherwise we probably don't get any benefit
 
186
        return True
 
187
 
 
188
    def recv(self, count):
 
189
        return os.read(self.proc.stdout.fileno(), count)
 
190
 
 
191
    def close(self):
 
192
        self.proc.stdin.close()
 
193
        self.proc.stdout.close()
 
194
        self.proc.wait()
 
195
 
 
196
 
 
197
class LoopbackSFTP(object):
 
198
    """Simple wrapper for a socket that pretends to be a paramiko Channel."""
 
199
 
 
200
    def __init__(self, sock):
 
201
        self.__socket = sock
 
202
 
 
203
    def send(self, data):
 
204
        return self.__socket.send(data)
 
205
 
 
206
    def recv(self, n):
 
207
        return self.__socket.recv(n)
 
208
 
 
209
    def recv_ready(self):
 
210
        return True
 
211
 
 
212
    def close(self):
 
213
        self.__socket.close()
 
214
 
 
215
 
 
216
SYSTEM_HOSTKEYS = {}
 
217
BZR_HOSTKEYS = {}
 
218
 
 
219
# This is a weakref dictionary, so that we can reuse connections
 
220
# that are still active. Long term, it might be nice to have some
 
221
# sort of expiration policy, such as disconnect if inactive for
 
222
# X seconds. But that requires a lot more fanciness.
 
223
_connected_hosts = weakref.WeakValueDictionary()
 
224
 
 
225
def clear_connection_cache():
 
226
    """Remove all hosts from the SFTP connection cache.
 
227
 
 
228
    Primarily useful for test cases wanting to force garbage collection.
 
229
    """
 
230
    _connected_hosts.clear()
 
231
 
 
232
 
 
233
def load_host_keys():
 
234
    """
 
235
    Load system host keys (probably doesn't work on windows) and any
 
236
    "discovered" keys from previous sessions.
 
237
    """
 
238
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
239
    try:
 
240
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
241
    except Exception, e:
 
242
        mutter('failed to load system host keys: ' + str(e))
 
243
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
244
    try:
 
245
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
 
246
    except Exception, e:
 
247
        mutter('failed to load bzr host keys: ' + str(e))
 
248
        save_host_keys()
 
249
 
 
250
 
 
251
def save_host_keys():
 
252
    """
 
253
    Save "discovered" host keys in $(config)/ssh_host_keys/.
 
254
    """
 
255
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
256
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
257
    ensure_config_dir_exists()
 
258
 
 
259
    try:
 
260
        f = open(bzr_hostkey_path, 'w')
 
261
        f.write('# SSH host keys collected by bzr\n')
 
262
        for hostname, keys in BZR_HOSTKEYS.iteritems():
 
263
            for keytype, key in keys.iteritems():
 
264
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
 
265
        f.close()
 
266
    except IOError, e:
 
267
        mutter('failed to save bzr host keys: ' + str(e))
93
268
 
94
269
 
95
270
class SFTPLock(object):
96
 
    """This fakes a lock in a remote location.
97
 
 
98
 
    A present lock is indicated just by the existence of a file.  This
99
 
    doesn't work well on all transports and they are only used in
100
 
    deprecated storage formats.
101
 
    """
102
 
 
 
271
    """This fakes a lock in a remote location."""
103
272
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
104
 
 
105
273
    def __init__(self, path, transport):
 
274
        assert isinstance(transport, SFTPTransport)
 
275
 
106
276
        self.lock_file = None
107
277
        self.path = path
108
278
        self.lock_path = path + '.write-lock'
131
301
            # What specific errors should we catch here?
132
302
            pass
133
303
 
134
 
 
135
 
class _SFTPReadvHelper(object):
136
 
    """A class to help with managing the state of a readv request."""
137
 
 
138
 
    # See _get_requests for an explanation.
139
 
    _max_request_size = 32768
140
 
 
141
 
    def __init__(self, original_offsets, relpath, _report_activity):
142
 
        """Create a new readv helper.
143
 
 
144
 
        :param original_offsets: The original requests given by the caller of
145
 
            readv()
146
 
        :param relpath: The name of the file (if known)
147
 
        :param _report_activity: A Transport._report_activity bound method,
148
 
            to be called as data arrives.
149
 
        """
150
 
        self.original_offsets = list(original_offsets)
151
 
        self.relpath = relpath
152
 
        self._report_activity = _report_activity
153
 
 
154
 
    def _get_requests(self):
155
 
        """Break up the offsets into individual requests over sftp.
156
 
 
157
 
        The SFTP spec only requires implementers to support 32kB requests. We
158
 
        could try something larger (openssh supports 64kB), but then we have to
159
 
        handle requests that fail.
160
 
        So instead, we just break up our maximum chunks into 32kB chunks, and
161
 
        asyncronously requests them.
162
 
        Newer versions of paramiko would do the chunking for us, but we want to
163
 
        start processing results right away, so we do it ourselves.
164
 
        """
165
 
        # TODO: Because we issue async requests, we don't 'fudge' any extra
166
 
        #       data.  I'm not 100% sure that is the best choice.
167
 
 
168
 
        # The first thing we do, is to collapse the individual requests as much
169
 
        # as possible, so we don't issues requests <32kB
170
 
        sorted_offsets = sorted(self.original_offsets)
171
 
        coalesced = list(ConnectedTransport._coalesce_offsets(sorted_offsets,
172
 
                                                        limit=0, fudge_factor=0))
173
 
        requests = []
174
 
        for c_offset in coalesced:
175
 
            start = c_offset.start
176
 
            size = c_offset.length
177
 
 
178
 
            # Break this up into 32kB requests
179
 
            while size > 0:
180
 
                next_size = min(size, self._max_request_size)
181
 
                requests.append((start, next_size))
182
 
                size -= next_size
183
 
                start += next_size
184
 
        if 'sftp' in debug.debug_flags:
185
 
            mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',
186
 
                self.relpath, len(sorted_offsets), len(coalesced),
187
 
                len(requests))
188
 
        return requests
189
 
 
190
 
    def request_and_yield_offsets(self, fp):
191
 
        """Request the data from the remote machine, yielding the results.
192
 
 
193
 
        :param fp: A Paramiko SFTPFile object that supports readv.
194
 
        :return: Yield the data requested by the original readv caller, one by
195
 
            one.
196
 
        """
197
 
        requests = self._get_requests()
198
 
        offset_iter = iter(self.original_offsets)
199
 
        cur_offset, cur_size = offset_iter.next()
200
 
        # paramiko .readv() yields strings that are in the order of the requests
201
 
        # So we track the current request to know where the next data is
202
 
        # being returned from.
203
 
        input_start = None
204
 
        last_end = None
205
 
        buffered_data = []
206
 
        buffered_len = 0
207
 
 
208
 
        # This is used to buffer chunks which we couldn't process yet
209
 
        # It is (start, end, data) tuples.
210
 
        data_chunks = []
211
 
        # Create an 'unlimited' data stream, so we stop based on requests,
212
 
        # rather than just because the data stream ended. This lets us detect
213
 
        # short readv.
214
 
        data_stream = itertools.chain(fp.readv(requests),
215
 
                                      itertools.repeat(None))
216
 
        for (start, length), data in itertools.izip(requests, data_stream):
217
 
            if data is None:
218
 
                if cur_coalesced is not None:
219
 
                    raise errors.ShortReadvError(self.relpath,
220
 
                        start, length, len(data))
221
 
            if len(data) != length:
222
 
                raise errors.ShortReadvError(self.relpath,
223
 
                    start, length, len(data))
224
 
            self._report_activity(length, 'read')
225
 
            if last_end is None:
226
 
                # This is the first request, just buffer it
227
 
                buffered_data = [data]
228
 
                buffered_len = length
229
 
                input_start = start
230
 
            elif start == last_end:
231
 
                # The data we are reading fits neatly on the previous
232
 
                # buffer, so this is all part of a larger coalesced range.
233
 
                buffered_data.append(data)
234
 
                buffered_len += length
235
 
            else:
236
 
                # We have an 'interrupt' in the data stream. So we know we are
237
 
                # at a request boundary.
238
 
                if buffered_len > 0:
239
 
                    # We haven't consumed the buffer so far, so put it into
240
 
                    # data_chunks, and continue.
241
 
                    buffered = ''.join(buffered_data)
242
 
                    data_chunks.append((input_start, buffered))
243
 
                input_start = start
244
 
                buffered_data = [data]
245
 
                buffered_len = length
246
 
            last_end = start + length
247
 
            if input_start == cur_offset and cur_size <= buffered_len:
248
 
                # Simplify the next steps a bit by transforming buffered_data
249
 
                # into a single string. We also have the nice property that
250
 
                # when there is only one string ''.join([x]) == x, so there is
251
 
                # no data copying.
252
 
                buffered = ''.join(buffered_data)
253
 
                # Clean out buffered data so that we keep memory
254
 
                # consumption low
255
 
                del buffered_data[:]
256
 
                buffered_offset = 0
257
 
                # TODO: We *could* also consider the case where cur_offset is in
258
 
                #       in the buffered range, even though it doesn't *start*
259
 
                #       the buffered range. But for packs we pretty much always
260
 
                #       read in order, so you won't get any extra data in the
261
 
                #       middle.
262
 
                while (input_start == cur_offset
263
 
                       and (buffered_offset + cur_size) <= buffered_len):
264
 
                    # We've buffered enough data to process this request, spit it
265
 
                    # out
266
 
                    cur_data = buffered[buffered_offset:buffered_offset + cur_size]
267
 
                    # move the direct pointer into our buffered data
268
 
                    buffered_offset += cur_size
269
 
                    # Move the start-of-buffer pointer
270
 
                    input_start += cur_size
271
 
                    # Yield the requested data
272
 
                    yield cur_offset, cur_data
273
 
                    cur_offset, cur_size = offset_iter.next()
274
 
                # at this point, we've consumed as much of buffered as we can,
275
 
                # so break off the portion that we consumed
276
 
                if buffered_offset == len(buffered_data):
277
 
                    # No tail to leave behind
278
 
                    buffered_data = []
279
 
                    buffered_len = 0
280
 
                else:
281
 
                    buffered = buffered[buffered_offset:]
282
 
                    buffered_data = [buffered]
283
 
                    buffered_len = len(buffered)
284
 
        if buffered_len:
285
 
            buffered = ''.join(buffered_data)
286
 
            del buffered_data[:]
287
 
            data_chunks.append((input_start, buffered))
288
 
        if data_chunks:
289
 
            if 'sftp' in debug.debug_flags:
290
 
                mutter('SFTP readv left with %d out-of-order bytes',
291
 
                    sum(map(lambda x: len(x[1]), data_chunks)))
292
 
            # We've processed all the readv data, at this point, anything we
293
 
            # couldn't process is in data_chunks. This doesn't happen often, so
294
 
            # this code path isn't optimized
295
 
            # We use an interesting process for data_chunks
296
 
            # Specifically if we have "bisect_left([(start, len, entries)],
297
 
            #                                       (qstart,)])
298
 
            # If start == qstart, then we get the specific node. Otherwise we
299
 
            # get the previous node
300
 
            while True:
301
 
                idx = bisect.bisect_left(data_chunks, (cur_offset,))
302
 
                if idx < len(data_chunks) and data_chunks[idx][0] == cur_offset:
303
 
                    # The data starts here
304
 
                    data = data_chunks[idx][1][:cur_size]
305
 
                elif idx > 0:
306
 
                    # The data is in a portion of a previous page
307
 
                    idx -= 1
308
 
                    sub_offset = cur_offset - data_chunks[idx][0]
309
 
                    data = data_chunks[idx][1]
310
 
                    data = data[sub_offset:sub_offset + cur_size]
311
 
                else:
312
 
                    # We are missing the page where the data should be found,
313
 
                    # something is wrong
314
 
                    data = ''
315
 
                if len(data) != cur_size:
316
 
                    raise AssertionError('We must have miscalulated.'
317
 
                        ' We expected %d bytes, but only found %d'
318
 
                        % (cur_size, len(data)))
319
 
                yield cur_offset, data
320
 
                cur_offset, cur_size = offset_iter.next()
321
 
 
322
 
 
323
 
class SFTPTransport(ConnectedTransport):
324
 
    """Transport implementation for SFTP access."""
325
 
 
 
304
class SFTPTransport (Transport):
 
305
    """
 
306
    Transport implementation for SFTP access.
 
307
    """
326
308
    _do_prefetch = _default_do_prefetch
327
 
    # TODO: jam 20060717 Conceivably these could be configurable, either
328
 
    #       by auto-tuning at run-time, or by a configuration (per host??)
329
 
    #       but the performance curve is pretty flat, so just going with
330
 
    #       reasonable defaults.
331
 
    _max_readv_combine = 200
332
 
    # Having to round trip to the server means waiting for a response,
333
 
    # so it is better to download extra bytes.
334
 
    # 8KiB had good performance for both local and remote network operations
335
 
    _bytes_to_read_before_seek = 8192
336
 
 
337
 
    # The sftp spec says that implementations SHOULD allow reads
338
 
    # to be at least 32K. paramiko.readv() does an async request
339
 
    # for the chunks. So we need to keep it within a single request
340
 
    # size for paramiko <= 1.6.1. paramiko 1.6.2 will probably chop
341
 
    # up the request itself, rather than us having to worry about it
342
 
    _max_request_size = 32768
343
 
 
344
 
    def __init__(self, base, _from_transport=None):
345
 
        super(SFTPTransport, self).__init__(base,
346
 
                                            _from_transport=_from_transport)
347
 
 
 
309
 
 
310
    def __init__(self, base, clone_from=None):
 
311
        assert base.startswith('sftp://')
 
312
        self._parse_url(base)
 
313
        base = self._unparse_url()
 
314
        if base[-1] != '/':
 
315
            base += '/'
 
316
        super(SFTPTransport, self).__init__(base)
 
317
        if clone_from is None:
 
318
            self._sftp_connect()
 
319
        else:
 
320
            # use the same ssh connection, etc
 
321
            self._sftp = clone_from._sftp
 
322
        # super saves 'self.base'
 
323
    
 
324
    def should_cache(self):
 
325
        """
 
326
        Return True if the data pulled across should be cached locally.
 
327
        """
 
328
        return True
 
329
 
 
330
    def clone(self, offset=None):
 
331
        """
 
332
        Return a new SFTPTransport with root at self.base + offset.
 
333
        We share the same SFTP session between such transports, because it's
 
334
        fairly expensive to set them up.
 
335
        """
 
336
        if offset is None:
 
337
            return SFTPTransport(self.base, self)
 
338
        else:
 
339
            return SFTPTransport(self.abspath(offset), self)
 
340
 
 
341
    def abspath(self, relpath):
 
342
        """
 
343
        Return the full url to the given relative path.
 
344
        
 
345
        @param relpath: the relative path or path components
 
346
        @type relpath: str or list
 
347
        """
 
348
        return self._unparse_url(self._remote_path(relpath))
 
349
    
348
350
    def _remote_path(self, relpath):
349
351
        """Return the path to be passed along the sftp protocol for relpath.
350
 
 
351
 
        :param relpath: is a urlencoded string.
352
 
        """
353
 
        relative = urlutils.unescape(relpath).encode('utf-8')
354
 
        remote_path = self._combine_paths(self._path, relative)
355
 
        # the initial slash should be removed from the path, and treated as a
356
 
        # homedir relative path (the path begins with a double slash if it is
357
 
        # absolute).  see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
358
 
        # RBC 20060118 we are not using this as its too user hostile. instead
359
 
        # we are following lftp and using /~/foo to mean '~/foo'
360
 
        # vila--20070602 and leave absolute paths begin with a single slash.
361
 
        if remote_path.startswith('/~/'):
362
 
            remote_path = remote_path[3:]
363
 
        elif remote_path == '/~':
364
 
            remote_path = ''
365
 
        return remote_path
366
 
 
367
 
    def _create_connection(self, credentials=None):
368
 
        """Create a new connection with the provided credentials.
369
 
 
370
 
        :param credentials: The credentials needed to establish the connection.
371
 
 
372
 
        :return: The created connection and its associated credentials.
373
 
 
374
 
        The credentials are only the password as it may have been entered
375
 
        interactively by the user and may be different from the one provided
376
 
        in base url at transport creation time.
377
 
        """
378
 
        if credentials is None:
379
 
            password = self._password
380
 
        else:
381
 
            password = credentials
382
 
 
383
 
        vendor = ssh._get_ssh_vendor()
384
 
        user = self._user
385
 
        if user is None:
386
 
            auth = config.AuthenticationConfig()
387
 
            user = auth.get_user('ssh', self._host, self._port)
388
 
        connection = vendor.connect_sftp(self._user, password,
389
 
                                         self._host, self._port)
390
 
        return connection, (user, password)
391
 
 
392
 
    def _get_sftp(self):
393
 
        """Ensures that a connection is established"""
394
 
        connection = self._get_connection()
395
 
        if connection is None:
396
 
            # First connection ever
397
 
            connection, credentials = self._create_connection()
398
 
            self._set_connection(connection, credentials)
399
 
        return connection
 
352
        
 
353
        relpath is a urlencoded string.
 
354
        """
 
355
        # FIXME: share the common code across transports
 
356
        assert isinstance(relpath, basestring)
 
357
        relpath = urllib.unquote(relpath).split('/')
 
358
        basepath = self._path.split('/')
 
359
        if len(basepath) > 0 and basepath[-1] == '':
 
360
            basepath = basepath[:-1]
 
361
 
 
362
        for p in relpath:
 
363
            if p == '..':
 
364
                if len(basepath) == 0:
 
365
                    # In most filesystems, a request for the parent
 
366
                    # of root, just returns root.
 
367
                    continue
 
368
                basepath.pop()
 
369
            elif p == '.':
 
370
                continue # No-op
 
371
            else:
 
372
                basepath.append(p)
 
373
 
 
374
        path = '/'.join(basepath)
 
375
        return path
 
376
 
 
377
    def relpath(self, abspath):
 
378
        username, password, host, port, path = self._split_url(abspath)
 
379
        error = []
 
380
        if (username != self._username):
 
381
            error.append('username mismatch')
 
382
        if (host != self._host):
 
383
            error.append('host mismatch')
 
384
        if (port != self._port):
 
385
            error.append('port mismatch')
 
386
        if (not path.startswith(self._path)):
 
387
            error.append('path mismatch')
 
388
        if error:
 
389
            extra = ': ' + ', '.join(error)
 
390
            raise PathNotChild(abspath, self.base, extra=extra)
 
391
        pl = len(self._path)
 
392
        return path[pl:].strip('/')
400
393
 
401
394
    def has(self, relpath):
402
395
        """
403
396
        Does the target location exist?
404
397
        """
405
398
        try:
406
 
            self._get_sftp().stat(self._remote_path(relpath))
407
 
            # stat result is about 20 bytes, let's say
408
 
            self._report_activity(20, 'read')
 
399
            self._sftp.stat(self._remote_path(relpath))
409
400
            return True
410
401
        except IOError:
411
402
            return False
412
403
 
413
404
    def get(self, relpath):
414
 
        """Get the file at the given relative path.
 
405
        """
 
406
        Get the file at the given relative path.
415
407
 
416
408
        :param relpath: The relative path to the file
417
409
        """
418
410
        try:
419
 
            # FIXME: by returning the file directly, we don't pass this
420
 
            # through to report_activity.  We could try wrapping the object
421
 
            # before it's returned.  For readv and get_bytes it's handled in
422
 
            # the higher-level function.
423
 
            # -- mbp 20090126
424
411
            path = self._remote_path(relpath)
425
 
            f = self._get_sftp().file(path, mode='rb')
 
412
            f = self._sftp.file(path, mode='rb')
426
413
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
427
414
                f.prefetch()
428
415
            return f
429
416
        except (IOError, paramiko.SSHException), e:
430
 
            self._translate_io_exception(e, path, ': error retrieving',
431
 
                failure_exc=errors.ReadError)
432
 
 
433
 
    def get_bytes(self, relpath):
434
 
        # reimplement this here so that we can report how many bytes came back
 
417
            self._translate_io_exception(e, path, ': error retrieving')
 
418
 
 
419
    def get_partial(self, relpath, start, length=None):
 
420
        """
 
421
        Get just part of a file.
 
422
 
 
423
        :param relpath: Path to the file, relative to base
 
424
        :param start: The starting position to read from
 
425
        :param length: The length to read. A length of None indicates
 
426
                       read to the end of the file.
 
427
        :return: A file-like object containing at least the specified bytes.
 
428
                 Some implementations may return objects which can be read
 
429
                 past this length, but this is not guaranteed.
 
430
        """
 
431
        # TODO: implement get_partial_multi to help with knit support
435
432
        f = self.get(relpath)
436
 
        try:
437
 
            bytes = f.read()
438
 
            self._report_activity(len(bytes), 'read')
439
 
            return bytes
440
 
        finally:
441
 
            f.close()
442
 
 
443
 
    def _readv(self, relpath, offsets):
444
 
        """See Transport.readv()"""
445
 
        # We overload the default readv() because we want to use a file
446
 
        # that does not have prefetch enabled.
447
 
        # Also, if we have a new paramiko, it implements an async readv()
448
 
        if not offsets:
449
 
            return
450
 
 
451
 
        try:
452
 
            path = self._remote_path(relpath)
453
 
            fp = self._get_sftp().file(path, mode='rb')
454
 
            readv = getattr(fp, 'readv', None)
455
 
            if readv:
456
 
                return self._sftp_readv(fp, offsets, relpath)
457
 
            if 'sftp' in debug.debug_flags:
458
 
                mutter('seek and read %s offsets', len(offsets))
459
 
            return self._seek_and_read(fp, offsets, relpath)
460
 
        except (IOError, paramiko.SSHException), e:
461
 
            self._translate_io_exception(e, path, ': error retrieving')
462
 
 
463
 
    def recommended_page_size(self):
464
 
        """See Transport.recommended_page_size().
465
 
 
466
 
        For SFTP we suggest a large page size to reduce the overhead
467
 
        introduced by latency.
468
 
        """
469
 
        return 64 * 1024
470
 
 
471
 
    def _sftp_readv(self, fp, offsets, relpath):
472
 
        """Use the readv() member of fp to do async readv.
473
 
 
474
 
        Then read them using paramiko.readv(). paramiko.readv()
475
 
        does not support ranges > 64K, so it caps the request size, and
476
 
        just reads until it gets all the stuff it wants.
477
 
        """
478
 
        helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
479
 
        return helper.request_and_yield_offsets(fp)
480
 
 
481
 
    def put_file(self, relpath, f, mode=None):
482
 
        """
483
 
        Copy the file-like object into the location.
 
433
        f.seek(start)
 
434
        if self._do_prefetch and hasattr(f, 'prefetch'):
 
435
            f.prefetch()
 
436
        return f
 
437
 
 
438
    def put(self, relpath, f, mode=None):
 
439
        """
 
440
        Copy the file-like or string object into the location.
484
441
 
485
442
        :param relpath: Location to put the contents, relative to base.
486
 
        :param f:       File-like object.
 
443
        :param f:       File-like or string object.
487
444
        :param mode: The final mode for the file
488
445
        """
489
446
        final_path = self._remote_path(relpath)
490
 
        return self._put(final_path, f, mode=mode)
 
447
        self._put(final_path, f, mode=mode)
491
448
 
492
449
    def _put(self, abspath, f, mode=None):
493
450
        """Helper function so both put() and copy_abspaths can reuse the code"""
498
455
        try:
499
456
            try:
500
457
                fout.set_pipelined(True)
501
 
                length = self._pump(f, fout)
 
458
                self._pump(f, fout)
502
459
            except (IOError, paramiko.SSHException), e:
503
460
                self._translate_io_exception(e, tmp_abspath)
504
 
            # XXX: This doesn't truly help like we would like it to.
505
 
            #      The problem is that openssh strips sticky bits. So while we
506
 
            #      can properly set group write permission, we lose the group
507
 
            #      sticky bit. So it is probably best to stop chmodding, and
508
 
            #      just tell users that they need to set the umask correctly.
509
 
            #      The attr.st_mode = mode, in _sftp_open_exclusive
510
 
            #      will handle when the user wants the final mode to be more
511
 
            #      restrictive. And then we avoid a round trip. Unless
512
 
            #      paramiko decides to expose an async chmod()
513
 
 
514
 
            # This is designed to chmod() right before we close.
515
 
            # Because we set_pipelined() earlier, theoretically we might
516
 
            # avoid the round trip for fout.close()
517
461
            if mode is not None:
518
 
                self._get_sftp().chmod(tmp_abspath, mode)
 
462
                self._sftp.chmod(tmp_abspath, mode)
519
463
            fout.close()
520
464
            closed = True
521
465
            self._rename_and_overwrite(tmp_abspath, abspath)
522
 
            return length
523
466
        except Exception, e:
524
467
            # If we fail, try to clean up the temporary file
525
468
            # before we throw the exception
531
474
            try:
532
475
                if not closed:
533
476
                    fout.close()
534
 
                self._get_sftp().remove(tmp_abspath)
 
477
                self._sftp.remove(tmp_abspath)
535
478
            except:
536
479
                # raise the saved except
537
480
                raise e
538
481
            # raise the original with its traceback if we can.
539
482
            raise
540
483
 
541
 
    def _put_non_atomic_helper(self, relpath, writer, mode=None,
542
 
                               create_parent_dir=False,
543
 
                               dir_mode=None):
544
 
        abspath = self._remote_path(relpath)
545
 
 
546
 
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
547
 
        #       set the file mode at create time. If it does, use it.
548
 
        #       But for now, we just chmod later anyway.
549
 
 
550
 
        def _open_and_write_file():
551
 
            """Try to open the target file, raise error on failure"""
552
 
            fout = None
553
 
            try:
554
 
                try:
555
 
                    fout = self._get_sftp().file(abspath, mode='wb')
556
 
                    fout.set_pipelined(True)
557
 
                    writer(fout)
558
 
                except (paramiko.SSHException, IOError), e:
559
 
                    self._translate_io_exception(e, abspath,
560
 
                                                 ': unable to open')
561
 
 
562
 
                # This is designed to chmod() right before we close.
563
 
                # Because we set_pipelined() earlier, theoretically we might
564
 
                # avoid the round trip for fout.close()
565
 
                if mode is not None:
566
 
                    self._get_sftp().chmod(abspath, mode)
567
 
            finally:
568
 
                if fout is not None:
569
 
                    fout.close()
570
 
 
571
 
        if not create_parent_dir:
572
 
            _open_and_write_file()
573
 
            return
574
 
 
575
 
        # Try error handling to create the parent directory if we need to
576
 
        try:
577
 
            _open_and_write_file()
578
 
        except NoSuchFile:
579
 
            # Try to create the parent directory, and then go back to
580
 
            # writing the file
581
 
            parent_dir = os.path.dirname(abspath)
582
 
            self._mkdir(parent_dir, dir_mode)
583
 
            _open_and_write_file()
584
 
 
585
 
    def put_file_non_atomic(self, relpath, f, mode=None,
586
 
                            create_parent_dir=False,
587
 
                            dir_mode=None):
588
 
        """Copy the file-like object into the target location.
589
 
 
590
 
        This function is not strictly safe to use. It is only meant to
591
 
        be used when you already know that the target does not exist.
592
 
        It is not safe, because it will open and truncate the remote
593
 
        file. So there may be a time when the file has invalid contents.
594
 
 
595
 
        :param relpath: The remote location to put the contents.
596
 
        :param f:       File-like object.
597
 
        :param mode:    Possible access permissions for new file.
598
 
                        None means do not set remote permissions.
599
 
        :param create_parent_dir: If we cannot create the target file because
600
 
                        the parent directory does not exist, go ahead and
601
 
                        create it, and then try again.
602
 
        """
603
 
        def writer(fout):
604
 
            self._pump(f, fout)
605
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
606
 
                                    create_parent_dir=create_parent_dir,
607
 
                                    dir_mode=dir_mode)
608
 
 
609
 
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
610
 
                             create_parent_dir=False,
611
 
                             dir_mode=None):
612
 
        def writer(fout):
613
 
            fout.write(bytes)
614
 
        self._put_non_atomic_helper(relpath, writer, mode=mode,
615
 
                                    create_parent_dir=create_parent_dir,
616
 
                                    dir_mode=dir_mode)
617
 
 
618
484
    def iter_files_recursive(self):
619
485
        """Walk the relative paths of all files in this transport."""
620
 
        # progress is handled by list_dir
621
486
        queue = list(self.list_dir('.'))
622
487
        while queue:
623
 
            relpath = queue.pop(0)
 
488
            relpath = urllib.quote(queue.pop(0))
624
489
            st = self.stat(relpath)
625
490
            if stat.S_ISDIR(st.st_mode):
626
491
                for i, basename in enumerate(self.list_dir(relpath)):
628
493
            else:
629
494
                yield relpath
630
495
 
631
 
    def _mkdir(self, abspath, mode=None):
632
 
        if mode is None:
633
 
            local_mode = 0777
634
 
        else:
635
 
            local_mode = mode
636
 
        try:
637
 
            self._report_activity(len(abspath), 'write')
638
 
            self._get_sftp().mkdir(abspath, local_mode)
639
 
            self._report_activity(1, 'read')
640
 
            if mode is not None:
641
 
                # chmod a dir through sftp will erase any sgid bit set
642
 
                # on the server side.  So, if the bit mode are already
643
 
                # set, avoid the chmod.  If the mode is not fine but
644
 
                # the sgid bit is set, report a warning to the user
645
 
                # with the umask fix.
646
 
                stat = self._get_sftp().lstat(abspath)
647
 
                mode = mode & 0777 # can't set special bits anyway
648
 
                if mode != stat.st_mode & 0777:
649
 
                    if stat.st_mode & 06000:
650
 
                        warning('About to chmod %s over sftp, which will result'
651
 
                                ' in its suid or sgid bits being cleared.  If'
652
 
                                ' you want to preserve those bits, change your '
653
 
                                ' environment on the server to use umask 0%03o.'
654
 
                                % (abspath, 0777 - mode))
655
 
                    self._get_sftp().chmod(abspath, mode=mode)
656
 
        except (paramiko.SSHException, IOError), e:
657
 
            self._translate_io_exception(e, abspath, ': unable to mkdir',
658
 
                failure_exc=FileExists)
659
 
 
660
496
    def mkdir(self, relpath, mode=None):
661
497
        """Create a directory at the given path."""
662
 
        self._mkdir(self._remote_path(relpath), mode=mode)
663
 
 
664
 
    def open_write_stream(self, relpath, mode=None):
665
 
        """See Transport.open_write_stream."""
666
 
        # initialise the file to zero-length
667
 
        # this is three round trips, but we don't use this
668
 
        # api more than once per write_group at the moment so
669
 
        # it is a tolerable overhead. Better would be to truncate
670
 
        # the file after opening. RBC 20070805
671
 
        self.put_bytes_non_atomic(relpath, "", mode)
672
 
        abspath = self._remote_path(relpath)
673
 
        # TODO: jam 20060816 paramiko doesn't publicly expose a way to
674
 
        #       set the file mode at create time. If it does, use it.
675
 
        #       But for now, we just chmod later anyway.
676
 
        handle = None
677
498
        try:
678
 
            handle = self._get_sftp().file(abspath, mode='wb')
679
 
            handle.set_pipelined(True)
 
499
            path = self._remote_path(relpath)
 
500
            # In the paramiko documentation, it says that passing a mode flag 
 
501
            # will filtered against the server umask.
 
502
            # StubSFTPServer does not do this, which would be nice, because it is
 
503
            # what we really want :)
 
504
            # However, real servers do use umask, so we really should do it that way
 
505
            self._sftp.mkdir(path)
 
506
            if mode is not None:
 
507
                self._sftp.chmod(path, mode=mode)
680
508
        except (paramiko.SSHException, IOError), e:
681
 
            self._translate_io_exception(e, abspath,
682
 
                                         ': unable to open')
683
 
        _file_streams[self.abspath(relpath)] = handle
684
 
        return FileFileStream(self, relpath, handle)
 
509
            self._translate_io_exception(e, path, ': unable to mkdir',
 
510
                failure_exc=FileExists)
685
511
 
686
 
    def _translate_io_exception(self, e, path, more_info='',
 
512
    def _translate_io_exception(self, e, path, more_info='', 
687
513
                                failure_exc=PathError):
688
514
        """Translate a paramiko or IOError into a friendlier exception.
689
515
 
694
520
        :param failure_exc: Paramiko has the super fun ability to raise completely
695
521
                           opaque errors that just set "e.args = ('Failure',)" with
696
522
                           no more information.
697
 
                           If this parameter is set, it defines the exception
 
523
                           If this parameter is set, it defines the exception 
698
524
                           to raise in these cases.
699
525
        """
700
526
        # paramiko seems to generate detailless errors.
701
527
        self._translate_error(e, path, raise_generic=False)
702
 
        if getattr(e, 'args', None) is not None:
 
528
        if hasattr(e, 'args'):
703
529
            if (e.args == ('No such file or directory',) or
704
530
                e.args == ('No such file',)):
705
531
                raise NoSuchFile(path, str(e) + more_info)
706
 
            if (e.args == ('mkdir failed',) or
707
 
                e.args[0].startswith('syserr: File exists')):
 
532
            if (e.args == ('mkdir failed',)):
708
533
                raise FileExists(path, str(e) + more_info)
709
534
            # strange but true, for the paramiko server.
710
535
            if (e.args == ('Failure',)):
711
536
                raise failure_exc(path, str(e) + more_info)
712
 
            # Can be something like args = ('Directory not empty:
713
 
            # '/srv/bazaar.launchpad.net/blah...: '
714
 
            # [Errno 39] Directory not empty',)
715
 
            if (e.args[0].startswith('Directory not empty: ')
716
 
                or getattr(e, 'errno', None) == errno.ENOTEMPTY):
717
 
                raise errors.DirectoryNotEmpty(path, str(e))
718
537
            mutter('Raising exception with args %s', e.args)
719
 
        if getattr(e, 'errno', None) is not None:
 
538
        if hasattr(e, 'errno'):
720
539
            mutter('Raising exception with errno %s', e.errno)
721
540
        raise e
722
541
 
723
 
    def append_file(self, relpath, f, mode=None):
 
542
    def append(self, relpath, f, mode=None):
724
543
        """
725
544
        Append the text in the file-like object into the final
726
545
        location.
727
546
        """
728
547
        try:
729
548
            path = self._remote_path(relpath)
730
 
            fout = self._get_sftp().file(path, 'ab')
 
549
            fout = self._sftp.file(path, 'ab')
731
550
            if mode is not None:
732
 
                self._get_sftp().chmod(path, mode)
 
551
                self._sftp.chmod(path, mode)
733
552
            result = fout.tell()
734
553
            self._pump(f, fout)
735
554
            return result
739
558
    def rename(self, rel_from, rel_to):
740
559
        """Rename without special overwriting"""
741
560
        try:
742
 
            self._get_sftp().rename(self._remote_path(rel_from),
 
561
            self._sftp.rename(self._remote_path(rel_from),
743
562
                              self._remote_path(rel_to))
744
563
        except (IOError, paramiko.SSHException), e:
745
564
            self._translate_io_exception(e, rel_from,
747
566
 
748
567
    def _rename_and_overwrite(self, abs_from, abs_to):
749
568
        """Do a fancy rename on the remote server.
750
 
 
 
569
        
751
570
        Using the implementation provided by osutils.
752
571
        """
753
572
        try:
754
 
            sftp = self._get_sftp()
755
573
            fancy_rename(abs_from, abs_to,
756
 
                         rename_func=sftp.rename,
757
 
                         unlink_func=sftp.remove)
 
574
                    rename_func=self._sftp.rename,
 
575
                    unlink_func=self._sftp.remove)
758
576
        except (IOError, paramiko.SSHException), e:
759
 
            self._translate_io_exception(e, abs_from,
760
 
                                         ': unable to rename to %r' % (abs_to))
 
577
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
761
578
 
762
579
    def move(self, rel_from, rel_to):
763
580
        """Move the item at rel_from to the location at rel_to"""
769
586
        """Delete the item at relpath"""
770
587
        path = self._remote_path(relpath)
771
588
        try:
772
 
            self._get_sftp().remove(path)
 
589
            self._sftp.remove(path)
773
590
        except (IOError, paramiko.SSHException), e:
774
591
            self._translate_io_exception(e, path, ': unable to delete')
775
 
 
776
 
    def external_url(self):
777
 
        """See bzrlib.transport.Transport.external_url."""
778
 
        # the external path for SFTP is the base
779
 
        return self.base
780
 
 
 
592
            
781
593
    def listable(self):
782
594
        """Return True if this store supports listing."""
783
595
        return True
787
599
        Return a list of all files at the given location.
788
600
        """
789
601
        # does anything actually use this?
790
 
        # -- Unknown
791
 
        # This is at least used by copy_tree for remote upgrades.
792
 
        # -- David Allouche 2006-08-11
793
602
        path = self._remote_path(relpath)
794
603
        try:
795
 
            entries = self._get_sftp().listdir(path)
796
 
            self._report_activity(sum(map(len, entries)), 'read')
 
604
            return self._sftp.listdir(path)
797
605
        except (IOError, paramiko.SSHException), e:
798
606
            self._translate_io_exception(e, path, ': failed to list_dir')
799
 
        return [urlutils.escape(entry) for entry in entries]
800
607
 
801
608
    def rmdir(self, relpath):
802
609
        """See Transport.rmdir."""
803
610
        path = self._remote_path(relpath)
804
611
        try:
805
 
            return self._get_sftp().rmdir(path)
 
612
            return self._sftp.rmdir(path)
806
613
        except (IOError, paramiko.SSHException), e:
807
614
            self._translate_io_exception(e, path, ': failed to rmdir')
808
615
 
810
617
        """Return the stat information for a file."""
811
618
        path = self._remote_path(relpath)
812
619
        try:
813
 
            return self._get_sftp().stat(path)
 
620
            return self._sftp.stat(path)
814
621
        except (IOError, paramiko.SSHException), e:
815
622
            self._translate_io_exception(e, path, ': unable to stat')
816
623
 
840
647
        # that we have taken the lock.
841
648
        return SFTPLock(relpath, self)
842
649
 
 
650
    def _unparse_url(self, path=None):
 
651
        if path is None:
 
652
            path = self._path
 
653
        path = urllib.quote(path)
 
654
        # handle homedir paths
 
655
        if not path.startswith('/'):
 
656
            path = "/~/" + path
 
657
        netloc = urllib.quote(self._host)
 
658
        if self._username is not None:
 
659
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
660
        if self._port is not None:
 
661
            netloc = '%s:%d' % (netloc, self._port)
 
662
        return urlparse.urlunparse(('sftp', netloc, path, '', '', ''))
 
663
 
 
664
    def _split_url(self, url):
 
665
        if isinstance(url, unicode):
 
666
            url = url.encode('utf-8')
 
667
        (scheme, netloc, path, params,
 
668
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
669
        assert scheme == 'sftp'
 
670
        username = password = host = port = None
 
671
        if '@' in netloc:
 
672
            username, host = netloc.split('@', 1)
 
673
            if ':' in username:
 
674
                username, password = username.split(':', 1)
 
675
                password = urllib.unquote(password)
 
676
            username = urllib.unquote(username)
 
677
        else:
 
678
            host = netloc
 
679
 
 
680
        if ':' in host:
 
681
            host, port = host.rsplit(':', 1)
 
682
            try:
 
683
                port = int(port)
 
684
            except ValueError:
 
685
                # TODO: Should this be ConnectionError?
 
686
                raise TransportError('%s: invalid port number' % port)
 
687
        host = urllib.unquote(host)
 
688
 
 
689
        path = urllib.unquote(path)
 
690
 
 
691
        # the initial slash should be removed from the path, and treated
 
692
        # as a homedir relative path (the path begins with a double slash
 
693
        # if it is absolute).
 
694
        # see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
 
695
        # RBC 20060118 we are not using this as its too user hostile. instead
 
696
        # we are following lftp and using /~/foo to mean '~/foo'.
 
697
        # handle homedir paths
 
698
        if path.startswith('/~/'):
 
699
            path = path[3:]
 
700
        elif path == '/~':
 
701
            path = ''
 
702
        return (username, password, host, port, path)
 
703
 
 
704
    def _parse_url(self, url):
 
705
        (self._username, self._password,
 
706
         self._host, self._port, self._path) = self._split_url(url)
 
707
 
 
708
    def _sftp_connect(self):
 
709
        """Connect to the remote sftp server.
 
710
        After this, self._sftp should have a valid connection (or
 
711
        we raise an TransportError 'could not connect').
 
712
 
 
713
        TODO: Raise a more reasonable ConnectionFailed exception
 
714
        """
 
715
        global _connected_hosts
 
716
 
 
717
        idx = (self._host, self._port, self._username)
 
718
        try:
 
719
            self._sftp = _connected_hosts[idx]
 
720
            return
 
721
        except KeyError:
 
722
            pass
 
723
        
 
724
        vendor = _get_ssh_vendor()
 
725
        if vendor == 'loopback':
 
726
            sock = socket.socket()
 
727
            sock.connect((self._host, self._port))
 
728
            self._sftp = SFTPClient(LoopbackSFTP(sock))
 
729
        elif vendor != 'none':
 
730
            sock = SFTPSubprocess(self._host, vendor, self._port,
 
731
                                  self._username)
 
732
            self._sftp = SFTPClient(sock)
 
733
        else:
 
734
            self._paramiko_connect()
 
735
 
 
736
        _connected_hosts[idx] = self._sftp
 
737
 
 
738
    def _paramiko_connect(self):
 
739
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
740
        
 
741
        load_host_keys()
 
742
 
 
743
        try:
 
744
            t = paramiko.Transport((self._host, self._port or 22))
 
745
            t.set_log_channel('bzr.paramiko')
 
746
            t.start_client()
 
747
        except paramiko.SSHException, e:
 
748
            raise ConnectionError('Unable to reach SSH host %s:%d' %
 
749
                                  (self._host, self._port), e)
 
750
            
 
751
        server_key = t.get_remote_server_key()
 
752
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
 
753
        keytype = server_key.get_name()
 
754
        if SYSTEM_HOSTKEYS.has_key(self._host) and SYSTEM_HOSTKEYS[self._host].has_key(keytype):
 
755
            our_server_key = SYSTEM_HOSTKEYS[self._host][keytype]
 
756
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
757
        elif BZR_HOSTKEYS.has_key(self._host) and BZR_HOSTKEYS[self._host].has_key(keytype):
 
758
            our_server_key = BZR_HOSTKEYS[self._host][keytype]
 
759
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
760
        else:
 
761
            warning('Adding %s host key for %s: %s' % (keytype, self._host, server_key_hex))
 
762
            if not BZR_HOSTKEYS.has_key(self._host):
 
763
                BZR_HOSTKEYS[self._host] = {}
 
764
            BZR_HOSTKEYS[self._host][keytype] = server_key
 
765
            our_server_key = server_key
 
766
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
 
767
            save_host_keys()
 
768
        if server_key != our_server_key:
 
769
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
 
770
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
771
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
 
772
                (self._host, our_server_key_hex, server_key_hex),
 
773
                ['Try editing %s or %s' % (filename1, filename2)])
 
774
 
 
775
        self._sftp_auth(t)
 
776
        
 
777
        try:
 
778
            self._sftp = t.open_sftp_client()
 
779
        except paramiko.SSHException, e:
 
780
            raise ConnectionError('Unable to start sftp client %s:%d' %
 
781
                                  (self._host, self._port), e)
 
782
 
 
783
    def _sftp_auth(self, transport):
 
784
        # paramiko requires a username, but it might be none if nothing was supplied
 
785
        # use the local username, just in case.
 
786
        # We don't override self._username, because if we aren't using paramiko,
 
787
        # the username might be specified in ~/.ssh/config and we don't want to
 
788
        # force it to something else
 
789
        # Also, it would mess up the self.relpath() functionality
 
790
        username = self._username or getpass.getuser()
 
791
 
 
792
        # Paramiko tries to open a socket.AF_UNIX in order to connect
 
793
        # to ssh-agent. That attribute doesn't exist on win32 (it does in cygwin)
 
794
        # so we get an AttributeError exception. For now, just don't try to
 
795
        # connect to an agent if we are on win32
 
796
        if sys.platform != 'win32':
 
797
            agent = paramiko.Agent()
 
798
            for key in agent.get_keys():
 
799
                mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
 
800
                try:
 
801
                    transport.auth_publickey(username, key)
 
802
                    return
 
803
                except paramiko.SSHException, e:
 
804
                    pass
 
805
        
 
806
        # okay, try finding id_rsa or id_dss?  (posix only)
 
807
        if self._try_pkey_auth(transport, paramiko.RSAKey, username, 'id_rsa'):
 
808
            return
 
809
        if self._try_pkey_auth(transport, paramiko.DSSKey, username, 'id_dsa'):
 
810
            return
 
811
 
 
812
        if self._password:
 
813
            try:
 
814
                transport.auth_password(username, self._password)
 
815
                return
 
816
            except paramiko.SSHException, e:
 
817
                pass
 
818
 
 
819
            # FIXME: Don't keep a password held in memory if you can help it
 
820
            #self._password = None
 
821
 
 
822
        # give up and ask for a password
 
823
        password = bzrlib.ui.ui_factory.get_password(
 
824
                prompt='SSH %(user)s@%(host)s password',
 
825
                user=username, host=self._host)
 
826
        try:
 
827
            transport.auth_password(username, password)
 
828
        except paramiko.SSHException, e:
 
829
            raise ConnectionError('Unable to authenticate to SSH host as %s@%s' %
 
830
                                  (username, self._host), e)
 
831
 
 
832
    def _try_pkey_auth(self, transport, pkey_class, username, filename):
 
833
        filename = os.path.expanduser('~/.ssh/' + filename)
 
834
        try:
 
835
            key = pkey_class.from_private_key_file(filename)
 
836
            transport.auth_publickey(username, key)
 
837
            return True
 
838
        except paramiko.PasswordRequiredException:
 
839
            password = bzrlib.ui.ui_factory.get_password(
 
840
                    prompt='SSH %(filename)s password',
 
841
                    filename=filename)
 
842
            try:
 
843
                key = pkey_class.from_private_key_file(filename, password)
 
844
                transport.auth_publickey(username, key)
 
845
                return True
 
846
            except paramiko.SSHException:
 
847
                mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
 
848
        except paramiko.SSHException:
 
849
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
 
850
        except IOError:
 
851
            pass
 
852
        return False
 
853
 
843
854
    def _sftp_open_exclusive(self, abspath, mode=None):
844
855
        """Open a remote path exclusively.
845
856
 
854
865
        :param abspath: The remote absolute path where the file should be opened
855
866
        :param mode: The mode permissions bits for the new file
856
867
        """
857
 
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
858
 
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
859
 
        #       However, there is no way to set the permission mode at open
860
 
        #       time using the sftp_client.file() functionality.
861
 
        path = self._get_sftp()._adjust_cwd(abspath)
862
 
        # mutter('sftp abspath %s => %s', abspath, path)
 
868
        path = self._sftp._adjust_cwd(abspath)
863
869
        attr = SFTPAttributes()
864
870
        if mode is not None:
865
871
            attr.st_mode = mode
866
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
 
872
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
867
873
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
868
874
        try:
869
 
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
 
875
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
870
876
            if t != CMD_HANDLE:
871
877
                raise TransportError('Expected an SFTP handle')
872
878
            handle = msg.get_string()
873
 
            return SFTPFile(self._get_sftp(), handle, 'wb', -1)
 
879
            return SFTPFile(self._sftp, handle, 'wb', -1)
874
880
        except (paramiko.SSHException, IOError), e:
875
881
            self._translate_io_exception(e, abspath, ': unable to open',
876
882
                failure_exc=FileExists)
877
883
 
878
 
    def _can_roundtrip_unix_modebits(self):
879
 
        if sys.platform == 'win32':
880
 
            # anyone else?
881
 
            return False
882
 
        else:
883
 
            return True
 
884
 
 
885
# ------------- server test implementation --------------
 
886
import socket
 
887
import threading
 
888
 
 
889
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
 
890
 
 
891
STUB_SERVER_KEY = """
 
892
-----BEGIN RSA PRIVATE KEY-----
 
893
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
 
894
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
 
895
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
 
896
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
 
897
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
 
898
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
 
899
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
 
900
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
 
901
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
 
902
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
 
903
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
 
904
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
 
905
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
 
906
-----END RSA PRIVATE KEY-----
 
907
"""
 
908
    
 
909
 
 
910
class SingleListener(threading.Thread):
 
911
 
 
912
    def __init__(self, callback):
 
913
        threading.Thread.__init__(self)
 
914
        self._callback = callback
 
915
        self._socket = socket.socket()
 
916
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
917
        self._socket.bind(('localhost', 0))
 
918
        self._socket.listen(1)
 
919
        self.port = self._socket.getsockname()[1]
 
920
        self.stop_event = threading.Event()
 
921
 
 
922
    def run(self):
 
923
        s, _ = self._socket.accept()
 
924
        # now close the listen socket
 
925
        self._socket.close()
 
926
        try:
 
927
            self._callback(s, self.stop_event)
 
928
        except socket.error:
 
929
            pass #Ignore socket errors
 
930
        except Exception, x:
 
931
            # probably a failed test
 
932
            warning('Exception from within unit test server thread: %r' % x)
 
933
 
 
934
    def stop(self):
 
935
        self.stop_event.set()
 
936
        # use a timeout here, because if the test fails, the server thread may
 
937
        # never notice the stop_event.
 
938
        self.join(5.0)
 
939
 
 
940
 
 
941
class SFTPServer(Server):
 
942
    """Common code for SFTP server facilities."""
 
943
 
 
944
    def __init__(self):
 
945
        self._original_vendor = None
 
946
        self._homedir = None
 
947
        self._server_homedir = None
 
948
        self._listener = None
 
949
        self._root = None
 
950
        self._vendor = 'none'
 
951
        # sftp server logs
 
952
        self.logs = []
 
953
 
 
954
    def _get_sftp_url(self, path):
 
955
        """Calculate an sftp url to this server for path."""
 
956
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
 
957
 
 
958
    def log(self, message):
 
959
        """StubServer uses this to log when a new server is created."""
 
960
        self.logs.append(message)
 
961
 
 
962
    def _run_server(self, s, stop_event):
 
963
        ssh_server = paramiko.Transport(s)
 
964
        key_file = os.path.join(self._homedir, 'test_rsa.key')
 
965
        file(key_file, 'w').write(STUB_SERVER_KEY)
 
966
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
 
967
        ssh_server.add_server_key(host_key)
 
968
        server = StubServer(self)
 
969
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
 
970
                                         StubSFTPServer, root=self._root,
 
971
                                         home=self._server_homedir)
 
972
        event = threading.Event()
 
973
        ssh_server.start_server(event, server)
 
974
        event.wait(5.0)
 
975
        stop_event.wait(30.0)
 
976
    
 
977
    def setUp(self):
 
978
        global _ssh_vendor
 
979
        self._original_vendor = _ssh_vendor
 
980
        _ssh_vendor = self._vendor
 
981
        self._homedir = os.getcwdu()
 
982
        if self._server_homedir is None:
 
983
            self._server_homedir = self._homedir
 
984
        self._root = '/'
 
985
        # FIXME WINDOWS: _root should be _server_homedir[0]:/
 
986
        self._listener = SingleListener(self._run_server)
 
987
        self._listener.setDaemon(True)
 
988
        self._listener.start()
 
989
 
 
990
    def tearDown(self):
 
991
        """See bzrlib.transport.Server.tearDown."""
 
992
        global _ssh_vendor
 
993
        self._listener.stop()
 
994
        _ssh_vendor = self._original_vendor
 
995
 
 
996
 
 
997
class SFTPFullAbsoluteServer(SFTPServer):
 
998
    """A test server for sftp transports, using absolute urls and ssh."""
 
999
 
 
1000
    def get_url(self):
 
1001
        """See bzrlib.transport.Server.get_url."""
 
1002
        return self._get_sftp_url(urlescape(self._homedir[1:]))
 
1003
 
 
1004
 
 
1005
class SFTPServerWithoutSSH(SFTPServer):
 
1006
    """An SFTP server that uses a simple TCP socket pair rather than SSH."""
 
1007
 
 
1008
    def __init__(self):
 
1009
        super(SFTPServerWithoutSSH, self).__init__()
 
1010
        self._vendor = 'loopback'
 
1011
 
 
1012
    def _run_server(self, sock, stop_event):
 
1013
        class FakeChannel(object):
 
1014
            def get_transport(self):
 
1015
                return self
 
1016
            def get_log_channel(self):
 
1017
                return 'paramiko'
 
1018
            def get_name(self):
 
1019
                return '1'
 
1020
            def get_hexdump(self):
 
1021
                return False
 
1022
            def close(self):
 
1023
                pass
 
1024
 
 
1025
        server = paramiko.SFTPServer(FakeChannel(), 'sftp', StubServer(self), StubSFTPServer,
 
1026
                                     root=self._root, home=self._server_homedir)
 
1027
        server.start_subsystem('sftp', None, sock)
 
1028
        server.finish_subsystem()
 
1029
 
 
1030
 
 
1031
class SFTPAbsoluteServer(SFTPServerWithoutSSH):
 
1032
    """A test server for sftp transports, using absolute urls."""
 
1033
 
 
1034
    def get_url(self):
 
1035
        """See bzrlib.transport.Server.get_url."""
 
1036
        return self._get_sftp_url(urlescape(self._homedir[1:]))
 
1037
 
 
1038
 
 
1039
class SFTPHomeDirServer(SFTPServerWithoutSSH):
 
1040
    """A test server for sftp transports, using homedir relative urls."""
 
1041
 
 
1042
    def get_url(self):
 
1043
        """See bzrlib.transport.Server.get_url."""
 
1044
        return self._get_sftp_url("~/")
 
1045
 
 
1046
 
 
1047
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
 
1048
    """A test servere for sftp transports, using absolute urls to non-home."""
 
1049
 
 
1050
    def setUp(self):
 
1051
        self._server_homedir = '/dev/noone/runs/tests/here'
 
1052
        super(SFTPSiblingAbsoluteServer, self).setUp()
884
1053
 
885
1054
 
886
1055
def get_test_permutations():
887
1056
    """Return the permutations to be used in testing."""
888
 
    from bzrlib.tests import stub_sftp
889
 
    return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
890
 
            (SFTPTransport, stub_sftp.SFTPHomeDirServer),
891
 
            (SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
 
1057
    return [(SFTPTransport, SFTPAbsoluteServer),
 
1058
            (SFTPTransport, SFTPHomeDirServer),
 
1059
            (SFTPTransport, SFTPSiblingAbsoluteServer),
892
1060
            ]