Split functions again

Author: TuxPowered42

serveradmin/serverdb/models.py

@@ -102,19 +102,22 @@ def is_unique_ip(
     ip_interface: Union[IPv4Interface, IPv6Interface],
     server: "Server",
     addr_types: list[str],
-    is_net: bool,
     attribute_id: Optional[int] = None,
 ) -> None:
-    """Validate if IPv4/IPv6 interface is unique
+    """Validate if given IP address is unique
 
     Raises a ValidationError if intern_ip or any other attribute of type inet
     with this ip_address already exists.
 
-    :param ip_interface:
-    :param server:
-    :param addr_types:
-    :param is_net:
-    :param attribute_id:
+    :param ip_interface:    The IP address to validate
+    :param server:          The current Server object to which the new IP address is
+                            to be assigned
+    :param addr_types:      Verify only against Servers of given IP_ADDR_TYPES.
+                            Allows for conflicting IP addresses, as long as they are on
+                            Servers with different IP_ADDR_TYPES.
+    :param attribute_id:    Verify only against this attribute. Allows for having
+                            conflicting IP addresses on different attributes, as long
+                            as they are on different Server objects.
     :return:
     """
 
@@ -127,40 +130,88 @@ def is_unique_ip(
     # the same IP address as long as it is in different attributes.
 
     duplicates = []
-    object_id = server.server_id
 
-    if is_net:
-        servertype_inet_attr_q = Q(server__servertype=server.servertype_id)
-        servertype_intern_ip_q = Q(servertype=server.servertype_id)
-        inet_attr_q = Q(value__net_overlaps=ip_interface)
-        intern_ip_q = Q(intern_ip__net_overlaps=ip_interface)
+    # TODO: Make attribute_id mandatory when intern_ip is gone.
+    if attribute_id:
+        object_attribute_q = Q(server_id=server.server_id) | ~Q(
+            attribute_id=attribute_id
+        )
     else:
-        servertype_inet_attr_q = Q()
-        servertype_intern_ip_q = Q()
-        inet_attr_q = Q(value=ip_interface)
-        intern_ip_q = Q(intern_ip=ip_interface)
+        object_attribute_q = Q(server_id=server.server_id)
+
+    # TODO: Remove intern_ip.
+    for d in Server.objects.filter(
+        Q(
+            Q(intern_ip=ip_interface)  # IP address
+            & Q(servertype__ip_addr_type__in=addr_types)  # IP address type
+            & ~Q(server_id=server.server_id)  # Self-server
+        )
+    ):
+        duplicates.append(f"{d.hostname} (intern_ip)")
+
+    for d in ServerInetAttribute.objects.filter(
+        Q(
+            Q(value=ip_interface)  # IP address
+            & Q(server__servertype__ip_addr_type__in=addr_types)  # IP address type
+            & ~object_attribute_q  # Self-server
+        )
+    ):
+        duplicates.append(f"{d.server.hostname} ({d.attribute})")
+
+    if duplicates:
+        raise ValidationError(
+            f"Can't set IP address {ip_interface} on {server.hostname}, conflicts with: {', '.join(duplicates)}"
+        )
+
+
+def network_overlaps(
+    ip_interface: Union[IPv4Interface, IPv6Interface],
+    server: "Server",
+    addr_types: list[str],
+    attribute_id: Optional[int] = None,
+) -> None:
+    """Validate if given IP prefix is unique
+
+    Raises a ValidationError if the IP prefix overlaps with any other existing
+    objects network of the given servertype.
+
+    :param ip_interface: The IP address to validate
+    :param server:          The current Server object to which the new IP prefix is
+                            to be assigned
+    :param addr_types:      Verify only against Servers of given IP_ADDR_TYPES.
+                            Allows for overlapping IP prefixes, as long as they are on
+                            Servers with different IP_ADDR_TYPES.
+    :param attribute_id:    Verify only against this attribute. Allows for having
+                            overlapping IP prefixes on different attributes, as long
+                            as they are on different Server objects.
+    :return:
+    """
+
+    duplicates = []
 
     # TODO: Make attribute_id mandatory when intern_ip is gone.
     if attribute_id:
-        object_attribute_q = Q(server_id=object_id) | ~Q(attribute_id=attribute_id)
+        object_attribute_q = Q(server_id=server.server_id) | ~Q(
+            attribute_id=attribute_id
+        )
     else:
-        object_attribute_q = Q(server_id=object_id)
+        object_attribute_q = Q(server_id=server.server_id)
 
     # TODO: Remove intern_ip.
     for d in Server.objects.filter(
         Q(
-            servertype_intern_ip_q  # Servertype
-            & intern_ip_q  # IP address
+            Q(servertype=server.servertype_id)  # Servertype
+            & Q(intern_ip__net_overlaps=ip_interface)  # IP address
             & Q(servertype__ip_addr_type__in=addr_types)  # IP address type
-            & ~Q(server_id=object_id)  # Self-server
+            & ~Q(server_id=server.server_id)  # Self-server
         )
     ):
         duplicates.append(f"{d.hostname} (intern_ip)")
 
     for d in ServerInetAttribute.objects.filter(
         Q(
-            servertype_inet_attr_q  # Servertype
-            & inet_attr_q  # IP address
+            Q(server__servertype=server.servertype_id)  # Servertype
+            & Q(value__net_overlaps=ip_interface)  # IP address
             & Q(server__servertype__ip_addr_type__in=addr_types)  # IP address type
             & ~object_attribute_q  # Self-server
         )
@@ -495,10 +546,10 @@ def clean(self):
 
             if ip_addr_type == "host":
                 is_ip_address(self.intern_ip)
-                is_unique_ip(self.intern_ip, self, ["host"], False)
+                is_unique_ip(self.intern_ip, self, ["host"])
             elif ip_addr_type == "network":
                 is_network(self.intern_ip)
-                is_unique_ip(self.intern_ip, self, ["network"], True)
+                network_overlaps(self.intern_ip, self, ["network"])
             elif ip_addr_type == "loadbalancer":
                 is_ip_address(self.intern_ip)
 
@@ -726,10 +777,10 @@ def clean(self):
             )
         elif ip_addr_type == "host":
             is_ip_address(self.value)
-            is_unique_ip(self.value, self.server, ["host"], False, self.attribute_id)
+            is_unique_ip(self.value, self.server, ["host"], self.attribute_id)
         elif ip_addr_type == "network":
             is_network(self.value)
-            is_unique_ip(self.value, self.server, ["network"], True, self.attribute_id)
+            network_overlaps(self.value, self.server, ["network"], self.attribute_id)
         elif ip_addr_type == "loadbalancer":
             is_ip_address(self.value)