racklint 0.1.0__py3-none-any.whl

racklint/__init__.py

@@ -0,0 +1,66 @@
+# racklint/src/racklint/__init__.py
+"""racklint: check servers against NetBox before they go into service.
+
+The names in __all__ are the public API. Anything else may change before 1.0.
+"""
+
+from racklint.baseline import FirmwareBaseline, FirmwareRule
+from racklint.checks import Check, FirmwareCheck, GpuCheck, MemoryCheck, NicCheck, SerialCheck, default_checks
+from racklint.engine import ActualReader, check_nodes, iter_results
+from racklint.errors import BaselineError, InventoryError, NetBoxError, RacklintError
+from racklint.models import (
+    ActualNode,
+    Dimm,
+    ExpectedNode,
+    Finding,
+    FirmwareItem,
+    Gpu,
+    GpuSpec,
+    HardwareSpec,
+    MemorySpec,
+    NetworkPort,
+    NodeResult,
+    PlannedInterface,
+    Report,
+    Status,
+)
+from racklint.netbox import NetBoxSource, netbox_client
+from racklint.redfish import BmcAccess, RedfishError, RedfishReader
+
+__all__ = [
+    "ActualNode",
+    "ActualReader",
+    "BaselineError",
+    "BmcAccess",
+    "Check",
+    "Dimm",
+    "ExpectedNode",
+    "Finding",
+    "FirmwareBaseline",
+    "FirmwareCheck",
+    "FirmwareItem",
+    "FirmwareRule",
+    "Gpu",
+    "GpuCheck",
+    "GpuSpec",
+    "HardwareSpec",
+    "InventoryError",
+    "MemoryCheck",
+    "MemorySpec",
+    "NetBoxError",
+    "NetBoxSource",
+    "NetworkPort",
+    "NicCheck",
+    "NodeResult",
+    "PlannedInterface",
+    "RacklintError",
+    "RedfishError",
+    "RedfishReader",
+    "Report",
+    "SerialCheck",
+    "Status",
+    "check_nodes",
+    "default_checks",
+    "iter_results",
+    "netbox_client",
+]

racklint/baseline.py

@@ -0,0 +1,29 @@
+# racklint/src/racklint/baseline.py
+"""The firmware baseline: the approved versions for each device type, kept in a YAML file under review."""
+
+from pathlib import Path
+from typing import Self
+
+import yaml
+from pydantic import Field, ValidationError
+
+from racklint.errors import BaselineError
+from racklint.models import FrozenModel
+
+
+class FirmwareRule(FrozenModel):
+    """Firmware items whose Id matches `match`, an fnmatch glob, must run one of the `approved` versions."""
+
+    match: str
+    approved: tuple[str, ...] = Field(min_length=1)
+
+
+class FirmwareBaseline(FrozenModel):
+    device_types: dict[str, tuple[FirmwareRule, ...]]
+
+    @classmethod
+    def load(cls, path: Path) -> Self:
+        try:
+            return cls.model_validate(yaml.safe_load(path.read_text()))
+        except (OSError, yaml.YAMLError, ValidationError) as error:
+            raise BaselineError(f"cannot load firmware baseline {path}: {error}") from error

racklint/checks.py

@@ -0,0 +1,116 @@
+# racklint/src/racklint/checks.py
+"""The checks: each compares one aspect of a node's plan with what its BMC reports.
+
+A check is pure. It returns one message per problem it finds, and no messages when the node is as planned.
+"""
+
+from fnmatch import fnmatchcase
+from typing import Protocol
+
+from racklint.baseline import FirmwareBaseline
+from racklint.models import ActualNode, ExpectedNode
+
+SPEC = "config context 'racklint'"
+
+
+def not_planned(item: str) -> str:
+    return f"not planned in NetBox: {item}"
+
+
+class Check(Protocol):
+    name: str
+
+    def run(self, expected: ExpectedNode, actual: ActualNode) -> list[str]: ...
+
+
+class SerialCheck:
+    name = "serial"
+
+    def run(self, expected: ExpectedNode, actual: ActualNode) -> list[str]:
+        if expected.serial is None:
+            return [not_planned("serial")]
+        if expected.serial in actual.serials:
+            return []
+        reported = ", ".join(actual.serials) or "none"
+        return [f"expected {expected.serial}, BMC reports {reported}"]
+
+
+class GpuCheck:
+    name = "gpu"
+
+    def run(self, expected: ExpectedNode, actual: ActualNode) -> list[str]:
+        if expected.spec is None:
+            return [not_planned(SPEC)]
+        planned = expected.spec.gpu
+        problems: list[str] = []
+        if len(actual.gpus) != planned.count:
+            problems.append(f"{len(actual.gpus)} found, {planned.count} planned")
+        problems += [
+            f"{gpu.id} is {gpu.model!r}, planned {planned.model!r}"
+            for gpu in actual.gpus
+            if gpu.model != planned.model
+        ]
+        return problems
+
+
+class MemoryCheck:
+    name = "memory"
+
+    def run(self, expected: ExpectedNode, actual: ActualNode) -> list[str]:
+        if expected.spec is None:
+            return [not_planned(SPEC)]
+        planned = expected.spec.memory
+        count = len(actual.dimms)
+        total_mib = sum(dimm.capacity_mib for dimm in actual.dimms)
+        if count == planned.dimm_count and total_mib == planned.total_gib * 1024:
+            return []
+        found = f"{count} DIMMs ({total_mib / 1024:g} GiB)"
+        return [f"{found}, {planned.dimm_count} planned ({planned.total_gib} GiB)"]
+
+
+class NicCheck:
+    """Planned MACs must be reported; interfaces planned without a MAC are only counted."""
+
+    name = "nic"
+
+    def run(self, expected: ExpectedNode, actual: ActualNode) -> list[str]:
+        if not expected.interfaces:
+            return [not_planned("interfaces")]
+        reported = {port.mac for port in actual.ports if port.mac}
+        problems = [
+            f"{interface.name} ({interface.mac}) not found"
+            for interface in expected.interfaces
+            if interface.mac and interface.mac not in reported
+        ]
+        if len(actual.ports) < len(expected.interfaces):
+            problems.append(f"{len(actual.ports)} ports found, {len(expected.interfaces)} planned")
+        return problems
+
+
+class FirmwareCheck:
+    """Every baseline rule must match a firmware item, and every match must run an approved version."""
+
+    name = "firmware"
+
+    def __init__(self, baseline: FirmwareBaseline) -> None:
+        self._baseline = baseline
+
+    def run(self, expected: ExpectedNode, actual: ActualNode) -> list[str]:
+        rules = self._baseline.device_types.get(expected.device_type)
+        if rules is None:
+            return [f"no firmware baseline for device type {expected.device_type}"]
+        problems: list[str] = []
+        for rule in rules:
+            matched = [item for item in actual.firmware if fnmatchcase(item.id, rule.match)]
+            if not matched:
+                problems.append(f"no firmware item matches {rule.match!r}")
+            problems += [
+                f"{item.id} {item.version} not in approved [{', '.join(rule.approved)}]"
+                for item in matched
+                if item.version not in rule.approved
+            ]
+        return problems
+
+
+def default_checks(baseline: FirmwareBaseline) -> list[Check]:
+    return [SerialCheck(), GpuCheck(), MemoryCheck(), NicCheck(), FirmwareCheck(baseline)]

