~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
2
 
# Copyright (C) 2005, 2006 Canonical Ltd
3
 
 
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
 
 
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
 
 
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
"""Implementation of Transport over SFTP, using paramiko."""
19
18
 
 
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
20
27
import errno
21
 
import getpass
 
28
import itertools
22
29
import os
23
30
import random
24
 
import re
25
31
import stat
26
 
import subprocess
27
32
import sys
28
33
import time
29
34
import urllib
30
35
import urlparse
31
 
import weakref
 
36
import warnings
32
37
 
33
 
from bzrlib.config import config_dir, ensure_config_dir_exists
34
 
from bzrlib.errors import (ConnectionError,
35
 
                           FileExists, 
36
 
                           TransportNotPossible, NoSuchFile, PathNotChild,
 
38
from bzrlib import (
 
39
    config,
 
40
    debug,
 
41
    errors,
 
42
    urlutils,
 
43
    )
 
44
from bzrlib.errors import (FileExists,
 
45
                           NoSuchFile, PathNotChild,
37
46
                           TransportError,
38
 
                           LockError, 
 
47
                           LockError,
39
48
                           PathError,
40
49
                           ParamikoNotPresent,
41
50
                           )
42
 
from bzrlib.osutils import pathjoin, fancy_rename
43
 
from bzrlib.trace import mutter, warning, error
 
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
44
56
from bzrlib.transport import (
45
 
    register_urlparse_netloc_protocol,
 
57
    FileFileStream,
 
58
    _file_streams,
 
59
    local,
46
60
    Server,
47
 
    Transport,
48
 
    urlescape,
 
61
    ssh,
 
62
    ConnectedTransport,
49
63
    )
50
 
import bzrlib.ui
 
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')
51
77
 
52
78
try:
53
79
    import paramiko
59
85
                               CMD_HANDLE, CMD_OPEN)
60
86
    from paramiko.sftp_attr import SFTPAttributes
61
87
    from paramiko.sftp_file import SFTPFile
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))
 
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))
268
93
 
269
94
 
270
95
class SFTPLock(object):
271
 
    """This fakes a lock in a remote location."""
 
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
 
272
103
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
 
104
 
273
105
    def __init__(self, path, transport):
274
 
        assert isinstance(transport, SFTPTransport)
275
 
 
276
106
        self.lock_file = None
277
107
        self.path = path
278
108
        self.lock_path = path + '.write-lock'
301
131
            # What specific errors should we catch here?
302
132
            pass
303
133
 
304
 
class SFTPTransport (Transport):
305
 
    """
306
 
    Transport implementation for SFTP access.
307
 
    """
 
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
 
308
326
    _do_prefetch = _default_do_prefetch
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
 
    
 
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
 
350
348
    def _remote_path(self, relpath):
351
349
        """Return the path to be passed along the sftp protocol for relpath.
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('/')
 
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
393
400
 
394
401
    def has(self, relpath):
395
402
        """
396
403
        Does the target location exist?
397
404
        """
398
405
        try:
399
 
            self._sftp.stat(self._remote_path(relpath))
 
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')
400
409
            return True
401
410
        except IOError:
402
411
            return False
403
412
 
404
413
    def get(self, relpath):
405
 
        """
406
 
        Get the file at the given relative path.
 
414
        """Get the file at the given relative path.
407
415
 
408
416
        :param relpath: The relative path to the file
409
417
        """
410
418
        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
411
424
            path = self._remote_path(relpath)
412
 
            f = self._sftp.file(path, mode='rb')
 
425
            f = self._get_sftp().file(path, mode='rb')
413
426
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
414
427
                f.prefetch()
415
428
            return f
416
429
        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
 
435
        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:
417
461
            self._translate_io_exception(e, path, ': error retrieving')
418
462
 
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
432
 
        f = self.get(relpath)
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.
 
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.
441
484
 
442
485
        :param relpath: Location to put the contents, relative to base.
443
 
        :param f:       File-like or string object.
 
486
        :param f:       File-like object.
444
487
        :param mode: The final mode for the file
