ms-split-router 0.1.0__py3-none-any.whl

ms_split_router/__init__.py

@@ -0,0 +1,4 @@
+"""Generate systemd-networkd/systemd-resolved split-tunnel configuration from ms-cloud-endpoints data."""
+
+__version__ = "0.1.0"
+GENERATOR = "ms-split-router"

ms_split_router/__main__.py

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

ms_split_router/cli.py

@@ -0,0 +1,192 @@
+"""Command line entry point."""
+
+import argparse
+import logging
+import sys
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+from . import GENERATOR, __version__
+from .config import Config, ConfigError, load_config, with_ipv6
+from .data import DataError, PartialDataError, fetch_document, load_document
+from .discover import Discovery, DiscoveryError, describe_links
+from .generate import GenerateError, generate
+from .install import apply_changes, diff, plan_changes, reload_commands, run_commands
+
+log = logging.getLogger(GENERATOR)
+
+EXIT_OK = 0
+EXIT_ERROR = 1
+EXIT_USAGE = 2
+EXIT_PARTIAL = 3
+EXIT_CHANGES = 4
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=GENERATOR,
+        description=(
+            "Generate systemd-networkd and systemd-resolved per-link split-tunnel configuration for Microsoft "
+            "365, Entra and Azure from ms-cloud-endpoints data. Without -o/--install the files are printed."
+        ),
+    )
+    parser.add_argument("-c", "--config", type=Path, metavar="FILE", help="generator configuration (YAML)")
+
+    data = parser.add_mutually_exclusive_group()
+    data.add_argument("--data", type=Path, metavar="FILE", help="ms-cloud-endpoints JSON/YAML (overrides data.file)")
+    data.add_argument("--fetch", action="store_true", help="run ms-cloud-endpoints even if data.file is set")
+    parser.add_argument(
+        "--allow-partial",
+        action="store_true",
+        help="continue when the collector reports failed sources (exit code 3)",
+    )
+    parser.add_argument(
+        "--ipv6",
+        action=argparse.BooleanOptionalAction,
+        help="override routes.ipv6 on every split link: --ipv6 requires IPv6 routes (fails without an IPv6 gateway "
+        "or IPv6 data), --no-ipv6 leaves them out",
+    )
+
+    target = parser.add_mutually_exclusive_group()
+    target.add_argument("-o", "--output", type=Path, metavar="DIR", help="write the files as a tree under DIR")
+    target.add_argument("--install", action="store_true", help="write the files under --root (default /)")
+    parser.add_argument("--root", type=Path, default=Path("/"), metavar="DIR", help="root for --install/--diff/--check")
+    parser.add_argument("--prune", action="store_true", help="remove generated files that are no longer rendered")
+    parser.add_argument(
+        "--reload", action="store_true", help="after --install, reload networkd/resolved/udev as needed"
+    )
+    parser.add_argument("--diff", action="store_true", help="print a unified diff against the target tree")
+    parser.add_argument(
+        "--check", action="store_true", help=f"write nothing; exit {EXIT_CHANGES} if the target tree is out of date"
+    )
+    inspection = parser.add_mutually_exclusive_group()
+    inspection.add_argument("--show-links", action="store_true", help="list the links seen by 'ip' and exit")
+    inspection.add_argument(
+        "--print-example-config", action="store_true", help="print the bundled example configuration and exit"
+    )
+    parser.add_argument("-v", "--verbose", action="count", default=0, help="-v info, -vv debug logging on stderr")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def _configure_logging(verbosity: int) -> None:
+    level = logging.WARNING if verbosity == 0 else logging.INFO if verbosity == 1 else logging.DEBUG
+    logging.basicConfig(level=level, format="%(levelname)s: %(message)s", stream=sys.stderr)
+
+
+def _load_data(config: Config, args: argparse.Namespace) -> dict[str, Any]:
+    if args.data is not None:
+        return load_document(args.data)
+    if config.data.file is not None and not args.fetch:
+        return load_document(config.data.file)
+    try:
+        return fetch_document(config)
+    except PartialDataError as exc:
+        if not args.allow_partial:
+            raise
+        log.warning("%s; continuing (--allow-partial)", exc)
+        return exc.document
+
+
+def _is_system_root(root: Path) -> bool:
+    return root.resolve() == Path("/")
+
+
+def _print_files(files: list[Any]) -> None:
+    for index, file in enumerate(files):
+        if index:
+            sys.stdout.write("\n")
+        sys.stdout.write(f"### /{file.path}\n{file.content}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    _configure_logging(args.verbose)
+
+    try:
+        if args.print_example_config:
+            try:
+                example = resources.files("ms_split_router").joinpath("example_config.yaml").read_text(encoding="utf-8")
+            except OSError as exc:
+                log.error("cannot read bundled example configuration: %s", exc)
+                return EXIT_ERROR
+            sys.stdout.write(example)
+            return EXIT_OK
+        if args.show_links:
+            for line in describe_links(Discovery()):
+                print(line)
+            return EXIT_OK
+        if args.config is None:
+            parser.error("-c/--config is required")
+        if args.reload and not args.install:
+            parser.error("--reload requires --install")
+
+        config = load_config(args.config)
+        if args.ipv6 is not None:
+            config = with_ipv6(config, args.ipv6)
+        document = _load_data(config, args)
+        generated = generate(config, document)
+    except ConfigError as exc:
+        log.error("configuration error: %s", exc)
+        return EXIT_USAGE
+    except PartialDataError as exc:
+        log.error("%s (use --allow-partial to continue)", exc)
+        return EXIT_PARTIAL
+    except (DataError, DiscoveryError, GenerateError) as exc:
+        log.error("%s", exc)
+        return EXIT_ERROR
+
+    for link in generated.links:
+        log.info(
+            "%s: %d IPv4 routes via %s, %d IPv6 routes via %s, %d routing domains",
+            link.id,
+            link.ipv4_routes,
+            link.gateway4 or "-",
+            link.ipv6_routes,
+            link.gateway6 or "-",
+            len(link.domains),
+        )
+        if link.dropped_third_party:
+            log.info("%s: excluded third-party domains: %s", link.id, " ".join(link.dropped_third_party))
+
+    writing = args.output is not None or args.install
+    if not (writing or args.diff or args.check):
+        _print_files(generated.files)
+        return EXIT_OK
+
+    root = args.output if args.output is not None else args.root
+    try:
+        changes = plan_changes(generated.files, root, prune=args.prune)
+    except OSError as exc:
+        log.error("cannot read %s: %s", exc.filename or root, exc.strerror or exc)
+        return EXIT_ERROR
+    if args.diff:
+        sys.stdout.write(diff(changes, root))
+    if args.check:
+        for change in changes:
+            print(f"{change.action}: {root / change.path}", file=sys.stderr)
+        return EXIT_CHANGES if changes else EXIT_OK
+    if not writing:
+        return EXIT_OK
+
+    try:
+        apply_changes(changes, root)
+    except OSError as exc:
+        log.error("cannot write %s: %s", exc.filename or root, exc.strerror or exc)
+        return EXIT_ERROR
+    for change in changes:
+        print(f"{change.action}: {root / change.path}", file=sys.stderr)
+    if not changes:
+        print(f"{root}: up to date", file=sys.stderr)
+
+    if args.reload and changes:
+        if not _is_system_root(root):
+            log.warning("--reload skipped: --root is not /")
+        else:
+            failed = run_commands(reload_commands(changes, config))
+            if failed:
+                log.error("reload command(s) failed: %s", "; ".join(failed))
+                return EXIT_ERROR
+    return EXIT_OK