arcsecond 3.18.2__tar.gz → 3.19.0__tar.gz

{arcsecond-3.18.2 → arcsecond-3.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arcsecond
-Version: 3.18.2
+Version: 3.19.0
 Summary: CLI for arcsecond.io
 Project-URL: Homepage, https://github.com/arcsecond-io/cli
 Project-URL: Issues, https://github.com/arcsecond-io/cli/issues

{arcsecond-3.18.2 → arcsecond-3.19.0}/arcsecond/imagesources/commands.py

@@ -613,13 +613,15 @@ def _unreachable_note(url: str) -> Optional[str]:
     )
     host = (urlsplit(url).hostname or "").lower()
     if host.endswith(".local"):
-        # The failure that is worth explaining rather than merely reporting:
-        # the browser you found the address in resolves .local names over
-        # mDNS, and the proxy asks the machine's resolver, which often cannot.
+        # Worth explaining rather than merely reporting. A .local name is
+        # answered by its own machine over multicast, and the proxy asks that
+        # way itself when this computer's resolver cannot — so reaching here
+        # means neither worked, and something is eating the multicast.
         note += (
-            " A .local name is answered by that machine itself over mDNS, "
-            "which not every computer can do — registering its IP address "
-            "instead is the reliable form."
+            " A .local name is answered by that machine itself over mDNS. The "
+            "proxy asks that way too when this computer cannot, so something "
+            "on the network is stopping both — a firewall, or a subnet the "
+            "multicast does not cross. Its IP address is the reliable form."
         )
     return note
 

{arcsecond-3.18.2 → arcsecond-3.19.0}/arcsecond/imagesources/detection.py

@@ -35,6 +35,8 @@ from urllib.parse import urlsplit
 
 from .sources.base import DetectedDevice
 from .sources.filewatch import detect_allsky
+from .sources.mdns import resolve as resolve_over_mdns
+from .sources.network import HTTP_SCHEMES
 from .store import ALLSKY, USB, Camera
 
 logger = logging.getLogger(__name__)
@@ -109,17 +111,45 @@ def is_reachable(url: str, timeout: float = NETWORK_TIMEOUT) -> tuple:
     if endpoint is None:
         return False, "the address cannot be read"
     host, port = endpoint
+
     try:
         with socket.create_connection((host, port), timeout=timeout):
             return True, f"answering on {host}:{port}"
     except socket.gaierror:
-        # Told apart from a connection that fails: nothing is wrong with the
-        # camera, the name simply does not resolve on this machine, and that
-        # is a different thing to go and fix.
-        return False, f"{host} cannot be resolved"
+        pass
     except OSError as e:
         return False, f"no answer on {host}:{port} ({e.strerror or e})"
 
+    # The machine's resolver has no answer. A `.local` name can still be
+    # answered by the machine that owns it, which is exactly what the proxy
+    # does when it connects — so the same fallback belongs here, or `detect`
+    # would call a camera missing that the proxy serves perfectly well.
+    #
+    # Only for the addresses the proxy fetches itself: an RTSP stream is
+    # opened by FFmpeg, with its own resolver and no way in, so promising that
+    # one works would be a promise this cannot keep.
+    if urlsplit(url).scheme.lower() not in HTTP_SCHEMES:
+        return False, f"{host} cannot be resolved"
+
+    addresses = resolve_over_mdns(host)
+    if not addresses:
+        # Told apart from a connection that fails: nothing is wrong with the
+        # camera, the name simply does not resolve here, and that is a
+        # different thing to go and fix.
+        return False, f"{host} cannot be resolved"
+
+    # A machine with several interfaces answers with an address for each, and
+    # only some of them are reachable from here — the same reason the proxy
+    # hands the whole list to aiohttp rather than picking one.
+    why = ""
+    for address in addresses:
+        try:
+            with socket.create_connection((address, port), timeout=timeout):
+                return True, f"answering on {address}:{port}, found over mDNS"
+        except OSError as e:
+            why = f"no answer on {address}:{port} ({e.strerror or e})"
+    return False, why
+
 
 # ---------------------------------------------------------------------------
 # The report

arcsecond-3.19.0/arcsecond/imagesources/sources/mdns.py

