131 lines
3.8 KiB
Python
131 lines
3.8 KiB
Python
from __future__ import annotations
|
|
|
|
import argparse
|
|
import asyncio
|
|
import logging
|
|
import os
|
|
import signal
|
|
import sys
|
|
from contextlib import suppress
|
|
|
|
from hypercorn.asyncio import serve as hypercorn_serve
|
|
from hypercorn.config import Config as HypercornConfig
|
|
|
|
import repub.crawl as crawl_module
|
|
from repub.web import SHUTDOWN_EVENT_KEY, create_app
|
|
|
|
FeedNameFilter = crawl_module.FeedNameFilter
|
|
check_runtime = crawl_module.check_runtime
|
|
|
|
__all__ = ["FeedNameFilter", "check_runtime", "entrypoint", "parse_args"]
|
|
|
|
logger = logging.getLogger(__name__)
|
|
logger.setLevel(logging.DEBUG)
|
|
logger.propagate = False
|
|
if not logger.handlers:
|
|
handler = logging.StreamHandler()
|
|
handler.setLevel(logging.DEBUG)
|
|
handler.setFormatter(
|
|
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
|
|
)
|
|
logger.addHandler(handler)
|
|
|
|
|
|
def parse_args(argv: list[str] | None = None) -> tuple[str, argparse.Namespace]:
|
|
raw_args = list(argv) if argv is not None else sys.argv[1:]
|
|
|
|
parser = argparse.ArgumentParser(description="Mirror RSS and Atom feeds")
|
|
subparsers = parser.add_subparsers(dest="command")
|
|
|
|
serve_parser = subparsers.add_parser("serve", help="Start the republisher web UI")
|
|
serve_parser.add_argument(
|
|
"--host",
|
|
default=os.environ.get("REPUBLISHER_HOST", "127.0.0.1"),
|
|
help="Host interface for the web UI",
|
|
)
|
|
serve_parser.add_argument(
|
|
"--port",
|
|
default=os.environ.get("REPUBLISHER_PORT", "8080"),
|
|
help="Port for the web UI",
|
|
)
|
|
serve_parser.add_argument(
|
|
"--dev-mode",
|
|
action="store_true",
|
|
help="Serve published feeds from /feeds for local development",
|
|
)
|
|
|
|
crawl_parser = subparsers.add_parser("crawl", help="Run the feed crawler once")
|
|
crawl_parser.add_argument(
|
|
"-c",
|
|
"--config",
|
|
default="repub.toml",
|
|
help="Path to runtime config TOML file",
|
|
)
|
|
if not raw_args:
|
|
raw_args = ["serve", "--dev-mode"]
|
|
elif raw_args[0] in {"-c", "--config"}:
|
|
raw_args = ["crawl", *raw_args]
|
|
elif raw_args[0] not in {"serve", "crawl"}:
|
|
raw_args = ["serve", "--dev-mode", *raw_args]
|
|
|
|
args = parser.parse_args(raw_args)
|
|
command = args.command or "serve"
|
|
return command, args
|
|
|
|
|
|
def _install_signal_handlers(stop_event: asyncio.Event) -> None:
|
|
loop = asyncio.get_running_loop()
|
|
|
|
def request_stop(*_: object) -> None:
|
|
if not stop_event.is_set():
|
|
stop_event.set()
|
|
|
|
for signum in (signal.SIGINT, signal.SIGTERM):
|
|
try:
|
|
loop.add_signal_handler(signum, request_stop)
|
|
except NotImplementedError:
|
|
signal.signal(signum, request_stop)
|
|
|
|
|
|
async def _serve_app(*, host: str, port: int, dev_mode: bool) -> None:
|
|
stop_event = asyncio.Event()
|
|
_install_signal_handlers(stop_event)
|
|
|
|
app = create_app(dev_mode=dev_mode)
|
|
app.extensions[SHUTDOWN_EVENT_KEY] = stop_event
|
|
|
|
config = HypercornConfig()
|
|
config.bind = [f"{host}:{port}"]
|
|
config.use_reloader = False
|
|
config.accesslog = "-"
|
|
config.errorlog = "-"
|
|
|
|
async def shutdown_trigger() -> None:
|
|
await stop_event.wait()
|
|
|
|
try:
|
|
await hypercorn_serve(app, config, shutdown_trigger=shutdown_trigger)
|
|
finally:
|
|
stop_event.set()
|
|
|
|
|
|
def entrypoint(argv: list[str] | None = None) -> int:
|
|
command, args = parse_args(argv)
|
|
|
|
if command == "crawl":
|
|
crawl_module.check_runtime = check_runtime
|
|
return crawl_module.crawl_from_config(args.config)
|
|
|
|
try:
|
|
port = int(args.port)
|
|
except ValueError:
|
|
logger.error("Invalid REPUBLISHER_PORT/--port value: %s", args.port)
|
|
return 2
|
|
|
|
with suppress(KeyboardInterrupt):
|
|
asyncio.run(_serve_app(host=args.host, port=port, dev_mode=bool(args.dev_mode)))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(entrypoint())
|