Code import

venv/lib/python2.7/site-packages/eventlet/debug.py

@@ -0,0 +1,174 @@
+"""The debug module contains utilities and functions for better
+debugging Eventlet-powered applications."""
+from __future__ import print_function
+
+import os
+import sys
+import linecache
+import re
+import inspect
+
+__all__ = ['spew', 'unspew', 'format_hub_listeners', 'format_hub_timers',
+           'hub_listener_stacks', 'hub_exceptions', 'tpool_exceptions',
+           'hub_prevent_multiple_readers', 'hub_timer_stacks',
+           'hub_blocking_detection']
+
+_token_splitter = re.compile('\W+')
+
+
+class Spew(object):
+
+    def __init__(self, trace_names=None, show_values=True):
+        self.trace_names = trace_names
+        self.show_values = show_values
+
+    def __call__(self, frame, event, arg):
+        if event == 'line':
+            lineno = frame.f_lineno
+            if '__file__' in frame.f_globals:
+                filename = frame.f_globals['__file__']
+                if (filename.endswith('.pyc') or
+                        filename.endswith('.pyo')):
+                    filename = filename[:-1]
+                name = frame.f_globals['__name__']
+                line = linecache.getline(filename, lineno)
+            else:
+                name = '[unknown]'
+                try:
+                    src = inspect.getsourcelines(frame)
+                    line = src[lineno]
+                except IOError:
+                    line = 'Unknown code named [%s].  VM instruction #%d' % (
+                        frame.f_code.co_name, frame.f_lasti)
+            if self.trace_names is None or name in self.trace_names:
+                print('%s:%s: %s' % (name, lineno, line.rstrip()))
+                if not self.show_values:
+                    return self
+                details = []
+                tokens = _token_splitter.split(line)
+                for tok in tokens:
+                    if tok in frame.f_globals:
+                        details.append('%s=%r' % (tok, frame.f_globals[tok]))
+                    if tok in frame.f_locals:
+                        details.append('%s=%r' % (tok, frame.f_locals[tok]))
+                if details:
+                    print("\t%s" % ' '.join(details))
+        return self
+
+
+def spew(trace_names=None, show_values=False):
+    """Install a trace hook which writes incredibly detailed logs
+    about what code is being executed to stdout.
+    """
+    sys.settrace(Spew(trace_names, show_values))
+
+
+def unspew():
+    """Remove the trace hook installed by spew.
+    """
+    sys.settrace(None)
+
+
+def format_hub_listeners():
+    """ Returns a formatted string of the current listeners on the current
+    hub.  This can be useful in determining what's going on in the event system,
+    especially when used in conjunction with :func:`hub_listener_stacks`.
+    """
+    from eventlet import hubs
+    hub = hubs.get_hub()
+    result = ['READERS:']
+    for l in hub.get_readers():
+        result.append(repr(l))
+    result.append('WRITERS:')
+    for l in hub.get_writers():
+        result.append(repr(l))
+    return os.linesep.join(result)
+
+
+def format_hub_timers():
+    """ Returns a formatted string of the current timers on the current
+    hub.  This can be useful in determining what's going on in the event system,
+    especially when used in conjunction with :func:`hub_timer_stacks`.
+    """
+    from eventlet import hubs
+    hub = hubs.get_hub()
+    result = ['TIMERS:']
+    for l in hub.timers:
+        result.append(repr(l))
+    return os.linesep.join(result)
+
+
+def hub_listener_stacks(state=False):
+    """Toggles whether or not the hub records the stack when clients register
+    listeners on file descriptors.  This can be useful when trying to figure
+    out what the hub is up to at any given moment.  To inspect the stacks
+    of the current listeners, call :func:`format_hub_listeners` at critical
+    junctures in the application logic.
+    """
+    from eventlet import hubs
+    hubs.get_hub().set_debug_listeners(state)
+
+
+def hub_timer_stacks(state=False):
+    """Toggles whether or not the hub records the stack when timers are set.
+    To inspect the stacks of the current timers, call :func:`format_hub_timers`
+    at critical junctures in the application logic.
+    """
+    from eventlet.hubs import timer
+    timer._g_debug = state
+
+
+def hub_prevent_multiple_readers(state=True):
+    """Toggle prevention of multiple greenlets reading from a socket
+
+    When multiple greenlets read from the same socket it is often hard
+    to predict which greenlet will receive what data.  To achieve
+    resource sharing consider using ``eventlet.pools.Pool`` instead.
+
+    But if you really know what you are doing you can change the state
+    to ``False`` to stop the hub from protecting against this mistake.
+    """
+    from eventlet.hubs import hub
+    hub.g_prevent_multiple_readers = state
+
+
+def hub_exceptions(state=True):
+    """Toggles whether the hub prints exceptions that are raised from its
+    timers.  This can be useful to see how greenthreads are terminating.
+    """
+    from eventlet import hubs
+    hubs.get_hub().set_timer_exceptions(state)
+    from eventlet import greenpool
+    greenpool.DEBUG = state
+
+
+def tpool_exceptions(state=False):
+    """Toggles whether tpool itself prints exceptions that are raised from
+    functions that are executed in it, in addition to raising them like
+    it normally does."""
+    from eventlet import tpool
+    tpool.QUIET = not state
+
+
+def hub_blocking_detection(state=False, resolution=1):
+    """Toggles whether Eventlet makes an effort to detect blocking
+    behavior in an application.
+
+    It does this by telling the kernel to raise a SIGALARM after a
+    short timeout, and clearing the timeout every time the hub
+    greenlet is resumed.  Therefore, any code that runs for a long
+    time without yielding to the hub will get interrupted by the
+    blocking detector (don't use it in production!).
+
+    The *resolution* argument governs how long the SIGALARM timeout
+    waits in seconds.  The implementation uses :func:`signal.setitimer`
+    and can be specified as a floating-point value.
+    The shorter the resolution, the greater the chance of false
+    positives.
+    """
+    from eventlet import hubs
+    assert resolution > 0
+    hubs.get_hub().debug_blocking = state
+    hubs.get_hub().debug_blocking_resolution = resolution
+    if not state:
+        hubs.get_hub().block_detect_post()