1
# Copyright (C) 2005-2011, 2016, 2017 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Implementation of Transport over SFTP, using paramiko."""
19
from __future__ import absolute_import
21
# TODO: Remove the transport-based lock_read and lock_write methods. They'll
22
# then raise TransportNotPossible, which will break remote access to any
23
# formats which rely on OS-level locks. That should be fine as those formats
24
# are pretty old, but these combinations may have to be removed from the test
25
# suite. Those formats all date back to 0.7; so we should be able to remove
26
# these methods when we officially drop support for those formats.
44
from bzrlib.errors import (FileExists,
51
from bzrlib.osutils import fancy_rename
52
from bzrlib.trace import mutter, warning
53
from bzrlib.transport import (
60
# Disable one particular warning that comes from paramiko in Python2.5; if
61
# this is emitted at the wrong time it tends to cause spurious test failures
62
# or at least noise in the test case::
64
# [1770/7639 in 86s, 1 known failures, 50 skipped, 2 missing features]
65
# test_permissions.TestSftpPermissions.test_new_files
66
# /var/lib/python-support/python2.5/paramiko/message.py:226: DeprecationWarning: integer argument expected, got float
67
# self.packet.write(struct.pack('>I', n))
68
warnings.filterwarnings('ignore',
69
'integer argument expected, got float',
70
category=DeprecationWarning,
71
module='paramiko.message')
75
except ImportError, e:
76
raise ParamikoNotPresent(e)
78
from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
79
SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
80
SFTP_OK, CMD_HANDLE, CMD_OPEN)
81
from paramiko.sftp_attr import SFTPAttributes
82
from paramiko.sftp_file import SFTPFile
85
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
86
# don't use prefetch unless paramiko version >= 1.5.5 (there were bugs earlier)
87
_default_do_prefetch = (_paramiko_version >= (1, 5, 5))
90
class SFTPLock(object):
91
"""This fakes a lock in a remote location.
93
A present lock is indicated just by the existence of a file. This
94
doesn't work well on all transports and they are only used in
95
deprecated storage formats.
98
__slots__ = ['path', 'lock_path', 'lock_file', 'transport']
100
def __init__(self, path, transport):
101
self.lock_file = None
103
self.lock_path = path + '.write-lock'
104
self.transport = transport
106
# RBC 20060103 FIXME should we be using private methods here ?
107
abspath = transport._remote_path(self.lock_path)
108
self.lock_file = transport._sftp_open_exclusive(abspath)
110
raise LockError('File %r already locked' % (self.path,))
113
if not self.lock_file:
115
self.lock_file.close()
116
self.lock_file = None
118
self.transport.delete(self.lock_path)
119
except (NoSuchFile,):
120
# What specific errors should we catch here?
124
class _SFTPReadvHelper(object):
125
"""A class to help with managing the state of a readv request."""
127
# See _get_requests for an explanation.
128
_max_request_size = 32768
130
def __init__(self, original_offsets, relpath, _report_activity):
131
"""Create a new readv helper.
133
:param original_offsets: The original requests given by the caller of
135
:param relpath: The name of the file (if known)
136
:param _report_activity: A Transport._report_activity bound method,
137
to be called as data arrives.
139
self.original_offsets = list(original_offsets)
140
self.relpath = relpath
141
self._report_activity = _report_activity
143
def _get_requests(self):
144
"""Break up the offsets into individual requests over sftp.
146
The SFTP spec only requires implementers to support 32kB requests. We
147
could try something larger (openssh supports 64kB), but then we have to
148
handle requests that fail.
149
So instead, we just break up our maximum chunks into 32kB chunks, and
150
asyncronously requests them.
151
Newer versions of paramiko would do the chunking for us, but we want to
152
start processing results right away, so we do it ourselves.
154
# TODO: Because we issue async requests, we don't 'fudge' any extra
155
# data. I'm not 100% sure that is the best choice.
157
# The first thing we do, is to collapse the individual requests as much
158
# as possible, so we don't issues requests <32kB
159
sorted_offsets = sorted(self.original_offsets)
160
coalesced = list(ConnectedTransport._coalesce_offsets(sorted_offsets,
161
limit=0, fudge_factor=0))
163
for c_offset in coalesced:
164
start = c_offset.start
165
size = c_offset.length
167
# Break this up into 32kB requests
169
next_size = min(size, self._max_request_size)
170
requests.append((start, next_size))
173
if 'sftp' in debug.debug_flags:
174
mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',
175
self.relpath, len(sorted_offsets), len(coalesced),
179
def request_and_yield_offsets(self, fp):
180
"""Request the data from the remote machine, yielding the results.
182
:param fp: A Paramiko SFTPFile object that supports readv.
183
:return: Yield the data requested by the original readv caller, one by
186
requests = self._get_requests()
187
offset_iter = iter(self.original_offsets)
188
cur_offset, cur_size = offset_iter.next()
189
# paramiko .readv() yields strings that are in the order of the requests
190
# So we track the current request to know where the next data is
191
# being returned from.
197
# This is used to buffer chunks which we couldn't process yet
198
# It is (start, end, data) tuples.
200
# Create an 'unlimited' data stream, so we stop based on requests,
201
# rather than just because the data stream ended. This lets us detect
203
data_stream = itertools.chain(fp.readv(requests),
204
itertools.repeat(None))
205
for (start, length), data in itertools.izip(requests, data_stream):
207
if cur_coalesced is not None:
208
raise errors.ShortReadvError(self.relpath,
209
start, length, len(data))
210
if len(data) != length:
211
raise errors.ShortReadvError(self.relpath,
212
start, length, len(data))
213
self._report_activity(length, 'read')
215
# This is the first request, just buffer it
216
buffered_data = [data]
217
buffered_len = length
219
elif start == last_end:
220
# The data we are reading fits neatly on the previous
221
# buffer, so this is all part of a larger coalesced range.
222
buffered_data.append(data)
223
buffered_len += length
225
# We have an 'interrupt' in the data stream. So we know we are
226
# at a request boundary.
228
# We haven't consumed the buffer so far, so put it into
229
# data_chunks, and continue.
230
buffered = ''.join(buffered_data)
231
data_chunks.append((input_start, buffered))
233
buffered_data = [data]
234
buffered_len = length
235
last_end = start + length
236
if input_start == cur_offset and cur_size <= buffered_len:
237
# Simplify the next steps a bit by transforming buffered_data
238
# into a single string. We also have the nice property that
239
# when there is only one string ''.join([x]) == x, so there is
241
buffered = ''.join(buffered_data)
242
# Clean out buffered data so that we keep memory
246
# TODO: We *could* also consider the case where cur_offset is in
247
# in the buffered range, even though it doesn't *start*
248
# the buffered range. But for packs we pretty much always
249
# read in order, so you won't get any extra data in the
251
while (input_start == cur_offset
252
and (buffered_offset + cur_size) <= buffered_len):
253
# We've buffered enough data to process this request, spit it
255
cur_data = buffered[buffered_offset:buffered_offset + cur_size]
256
# move the direct pointer into our buffered data
257
buffered_offset += cur_size
258
# Move the start-of-buffer pointer
259
input_start += cur_size
260
# Yield the requested data
261
yield cur_offset, cur_data
262
cur_offset, cur_size = offset_iter.next()
263
# at this point, we've consumed as much of buffered as we can,
264
# so break off the portion that we consumed
265
if buffered_offset == len(buffered_data):
266
# No tail to leave behind
270
buffered = buffered[buffered_offset:]
271
buffered_data = [buffered]
272
buffered_len = len(buffered)
273
# now that the data stream is done, close the handle
276
buffered = ''.join(buffered_data)
278
data_chunks.append((input_start, buffered))
280
if 'sftp' in debug.debug_flags:
281
mutter('SFTP readv left with %d out-of-order bytes',
282
sum(map(lambda x: len(x[1]), data_chunks)))
283
# We've processed all the readv data, at this point, anything we
284
# couldn't process is in data_chunks. This doesn't happen often, so
285
# this code path isn't optimized
286
# We use an interesting process for data_chunks
287
# Specifically if we have "bisect_left([(start, len, entries)],
289
# If start == qstart, then we get the specific node. Otherwise we
290
# get the previous node
292
idx = bisect.bisect_left(data_chunks, (cur_offset,))
293
if idx < len(data_chunks) and data_chunks[idx][0] == cur_offset:
294
# The data starts here
295
data = data_chunks[idx][1][:cur_size]
297
# The data is in a portion of a previous page
299
sub_offset = cur_offset - data_chunks[idx][0]
300
data = data_chunks[idx][1]
301
data = data[sub_offset:sub_offset + cur_size]
303
# We are missing the page where the data should be found,
306
if len(data) != cur_size:
307
raise AssertionError('We must have miscalulated.'
308
' We expected %d bytes, but only found %d'
309
% (cur_size, len(data)))
310
yield cur_offset, data
311
cur_offset, cur_size = offset_iter.next()
314
class SFTPTransport(ConnectedTransport):
315
"""Transport implementation for SFTP access."""
317
_do_prefetch = _default_do_prefetch
318
# TODO: jam 20060717 Conceivably these could be configurable, either
319
# by auto-tuning at run-time, or by a configuration (per host??)
320
# but the performance curve is pretty flat, so just going with
321
# reasonable defaults.
322
_max_readv_combine = 200
323
# Having to round trip to the server means waiting for a response,
324
# so it is better to download extra bytes.
325
# 8KiB had good performance for both local and remote network operations
326
_bytes_to_read_before_seek = 8192
328
# The sftp spec says that implementations SHOULD allow reads
329
# to be at least 32K. paramiko.readv() does an async request
330
# for the chunks. So we need to keep it within a single request
331
# size for paramiko <= 1.6.1. paramiko 1.6.2 will probably chop
332
# up the request itself, rather than us having to worry about it
333
_max_request_size = 32768
335
def _remote_path(self, relpath):
336
"""Return the path to be passed along the sftp protocol for relpath.
338
:param relpath: is a urlencoded string.
340
remote_path = self._parsed_url.clone(relpath).path
341
# the initial slash should be removed from the path, and treated as a
342
# homedir relative path (the path begins with a double slash if it is
343
# absolute). see draft-ietf-secsh-scp-sftp-ssh-uri-03.txt
344
# RBC 20060118 we are not using this as its too user hostile. instead
345
# we are following lftp and using /~/foo to mean '~/foo'
346
# vila--20070602 and leave absolute paths begin with a single slash.
347
if remote_path.startswith('/~/'):
348
remote_path = remote_path[3:]
349
elif remote_path == '/~':
353
def _create_connection(self, credentials=None):
354
"""Create a new connection with the provided credentials.
356
:param credentials: The credentials needed to establish the connection.
358
:return: The created connection and its associated credentials.
360
The credentials are only the password as it may have been entered
361
interactively by the user and may be different from the one provided
362
in base url at transport creation time.
364
if credentials is None:
365
password = self._parsed_url.password
367
password = credentials
369
vendor = ssh._get_ssh_vendor()
370
user = self._parsed_url.user
372
auth = config.AuthenticationConfig()
373
user = auth.get_user('ssh', self._parsed_url.host,
374
self._parsed_url.port)
375
connection = vendor.connect_sftp(self._parsed_url.user, password,
376
self._parsed_url.host, self._parsed_url.port)
377
return connection, (user, password)
379
def disconnect(self):
380
connection = self._get_connection()
381
if connection is not None:
385
"""Ensures that a connection is established"""
386
connection = self._get_connection()
387
if connection is None:
388
# First connection ever
389
connection, credentials = self._create_connection()
390
self._set_connection(connection, credentials)
393
def has(self, relpath):
395
Does the target location exist?
398
self._get_sftp().stat(self._remote_path(relpath))
399
# stat result is about 20 bytes, let's say
400
self._report_activity(20, 'read')
405
def get(self, relpath):
406
"""Get the file at the given relative path.
408
:param relpath: The relative path to the file
411
path = self._remote_path(relpath)
412
f = self._get_sftp().file(path, mode='rb')
413
size = f.stat().st_size
414
if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
417
except (IOError, paramiko.SSHException), e:
418
self._translate_io_exception(e, path, ': error retrieving',
419
failure_exc=errors.ReadError)
421
def get_bytes(self, relpath):
422
# reimplement this here so that we can report how many bytes came back
423
f = self.get(relpath)
426
self._report_activity(len(bytes), 'read')
431
def _readv(self, relpath, offsets):
432
"""See Transport.readv()"""
433
# We overload the default readv() because we want to use a file
434
# that does not have prefetch enabled.
435
# Also, if we have a new paramiko, it implements an async readv()
440
path = self._remote_path(relpath)
441
fp = self._get_sftp().file(path, mode='rb')
442
readv = getattr(fp, 'readv', None)
444
return self._sftp_readv(fp, offsets, relpath)
445
if 'sftp' in debug.debug_flags:
446
mutter('seek and read %s offsets', len(offsets))
447
return self._seek_and_read(fp, offsets, relpath)
448
except (IOError, paramiko.SSHException), e:
449
self._translate_io_exception(e, path, ': error retrieving')
451
def recommended_page_size(self):
452
"""See Transport.recommended_page_size().
454
For SFTP we suggest a large page size to reduce the overhead
455
introduced by latency.
459
def _sftp_readv(self, fp, offsets, relpath):
460
"""Use the readv() member of fp to do async readv.
462
Then read them using paramiko.readv(). paramiko.readv()
463
does not support ranges > 64K, so it caps the request size, and
464
just reads until it gets all the stuff it wants.
466
helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
467
return helper.request_and_yield_offsets(fp)
469
def put_file(self, relpath, f, mode=None):
471
Copy the file-like object into the location.
473
:param relpath: Location to put the contents, relative to base.
474
:param f: File-like object.
475
:param mode: The final mode for the file
477
final_path = self._remote_path(relpath)
478
return self._put(final_path, f, mode=mode)
480
def _put(self, abspath, f, mode=None):
481
"""Helper function so both put() and copy_abspaths can reuse the code"""
482
tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
483
os.getpid(), random.randint(0,0x7FFFFFFF))
484
fout = self._sftp_open_exclusive(tmp_abspath, mode=mode)
488
fout.set_pipelined(True)
489
length = self._pump(f, fout)
490
except (IOError, paramiko.SSHException), e:
491
self._translate_io_exception(e, tmp_abspath)
492
# XXX: This doesn't truly help like we would like it to.
493
# The problem is that openssh strips sticky bits. So while we
494
# can properly set group write permission, we lose the group
495
# sticky bit. So it is probably best to stop chmodding, and
496
# just tell users that they need to set the umask correctly.
497
# The attr.st_mode = mode, in _sftp_open_exclusive
498
# will handle when the user wants the final mode to be more
499
# restrictive. And then we avoid a round trip. Unless
500
# paramiko decides to expose an async chmod()
502
# This is designed to chmod() right before we close.
503
# Because we set_pipelined() earlier, theoretically we might
504
# avoid the round trip for fout.close()
506
self._get_sftp().chmod(tmp_abspath, mode)
509
self._rename_and_overwrite(tmp_abspath, abspath)
512
# If we fail, try to clean up the temporary file
513
# before we throw the exception
514
# but don't let another exception mess things up
515
# Write out the traceback, because otherwise
516
# the catch and throw destroys it
518
mutter(traceback.format_exc())
522
self._get_sftp().remove(tmp_abspath)
524
# raise the saved except
526
# raise the original with its traceback if we can.
529
def _put_non_atomic_helper(self, relpath, writer, mode=None,
530
create_parent_dir=False,
532
abspath = self._remote_path(relpath)
534
# TODO: jam 20060816 paramiko doesn't publicly expose a way to
535
# set the file mode at create time. If it does, use it.
536
# But for now, we just chmod later anyway.
538
def _open_and_write_file():
539
"""Try to open the target file, raise error on failure"""
543
fout = self._get_sftp().file(abspath, mode='wb')
544
fout.set_pipelined(True)
546
except (paramiko.SSHException, IOError), e:
547
self._translate_io_exception(e, abspath,
550
# This is designed to chmod() right before we close.
551
# Because we set_pipelined() earlier, theoretically we might
552
# avoid the round trip for fout.close()
554
self._get_sftp().chmod(abspath, mode)
559
if not create_parent_dir:
560
_open_and_write_file()
563
# Try error handling to create the parent directory if we need to
565
_open_and_write_file()
567
# Try to create the parent directory, and then go back to
569
parent_dir = os.path.dirname(abspath)
570
self._mkdir(parent_dir, dir_mode)
571
_open_and_write_file()
573
def put_file_non_atomic(self, relpath, f, mode=None,
574
create_parent_dir=False,
576
"""Copy the file-like object into the target location.
578
This function is not strictly safe to use. It is only meant to
579
be used when you already know that the target does not exist.
580
It is not safe, because it will open and truncate the remote
581
file. So there may be a time when the file has invalid contents.
583
:param relpath: The remote location to put the contents.
584
:param f: File-like object.
585
:param mode: Possible access permissions for new file.
586
None means do not set remote permissions.
587
:param create_parent_dir: If we cannot create the target file because
588
the parent directory does not exist, go ahead and
589
create it, and then try again.
593
self._put_non_atomic_helper(relpath, writer, mode=mode,
594
create_parent_dir=create_parent_dir,
597
def put_bytes_non_atomic(self, relpath, raw_bytes, mode=None,
598
create_parent_dir=False,
600
if not isinstance(raw_bytes, str):
602
'raw_bytes must be a plain string, not %s' % type(raw_bytes))
605
fout.write(raw_bytes)
606
self._put_non_atomic_helper(relpath, writer, mode=mode,
607
create_parent_dir=create_parent_dir,
610
def iter_files_recursive(self):
611
"""Walk the relative paths of all files in this transport."""
612
# progress is handled by list_dir
613
queue = list(self.list_dir('.'))
615
relpath = queue.pop(0)
616
st = self.stat(relpath)
617
if stat.S_ISDIR(st.st_mode):
618
for i, basename in enumerate(self.list_dir(relpath)):
619
queue.insert(i, relpath+'/'+basename)
623
def _mkdir(self, abspath, mode=None):
629
self._report_activity(len(abspath), 'write')
630
self._get_sftp().mkdir(abspath, local_mode)
631
self._report_activity(1, 'read')
633
# chmod a dir through sftp will erase any sgid bit set
634
# on the server side. So, if the bit mode are already
635
# set, avoid the chmod. If the mode is not fine but
636
# the sgid bit is set, report a warning to the user
637
# with the umask fix.
638
stat = self._get_sftp().lstat(abspath)
639
mode = mode & 0777 # can't set special bits anyway
640
if mode != stat.st_mode & 0777:
641
if stat.st_mode & 06000:
642
warning('About to chmod %s over sftp, which will result'
643
' in its suid or sgid bits being cleared. If'
644
' you want to preserve those bits, change your '
645
' environment on the server to use umask 0%03o.'
646
% (abspath, 0777 - mode))
647
self._get_sftp().chmod(abspath, mode=mode)
648
except (paramiko.SSHException, IOError), e:
649
self._translate_io_exception(e, abspath, ': unable to mkdir',
650
failure_exc=FileExists)
652
def mkdir(self, relpath, mode=None):
653
"""Create a directory at the given path."""
654
self._mkdir(self._remote_path(relpath), mode=mode)
656
def open_write_stream(self, relpath, mode=None):
657
"""See Transport.open_write_stream."""
658
# initialise the file to zero-length
659
# this is three round trips, but we don't use this
660
# api more than once per write_group at the moment so
661
# it is a tolerable overhead. Better would be to truncate
662
# the file after opening. RBC 20070805
663
self.put_bytes_non_atomic(relpath, "", mode)
664
abspath = self._remote_path(relpath)
665
# TODO: jam 20060816 paramiko doesn't publicly expose a way to
666
# set the file mode at create time. If it does, use it.
667
# But for now, we just chmod later anyway.
670
handle = self._get_sftp().file(abspath, mode='wb')
671
handle.set_pipelined(True)
672
except (paramiko.SSHException, IOError), e:
673
self._translate_io_exception(e, abspath,
675
_file_streams[self.abspath(relpath)] = handle
676
return FileFileStream(self, relpath, handle)
678
def _translate_io_exception(self, e, path, more_info='',
679
failure_exc=PathError):
680
"""Translate a paramiko or IOError into a friendlier exception.
682
:param e: The original exception
683
:param path: The path in question when the error is raised
684
:param more_info: Extra information that can be included,
685
such as what was going on
686
:param failure_exc: Paramiko has the super fun ability to raise completely
687
opaque errors that just set "e.args = ('Failure',)" with
689
If this parameter is set, it defines the exception
690
to raise in these cases.
692
# paramiko seems to generate detailless errors.
693
self._translate_error(e, path, raise_generic=False)
694
if getattr(e, 'args', None) is not None:
695
if (e.args == ('No such file or directory',) or
696
e.args == ('No such file',)):
697
raise NoSuchFile(path, str(e) + more_info)
698
if (e.args == ('mkdir failed',) or
699
e.args[0].startswith('syserr: File exists')):
700
raise FileExists(path, str(e) + more_info)
701
# strange but true, for the paramiko server.
702
if (e.args == ('Failure',)):
703
raise failure_exc(path, str(e) + more_info)
704
# Can be something like args = ('Directory not empty:
705
# '/srv/bazaar.launchpad.net/blah...: '
706
# [Errno 39] Directory not empty',)
707
if (e.args[0].startswith('Directory not empty: ')
708
or getattr(e, 'errno', None) == errno.ENOTEMPTY):
709
raise errors.DirectoryNotEmpty(path, str(e))
710
if e.args == ('Operation unsupported',):
711
raise errors.TransportNotPossible()
712
mutter('Raising exception with args %s', e.args)
713
if getattr(e, 'errno', None) is not None:
714
mutter('Raising exception with errno %s', e.errno)
717
def append_file(self, relpath, f, mode=None):
719
Append the text in the file-like object into the final
723
path = self._remote_path(relpath)
724
fout = self._get_sftp().file(path, 'ab')
726
self._get_sftp().chmod(path, mode)
730
except (IOError, paramiko.SSHException), e:
731
self._translate_io_exception(e, relpath, ': unable to append')
733
def rename(self, rel_from, rel_to):
734
"""Rename without special overwriting"""
736
self._get_sftp().rename(self._remote_path(rel_from),
737
self._remote_path(rel_to))
738
except (IOError, paramiko.SSHException), e:
739
self._translate_io_exception(e, rel_from,
740
': unable to rename to %r' % (rel_to))
742
def _rename_and_overwrite(self, abs_from, abs_to):
743
"""Do a fancy rename on the remote server.
745
Using the implementation provided by osutils.
748
sftp = self._get_sftp()
749
fancy_rename(abs_from, abs_to,
750
rename_func=sftp.rename,
751
unlink_func=sftp.remove)
752
except (IOError, paramiko.SSHException), e:
753
self._translate_io_exception(e, abs_from,
754
': unable to rename to %r' % (abs_to))
756
def move(self, rel_from, rel_to):
757
"""Move the item at rel_from to the location at rel_to"""
758
path_from = self._remote_path(rel_from)
759
path_to = self._remote_path(rel_to)
760
self._rename_and_overwrite(path_from, path_to)
762
def delete(self, relpath):
763
"""Delete the item at relpath"""
764
path = self._remote_path(relpath)
766
self._get_sftp().remove(path)
767
except (IOError, paramiko.SSHException), e:
768
self._translate_io_exception(e, path, ': unable to delete')
770
def external_url(self):
771
"""See bzrlib.transport.Transport.external_url."""
772
# the external path for SFTP is the base
776
"""Return True if this store supports listing."""
779
def list_dir(self, relpath):
781
Return a list of all files at the given location.
783
# does anything actually use this?
785
# This is at least used by copy_tree for remote upgrades.
786
# -- David Allouche 2006-08-11
787
path = self._remote_path(relpath)
789
entries = self._get_sftp().listdir(path)
790
self._report_activity(sum(map(len, entries)), 'read')
791
except (IOError, paramiko.SSHException), e:
792
self._translate_io_exception(e, path, ': failed to list_dir')
793
return [urlutils.escape(entry) for entry in entries]
795
def rmdir(self, relpath):
796
"""See Transport.rmdir."""
797
path = self._remote_path(relpath)
799
return self._get_sftp().rmdir(path)
800
except (IOError, paramiko.SSHException), e:
801
self._translate_io_exception(e, path, ': failed to rmdir')
803
def stat(self, relpath):
804
"""Return the stat information for a file."""
805
path = self._remote_path(relpath)
807
return self._get_sftp().lstat(path)
808
except (IOError, paramiko.SSHException), e:
809
self._translate_io_exception(e, path, ': unable to stat')
811
def readlink(self, relpath):
812
"""See Transport.readlink."""
813
path = self._remote_path(relpath)
815
return self._get_sftp().readlink(path)
816
except (IOError, paramiko.SSHException), e:
817
self._translate_io_exception(e, path, ': unable to readlink')
819
def symlink(self, source, link_name):
820
"""See Transport.symlink."""
822
conn = self._get_sftp()
823
sftp_retval = conn.symlink(source, link_name)
824
if SFTP_OK != sftp_retval:
825
raise TransportError(
826
'%r: unable to create symlink to %r' % (link_name, source),
829
except (IOError, paramiko.SSHException), e:
830
self._translate_io_exception(e, link_name,
831
': unable to create symlink to %r' % (source))
833
def lock_read(self, relpath):
835
Lock the given file for shared (read) access.
836
:return: A lock object, which has an unlock() member function
838
# FIXME: there should be something clever i can do here...
839
class BogusLock(object):
840
def __init__(self, path):
844
return BogusLock(relpath)
846
def lock_write(self, relpath):
848
Lock the given file for exclusive (write) access.
849
WARNING: many transports do not support this, so trying avoid using it
851
:return: A lock object, which has an unlock() member function
853
# This is a little bit bogus, but basically, we create a file
854
# which should not already exist, and if it does, we assume
855
# that there is a lock, and if it doesn't, the we assume
856
# that we have taken the lock.
857
return SFTPLock(relpath, self)
859
def _sftp_open_exclusive(self, abspath, mode=None):
860
"""Open a remote path exclusively.
862
SFTP supports O_EXCL (SFTP_FLAG_EXCL), which fails if
863
the file already exists. However it does not expose this
864
at the higher level of SFTPClient.open(), so we have to
867
WARNING: This breaks the SFTPClient abstraction, so it
868
could easily break against an updated version of paramiko.
870
:param abspath: The remote absolute path where the file should be opened
871
:param mode: The mode permissions bits for the new file
873
# TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
874
# using the 'x' flag to indicate SFTP_FLAG_EXCL.
875
# However, there is no way to set the permission mode at open
876
# time using the sftp_client.file() functionality.
877
path = self._get_sftp()._adjust_cwd(abspath)
878
# mutter('sftp abspath %s => %s', abspath, path)
879
attr = SFTPAttributes()
882
omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
883
| SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
885
t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
887
raise TransportError('Expected an SFTP handle')
888
handle = msg.get_string()
889
return SFTPFile(self._get_sftp(), handle, 'wb', -1)
890
except (paramiko.SSHException, IOError), e:
891
self._translate_io_exception(e, abspath, ': unable to open',
892
failure_exc=FileExists)
894
def _can_roundtrip_unix_modebits(self):
895
if sys.platform == 'win32':
902
def get_test_permutations():
903
"""Return the permutations to be used in testing."""
904
from bzrlib.tests import stub_sftp
905
return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
906
(SFTPTransport, stub_sftp.SFTPHomeDirServer),
907
(SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
added
removed
bzrlib/transport/sftp.py
