def test_basic_local():
"""Basic local object support"""
l = Local()
l.foo = 0
values = []
def value_setter(idx):
time.sleep(0.01 * idx)
l.foo = idx
time.sleep(0.02)
values.append(l.foo)
threads = [Thread(target=value_setter, args=(x,)) for x in [1, 2, 3]]
for thread in threads:
thread.start()
time.sleep(0.2)
assert sorted(values) == [1, 2, 3]
def delfoo():
del l.foo
delfoo()
assert_raises(AttributeError, lambda: l.foo)
assert_raises(AttributeError, delfoo)
release_local(l)
def destroy(): """closes connection and releases werkzeug local""" if conn: conn.close() from werkzeug.local import release_local release_local(local)
def test_basic_local():
ns = local.Local()
ns.foo = 0
values = []
def value_setter(idx):
time.sleep(0.01 * idx)
ns.foo = idx
time.sleep(0.02)
values.append(ns.foo)
threads = [Thread(target=value_setter, args=(x,)) for x in [1, 2, 3]]
for thread in threads:
thread.start()
time.sleep(0.2)
assert sorted(values) == [1, 2, 3]
def delfoo():
del ns.foo
delfoo()
pytest.raises(AttributeError, lambda: ns.foo)
pytest.raises(AttributeError, delfoo)
local.release_local(ns)
def end_fake_request():
"""
Start lizard_history machinery to log changes and remove the
fake_request from the thread.
"""
ops_done.send(None)
release_local(_local)
def manage(cls):
""" Context manager for a set of environments. """
if hasattr(cls._local, 'environments'):
yield
else:
try:
cls._local.environments = Environments()
yield
finally:
release_local(cls._local)
def test_local_release():
l = local.Local()
l.foo = 42
local.release_local(l)
assert not hasattr(l, 'foo')
ls = local.LocalStack()
ls.push(42)
local.release_local(ls)
assert ls.top is None
def test_local_release():
ns = local.Local()
ns.foo = 42
local.release_local(ns)
assert not hasattr(ns, "foo")
ls = local.LocalStack()
ls.push(42)
local.release_local(ls)
assert ls.top is None
def test_local_release(self):
loc = local.Local()
loc.foo = 42
local.release_local(loc)
assert not hasattr(loc, 'foo')
ls = local.LocalStack()
ls.push(42)
local.release_local(ls)
assert ls.top is None
def test_local_release():
"""Locals work without manager"""
loc = Local()
loc.foo = 42
release_local(loc)
assert not hasattr(loc, "foo")
ls = LocalStack()
ls.push(42)
release_local(ls)
assert ls.top is None
def __call__(self, environ, start_response):
"""Process a request"""
# Set up the request and do our pre-processing
request = Request(environ)
self.before(request)
# Defer to the wrapped app, then do our cleanup n stuff
response = Response.from_app(self.app, environ)
self.after(request, response)
release_local(self.local)
# finally, blah
return response(environ, start_response)
def __call__(self, environ, start_response):
"""Process a request"""
try:
# Set up the request
request = Request(environ)
# Defer to the wrapped app, then do our cleanup
response = Response.from_app(self.app, environ)
if response.status_code/100 in self.error_prefixes:
abort(response.status_code)
release_local(self.local)
return response(environ, start_response)
except HTTPException as err:
response = self.jsonify_error(err, environ)
return response(environ, start_response)
def test_metric_hook_user_name(context, get_breadcrumbs):
r = mock_response(view='view')
talisker.requests._local.metric_api_name = 'api'
talisker.requests._local.metric_host_name = 'service'
talisker.requests.metrics_response_hook(r)
release_local(talisker.requests._local)
assert context.statsd[0] == 'requests.count.service.api:1|c'
assert context.statsd[1] == (
'requests.latency.service.api.200:1000.000000|ms'
)
breadcrumbs = get_breadcrumbs()
if breadcrumbs is not None:
assert breadcrumbs[0]['type'] == 'http'
assert breadcrumbs[0]['category'] == 'requests'
assert breadcrumbs[0]['data']['url'] == 'http://example.com/'
assert breadcrumbs[0]['data']['host'] == 'example.com'
assert breadcrumbs[0]['data']['view'] == 'view'
assert breadcrumbs[0]['data']['method'] == 'GET'
assert breadcrumbs[0]['data']['status_code'] == 200
assert breadcrumbs[0]['data']['duration_ms'] == 1000.0
def main():
logging.getLogger().setLevel(logging.DEBUG)
from kay.utils import local
from werkzeug.local import release_local
release_local(local)
run_wsgi_app(application)
def clear():
release_local(context)
def process_response(self, request, response):
release_local(_local)
return response
def clear():
release_local(CONTEXT)
def destroy(): """closes connection and releases werkzeug local""" if conn: conn.close() release_local(local)
def process_exception(self, request, exception):
release_local(_local)
def cleanup():
release_local(request_context)
def destroy():
"""Closes connection and releases werkzeug local."""
if db:
db.close()
release_local(local)
def process_exception(self, request, exception):
release_local(_local)
def destroy(): """Closes connection and releases werkzeug local.""" if db: db.close() release_local(local)
def release(self):
release_local(_local)
