def f1():
print 12
gr2.switch()
print dir(get_ident())
print "thread id in f1() " + str(get_ident())
print 34
gr2.switch()
def __init__(self):
object.__setattr__(self, '__local__', {})
ident = get_ident()
self.__local__[ident] = {
'request': _cprequest.Request(httputil.Host("127.0.0.1", 80), httputil.Host("127.0.0.1", 1111)),
'response': _cprequest.Response()
}
def __setattr__(self, name, value):
ident = get_ident()
local = self.__local__
try:
local[ident][name] = value
except KeyError:
local[ident] = {name: value}
def get_locale():
"""Get the thread local module locale. This will be the default locale
for newly date/datetime instances in current thread.
:return: str|None
"""
return _thread_local_locales.get(get_ident())
def current(self):
ident = get_ident()
try:
return self.idents[ident]
except KeyError:
d = self.initial.copy()
self.idents[ident] = d
return d
def top(self):
"""The topmost item on the stack. If the stack is empty,
`None` is returned.
"""
try:
return self._stack.get(get_ident(), [])[-1]
except (AttributeError, IndexError):
return None
def wait(self):
"""Invoked from each client's thread to wait for the next frame."""
ident = get_ident()
if ident not in self.events:
# Este es nuevo cliente
# se agrega una entrada para el "events"
# cada entrada tiene 2 elementos, un thread.Event() y un timestamp
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def wait(self):
"""Invoked from each client's thread to wait for the next frame."""
ident = get_ident()
if ident not in self.events:
# Not in mean no client
# We need to add a new client, add it to the events
# Each entry has two elements, a threading.Event() and a timestamp
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def wait(self):
"""fircare client are cate un thread si trebuie sa astepte un nou frame"""
ident = get_ident()
if ident not in self.events:
# acesta este un nou client
# adaugam clientul la self.events
# fiecare intrare are doua elemente, threading.Event() si un timp
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def wait(self):
"""Invoked from each client's thread to wait for the next frame."""
ident = get_ident()
if ident not in self.events:
# this is a new client
# add an entry for it in the self.events dict
# each entry has two elements, a threading.Event() and a timestamp
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def wait(self):
"""Invoked from each client's thread to wait for the next frame."""
ident = get_ident()
if ident not in self.events:
# this is a new client
# add an entry for it in the self.events dict
# each entry has two elements, a threading.Event() and a timestamp
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def __init__(self):
object.__setattr__(self, '__local__', {})
ident = get_ident()
self.__local__[ident] = {
'request':
_cprequest.Request(httputil.Host("127.0.0.1", 80),
httputil.Host("127.0.0.1", 1111)),
'response':
_cprequest.Response()
}
def wait(self):
ident = get_ident()
logging.debug(self.log +
"wait() ident: {} Enter function".format(ident))
if ident not in self.events:
self.events[ident] = Event()
logging.debug(self.log +
"wait() ident: {} Create event".format(ident))
return self.events[ident].wait()
def greenlet_ident():
ident = get_ident()
try:
ident = int(ident)
except TypeError:
# greenlet.getcurrent() return greenlet.greenlet object.
ident = id(ident)
idents = [ident, int(getpid())]
return "-".join(str(i) for i in idents)
def clear_dbsession():
global dbsession_used
ident = get_ident()
dbsessions = dbsession_used.pop(ident, [])
for name in dbsessions:
try:
dbsession_class = dbsession_cache.get(name)
dbsession_class.remove()
except Exception:
logger.error('error while clear dbsession')
logger.traceback()
def process_request(self, request):
request.is_mobile = lambda: bool(
settings.RE_MOBILE.search(request.META.get('HTTP_USER_AGENT', '')))
# 是否为合法 WEIXIN 请求，必须符合两个条件，wx 客户端 & WX PAAS 域名
request_origin_url = "%s://%s" % (request.scheme, request.get_host())
request.is_wechat = lambda: (bool(
settings.RE_WECHAT.search(request.META.get('HTTP_USER_AGENT', ''))
) and request_origin_url == settings.WEIXIN_BK_URL)
self._request_pool[get_ident()] = request
return None
def pop(self):
"""Removes the topmost item from the stack, will return the
old value or `None` if the stack was already empty.
"""
ident = get_ident()
stack = self._stack.get(ident, None)
if stack is None:
return None
elif len(stack) == 1:
self._stack.pop(ident, None)
return stack[-1]
else:
return stack.pop()
def _thread(cls):
"""Camera background thread."""
timePrint('Starting camera thread %s' % get_ident())
frames_iterator = cls.frames()
for frame in frames_iterator:
BaseCamera.frame = frame
if BaseCamera.faceTracker != None:
BaseCamera.trackingFrame = frame.copy()
BaseCamera.faceTracker.detectOrTrack(BaseCamera.trackingFrame)
BaseCamera.event.set() # send signal to clients
time.sleep(0)
# if there hasn't been any clients asking for frames in
# the last 10 seconds then stop the thread
if time.time() - BaseCamera.last_access > 10:
frames_iterator.close()
timePrint('Stopping camera thread due to inactivity %s' %
get_ident())
break
BaseCamera.thread = None
BaseCamera.faceTracker = None
def __setstate__(self, state):
self._pyroUri = core.URI(state[0])
self._pyroOneway = set(state[1])
self._pyroMethods = set(state[2])
self._pyroAttrs = set(state[3])
self._pyroHandshake = state[4]
self._pyroSerializer = state[5]
self.__pyroTimeout = config.COMMTIMEOUT
self._pyroMaxRetries = config.MAX_RETRIES
self._pyroConnection = None
self._pyroSeq = 0
self._pyroRawWireResponse = False
self.__pyroOwnerThread = get_ident()
def pop(self):
"""Removes the topmost item from the stack, will return the
old value or `None` if the stack was already empty.
"""
ident = get_ident()
stack = self._stack.get(ident, None)
if stack is None:
return None
elif len(stack) == 1:
self._stack.pop(ident, None)
return stack[-1]
else:
return stack.pop()
def set_locale(locale):
"""Set the thread local module locale. This will be the default locale
for new date/datetime instances in current thread.
Returns the previous value of locale set on current thread.
Note: since Python thread identities maybe recycled and reused,
always ensure the desied locale is set for current thread,
or the locale maybe affected by previous threads with the same
identity.
:param str|None: locale
:return: str|None
"""
thread_identity = get_ident()
prev_locale = _thread_local_locales.get(thread_identity)
_thread_local_locales[thread_identity] = locale
return prev_locale
def set_locale(locale):
"""Set the thread local module locale. This will be the default locale
for new date/datetime instances in current thread.
Returns the previous value of locale set on current thread.
Note: since Python thread identities maybe recycled and reused,
always ensure the desied locale is set for current thread,
or the locale maybe affected by previous threads with the same
identity.
:param str|None: locale
:return: str|None
"""
thread_identity = get_ident()
prev_locale = _thread_local_locales.get(thread_identity)
_thread_local_locales[thread_identity] = locale
return prev_locale
def process_request(self, request):
request.is_mobile = lambda: bool(
settings.RE_MOBILE.search(request.META.get('HTTP_USER_AGENT', '')))
# 是否为合法的RIO请求
request.is_rio = lambda: bool(
request.META.get('HTTP_STAFFNAME', '') and settings.RIO_TOKEN and
settings.RE_WECHAT.search(request.META.get('HTTP_USER_AGENT', '')))
# 是否为合法 WEIXIN 请求，必须符合两个条件，wx 客户端 & WX PAAS 域名
request_origin_url = "%s://%s" % (request.scheme, request.get_host())
request.is_wechat = lambda: (bool(
settings.RE_WECHAT.search(request.META.get('HTTP_USER_AGENT', ''))
) and request_origin_url == settings.WEIXIN_BK_URL and not request.
is_rio())
# JWT请求
request.is_bk_jwt = lambda: bool(
request.META.get('HTTP_X_BKAPI_JWT', ''))
self._request_pool[get_ident()] = request
return None
def process_response(self, request, response):
assert request is self._request_pool.pop(get_ident())
return response
def clear(self):
"""Clear all attributes of the current greenlet."""
del self.__local__[get_ident()]
def get_request():
return request_accessor.send(get_ident(), from_signal=True)[0][1]
def __getattr__(self, name):
try:
return self.__local__[get_ident()][name]
except KeyError:
raise AttributeError(name)
def __check_owner(self):
if get_ident() != self.__pyroOwnerThread:
raise errors.PyroError(
"the calling thread is not the owner of this proxy, "
"create a new proxy in this thread or transfer ownership.")
def push(self, obj):
"""Pushes a new item to the stack"""
rv = self._stack.setdefault(get_ident(), [])
rv.append(obj)
return rv
def load(self, request, response):
self.__local__[get_ident()] = {
'request': request,
'response': response
}
def clear(self):
self.events[get_ident()][0].clear()
def __setattr__(self, k, v):
ident = get_ident()
if ident in Local.storage:
Local.storage[ident][k] = v
else:
Local.storage[ident] = {k: v}
def push(self, obj):
"""Pushes a new item to the stack"""
rv = self._stack.setdefault(get_ident(), [])
rv.append(obj)
return rv
def hex_ident():
ident = get_ident()
if not isinstance(ident, int):
ident = id(ident)
return "%x" % ident
def ident(self):
return get_ident()
def hex_ident():
ident = get_ident()
if not isinstance(ident, int):
ident = id(ident)
return "%x" % ident
storage[ident] = {name: value}
def __delattr__(self, name):
try:
del self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
obj = Local()
obj.stack = []
obj.stack.append('小李')
obj.stack.append('老小')
obj.stack.pop()
obj.request = 456
print(obj.__storage__, obj.__storage__.get(get_ident())['stack'])
print('*************************************************************')
class LocalStack(object):
def __init__(self):
self._local = Local()
def push(self, obj):
"""Pushes a new item to the stack"""
rv = getattr(self._local, "stack", None)
if rv is None:
self._local.stack = rv = []
rv.append(obj)
return rv
def hello_world():
print(get_ident())
time.sleep(10)
return "hello world"
def hello():
print(get_ident())
return "hello"
def ident(self):
return get_ident()
def clear(self):
"""Invoked from each client's thread after a frame was processed."""
self.events[get_ident()][0].clear()
def __getattr__(self, item):
ident = get_ident()
return Local.storage[ident][item]
def wait(self):
"""Invoked from each client's thread to wait for the next frame."""
ident = get_ident()
if ident not in self.events:
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def wait(self):
ident = get_ident()
if ident not in self.events:
self.events[ident] = [threading.Event(), time()]
return self.events[ident][0].wait()
def clear(self):
"""apelat de la fiecare thread al clientului cand un frame este procesat"""
self.events[get_ident()][0].clear()
def clear(self):
"""Invoked from each client's thread after a frame was processed."""
self.events[get_ident()][0].clear()
def f2():
print 56
print "thread id in f2() "+str(get_ident())
gr1.switch()
print 78
