« back to all changes in this revision
Viewing changes to bzrlib/smart/medium.py
- browse files at revision 5246.2.21
- compare with another revision
- download diff
- download tarball
- view history from revision 5246.2.21
- Committer: Andrew Bennetts
- Date: 2010-06-17 05:37:26 UTC
- mfrom: (5299 +trunk)
- mto: (5050.3.16 2.2)
- mto: This revision was merged to the branch mainline in revision 5365.
- Revision ID: andrew.bennetts@canonical.com-20100617053726-wcev5m894cs4hrtz
Merge lp:bzr.
- files modified:
- NEWS
added
removed
bzrlib/smart/medium.py
715
715
"""A client medium using simple pipes.
716
716
717
717
This client does not manage the pipes: it assumes they will always be open.
718
719
Note that if readable_pipe.read might raise IOError or OSError with errno
720
of EINTR, it must be safe to retry the read. Plain CPython fileobjects
721
(such as used for sys.stdin) are safe.
722
718
"""
723
719
724
720
def __init__(self, readable_pipe, writeable_pipe, base):
737
733
738
734
def _read_bytes(self, count):
739
735
"""See SmartClientStreamMedium._read_bytes."""
740
bytes = osutils.until_no_eintr(self._readable_pipe.read, count)
736
bytes_to_read = min(count, _MAX_READ_SIZE)
737
bytes = self._readable_pipe.read(bytes_to_read)
741
738
self._report_activity(len(bytes), 'read')
742
739
return bytes
743
740
744
741
742
class SSHParams(object):
743
"""A set of parameters for starting a remote bzr via SSH."""
744
745
def __init__(self, host, port=None, username=None, password=None,
746
bzr_remote_path='bzr'):
747
self.host = host
748
self.port = port
749
self.username = username
750
self.password = password
751
self.bzr_remote_path = bzr_remote_path
752
753
745
754
class SmartSSHClientMedium(SmartClientStreamMedium):
746
"""A client medium using SSH."""
755
"""A client medium using SSH.
756
757
It delegates IO to a SmartClientSocketMedium or
758
SmartClientAlreadyConnectedSocketMedium (depending on platform).
759
"""
747
760
748
def __init__(self, host, port=None, username=None, password=None,
749
base=None, vendor=None, bzr_remote_path=None):
761
def __init__(self, base, ssh_params, vendor=None):
750
762
"""Creates a client that will connect on the first use.
751
763
764
:param ssh_params: A SSHParams instance.
752
765
:param vendor: An optional override for the ssh vendor to use. See
753
766
bzrlib.transport.ssh for details on ssh vendors.
754
767
"""
755
self._connected = False
756
self._host = host
757
self._password = password
758
self._port = port
759
self._username = username
768
self._real_medium = None
769
self._ssh_params = ssh_params
760
770
# for the benefit of progress making a short description of this
761
771
# transport
762
772
self._scheme = 'bzr+ssh'
764
774
# _DebugCounter so we have to store all the values used in our repr
765
775
# method before calling the super init.
766
776
SmartClientStreamMedium.__init__(self, base)
767
self._read_from = None
777
self._vendor = vendor
768
778
self._ssh_connection = None
769
self._vendor = vendor
770
self._write_to = None
771
self._bzr_remote_path = bzr_remote_path
772
779
773
780
def __repr__(self):
774
if self._port is None:
781
if self._ssh_params.port is None:
775
782
maybe_port = ''
776
783
else:
777
maybe_port = ':%s' % self._port
784
maybe_port = ':%s' % self._ssh_params.port
778
785
return "%s(%s://%s@%s%s/)" % (
779
786
self.__class__.__name__,
780
787
self._scheme,
781
self._username,
782
self._host,
788
self._ssh_params.username,
789
self._ssh_params.host,
783
790
maybe_port)
784
791
785
792
def _accept_bytes(self, bytes):
786
793
"""See SmartClientStreamMedium.accept_bytes."""
787
794
self._ensure_connection()
788
self._write_to.write(bytes)
789
self._report_activity(len(bytes), 'write')
795
self._real_medium.accept_bytes(bytes)
790
796
791
797
def disconnect(self):
792
798
"""See SmartClientMedium.disconnect()."""
793
if not self._connected:
794
return
795
self._read_from.close()
796
self._write_to.close()
797
self._ssh_connection.close()
798
self._connected = False
799
if self._real_medium is not None:
800
self._real_medium.disconnect()
801
self._real_medium = None
802
if self._ssh_connection is not None:
803
self._ssh_connection.close()
804
self._ssh_connection = None
799
805
800
806
def _ensure_connection(self):
801
807
"""Connect this medium if not already connected."""
802
if self._connected:
808
if self._real_medium is not None:
803
809
return
804
810
if self._vendor is None:
805
811
vendor = ssh._get_ssh_vendor()
806
812
else:
807
813
vendor = self._vendor
808
self._ssh_connection = vendor.connect_ssh(self._username,
809
self._password, self._host, self._port,
810
command=[self._bzr_remote_path, 'serve', '--inet',
814
self._ssh_connection = vendor.connect_ssh(self._ssh_params.username,
815
self._ssh_params.password, self._ssh_params.host,
816
self._ssh_params.port,
817
command=[self._ssh_params.bzr_remote_path, 'serve', '--inet',
811
818
'--directory=/', '--allow-writes'])
812
self._read_from, self._write_to = \
813
self._ssh_connection.get_filelike_channels()
814
self._connected = True
819
io_kind, io_object = self._ssh_connection.get_sock_or_pipes()
820
if io_kind == 'socket':
821
self._real_medium = SmartClientAlreadyConnectedSocketMedium(
822
self.base, io_object)
823
elif io_kind == 'pipes':
824
read_from, write_to = io_object
825
self._real_medium = SmartSimplePipesClientMedium(
826
read_from, write_to, self.base)
827
else:
828
raise AssertionError(
829
"Unexpected io_kind %r from %r"
830
% (io_kind, self._ssh_connection))
815
831
816
832
def _flush(self):
817
833
"""See SmartClientStreamMedium._flush()."""
818
self._write_to.flush()
834
self._real_medium._flush()
819
835
820
836
def _read_bytes(self, count):
821
837
"""See SmartClientStreamMedium.read_bytes."""
822
if not self._connected:
838
if self._real_medium is None:
823
839
raise errors.MediumNotConnected(self)
824
bytes_to_read = min(count, _MAX_READ_SIZE)
825
bytes = self._read_from.read(bytes_to_read)
826
self._report_activity(len(bytes), 'read')
827
return bytes
840
return self._real_medium.read_bytes(count)
828
841
829
842
830
843
# Port 4155 is the default port for bzr://, registered with IANA.
832
845
BZR_DEFAULT_PORT = 4155
833
846
834
847
835
class SmartTCPClientMedium(SmartClientStreamMedium):
836
"""A client medium using TCP."""
848
class SmartClientSocketMedium(SmartClientStreamMedium):
849
"""A client medium using a socket.
850
851
This class isn't usable directly. Use one of its subclasses instead.
852
"""
837
853
838
def __init__(self, host, port, base):
839
"""Creates a client that will connect on the first use."""
854
def __init__(self, base):
840
855
SmartClientStreamMedium.__init__(self, base)
856
self._socket = None
841
857
self._connected = False
842
self._host = host
843
self._port = port
844
self._socket = None
845
858
846
859
def _accept_bytes(self, bytes):
847
860
"""See SmartClientMedium.accept_bytes."""
848
861
self._ensure_connection()
849
862
osutils.send_all(self._socket, bytes, self._report_activity)
850
863
864
def _ensure_connection(self):
865
"""Connect this medium if not already connected."""
866
raise NotImplementedError(self._ensure_connection)
867
868
def _flush(self):
869
"""See SmartClientStreamMedium._flush().
870
871
For sockets we do no flushing. For TCP sockets we may want to turn off
872
TCP_NODELAY and add a means to do a flush, but that can be done in the
873
future.
874
"""
875
876
def _read_bytes(self, count):
877
"""See SmartClientMedium.read_bytes."""
878
if not self._connected:
879
raise errors.MediumNotConnected(self)
880
return osutils.read_bytes_from_socket(
881
self._socket, self._report_activity)
882
851
883
def disconnect(self):
852
884
"""See SmartClientMedium.disconnect()."""
853
885
if not self._connected:
856
888
self._socket = None
857
889
self._connected = False
858
890
891
892
class SmartTCPClientMedium(SmartClientSocketMedium):
893
"""A client medium that creates a TCP connection."""
894
895
def __init__(self, host, port, base):
896
"""Creates a client that will connect on the first use."""
897
SmartClientSocketMedium.__init__(self, base)
898
self._host = host
899
self._port = port
900
859
901
def _ensure_connection(self):
860
902
"""Connect this medium if not already connected."""
861
903
if self._connected:
895
937
(self._host, port, err_msg))
896
938
self._connected = True
897
939
898
def _flush(self):
899
"""See SmartClientStreamMedium._flush().
900
901
For TCP we do no flushing. We may want to turn off TCP_NODELAY and
902
add a means to do a flush, but that can be done in the future.
903
"""
904
905
def _read_bytes(self, count):
906
"""See SmartClientMedium.read_bytes."""
907
if not self._connected:
908
raise errors.MediumNotConnected(self)
909
return osutils.read_bytes_from_socket(
910
self._socket, self._report_activity)
940
941
class SmartClientAlreadyConnectedSocketMedium(SmartClientSocketMedium):
942
"""A client medium for an already connected socket.
943
944
Note that this class will assume it "owns" the socket, so it will close it
945
when its disconnect method is called.
946
"""
947
948
def __init__(self, base, sock):
949
SmartClientSocketMedium.__init__(self, base)
950
self._socket = sock
951
self._connected = True
952
953
def _ensure_connection(self):
954
# Already connected, by definition! So nothing to do.
955
pass
911
956
912
957
913
958
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1