@@ -0,0 +1,221 @@
+"""
+Resolving a ``.local`` name when the machine's own resolver will not.
+
+A ``.local`` name is not in any DNS server: the machine that owns it answers
+for itself, over multicast, on 224.0.0.251:5353 (RFC 6762). Most operating
+systems do that for every application — macOS through mDNSResponder, Linux
+through Avahi, Windows through its DNS client — but not all of them do, and
+not on every network profile. When they do not, ``getaddrinfo`` sends the
+query to the configured DNS server instead, which knows nothing about
+``.local`` and answers SERVFAIL. That is what a proxy sees as::
+
+    Cannot connect to host skykot.local:80 [DNS server returned general failure]
+
+while the browser two windows away, which speaks mDNS itself, shows the very
+same camera. So the proxy speaks it too, as a fallback and only for ``.local``
+names — anything else belongs to the machine's resolver and stays there.
+
+This is deliberately a *one-shot* query, not a discovery service: one question
+about one name, the first answer wins, and nothing is kept running. mDNS on
+the wire is ordinary DNS, so what follows is a small DNS encoder and decoder
+rather than anything exotic.
+"""
+
+import logging
+import socket
+import struct
+import time
+
+logger = logging.getLogger(__name__)
+
+MDNS_ADDRESS = "224.0.0.251"
+MDNS_PORT = 5353
+SUFFIX = ".local"
+
+# Long enough for a machine on the same network to answer, short enough that a
+# camera which is simply switched off does not hold anything up. A responder
+# on the same LAN answers in milliseconds.
+DEFAULT_TIMEOUT = 1.5
+
+_TYPE_A = 1
+_CLASS_IN = 1
+# RFC 6762 §5.4: the top bit of the class field asks the responder to answer
+# this one directly to our port rather than multicasting it to the network.
+# Without it the answer goes to port 5353, where the system responder — if
+# there is one — is listening instead of us.
+_UNICAST_RESPONSE = 0x8000
+_HEADER = struct.Struct("!6H")
+_POINTER_MASK = 0xC0
+
+
+def is_mdns_name(host: str) -> bool:
+    """Whether ``host`` is a name only multicast DNS can answer for."""
+    host = (host or "").strip().rstrip(".").lower()
+    return host.endswith(SUFFIX) and host != SUFFIX
+
+
+def _encode_name(name: str) -> bytes:
+    parts = [p for p in name.strip().rstrip(".").split(".") if p]
+    encoded = b""
+    for part in parts:
+        raw = part.encode("utf-8")
+        if len(raw) > 63:
+            raise ValueError(f"label too long in {name!r}")
+        encoded += bytes([len(raw)]) + raw
+    return encoded + b"\x00"
+
+
+def _build_query(name: str) -> bytes:
+    # Transaction id 0: a responder echoes it back, and having only one query
+    # in flight per socket means there is nothing to match it against.
+    header = _HEADER.pack(0, 0, 1, 0, 0, 0)
+    question = _encode_name(name)
+    question += struct.pack("!HH", _TYPE_A, _CLASS_IN | _UNICAST_RESPONSE)
+    return header + question
+
+
+def _read_name(data: bytes, offset: int) -> tuple:
+    """``(name, offset_after)``, following compression pointers.
+
+    Answers routinely point back into the question rather than repeating the
+    name, so a decoder that cannot follow a pointer reads garbage.
+    """
+    labels = []
+    jumped = False
+    end = offset
+    seen = 0
+
+    while True:
+        if offset >= len(data):
+            raise ValueError("truncated name")
+        length = data[offset]
+        if length == 0:
+            offset += 1
+            if not jumped:
+                end = offset
+            break
+        if length & _POINTER_MASK == _POINTER_MASK:
+            if offset + 1 >= len(data):
+                raise ValueError("truncated pointer")
+            target = ((length & 0x3F) << 8) | data[offset + 1]
+            if not jumped:
+                end = offset + 2
+                jumped = True
+            # A pointer chain must make progress towards the start of the
+            # packet; anything else is a loop, and a packet from the network
+            # is not to be trusted to avoid one.
+            if target >= offset:
+                raise ValueError("pointer does not move backwards")
+            offset = target
+            seen += 1
+            if seen > 32:
+                raise ValueError("too many pointers")
+            continue
+        offset += 1
+        labels.append(data[offset : offset + length].decode("utf-8", "replace"))
+        offset += length
+
+    return ".".join(labels), end
+
+
+def _parse_response(data: bytes, wanted: str) -> list:
+    """Every IPv4 address ``wanted`` resolves to in ``data``.
+
+    Only A records for the name that was asked about count. A response may
+    carry records about other names entirely — a responder is free to include
+    whatever it thinks useful — and answering with one of those would send the
+    proxy to a different machine.
+
+    All of them, not the first: a machine with more than one interface answers
+    with an address per interface, and which of those the caller can actually
+    reach is not something this can tell from here. A Mac answering for itself
+    while a virtual network is up is the ordinary case, not an exotic one.
+    """
+    found: list = []
+    try:
+        _, _, questions, answers, authority, additional = _HEADER.unpack_from(data)
+    except struct.error:
+        return found
+
+    offset = _HEADER.size
+    try:
+        for _ in range(questions):
+            _, offset = _read_name(data, offset)
+            offset += 4  # QTYPE, QCLASS
+
+        target = wanted.rstrip(".").lower()
+        for _ in range(answers + authority + additional):
+            name, offset = _read_name(data, offset)
+            rtype, rclass, _, length = struct.unpack_from("!HHIH", data, offset)
+            offset += 10
+            rdata = data[offset : offset + length]
+            offset += length
+            if (
+                rtype == _TYPE_A
+                and (rclass & 0x7FFF) == _CLASS_IN
+                and len(rdata) == 4
+                and name.rstrip(".").lower() == target
+            ):
+                address = socket.inet_ntoa(rdata)
+                if address not in found:
+                    found.append(address)
+    except (ValueError, struct.error, IndexError):
+        # A malformed packet is one more reason to fall back to failing, not a
+        # reason to take the proxy down. Anyone on the network can send one.
+        # Whatever was read before the damage is still good.
+        logger.debug("Ignoring the rest of a malformed mDNS response for %s", wanted)
+
+    return found
+
+
+def resolve(host: str, timeout: float = DEFAULT_TIMEOUT) -> list:
+    """Ask the network for ``host``'s IPv4 addresses. Empty if none answer.
+
+    In the order the responder gave them, which is the order to try them in:
+    the caller connects to each until one works, since a machine with several
+    interfaces answers for all of them and only some may be reachable.
+
+    Blocking, and short. Call it from a thread when the caller is async.
+    """
+    if not is_mdns_name(host):
+        return []
+
+    name = host.strip().rstrip(".")
+    try:
+        query = _build_query(name)
+    except ValueError:
+        return []
+
+    sock = None
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 1)
+        sock.settimeout(timeout)
+        sock.bind(("", 0))
+        sock.sendto(query, (MDNS_ADDRESS, MDNS_PORT))
+
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            sock.settimeout(max(0.05, deadline - time.monotonic()))
+            try:
+                data, _ = sock.recvfrom(4096)
+            except socket.timeout:
+                return []
+            addresses = _parse_response(data, name)
+            if addresses:
+                logger.info("Resolved %s to %s over mDNS.", name, addresses)
+                return addresses
+            # Something else on the network answered, or answered about
+            # another name. Keep listening until the deadline rather than
+            # taking the first packet as the last word.
+    except OSError as e:
+        # No multicast route, a firewall in the way, a network that is down:
+        # all of them mean "not resolved here", which is what the caller does
+        # something about.
+        logger.debug("mDNS query for %s failed: %s", name, e)
+    finally:
+        if sock is not None:
+            sock.close()
+
+    return []