445
488
        """
446
489
        final_path = self._remote_path(relpath)
447
 
        self._put(final_path, f, mode=mode)
 
490
        return self._put(final_path, f, mode=mode)
448
491
 
449
492
    def _put(self, abspath, f, mode=None):
450
493
        """Helper function so both put() and copy_abspaths can reuse the code"""
455
498
        try:
456
499
            try:
457
500
                fout.set_pipelined(True)
458
 
                self._pump(f, fout)
 
501
                length = self._pump(f, fout)
459
502
            except (IOError, paramiko.SSHException), e:
460
503
                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()
461
517
            if mode is not None:
462
 
                self._sftp.chmod(tmp_abspath, mode)
 
518
                self._get_sftp().chmod(tmp_abspath, mode)
463
519
            fout.close()
464
520
            closed = True
465
521
            self._rename_and_overwrite(tmp_abspath, abspath)
 
522
            return length
466
523
        except Exception, e:
467
524
            # If we fail, try to clean up the temporary file
468
525
            # before we throw the exception
474
531
            try:
475
532
                if not closed:
476
533
                    fout.close()
477
 
                self._sftp.remove(tmp_abspath)
 
534
                self._get_sftp().remove(tmp_abspath)
478
535
            except:
479
536
                # raise the saved except
480
537
                raise e
481
538
            # raise the original with its traceback if we can.
482
539
            raise
483
540
 
 
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
 
484
618
    def iter_files_recursive(self):
485
619
        """Walk the relative paths of all files in this transport."""
 
620
        # progress is handled by list_dir
486
621
        queue = list(self.list_dir('.'))
487
622
        while queue:
488
 
            relpath = urllib.quote(queue.pop(0))
 
623
            relpath = queue.pop(0)
489
624
            st = self.stat(relpath)
490
625
            if stat.S_ISDIR(st.st_mode):
491
626
                for i, basename in enumerate(self.list_dir(relpath)):
493
628
            else:
494
629
                yield relpath
495
630
 
 
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
 
496
660
    def mkdir(self, relpath, mode=None):
497
661
        """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
498
677
        try:
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)
 
678
            handle = self._get_sftp().file(abspath, mode='wb')
 
679
            handle.set_pipelined(True)
508
680
        except (paramiko.SSHException, IOError), e:
509
 
            self._translate_io_exception(e, path, ': unable to mkdir',
510
 
                failure_exc=FileExists)
 
681
            self._translate_io_exception(e, abspath,
 
682
                                         ': unable to open')
 
683
        _file_streams[self.abspath(relpath)] = handle
 
684
        return FileFileStream(self, relpath, handle)
511
685
 
512
 
    def _translate_io_exception(self, e, path, more_info='', 
 
686
    def _translate_io_exception(self, e, path, more_info='',
513
687
                                failure_exc=PathError):
514
688
        """Translate a paramiko or IOError into a friendlier exception.
515
689
 
520
694
        :param failure_exc: Paramiko has the super fun ability to raise completely
521
695
                           opaque errors that just set "e.args = ('Failure',)" with
522
696
                           no more information.
523
 
                           If this parameter is set, it defines the exception 
 
697
                           If this parameter is set, it defines the exception
524
698
                           to raise in these cases.
525
699
        """
526
700
        # paramiko seems to generate detailless errors.
527
701
        self._translate_error(e, path, raise_generic=False)
528
 
        if hasattr(e, 'args'):
 
702
        if getattr(e, 'args', None) is not None:
529
703
            if (e.args == ('No such file or directory',) or
530
704
                e.args == ('No such file',)):
531
705
                raise NoSuchFile(path, str(e) + more_info)
532
 
            if (e.args == ('mkdir failed',)):
 
706
            if (e.args == ('mkdir failed',) or
 
707
                e.args[0].startswith('syserr: File exists')):
533
708
                raise FileExists(path, str(e) + more_info)
534
709
            # strange but true, for the paramiko server.
535
710
            if (e.args == ('Failure',)):
536
711
                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))
537
718
            mutter('Raising exception with args %s', e.args)
538
 
        if hasattr(e, 'errno'):
 
719
        if getattr(e, 'errno', None) is not None:
539
720
            mutter('Raising exception with errno %s', e.errno)
540
721
        raise e
541
722
 
542
 
    def append(self, relpath, f, mode=None):
 
723
    def append_file(self, relpath, f, mode=None):
543
724
        """
544
725
        Append the text in the file-like object into the final
545
726
        location.
546
727
        """
547
728
        try:
548
729
            path = self._remote_path(relpath)
549
 
            fout = self._sftp.file(path, 'ab')
 
730
            fout = self._get_sftp().file(path, 'ab')
550
731
            if mode is not None:
551
 
                self._sftp.chmod(path, mode)
 
732
                self._get_sftp().chmod(path, mode)
552
733
            result = fout.tell()
553
734
            self._pump(f, fout)
554
735
            return result
558
739
    def rename(self, rel_from, rel_to):
559
740
        """Rename without special overwriting"""
560
741
        try:
