/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/sftp.py

  • Committer: Andrew Bennetts
  • Date: 2010-04-13 04:33:55 UTC
  • mfrom: (5147 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5149.
  • Revision ID: andrew.bennetts@canonical.com-20100413043355-lg3id0uwtju0k3zs
Merge lp:bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/sftp.py
1
 
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
2
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
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
 
29
28
import itertools
30
29
import os
31
30
import random
32
 
import select
33
 
import socket
34
31
import stat
35
32
import sys
36
33
import time
39
36
import warnings
40
37
 
41
38
from bzrlib import (
 
39
    config,
 
40
    debug,
42
41
    errors,
43
42
    urlutils,
44
43
    )
83
82
else:
84
83
    from paramiko.sftp import (SFTP_FLAG_WRITE, SFTP_FLAG_CREATE,
85
84
                               SFTP_FLAG_EXCL, SFTP_FLAG_TRUNC,
86
 
                               CMD_HANDLE, CMD_OPEN)
 
85
                               SFTP_OK, CMD_HANDLE, CMD_OPEN)
87
86
    from paramiko.sftp_attr import SFTPAttributes
88
87
    from paramiko.sftp_file import SFTPFile
89
88
 
95
94
 
96
95
class SFTPLock(object):
97
96
    """This fakes a lock in a remote location.
98
 
    
 
97
 
99
98
    A present lock is indicated just by the existence of a file.  This
100
 
    doesn't work well on all transports and they are only used in 
 
99
    doesn't work well on all transports and they are only used in
101
100
    deprecated storage formats.
102
101
    """
103
 
    
 
102
 
104
103
    __slots__ = ['path', 'lock_path', 'lock_file', 'transport']
105
104
 
106
105
    def __init__(self, path, transport):
139
138
    # See _get_requests for an explanation.
140
139
    _max_request_size = 32768
141
140
 
142
 
    def __init__(self, original_offsets, relpath):
 
141
    def __init__(self, original_offsets, relpath, _report_activity):
143
142
        """Create a new readv helper.
144
143
 
145
144
        :param original_offsets: The original requests given by the caller of
146
145
            readv()
147
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.
148
149
        """
149
150
        self.original_offsets = list(original_offsets)
150
151
        self.relpath = relpath
 
152
        self._report_activity = _report_activity
151
153
 
152
154
    def _get_requests(self):
153
155
        """Break up the offsets into individual requests over sftp.
179
181
                requests.append((start, next_size))
180
182
                size -= next_size
181
183
                start += next_size
182
 
        mutter('SFTP.readv(%s) %s offsets => %s coalesced => %s requests',
183
 
               self.relpath, len(sorted_offsets), len(coalesced),
184
 
               len(requests))
 
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))
185
188
        return requests
186
189
 
187
190
    def request_and_yield_offsets(self, fp):
218
221
            if len(data) != length:
219
222
                raise errors.ShortReadvError(self.relpath,
220
223
                    start, length, len(data))
 
224
            self._report_activity(length, 'read')
221
225
            if last_end is None:
222
226
                # This is the first request, just buffer it
223
227
                buffered_data = [data]
282
286
            del buffered_data[:]
283
287
            data_chunks.append((input_start, buffered))
284
288
        if data_chunks:
285
 
            mutter('SFTP readv left with %d out-of-order bytes',
286
 
                   sum(map(lambda x: len(x[1]), 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)))
287
292
            # We've processed all the readv data, at this point, anything we
288
293
            # couldn't process is in data_chunks. This doesn't happen often, so
289
294
            # this code path isn't optimized
294
299
            # get the previous node
295
300
            while True:
296
301
                idx = bisect.bisect_left(data_chunks, (cur_offset,))
297
 
                if data_chunks[idx][0] == cur_offset: # The data starts here
 
302
                if idx < len(data_chunks) and data_chunks[idx][0] == cur_offset:
 
303
                    # The data starts here
298
304
                    data = data_chunks[idx][1][:cur_size]
299
305
                elif idx > 0:
300
306
                    # The data is in a portion of a previous page
341
347
 
342
348
    def _remote_path(self, relpath):
343
349
        """Return the path to be passed along the sftp protocol for relpath.
344
 
        
 
350
 
345
351
        :param relpath: is a urlencoded string.