{arcsecond-3.18.2 → arcsecond-3.19.0}/arcsecond/imagesources/sources/network.py

@@ -22,9 +22,11 @@ import asyncio
 import hashlib
 import logging
 import os
+import socket
 from typing import Optional
 from urllib.parse import urlsplit, urlunsplit
 
+from . import mdns
 from .base import FrameSource, SourceInfo
 
 logger = logging.getLogger(__name__)
@@ -163,6 +165,7 @@ class HTTPImageSource(FrameSource):
         self._etag: Optional[str] = None
         self._last_modified: Optional[str] = None
         self._digest: Optional[bytes] = None
+        self._resolver = None
 
     async def open(self) -> None:
         import aiohttp
@@ -170,7 +173,13 @@ class HTTPImageSource(FrameSource):
         timeout = aiohttp.ClientTimeout(
             total=None, connect=_CONNECT_TIMEOUT, sock_read=_READ_TIMEOUT
         )
-        self._session = aiohttp.ClientSession(timeout=timeout)
+        # aiohttp never closes a resolver it was handed, so this one is kept
+        # and closed alongside the session.
+        self._resolver = _mdns_aware_resolver()
+        self._session = aiohttp.ClientSession(
+            timeout=timeout,
+            connector=aiohttp.TCPConnector(resolver=self._resolver),
+        )
 
         try:
             response = await self._session.get(self.url)
