def __init__(self,*args):
test_util.DummyEndpoint.__init__(self,*args)
# adding data for a
self.alpha_name = 'alpha'
self._global_var_store.add_var(
self.alpha_name,
wVariables.WaldoNumVariable(
self.alpha_name,self._host_uuid,
False,1))
setattr(
self,
util.endpoint_call_func_name('update_alpha'),
self.update_alpha)
setattr(
self,
util.endpoint_call_func_name('update_alpha_and_send_message'),
self.update_alpha_and_send_message)
def __init__(self,conn_obj,host_uuid=None):
test_util.DummyEndpoint.__init__(self,conn_obj,host_uuid)
# when dispatching to partner, we request the function name as
# it would appear in the Waldo source file. However, the
# compiler mangles it into another name. The call below
# ensures that that the mangled name exists.
setattr(
self,
util.endpoint_call_func_name('endpoint_func'),
self.endpoint_func)
def __init__(self,*args):
test_util.DummyEndpoint.__init__(self,*args)
# adding data for b
self.beta_name = 'beta'
self._global_var_store.add_var(
self.beta_name,
wVariables.WaldoNumVariable(
self.beta_name,self._host_uuid,
False,1))
setattr(
self,
util.endpoint_call_func_name('update_beta'),
self.update_beta)
setattr(
self,
util.partner_endpoint_msg_call_func_name('update_beta_when_receive_message'),
self.update_beta_when_receive_message)
def emit_public_method_interface(
public_method_node,endpoint_name,ast_root,fdep_dict,emit_ctx):
'''
@param {AstNode} public_method_node --- An AstNode with label
AST_PUBLIC_FUNCTION
'''
method_name_node = public_method_node.children[0]
method_name = method_name_node.value
method_arg_names = get_method_arg_names(public_method_node)
# turns the array of argnames above into a single string of csv
# arg names
comma_sep_arg_names = reduce (
lambda x, y : x + ',' + y,
method_arg_names,'')
public_header = '''
def %s(self%s):
''' % (method_name, comma_sep_arg_names)
# wait until ready initialization for node has completed before
# continuing
public_body = '''
# ensure that both sides have completed their onCreate calls
# before continuing
self._block_ready()
'''
#### Deep copy non-external args
# non_ext_arg_names is an array of strings
non_ext_arg_names = get_non_external_arg_names_from_func_node(
public_method_node)
# do not need to copy arguments in: each function call does so on
# its own.
# Each element in this list is an index for a return parameter
# that should be de-waldo-ified before returning. We pass this
# argument to the internal function that the internal function
# knows which returns need to be de-waldo-ified before being
# returned and which do not.
list_return_external_positions = (
get_external_return_positions_from_func_node(public_method_node))
#### create a root event + ctx for event, call internal, and reurn
internal_method_name = lib_util.endpoint_call_func_name(method_name)
public_body += '''
while True: # FIXME: currently using infinite retry
_root_event = self._act_event_map.create_root_event()
_ctx = %s(
self._global_var_store,
# not using sequence local store
%s(self._host_uuid))
# call internal function... note True as last param tells internal
# version of function that it needs to de-waldo-ify all return
# arguments (while inside transaction) so that this method may
# return them....if it were false, might just get back refrences
# to Waldo variables, and de-waldo-ifying them outside of the
# transaction might return over-written/inconsistent values.
_to_return = self.%s(_root_event,_ctx %s,%s)
# try committing root event
_root_event.request_commit()
_commit_resp = _root_event.event_complete_queue.get()
if isinstance(_commit_resp,%s):
# means it isn't a backout message: we're done
return _to_return
''' % (emit_utils.library_transform('ExecutingEventContext'),
emit_utils.library_transform('VariableStore'),
internal_method_name,
comma_sep_arg_names,
str(list_return_external_positions),
emit_utils.library_transform('CompleteRootCallResult'))
return public_header + emit_utils.indent_str(public_body)