346
352
        """
347
353
        relative = urlutils.unescape(relpath).encode('utf-8')
375
381
            password = credentials
376
382
 
377
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)
378
388
        connection = vendor.connect_sftp(self._user, password,
379
389
                                         self._host, self._port)
380
 
        return connection, password
 
390
        return connection, (user, password)
381
391
 
382
392
    def _get_sftp(self):
383
393
        """Ensures that a connection is established"""
394
404
        """
395
405
        try:
396
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')
397
409
            return True
398
410
        except IOError:
399
411
            return False
400
412
 
401
413
    def get(self, relpath):
402
 
        """
403
 
        Get the file at the given relative path.
 
414
        """Get the file at the given relative path.
404
415
 
405
416
        :param relpath: The relative path to the file
406
417
        """
407
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
408
424
            path = self._remote_path(relpath)
409
425
            f = self._get_sftp().file(path, mode='rb')
410
426
            if self._do_prefetch and (getattr(f, 'prefetch', None) is not None):
414
430
            self._translate_io_exception(e, path, ': error retrieving',
415
431
                failure_exc=errors.ReadError)
416
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
 
417
443
    def _readv(self, relpath, offsets):
418
444
        """See Transport.readv()"""
419
445
        # We overload the default readv() because we want to use a file
428
454
            readv = getattr(fp, 'readv', None)
429
455
            if readv:
430
456
                return self._sftp_readv(fp, offsets, relpath)
431
 
            mutter('seek and read %s offsets', len(offsets))
 
457
            if 'sftp' in debug.debug_flags:
 
458
                mutter('seek and read %s offsets', len(offsets))
432
459
            return self._seek_and_read(fp, offsets, relpath)
433
460
        except (IOError, paramiko.SSHException), e:
434
461
            self._translate_io_exception(e, path, ': error retrieving')
441
468
        """
442
469
        return 64 * 1024
443
470
 
444
 
    def _sftp_readv(self, fp, offsets, relpath='<unknown>'):
 
471
    def _sftp_readv(self, fp, offsets, relpath):
445
472
        """Use the readv() member of fp to do async readv.
446
473
 
447
 
        And then read them using paramiko.readv(). paramiko.readv()
 
474
        Then read them using paramiko.readv(). paramiko.readv()
448
475
        does not support ranges > 64K, so it caps the request size, and
449
 
        just reads until it gets all the stuff it wants
 
476
        just reads until it gets all the stuff it wants.
450
477
        """
451
 
        helper = _SFTPReadvHelper(offsets, relpath)
 
478
        helper = _SFTPReadvHelper(offsets, relpath, self._report_activity)
452
479
        return helper.request_and_yield_offsets(fp)
453
480
 
454
481
    def put_file(self, relpath, f, mode=None):
480
507
            #      sticky bit. So it is probably best to stop chmodding, and
481
508
            #      just tell users that they need to set the umask correctly.
482
509
            #      The attr.st_mode = mode, in _sftp_open_exclusive
483
 
            #      will handle when the user wants the final mode to be more 
484
 
            #      restrictive. And then we avoid a round trip. Unless 
 
510
            #      will handle when the user wants the final mode to be more
 
511
            #      restrictive. And then we avoid a round trip. Unless
485
512
            #      paramiko decides to expose an async chmod()
486
513
 
487
514
            # This is designed to chmod() right before we close.
488
 
            # Because we set_pipelined() earlier, theoretically we might 
 
515
            # Because we set_pipelined() earlier, theoretically we might
489
516
            # avoid the round trip for fout.close()
490
517
            if mode is not None:
491
518
                self._get_sftp().chmod(tmp_abspath, mode)
533
560
                                                 ': unable to open')
534
561
 
535
562
                # This is designed to chmod() right before we close.
536
 
                # Because we set_pipelined() earlier, theoretically we might 
 
563
                # Because we set_pipelined() earlier, theoretically we might
537
564
                # avoid the round trip for fout.close()
538
565
                if mode is not None:
539
566
                    self._get_sftp().chmod(abspath, mode)
590
617
 
591
618
    def iter_files_recursive(self):
592
619
        """Walk the relative paths of all files in this transport."""
 
620
        # progress is handled by list_dir
593
621
        queue = list(self.list_dir('.'))
594
622
        while queue:
595
623
            relpath = queue.pop(0)
606
634
        else:
607
635
            local_mode = mode
608
636
        try:
 
637
            self._report_activity(len(abspath), 'write')
