← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/medium.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/medium.py
87
87
 
88
88
def _get_line(read_bytes_func):
89
89
    """Read bytes using read_bytes_func until a newline byte.
90
 
    
 
90
 
91
91
    This isn't particularly efficient, so should only be used when the
92
92
    expected size of the line is quite short.
93
 
    
 
93
 
94
94
    :returns: a tuple of two strs: (line, excess)
95
95
    """
96
96
    newline_pos = -1
112
112
 
113
113
    def __init__(self):
114
114
        self._push_back_buffer = None
115
 
        
 
115
 
116
116
    def _push_back(self, bytes):
117
117
        """Return unused bytes to the medium, because they belong to the next
118
118
        request(s).
152
152
 
153
153
    def _get_line(self):
154
154
        """Read bytes from this request's response until a newline byte.
155
 
        
 
155
 
156
156
        This isn't particularly efficient, so should only be used when the
157
157
        expected size of the line is quite short.
158
158
 
161
161
        line, excess = _get_line(self.read_bytes)
162
162
        self._push_back(excess)
163
163
        return line
164
 
 
 
164
 
165
165
 
166
166
class SmartServerStreamMedium(SmartMedium):
167
167
    """Handles smart commands coming over a stream.
172
172
    One instance is created for each connected client; it can serve multiple
173
173
    requests in the lifetime of the connection.
174
174
 
175
 
    The server passes requests through to an underlying backing transport, 
 
175
    The server passes requests through to an underlying backing transport,
176
176
    which will typically be a LocalTransport looking at the server's filesystem.
177
177
 
178
178
    :ivar _push_back_buffer: a str of bytes that have been read from the stream
223
223
 
224
224
    def _serve_one_request(self, protocol):
225
225
        """Read one request from input, process, send back a response.
226
 
        
 
226
 
227
227
        :param protocol: a SmartServerRequestProtocol.
228
228
        """
229
229
        try:
268
268
                self.finished = True
269
269
                return
270
270
            protocol.accept_bytes(bytes)
271
 
        
 
271
 
272
272
        self._push_back(protocol.unused_data)
273
273
 
274
274
    def _read_bytes(self, desired_count):
350
350
    request.finished_reading()
351
351
 
352
352
    It is up to the individual SmartClientMedium whether multiple concurrent
353
 
    requests can exist. See SmartClientMedium.get_request to obtain instances 
354
 
    of SmartClientMediumRequest, and the concrete Medium you are using for 
 
353
    requests can exist. See SmartClientMedium.get_request to obtain instances
 
354
    of SmartClientMediumRequest, and the concrete Medium you are using for
355
355
    details on concurrency and pipelining.
356
356
    """
357
357
 
403
403
    def _finished_reading(self):
404
404
        """Helper for finished_reading.
405
405
 
406
 
        finished_reading checks the state of the request to determine if 
 
406
        finished_reading checks the state of the request to determine if
407
407
        finished_reading is allowed, and if it is hands off to _finished_reading
408
408
        to perform the action.
409
409
        """
423
423
    def _finished_writing(self):
424
424
        """Helper for finished_writing.
425
425
 
426
 
        finished_writing checks the state of the request to determine if 
 
426
        finished_writing checks the state of the request to determine if
427
427
        finished_writing is allowed, and if it is hands off to _finished_writing
428
428
        to perform the action.
429
429
        """
449
449
        read_bytes checks the state of the request to determing if bytes
450
450
        should be read. After that it hands off to _read_bytes to do the
451
451
        actual read.
452
 
        
 
452
 
453
453
        By default this forwards to self._medium.read_bytes because we are
454
454
        operating on the medium's stream.
455
455
        """
466
466
 
467
467
    def _read_line(self):
468
468
        """Helper for SmartClientMediumRequest.read_line.
469
 
        
 
469
 
470
470
        By default this forwards to self._medium._get_line because we are
471
471
        operating on the medium's stream.
472
472
        """
516
516
        value[0] = 0
517
517
        if count != 0:
518
518
            trace.note('HPSS calls: %d %s', count, medium_repr)
519
 
        
 
519
 
520
520
    def flush_all(self):
521
521
        for ref in list(self.counts.keys()):
522
522
            self.done(ref)
523
523
 
524
524
_debug_counter = None
525
 
  
526
 
  
 
525
 
 
526
 
527
527
class SmartClientMedium(SmartMedium):
528
528
    """Smart client is a medium for sending smart protocol requests over."""
529
529
 
621
621
 
622
622
    def disconnect(self):
623
623
        """If this medium maintains a persistent connection, close it.
