mreg-cli 1.0.0__py3-none-any.whl

mreg_cli/api/fields.py

@@ -0,0 +1,104 @@
+"""Fields for models of the API."""
+
+from __future__ import annotations
+
+import ipaddress
+import re
+from typing import Annotated, Any
+
+from pydantic import BeforeValidator, field_validator
+
+from mreg_cli.api.abstracts import FrozenModel
+from mreg_cli.exceptions import InputFailure
+from mreg_cli.types import IP_AddressT
+
+_mac_regex = re.compile(r"^([0-9A-Fa-f]{2}[.:-]){5}([0-9A-Fa-f]{2})$")
+
+
+class MACAddressField(FrozenModel):
+    """Represents a MAC address."""
+
+    address: str
+
+    @field_validator("address", mode="after")
+    @classmethod
+    def validate_and_format_mac(cls, v: str) -> str:
+        """Validate and normalize MAC address to 'aa:bb:cc:dd:ee:ff' format.
+
+        :param v: The input MAC address string.
+        :raises ValueError: If the input does not match the expected MAC address pattern.
+        :returns: The normalized MAC address.
+        """
+        # Validate input format
+        if not _mac_regex.match(v):
+            raise ValueError("Invalid MAC address format")
+
+        # Normalize MAC address
+        v = re.sub(r"[.:-]", "", v).lower()
+        return ":".join(v[i : i + 2] for i in range(0, 12, 2))
+
+    def __str__(self) -> str:
+        """Return the MAC address as a string."""
+        return self.address
+
+
+class IPAddressField(FrozenModel):
+    """Represents an IP address, automatically determines if it's IPv4 or IPv6."""
+
+    address: IP_AddressT
+
+    @classmethod
+    def from_string(cls, address: str) -> IPAddressField:
+        """Create an IPAddressField from a string.
+
+        Shortcut for creating an IPAddressField from a string,
+        without having to convince the type checker that we can
+        pass in a string to the address field each time.
+        """
+        return cls(address=address)  # pyright: ignore[reportArgumentType] # validator handles this
+
+    @field_validator("address", mode="before")
+    @classmethod
+    def parse_ip_address(cls, value: Any) -> IP_AddressT:
+        """Parse and validate the IP address."""
+        try:
+            return ipaddress.ip_address(value)
+        except ValueError as e:
+            raise InputFailure(f"Invalid IP address '{value}'.") from e
+
+    def is_ipv4(self) -> bool:
+        """Check if the IP address is IPv4."""
+        return isinstance(self.address, ipaddress.IPv4Address)
+
+    def is_ipv6(self) -> bool:
+        """Check if the IP address is IPv6."""
+        return isinstance(self.address, ipaddress.IPv6Address)
+
+    @staticmethod
+    def is_valid(value: str) -> bool:
+        """Check if the value is a valid IP address."""
+        try:
+            ipaddress.ip_address(value)
+            return True
+        except ValueError:
+            return False
+
+    def __str__(self) -> str:
+        """Return the IP address as a string."""
+        return str(self.address)
+
+    def __hash__(self):
+        """Return a hash of the IP address."""
+        return hash(self.address)
+
+
+def _extract_name(value: dict[str, Any]) -> str:
+    """Extract the name from the dictionary.
+
+    :param v: Dictionary containing the name.
+    :returns: Extracted name as a string.
+    """
+    return value["name"]
+
+
+NameList = list[Annotated[str, BeforeValidator(_extract_name)]]

mreg_cli/api/history.py

