Fix ipv6 host lookup raising ValidationError when not found

Author: pederhan

mreg_cli/api/fields.py

@@ -41,6 +41,29 @@ def validate_naive(cls, value: str | MacAddress | Self) -> Self:
         except ValidationError as e:
             raise ValueError(f"Invalid MAC address '{value}'") from e
 
+    @classmethod
+    def parse(cls, obj: Any) -> MacAddress:
+        """Parse a MAC address from a string. Returns the MAC address as a string.
+
+        :param obj: The object to parse.
+        :returns: The MAC address as a string.
+        :raises ValueError: If the object is not a valid MAC address.
+        """
+        # Match interface of NetworkOrIP.parse
+        return cls.validate(obj).address
+
+    @classmethod
+    def parse_optional(cls, obj: Any) -> MacAddress | None:
+        """Parse a MAC address from a string. Returns None if the MAC address is invalid.
+
+        :param obj: The object to parse.
+        :returns: The MAC address as a string or None if it is invalid.
+        """
+        try:
+            return cls.parse(obj)
+        except ValueError:
+            return None
+
     def __str__(self) -> str:
         """Return the MAC address as a string."""
         return str(self.address)

mreg_cli/api/models.py

@@ -10,6 +10,7 @@
 from typing import Any, Callable, ClassVar, Iterable, List, Literal, Self, cast, overload
 
 from pydantic import AliasChoices, BaseModel, ConfigDict, Field, computed_field, field_validator
+from pydantic_extra_types.mac_address import MacAddress
 from typing_extensions import Unpack
 
 from mreg_cli.api.abstracts import APIMixin, FrozenModel, FrozenModelWithTimestamps
@@ -100,7 +101,11 @@ def parse(cls, value: Any, mode: Literal["network"]) -> IP_NetworkT: ...
 
     @overload
     @classmethod
-    def parse(cls, value: Any, mode: IPNetMode) -> IP_AddressT | IP_NetworkT: ...
+    def parse(cls, value: Any, mode: Literal["networkv4"]) -> ipaddress.IPv4Network: ...
+
+    @overload
+    @classmethod
+    def parse(cls, value: Any, mode: Literal["networkv6"]) -> ipaddress.IPv6Network: ...
 
     @classmethod
     def parse(cls, value: Any, mode: IPNetMode | None = None) -> IP_AddressT | IP_NetworkT:
@@ -126,6 +131,38 @@ def parse(cls, value: Any, mode: IPNetMode | None = None) -> IP_AddressT | IP_Ne
             return func(ipnet)
         return ipnet.ip_or_network
 
+    @classmethod
+    def parse_ip_optional(
+        cls, ip: str, version: Literal[4, 6] | None = None
+    ) -> IP_AddressT | None:
+        """Check if a value is a valid IP address.
+
+        :param ip: The IP address to parse.
+        :param version: The IP version to parse as. Parses as any version if None.
+        :returns: The parsed IP address or None if parsing fails.
+        """
+        mode = "ipv4" if version == 4 else "ipv6" if version == 6 else "ip"
+        try:
+            return cls.parse(ip, mode=mode)
+        except ValueError:
+            return None
+
+    @classmethod
+    def parse_network_optional(
+        cls, ip: str, version: Literal[4, 6] | None = None
+    ) -> IP_NetworkT | None:
+        """Parse a value as an IP network. Returns None if parsing fails.
+
+        :param ip: The IP network to parse.
+        :param version: The IP version to parse as. Parses as any version if None.
+        :returns: The parsed IP network or None if parsing fails.
+        """
+        mode = "networkv4" if version == 4 else "networkv6" if version == 6 else "network"
+        try:
+            return cls.parse(ip, mode=mode)
+        except ValueError:
+            return None
+
     @field_validator("ip_or_network", mode="before")
     @classmethod
     def validate_ip_or_network(cls, value: Any) -> IP_AddressT | IP_NetworkT:
@@ -2610,6 +2647,58 @@ def endpoint(cls) -> Endpoint:
         """Return the endpoint for the class."""
         return Endpoint.Hosts
 