racklint/cli.py

@@ -0,0 +1,127 @@
+# racklint/src/racklint/cli.py
+"""The racklint command line. It wires NetBox, the BMC reader, the checks and a renderer together."""
+
+import asyncio
+import ssl
+from collections.abc import Sequence
+from enum import StrEnum
+from pathlib import Path
+from typing import Annotated, NoReturn
+
+import typer
+from pydantic import ValidationError
+from rich.console import Console
+
+from racklint.baseline import FirmwareBaseline
+from racklint.checks import default_checks
+from racklint.engine import check_nodes
+from racklint.errors import BaselineError, NetBoxError
+from racklint.models import Report
+from racklint.netbox import NetBoxSource, netbox_client
+from racklint.redfish import BmcAccess, RedfishReader
+from racklint.render import JsonRenderer, Renderer, TableRenderer
+from racklint.settings import Settings
+
+EXIT_NOT_PASSED = 1
+EXIT_USAGE = 2
+
+
+class OutputFormat(StrEnum):
+    TABLE = "table"
+    JSON = "json"
+
+
+RENDERERS: dict[OutputFormat, Renderer] = {
+    OutputFormat.TABLE: TableRenderer(),
+    OutputFormat.JSON: JsonRenderer(),
+}
+
+app = typer.Typer(add_completion=False, no_args_is_help=True)
+
+
+@app.callback()
+def main() -> None:
+    """Check servers against NetBox and a firmware baseline before they go into service."""
+
+
+@app.command()
+def check(
+    baseline: Annotated[Path, typer.Option(help="Firmware baseline YAML file.")],
+    rack: Annotated[str | None, typer.Option(help="Check every device in this NetBox rack.")] = None,
+    site: Annotated[
+        str | None, typer.Option(help="Site slug, if the rack name exists in several sites.")
+    ] = None,
+    device: Annotated[
+        list[str] | None, typer.Option(help="Check this NetBox device. Repeat for more.")
+    ] = None,
+    output_format: Annotated[
+        OutputFormat, typer.Option("--format", help="Output format.")
+    ] = OutputFormat.TABLE,
+    concurrency: Annotated[int | None, typer.Option(min=1, help="BMCs to read at once.")] = None,
+    ca_bundle: Annotated[
+        Path | None, typer.Option(exists=True, dir_okay=False, help="CA bundle for BMC TLS certificates.")
+    ] = None,
+    insecure: Annotated[bool, typer.Option("--insecure", help="Do not verify BMC TLS certificates.")] = False,
+) -> None:
+    """Check each node. Exit 1 if any node fails or cannot be read."""
+    if bool(rack) == bool(device):
+        _exit_usage("pass either --rack or --device")
+    try:
+        settings = load_settings(concurrency, ca_bundle, insecure)
+    except ValidationError as error:
+        _exit_usage(describe_settings_error(error))
+    try:
+        firmware_baseline = FirmwareBaseline.load(baseline)
+        report = asyncio.run(_check(settings, firmware_baseline, rack, site, device or []))
+    except (BaselineError, NetBoxError) as error:
+        _exit_usage(str(error))
+    RENDERERS[output_format].render(report, Console())
+    raise typer.Exit(0 if report.passed else EXIT_NOT_PASSED)
+
+
+def load_settings(concurrency: int | None, ca_bundle: Path | None, insecure: bool) -> Settings:
+    """Settings from the environment, overridden by the command-line options that were given."""
+    overrides: dict[str, object] = {}
+    if concurrency is not None:
+        overrides["concurrency"] = concurrency
+    if ca_bundle is not None:
+        overrides["bmc_ca_bundle"] = ca_bundle
+    if insecure:
+        overrides["bmc_verify_tls"] = False
+    return Settings().model_copy(update=overrides)
+
+
+def describe_settings_error(error: ValidationError) -> str:
+    problems = (
+        f"RACKLINT_{'_'.join(str(part) for part in problem['loc']).upper()}: {problem['msg']}"
+        for problem in error.errors()
+    )
+    return "invalid settings: " + "; ".join(problems)
+
+
+def bmc_access(settings: Settings) -> BmcAccess:
+    verify: ssl.SSLContext | bool = settings.bmc_verify_tls
+    if verify and settings.bmc_ca_bundle is not None:
+        verify = ssl.create_default_context(cafile=settings.bmc_ca_bundle)
+    return BmcAccess(
+        username=settings.bmc_username,
+        password=settings.bmc_password.get_secret_value(),
+        scheme=settings.bmc_scheme,
+        verify=verify,
+        max_requests=settings.bmc_concurrency,
+    )
+
+
+async def _check(
+    settings: Settings, baseline: FirmwareBaseline, rack: str | None, site: str | None, devices: Sequence[str]
+) -> Report:
+    async with netbox_client(str(settings.netbox_url), settings.netbox_token.get_secret_value()) as client:
+        source = NetBoxSource(client)
+        nodes = await source.rack(rack, site) if rack else await source.devices(devices)
+    reader = RedfishReader(bmc_access(settings))
+    return await check_nodes(nodes, reader, default_checks(baseline), settings.concurrency)
+
+
+def _exit_usage(message: str) -> NoReturn:
+    Console(stderr=True).print(f"racklint: {message}", markup=False, highlight=False)
+    raise typer.Exit(EXIT_USAGE)

racklint/engine.py