609
638
            self._get_sftp().mkdir(abspath, local_mode)
 
639
            self._report_activity(1, 'read')
610
640
            if mode is not None:
611
641
                # chmod a dir through sftp will erase any sgid bit set
612
642
                # on the server side.  So, if the bit mode are already
634
664
    def open_write_stream(self, relpath, mode=None):
635
665
        """See Transport.open_write_stream."""
636
666
        # initialise the file to zero-length
637
 
        # this is three round trips, but we don't use this 
638
 
        # api more than once per write_group at the moment so 
 
667
        # this is three round trips, but we don't use this
 
668
        # api more than once per write_group at the moment so
639
669
        # it is a tolerable overhead. Better would be to truncate
640
670
        # the file after opening. RBC 20070805
641
671
        self.put_bytes_non_atomic(relpath, "", mode)
664
694
        :param failure_exc: Paramiko has the super fun ability to raise completely
665
695
                           opaque errors that just set "e.args = ('Failure',)" with
666
696
                           no more information.
667
 
                           If this parameter is set, it defines the exception 
 
697
                           If this parameter is set, it defines the exception
668
698
                           to raise in these cases.
669
699
        """
670
700
        # paramiko seems to generate detailless errors.
679
709
            # strange but true, for the paramiko server.
680
710
            if (e.args == ('Failure',)):
681
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))
682
718
            mutter('Raising exception with args %s', e.args)
683
719
        if getattr(e, 'errno', None) is not None:
684
720
            mutter('Raising exception with errno %s', e.errno)
711
747
 
712
748
    def _rename_and_overwrite(self, abs_from, abs_to):
713
749
        """Do a fancy rename on the remote server.
714
 
        
 
750
 
715
751
        Using the implementation provided by osutils.
716
752
        """
717
753
        try:
736
772
            self._get_sftp().remove(path)
737
773
        except (IOError, paramiko.SSHException), e:
738
774
            self._translate_io_exception(e, path, ': unable to delete')
739
 
            
 
775
 
740
776
    def external_url(self):
741
777
        """See bzrlib.transport.Transport.external_url."""
742
778
        # the external path for SFTP is the base
757
793
        path = self._remote_path(relpath)
758
794
        try:
759
795
            entries = self._get_sftp().listdir(path)
 
796
            self._report_activity(sum(map(len, entries)), 'read')
760
797
        except (IOError, paramiko.SSHException), e:
761
798
            self._translate_io_exception(e, path, ': failed to list_dir')
762
799
        return [urlutils.escape(entry) for entry in entries]
773
810
        """Return the stat information for a file."""
774
811
        path = self._remote_path(relpath)
775
812
        try:
776
 
            return self._get_sftp().stat(path)
 
813
            return self._get_sftp().lstat(path)
777
814
        except (IOError, paramiko.SSHException), e:
778
815
            self._translate_io_exception(e, path, ': unable to stat')
779
816
 
 
817
    def readlink(self, relpath):
 
818
        """See Transport.readlink."""
 
819
        path = self._remote_path(relpath)
 
820
        try:
 
821
            return self._get_sftp().readlink(path)
 
822
        except (IOError, paramiko.SSHException), e:
 
823
            self._translate_io_exception(e, path, ': unable to readlink')
 
824
 
 
825
    def symlink(self, source, link_name):
 
826
        """See Transport.symlink."""
 
827
        try:
 
828
            conn = self._get_sftp()
 
829
            sftp_retval = conn.symlink(source, link_name)
 
830
            if SFTP_OK != sftp_retval:
 
831
                raise TransportError(
 
832
                    '%r: unable to create symlink to %r' % (link_name, source),
 
833
                    sftp_retval
 
834
                )
 
835
        except (IOError, paramiko.SSHException), e:
 
836
            self._translate_io_exception(e, link_name,
 
837
                                         ': unable to create symlink to %r' % (source))
 
838
 
780
839
    def lock_read(self, relpath):
781
840
        """
782
841
        Lock the given file for shared (read) access.
