def __init__(self,conn_obj): super(PartnerEndpoint,self).__init__(conn_obj) setattr( self, util.partner_endpoint_msg_call_func_name('test_partner_write'), self.test_partner_write)
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 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 # 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_to_call_txt = '"' + lib_util.partner_endpoint_msg_call_func_name( next_sequence_block_src_name) + '"' next_sequence_txt = ''' _context.hide_partner_call( self,_active_event,%s,False) ''' % (next_to_call_txt) msg_receive_txt += emit_utils.indent_str(next_sequence_txt) return msg_receive_txt
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 handle_first_sequence_msg_from_partner( self,msg,name_of_block_to_exec_next): ''' ASSUMES ALREADY WITHIN LOCK @param {PartnerMessageRequestSequenceBlock.proto} msg --- @param {string} name_of_block_to_exec_next --- the name of the sequence block to execute next. @returns {Executing event} means that the other side has generated a first message create a new context to execute that message and do so in a new thread. ''' ### FIGURE OUT WHAT TO EXECUTE NEXT #### DEBUG if name_of_block_to_exec_next == None: util.logger_assert( 'Error in _ActiveEvent. Should not receive the ' + 'beginning of a sequence message without some ' + 'instruction for what to do next.') #### END DEBUG block_to_exec_internal_name = util.partner_endpoint_msg_call_func_name( name_of_block_to_exec_next) #### MAYBE DEBUG # ("maybe" because we also may want to throw a Waldo error # for this instead of just asserting out.) if not hasattr( self.event_parent.local_endpoint,block_to_exec_internal_name): util.logger_assert( 'Error in _ActiveEvent. Received a request to ' + 'perform an unknown sequence step.') #### END MAYBE DEBUG to_exec = getattr(self.event_parent.local_endpoint,block_to_exec_internal_name) ### SET UP CONTEXT FOR EXECUTING seq_local_var_store = waldoVariableStore._VariableStore( self.event_parent.local_endpoint._host_uuid) # FIXME: eventually, want to remove pickle-ing here seq_local_var_store.incorporate_deltas( self,msg.sequence_local_var_store_deltas) evt_ctx = _ExecutingEventContext( # already incorporated deltas for global_var_store # above. self.event_parent.local_endpoint._global_var_store, seq_local_var_store) evt_ctx.set_to_reply_with(msg.reply_with_uuid.data) # used to actually start execution of context thread at end # of loop. must start event outside of locks. That way, # if the exec event leads to and endpoint call, etc., we # don't block waiting on its return. exec_event = _ExecutingEvent( to_exec,self,evt_ctx, None # using None here means that we do not need to # bother with waiting for modified peered-s to # update. ) return exec_event
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