@@ -0,0 +1,60 @@
+# racklint/src/racklint/engine.py
+"""Check every node: read its BMC, run the checks on what it reports, and collect the results."""
+
+import asyncio
+from collections.abc import AsyncIterator, Coroutine, Sequence
+from typing import Any, Protocol
+
+from racklint.checks import Check, not_planned
+from racklint.errors import InventoryError
+from racklint.models import ActualNode, ExpectedNode, Finding, NodeResult, Report, Status
+
+
+class ActualReader(Protocol):
+    async def read(self, bmc_address: str) -> ActualNode:
+        """Return what the BMC reports, or raise InventoryError."""
+        ...
+
+
+async def check_nodes(
+    nodes: Sequence[ExpectedNode], reader: ActualReader, checks: Sequence[Check], concurrency: int
+) -> Report:
+    """Check the nodes with at most `concurrency` BMCs read at once. Results keep the order of `nodes`."""
+    results = await asyncio.gather(*_bounded(nodes, reader, checks, concurrency))
+    return Report(results=tuple(results))
+
+
+async def iter_results(
+    nodes: Sequence[ExpectedNode], reader: ActualReader, checks: Sequence[Check], concurrency: int
+) -> AsyncIterator[NodeResult]:
+    """Like check_nodes, but yield each node's result as soon as it is ready, for live progress."""
+    for finished in asyncio.as_completed(_bounded(nodes, reader, checks, concurrency)):
+        yield await finished
+
+
+def _bounded(
+    nodes: Sequence[ExpectedNode], reader: ActualReader, checks: Sequence[Check], concurrency: int
+) -> list[Coroutine[Any, Any, NodeResult]]:
+    """One check per node, sharing a limit of `concurrency` BMC reads at a time."""
+    slots = asyncio.Semaphore(concurrency)
+
+    async def check_in_slot(node: ExpectedNode) -> NodeResult:
+        async with slots:
+            return await check_node(node, reader, checks)
+
+    return [check_in_slot(node) for node in nodes]
+
+
+async def check_node(node: ExpectedNode, reader: ActualReader, checks: Sequence[Check]) -> NodeResult:
+    if node.bmc_address is None:
+        missing = Finding(check="bmc", message=not_planned("BMC address"))
+        return NodeResult(node=node.name, bmc_address=None, status=Status.FAIL, findings=(missing,))
+    try:
+        actual = await reader.read(node.bmc_address)
+    except InventoryError as error:
+        return NodeResult(node=node.name, bmc_address=node.bmc_address, status=Status.ERROR, error=str(error))
+    findings = tuple(
+        Finding(check=check.name, message=message) for check in checks for message in check.run(node, actual)
+    )
+    status = Status.FAIL if findings else Status.PASS
+    return NodeResult(node=node.name, bmc_address=node.bmc_address, status=status, findings=findings)

racklint/errors.py

@@ -0,0 +1,18 @@
+# racklint/src/racklint/errors.py
+"""The errors racklint raises. A caller can catch RacklintError to handle all of them."""
+
+
+class RacklintError(Exception):
+    """Base class of every error racklint raises on purpose."""
+
+
+class BaselineError(RacklintError):
+    """The firmware baseline is missing or invalid."""
+
+
+class NetBoxError(RacklintError):
+    """NetBox could not be read, or does not hold what was asked for."""
+
+
+class InventoryError(RacklintError):
+    """A node's actual state could not be read from its BMC."""

racklint/models.py

@@ -0,0 +1,131 @@
+# racklint/src/racklint/models.py
+"""The state racklint works on: what NetBox plans, what a BMC reports, and the verdict on each node."""
+
+import re
+from enum import StrEnum
+from typing import Annotated, Literal
+
+from pydantic import AfterValidator, BaseModel, ConfigDict
+
+_MAC_SEPARATORS = re.compile(r"[:.\-]")
+_MAC_DIGITS = re.compile(r"[0-9a-f]{12}")
+
+
+def normalise_mac(value: str) -> str:
+    """Return a MAC address as lower-case, colon-separated pairs, whichever separators it came with."""
+    digits = _MAC_SEPARATORS.sub("", value.lower())
+    if not _MAC_DIGITS.fullmatch(digits):
+        raise ValueError(f"not a MAC address: {value!r}")
+    return ":".join(digits[index : index + 2] for index in range(0, 12, 2))
+
+
+MacAddress = Annotated[str, AfterValidator(normalise_mac)]
+
+
+class FrozenModel(BaseModel):
+    """Immutable, with surrounding whitespace stripped from every string."""
+
+    model_config = ConfigDict(frozen=True, str_strip_whitespace=True)
+
+
+# What NetBox plans
+
+
+class GpuSpec(FrozenModel):
+    count: int
+    model: str
+
+
+class MemorySpec(FrozenModel):
+    dimm_count: int
+    total_gib: int
+
+
+class HardwareSpec(FrozenModel):
+    """The `racklint` key of a device's config context."""
+
+    gpu: GpuSpec
+    memory: MemorySpec
+
+
+class PlannedInterface(FrozenModel):
+    name: str
+    mac: MacAddress | None = None
+
+
+class ExpectedNode(FrozenModel):
+    """A device as NetBox plans it. None means NetBox does not record the value."""
+
+    name: str
+    device_type: str
+    serial: str | None = None
+    bmc_address: str | None = None
+    spec: HardwareSpec | None = None
+    interfaces: tuple[PlannedInterface, ...] = ()
+
+
+# What a BMC reports
+
+
+class Gpu(FrozenModel):
+    id: str
+    model: str
+
+
+class Dimm(FrozenModel):
+    id: str
+    capacity_mib: int
+
+
+class NetworkPort(FrozenModel):
+    id: str
+    mac: MacAddress | None = None
+
+
+class FirmwareItem(FrozenModel):
+    id: str
+    version: str
+
+
+class ActualNode(FrozenModel):
+    """A node as its BMC reports it."""
+
+    serials: tuple[str, ...] = ()
+    gpus: tuple[Gpu, ...] = ()
+    dimms: tuple[Dimm, ...] = ()
+    ports: tuple[NetworkPort, ...] = ()
+    firmware: tuple[FirmwareItem, ...] = ()
+
+
+# The verdict
+
+
+class Status(StrEnum):
+    PASS = "pass"
+    FAIL = "fail"
+    ERROR = "error"
+
+
+class Finding(FrozenModel):
+    check: str
+    message: str
+
+
+class NodeResult(FrozenModel):
+    node: str
+    bmc_address: str | None
+    status: Status
+    findings: tuple[Finding, ...] = ()
+    error: str | None = None
+
+
+class Report(FrozenModel):
+    schema_version: Literal[1] = 1
+    results: tuple[NodeResult, ...]
+
+    def count(self, status: Status) -> int:
+        return sum(1 for result in self.results if result.status == status)
+
+    @property
+    def passed(self) -> bool:
+        return all(result.status == Status.PASS for result in self.results)

