/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: Canonical.com Patch Queue Manager
  • Date: 2008-10-23 17:59:52 UTC
  • mfrom: (3788.1.5 msvc_python24)
  • Revision ID: pqm@pqm.ubuntu.com-20081023175952-0gr8np56nf6ab5yn
(jam) Allow extensions to compile for python2.4 and using msvc

Show diffs side-by-side

added added

removed removed

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