hpavil 0.1.0__tar.gz

hpavil-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: hpavil
+Version: 0.1.0
+Summary: Solace bridge inventory backend — parses broker .cli configs into a queryable bridge and topology inventory.
+Requires-Python: >=3.9

hpavil-0.1.0/bridge_inventory/__init__.py

@@ -0,0 +1,6 @@
+"""Solace bridge inventory backend."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"
+

hpavil-0.1.0/bridge_inventory/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

hpavil-0.1.0/bridge_inventory/api/__init__.py

@@ -0,0 +1,2 @@
+"""REST API adapter."""
+

hpavil-0.1.0/bridge_inventory/api/server.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import json
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Callable, Dict, Optional
+from urllib.parse import parse_qs, urlparse
+
+from ..app import BridgeInventoryService
+
+
+class JsonApiHandler(BaseHTTPRequestHandler):
+    service: BridgeInventoryService
+
+    def do_GET(self) -> None:
+        self._handle("GET")
+
+    def do_POST(self) -> None:
+        self._handle("POST")
+
+    def log_message(self, format: str, *args: object) -> None:
+        return
+
+    def _handle(self, method: str) -> None:
+        parsed = urlparse(self.path)
+        try:
+            if method == "GET" and parsed.path == "/health":
+                self._json(200, self.service.health())
+            elif method == "POST" and parsed.path == "/scan":
+                self._json(200, self.service.scan())
+            elif method == "GET" and parsed.path == "/summary":
+                self._json(200, self.service.summary())
+            elif method == "GET" and parsed.path == "/source-files":
+                self._json(200, {"items": self.service.source_files()})
+            elif method == "GET" and parsed.path == "/brokers":
+                self._json(200, {"items": self.service.brokers()})
+            elif method == "GET" and parsed.path == "/bridges":
+                query = parse_qs(parsed.query)
+                bridge_type = query.get("type", [None])[0]
+                self._json(200, {"items": self.service.bridges(bridge_type=bridge_type)})
+            elif method == "GET" and parsed.path.startswith("/bridges/"):
+                bridge_id = parsed.path.removeprefix("/bridges/")
+                bridge = self.service.bridge(bridge_id)
+                if bridge is None:
+                    self._json(404, {"error": "bridge_not_found", "id": bridge_id})
+                else:
+                    self._json(200, bridge)
+            elif method == "GET" and parsed.path == "/bridge-relationships":
+                self._json(200, {"items": self.service.relationships()})
+            elif method == "GET" and parsed.path == "/topology-relationships":
+                self._json(200, {"items": self.service.topology_relationships()})
+            elif method == "GET" and parsed.path == "/bridge-port-remediation-plan":
+                query = parse_qs(parsed.query)
+                broker = query.get("broker", [None])[0]
+                desired_port = _int_query(query, "desired_port", 55443)
+                self._json(
+                    200,
+                    self.service.bridge_port_remediation_plan(
+                        broker=broker, desired_port=desired_port
+                    ),
+                )
+            elif method == "GET" and parsed.path == "/parser-warnings":
+                self._json(200, {"items": self.service.warnings()})
+            else:
+                self._json(404, {"error": "not_found", "path": parsed.path})
+        except Exception as exc:
+            self._json(500, {"error": "internal_error", "message": str(exc)})
+
+    def _json(self, status: int, payload: Any) -> None:
+        data = json.dumps(payload, indent=2, sort_keys=True).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+
+def make_server(
+    service: BridgeInventoryService, host: str = "127.0.0.1", port: int = 8787
+) -> ThreadingHTTPServer:
+    class Handler(JsonApiHandler):
+        pass
+
+    Handler.service = service
+    return ThreadingHTTPServer((host, port), Handler)
+
+
+def _int_query(query: Dict[str, list[str]], name: str, default: int) -> int:
+    values = query.get(name)
+    if not values or values[0] is None:
+        return default
+    try:
+        return int(values[0])
+    except ValueError:
+        return default

hpavil-0.1.0/bridge_inventory/app.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .core.parser import SolaceCliParser
+from .core.remediation import BridgePortRemediationPlanner
+from .core.resolver import BridgeRelationshipResolver
+from .core.topology import TopologyParser, TopologyResolver
+from .infra.file_scanner import CliDirectoryScanner
+from .infra.sqlite_store import SQLiteInventoryStore
+
+
+class BridgeInventoryService:
+    def __init__(self, cli_dir: Path, db_path: Path):
+        self.cli_dir = cli_dir
+        self.db_path = db_path
+        self.scanner = CliDirectoryScanner(cli_dir)
+        self.parser = SolaceCliParser()
+        self.resolver = BridgeRelationshipResolver()
+        self.topology_parser = TopologyParser()
+        self.topology_resolver = TopologyResolver()
+        self.bridge_port_remediation_planner = BridgePortRemediationPlanner()
+        self.store = SQLiteInventoryStore(db_path)
+
+    def scan(self) -> Dict[str, Any]:
+        source_files = self.scanner.scan()
+        parsed = []
+        topology_configs = []
+        for source_file in source_files:
+            broker_config = self.parser.parse_file(source_file.path)
+            parsed.append(broker_config)
+            topology_configs.append(
+                self.topology_parser.parse_file(
+                    source_file.path, broker_config.identity.broker_name
+                )
+            )
+        relationships = self.resolver.resolve(parsed)
+        topology_relationships = self.topology_resolver.resolve(topology_configs)
+        self.store.replace_inventory(
+            source_files, parsed, relationships, topology_relationships
+        )
+        summary = self.store.summary()
+        summary["cli_dir"] = str(self.cli_dir.resolve())
+        summary["db_path"] = str(self.db_path.resolve())
+        return summary
+
+    def health(self) -> Dict[str, Any]:
+        self.store.initialize()
+        return {"status": "ok", "cli_dir": str(self.cli_dir), "db_path": str(self.db_path)}
+
+    def source_files(self) -> List[Dict[str, Any]]:
+        return self.store.list_source_files()
+
+    def brokers(self) -> List[Dict[str, Any]]:
+        return self.store.list_brokers()
+
+    def bridges(self, bridge_type: Optional[str] = None) -> List[Dict[str, Any]]:
+        return self.store.list_bridges(bridge_type=bridge_type)
+
+    def bridge(self, bridge_id: str) -> Optional[Dict[str, Any]]:
+        return self.store.get_bridge(bridge_id)
+
+    def relationships(self) -> List[Dict[str, Any]]:
+        return self.store.list_relationships()
+
+    def topology_relationships(self) -> List[Dict[str, Any]]:
+        return self.store.list_topology_relationships()
+
+    def bridge_port_remediation_plan(
+        self, broker: Optional[str] = None, desired_port: int = 55443
+    ) -> Dict[str, Any]:
+        return self.bridge_port_remediation_planner.plan(
+            bridges=self.bridges("message_vpn_bridge"),
+            relationships=self.relationships(),
+            broker=broker,
+            desired_port=desired_port,
+        )
+
+    def warnings(self) -> List[Dict[str, Any]]:
+        return self.store.list_warnings()
+
+    def summary(self) -> Dict[str, Any]:
+        self.store.initialize()
+        summary = self.store.summary()
+        summary["cli_dir"] = str(self.cli_dir.resolve())
+        summary["db_path"] = str(self.db_path.resolve())
+        return summary

hpavil-0.1.0/bridge_inventory/cli.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from .app import BridgeInventoryService
+from .api.server import make_server
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Solace bridge inventory backend")
+    subcommands = parser.add_subparsers(dest="command", required=True)
+
+    scan_parser = subcommands.add_parser("scan", help="Scan local .cli files")
+    add_common_args(scan_parser)
+
+    serve_parser = subcommands.add_parser("serve", help="Run the REST API")
+    add_common_args(serve_parser)
+    serve_parser.add_argument("--host", default="127.0.0.1")
+    serve_parser.add_argument("--port", type=int, default=8787)
+    serve_parser.add_argument(
+        "--no-initial-scan",
+        action="store_true",
+        help="Start API without scanning first",
+    )
+
+    args = parser.parse_args(argv)
+    service = BridgeInventoryService(Path(args.cli_dir), Path(args.db))
+
+    if args.command == "scan":
+        print(json.dumps(service.scan(), indent=2, sort_keys=True))
+        return 0
+    if args.command == "serve":
+        if not args.no_initial_scan:
+            summary = service.scan()
+            print(json.dumps({"initial_scan": summary}, indent=2, sort_keys=True))
+        server = make_server(service, host=args.host, port=args.port)
+        url = f"http://{args.host}:{args.port}"
+        print(f"Serving bridge inventory API at {url}")
+        print("Endpoints: /health /summary /bridges /bridge-relationships /topology-relationships /bridge-port-remediation-plan")
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            print("\nStopping server")
+        finally:
+            server.server_close()
+        return 0
+    return 2
+
+
+def add_common_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--cli-dir",
+        default=".",
+        help="Directory containing local .cli files",
+    )
+    parser.add_argument(
+        "--db",
+        default=".bridge_inventory.sqlite",
+        help="SQLite database path",
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hpavil-0.1.0/bridge_inventory/core/__init__.py

@@ -0,0 +1,2 @@
+"""Core domain model, parser, and resolver."""
+

hpavil-0.1.0/bridge_inventory/core/models.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+def without_none(value: Dict[str, Any]) -> Dict[str, Any]:
+    return {k: v for k, v in value.items() if v is not None}
+
+
+@dataclass
+class ParserWarning:
+    source_file: str
+    line_number: int
+    code: str
+    message: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class BrokerIdentity:
+    source_file: str
+    broker_name: str
+    router_name: Optional[str] = None
+    version: Optional[str] = None
+    generated_at: Optional[str] = None
+    redacted: Optional[bool] = None
+    aliases: List[str] = field(default_factory=list)
+
+    def all_aliases(self) -> List[str]:
+        aliases = [self.broker_name]
+        if self.router_name:
+            aliases.append(self.router_name)
+        aliases.extend(self.aliases)
+        seen = set()
+        result = []
+        for alias in aliases:
+            if alias and alias not in seen:
+                seen.add(alias)
+                result.append(alias)
+        return result
+
+    def to_dict(self) -> Dict[str, Any]:
+        return without_none(asdict(self))
+
+
+@dataclass
+class MessageVpn:
+    broker_name: str
+    name: str
+    admin_state: Optional[str] = None
+    replication_state: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return without_none(asdict(self))
+
+
+@dataclass
+class MessageVpnBridgeTarget:
+    remote_vpn: str
+    remote_kind: Optional[str] = None
+    remote_value: Optional[str] = None
+    remote_broker: Optional[str] = None
+    admin_state: Optional[str] = None
+    tls_enabled: Optional[bool] = None
+    compressed_data_enabled: Optional[bool] = None
+    message_spool_queue: Optional[str] = None
+    window_size: Optional[int] = None
+    connect_order: Optional[int] = None
+    unidirectional_client_profile: Optional[str] = None
+    source_line: Optional[int] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return without_none(asdict(self))
+
+
+@dataclass
+class MessageVpnBridge:
+    broker_name: str
+    source_vpn: str
+    bridge_name: str
+    redundancy: Optional[str] = None
+    admin_state: Optional[str] = None
+    max_ttl: Optional[int] = None
+    auth_scheme: Optional[str] = None
+    client_username: Optional[str] = None
+    retry_count: Optional[int] = None
+    retry_delay: Optional[int] = None
+    source_line: Optional[int] = None
+    targets: List[MessageVpnBridgeTarget] = field(default_factory=list)
+
+    @property
+    def bridge_type(self) -> str:
+        return "message_vpn_bridge"
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = without_none(asdict(self))
+        data["bridge_type"] = self.bridge_type
+        return data
+
+
+@dataclass
+class VpnReplicationBridge:
+    broker_name: str
+    source_vpn: str
+    bridge_name: str = "#MSGVPN_REPLICATION_BRIDGE"
+    admin_state: Optional[str] = None
+    replication_state: Optional[str] = None
+    transaction_replication_mode: Optional[str] = None
+    auth_scheme: Optional[str] = None
+    client_username: Optional[str] = None
+    tls_enabled: Optional[bool] = None
+    compressed_data_enabled: Optional[bool] = None
+    window_size: Optional[int] = None
+    retry_delay: Optional[int] = None
+    unidirectional_client_profile: Optional[str] = None
+    queue_max_spool_usage: Optional[int] = None
+    queue_reject_msg_to_sender_on_discard: Optional[bool] = None
+    source_line: Optional[int] = None
+
+    @property
+    def bridge_type(self) -> str:
+        return "vpn_replication_bridge"
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = without_none(asdict(self))
+        data["bridge_type"] = self.bridge_type
+        return data
+
+
+@dataclass
+class ConfigSyncReplicationBridge:
+    broker_name: str
+    bridge_name: str = "#CONFIG_SYNC_REPLICATION_BRIDGE"
+    admin_state: Optional[str] = None
+    remote_broker: Optional[str] = None
+    replication_mate_connect_via: Optional[str] = None
+    replication_mate_virtual_router: Optional[str] = None
+    auth_scheme: Optional[str] = None
+    tls_enabled: Optional[bool] = None
+    compressed_data_enabled: Optional[bool] = None
+    window_size: Optional[int] = None
+    retry_delay: Optional[int] = None
+    source_line: Optional[int] = None
+
+    @property
+    def bridge_type(self) -> str:
+        return "config_sync_replication_bridge"
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = without_none(asdict(self))
+        data["bridge_type"] = self.bridge_type
+        return data
+
+
+@dataclass
+class ParsedBrokerConfig:
+    identity: BrokerIdentity
+    message_vpns: List[MessageVpn] = field(default_factory=list)
+    message_vpn_bridges: List[MessageVpnBridge] = field(default_factory=list)
+    vpn_replication_bridges: List[VpnReplicationBridge] = field(default_factory=list)
+    config_sync_replication_bridge: Optional[ConfigSyncReplicationBridge] = None
+    warnings: List[ParserWarning] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "identity": self.identity.to_dict(),
+            "message_vpns": [x.to_dict() for x in self.message_vpns],
+            "message_vpn_bridges": [x.to_dict() for x in self.message_vpn_bridges],
+            "vpn_replication_bridges": [
+                x.to_dict() for x in self.vpn_replication_bridges
+            ],
+            "config_sync_replication_bridge": (
+                self.config_sync_replication_bridge.to_dict()
+                if self.config_sync_replication_bridge
+                else None
+            ),
+            "warnings": [x.to_dict() for x in self.warnings],
+        }
+
+
+@dataclass
+class BridgeRelationship:
+    relationship_type: str
+    direction: str
+    source_broker: str
+    bridge_name: str
+    source_vpn: Optional[str] = None
+    remote_broker: Optional[str] = None
+    remote_vpn: Optional[str] = None
+    remote_endpoint: Optional[str] = None
+    status: str = "unresolved"
+    counterpart_bridge_name: Optional[str] = None
+    notes: List[str] = field(default_factory=list)
+    details: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return without_none(asdict(self))
+
+
+@dataclass
+class Inventory:
+    brokers: List[ParsedBrokerConfig]
+    relationships: List[BridgeRelationship]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "brokers": [x.to_dict() for x in self.brokers],
+            "relationships": [x.to_dict() for x in self.relationships],
+        }