@@ -266,6 +275,9 @@ class HTTPImageSource(FrameSource):
         if self._session is not None:
             await self._session.close()
             self._session = None
+        if self._resolver is not None:
+            await self._resolver.close()
+            self._resolver = None
 
     def info(self) -> SourceInfo:
         return SourceInfo(
@@ -279,6 +291,65 @@ class HTTPImageSource(FrameSource):
         )
 
 
+async def _resolve_over_mdns(host: str) -> list:
+    """``host``'s addresses according to the machine that owns the name."""
+    if not mdns.is_mdns_name(host):
+        return []
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(None, mdns.resolve, host)
+
+
+def _mdns_aware_resolver():
+    """An aiohttp resolver that falls back to mDNS for a ``.local`` name.
+
+    The machine's own resolver is asked first and is almost always the end of
+    it. Only when it has no answer, and only for a ``.local`` name, is the
+    network asked directly — see ``mdns``. A camera registered by such a name
+    therefore keeps working when its address changes, which is the whole
+    reason for resolving at connect time rather than storing an address.
+
+    Built inside a function because aiohttp is an optional dependency: the CLI
+    has to stay importable on a machine that never installed the proxy extra.
+    """
+    import aiohttp
+    from aiohttp.abc import AbstractResolver
+
+    class _MDNSFallbackResolver(AbstractResolver):
+        def __init__(self):
+            self._default = aiohttp.DefaultResolver()
+
+        async def resolve(self, host, port=0, family=socket.AF_INET):
+            try:
+                return await self._default.resolve(host, port, family)
+            except OSError:
+                # Only A records are asked for, so an IPv6-only lookup is not
+                # something this can answer.
+                if family not in (socket.AF_INET, socket.AF_UNSPEC):
+                    raise
+                addresses = await _resolve_over_mdns(host)
+                if not addresses:
+                    raise
+                # Every address the machine answered with, in the order it
+                # gave them: aiohttp tries them in turn, which is what makes
+                # a responder with several interfaces work.
+                return [
+                    {
+                        "hostname": host,
+                        "host": address,
+                        "port": port,
+                        "family": socket.AF_INET,
+                        "proto": 0,
+                        "flags": socket.AI_NUMERICHOST,
+                    }
+                    for address in addresses
+                ]
+
+        async def close(self) -> None:
+            await self._default.close()
+
+    return _MDNSFallbackResolver()
+
+
 class AllSkyHTTPSource(HTTPImageSource):
     """An all-sky camera that publishes its JPEG over HTTP.
 

{arcsecond-3.18.2 → arcsecond-3.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arcsecond"
-version = "3.18.2"
+version = "3.19.0"
 authors = [
     { name = "Cedric Foellmi", email = "cedric@arcsecond.io" },
 ]

{arcsecond-3.18.2 → arcsecond-3.19.0}/tests/test_imagesources_detection.py

@@ -135,19 +135,73 @@ def test_reachability_never_leaks_the_password():
     assert "hunter2" not in why
 
 
-def test_a_name_that_does_not_resolve_says_so(monkeypatch):
-    """Distinct from a refused connection: the camera may be perfectly fine."""
+def _unresolvable(monkeypatch, answering=()):
+    """Make the machine's resolver fail, except for addresses in ``answering``."""
     import socket as socket_module
 
-    def no_such_name(*a, **k):
+    from contextlib import nullcontext
+
+    def connect(endpoint, timeout=None):
+        host, _ = endpoint
+        if host in answering:
+            return nullcontext()
         raise socket_module.gaierror(-2, "Name or service not known")
 
