GitHub

AddressResolverService

API reference for AddressResolverService.

Resolves endpoints to socket addresses (a non-empty tuple).

Functions

__init__

__init__(_dns, _scope_id=None) -> None
ParameterTypeDescription
_dnsDnsService
_scope_idScopeIdLookup | None = None

resolve

resolve(target: InetAddress | HostPortInput, *, family: Literal['IPv4']) -> Effect[tuple[InetAddressV4, ...], ResolveError]
resolve(target: InetAddress | HostPortInput, *, family: Literal['IPv6']) -> Effect[tuple[InetAddressV6, ...], ResolveError]
resolve(target: InetAddress | HostPortInput, *, family: IpFamily | None = None) -> Effect[tuple[InetAddress, ...], ResolveError]
resolve(target: SocketAddress | HostPortInput, *, family: IpFamily | None = None) -> Effect[tuple[SocketAddress, ...], ResolveError]

The socket addresses to connect to for target, in the order found: an IP literal (a scoped IPv6 one with its zone looked up) directly, a domain name through Dns (link-local IPv6 results dropped, their scope unknown), a socket address as it is. With family, a name is looked up in that family only. Fails with NetAddressError for a malformed target, a literal or inet address of another family, or only link-local results, and with DnsError when the lookup does.

ParameterTypeDescription
target
family= None
@overload
def resolve(
    self, target: InetAddress | HostPortInput, *, family: Literal["IPv4"]
) -> Effect[tuple[InetAddressV4, ...], ResolveError]: ...
@overload
def resolve(
    self, target: InetAddress | HostPortInput, *, family: Literal["IPv6"]
) -> Effect[tuple[InetAddressV6, ...], ResolveError]: ...
@overload
def resolve(
    self, target: InetAddress | HostPortInput, *, family: IpFamily | None = None
) -> Effect[tuple[InetAddress, ...], ResolveError]: ...
@overload
def resolve(
    self, target: SocketAddress | HostPortInput, *, family: IpFamily | None = None
) -> Effect[tuple[SocketAddress, ...], ResolveError]: ...
def resolve(
    self, target: SocketAddress | HostPortInput, *, family: IpFamily | None = None
) -> Effect[tuple[SocketAddress, ...], ResolveError]:
    """The socket addresses to connect to for ``target``, in the order
    found: an IP literal (a scoped IPv6 one with its zone looked up)
    directly, a domain name through ``Dns`` (link-local IPv6 results
    dropped, their scope unknown), a socket address as it is. With
    ``family``, a name is looked up in that family only. Fails with
    ``NetAddressError`` for a malformed target, a literal or inet
    address of another family, or only link-local results, and with
    ``DnsError`` when the lookup does."""
    if isinstance(target, UnixPathAddress):
        return succeed((target,))
    if isinstance(target, (InetAddressV4, InetAddressV6)):
        return _widen(_in_family(target, family))
    if not isinstance(target, HostPort):
        return from_result(host_port_from_input(target)).flat_map(
            lambda endpoint: self.resolve(endpoint, family=family)
        )
    host, port = target.host, target.port
    if isinstance(host, (IPv4Address, IPv6Address)) or "%" in host:
        return _widen(self._from_literal(host, port).flat_map(lambda a: _in_family(a, family)))

    def addresses(
        found: tuple[IPv4Address | IPv6Address, ...],
    ) -> Effect[tuple[SocketAddress, ...], ResolveError]:
        # Lookups do not report the scope that a link-local IPv6 address needs.
        usable = tuple(
            inet_address_unsafe(a, port)
            for a in found
            if not (isinstance(a, IPv6Address) and is_link_local(a))
        )
        if usable:
            return succeed(usable)
        return fail(
            NetAddressError(
                "only link-local IPv6 addresses were found, "
                "and lookups do not report their scope",
                host,
            )
        )

    return self._dns.lookup(host, family=family).flat_map(addresses)