561
 
            self._sftp.rename(self._remote_path(rel_from),
 
742
            self._get_sftp().rename(self._remote_path(rel_from),
562
743
                              self._remote_path(rel_to))
563
744
        except (IOError, paramiko.SSHException), e:
564
745
            self._translate_io_exception(e, rel_from,
566
747
 
567
748
    def _rename_and_overwrite(self, abs_from, abs_to):
568
749
        """Do a fancy rename on the remote server.
569
 
        
 
750
 
570
751
        Using the implementation provided by osutils.
571
752
        """
572
753
        try:
 
754
            sftp = self._get_sftp()
573
755
            fancy_rename(abs_from, abs_to,
574
 
                    rename_func=self._sftp.rename,
575
 
                    unlink_func=self._sftp.remove)
 
756
                         rename_func=sftp.rename,
 
757
                         unlink_func=sftp.remove)
576
758
        except (IOError, paramiko.SSHException), e:
577
 
            self._translate_io_exception(e, abs_from, ': unable to rename to %r' % (abs_to))
 
759
            self._translate_io_exception(e, abs_from,
 
760
                                         ': unable to rename to %r' % (abs_to))
578
761
 
579
762
    def move(self, rel_from, rel_to):
580
763
        """Move the item at rel_from to the location at rel_to"""
586
769
        """Delete the item at relpath"""
587
770
        path = self._remote_path(relpath)
588
771
        try:
589
 
            self._sftp.remove(path)
 
772
            self._get_sftp().remove(path)
590
773
        except (IOError, paramiko.SSHException), e:
591
774
            self._translate_io_exception(e, path, ': unable to delete')
592
 
            
 
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
 
593
781
    def listable(self):
594
782
        """Return True if this store supports listing."""
595
783
        return True
599
787
        Return a list of all files at the given location.
600
788
        """
601
789
        # 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
602
793
        path = self._remote_path(relpath)
603
794
        try:
604
 
            return self._sftp.listdir(path)
 
795
            entries = self._get_sftp().listdir(path)
 
796
            self._report_activity(sum(map(len, entries)), 'read')
605
797
        except (IOError, paramiko.SSHException), e:
606
798
            self._translate_io_exception(e, path, ': failed to list_dir')
 
799
        return [urlutils.escape(entry) for entry in entries]
607
800
 
608
801
    def rmdir(self, relpath):
609
802
        """See Transport.rmdir."""
610
803
        path = self._remote_path(relpath)
611
804
        try:
612
 
            return self._sftp.rmdir(path)
 
805
            return self._get_sftp().rmdir(path)
613
806
        except (IOError, paramiko.SSHException), e:
614
807
            self._translate_io_exception(e, path, ': failed to rmdir')
615
808
 
617
810
        """Return the stat information for a file."""
618
811
        path = self._remote_path(relpath)
619
812
        try:
620
 
            return self._sftp.stat(path)
 
813
            return self._get_sftp().stat(path)
621
814
        except (IOError, paramiko.SSHException), e:
622
815
            self._translate_io_exception(e, path, ': unable to stat')
623
816
 
647
840
        # that we have taken the lock.
648
841
        return SFTPLock(relpath, self)
649
842
 
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
 
 
854
843
    def _sftp_open_exclusive(self, abspath, mode=None):
855
844
        """Open a remote path exclusively.
856
845
 
865
854
        :param abspath: The remote absolute path where the file should be opened
866
855
        :param mode: The mode permissions bits for the new file
867
856
        """
868
 
        path = self._sftp._adjust_cwd(abspath)
 
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)
869
863
        attr = SFTPAttributes()
870
864
        if mode is not None:
871
865
            attr.st_mode = mode
872
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
 
866
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
873
867
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
874
868
        try:
875
 
            t, msg = self._sftp._request(CMD_OPEN, path, omode, attr)
 
869
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
876
870
            if t != CMD_HANDLE:
877
871
                raise TransportError('Expected an SFTP handle')
878
872
            handle = msg.get_string()
879
 
            return SFTPFile(self._sftp, handle, 'wb', -1)
 
873
            return SFTPFile(self._get_sftp(), handle, 'wb', -1)
880
874
        except (paramiko.SSHException, IOError), e:
881
875
            self._translate_io_exception(e, abspath, ': unable to open',
882
876
                failure_exc=FileExists)
883
877
 
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()
 
878
    def _can_roundtrip_unix_modebits(self):
 
879
        if sys.platform == 'win32':
 
880
            # anyone else?
 
881
            return False
 
882
        else:
 
883
            return True
1053
884
 
1054
885
 
1055
886
def get_test_permutations():
1056
887
    """Return the permutations to be used in testing."""
1057
 
    return [(SFTPTransport, SFTPAbsoluteServer),
1058
 
            (SFTPTransport, SFTPHomeDirServer),
1059
 
            (SFTPTransport, SFTPSiblingAbsoluteServer),
 
888
    from bzrlib.tests import stub_sftp
 
889
    return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
 
890
            (SFTPTransport, stub_sftp.SFTPHomeDirServer),
 
891
            (SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
1060
892
            ]