-    monkeypatch.setattr(detection.socket, "create_connection", no_such_name)
+    monkeypatch.setattr(detection.socket, "create_connection", connect)
+
+
+def test_a_name_that_does_not_resolve_says_so(monkeypatch):
+    """Distinct from a refused connection: the camera may be perfectly fine."""
+    _unresolvable(monkeypatch)
+    monkeypatch.setattr(detection, "resolve_over_mdns", lambda host, **k: [])
+
     reachable, why = detection.is_reachable("http://skykot.local/image.jpg")
     assert reachable is False
     assert why == "skykot.local cannot be resolved"
 
 
+def test_a_local_name_the_machine_cannot_resolve_is_asked_of_the_network(monkeypatch):
+    """What the proxy does when it connects, so `detect` must agree with it."""
+    _unresolvable(monkeypatch, answering={"192.168.1.42"})
+    monkeypatch.setattr(
+        detection, "resolve_over_mdns", lambda host, **k: ["192.168.1.42"]
+    )
+
+    reachable, why = detection.is_reachable("http://skykot.local/image.jpg")
+    assert reachable is True
+    assert why == "answering on 192.168.1.42:80, found over mDNS"
+
+
+def test_an_address_that_does_not_answer_is_not_the_last_word(monkeypatch):
+    """The first address a multi-homed machine gives may be one this network
+    cannot reach; the others are still worth trying."""
+    _unresolvable(monkeypatch, answering={"192.168.1.97"})
+    monkeypatch.setattr(
+        detection,
+        "resolve_over_mdns",
+        lambda host, **k: ["192.168.64.1", "192.168.1.97"],
+    )
+
+    reachable, why = detection.is_reachable("http://skykot.local/image.jpg")
+    assert reachable is True
+    assert "192.168.1.97" in why
+
+
+def test_a_video_stream_is_not_asked_of_the_network(monkeypatch):
+    """FFmpeg opens an RTSP stream with its own resolver, out of our reach —
+    so promising it works would be a promise we cannot keep."""
+    _unresolvable(monkeypatch, answering={"192.168.1.42"})
+
+    def never(*a, **k):
+        raise AssertionError("asked over mDNS")
+
+    monkeypatch.setattr(detection, "resolve_over_mdns", never)
+
+    reachable, why = detection.is_reachable("rtsp://cam.local/stream1")
+    assert reachable is False
+    assert why == "cam.local cannot be resolved"
+
+
 def test_an_address_that_cannot_be_read_is_not_contacted():
     reachable, why = detection.is_reachable("http://")
     assert reachable is False

arcsecond-3.19.0/tests/test_imagesources_mdns.py