racklint/netbox.py

@@ -0,0 +1,116 @@
+# racklint/src/racklint/netbox.py
+"""Read the planned state of devices from the NetBox REST API. racklint only ever sends GET requests."""
+
+from collections import defaultdict
+from collections.abc import Sequence
+from typing import Any
+
+import httpx
+from pydantic import ValidationError
+
+from racklint.errors import NetBoxError
+from racklint.models import ExpectedNode, HardwareSpec, PlannedInterface
+
+Record = dict[str, Any]
+
+CONFIG_CONTEXT_KEY = "racklint"
+PAGE_SIZE = 250
+TIMEOUT = httpx.Timeout(30.0)
+
+
+def auth_header(token: str) -> str:
+    """v2 tokens (NetBox 4.5+, prefixed nbt_) use the Bearer scheme; legacy tokens use Token."""
+    scheme = "Bearer" if token.startswith("nbt_") else "Token"
+    return f"{scheme} {token}"
+
+
+def netbox_client(url: str, token: str) -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        base_url=url,
+        headers={"Authorization": auth_header(token), "Accept": "application/json"},
+        timeout=TIMEOUT,
+    )
+
+
+class NetBoxSource:
+    """Turns NetBox devices into ExpectedNodes, reading devices and their interfaces in bulk."""
+
+    def __init__(self, client: httpx.AsyncClient) -> None:
+        self._client = client
+
+    async def rack(self, name: str, site: str | None = None) -> list[ExpectedNode]:
+        query = {"name": name} if site is None else {"name": name, "site": site}
+        racks = await self._list("dcim/racks", query)
+        if not racks:
+            raise NetBoxError(f"rack {name!r} not found")
+        if len(racks) > 1:
+            sites = ", ".join(sorted(rack["site"]["slug"] for rack in racks))
+            raise NetBoxError(f"rack {name!r} exists in several sites ({sites}); pass --site")
+        devices = await self._list("dcim/devices", {"rack_id": racks[0]["id"]})
+        if not devices:
+            raise NetBoxError(f"rack {name!r} has no devices")
+        return await self._expected(devices)
+
+    async def devices(self, names: Sequence[str]) -> list[ExpectedNode]:
+        devices = await self._list("dcim/devices", {"name": list(names)})
+        missing = set(names) - {device["name"] for device in devices}
+        if missing:
+            raise NetBoxError(f"devices not found: {', '.join(sorted(missing))}")
+        return await self._expected(devices)
+
+    async def _expected(self, devices: list[Record]) -> list[ExpectedNode]:
+        interfaces = await self._list(
+            "dcim/interfaces",
+            {"device_id": [device["id"] for device in devices], "kind": "physical", "mgmt_only": "false"},
+        )
+        planned: defaultdict[int, list[PlannedInterface]] = defaultdict(list)
+        for interface in interfaces:
+            planned[interface["device"]["id"]].append(_planned_interface(interface))
+        return [_expected_node(device, planned[device["id"]]) for device in devices]
+
+    async def _list(self, endpoint: str, query: Record) -> list[Record]:
+        """Every object a list endpoint returns for `query`, page by page."""
+        records: list[Record] = []
+        while True:
+            page = await self._get(f"/api/{endpoint}/", query | {"limit": PAGE_SIZE, "offset": len(records)})
+            records.extend(page["results"])
+            if not page["results"] or len(records) >= page["count"]:
+                return records
+
+    async def _get(self, path: str, params: Record) -> Record:
+        try:
+            response = await self._client.get(path, params=params)
+            response.raise_for_status()
+            page: Record = response.json()
+        except (httpx.HTTPError, ValueError) as error:
+            raise NetBoxError(f"NetBox request failed: {error}") from error
+        return page
+
+
+def _expected_node(device: Record, interfaces: list[PlannedInterface]) -> ExpectedNode:
+    oob_ip = device.get("oob_ip")
+    return ExpectedNode(
+        name=device["name"],
+        device_type=device["device_type"]["slug"],
+        serial=device.get("serial") or None,
+        bmc_address=oob_ip["address"].split("/")[0] if oob_ip else None,
+        spec=_hardware_spec(device),
+        interfaces=tuple(interfaces),
+    )
+
+
+def _hardware_spec(device: Record) -> HardwareSpec | None:
+    context = device.get("config_context") or {}
+    if CONFIG_CONTEXT_KEY not in context:
+        return None
+    try:
+        return HardwareSpec.model_validate(context[CONFIG_CONTEXT_KEY])
+    except ValidationError as error:
+        raise NetBoxError(
+            f"{device['name']}: invalid {CONFIG_CONTEXT_KEY!r} config context: {error}"
+        ) from error
+
+
+def _planned_interface(interface: Record) -> PlannedInterface:
+    primary_mac = interface.get("primary_mac_address")
+    return PlannedInterface(name=interface["name"], mac=primary_mac["mac_address"] if primary_mac else None)

racklint/redfish.py