624
 
        
 
624
 
625
625
        The default implementation does nothing.
626
626
        """
627
 
        
 
627
 
628
628
    def remote_path_from_transport(self, transport):
629
629
        """Convert transport into a path suitable for using in a request.
630
 
        
 
630
 
631
631
        Note that the resulting remote path doesn't encode the host name or
632
632
        anything but path, so it is only safe to use it in requests sent over
633
633
        the medium from the matching transport.
661
661
 
662
662
    def _flush(self):
663
663
        """Flush the output stream.
664
 
        
 
664
 
665
665
        This method is used by the SmartClientStreamMediumRequest to ensure that
666
666
        all data for a request is sent, to avoid long timeouts or deadlocks.
667
667
        """
678
678
 
679
679
class SmartSimplePipesClientMedium(SmartClientStreamMedium):
680
680
    """A client medium using simple pipes.
681
 
    
 
681
 
682
682
    This client does not manage the pipes: it assumes they will always be open.
683
683
    """
684
684
 
702
702
 
703
703
class SmartSSHClientMedium(SmartClientStreamMedium):
704
704
    """A client medium using SSH."""
705
 
    
 
705
 
706
706
    def __init__(self, host, port=None, username=None, password=None,
707
707
            base=None, vendor=None, bzr_remote_path=None):
708
708
        """Creates a client that will connect on the first use.
709
 
        
 
709
 
710
710
        :param vendor: An optional override for the ssh vendor to use. See
711
711
            bzrlib.transport.ssh for details on ssh vendors.
712
712
        """
776
776
 
777
777
class SmartTCPClientMedium(SmartClientStreamMedium):
778
778
    """A client medium using TCP."""
779
 
    
 
779
 
780
780
    def __init__(self, host, port, base):
781
781
        """Creates a client that will connect on the first use."""
782
782
        SmartClientStreamMedium.__init__(self, base)
807
807
        else:
808
808
            port = int(self._port)
809
809
        try:
810
 
            sockaddrs = socket.getaddrinfo(self._host, port, socket.AF_UNSPEC, 
 
810
            sockaddrs = socket.getaddrinfo(self._host, port, socket.AF_UNSPEC,
811
811
                socket.SOCK_STREAM, 0, 0)
812
812
        except socket.gaierror, (err_num, err_msg):
813
813
            raise errors.ConnectionError("failed to lookup %s:%d: %s" %
817
817
        for (family, socktype, proto, canonname, sockaddr) in sockaddrs:
818
818
            try:
819
819
                self._socket = socket.socket(family, socktype, proto)
820
 
                self._socket.setsockopt(socket.IPPROTO_TCP, 
 
820
                self._socket.setsockopt(socket.IPPROTO_TCP,
821
821
                                        socket.TCP_NODELAY, 1)
822
822
                self._socket.connect(sockaddr)
823
823
            except socket.error, err:
839
839
 
840
840
    def _flush(self):
841
841
        """See SmartClientStreamMedium._flush().
842
 
        
843
 
        For TCP we do no flushing. We may want to turn off TCP_NODELAY and 
 
842
 
 
843
        For TCP we do no flushing. We may want to turn off TCP_NODELAY and
844
844
        add a means to do a flush, but that can be done in the future.
845
845
        """
846
846
 
876
876
 
877
877
    def _accept_bytes(self, bytes):
878
878
        """See SmartClientMediumRequest._accept_bytes.
879
 
        
 
879
 
880
880
        This forwards to self._medium._accept_bytes because we are operating
881
881
        on the mediums stream.
882
882
        """
885
885
    def _finished_reading(self):
886
886
        """See SmartClientMediumRequest._finished_reading.
887
887
 
888
 
        This clears the _current_request on self._medium to allow a new 
 
888
        This clears the _current_request on self._medium to allow a new
889
889
        request to be created.
890
890
        """
891
891
        if self._medium._current_request is not self:
892
892
            raise AssertionError()
893
893
        self._medium._current_request = None
894
 
        
 
894
 
895
895
    def _finished_writing(self):
896
896
        """See SmartClientMediumRequest._finished_writing.
897
897