def _log_method(self, context, args, kwargs):
method = helpers.get_current_method(context)
param_gen = itertools.chain(
(six.text_type(arg) for arg in args),
(u'{0} => {1}'.format(name, value)
for name, value in six.iteritems(kwargs)))
params_str = u', '.join(param_gen)
method_name = '::'.join((method.declaring_type.name, method.name))
thread_id = helpers.get_current_thread_id()
caller_str = ''
caller_ctx = helpers.get_caller_context(context)
if caller_ctx is not None:
frame = stack_trace.compose_stack_frame(caller_ctx)
if frame['location']:
caller_str = ' called from ' + stack_trace.format_frame(frame)
LOG.trace(u'{thread}: Begin execution {method}({params}){caller}'
.format(thread=thread_id, method=method_name,
params=params_str, caller=caller_str))
try:
def log_result(result):
LOG.trace(
u'{thread}: End execution {method} with result '
u'{result}'.format(
thread=thread_id, method=method_name, result=result))
yield log_result
except Exception as e:
LOG.trace(
u'{thread}: End execution {method} with exception '
u'{exc}'.format(thread=thread_id, method=method_name, exc=e))
raise
def _log_method(self, context, args, kwargs):
method = helpers.get_current_method(context)
param_gen = itertools.chain(
(six.text_type(arg) for arg in args),
(u'{0} => {1}'.format(name, value)
for name, value in kwargs.items()))
params_str = u', '.join(param_gen)
method_name = '::'.join((method.declaring_type.name, method.name))
thread_id = helpers.get_current_thread_id()
caller_str = ''
caller_ctx = helpers.get_caller_context(context)
if caller_ctx is not None:
frame = stack_trace.compose_stack_frame(caller_ctx)
if frame['location']:
caller_str = ' called from ' + stack_trace.format_frame(frame)
LOG.trace(u'{thread}: Begin execution {method}({params}){caller}'
.format(thread=thread_id, method=method_name,
params=params_str, caller=caller_str))
try:
def log_result(result):
LOG.trace(
u'{thread}: End execution {method} with result '
u'{result}'.format(
thread=thread_id, method=method_name, result=result))
yield log_result
except Exception as e:
LOG.trace(
u'{thread}: End execution {method} with exception '
u'{exc}'.format(thread=thread_id, method=method_name, exc=e))
raise
def _invoke_method_implementation(self, method, this, context, params):
body = method.body
if not body:
return None
murano_class = method.murano_class
current_thread = eventlet.greenthread.getcurrent()
if not hasattr(current_thread, '_muranopl_thread_marker'):
thread_marker = current_thread._muranopl_thread_marker = \
uuid.uuid4().hex
else:
thread_marker = current_thread._muranopl_thread_marker
method_id = id(body)
this_id = this.object_id
while True:
event, marker = self._locks.get((method_id, this_id), (None, None))
if event:
if marker == thread_marker:
return self._invoke_method_implementation_gt(
body, this, params, murano_class, context)
event.wait()
else:
break
event = eventlet.event.Event()
self._locks[(method_id, this_id)] = (event, thread_marker)
# noinspection PyProtectedMember
method_info = '{0}.{1} ({2})'.format(murano_class.name, method._name,
hash((method_id, this_id)))
# Prepare caller information
caller_ctx = helpers.get_caller_context(context)
if caller_ctx:
caller_info = trace.compose_stack_frame(caller_ctx)
LOG.debug('{0}: Begin execution: {1} called from {2}'.format(
thread_marker, method_info, trace.format_frame(caller_info)))
else:
LOG.debug('{0}: Begin execution: {1}'.format(
thread_marker, method_info))
try:
gt = eventlet.spawn(self._invoke_method_implementation_gt, body,
this, params, murano_class, context,
thread_marker)
result = gt.wait()
except Exception as e:
LOG.debug("{0}: End execution: {1} with exception {2}".format(
thread_marker, method_info, e))
raise
else:
LOG.debug("{0}: End execution: {1}".format(thread_marker,
method_info))
finally:
del self._locks[(method_id, this_id)]
event.send()
return result
def _invoke_method_implementation(self, method, this, context, params):
body = method.body
if not body:
return None
murano_class = method.murano_class
current_thread = eventlet.greenthread.getcurrent()
if not hasattr(current_thread, '_muranopl_thread_marker'):
thread_marker = current_thread._muranopl_thread_marker = \
uuid.uuid4().hex
else:
thread_marker = current_thread._muranopl_thread_marker
method_id = id(body)
this_id = this.object_id
while True:
event, marker = self._locks.get((method_id, this_id), (None, None))
if event:
if marker == thread_marker:
return self._invoke_method_implementation_gt(
body, this, params, murano_class, context)
event.wait()
else:
break
event = eventlet.event.Event()
self._locks[(method_id, this_id)] = (event, thread_marker)
# noinspection PyProtectedMember
method_info = '{0}.{1} ({2})'.format(murano_class.name, method._name,
hash((method_id, this_id)))
# Prepare caller information
caller_ctx = helpers.get_caller_context(context)
if caller_ctx:
caller_info = trace.compose_stack_frame(caller_ctx)
LOG.debug(
'{0}: Begin execution: {1} called from {2}'.format(
thread_marker, method_info, trace.format_frame(
caller_info)))
else:
LOG.debug(
'{0}: Begin execution: {1}'.format(
thread_marker, method_info))
gt = eventlet.spawn(self._invoke_method_implementation_gt, body,
this, params, murano_class, context,
thread_marker)
result = gt.wait()
del self._locks[(method_id, this_id)]
LOG.debug(
"{0}: End execution: {1}".format(thread_marker, method_info))
event.send()
return result
def _log_method(self, context, args, kwargs):
method = helpers.get_current_method(context)
param_gen = itertools.chain(
(six.text_type(arg) for arg in args),
(u"{0} => {1}".format(name, value) for name, value in six.iteritems(kwargs)),
)
params_str = u", ".join(param_gen)
method_name = "{0}::{1}".format(method.murano_class.name, method.name)
thread_id = helpers.get_current_thread_id()
caller_str = ""
caller_ctx = helpers.get_caller_context(context)
if caller_ctx is not None:
frame = stack_trace.compose_stack_frame(caller_ctx)
if frame["location"]:
caller_str = " called from " + stack_trace.format_frame(frame)
LOG.trace(
u"{thread}: Begin execution {method}({params}){caller}".format(
thread=thread_id, method=method_name, params=params_str, caller=caller_str
)
)
try:
def log_result(result):
LOG.trace(
u"{thread}: End execution {method} with result "
u"{result}".format(thread=thread_id, method=method_name, result=result)
)
yield log_result
except Exception as e:
LOG.trace(
u"{thread}: End execution {method} with exception "
u"{exc}".format(thread=thread_id, method=method_name, exc=e)
)
raise