mirror of
https://github.com/bunny-lab-io/Borealis.git
synced 2025-10-27 15:41:57 -06:00
292 lines
10 KiB
Python
292 lines
10 KiB
Python
"""Entrypoint helpers for running the Borealis Engine runtime.
|
|
|
|
The bootstrapper assembles configuration via :func:`Data.Engine.config.load_runtime_config`
|
|
before delegating to :func:`Data.Engine.server.create_app`. It mirrors the
|
|
legacy server defaults by binding to ``0.0.0.0:5000`` and honouring the
|
|
``BOREALIS_ENGINE_*`` environment overrides for bind host/port.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import time
|
|
from pathlib import Path
|
|
from typing import Any, Dict, Optional
|
|
|
|
from .server import EngineContext, create_app
|
|
|
|
|
|
DEFAULT_HOST = "0.0.0.0"
|
|
DEFAULT_PORT = 5000
|
|
|
|
|
|
def _project_root() -> Path:
|
|
"""Locate the repository root by discovering the Borealis bootstrap script."""
|
|
|
|
current = Path(__file__).resolve().parent
|
|
|
|
for candidate in (current, *current.parents):
|
|
if (candidate / "Borealis.ps1").is_file():
|
|
return candidate
|
|
|
|
raise RuntimeError(
|
|
"Unable to locate the Borealis project root; Borealis.ps1 was not found "
|
|
"in any parent directory."
|
|
)
|
|
|
|
|
|
def _build_runtime_config() -> Dict[str, Any]:
|
|
api_groups_override = os.environ.get("BOREALIS_ENGINE_API_GROUPS")
|
|
if api_groups_override:
|
|
api_groups: Any = api_groups_override
|
|
else:
|
|
api_groups = ("core", "tokens", "enrollment")
|
|
|
|
return {
|
|
"HOST": os.environ.get("BOREALIS_ENGINE_HOST", DEFAULT_HOST),
|
|
"PORT": int(os.environ.get("BOREALIS_ENGINE_PORT", DEFAULT_PORT)),
|
|
"TLS_CERT_PATH": os.environ.get("BOREALIS_TLS_CERT"),
|
|
"TLS_KEY_PATH": os.environ.get("BOREALIS_TLS_KEY"),
|
|
"TLS_BUNDLE_PATH": os.environ.get("BOREALIS_TLS_BUNDLE"),
|
|
"API_GROUPS": api_groups,
|
|
}
|
|
|
|
|
|
def _stage_web_interface_assets(logger: Optional[logging.Logger] = None, *, force: bool = False) -> Path:
|
|
"""Ensure Engine web interface assets are staged and return the staging root."""
|
|
|
|
if logger is None:
|
|
logger = logging.getLogger("borealis.engine.bootstrap")
|
|
if not logger.handlers:
|
|
handler = logging.StreamHandler()
|
|
handler.setFormatter(logging.Formatter("%(asctime)s-%(name)s-%(levelname)s: %(message)s"))
|
|
logger.addHandler(handler)
|
|
logger.propagate = False
|
|
logger.setLevel(logging.INFO)
|
|
|
|
project_root = _project_root()
|
|
engine_web_root = project_root / "Engine" / "web-interface"
|
|
legacy_source = project_root / "Data" / "Server" / "WebUI"
|
|
|
|
if not legacy_source.is_dir():
|
|
raise RuntimeError(
|
|
f"Engine web interface source missing: {legacy_source}"
|
|
)
|
|
|
|
index_path = engine_web_root / "index.html"
|
|
if engine_web_root.exists() and index_path.is_file() and not force:
|
|
logger.info("Engine web interface already staged at %s; skipping copy.", engine_web_root)
|
|
return engine_web_root
|
|
|
|
if engine_web_root.exists():
|
|
shutil.rmtree(engine_web_root)
|
|
|
|
shutil.copytree(legacy_source, engine_web_root)
|
|
|
|
if not index_path.is_file():
|
|
raise RuntimeError(
|
|
f"Engine web interface staging failed; missing {index_path}"
|
|
)
|
|
|
|
logger.info("Engine web interface staged from %s to %s", legacy_source, engine_web_root)
|
|
return engine_web_root
|
|
|
|
|
|
def _determine_static_folder(staging_root: Path) -> str:
|
|
for candidate in (staging_root / "build", staging_root / "dist", staging_root):
|
|
if candidate.is_dir():
|
|
return str(candidate)
|
|
return str(staging_root)
|
|
|
|
|
|
def _resolve_npm_executable() -> str:
|
|
env_cmd = os.environ.get("BOREALIS_NPM_CMD")
|
|
if env_cmd:
|
|
candidate = Path(env_cmd).expanduser()
|
|
if candidate.is_file():
|
|
return str(candidate)
|
|
|
|
node_dir = os.environ.get("BOREALIS_NODE_DIR")
|
|
if node_dir:
|
|
candidate = Path(node_dir) / "npm.cmd"
|
|
if candidate.is_file():
|
|
return str(candidate)
|
|
candidate = Path(node_dir) / "npm.exe"
|
|
if candidate.is_file():
|
|
return str(candidate)
|
|
candidate = Path(node_dir) / "npm"
|
|
if candidate.is_file():
|
|
return str(candidate)
|
|
|
|
if os.name == "nt":
|
|
return "npm.cmd"
|
|
return "npm"
|
|
|
|
|
|
def _run_npm(args: list[str], cwd: Path, logger: logging.Logger) -> None:
|
|
command = [_resolve_npm_executable()] + args
|
|
logger.info("Running npm command: %s", " ".join(command))
|
|
start = time.time()
|
|
try:
|
|
completed = subprocess.run(command, cwd=str(cwd), capture_output=True, text=True, check=False)
|
|
except FileNotFoundError as exc:
|
|
raise RuntimeError("npm executable not found; ensure Node.js dependencies are installed.") from exc
|
|
duration = time.time() - start
|
|
if completed.returncode != 0:
|
|
logger.error(
|
|
"npm command failed (%ss): %s\nstdout: %s\nstderr: %s",
|
|
f"{duration:.2f}",
|
|
" ".join(command),
|
|
completed.stdout.strip(),
|
|
completed.stderr.strip(),
|
|
)
|
|
raise RuntimeError(f"npm command {' '.join(command)} failed with exit code {completed.returncode}")
|
|
stdout = completed.stdout.strip()
|
|
if stdout:
|
|
logger.debug("npm stdout: %s", stdout)
|
|
stderr = completed.stderr.strip()
|
|
if stderr:
|
|
logger.debug("npm stderr: %s", stderr)
|
|
logger.info("npm command completed in %.2fs", duration)
|
|
|
|
|
|
def _ensure_web_ui_build(staging_root: Path, logger: logging.Logger, *, mode: str) -> str:
|
|
package_json = staging_root / "package.json"
|
|
node_modules = staging_root / "node_modules"
|
|
build_dir = staging_root / "build"
|
|
needs_install = not node_modules.is_dir()
|
|
needs_build = not build_dir.is_dir()
|
|
|
|
if not needs_build and package_json.is_file():
|
|
build_index = build_dir / "index.html"
|
|
if build_index.is_file():
|
|
needs_build = build_index.stat().st_mtime < package_json.stat().st_mtime
|
|
else:
|
|
needs_build = True
|
|
|
|
if mode == "developer":
|
|
logger.info("Engine launched in developer mode; skipping WebUI build step.")
|
|
return _determine_static_folder(staging_root)
|
|
|
|
if not package_json.is_file():
|
|
logger.warning("WebUI package.json not found at %s; continuing without rebuild.", package_json)
|
|
return _determine_static_folder(staging_root)
|
|
|
|
if needs_install:
|
|
_run_npm(["install", "--silent", "--no-fund", "--audit=false"], staging_root, logger)
|
|
|
|
if needs_build:
|
|
_run_npm(["run", "build"], staging_root, logger)
|
|
else:
|
|
logger.info("Existing WebUI build found at %s; reuse.", build_dir)
|
|
|
|
return _determine_static_folder(staging_root)
|
|
|
|
|
|
def _ensure_tls_material(context: EngineContext) -> None:
|
|
"""Ensure TLS certificate material exists, updating the context if created."""
|
|
|
|
try: # Lazy import so Engine still starts if legacy modules are unavailable.
|
|
from Modules.crypto import certificates # type: ignore
|
|
except Exception:
|
|
return
|
|
|
|
try:
|
|
cert_path, key_path, bundle_path = certificates.ensure_certificate()
|
|
except Exception as exc:
|
|
context.logger.error("Failed to auto-provision Engine TLS certificates: %s", exc)
|
|
return
|
|
|
|
cert_path_str = str(cert_path)
|
|
key_path_str = str(key_path)
|
|
bundle_path_str = str(bundle_path)
|
|
|
|
if not context.tls_cert_path or not Path(context.tls_cert_path).is_file():
|
|
context.tls_cert_path = cert_path_str
|
|
if not context.tls_key_path or not Path(context.tls_key_path).is_file():
|
|
context.tls_key_path = key_path_str
|
|
if not context.tls_bundle_path or not Path(context.tls_bundle_path).is_file():
|
|
context.tls_bundle_path = bundle_path_str
|
|
|
|
|
|
def _prepare_tls_run_kwargs(context: EngineContext) -> Dict[str, Any]:
|
|
"""Validate and return TLS arguments for the Socket.IO runner."""
|
|
|
|
_ensure_tls_material(context)
|
|
|
|
run_kwargs: Dict[str, Any] = {}
|
|
|
|
key_path_value = context.tls_key_path
|
|
if not key_path_value:
|
|
return run_kwargs
|
|
|
|
key_path = Path(key_path_value)
|
|
if not key_path.is_file():
|
|
raise RuntimeError(f"Engine TLS key file not found: {key_path}")
|
|
|
|
cert_candidates = []
|
|
if context.tls_bundle_path:
|
|
cert_candidates.append(context.tls_bundle_path)
|
|
if context.tls_cert_path and context.tls_cert_path not in cert_candidates:
|
|
cert_candidates.append(context.tls_cert_path)
|
|
|
|
if not cert_candidates:
|
|
raise RuntimeError("Engine TLS certificate path not configured; ensure certificates are provisioned.")
|
|
|
|
missing_candidates = []
|
|
for candidate in cert_candidates:
|
|
candidate_path = Path(candidate)
|
|
if candidate_path.is_file():
|
|
run_kwargs["certfile"] = str(candidate_path)
|
|
run_kwargs["keyfile"] = str(key_path)
|
|
return run_kwargs
|
|
missing_candidates.append(str(candidate_path))
|
|
|
|
checked = ", ".join(missing_candidates)
|
|
raise RuntimeError(f"Engine TLS certificate file not found. Checked: {checked}")
|
|
|
|
|
|
def main() -> None:
|
|
config = _build_runtime_config()
|
|
mode = os.environ.get("BOREALIS_ENGINE_MODE", "production").strip().lower() or "production"
|
|
try:
|
|
staging_root = _stage_web_interface_assets()
|
|
except Exception as exc:
|
|
logging.getLogger("borealis.engine.bootstrap").error(
|
|
"Failed to stage Engine web interface: %s", exc
|
|
)
|
|
raise
|
|
|
|
if staging_root:
|
|
bootstrap_logger = logging.getLogger("borealis.engine.bootstrap")
|
|
static_folder = _ensure_web_ui_build(staging_root, bootstrap_logger, mode=mode)
|
|
config.setdefault("STATIC_FOLDER", static_folder)
|
|
|
|
app, socketio, context = create_app(config)
|
|
|
|
if staging_root:
|
|
context.logger.info("Engine WebUI assets ready at %s", config["STATIC_FOLDER"])
|
|
|
|
host = config.get("HOST", DEFAULT_HOST)
|
|
port = int(config.get("PORT", DEFAULT_PORT))
|
|
|
|
run_kwargs: Dict[str, Any] = {"host": host, "port": port}
|
|
try:
|
|
tls_kwargs = _prepare_tls_run_kwargs(context)
|
|
except RuntimeError as exc:
|
|
context.logger.error("TLS configuration error: %s", exc)
|
|
raise
|
|
else:
|
|
if tls_kwargs:
|
|
run_kwargs.update(tls_kwargs)
|
|
context.logger.info("Engine TLS enabled using certificate %s", tls_kwargs["certfile"])
|
|
|
|
socketio.run(app, **run_kwargs)
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover - manual launch helper
|
|
main()
|