819
878
        """
820
879
        # TODO: jam 20060816 Paramiko >= 1.6.2 (probably earlier) supports
821
880
        #       using the 'x' flag to indicate SFTP_FLAG_EXCL.
822
 
        #       However, there is no way to set the permission mode at open 
 
881
        #       However, there is no way to set the permission mode at open
823
882
        #       time using the sftp_client.file() functionality.
824
883
        path = self._get_sftp()._adjust_cwd(abspath)
825
884
        # mutter('sftp abspath %s => %s', abspath, path)
826
885
        attr = SFTPAttributes()
827
886
        if mode is not None:
828
887
            attr.st_mode = mode
829
 
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE 
 
888
        omode = (SFTP_FLAG_WRITE | SFTP_FLAG_CREATE
830
889
                | SFTP_FLAG_TRUNC | SFTP_FLAG_EXCL)
831
890
        try:
832
891
            t, msg = self._get_sftp()._request(CMD_OPEN, path, omode, attr)
845
904
        else:
846
905
            return True
847
906
 
848
 
# ------------- server test implementation --------------
849
 
import threading
850
 
 
851
 
from bzrlib.tests.stub_sftp import StubServer, StubSFTPServer
852
 
 
853
 
STUB_SERVER_KEY = """
854
 
-----BEGIN RSA PRIVATE KEY-----
855
 
MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz
856
 
oWGW+GUjzKxTiiPvVmxFgx5wdsFvF03v34lEVVhMpouqPAYQ15N37K/ir5XY+9m/
857
 
d8ufMCkjeXsQkKqFbAlQcnWMCRnOoPHS3I4vi6hmnDDeeYTSRvfLbW0fhwIBIwKB
858
 
gBIiOqZYaoqbeD9OS9z2K9KR2atlTxGxOJPXiP4ESqP3NVScWNwyZ3NXHpyrJLa0
859
 
EbVtzsQhLn6rF+TzXnOlcipFvjsem3iYzCpuChfGQ6SovTcOjHV9z+hnpXvQ/fon
860
 
soVRZY65wKnF7IAoUwTmJS9opqgrN6kRgCd3DASAMd1bAkEA96SBVWFt/fJBNJ9H
861
 
tYnBKZGw0VeHOYmVYbvMSstssn8un+pQpUm9vlG/bp7Oxd/m+b9KWEh2xPfv6zqU
862
 
avNwHwJBANqzGZa/EpzF4J8pGti7oIAPUIDGMtfIcmqNXVMckrmzQ2vTfqtkEZsA
863
 
4rE1IERRyiJQx6EJsz21wJmGV9WJQ5kCQQDwkS0uXqVdFzgHO6S++tjmjYcxwr3g
864
 
H0CoFYSgbddOT6miqRskOQF3DZVkJT3kyuBgU2zKygz52ukQZMqxCb1fAkASvuTv
865
 
qfpH87Qq5kQhNKdbbwbmd2NxlNabazPijWuphGTdW0VfJdWfklyS2Kr+iqrs/5wV
866
 
HhathJt636Eg7oIjAkA8ht3MQ+XSl9yIJIS8gVpbPxSw5OMfw0PjVE7tBdQruiSc
867
 
nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7
868
 
-----END RSA PRIVATE KEY-----
869
 
"""
870
 
 
871
 
 
872
 
class SocketListener(threading.Thread):
873
 
 
874
 
    def __init__(self, callback):
875
 
        threading.Thread.__init__(self)
876
 
        self._callback = callback
877
 
        self._socket = socket.socket()
878
 
        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
879
 
        self._socket.bind(('localhost', 0))
880
 
        self._socket.listen(1)
881
 
        self.port = self._socket.getsockname()[1]
882
 
        self._stop_event = threading.Event()
883
 
 
884
 
    def stop(self):
885
 
        # called from outside this thread
886
 
        self._stop_event.set()
887
 
        # use a timeout here, because if the test fails, the server thread may
888
 
        # never notice the stop_event.
889
 
        self.join(5.0)
890
 
        self._socket.close()
891
 
 
892
 
    def run(self):
893
 
        while True:
894
 
            readable, writable_unused, exception_unused = \
895
 
                select.select([self._socket], [], [], 0.1)
896
 
            if self._stop_event.isSet():
897
 
                return
898
 
            if len(readable) == 0:
899
 
                continue
900
 
            try:
901
 
                s, addr_unused = self._socket.accept()
902
 
                # because the loopback socket is inline, and transports are
903
 
                # never explicitly closed, best to launch a new thread.
904
 
                threading.Thread(target=self._callback, args=(s,)).start()
905
 
            except socket.error, x:
906
 
                sys.excepthook(*sys.exc_info())
907
 
                warning('Socket error during accept() within unit test server'
908
 
                        ' thread: %r' % x)
909
 
            except Exception, x:
910
 
                # probably a failed test; unit test thread will log the
911
 
                # failure/error
912
 
                sys.excepthook(*sys.exc_info())
913
 
                warning('Exception from within unit test server thread: %r' % 
914
 
                        x)
915
 
 
916
 
 
917
 
class SocketDelay(object):
918
 
    """A socket decorator to make TCP appear slower.