+    @classmethod
+    def get_by_ip(cls, ip: IP_AddressT, inform_as_ptr: bool = True) -> Host | None:
+        """Get a host by IP address.
+
+        :param ip: The IP address to search for.
+        :param check_ptr: If True, check for PTR overrides as well.
+        :returns: The Host object if found, None otherwise.
+        """
+        try:
+            host = cls.get_by_field("ipaddresses__ipaddress", str(ip))
+            if not host:
+                host = cls.get_by_field("ptr_overrides__ipaddress", str(ip))
+                if host and inform_as_ptr:
+                    OutputManager().add_line(f"{ip} is a PTR override for {host.name}")
+            return host
+        except MultipleEntitiesFound as e:
+            raise MultipleEntitiesFound(f"Multiple hosts found with IP address {ip}.") from e
+
+    @classmethod
+    def get_by_ip_or_raise(cls, ip: IP_AddressT, inform_as_ptr: bool = True) -> Host:
+        """Get a host by IP address or raise EntityNotFound.
+
+        :param ip: The IP address to search for.
+        :returns: The Host object if found.
+        :param check_ptr: If True, check for PTR overrides as well.
+        """
+        host = cls.get_by_ip(ip, inform_as_ptr=inform_as_ptr)
+        if not host:
+            raise EntityNotFound(f"Host with IP address {ip} not found.")
+        return host
+
+    @classmethod
+    def get_by_mac(cls, mac: MacAddress) -> Host | None:
+        """Get a host by MAC address.
+
+        :param ip: The MAC address to search for.
+        :returns: The Host object if found, None otherwise.
+        """
+        return cls.get_by_field("ipaddresses__macaddress", str(mac))
+
+    @classmethod
+    def get_by_mac_or_raise(cls, mac: MacAddress) -> Host:
+        """Get a host by MAC address or raise EntityNotFound.
+
+        :param ip: The MAC address to search for.
+        :returns: The Host object if found.
+        """
+        host = cls.get_by_mac(mac)
+        if not host:
+            raise EntityNotFound(f"Host with MAC address {mac} not found.")
+        return host
+
     @classmethod
     def get_by_any_means_or_raise(
         cls, identifier: str | HostT, inform_as_cname: bool = True, inform_as_ptr: bool = True
@@ -2670,56 +2759,31 @@ def get_by_any_means(
 
         :returns: A Host object if the host was found, otherwise None.
         """
-        host = None
         if not isinstance(identifier, HostT):
             if identifier.isdigit():
                 return Host.get_by_id(int(identifier))
 
-            try:
-                ptr = False
-                ipaddress.ip_address(identifier)
-                NetworkOrIP.parse(identifier, mode="ip")
-
-                host = Host.get_by_field("ipaddresses__ipaddress", identifier)
-                if not host:
-                    host = Host.get_by_field("ptr_overrides__ipaddress", identifier)
-                    ptr = True
-
-                if host:
-                    if ptr and inform_as_ptr:
-                        OutputManager().add_line(f"{identifier} is a PTR override for {host.name}")
-                    return host
-            except MultipleEntitiesFound as e:
-                raise MultipleEntitiesFound(
-                    f"Multiple hosts found with IP address or PTR {identifier}."
-                ) from e
-            except ValueError:  # invalid IP
-                pass
+            if ip := NetworkOrIP.parse_ip_optional(identifier):
+                host = cls.get_by_ip_or_raise(ip, inform_as_ptr=inform_as_ptr)
+                return host
 
-            try:
-                mac = MACAddressField.validate_naive(identifier)
-                return Host.get_by_field("ipaddresses__macaddress", mac.address)
-            except ValueError:
-                pass
+            if mac := MACAddressField.parse_optional(identifier):
+                return cls.get_by_mac_or_raise(mac)
 
             # Let us try to find the host by name...
-            name = HostT(hostname=identifier)
-        else:
-            name = identifier
-
-        host = Host.get_by_field("name", name.hostname)
+            identifier = HostT(hostname=identifier)
 
-        if host:
+        if host := cls.get_by_field("name", identifier.hostname):
             return host
 
-        cname = CNAME.get_by_field("name", name.hostname)
+        cname = CNAME.get_by_field("name", identifier.hostname)
         # If we found a CNAME, get the host it points to. We're not interested in the
         # CNAME itself.
         if cname is not None:
             host = Host.get_by_id(cname.host)
 
             if host and inform_as_cname:
-                OutputManager().add_line(f"{name} is a CNAME for {host.name}")
+                OutputManager().add_line(f"{identifier.hostname} is a CNAME for {host.name}")
 
         return host