def __init__(self, conn_obj, host_uuid=None): # all dummy endpoints will have the same _VariableStore # Peered Number numero = 100; # Peered Text some_str = 'test'; # Peered List (elements: Text) text_list; if host_uuid == None: host_uuid = util.generate_uuid() glob_var_store = waldoVariableStore._VariableStore(host_uuid) self.peered_number_var_name = "numero" glob_var_store.add_var( self.peered_number_var_name, wVariables.WaldoNumVariable(self.peered_number_var_name, host_uuid, True, 100) ) self.peered_str_var_name = "some_str" glob_var_store.add_var( self.peered_str_var_name, wVariables.WaldoTextVariable(self.peered_str_var_name, host_uuid, True, "test") ) self.peered_list_var_name = "text_list" glob_var_store.add_var( self.peered_list_var_name, wVariables.WaldoTextVariable(self.peered_list_var_name, host_uuid, True) ) waldoEndpoint._Endpoint.__init__(self, Waldo._waldo_classes, host_uuid, conn_obj, glob_var_store)
def sequence_block(self,active_event=None,context=None): ''' The first time that this function is called, it has neither an active_event, nor a context. We create them. ''' # keep track of whether this is the first message sent in a # sequence so that we know whether or not we must force # updating all the new sequence local data. _first_msg = False if active_event == None: # create active event active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid)) _first_msg = True # Send messages back and forth to each other to decrement # peered local data seq_local_num. Keep doing so until # numero is negative. peered_var = context.global_store.get_var_if_exists( self.peered_number_var_name) if peered_var.get_val(active_event) > 0: # keep sending messages until less than 0. peered_var.write_val(active_event,peered_var.get_val(active_event) - 1) # store each value as go through in array so that can # check at the end that did in fact get sequential # decrement of values. global array_of_values array_of_values.append(peered_var.get_val(active_event)) threadsafe_queue = Queue.Queue() active_event.issue_partner_sequence_block_call( context,'sequence_block',threadsafe_queue,_first_msg) seq_msg_call_res = threadsafe_queue.get() context.set_to_reply_with(seq_msg_call_res.reply_with_msg_field) # apply changes to sequence variables. (There shouldn't # be any, but it's worth getting in practice.) Note: that # the system has already applied deltas for global data. context.sequence_local_store.incorporate_deltas( active_event,seq_msg_call_res.sequence_local_var_store_deltas) # send more messages to_exec_next = seq_msg_call_res.to_exec_next_name_msg_field to_exec = getattr(self,to_exec_next) to_exec(active_event,context) # so that root can commit return active_event
def new_event_and_write(self,var_name,var_val): active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid)) var = context.global_store.get_var_if_exists(var_name) var.write_val(active_event,var_val) return active_event
def evt_r1(self,endpoint_a): active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid)) threadsafe_queue = Queue.Queue() active_event.issue_endpoint_object_call( endpoint_a,'update_alpha_and_send_message', threadsafe_queue) endpoint_call_res = threadsafe_queue.get() return active_event
def write_numero(self): active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid), ) var = context.global_store.get_var_if_exists(self.peered_number_var_name) var_value = var.get_val(active_event) var.write_val(active_event, var_value + 1) var_value = var.get_val(active_event) active_event.request_commit() queue_elem = active_event.event_complete_queue.get() return var_value
def endpoint_func(self,active_event,context,other_endpoint): ''' The first time that this function is called, it has neither an active_event, nor a context. We need to explicitly pass in None for them. ''' if active_event == None: # create active event active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid)) # Execute endpoint call back and forth. Keep doing so until # numero is negative. endpoint_var = context.global_store.get_var_if_exists( self.endpoint_number_var_name) if endpoint_var.get_val(active_event) > 0: # keep sending messages until less than 0. endpoint_var.write_val(active_event,endpoint_var.get_val(active_event) - 1) # store each value as go through in array so that can # check at the end that did in fact get sequential # decrement of values. global array_of_values array_of_values.append(endpoint_var.get_val(active_event)) threadsafe_queue = Queue.Queue() active_event.issue_endpoint_object_call( other_endpoint,'endpoint_func', threadsafe_queue,self) endpoint_call_res = threadsafe_queue.get() # so that root can commit return active_event
def new_event_and_read_numero(self): ''' Create a new event that reads the value of the peered number 'numero.' ''' active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid)) peered_var = context.global_store.get_var_if_exists( self.peered_number_var_name) var_value = peered_var.get_val(active_event) # warning just assuming that commit goes through instead of # retrying the event. active_event.request_commit() queue_elem = active_event.event_complete_queue.get() return var_value
def evt_r2(self,endpoint_b): active_event = self._act_event_map.create_root_event() # create context context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store, # not using sequence local store waldoVariableStore._VariableStore(self._host_uuid)) # first, call method on b threadsafe_queue = Queue.Queue() active_event.issue_endpoint_object_call( endpoint_b,'update_beta', threadsafe_queue) endpoint_call_res = threadsafe_queue.get() # call method on c, which calls method on a threadsafe_queue = Queue.Queue() active_event.issue_partner_sequence_block_call( context,'receive_message_for_a',threadsafe_queue,True) msg_call_res = threadsafe_queue.get() return active_event
def sequence_block(self,active_event=None,context=None): ''' The first time that this function is called, it has neither an active_event, nor a context. We create them. ''' seq_local_num_name = 'seq_local_num' # keep track of whether this is the first message sent in a # sequence so that we know whether or not we must force # updating all the new sequence local data. _first_msg = False if active_event == None: # create active event active_event = self._act_event_map.create_root_event() # create context seq_local_store = waldoVariableStore._VariableStore(self._host_uuid) seq_local_store.add_var( seq_local_num_name, wVariables.WaldoNumVariable( seq_local_num_name,self._host_uuid,True,100)) context = waldoExecutingEvent._ExecutingEventContext( self._global_var_store,seq_local_store) _first_msg = True # Send messages back and forth to each other to decrement # sequence local data seq_local_num. Keep doing so until # seq_local_num is negative. local_var = context.sequence_local_store.get_var_if_exists(seq_local_num_name) if local_var.get_val(active_event) > 0: # keep sending messages until less than 0. local_var.write_val(active_event,local_var.get_val(active_event) - 1) # store each value as go through in array so that can # check at the end that did in fact get sequential # decrement of values. global array_of_values array_of_values.append(local_var.get_val(active_event)) threadsafe_queue = Queue.Queue() active_event.issue_partner_sequence_block_call( context,'sequence_block',threadsafe_queue,_first_msg) seq_msg_call_res = threadsafe_queue.get() context.set_to_reply_with(seq_msg_call_res.reply_with_msg_field) # apply changes to sequence local data. (global changes, # which aren't applicable in this example, have already # been applied.) context.sequence_local_store.incorporate_deltas( active_event,seq_msg_call_res.sequence_local_var_store_deltas) # send more messages to_exec_next = seq_msg_call_res.to_exec_next_name_msg_field to_exec = getattr(self,to_exec_next) to_exec(active_event,context) else: # at this point, should initiate the commit of data. # print '\nComplete!!!\n' pass