@@ -0,0 +1,172 @@
+# racklint/src/racklint/redfish.py
+"""Read a node's hardware from its BMC over Redfish, without the host OS running.
+
+The reader starts at the service root and follows @odata.id links, so it relies on no vendor-specific
+paths. GPUs are the Processors with ProcessorType "GPU" in every ComputerSystem.
+"""
+
+import asyncio
+import contextlib
+import ssl
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from racklint.errors import InventoryError
+from racklint.models import ActualNode, Dimm, FirmwareItem, Gpu, NetworkPort
+
+Resource = dict[str, Any]
+
+SERVICE_ROOT = "/redfish/v1"
+TIMEOUT = httpx.Timeout(15.0, connect=5.0)
+ATTEMPTS = 3
+BACKOFF_SECONDS = 0.5
+
+
+class RedfishError(InventoryError):
+    """The BMC could not be read."""
+
+
+@dataclass(frozen=True)
+class BmcAccess:
+    """How to reach the BMCs: one set of credentials and TLS settings for all of them."""
+
+    username: str
+    password: str
+    scheme: str = "https"
+    verify: ssl.SSLContext | bool = True
+    max_requests: int = 4
+
+
+class RedfishReader:
+    """The engine's ActualReader for BMCs that speak Redfish."""
+
+    def __init__(self, access: BmcAccess) -> None:
+        self._access = access
+
+    async def read(self, bmc_address: str) -> ActualNode:
+        async with httpx.AsyncClient(
+            base_url=f"{self._access.scheme}://{_url_host(bmc_address)}",
+            auth=httpx.BasicAuth(self._access.username, self._access.password),
+            verify=self._access.verify,
+            timeout=TIMEOUT,
+        ) as http:
+            try:
+                return await read_inventory(RedfishClient(http, self._access.max_requests))
+            except (KeyError, TypeError, ValueError) as error:
+                raise RedfishError(f"unexpected Redfish payload: {error!r}") from error
+
+
+class RedfishClient:
+    """GETs resources from one BMC, at most `max_requests` at a time, retrying transient failures."""
+
+    def __init__(self, http: httpx.AsyncClient, max_requests: int, backoff: float = BACKOFF_SECONDS) -> None:
+        self._http = http
+        self._slots = asyncio.Semaphore(max_requests)
+        self._backoff = backoff
+
+    async def get(self, path: str) -> Resource:
+        async with self._slots:
+            response = await self._get_with_retries(path)
+        if response.status_code == httpx.codes.UNAUTHORIZED:
+            raise RedfishError("authentication failed")
+        if response.is_error:
+            raise RedfishError(f"GET {path} returned HTTP {response.status_code}")
+        try:
+            resource = response.json()
+        except ValueError:
+            resource = None
+        if not isinstance(resource, dict):
+            raise RedfishError(f"GET {path} returned a body that is not a JSON object")
+        return resource
+
+    async def _get_with_retries(self, path: str) -> httpx.Response:
+        for attempt in range(ATTEMPTS - 1):
+            # Connection errors, timeouts, 5xx and 429 are worth another try; any other answer is final.
+            with contextlib.suppress(httpx.TransportError):
+                response = await self._http.get(path)
+                if not _is_transient(response.status_code):
+                    return response
+            await asyncio.sleep(self._backoff * 2**attempt)
+        try:
+            return await self._http.get(path)
+        except httpx.TransportError as error:
+            raise RedfishError(f"GET {path} failed: {error!r}") from error
+
+
+def _is_transient(status_code: int) -> bool:
+    return status_code == httpx.codes.TOO_MANY_REQUESTS or status_code >= httpx.codes.INTERNAL_SERVER_ERROR
+
+
+def _url_host(address: str) -> str:
+    """An IPv6 address needs brackets in a URL."""
+    return f"[{address}]" if ":" in address else address
+
+
+async def read_inventory(client: RedfishClient) -> ActualNode:
+    """Walk the service one level at a time, fetching the collections of each level concurrently."""
+    root = await client.get(SERVICE_ROOT)
+    systems, chassis, update_service = await asyncio.gather(
+        _members(client, root, "Systems"),
+        _members(client, root, "Chassis"),
+        _follow(client, root, "UpdateService"),
+    )
+    processors, modules, adapters, firmware = await asyncio.gather(
+        _members_of_each(client, systems, "Processors"),
+        _members_of_each(client, systems, "Memory"),
+        _members_of_each(client, chassis, "NetworkAdapters"),
+        _members(client, update_service, "FirmwareInventory"),
+    )
+    functions = await _members_of_each(client, adapters, "NetworkDeviceFunctions")
+    return ActualNode(
+        serials=tuple(system["SerialNumber"] for system in systems if system.get("SerialNumber")),
+        gpus=tuple(_gpu(processor) for processor in processors if processor.get("ProcessorType") == "GPU"),
+        dimms=tuple(_dimm(module) for module in modules if _is_enabled(module)),
+        ports=tuple(_port(function) for function in functions),
+        firmware=tuple(_firmware_item(item) for item in firmware),
+    )
+
+
+async def _follow(client: RedfishClient, resource: Resource | None, key: str) -> Resource | None:
+    """The resource that `resource[key]` links to, if there is such a link."""
+    link = resource.get(key) if resource else None
+    return await client.get(link["@odata.id"]) if link else None
+
+
+async def _members(client: RedfishClient, resource: Resource | None, key: str) -> list[Resource]:
+    """The members of the collection that `resource[key]` links to; none if there is no such link."""
+    collection = await _follow(client, resource, key)
+    if collection is None:
+        return []
+    return list(
+        await asyncio.gather(*(client.get(member["@odata.id"]) for member in collection.get("Members", [])))
+    )
+
+
+async def _members_of_each(client: RedfishClient, resources: list[Resource], key: str) -> list[Resource]:
+    nested = await asyncio.gather(*(_members(client, resource, key) for resource in resources))
+    return [member for members in nested for member in members]
+
+
+def _gpu(processor: Resource) -> Gpu:
+    return Gpu(id=processor["Id"], model=processor.get("Model") or "")
+
+
+def _dimm(module: Resource) -> Dimm:
+    return Dimm(id=module["Id"], capacity_mib=module["CapacityMiB"])
+
+
+def _port(function: Resource) -> NetworkPort:
+    ethernet = function.get("Ethernet") or {}
+    return NetworkPort(
+        id=function["Id"], mac=ethernet.get("PermanentMACAddress") or ethernet.get("MACAddress")
+    )
+
+
+def _firmware_item(item: Resource) -> FirmwareItem:
+    return FirmwareItem(id=item["Id"], version=item.get("Version") or "")
+
+
+def _is_enabled(resource: Resource) -> bool:
+    return (resource.get("Status") or {}).get("State") == "Enabled"

racklint/render.py