@@ -0,0 +1,152 @@
+"""History abstractions for mreg-cli."""
+
+from __future__ import annotations
+
+import datetime
+import json
+from enum import Enum
+from typing import Any, Self
+
+from pydantic import BaseModel, Field, field_validator
+
+from mreg_cli.api.endpoints import Endpoint
+from mreg_cli.exceptions import EntityNotFound, InternalError
+from mreg_cli.outputmanager import OutputManager
+from mreg_cli.types import QueryParams
+from mreg_cli.utilities.api import get_typed
+
+
+class HistoryResource(str, Enum):
+    """History resources for the API.
+
+    Names represent resource names.
+    Values represent resource relations.
+
+    Access resource names and relation with the `resource()` and `relation()` methods.
+    """
+
+    Host = "hosts"
+    Group = "groups"
+    HostPolicy_Role = "roles"
+    HostPolicy_Atom = "atoms"
+
+    @classmethod
+    def _missing_(cls, value: Any) -> HistoryResource:
+        v = str(value).lower()
+        for resource in cls:
+            if resource.value == v:
+                return resource
+            elif resource.name.lower() == v:
+                return resource
+        raise ValueError(f"Unknown resource {value}")
+
+    def relation(self) -> str:
+        """Get the resource relation."""
+        return self.value
+
+    def resource(self) -> str:
+        """Get the resource name."""
+        return self.name.lower()
+
+
+class HistoryItem(BaseModel):
+    """Represents a history item."""
+
+    id: int  # noqa: A003
+    timestamp: datetime.datetime
+    user: str
+    resource: HistoryResource
+    name: str
+    mid: int = Field(alias="model_id")  # model_ is an internal pydantic namespace.
+    model: str
+    action: str
+    data: dict[str, Any]
+
+    @field_validator("data", mode="before")
+    def parse_json_data(cls, v: Any) -> Any:
+        """Ensure that non-dict values are treated as JSON."""
+        if isinstance(v, dict):
+            return v  # pyright: ignore[reportUnknownVariableType]
+        try:
+            return json.loads(v)
+        except json.JSONDecodeError as e:
+            raise ValueError("Failed to parse history data as JSON") from e
+
+    def clean_timestamp(self) -> str:
+        """Clean up the timestamp for output."""
+        return self.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+    def msg(self, basename: str) -> str:
+        """Attempt to make a history item human readable."""
+        msg = ""
+        action = self.action
+        model = self.model
+        if action in ("add", "remove"):
+            if action == "add":
+                direction = "to"
+            elif action == "remove":
+                direction = "from"
+            else:
+                raise InternalError(f"Unhandled history entry: {action}")
+            rel = self.data["relation"][:-1]
+            cls = str(self.resource)
+            if "." in cls:
+                cls = cls[cls.rindex(".") + 1 :]
+            cls = cls.replace("HostPolicy_", "")
+            cls = cls.lower()
+            msg = f"{rel} {self.data['name']} {direction} {cls} {self.name}"
+        elif action == "create":
+            msg = ", ".join(f"{k} = '{v}'" for k, v in self.data.items())
+        elif action == "update":
+            if model in ("Ipaddress",):
+                msg = self.data["current_data"]["ipaddress"] + ", "
+            changes: list[str] = []
+            for key, newval in self.data["update"].items():
+                oldval = self.data["current_data"][key] or "not set"
+                newval = newval or "not set"
+                changes.append(f"{key}: {oldval} -> {newval}")
+            msg += ",".join(changes)
+        elif action == "destroy":
+            if model == "Host":
+                msg = "deleted " + self.name
+            else:
+                msg = ", ".join(f"{k} = '{v}'" for k, v in self.data.items())
+        else:
+            raise InternalError(f"Unhandled history entry: {action}")
+
+        return msg
+
+    def output(self, basename: str) -> None:
+        """Output the history item."""
+        ts = self.clean_timestamp()
+        msg = self.msg(basename)
+        OutputManager().add_line(f"{ts} [{self.user}]: {self.model} {self.action}: {msg}")
+
+    @classmethod
+    def output_multiple(cls, basename: str, items: list[HistoryItem]) -> None:
+        """Output multiple history items."""
+        for item in sorted(items, key=lambda i: i.timestamp):
+            item.output(basename)
+
+    @classmethod
+    def get(cls, name: str, resource: HistoryResource) -> list[Self]:
+        """Get history items for a resource."""
+        params: QueryParams = {"resource": resource.resource(), "name": name}
+        ret = get_typed(Endpoint.History, list[cls], params=params)
+        if len(ret) == 0:
+            raise EntityNotFound(f"No history found for {name}")
+
+        model_ids = ",".join({str(i.mid) for i in ret})
+        params = {
+            "resource": resource.resource(),
+            "model_id__in": model_ids,
+        }
+        ret = get_typed(Endpoint.History, list[cls], params=params)
+
+        params = {
+            "data__relation": resource.relation(),
+            "data__id__in": model_ids,
+        }
+        ret.extend(get_typed(Endpoint.History, list[cls], params=params))
+
+        return ret