919
 
 
920
 
    This changes recv, send, and sendall to add a fixed latency to each python
921
 
    call if a new roundtrip is detected. That is, when a recv is called and the
922
 
    flag new_roundtrip is set, latency is charged. Every send and send_all
923
 
    sets this flag.
924
 
 
925
 
    In addition every send, sendall and recv sleeps a bit per character send to
926
 
    simulate bandwidth.
927
 
 
928
 
    Not all methods are implemented, this is deliberate as this class is not a
929
 
    replacement for the builtin sockets layer. fileno is not implemented to
930
 
    prevent the proxy being bypassed. 
931
 
    """
932
 
 
933
 
    simulated_time = 0
934
 
    _proxied_arguments = dict.fromkeys([
935
 
        "close", "getpeername", "getsockname", "getsockopt", "gettimeout",
936
 
        "setblocking", "setsockopt", "settimeout", "shutdown"])
937
 
 
938
 
    def __init__(self, sock, latency, bandwidth=1.0, 
939
 
                 really_sleep=True):
940
 
        """ 
941
 
        :param bandwith: simulated bandwith (MegaBit)
942
 
        :param really_sleep: If set to false, the SocketDelay will just
943
 
        increase a counter, instead of calling time.sleep. This is useful for
944
 
        unittesting the SocketDelay.
945
 
        """
946
 
        self.sock = sock
947
 
        self.latency = latency
948
 
        self.really_sleep = really_sleep
949
 
        self.time_per_byte = 1 / (bandwidth / 8.0 * 1024 * 1024) 
950
 
        self.new_roundtrip = False
951
 
 
952
 
    def sleep(self, s):
953
 
        if self.really_sleep:
954
 
            time.sleep(s)
955
 
        else:
956
 
            SocketDelay.simulated_time += s
957
 
 
958
 
    def __getattr__(self, attr):
959
 
        if attr in SocketDelay._proxied_arguments:
960
 
            return getattr(self.sock, attr)
961
 
        raise AttributeError("'SocketDelay' object has no attribute %r" %
962
 
                             attr)
963
 
 
964
 
    def dup(self):
965
 
        return SocketDelay(self.sock.dup(), self.latency, self.time_per_byte,
966
 
                           self._sleep)
967
 
 
968
 
    def recv(self, *args):
969
 
        data = self.sock.recv(*args)
970
 
        if data and self.new_roundtrip:
971
 
            self.new_roundtrip = False
972
 
            self.sleep(self.latency)
973
 
        self.sleep(len(data) * self.time_per_byte)
974
 
        return data
975
 
 
976
 
    def sendall(self, data, flags=0):
977
 
        if not self.new_roundtrip:
978
 
            self.new_roundtrip = True
979
 
            self.sleep(self.latency)
980
 
        self.sleep(len(data) * self.time_per_byte)
981
 
        return self.sock.sendall(data, flags)
982
 
 
983
 
    def send(self, data, flags=0):
984
 
        if not self.new_roundtrip:
985
 
            self.new_roundtrip = True
986
 
            self.sleep(self.latency)
987
 
        bytes_sent = self.sock.send(data, flags)
988
 
        self.sleep(bytes_sent * self.time_per_byte)
989
 
        return bytes_sent
990
 
 
991
 
 
992
 
class SFTPServer(Server):
993
 
    """Common code for SFTP server facilities."""
994
 
 
995
 
    def __init__(self, server_interface=StubServer):
996
 
        self._original_vendor = None
997
 
        self._homedir = None
998
 
        self._server_homedir = None
999
 
        self._listener = None
1000
 
        self._root = None
1001
 
        self._vendor = ssh.ParamikoVendor()
1002
 
        self._server_interface = server_interface
1003
 
        # sftp server logs
1004
 
        self.logs = []
1005
 
        self.add_latency = 0
1006
 
 
1007
 
    def _get_sftp_url(self, path):
1008
 
        """Calculate an sftp url to this server for path."""
1009
 
        return 'sftp://foo:bar@localhost:%d/%s' % (self._listener.port, path)
1010
 
 
1011
 
    def log(self, message):
1012
 
        """StubServer uses this to log when a new server is created."""
1013
 
        self.logs.append(message)
1014
 
 
1015
 
    def _run_server_entry(self, sock):
1016
 
        """Entry point for all implementations of _run_server.