@@ -0,0 +1,46 @@
+# racklint/src/racklint/render.py
+"""Present a report: a table for people, JSON for pipelines."""
+
+from typing import Protocol
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from racklint.models import NodeResult, Report, Status
+
+STATUS_STYLES = {Status.PASS: "bold green", Status.FAIL: "bold red", Status.ERROR: "bold yellow"}
+
+
+class Renderer(Protocol):
+    def render(self, report: Report, console: Console) -> None: ...
+
+
+class TableRenderer:
+    def render(self, report: Report, console: Console) -> None:
+        table = Table("Node", "BMC", "Status", "Reasons")
+        for result in report.results:
+            # Text, not str: reasons such as "approved [1.4.0]" must not be read as rich markup.
+            table.add_row(
+                Text(result.node),
+                Text(result.bmc_address or "-"),
+                Text(result.status.upper(), style=STATUS_STYLES[result.status]),
+                Text("\n".join(_reasons(result))),
+            )
+        console.print(table)
+        console.print(
+            f"{report.count(Status.PASS)} passed, {report.count(Status.FAIL)} failed, "
+            f"{report.count(Status.ERROR)} errored",
+            highlight=False,
+        )
+
+
+class JsonRenderer:
+    def render(self, report: Report, console: Console) -> None:
+        console.out(report.model_dump_json(indent=2), highlight=False)
+
+
+def _reasons(result: NodeResult) -> list[str]:
+    if result.error is not None:
+        return [result.error]
+    return [f"{finding.check}: {finding.message}" for finding in result.findings]

racklint/settings.py

@@ -0,0 +1,24 @@
+# racklint/src/racklint/settings.py
+"""The CLI's settings, from RACKLINT_* environment variables or a .env file in the working directory.
+
+The library does not use them: it takes explicit objects such as BmcAccess.
+"""
+
+from typing import Literal
+
+from pydantic import FilePath, HttpUrl, PositiveInt, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="RACKLINT_", env_file=".env", extra="ignore", frozen=True)
+
+    netbox_url: HttpUrl
+    netbox_token: SecretStr
+    bmc_username: str
+    bmc_password: SecretStr
+    bmc_scheme: Literal["https", "http"] = "https"
+    bmc_verify_tls: bool = True
+    bmc_ca_bundle: FilePath | None = None
+    concurrency: PositiveInt = 16
+    bmc_concurrency: PositiveInt = 4

racklint-0.1.0.dist-info/METADATA

