← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/medium.py

  • Committer: Vincent Ladeuil
  • Date: 2010-06-17 09:23:19 UTC
  • mfrom: (5301 +trunk)
  • mto: (5247.1.8 first-try)
  • mto: This revision was merged to the branch mainline in revision 5326.
  • Revision ID: v.ladeuil+lp@free.fr-20100617092319-da2bzdtf3j0voynf
Merge bzr.dev into cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
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):