← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/medium.py

  • Committer: Andrew Bennetts
  • Date: 2010-03-18 23:11:15 UTC
  • mto: This revision was merged to the branch mainline in revision 5117.
  • Revision ID: andrew.bennetts@canonical.com-20100318231115-zrjij60gnj7qg6jw
Consolidate changes, try to minimise unnecessary changes and tidy up those that kept.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/medium.py
24
24
bzrlib/transport/smart/__init__.py.
25
25
"""
26
26
 
27
 
import errno
28
27
import os
29
 
import socket
30
28
import sys
31
29
import urllib
32
30
 
33
31
from bzrlib.lazy_import import lazy_import
34
32
lazy_import(globals(), """
35
33
import atexit
 
34
import socket
36
35
import thread
37
36
import weakref
38
37
 
47
46
from bzrlib.smart import client, protocol, request, vfs
48
47
from bzrlib.transport import ssh
49
48
""")
50
 
#usually already imported, and getting IllegalScoperReplacer on it here.
51
49
from bzrlib import osutils
52
50
 
53
 
# We must not read any more than 64k at a time so we don't risk "no buffer
54
 
# space available" errors on some platforms.  Windows in particular is likely
55
 
# to throw WSAECONNABORTED or WSAENOBUFS if given too much data at once.
56
51
# Throughout this module buffer size parameters are either limited to be at
57
 
# most 64k, or are ignored and 64k is used instead.
58
 
_MAX_READ_SIZE = 64 * 1024
59
 
 
 
52
# most _MAX_READ_SIZE, or are ignored and _MAX_READ_SIZE is used instead.
 
53
# For this module's purposes, MAX_SOCKET_CHUNK is a reasonable size for reads
 
54
# from non-sockets as well.
 
55
_MAX_READ_SIZE = osutils.MAX_SOCKET_CHUNK
60
56
 
61
57
def _get_protocol_factory_for_bytes(bytes):
62
58
    """Determine the right protocol factory for 'bytes'.
278
274
    def _serve_one_request_unguarded(self, protocol):
279
275
        while protocol.next_read_size():
280
276
            # We can safely try to read large chunks.  If there is less data
281
 
            # than _MAX_READ_SIZE ready, the socket wil just return a short
282
 
            # read immediately rather than block.
283
 
            bytes = self.read_bytes(_MAX_READ_SIZE)
 
277
            # than MAX_SOCKET_CHUNK ready, the socket will just return a
 
278
            # short read immediately rather than block.
 
279
            bytes = self.read_bytes(osutils.MAX_SOCKET_CHUNK)
284
280
            if bytes == '':
285
281
                self.finished = True
286
282
                return
289
285
        self._push_back(protocol.unused_data)
290
286
 
291
287
    def _read_bytes(self, desired_count):
292
 
        return _read_bytes_from_socket(self.socket, self._report_activity)
 
288
        return osutils.read_bytes_from_socket(
 
289
            self.socket, self._report_activity)
293
290
 
294
291
    def terminate_due_to_error(self):
295
292
        # TODO: This should log to a server log file, but no such thing
714
711
    This client does not manage the pipes: it assumes they will always be open.
715
712
 
716
713
    Note that if readable_pipe.read might raise IOError or OSError with errno
717
 
    of EINTR, it must be safe to retry the read.
 
714
    of EINTR, it must be safe to retry the read.  Plain CPython fileobjects
 
715
    (such as used for sys.stdin) are safe.
718
716
    """
719
717
 
720
718
    def __init__(self, readable_pipe, writeable_pipe, base):
902
900
        """See SmartClientMedium.read_bytes."""
903
901
        if not self._connected:
904
902
            raise errors.MediumNotConnected(self)
905
 
        return _read_bytes_from_socket(self._socket, self._report_activity)
 
903
        return osutils.read_bytes_from_socket(
 
904
            self._socket, self._report_activity)
906
905
 
907
906
 
908
907
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
945
944
        self._medium._flush()
946
945
 
947
946
 
948
 
def _read_bytes_from_socket(sock, report_activity,
949
 
        max_read_size=_MAX_READ_SIZE):
950
 
    """Read up to max_read_size of bytes from sock and notify of progress.
951
 
 
952
 
    Translates "Connection reset by peer" into file-like EOF (return an
953
 
    empty string rather than raise an error), and repeats the recv if
954
 
    interrupted by a signal.
955
 
    """
956
 
    while 1:
957
 
        try:
958
 
            bytes = sock.recv(_MAX_READ_SIZE)
959
 
        except socket.error, e:
960
 
            eno = e.args[0]
961
 
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
962
 
                # The connection was closed by the other side.  Callers expect
963
 
                # an empty string to signal end-of-stream.
964
 
                return ""
965
 
            elif eno == errno.EINTR:
966
 
                # Retry the interrupted recv.
967
 
                continue
968
 
            raise
969
 
        else:
970
 
            report_activity(len(bytes), 'read')
971
 
            return bytes
972
 
 
973