@@ -0,0 +1,342 @@
+Metadata-Version: 2.4
+Name: racklint
+Version: 0.1.0
+Summary: Check bare-metal and GPU servers against NetBox before they go into service.
+Author: Reza Iskandar Achmad
+License-Expression: MIT
+Project-URL: Repository, https://github.com/riskand/racklint
+Keywords: redfish,bmc,netbox,commissioning,gpu,data-centre
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28
+Requires-Dist: pydantic>=2.9
+Requires-Dist: pydantic-settings>=2.6
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.9
+Requires-Dist: typer>=0.15
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13; extra == "dev"
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.25; extra == "dev"
+Requires-Dist: pytest-cov>=6.0; extra == "dev"
+Requires-Dist: respx>=0.22; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
+Requires-Dist: types-pyyaml>=6.0; extra == "dev"
+Dynamic: license-file
+
+# racklint
+
+**Check servers against the inventory before they go into service.**
+
+racklint is a commissioning validator for bare-metal and GPU clusters. It reads what each server reports through
+its BMC over [Redfish](https://www.dmtf.org/standards/redfish) and compares that with what
+[NetBox](https://netbox.dev) says should be there. Every mismatch is flagged: a wrong GPU count, a wrong serial
+number, firmware not on the approved baseline, a missing NIC.
+
+You can use it in two ways: as the `racklint` command, or as a Python library.
+
+## Why
+
+When a rack is brought up, the question is not "what hardware is in it?" but "is the hardware in it what we
+ordered and planned for?" Existing tools such as [netbox-sync](https://github.com/bb-Ricardo/netbox-sync) and
+[netbox-agent](https://github.com/Solvik/netbox-agent) answer the first question: they read the hardware and
+write it into NetBox, so NetBox ends up describing whatever was found.
+
+racklint works the other way. NetBox holds the planned state and stays the source of truth. racklint checks the
+hardware against it, changes nothing, and fails loudly on any difference. That makes it useful as a gate: a
+node only moves to the next stage of bring-up once racklint passes it.
+
+It is read-only. It sends only GET requests to NetBox and to the BMCs. The host OS does not need to be running.
+
+## Install
+
+```bash
+pip install racklint
+```
+
+racklint needs Python 3.12 or later.
+
+## Command line
+
+### Settings
+
+The command reads its settings from `RACKLINT_*` environment variables, or from a `.env` file in the working
+directory.
+
+| Setting | Default | Meaning |
+|---|---|---|
+| `RACKLINT_NETBOX_URL` | required | Base URL of NetBox, for example `https://netbox.example.net` |
+| `RACKLINT_NETBOX_TOKEN` | required | NetBox API token |
+| `RACKLINT_BMC_USERNAME` | required | User name for every BMC |
+| `RACKLINT_BMC_PASSWORD` | required | Password for every BMC |
+| `RACKLINT_BMC_SCHEME` | `https` | `https` or `http` |
+| `RACKLINT_BMC_VERIFY_TLS` | `true` | Verify BMC TLS certificates |
+| `RACKLINT_BMC_CA_BUNDLE` | unset | CA bundle file used to verify BMC certificates |
+| `RACKLINT_CONCURRENCY` | `16` | BMCs read at once |
+| `RACKLINT_BMC_CONCURRENCY` | `4` | Requests in flight to one BMC |
+
+A token that starts with `nbt_` (NetBox 4.5 and later) is sent as a bearer token. Any other token is sent as a
+legacy `Token`.
+
+### Run a check
+
+```bash
+racklint check --rack R01 --baseline baseline.yaml
+racklint check --device gpu-01 --device gpu-02 --baseline baseline.yaml
+```
+
+Pass exactly one of `--rack` and `--device`.
+
+| Option | Meaning |
+|---|---|
+| `--rack NAME` | Check every device in this NetBox rack |
+| `--site SLUG` | Site slug. Needed only if the rack name exists in several sites |
+| `--device NAME` | Check this device. Repeat for more |
+| `--baseline PATH` | Firmware baseline file. Required |
+| `--format table\|json` | Output format. Default `table` |
+| `--concurrency N` | BMCs to read at once. Overrides `RACKLINT_CONCURRENCY` |
+| `--ca-bundle PATH` | CA bundle for BMC certificates. Overrides `RACKLINT_BMC_CA_BUNDLE` |
+| `--insecure` | Do not verify BMC certificates. Overrides `RACKLINT_BMC_VERIFY_TLS` |
+
+The baseline is a YAML file with the approved firmware versions for each NetBox device type. Each `match` is a
+case-sensitive glob on the `Id` of a member of the BMC's firmware inventory. Versions must be quoted strings.
+
+```yaml
+device_types:
+  gpu-node-h100:             # NetBox device-type slug
+    - match: "BMC"
+      approved: ["1.4.0"]
+    - match: "GPU_*"
+      approved: ["96.00.89.00.01"]
+```
+
+### Exit codes
+
+| Code | Meaning |
+|---|---|
+| `0` | Every node passed |
+| `1` | At least one node failed, or its BMC could not be read |
+| `2` | Usage or configuration error: bad arguments, invalid settings or baseline, NetBox unreachable or returning an error, rack or device not found |
+
+Use the exit code to gate a pipeline.
+
+### Output
+
+The table has one row per node and one line per reason, then a summary:
+
+```console
+┏━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Node ┃ BMC        ┃ Status ┃ Reasons                                         ┃
+┡━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ n01  │ 192.0.2.11 │ PASS   │                                                 │
+│ n02  │ 192.0.2.12 │ PASS   │                                                 │
+│ n03  │ 192.0.2.13 │ FAIL   │ gpu: 7 found, 8 planned                         │
+│ n04  │ 192.0.2.14 │ PASS   │                                                 │
+│ n05  │ 192.0.2.15 │ FAIL   │ memory: 31 DIMMs (1984 GiB), 32 planned (2048   │
+│      │            │        │ GiB)                                            │
+│      │            │        │ firmware: BMC 1.3.2 not in approved [1.4.0]     │
+│ n06  │ 192.0.2.16 │ PASS   │                                                 │
+└──────┴────────────┴────────┴─────────────────────────────────────────────────┘
+4 passed, 2 failed, 0 errored
+```
+
+A node has status `PASS`, `FAIL` or `ERROR`. `ERROR` means racklint could not read the BMC (a connection
+failure after retries, a timeout, a rejected login or an invalid reply). No checks run for that node, and the
+reason is the error.
+
+With `--format json` the output is the report as JSON. This is one failing node:
+
+```json
+{
+  "schema_version": 1,
+  "results": [
+    {
+      "node": "n03",
+      "bmc_address": "192.0.2.13",
+      "status": "fail",
+      "findings": [
+        {
+          "check": "gpu",
+          "message": "7 found, 8 planned"
+        }
+      ],
+      "error": null
+    }
+  ]
+}
+```
+
+`status` is `pass`, `fail` or `error`. `error` is set only when the status is `error`.
+
+## Python library
+
+The names exported from `racklint` (its `__all__`) are the public API. Anything else may change before 1.0. The
+package ships type hints (`py.typed`). The names fall into these groups:
+
+| Group | Names |
+|---|---|
+| State | `ExpectedNode`, `PlannedInterface`, `HardwareSpec`, `GpuSpec`, `MemorySpec`, `ActualNode`, `Gpu`, `Dimm`, `NetworkPort`, `FirmwareItem` |
+| Verdict | `Report`, `NodeResult`, `Finding`, `Status` |
+| Running checks | `check_nodes`, `iter_results`, `ActualReader`, `Check`, `default_checks`, `SerialCheck`, `GpuCheck`, `MemoryCheck`, `NicCheck`, `FirmwareCheck` |
+| Sources | `NetBoxSource`, `netbox_client`, `RedfishReader`, `BmcAccess`, `FirmwareBaseline`, `FirmwareRule` |
+| Errors | `RacklintError`, `BaselineError`, `NetBoxError`, `InventoryError`, `RedfishError` |
+
+The library is async and does not read `RACKLINT_*` settings: you pass it explicit objects. This example reads
+the plan for rack R01 from NetBox, reads each BMC and prints a verdict per node. It takes its connection details
+from the environment.
+
+```python
+import asyncio
+import os
+from pathlib import Path
+
+from racklint import (
+    BmcAccess,
+    FirmwareBaseline,
+    NetBoxSource,
+    RedfishReader,
+    check_nodes,
+    default_checks,
+    netbox_client,
+)
+
+
+async def main() -> None:
+    async with netbox_client(os.environ["NETBOX_URL"], os.environ["NETBOX_TOKEN"]) as client:
+        nodes = await NetBoxSource(client).rack("R01")
+
+    access = BmcAccess(username=os.environ["BMC_USERNAME"], password=os.environ["BMC_PASSWORD"])
+    baseline = FirmwareBaseline.load(Path("baseline.yaml"))
+    report = await check_nodes(nodes, RedfishReader(access), default_checks(baseline), concurrency=16)
+
+    for result in report.results:
+        print(result.node, result.status, [finding.message for finding in result.findings])
+    print("all passed" if report.passed else "not all passed")
+
+
+asyncio.run(main())
+```
+
+`check_nodes` returns a `Report` with the results in the order of `nodes`. To act on each result as soon as it
+is ready, for live progress, loop over `iter_results` instead. It takes the same arguments and yields
+`NodeResult`s in the order they finish:
+
+```python
+import asyncio
+import os
+from pathlib import Path
+
+from racklint import (
+    BmcAccess,
+    FirmwareBaseline,
+    NetBoxSource,
+    RedfishReader,
+    default_checks,
+    iter_results,
+    netbox_client,
+)
+
+
+async def main() -> None:
+    async with netbox_client(os.environ["NETBOX_URL"], os.environ["NETBOX_TOKEN"]) as client:
+        nodes = await NetBoxSource(client).devices(["gpu-01", "gpu-02"])
+
+    access = BmcAccess(username=os.environ["BMC_USERNAME"], password=os.environ["BMC_PASSWORD"])
+    checks = default_checks(FirmwareBaseline.load(Path("baseline.yaml")))
+    async for result in iter_results(nodes, RedfishReader(access), checks, concurrency=16):
+        print(result.node, result.status)
+
+
+asyncio.run(main())
+```
+
+`NetBoxSource` raises `NetBoxError` and `FirmwareBaseline.load` raises `BaselineError`; both are subclasses of
+`RacklintError`. A BMC that cannot be read does not raise: its node gets status `error`.
+
+A `FirmwareBaseline` can also be built from a dict with `FirmwareBaseline.model_validate`, so an application
+can keep the baseline in its own database.
+
+The NetBox source is optional. A NetBox plugin runs inside NetBox, so it can build `ExpectedNode`s from the
+Django ORM instead of the REST API, then call `asyncio.run(check_nodes(...))` from a background job, which is
+synchronous code.
+
+## What it checks
+
+| Check | Fails when | Example reason |
+|---|---|---|
+| Serial | The device's serial matches the serial of no system on the BMC | `serial: expected SN-R01-03, BMC reports SN-R01-30` |
+| GPU | The GPU count differs, or a GPU's model differs from the planned model | `gpu: 7 found, 8 planned` |
+| Memory | The enabled DIMM count or the total capacity differs | `memory: 31 DIMMs (1984 GiB), 32 planned (2048 GiB)` |
+| NIC | A planned MAC address is not reported, or fewer ports are reported than interfaces are planned | `nic: eth2 (a0:88:c2:00:03:03) not found` |
+| Firmware | The device type has no baseline, a baseline entry matches no firmware item, or a matched item's version is not approved | `firmware: BMC 1.3.2 not in approved [1.4.0]` |
+
+A node passes only if every check passes. Firmware items that match no baseline entry are ignored, and so are
+reported ports beyond the plan.
+
+If NetBox lacks a value a check needs, the node fails with `not planned in NetBox: <item>`. A device with no
+BMC address fails with that reason alone.
+
+### What NetBox must hold
+
+| Item | Where racklint reads it |
+|---|---|
+| Serial | The device's `serial` field |
+| BMC address | The device's out-of-band IP (`oob_ip`). The prefix length is dropped |
+| Device type | The device type's slug. It selects the firmware baseline |
+| NICs | The device's physical interfaces that are not management-only. A MAC address is compared if the interface has a primary MAC; without one, racklint only counts the port |
+| GPU and memory | The `racklint` key of the device's config context |
+
+Assign the config context to the device type, so every device of that type gets it:
+
+```yaml
+racklint:
+  gpu:    {count: 8, model: "NVIDIA H100 80GB HBM3"}
+  memory: {dimm_count: 32, total_gib: 2048}
+```
+
+An invalid `racklint` config context is a configuration error and stops the run with exit code `2`.
+
+On the BMC side, racklint starts at `/redfish/v1` and follows the links the service returns. It hardcodes no
+vendor paths. It reads systems, processors, memory, network adapters and the firmware inventory. It uses HTTP
+Basic authentication on every request and opens no Redfish sessions. It makes up to three attempts at a
+request that fails with a connection error, a timeout, HTTP 5xx or 429, and uses a connect timeout of 5
+seconds and a read timeout of 15 seconds.
+
+## Try it without hardware
+
+[`examples/no-hardware/`](examples/no-hardware) is a Docker Compose stack with a real NetBox and six mock BMCs,
+two of them built wrong on purpose. One command checks the rack, and the summary line is
+`4 passed, 2 failed, 0 errored`. See its README for the steps and what is planted.
+
+## Limitations
+
+- GPUs are found only as Redfish `Processors` with `ProcessorType == "GPU"`. A BMC that exposes GPUs another way
+  shows zero GPUs.
+- One set of BMC credentials applies to every node in a run.
+- Read-only by design. racklint reports differences and never fixes them in NetBox or on a BMC.
+
+## Related work
+
+| Project | What it does |
+|---|---|
+| [bb-Ricardo/netbox-sync](https://github.com/bb-Ricardo/netbox-sync) | Syncs VMware and Redfish sources into NetBox |
+| [Solvik/netbox-agent](https://github.com/Solvik/netbox-agent) | Agent on each server that pushes hardware into NetBox |
+| [bb-Ricardo/check_redfish](https://github.com/bb-Ricardo/check_redfish) | Monitoring plugin for component health over Redfish |
+| OpenStack Ironic, Metal3, MAAS, Warewulf | Full provisioning platforms with BMC inspection |
+
+racklint is smaller than any of these and does one thing: it compares the hardware with NetBox's plan and
+reports the differences.
+
+## License
+
+[MIT](LICENSE)

racklint-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+racklint/__init__.py,sha256=bojv7B69WLbBExWdzBTSHo228u975WGYZvSgBWQCtnY,1547
+racklint/baseline.py,sha256=z8F8dhqap-QLGKEY3TUFPdnSlJX9Mjeh-RUWNQOTVfM,941
+racklint/checks.py,sha256=LFoPLibnfX7FMs0Uonp9WQ_fgry4eTOFf9Ab-wC7ng8,4079
+racklint/cli.py,sha256=Pv1z9cImRE1tGCIc9YDDrN7DAX8PhDqQh0sgUMrVufY,4810
+racklint/engine.py,sha256=HUHpyRmn5zP-8qhSn650TbZGEaylViWADGsHX1VNRpY,2640
+racklint/errors.py,sha256=wMWcJwjw4y2KrQ_IuEbQDkD-PPq6XedYBknPNFPHlsc,527
+racklint/models.py,sha256=nF4O2atKijrHEHU_4IMexQ_hqLkjzAuSjSuVaFnGTfE,2851
+racklint/netbox.py,sha256=aZoSS5LExYhq9swGVPTokniRg1hnsINWlMDhqBkDook,4723
+racklint/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+racklint/redfish.py,sha256=TNtc4N3T0oLb34vObUgfgqPAjVDwQgdt33nA7IFDM7o,6660
+racklint/render.py,sha256=se4d_x3H57icAudg1IYNqbiv_Ry-tnGE8Du-EdJITDg,1588
+racklint/settings.py,sha256=9nNhYnPbdB8GI0x1OGTWyNsNQi6g0sHACN74YsQyd5I,813
+racklint-0.1.0.dist-info/licenses/LICENSE,sha256=-PMFfPbf8g1LaUdw7cgrVXF5YYF-RA5uLEtkHsWI4y4,1077
+racklint-0.1.0.dist-info/METADATA,sha256=DfryvogWVMEtw38RPiX9vdYd7j52ANsjL2lYP0Ok1iY,14812
+racklint-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+racklint-0.1.0.dist-info/entry_points.txt,sha256=iienqnMceoWGpJhQDTEQD3TV3LGxaJgfnWQVEINRDa8,46
+racklint-0.1.0.dist-info/top_level.txt,sha256=34Bk7HMWKC2vp2sZunhaz9C3wFHCk7d2io577xjGLrM,9
+racklint-0.1.0.dist-info/RECORD,,

racklint-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

racklint-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+racklint = racklint.cli:app

racklint-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Reza Iskandar Achmad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

racklint-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+racklint