/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/smart/medium.py

  • Committer: Andrew Bennetts
  • Date: 2008-10-27 06:14:45 UTC
  • mfrom: (3793 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3795.
  • Revision ID: andrew.bennetts@canonical.com-20081027061445-eqt9lz6uw1mbvq4g
Merge from bzr.dev.

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
27
28
import os
28
29
import socket
29
30
import sys
31
32
 
32
33
from bzrlib.lazy_import import lazy_import
33
34
lazy_import(globals(), """
 
35
import atexit
 
36
import weakref
34
37
from bzrlib import (
 
38
    debug,
35
39
    errors,
36
40
    osutils,
37
41
    symbol_versioning,
 
42
    trace,
38
43
    urlutils,
39
44
    )
40
 
from bzrlib.smart import protocol
 
45
from bzrlib.smart import client, protocol
41
46
from bzrlib.transport import ssh
42
47
""")
43
48
 
468
473
        return self._medium._get_line()
469
474
 
470
475
 
 
476
class _DebugCounter(object):
 
477
    """An object that counts the HPSS calls made to each client medium.
 
478
 
 
479
    When a medium is garbage-collected, or failing that when atexit functions
 
480
    are run, the total number of calls made on that medium are reported via
 
481
    trace.note.
 
482
    """
 
483
 
 
484
    def __init__(self):
 
485
        self.counts = weakref.WeakKeyDictionary()
 
486
        client._SmartClient.hooks.install_named_hook(
 
487
            'call', self.increment_call_count, 'hpss call counter')
 
488
        atexit.register(self.flush_all)
 
489
 
 
490
    def track(self, medium):
 
491
        """Start tracking calls made to a medium.
 
492
 
 
493
        This only keeps a weakref to the medium, so shouldn't affect the
 
494
        medium's lifetime.
 
495
        """
 
496
        medium_repr = repr(medium)
 
497
        # Add this medium to the WeakKeyDictionary
 
498
        self.counts[medium] = [0, medium_repr]
 
499
        # Weakref callbacks are fired in reverse order of their association
 
500
        # with the referenced object.  So we add a weakref *after* adding to
 
501
        # the WeakKeyDict so that we can report the value from it before the
 
502
        # entry is removed by the WeakKeyDict's own callback.
 
503
        ref = weakref.ref(medium, self.done)
 
504
 
 
505
    def increment_call_count(self, params):
 
506
        # Increment the count in the WeakKeyDictionary
 
507
        value = self.counts[params.medium]
 
508
        value[0] += 1
 
509
 
 
510
    def done(self, ref):
 
511
        value = self.counts[ref]
 
512
        count, medium_repr = value
 
513
        # In case this callback is invoked for the same ref twice (by the
 
514
        # weakref callback and by the atexit function), set the call count back
 
515
        # to 0 so this item won't be reported twice.
 
516
        value[0] = 0
 
517
        if count != 0:
 
518
            trace.note('HPSS calls: %d %s', count, medium_repr)
 
519
        
 
520
    def flush_all(self):
 
521
        for ref in list(self.counts.keys()):
 
522
            self.done(ref)
 
523
 
 
524
_debug_counter = None
 
525
  
 
526
  
471
527
class SmartClientMedium(SmartMedium):
472
528
    """Smart client is a medium for sending smart protocol requests over."""
473
529
 
482
538
        # _remote_version_is_before tracks the bzr version the remote side
483
539
        # can be based on what we've seen so far.
484
540
        self._remote_version_is_before = None
 
541
        # Install debug hook function if debug flag is set.
 
542
        if 'hpss' in debug.debug_flags:
 
543
            global _debug_counter
 
544
            if _debug_counter is None:
 
545
                _debug_counter = _DebugCounter()
 
546
            _debug_counter.track(self)
485
547
 
486
548
    def _is_remote_before(self, version_tuple):
487
549
        """Is it possible the remote side supports RPCs for a given version?
784
846
            raise errors.MediumNotConnected(self)
785
847
        # We ignore the desired_count because on sockets it's more efficient to
786
848
        # read large chunks (of _MAX_READ_SIZE bytes) at a time.
787
 
        return self._socket.recv(_MAX_READ_SIZE)
 
849
        try:
 
850
            return self._socket.recv(_MAX_READ_SIZE)
 
851
        except socket.error, e:
 
852
            if len(e.args) and e.args[0] == errno.ECONNRESET:
 
853
                # Callers expect an empty string in that case
 
854
                return ''
 
855
            else:
 
856
                raise
788
857
 
789
858
 
790
859
class SmartClientStreamMediumRequest(SmartClientMediumRequest):