1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
"""Implements the standard threading module, using greenthreads."""
import eventlet
from eventlet.green import thread
from eventlet.green import time
from eventlet.support import greenlets as greenlet
__patched__ = ['Lock', '_allocate_lock', '_get_main_thread_ident',
'_make_thread_handle', '_shutdown', '_sleep',
'_start_joinable_thread', '_start_new_thread', '_ThreadHandle',
'currentThread', 'current_thread', 'local', 'stack_size',
"_active", "_limbo"]
__patched__ += ['get_ident', '_set_sentinel']
__orig_threading = eventlet.patcher.original('threading')
__threadlocal = __orig_threading.local()
__patched_enumerate = None
eventlet.patcher.inject(
'threading',
globals(),
('_thread', thread),
('time', time))
_count = 1
class _GreenThread:
"""Wrapper for GreenThread objects to provide Thread-like attributes
and methods"""
def __init__(self, g):
global _count
self._g = g
self._name = 'GreenThread-%d' % _count
_count += 1
def __repr__(self):
return '<_GreenThread(%s, %r)>' % (self._name, self._g)
def join(self, timeout=None):
return self._g.wait()
def getName(self):
return self._name
get_name = getName
def setName(self, name):
self._name = str(name)
set_name = setName
name = property(getName, setName)
ident = property(lambda self: id(self._g))
def isAlive(self):
return True
is_alive = isAlive
daemon = property(lambda self: True)
def isDaemon(self):
return self.daemon
is_daemon = isDaemon
__threading = None
def _fixup_thread(t):
# Some third-party packages (lockfile) will try to patch the
# threading.Thread class with a get_name attribute if it doesn't
# exist. Since we might return Thread objects from the original
# threading package that won't get patched, let's make sure each
# individual object gets patched too our patched threading.Thread
# class has been patched. This is why monkey patching can be bad...
global __threading
if not __threading:
__threading = __import__('threading')
if (hasattr(__threading.Thread, 'get_name') and
not hasattr(t, 'get_name')):
t.get_name = t.getName
return t
def current_thread():
global __patched_enumerate
g = greenlet.getcurrent()
if not g:
# Not currently in a greenthread, fall back to standard function
return _fixup_thread(__orig_threading.current_thread())
try:
active = __threadlocal.active
except AttributeError:
active = __threadlocal.active = {}
g_id = id(g)
t = active.get(g_id)
if t is not None:
return t
# FIXME: move import from function body to top
# (jaketesler@github) Furthermore, I was unable to have the current_thread() return correct results from
# threading.enumerate() unless the enumerate() function was a) imported at runtime using the gross __import__() call
# and b) was hot-patched using patch_function().
# https://github.com/eventlet/eventlet/issues/172#issuecomment-379421165
if __patched_enumerate is None:
__patched_enumerate = eventlet.patcher.patch_function(__import__('threading').enumerate)
found = [th for th in __patched_enumerate() if th.ident == g_id]
if found:
return found[0]
# Add green thread to active if we can clean it up on exit
def cleanup(g):
del active[g_id]
try:
g.link(cleanup)
except AttributeError:
# Not a GreenThread type, so there's no way to hook into
# the green thread exiting. Fall back to the standard
# function then.
t = _fixup_thread(__orig_threading.current_thread())
else:
t = active[g_id] = _GreenThread(g)
return t
currentThread = current_thread
|
