async def run(*args, **kwargs): called.append("run") if len(called) > 0: s1 = DiscoveryMessages.StateService( service=Services.UDP, port=56, target="d073d5000001" ) s1.Information.update( remote_addr=("192.168.0.3", 56700), sender_message=DiscoveryMessages.GetService(), ) yield s1 if len(called) > 1: s2 = DiscoveryMessages.StateService( service=Services.UDP, port=58, target="d073d5000002" ) s2.Information.update( remote_addr=("192.168.0.4", 56700), sender_message=DiscoveryMessages.GetService(), ) yield s2 if len(called) > 2: s3 = DiscoveryMessages.StateService( service=Services.UDP, port=59, target="d073d5000003" ) s3.Information.update( remote_addr=("192.168.0.5", 56700), sender_message=DiscoveryMessages.GetService(), ) yield s3
async def respond(s, event): if event | DeviceMessages.GetPower: event.set_replies(DeviceMessages.StatePower(level=s.device_attrs.power)) if event | DeviceMessages.GetLabel: event.ignore_request() elif event | DeviceMessages.SetPower: event.set_replies(DeviceMessages.StatePower(level=s.device_attrs.power)) await s.device_attrs.attrs_apply( s.device_attrs.attrs_path("power").changer_to(event.pkt.level), event=None, ) elif event | DiscoveryMessages.GetService: event.set_replies( DiscoveryMessages.StateService(service=Services.UDP, port=56700), DiscoveryMessages.StateService(service=Services.UDP, port=76500), )
async def respond(self, event): if event | DiscoveryMessages.GetService and event.io is self: port = self.options.get("state_service_port", self.options.port) state_service_port = 0 if port is None else port event.add_replies( DiscoveryMessages.StateService( service=self.options.state_service, port=state_service_port))
async def run(*args, **kwargs): s1 = DiscoveryMessages.StateService( service=Services.UDP, port=56, target="d073d5000001" ) s1.Information.update( remote_addr=("192.168.0.3", 56700), sender_message=DiscoveryMessages.GetService(), ) yield s1
async def ensure_udp_service(self): await self.stop_service(Services.UDP) class ServerProtocol(asyncio.Protocol): def connection_made(sp, transport): sp.udp_transport = transport def datagram_received(sp, data, addr): if not self.attrs.online: return async def received_data(bts, a): sp.udp_transport.sendto(bts, addr) self.sync_write("udp", received_data, data) def error_received(sp, exc): log.error(hp.lc("Error on udp transport", error=exc)) remote = None for i in range(3): port = self.port if port is None: port = self.make_port() try: remote, _ = await asyncio.get_event_loop( ).create_datagram_endpoint(ServerProtocol, local_addr=("0.0.0.0", port)) break except OSError: log.exception("Couldn't make datagram server") await asyncio.sleep(0.1) if remote is None: raise Exception("Failed to bind to a udp socket for fake device") async def closer(): remote.close() async def add_service(adder): await adder(self.serial, Services.UDP, host="127.0.0.1", port=port) def address(source): if source == "udp": return ("127.0.0.1", port) state_service = DiscoveryMessages.StateService(service=Services.UDP, port=port) self.services.append( Service(Services.UDP, closer, add_service, state_service, address))
async def ensure_memory_service(self): await self.stop_service(MemoryService) async def closer(): pass async def add_service(adder): await adder(self.serial, MemoryService, writer=partial(self.write, "memory")) def address(source): if source == "memory": return (f"fake://{self.serial}/memory", 56700) state_service = DiscoveryMessages.StateService(service=Services.UDP, port=56700) self.services.append( Service(MemoryService, closer, add_service, state_service, address))
def make_response(self, pkt, protocol): if pkt | DiscoveryMessages.GetService: msgs = [] for service, (_, port) in self.services[0]: msgs.append(DiscoveryMessages.StateService(service=service, port=port)) return msgs
def datagram_received(sp, data, addr): pkt = DiscoveryMessages.unpack(data, protocol_register=protocol_register) assert pkt | DiscoveryMessages.GetService res = DiscoveryMessages.StateService(target=target, source=pkt.source, sequence=pkt.sequence, service=Services.UDP, port=port) self.transport.sendto(res.tobytes(None), addr)
sent_pkt_type=502, sequence=1, source=2, serial=device.serial, ): await send_single(original, timeout=3, no_retry=True) assert t.time == 3 assertSent(sender, (0, device.serial, original.Payload.__name__, original.payload)) async it "doesn't wait beyond timeout for unlimited reply messages that get no reply", send_single, sender, device, FakeTime, MockedCallLater: original = DiscoveryMessages.GetService(ack_required=False) io = device.io["MEMORY"] reply1 = DiscoveryMessages.StateService(service=1, port=56700) reply2 = DiscoveryMessages.StateService(service=2, port=56700) info = {"m": None} @io.packet_filter.intercept_process_request async def process_request(event, Cont): if event | DiscoveryMessages.GetService: event.set_replies(Cont) event.handled = False event._viewers_only = True return True else: raise Cont() @io.packet_filter.intercept_process_outgoing