def test_airport_handler():
handler, _ = scan()[AIRPORT_SERVICE]
mdns_service = mdns.Service(RAOP_SERVICE, "foo@bar",
ip_address("127.0.0.1"), 1234, {"foo": "bar"})
mdns_response = mdns.Response([], False, None)
assert not handler(mdns_service, mdns_response)
def test_airplay_handler_to_service():
handler, _ = scan()[AIRPLAY_SERVICE]
mdns_service = mdns.Service(AIRPLAY_SERVICE, "foo",
ip_address("127.0.0.1"), 1234, {"foo": "bar"})
mdns_response = mdns.Response([], False, None)
name, service = handler(mdns_service, mdns_response)
assert name == "foo"
assert service.port == 1234
assert service.credentials is None
assert not DeepDiff(service.properties, {"foo": "bar"})
def test_mrp_handler_to_service():
handler, _ = scan()[MRP_SERVICE]
mdns_service = mdns.Service(MRP_SERVICE, "foo", ip_address("127.0.0.1"),
1234, {"Name": "test"})
mdns_response = mdns.Response([], False, None)
name, service = handler(mdns_service, mdns_response)
assert name == "test"
assert service.port == 1234
assert service.credentials is None
assert not DeepDiff(service.properties, {"Name": "test"})
def test_homesharing_handler_to_service():
handler, _ = scan()[HOMESHARING_SERVICE]
mdns_service = mdns.Service(
HOMESHARING_SERVICE, "foo", ip_address("127.0.0.1"), 1234, {"Name": "bar"}
)
mdns_response = mdns.Response([], False, None)
name, service = handler(mdns_service, mdns_response)
assert name == "bar"
assert service.port == 1234
assert service.credentials is None
assert not DeepDiff(service.properties, {"Name": "bar"})
def _process_responses(
self,
dev_services_by_address: Dict[str, List[mdns.Service]],
model_by_address: Dict[str, Optional[str]],
):
"""Process and callback each aggregated response to the base handler."""
for address, dev_services in dev_services_by_address.items():
self.handle_response(
mdns.Response(
services=dev_services,
deep_sleep=all(
service.port == 0 and service.type != SLEEP_PROXY_TYPE
for service in dev_services),
model=model_by_address.get(address),
))
async def _multicast(loop, services, **kwargs):
# Flatten list of lists of addresses: [["1.2.3.4"], ["2.2.2.2"]] -> ["1.2.3.4", "2.2.2.2"]
hosts = set(
chain(*[
service.addresses for service in udns_server.services.values()
]))
devices = []
sleep_proxy = udns_server.sleep_proxy
udns_server.sleep_proxy = False
for host in hosts:
udns_server.ip_filter = host
response = await mdns.unicast(loop,
"127.0.0.1",
services,
port=udns_server.port)
devices.append(
mdns.Response(response.services, sleep_proxy, response.model))
return devices
async def _get_services(self, host: IPv4Address,
timeout: int) -> mdns.Response:
port = int(os.environ.get("PYATV_UDNS_PORT",
5353)) # For testing purposes
knocker = None
try:
knocker = await knock.knocker(host,
KNOCK_PORTS,
self.loop,
timeout=timeout)
response = await mdns.unicast(
self.loop,
str(host),
self.services,
port=port,
timeout=timeout,
)
except asyncio.TimeoutError:
return mdns.Response([], False, None)
finally:
if knocker:
knocker.cancel()
return response
