def __init__(self,endpoint_a,*args):
test_util.DummyEndpoint.__init__(self,*args)
self.endpoint_a = endpoint_a
setattr(
self,
util.partner_endpoint_msg_call_func_name('receive_message_for_a'),
self.receive_message_for_a)
def __init__(self,conn_obj):
test_util.DummyEndpoint.__init__(self,conn_obj)
# 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.partner_endpoint_msg_call_func_name('sequence_block'),
self.sequence_block)
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_message_receive(
message_receive_node,next_to_call_node,endpoint_name,ast_root,
fdep_dict,emit_ctx):
'''
@param {AstNode or None} next_to_call_node --- If AstNode, then
has label AST_MESSAGE_RECEIVE_FUNCTION. If None, means that this
is the last message receive node in sequence and should tell other
side to issue a block call with target None.
'''
msg_recv_node_name_node = message_receive_node.children[1]
msg_recv_name = msg_recv_node_name_node.value
emit_ctx.in_message_receive = True
emit_ctx.message_seq_return_txt = '\nreturn '
msg_receive_txt = emit_private_method_interface(
message_receive_node,endpoint_name,ast_root,fdep_dict,emit_ctx,
lib_util.partner_endpoint_msg_call_func_name)
msg_receive_txt += '\n'
emit_ctx.in_message_receive = False
emit_ctx.message_seq_return_txt = ''
## Ends by telling the opposite side what to do next
next_to_call_txt = 'None'
if next_to_call_node != None:
# the name of the next sequence block to execute, as it
# appears in the source Waldo text, ie, before mangling.
next_sequence_block_src_name = next_to_call_node.children[1].value
next_to_call_txt = '"' + lib_util.partner_endpoint_msg_call_func_name(
next_sequence_block_src_name) + '"'
# note that we must wait on receiving a response from the other
# side before we can continue on, or the original sender may
# return too early. We should not wait on the last message that we
# send however, because, we do not expect any response to it.
# (Ie, if next_to_call_txt == 'None', then do not wait.)
next_sequence_txt = '''
_threadsafe_queue = %s.Queue()
_active_event.issue_partner_sequence_block_call(
_context,%s,_threadsafe_queue,False)
# must wait on the result of the call before returning
if %s != None:
# means that we have another sequence item to execute next
_queue_elem = _threadsafe_queue.get()
''' % (emit_utils.library_transform('Queue'),
next_to_call_txt,
next_to_call_txt)
next_sequence_txt += '''
if isinstance(_queue_elem,%s):
# back everything out
raise %s()
_context.set_to_reply_with(_queue_elem.reply_with_msg_field)
# apply changes to sequence variables. Note: that
# the system has already applied deltas for global data.
_context.sequence_local_store.incorporate_deltas(
_active_event,_queue_elem.sequence_local_var_store_deltas)
# send more messages
_to_exec_next = _queue_elem.to_exec_next_name_msg_field
if _to_exec_next != None:
# means that we do not have any additional functions to exec
_to_exec = getattr(self,_to_exec_next)
_to_exec(_active_event,_context)
''' % (emit_utils.library_transform('BackoutBeforeReceiveMessageResult'),
emit_utils.library_transform('BackoutException'))
msg_receive_txt += emit_utils.indent_str(next_sequence_txt)
return msg_receive_txt