1017
 
        
1018
 
        If self.add_latency is > 0.000001 then sock is given a latency adding
1019
 
        decorator.
1020
 
        """
1021
 
        if self.add_latency > 0.000001:
1022
 
            sock = SocketDelay(sock, self.add_latency)
1023
 
        return self._run_server(sock)
1024
 
 
1025
 
    def _run_server(self, s):
1026
 
        ssh_server = paramiko.Transport(s)
1027
 
        key_file = pathjoin(self._homedir, 'test_rsa.key')
1028
 
        f = open(key_file, 'w')
1029
 
        f.write(STUB_SERVER_KEY)
1030
 
        f.close()
1031
 
        host_key = paramiko.RSAKey.from_private_key_file(key_file)
1032
 
        ssh_server.add_server_key(host_key)
1033
 
        server = self._server_interface(self)
1034
 
        ssh_server.set_subsystem_handler('sftp', paramiko.SFTPServer,
1035
 
                                         StubSFTPServer, root=self._root,
1036
 
                                         home=self._server_homedir)
1037
 
        event = threading.Event()
1038
 
        ssh_server.start_server(event, server)
1039
 
        event.wait(5.0)
1040
 
    
1041
 
    def setUp(self, backing_server=None):
1042
 
        # XXX: TODO: make sftpserver back onto backing_server rather than local
1043
 
        # disk.
1044
 
        if not (backing_server is None or
1045
 
                isinstance(backing_server, local.LocalURLServer)):
1046
 
            raise AssertionError(
1047
 
                "backing_server should not be %r, because this can only serve the "
1048
 
                "local current working directory." % (backing_server,))
1049
 
        self._original_vendor = ssh._ssh_vendor_manager._cached_ssh_vendor
1050
 
        ssh._ssh_vendor_manager._cached_ssh_vendor = self._vendor
1051
 
        if sys.platform == 'win32':
1052
 
            # Win32 needs to use the UNICODE api
1053
 
            self._homedir = getcwd()
1054
 
        else:
1055
 
            # But Linux SFTP servers should just deal in bytestreams
1056
 
            self._homedir = os.getcwd()
1057
 
        if self._server_homedir is None:
1058
 
            self._server_homedir = self._homedir
1059
 
        self._root = '/'
1060
 
        if sys.platform == 'win32':
1061
 
            self._root = ''
1062
 
        self._listener = SocketListener(self._run_server_entry)
1063
 
        self._listener.setDaemon(True)
1064
 
        self._listener.start()
1065
 
 
1066
 
    def tearDown(self):
1067
 
        """See bzrlib.transport.Server.tearDown."""
1068
 
        self._listener.stop()
1069
 
        ssh._ssh_vendor_manager._cached_ssh_vendor = self._original_vendor
1070
 
 
1071
 
    def get_bogus_url(self):
1072
 
        """See bzrlib.transport.Server.get_bogus_url."""
1073
 
        # this is chosen to try to prevent trouble with proxies, wierd dns, etc
1074
 
        # we bind a random socket, so that we get a guaranteed unused port
1075
 
        # we just never listen on that port
1076
 
        s = socket.socket()
1077
 
        s.bind(('localhost', 0))
1078
 
        return 'sftp://%s:%s/' % s.getsockname()
1079
 
 
1080
 
 
1081
 
class SFTPFullAbsoluteServer(SFTPServer):
1082
 
    """A test server for sftp transports, using absolute urls and ssh."""
1083
 
 
1084
 
    def get_url(self):
1085
 
        """See bzrlib.transport.Server.get_url."""
1086
 
        homedir = self._homedir
1087
 
        if sys.platform != 'win32':
1088
 
            # Remove the initial '/' on all platforms but win32
1089
 
            homedir = homedir[1:]
1090
 
        return self._get_sftp_url(urlutils.escape(homedir))
1091
 
 
1092
 
 
1093
 
class SFTPServerWithoutSSH(SFTPServer):
1094
 
    """An SFTP server that uses a simple TCP socket pair rather than SSH."""
1095
 
 
1096
 
    def __init__(self):
1097
 
        super(SFTPServerWithoutSSH, self).__init__()
1098
 
        self._vendor = ssh.LoopbackVendor()
1099
 
 
1100
 
    def _run_server(self, sock):
1101
 
        # Re-import these as locals, so that they're still accessible during
1102
 
        # interpreter shutdown (when all module globals get set to None, leading
1103
 
        # to confusing errors like "'NoneType' object has no attribute 'error'".
1104
 
        class FakeChannel(object):
1105
 
            def get_transport(self):
1106
 
                return self
1107
 
            def get_log_channel(self):
1108
 
                return 'paramiko'
1109
 
            def get_name(self):
1110
 
                return '1'
1111
 
            def get_hexdump(self):
1112
 
                return False
1113
 
            def close(self):
1114
 
                pass
1115
 
 
1116
 
        server = paramiko.SFTPServer(
1117
 
            FakeChannel(), 'sftp', StubServer(self), StubSFTPServer,
1118
 
            root=self._root, home=self._server_homedir)
1119
 
        try:
1120
 
            server.start_subsystem(
1121
 
                'sftp', None, ssh.SocketAsChannelAdapter(sock))
1122
 
        except socket.error, e:
1123
 
            if (len(e.args) > 0) and (e.args[0] == errno.EPIPE):
1124
 
                # it's okay for the client to disconnect abruptly
1125
 
                # (bug in paramiko 1.6: it should absorb this exception)
1126
 
                pass
1127
 
            else:
1128
 
                raise
1129
 
        except Exception, e:
1130
 
            # This typically seems to happen during interpreter shutdown, so
1131
 
            # most of the useful ways to report this error are won't work.
1132
 
            # Writing the exception type, and then the text of the exception,
1133
 
            # seems to be the best we can do.
1134
 
            import sys
1135
 
            sys.stderr.write('\nEXCEPTION %r: ' % (e.__class__,))
1136
 
            sys.stderr.write('%s\n\n' % (e,))
1137
 
        server.finish_subsystem()
1138
 
 
1139
 
 
1140
 
class SFTPAbsoluteServer(SFTPServerWithoutSSH):
1141
 
    """A test server for sftp transports, using absolute urls."""
1142
 
 
1143
 
    def get_url(self):
1144
 
        """See bzrlib.transport.Server.get_url."""
1145
 
        homedir = self._homedir
1146
 
        if sys.platform != 'win32':
1147
 
            # Remove the initial '/' on all platforms but win32
1148
 
            homedir = homedir[1:]
1149
 
        return self._get_sftp_url(urlutils.escape(homedir))
1150
 
 
1151
 
 
1152
 
class SFTPHomeDirServer(SFTPServerWithoutSSH):
1153
 
    """A test server for sftp transports, using homedir relative urls."""
1154
 
 
1155
 
    def get_url(self):
1156
 
        """See bzrlib.transport.Server.get_url."""
1157
 
        return self._get_sftp_url("~/")
1158
 
 
1159
 
 
1160
 
class SFTPSiblingAbsoluteServer(SFTPAbsoluteServer):
1161
 
    """A test server for sftp transports where only absolute paths will work.
1162
 
 
1163
 
    It does this by serving from a deeply-nested directory that doesn't exist.
1164
 
    """
1165
 
 
1166
 
    def setUp(self, backing_server=None):
1167
 
        self._server_homedir = '/dev/noone/runs/tests/here'
1168
 
        super(SFTPSiblingAbsoluteServer, self).setUp(backing_server)
1169
 
 
1170
907
 
1171
908
def get_test_permutations():
1172
909
    """Return the permutations to be used in testing."""
1173
 
    return [(SFTPTransport, SFTPAbsoluteServer),
1174
 
            (SFTPTransport, SFTPHomeDirServer),
1175
 
            (SFTPTransport, SFTPSiblingAbsoluteServer),
 
910
    from bzrlib.tests import stub_sftp
 
911
    return [(SFTPTransport, stub_sftp.SFTPAbsoluteServer),
 
912
            (SFTPTransport, stub_sftp.SFTPHomeDirServer),
 
913
            (SFTPTransport, stub_sftp.SFTPSiblingAbsoluteServer),
1176
914
            ]