def finish(self):
pyons.info(
"===== client id={} finished:"
"\n\t* requests sent : {}/{}"
"\n\t* responses received: {}"
"".format(self.client_id, self.num_requests_sent,
self.max_requests, self.num_responses_received), self)
def pong_handler(event, source=None):
cmd = Message('PING', next(pyons.get_model().command_index))
pyons.get_model().num_pings_generated += 1
pyons.create_timeout(pyons.get_model().next_ping_timeout, cmd)
pyons.info("received {}, sending {} in {} sec.".format(
event, cmd, pyons.get_model().next_ping_timeout),
sender="pong_handler")
def finish(self):
pyons.info(
"===== server finished:"
"\n\t* requests received: {}"
"\n\t* responses sent : {}"
"".format(self.num_requests_received, self.num_responses_sent),
"Server")
def handle_response(self, event, source):
if not isinstance(source, Server):
raise RuntimeError("expected events from server only")
self.num_responses_received += 1
pyons.info("received {} from the server".format(event), self)
self.next_request_timeout_id = pyons.create_timeout(
self.request_interval, "timeout")
def generate(self, event, source):
assert source is self and event == "timeout"
client_id = self.next_client_id
pyons.info("building a new client #{}".format(client_id), self)
client = Client(client_id, self.server, self.max_requests,
self.request_interval)
pyons.add_entity(client)
self.next_timeout_id = pyons.create_timeout(self.timeout, "timeout")
self.next_client_id += 1
def finalize():
m = pyons.get_model()
pyons.info("PingPong is finished:", sender="finalize")
print("\t+ pings generated: {}".format(m.num_pings_generated))
print("\t+ pongs generated: {}".format(m.num_pongs_generated))
print("\t+ events generated: {}".format(pyons.get_num_events_served()))
events = ['{}@t={}'.format(envelope.event, envelope.time)
for envelope in pyons.Dispatcher().events]
print("\t+ resting events: {}".format(events))
def _handle_slot_end(self):
# STATISTICS ====>
assert isinstance(self.tag_read_data, journal.TagReadRecord)
assert isinstance(self.round_info, journal.InventoryRoundRecord)
if self.tag_read_data.epc is not None:
if self.tag_read_data.tid is not None:
self.round_info.n_tid_reads += 1
else:
self.round_info.n_epc_only_reads += 1
journal.Journal().write_tag_read(self.tag_read_data)
pyons.info("** received tag: EPC={}, TID={}".format(
self.tag_read_data.epc, self.tag_read_data.tid))
self._slot_durations.append(pyons.time() - self._slot_started_at)
self.tag_read_data = None
# <===== END OF STATISTICS
self._slot += 1
if self._slot < 2**self.q:
self._handle_slot_start()
else:
self._handle_round_end()
def ping_handler(event, source=None):
reply = Message('PONG', event.index)
pyons.get_model().num_pongs_generated += 1
pyons.create_timeout(pyons.get_model().reply_timeout, reply)
pyons.info("received {}, sending {} in {} sec.".format(
event, reply, pyons.get_model().reply_timeout), sender="ping_handler")
def initialize():
pyons.info("PingPong is initializing", sender="initialize")
cmd = Message('PING', next(pyons.get_model().command_index))
pyons.get_model().num_pings_generated += 1
pyons.create_timeout(0, cmd)
def handle_event(self, event, source):
self.num_requests_received += 1
self.num_responses_sent += 1
msg = ("pong", event[1], event[2])
pyons.info("received {}, sending {}".format(event, msg), "Server")
pyons.send_event(msg, source)
def send_next_ping(self):
index = next(self.ping_index)
pyons.info("sending ping #{} to the server".format(index), self)
pyons.send_event(("ping", self.client_id, index), self.server)
self.num_requests_sent += 1
return index
def finish(self):
pyons.info("===== generator finished:"
"\n\t* clients generated: {}".format(self.next_client_id))