@@ -0,0 +1,273 @@
+"""Tests for resolving a `.local` name when the machine's resolver will not.
+
+Nothing here touches the network: the wire format is what matters, so the
+packets are built by hand and fed to the parser. A responder on the other end
+is somebody else's software, and a test that waited for one would pass or fail
+according to what happens to be plugged in.
+"""
+
+import socket
+import struct
+
+import pytest
+
+from arcsecond.imagesources.sources import mdns
+
+NAME = "skykot.local"
+
+
+def _response(records, questions=(NAME,), flags=0x8400):
+    """A response packet carrying ``records`` as ``(name, type, rdata)``."""
+    header = mdns._HEADER.pack(0, flags, len(questions), len(records), 0, 0)
+    body = b""
+    for question in questions:
+        body += mdns._encode_name(question) + struct.pack("!HH", 1, 1)
+    for name, rtype, rdata in records:
+        body += mdns._encode_name(name)
+        body += struct.pack("!HHIH", rtype, 1, 120, len(rdata)) + rdata
+    return header + body
+
+
+# ---------------------------------------------------------------------------
+# Which names this is for
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "host,expected",
+    [
+        ("skykot.local", True),
+        ("skykot.local.", True),
+        ("SKYKOT.LOCAL", True),
+        ("allsky.example.com", False),
+        ("192.168.1.42", False),
+        (".local", False),
+        ("", False),
+    ],
+)
+def test_only_local_names_are_asked_of_the_network(host, expected):
+    """Everything else belongs to the machine's resolver and stays there."""
+    assert mdns.is_mdns_name(host) is expected
+
+
+def test_a_name_that_is_not_local_is_not_even_asked(monkeypatch):
+    def no_sockets(*a, **k):
+        raise AssertionError("opened a socket")
+
+    monkeypatch.setattr(mdns.socket, "socket", no_sockets)
+    assert mdns.resolve("allsky.example.com") == []
+
+
+# ---------------------------------------------------------------------------
+# The query
+# ---------------------------------------------------------------------------
+
+
+def test_the_query_asks_for_one_a_record_by_name():
+    query = mdns._build_query(NAME)
+    _, _, questions, answers, _, _ = mdns._HEADER.unpack_from(query)
+    assert (questions, answers) == (1, 0)
+    assert mdns._encode_name(NAME) in query
+
+
+def test_the_query_asks_to_be_answered_directly():
+    """Without the unicast bit the answer goes to port 5353, where the
+    system responder is listening instead of us."""
+    query = mdns._build_query(NAME)
+    _, qclass = struct.unpack("!HH", query[-4:])
+    assert qclass & mdns._UNICAST_RESPONSE
+    assert qclass & 0x7FFF == mdns._CLASS_IN
+
+
+# ---------------------------------------------------------------------------
+# The answer
+# ---------------------------------------------------------------------------
+
+
+def test_an_address_is_read_from_the_answer():
+    packet = _response([(NAME, 1, socket.inet_aton("192.168.1.42"))])
+    assert mdns._parse_response(packet, NAME) == ["192.168.1.42"]
+
+
+def test_a_name_written_as_a_pointer_is_followed():
+    """Responders routinely point back at the question instead of repeating
+    the name, so a decoder that cannot follow one reads garbage."""
+    header = mdns._HEADER.pack(0, 0x8400, 1, 1, 0, 0)
+    question = mdns._encode_name(NAME) + struct.pack("!HH", 1, 1)
+    pointer = struct.pack("!H", 0xC000 | mdns._HEADER.size)
+    answer = pointer + struct.pack("!HHIH", 1, 1, 120, 4)
+    answer += socket.inet_aton("192.168.1.42")
+
+    assert mdns._parse_response(header + question + answer, NAME) == ["192.168.1.42"]
+
+
+def test_an_answer_about_another_machine_is_not_taken():
+    """A responder may say whatever it finds useful. Taking one of those
+    would send the proxy to a different machine entirely."""
+    packet = _response([("other.local", 1, socket.inet_aton("10.0.0.1"))])
+    assert mdns._parse_response(packet, NAME) == []
+
+
+def test_the_right_answer_is_found_among_others():
+    packet = _response(
+        [
+            ("other.local", 1, socket.inet_aton("10.0.0.1")),
+            (NAME, 1, socket.inet_aton("192.168.1.42")),
+        ]
+    )
+    assert mdns._parse_response(packet, NAME) == ["192.168.1.42"]
+
+
+def test_every_address_a_machine_answers_with_is_kept():
+    """A machine with more than one interface answers with one address each,
+    and which of them the caller can reach is not knowable from here."""
+    packet = _response(
+        [
+            (NAME, 1, socket.inet_aton("192.168.64.1")),
+            (NAME, 1, socket.inet_aton("192.168.1.97")),
+        ]
+    )
+    assert mdns._parse_response(packet, NAME) == ["192.168.64.1", "192.168.1.97"]
+
+
+def test_the_same_address_twice_is_kept_once():
+    packet = _response(
+        [
+            (NAME, 1, socket.inet_aton("192.168.1.97")),
+            (NAME, 1, socket.inet_aton("192.168.1.97")),
+        ]
+    )
+    assert mdns._parse_response(packet, NAME) == ["192.168.1.97"]
+
+
+def test_a_record_that_is_not_an_address_is_ignored():
+    packet = _response([(NAME, 12, mdns._encode_name("something.local"))])
+    assert mdns._parse_response(packet, NAME) == []
+
+
+@pytest.mark.parametrize(
+    "packet",
+    [
+        b"",
+        b"\x00\x01\x02",
+        mdns._HEADER.pack(0, 0x8400, 1, 1, 0, 0) + b"\x05sky",  # truncated name
+        # A pointer to itself: a packet from the network must not be trusted
+        # to avoid a loop.
+        mdns._HEADER.pack(0, 0x8400, 0, 1, 0, 0) + struct.pack("!H", 0xC00C),
+    ],
+)
+def test_a_malformed_packet_is_ignored_rather_than_fatal(packet):
+    """Anyone on the network can send one, and the proxy must survive it."""
+    assert mdns._parse_response(packet, NAME) == []
+
+
+# ---------------------------------------------------------------------------
+# The query as a whole
+# ---------------------------------------------------------------------------
+
+
+def test_nothing_answering_is_an_answer(monkeypatch):
+    class SilentSocket:
+        def setsockopt(self, *a):
+            pass
+
+        def settimeout(self, *a):
+            pass
+
+        def bind(self, *a):
+            pass
+
+        def sendto(self, *a):
+            pass
+
+        def recvfrom(self, *a):
+            raise socket.timeout()
+
+        def close(self):
+            pass
+
+    monkeypatch.setattr(mdns.socket, "socket", lambda *a, **k: SilentSocket())
+    assert mdns.resolve(NAME, timeout=0.05) == []
+
+
+def test_a_network_that_refuses_multicast_is_not_fatal(monkeypatch):
+    """No route, or a firewall in the way: that means "not resolved here",
+    which is a thing the caller reports rather than a crash."""
+
+    def no_multicast(*a, **k):
+        raise OSError("Network is unreachable")
+
+    monkeypatch.setattr(mdns.socket, "socket", no_multicast)
+    assert mdns.resolve(NAME, timeout=0.05) == []
+
+
+# ---------------------------------------------------------------------------
+# The resolver the proxy hands to aiohttp
+# ---------------------------------------------------------------------------
+
+
+def _resolve(host, family=socket.AF_INET, default=None):
+    """Run the proxy's resolver for ``host``, with ``default`` standing in for
+    the machine's own resolver."""
+    import asyncio
+    from unittest.mock import AsyncMock, patch
+
+    from arcsecond.imagesources.sources.network import _mdns_aware_resolver
+
+    if default is None:
+        machine = AsyncMock(side_effect=socket.gaierror(-2, "not known"))
+    else:
+        machine = AsyncMock(return_value=default)
+
+    async def main():
+        resolver = _mdns_aware_resolver()
+        with patch.object(
+            resolver, "_default", AsyncMock(resolve=machine, close=AsyncMock())
+        ):
+            try:
+                return await resolver.resolve(host, 80, family)
+            finally:
+                await resolver.close()
+
+    return asyncio.run(main())
+
+
+def test_the_machine_resolver_is_asked_first():
+    """It is the answer almost every time, and mDNS is only for what is left."""
+    answer = [{"hostname": "cam.example.com", "host": "10.0.0.5", "port": 80}]
+    assert _resolve("cam.example.com", default=answer) == answer
+
+
+def test_a_local_name_falls_back_to_the_network(monkeypatch):
+    monkeypatch.setattr(mdns, "resolve", lambda host, *a, **k: ["192.168.1.42"])
+
+    (result,) = _resolve(NAME)
+    assert result["host"] == "192.168.1.42"
+    assert result["hostname"] == NAME
+    assert result["port"] == 80
+    assert result["family"] == socket.AF_INET
+
+
+def test_every_address_is_offered_to_aiohttp(monkeypatch):
+    """aiohttp tries them in turn, which is what makes a multi-homed
+    responder work rather than work half the time."""
+    monkeypatch.setattr(
+        mdns, "resolve", lambda host, *a, **k: ["192.168.64.1", "192.168.1.97"]
+    )
+    assert [r["host"] for r in _resolve(NAME)] == ["192.168.64.1", "192.168.1.97"]
+
+
+def test_a_name_nothing_answers_for_still_fails(monkeypatch):
+    """The connection error the operator gets must stay the real one."""
+    monkeypatch.setattr(mdns, "resolve", lambda host, *a, **k: [])
+
+    with pytest.raises(socket.gaierror):
+        _resolve(NAME)
+
+
+def test_an_ipv6_lookup_is_not_answered_with_an_ipv4_address(monkeypatch):
+    """Only A records are asked for, so this is not ours to answer."""
+    monkeypatch.setattr(mdns, "resolve", lambda host, *a, **k: ["192.168.1.42"])
+
+    with pytest.raises(socket.gaierror):
+        _resolve(NAME, family=socket.AF_INET6)

{arcsecond-3.18.2 → arcsecond-3.19.0}/uv.lock

@@ -155,7 +155,7 @@ wheels = [
 
 [[package]]
 name = "arcsecond"
-version = "3.18.2"
+version = "3.19.0"
 source = { editable = "." }
 dependencies = [
     { name = "alpyca" },