Lines Matching refs:self
53 def __init__(self): argument
54 self._nodes = {}
55 self.commissioning_messages = {}
56 …self._payload_parse_factory = mesh_cop.MeshCopCommandFactory(mesh_cop.create_default_mesh_cop_tlv_…
57 self._mesh_cop_msg_set = mesh_cop.create_mesh_cop_message_type_set()
59 def __del__(self): argument
60 self._nodes = None
62 def add_node(self, node): argument
63 self._nodes[node.nodeid] = node
64 self.commissioning_messages[node.nodeid] = []
66 def set_lowpan_context(self, cid, prefix): argument
69 def get_messages_sent_by(self, nodeid): argument
72 def go(self, duration, nodeid=None): argument
75 def stop(self): argument
78 def read_cert_messages_in_commissioning_log(self, nodeids): argument
80 node = self._nodes[nodeid]
88 msg = self._payload_parse_factory.parse(type.decode("utf-8"), io.BytesIO(payload))
89 self.commissioning_messages[nodeid].append(msg)
94 def __init__(self, use_message_factory=True): argument
95 super(RealTime, self).__init__()
96 … self._sniffer = config.create_default_thread_sniffer(use_message_factory=use_message_factory)
97 self._sniffer.start()
99 def set_lowpan_context(self, cid, prefix): argument
100 self._sniffer.set_lowpan_context(cid, prefix)
102 def get_messages_sent_by(self, nodeid): argument
103 messages = self._sniffer.get_messages_sent_by(nodeid).messages
104 ret = message.MessagesSet(messages, self.commissioning_messages[nodeid])
105 self.commissioning_messages[nodeid] = []
108 def now(self): argument
111 def go(self, duration, nodeid=None): argument
114 def stop(self): argument
115 if self.is_running:
117 self._sniffer = None
120 def is_running(self): argument
121 return self._sniffer is not None
151 def __init__(self, use_message_factory=True): argument
152 super(VirtualTime, self).__init__()
153 self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
154 self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2 * 1024 * 1024)
155 self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2 * 1024 * 1024)
158 self.port = self.BASE_PORT + (self.PORT_OFFSET * (self.MAX_NODES + 1))
159 self.sock.bind((ip, self.port))
161 self.devices = {}
162 self.event_queue = []
164 self.event_sequence = 0
165 self.current_time = 0
166 self.current_event = None
167 self.awake_devices = set()
168 self._nodes_by_ack_seq = {}
169 self._node_ack_seq = {}
171 self._pcap = pcap.PcapCodec(os.getenv('TEST_NAME', 'current'))
173 self._spinel_cli_addr = (ip, self.BASE_PORT + self.port)
174 self.current_nodeid = None
175 self._pause_time = 0
178 self._message_factory = config.create_default_thread_message_factory()
180 self._message_factory = None
182 def __del__(self): argument
183 if self.sock:
184 self.stop()
186 def stop(self): argument
187 if self.sock:
188 self.sock.close()
189 self.sock = None
192 def is_running(self): argument
193 return self.sock is not None
195 def _add_message(self, nodeid, message_obj): argument
196 addr = ('127.0.0.1', self.port + nodeid)
200 if self._message_factory is not None:
201 messages = self._message_factory.create(io.BytesIO(message_obj))
202 self.devices[addr]['msgs'] += messages
211 def set_lowpan_context(self, cid, prefix): argument
212 if self._message_factory is not None:
213 self._message_factory.set_lowpan_context(cid, prefix)
215 def get_messages_sent_by(self, nodeid): argument
227 addr = ('127.0.0.1', self.port + nodeid)
229 messages = self.devices[addr]['msgs']
230 self.devices[addr]['msgs'] = []
232 ret = message.MessagesSet(messages, self.commissioning_messages[nodeid])
233 self.commissioning_messages[nodeid] = []
236 def _is_radio(self, addr): argument
237 return addr[1] < self.BASE_PORT * 2
239 def _to_core_addr(self, addr): argument
240 assert self._is_radio(addr)
241 return (addr[0], addr[1] + self.BASE_PORT)
243 def _to_radio_addr(self, addr): argument
244 assert not self._is_radio(addr)
245 return (addr[0], addr[1] - self.BASE_PORT)
247 def _core_addr_from(self, nodeid): argument
248 if self._nodes[nodeid].is_posix:
249 return ('127.0.0.1', self.BASE_PORT + self.port + nodeid)
251 return ('127.0.0.1', self.port + nodeid)
253 def _next_event_time(self): argument
254 if len(self.event_queue) == 0:
255 return self.END_OF_TIME
257 return self.event_queue[0][0]
259 def receive_events(self): argument
262 if (self.current_event or len(self.awake_devices) or
263 (self._next_event_time() > self._pause_time and self.current_nodeid)):
264 self.sock.settimeout(self.BLOCK_TIMEOUT)
266 msg, addr = self.sock.recvfrom(self.MAX_MESSAGE)
270 print(self.current_nodeid)
272 print(self.awake_devices)
274 print(self.current_time)
276 print(self.current_event)
278 for event in self.event_queue:
282 self.sock.settimeout(0)
284 msg, addr = self.sock.recvfrom(self.MAX_MESSAGE)
288 if addr != self._spinel_cli_addr and addr not in self.devices:
289 self.devices[addr] = {}
290 self.devices[addr]['alarm'] = None
291 self.devices[addr]['msgs'] = []
292 self.devices[addr]['time'] = self.current_time
293 self.awake_devices.discard(addr)
299 event_time = self.current_time + delay
313 if type == self.OT_SIM_EVENT_ALARM_FIRED:
315 if self.devices[addr]['alarm']:
316 self.event_queue.remove(self.devices[addr]['alarm'])
320 event = (event_time, self.event_sequence, addr, type, datalen)
321 self.event_sequence += 1
323 bisect.insort(self.event_queue, event)
324 self.devices[addr]['alarm'] = event
326 self.awake_devices.discard(addr)
328 if (self.current_event and self.current_event[self.EVENT_ADDR] == addr):
330 self.current_event = None
332 elif type == self.OT_SIM_EVENT_RADIO_RECEIVED:
333 assert self._is_radio(addr)
339 recv_devices = self._nodes_by_ack_seq.get(frame_info.seq_no)
341 recv_devices = recv_devices or self.devices.keys()
344 if device != addr and self._is_radio(device):
347 self.event_sequence,
353 self.event_sequence += 1
355 bisect.insort(self.event_queue, event)
357 self._pcap.append(data, (event_time // 1000000, event_time % 1000000))
358 self._add_message(addr[1] - self.port, data)
363 self.event_sequence,
369 self.event_sequence += 1
370 bisect.insort(self.event_queue, event)
373 self._on_ack_seq_change(addr, frame_info.seq_no)
375 self.awake_devices.add(addr)
377 elif type == self.OT_SIM_EVENT_RADIO_SPINEL_WRITE:
378 assert not self._is_radio(addr)
379 radio_addr = self._to_radio_addr(addr)
380 if radio_addr not in self.devices:
381 self.awake_devices.add(radio_addr)
385 self.event_sequence,
387 self.OT_SIM_EVENT_UART_WRITE,
391 self.event_sequence += 1
392 bisect.insort(self.event_queue, event)
394 self.awake_devices.add(addr)
396 elif type == self.OT_SIM_EVENT_UART_WRITE:
397 assert self._is_radio(addr)
398 core_addr = self._to_core_addr(addr)
399 if core_addr not in self.devices:
400 self.awake_devices.add(core_addr)
404 self.event_sequence,
406 self.OT_SIM_EVENT_RADIO_SPINEL_WRITE,
410 self.event_sequence += 1
411 bisect.insort(self.event_queue, event)
413 self.awake_devices.add(addr)
415 elif type == self.OT_SIM_EVENT_POSTCMD:
416 assert self.current_time == self._pause_time
418 if self.current_nodeid == nodeid:
419 self.current_nodeid = None
421 def _on_ack_seq_change(self, device: tuple, seq_no: int): argument
422 old_seq = self._node_ack_seq.pop(device, None)
424 self._nodes_by_ack_seq[old_seq].remove(device)
426 self._node_ack_seq[device] = seq_no
427 self._nodes_by_ack_seq.setdefault(seq_no, set()).add(device)
429 def _send_message(self, message, addr): argument
432 sent = self.sock.sendto(message, addr)
440 def process_next_event(self): argument
441 assert self.current_event is None
442 assert self._next_event_time() < self.END_OF_TIME
445 event = self.event_queue.pop(0)
461 self.current_event = event
463 assert event_time >= self.current_time
464 self.current_time = event_time
466 elapsed = event_time - self.devices[addr]['time']
467 self.devices[addr]['time'] = event_time
471 if type == self.OT_SIM_EVENT_ALARM_FIRED:
472 self.devices[addr]['alarm'] = None
473 self._send_message(message, addr)
474 elif type == self.OT_SIM_EVENT_RADIO_RECEIVED:
476 self._send_message(message, addr)
477 elif type == self.OT_SIM_EVENT_RADIO_SPINEL_WRITE:
479 self._send_message(message, addr)
480 elif type == self.OT_SIM_EVENT_UART_WRITE:
482 self._send_message(message, addr)
484 def sync_devices(self): argument
485 self.current_time = self._pause_time
486 for addr in self.devices:
487 elapsed = self.current_time - self.devices[addr]['time']
491 self.devices[addr]['time'] = self.current_time
492 message = struct.pack('=QBH', elapsed, self.OT_SIM_EVENT_ALARM_FIRED, 0)
493 self._send_message(message, addr)
494 self.awake_devices.add(addr)
495 self.receive_events()
496 self.awake_devices.clear()
498 def now(self): argument
499 return self.current_time / 1000000
501 def go(self, duration, nodeid=None): argument
502 assert self.current_time == self._pause_time
505 self._pause_time += duration
507 if self.NCP_SIM:
508 self.current_nodeid = nodeid
509 self.awake_devices.add(self._core_addr_from(nodeid))
510 self.receive_events()
511 while self._next_event_time() <= self._pause_time:
512 self.process_next_event()
513 self.receive_events()
515 self.sync_devices()
516 dbg_print('current time %d us' % self.current_time)