From a19b78be3b14d823b533d7527d457e352389768c Mon Sep 17 00:00:00 2001 From: "mula.liu" Date: Thu, 8 Oct 2026 01:57:17 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E7=81=AB=E7=AE=AD=E5=8F=91?= =?UTF-8?q?=E5=B0=84=E4=BA=8B=E4=BB=B6=E8=A1=A8=E4=B8=8E=20Launch=20Librar?= =?UTF-8?q?y=20=E5=90=8C=E6=AD=A5=EF=BC=8C=E9=A2=84=E7=BD=AE=E9=AB=98?= =?UTF-8?q?=E9=A2=91=E7=81=AB=E7=AE=AD=E5=9E=8B=E5=8F=B7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.production | 7 + backend/app/api/rocket_event.py | 133 ++++++++ backend/app/config.py | 5 + backend/app/jobs/predefined.py | 54 +++ backend/app/main.py | 9 + backend/app/models/db/__init__.py | 2 + backend/app/models/db/rocket_event.py | 56 ++++ backend/app/services/rocket_event_service.py | 305 +++++++++++++++++ backend/app/services/rocket_preset_service.py | 314 ++++++++++++++++++ docker-compose.yml | 3 + 10 files changed, 888 insertions(+) create mode 100644 backend/app/api/rocket_event.py create mode 100644 backend/app/models/db/rocket_event.py create mode 100644 backend/app/services/rocket_event_service.py create mode 100644 backend/app/services/rocket_preset_service.py diff --git a/.env.production b/.env.production index f558fc8..c4015e2 100644 --- a/.env.production +++ b/.env.production @@ -57,6 +57,13 @@ MAX_UPLOAD_SIZE=10485760 HTTP_PROXY=http://192.168.124.203:20171 HTTPS_PROXY=http://192.168.124.203:20171 +# ====================== +# Rocket Launch Events (The Space Devs Launch Library 2) +# ====================== +# 可选:在 https://awesome.space.nasaspaceflight.com/ 注册后申请令牌, +# 匿名同步有较严的速率限制,配置令牌后更宽松 +# LAUNCH_LIBRARY_TOKEN= + # ====================== # Data Path Configuration # ====================== diff --git a/backend/app/api/rocket_event.py b/backend/app/api/rocket_event.py new file mode 100644 index 0000000..7b5947c --- /dev/null +++ b/backend/app/api/rocket_event.py @@ -0,0 +1,133 @@ +"""火箭发射事件查询接口。""" +from datetime import datetime, timezone +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, Query, status +from pydantic import BaseModel, ConfigDict, Field +from sqlalchemy import func, select +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload + +from app.database import get_db +from app.models.db import RocketConfig, RocketEvent + + +router = APIRouter(prefix="/rocket-events", tags=["rocket-events"]) + +RocketCodeFilter = Annotated[str | None, Query(description="按本地型号 code 过滤,例如 falcon-9")] + + +class RocketBrief(BaseModel): + code: str + name: str + name_zh: str | None = None + + model_config = ConfigDict(from_attributes=True) + + +class RocketEventResponse(BaseModel): + id: int + source: str + source_id: str + name: str + mission_name: str | None = None + mission_description: str | None = None + mission_type: str | None = None + rocket_name: str | None = None + provider: str | None = None + orbit: str | None = None + launch_site_name: str | None = None + location_name: str | None = None + latitude: float | None = None + longitude: float | None = None + net: datetime + status: str + image_url: str | None = None + source_url: str | None = None + rocket: RocketBrief | None = None + + model_config = ConfigDict(from_attributes=True) + + +class RocketEventPage(BaseModel): + events: list[RocketEventResponse] + total: int = Field(description="符合过滤条件的总条数") + + +@router.get("", response_model=RocketEventPage) +async def list_rocket_events( + db: AsyncSession = Depends(get_db), + rocket_code: RocketCodeFilter = None, + upcoming: Annotated[bool | None, Query(description="true 只看未发射(按时间升序);false 只看已飞完;不传为全部")] = None, + start: Annotated[datetime | None, Query(description="发射时间下界(UTC)")] = None, + end: Annotated[datetime | None, Query(description="发射时间上界(UTC)")] = None, + search: Annotated[str | None, Query(description="按任务名 / 型号 / 发射场模糊搜索")] = None, + limit: int = Query(20, ge=1, le=100), + offset: int = Query(0, ge=0), +): + now = datetime.now(timezone.utc).replace(tzinfo=None) + + filters = [] + if upcoming is True: + filters.append(RocketEvent.net >= now) + elif upcoming is False: + filters.append(RocketEvent.net < now) + if start: + filters.append(RocketEvent.net >= start) + if end: + filters.append(RocketEvent.net < end) + if rocket_code: + filters.append(RocketConfig.code == rocket_code.lower()) + if search: + keyword = f"%{search.strip()}%" + filters.append( + RocketEvent.name.ilike(keyword) + | RocketEvent.rocket_name.ilike(keyword) + | RocketEvent.location_name.ilike(keyword) + ) + + total = await db.scalar( + select(func.count(RocketEvent.id)) + .join(RocketConfig, RocketConfig.id == RocketEvent.rocket_config_id, isouter=True) + .where(*filters) + ) + order = RocketEvent.net.asc() if upcoming is True else RocketEvent.net.desc() + result = await db.execute( + select(RocketEvent) + .options(selectinload(RocketEvent.rocket)) + .join(RocketConfig, RocketConfig.id == RocketEvent.rocket_config_id, isouter=True) + .where(*filters) + .order_by(order, RocketEvent.id) + .offset(offset) + .limit(limit) + ) + return RocketEventPage( + events=[RocketEventResponse.model_validate(item) for item in result.scalars().all()], + total=total or 0, + ) + + +@router.get("/stats", response_model=dict) +async def rocket_event_stats(db: AsyncSession = Depends(get_db)): + """总量、未发射数量、数据源最近一次同步时间。""" + now = datetime.now(timezone.utc).replace(tzinfo=None) + total = await db.scalar(select(func.count(RocketEvent.id))) + upcoming_count = await db.scalar( + select(func.count(RocketEvent.id)).where(RocketEvent.net >= now) + ) + last_synced = await db.scalar(select(func.max(RocketEvent.updated_at))) + return { + "total": total or 0, + "upcoming": upcoming_count or 0, + "last_synced_at": last_synced, + } + + +@router.get("/{event_id}", response_model=RocketEventResponse) +async def get_rocket_event(event_id: int, db: AsyncSession = Depends(get_db)): + event = (await db.execute( + select(RocketEvent).options(selectinload(RocketEvent.rocket)).where(RocketEvent.id == event_id) + )).scalar_one_or_none() + if not event: + raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Rocket event not found") + return event diff --git a/backend/app/config.py b/backend/app/config.py index 7c7e485..12bb2e3 100644 --- a/backend/app/config.py +++ b/backend/app/config.py @@ -64,6 +64,11 @@ class Settings(BaseSettings): terminal_pair_code_ttl_seconds: int = 60 * 10 # pairing code validity terminal_token_expire_days: int = 365 # long lived terminal token lifetime + # 火箭发射事件数据源:The Space Devs Launch Library 2 + launch_library_api_base: str = "https://ll.thespacedevs.com/2.2.0" + launch_library_token: str = "" # 可选,注册后速率限制更宽松 + launch_library_timeout: int = 30 + # File upload settings upload_dir: str = "upload" max_upload_size: int = 10485760 # 10MB diff --git a/backend/app/jobs/predefined.py b/backend/app/jobs/predefined.py index a6deacf..068426a 100644 --- a/backend/app/jobs/predefined.py +++ b/backend/app/jobs/predefined.py @@ -17,6 +17,7 @@ from app.services.horizons import HorizonsService from app.services.nasa_sbdb_service import nasa_sbdb_service from app.services.event_service import event_service from app.services.planetary_events_service import planetary_events_service +from app.services import rocket_event_service logger = logging.getLogger(__name__) @@ -630,3 +631,56 @@ async def calculate_planetary_events( "total_events_saved": total_events_saved, "total_events_failed": total_events_failed } + + +@task_registry.register( + name="sync_rocket_launch_events", + description="从 The Space Devs Launch Library 2 获取全球火箭发射排期与结果,写入 rocket_events 并关联本地火箭型号", + category="data_sync", + parameters=[ + { + "name": "max_pages", + "type": "integer", + "description": "最多翻几页(每页按发射时间升序,1 页约等于 1~2 个月的排期)", + "required": False, + "default": 2 + }, + { + "name": "page_size", + "type": "integer", + "description": "每页条数,数据源上限 100", + "required": False, + "default": 100 + }, + { + "name": "days_ahead", + "type": "integer", + "description": "只保留发射时间在 N 天之内的记录", + "required": False, + "default": 90 + } + ] +) +async def sync_rocket_launch_events( + db: AsyncSession, + logger: logging.Logger, + params: Dict[str, Any] +) -> Dict[str, Any]: + """Sync global rocket launch events and link them to rocket_configs.""" + max_pages = int(params.get("max_pages", 2)) + page_size = int(params.get("page_size", 100)) + days_ahead = int(params.get("days_ahead", 90)) + + logger.info(f"Starting rocket launch event sync: max_pages={max_pages}, " + f"page_size={page_size}, days_ahead={days_ahead}") + try: + return await rocket_event_service.sync_launch_events( + db, max_pages=max_pages, page_size=page_size, days_ahead=days_ahead, log=logger + ) + except rocket_event_service.LaunchSourceThrottled as e: + logger.warning(f"Rocket launch event sync throttled: {e}") + return {"success": False, "error": str(e), "retry_after_seconds": e.retry_after_seconds} + except Exception as e: + logger.error(f"Rocket launch event sync failed: {e}") + await db.rollback() + return {"success": False, "error": str(e)} diff --git a/backend/app/main.py b/backend/app/main.py index 96a2263..0fbbfbc 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -35,6 +35,7 @@ from app.api.scheduled_job import router as scheduled_job_router from app.api.social import router as social_router # Import social_router from app.api.event import router as event_router # Import event_router from app.api.rocket import router as rocket_router +from app.api.rocket_event import router as rocket_event_router from app.api.terminal import router as terminal_router from app.api.device import router as device_router from app.services.redis_cache import redis_cache @@ -81,10 +82,17 @@ async def lifespan(app: FastAPI): # Initialize default system settings from app.database import AsyncSessionLocal from app.services.system_settings_service import system_settings_service + from app.services.rocket_preset_service import ensure_high_frequency_rockets + from app.services.rocket_event_service import ensure_launch_event_job async with AsyncSessionLocal() as db: await system_settings_service.initialize_default_settings(db) + # 预置高频发射火箭型号 + 发射事件同步定时任务 + added_rockets = await ensure_high_frequency_rockets(db) + await ensure_launch_event_job(db) await db.commit() logger.info("✓ Default system settings initialized") + if added_rockets: + logger.info(f"✓ Rocket presets added: {', '.join(added_rockets)}") # Preheat caches (load from database to Redis) await preheat_all_caches() @@ -191,6 +199,7 @@ app.include_router(scheduled_job_router, prefix=settings.api_prefix) app.include_router(social_router, prefix=settings.api_prefix) app.include_router(event_router, prefix=settings.api_prefix) # Added event_router app.include_router(rocket_router, prefix=settings.api_prefix) +app.include_router(rocket_event_router, prefix=settings.api_prefix) # ESP32 terminal: pairing + device management app.include_router(terminal_router, prefix=settings.api_prefix) diff --git a/backend/app/models/db/__init__.py b/backend/app/models/db/__init__.py index b30d80c..2f095c7 100644 --- a/backend/app/models/db/__init__.py +++ b/backend/app/models/db/__init__.py @@ -16,6 +16,7 @@ from .task import Task from .user_follow import UserFollow from .celestial_event import CelestialEvent from .rocket import RocketConfig +from .rocket_event import RocketEvent from .terminal_device import TerminalDevice __all__ = [ @@ -36,5 +37,6 @@ __all__ = [ "UserFollow", "CelestialEvent", "RocketConfig", + "RocketEvent", "TerminalDevice", ] diff --git a/backend/app/models/db/rocket_event.py b/backend/app/models/db/rocket_event.py new file mode 100644 index 0000000..746f5c8 --- /dev/null +++ b/backend/app/models/db/rocket_event.py @@ -0,0 +1,56 @@ +"""Rocket launch event ORM model.""" +from sqlalchemy import ( + Column, Double, ForeignKey, Integer, String, Text, TIMESTAMP, UniqueConstraint, +) +from sqlalchemy.sql import func +from sqlalchemy.orm import relationship + +from app.database import Base + + +class RocketEvent(Base): + """一次真实的火箭发射事件(来自外部持续更新的发射计划数据源)。 + + 与 rocket_configs 的关系:rocket_config_id 指向本地建模的运载型号, + 数据源里那些本地还没建模的型号该字段为空,型号原名仍保留在 rocket_name。 + 时间一律为无时区 UTC,和库里其它时间字段一致。 + """ + + __tablename__ = "rocket_events" + + id = Column(Integer, primary_key=True, autoincrement=True) + source = Column(String(32), nullable=False, default="thespacedevs", comment="数据源标识") + source_id = Column(String(64), nullable=False, comment="数据源侧的发射 ID") + rocket_config_id = Column( + Integer, ForeignKey("rocket_configs.id", ondelete="SET NULL"), nullable=True, index=True, + ) + + name = Column(String(200), nullable=False, comment="发射任务标题") + mission_name = Column(String(200), nullable=True) + mission_description = Column(Text, nullable=True) + mission_type = Column(String(60), nullable=True) + rocket_name = Column(String(120), nullable=True, comment="数据源侧运载火箭型号名") + provider = Column(String(120), nullable=True, comment="发射服务商") + orbit = Column(String(60), nullable=True) + + launch_site_name = Column(String(120), nullable=True, comment="发射工位") + location_name = Column(String(120), nullable=True, comment="发射场") + latitude = Column(Double, nullable=True) + longitude = Column(Double, nullable=True) + + net = Column(TIMESTAMP, nullable=False, index=True, comment="发射时间 T-0(UTC)") + status = Column(String(40), nullable=False, default="", comment="发射状态") + image_url = Column(String(500), nullable=True) + source_url = Column(String(300), nullable=True) + + created_at = Column(TIMESTAMP, server_default=func.now()) + updated_at = Column(TIMESTAMP, server_default=func.now(), onupdate=func.now()) + + __table_args__ = ( + UniqueConstraint("source", "source_id", name="uq_rocket_events_source_id"), + ) + + rocket = relationship("RocketConfig", foreign_keys=[rocket_config_id]) + + def __repr__(self): + return f"" diff --git a/backend/app/services/rocket_event_service.py b/backend/app/services/rocket_event_service.py new file mode 100644 index 0000000..40c9748 --- /dev/null +++ b/backend/app/services/rocket_event_service.py @@ -0,0 +1,305 @@ +"""全球火箭发射事件同步。 + +数据源:The Space Devs 的 Launch Library 2(https://ll.thespacedevs.com)。 +`/launch/upcoming/` 按发射时间升序返回正在排期与刚刚飞完的发射,含最终结果状态, +因此一次同步既能拿到未来的排期,也能把已飞完任务的状态改写为成功/失败。 +(同源的 /launch/past/ 目前会返回 500,历史回填不可用。) + +匿名调用有较严的速率限制,未配置 LAUNCH_LIBRARY_TOKEN 时按每 6 小时一次的 +默认频率同步;申请令牌后填进 .env 即可放宽。 +""" +import asyncio +import logging +from collections import Counter +from datetime import datetime, timedelta, timezone +from typing import Any + +import httpx +from sqlalchemy import select +from sqlalchemy.dialects.postgresql import insert +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.sql import func + +from app.config import settings +from app.models.db import RocketConfig, RocketEvent +from app.models.db.scheduled_job import JobType, ScheduledJob + +logger = logging.getLogger(__name__) + +SOURCE = "thespacedevs" +USER_AGENT = "cosmo-backend/1.0 (+https://cosmo.unisspace.com)" +DEFAULT_CRON = "20 */6 * * *" # 每 6 小时一次 +DEFAULT_JOB_NAME = "同步全球火箭发射事件" + +# 数据源型号名(小写、空格分隔)→ 本地 rocket_configs.code。 +# 源里同一型号有大量变体(Falcon 9 Block 5 / Long March 5B / Soyuz 2.1b ...), +# 先试完整型号名,再退化到主干名,最后靠 code/name 直接匹配。 +LAUNCHER_ALIASES: dict[str, str] = { + "falcon 9": "falcon-9", + "falcon 9 block 5": "falcon-9", + "falcon heavy": "falcon-heavy", + "starship": "starship", + "electron": "electron", + "electron hk": "electron", + "long march 2f": "long-march-2f", + "long march 7": "long-march-7", + "long march 7a": "long-march-7", + "long march 5": "long-march-5", + "long march 5b": "long-march-5", + "long march 6a": "long-march-6a", + "long march 8": "long-march-8", + "long march 8a": "long-march-8", + "long march 8b": "long-march-8", + "ariane 62": "ariane-6", + "ariane 64": "ariane-6", + "soyuz 2": "soyuz-2", + "soyuz 2.1a": "soyuz-2", + "soyuz 2.1b": "soyuz-2", +} + + +class LaunchSourceError(Exception): + """数据源不可用。""" + + +class LaunchSourceThrottled(LaunchSourceError): + """数据源限流(HTTP 429)。""" + + def __init__(self, retry_after_seconds: int | None = None): + super().__init__(f"数据源限流,{retry_after_seconds} 秒后可重试" + if retry_after_seconds else "数据源限流") + self.retry_after_seconds = retry_after_seconds + + +def _normalize(text: str | None) -> str: + return " ".join((text or "").lower().replace("-", " ").replace("_", " ").split()) + + +def _parse_net(value: str | None) -> datetime | None: + """Launch Library 的时间是 `2026-10-08T07:54:00Z`,统一存成无时区 UTC。""" + if not value: + return None + try: + parsed = datetime.fromisoformat(value.replace("Z", "+00:00")) + except ValueError: + return None + if parsed.tzinfo is not None: + parsed = parsed.astimezone(timezone.utc).replace(tzinfo=None) + return parsed + + +def _clip(value: str | None, size: int) -> str | None: + return value[:size] if value else None + + +def _to_float(value: Any) -> float | None: + try: + return float(value) + except (TypeError, ValueError): + return None + + +async def build_rocket_lookup(db: AsyncSession) -> dict[str, int]: + """把本地型号按 code / 英文名 / 中文名登记成查找表,再叠加内置别名。""" + rows = (await db.execute( + select(RocketConfig.id, RocketConfig.code, RocketConfig.name, RocketConfig.name_zh) + )).all() + + lookup: dict[str, int] = {} + by_code: dict[str, int] = {} + for rocket_id, code, name, name_zh in rows: + for key in (code, name, name_zh): + normalized = _normalize(key) + if normalized: + lookup.setdefault(normalized, rocket_id) + by_code[_normalize(code)] = rocket_id + + for alias, code in LAUNCHER_ALIASES.items(): + rocket_id = by_code.get(_normalize(code)) + if rocket_id is not None: + lookup.setdefault(alias, rocket_id) + return lookup + + +def match_rocket(lookup: dict[str, int], configuration: dict) -> int | None: + """按 full_name → name+variant → name → family 依次尝试匹配本地型号。""" + name = (configuration.get("name") or "").strip() + variant = (configuration.get("variant") or "").strip() + candidates = [ + configuration.get("full_name"), + f"{name} {variant}" if name and variant else None, + name, + configuration.get("family"), + ] + for candidate in candidates: + rocket_id = lookup.get(_normalize(candidate)) + if rocket_id is not None: + return rocket_id + return None + + +def parse_launch(item: dict, lookup: dict[str, int]) -> dict | None: + """把源侧一条发射记录转成 rocket_events 的字段。""" + source_id = str(item.get("id") or "").strip() + net = _parse_net(item.get("net")) + if not source_id or net is None: + return None + + configuration = (item.get("rocket") or {}).get("configuration") or {} + mission = item.get("mission") or {} + pad = item.get("pad") or {} + location = pad.get("location") or {} + mission_name = mission.get("name") if isinstance(mission.get("name"), str) else None + + return { + "source": SOURCE, + "source_id": _clip(source_id, 64), + "rocket_config_id": match_rocket(lookup, configuration), + "name": _clip(item.get("name") or mission_name or source_id, 200), + "mission_name": _clip(mission_name, 200), + "mission_description": _clip(mission.get("description"), 4000), + "mission_type": _clip(mission.get("type"), 60), + "rocket_name": _clip(configuration.get("full_name") or configuration.get("name"), 120), + "provider": _clip((item.get("launch_service_provider") or {}).get("name"), 120), + "orbit": _clip((mission.get("orbit") or {}).get("name") if isinstance(mission.get("orbit"), dict) else None, 60), + "launch_site_name": _clip(pad.get("name"), 120), + "location_name": _clip(location.get("name"), 120), + "latitude": _to_float(pad.get("latitude")), + "longitude": _to_float(pad.get("longitude")), + "net": net, + "status": _clip((item.get("status") or {}).get("name"), 40) or "", + "image_url": _clip(item.get("image"), 500), + "source_url": _clip(item.get("url"), 300), + } + + +async def _get_page(client: httpx.AsyncClient, base: str, params: dict) -> dict: + response = await client.get(f"{base}/launch/upcoming/", params=params) + if response.status_code == 429: + retry_after = None + try: + retry_after = int(response.headers.get("Retry-After")) + except (TypeError, ValueError): + pass + raise LaunchSourceThrottled(retry_after) + try: + response.raise_for_status() + except httpx.HTTPStatusError as exc: + raise LaunchSourceError(f"数据源返回 {exc.response.status_code}") from exc + return response.json() + + +async def fetch_launches(max_pages: int, page_size: int) -> list[dict]: + """拉取未来排期(含刚飞完的),按发射时间升序。""" + headers = {"User-Agent": USER_AGENT, "accept": "application/json"} + if settings.launch_library_token: + headers["Authorization"] = f"Token {settings.launch_library_token}" + + client_kwargs: dict[str, Any] = { + "headers": headers, + "timeout": settings.launch_library_timeout, + } + if settings.proxy_dict: + client_kwargs["proxies"] = settings.proxy_dict + + items: list[dict] = [] + async with httpx.AsyncClient(**client_kwargs) as client: + for page in range(max_pages): + payload = await _get_page(client, settings.launch_library_api_base, + {"limit": page_size, "offset": page * page_size}) + results = payload.get("results") or [] + items.extend(results) + if len(results) < page_size or not payload.get("next"): + break + await asyncio.sleep(1.5) # 别连续压同一个匿名 IP + return items + + +async def sync_launch_events( + db: AsyncSession, + *, + max_pages: int = 2, + page_size: int = 100, + days_ahead: int = 90, + log: logging.Logger | None = None, +) -> dict[str, Any]: + """同步发射事件并按型号关联 rocket_configs,返回本次统计。""" + log = log or logger + horizon = datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(days=days_ahead) + + items = await fetch_launches(min(max_pages, 5), min(page_size, 100)) + lookup = await build_rocket_lookup(db) + + rows = [] + unmapped: Counter[str] = Counter() + for item in items: + values = parse_launch(item, lookup) + if values is None or values["net"] > horizon: + continue + if values["rocket_config_id"] is None and values["rocket_name"]: + unmapped[values["rocket_name"]] += 1 + rows.append(values) + + known = set() + if rows: + batch = [r["source_id"] for r in rows] + for start in range(0, len(batch), 500): + result = await db.execute( + select(RocketEvent.source_id).where( + RocketEvent.source == SOURCE, + RocketEvent.source_id.in_(batch[start:start + 500]), + ) + ) + known.update(result.scalars().all()) + + mutable = ( + "rocket_config_id", "name", "mission_name", "mission_description", "mission_type", + "rocket_name", "provider", "orbit", "launch_site_name", "location_name", + "latitude", "longitude", "net", "status", "image_url", "source_url", + ) + for values in rows: + statement = insert(RocketEvent).values(**values) + statement = statement.on_conflict_do_update( + index_elements=["source", "source_id"], + set_={key: values[key] for key in mutable} | {"updated_at": func.now()}, + ) + await db.execute(statement) + await db.commit() + + unmapped_ranking = [{"rocket": name, "count": count} for name, count in unmapped.most_common(10)] + summary = { + "success": True, + "source": SOURCE, + "fetched": len(items), + "stored": len(rows), + "created": len(rows) - len(known), + "updated": len(known), + "mapped": sum(1 for r in rows if r["rocket_config_id"] is not None), + "horizon": horizon.isoformat(), + "unmapped_rockets": unmapped_ranking, + } + log.info("火箭发射事件同步:拉取 %s 条,写入 %s 条(新增 %s,更新 %s),型号已关联 %s 条", + summary["fetched"], summary["stored"], summary["created"], summary["updated"], summary["mapped"]) + return summary + + +async def ensure_launch_event_job(db: AsyncSession) -> bool: + """保证默认同步任务存在;已存在则不动管理端改过的频率与参数。""" + existing = (await db.execute( + select(ScheduledJob.id).where(ScheduledJob.predefined_function == "sync_rocket_launch_events") + )).scalar_one_or_none() + if existing: + return False + + db.add(ScheduledJob( + name=DEFAULT_JOB_NAME, + job_type=JobType.PREDEFINED, + predefined_function="sync_rocket_launch_events", + function_params={"max_pages": 2, "page_size": 100, "days_ahead": 90}, + cron_expression=DEFAULT_CRON, + is_active=True, + description="从 The Space Devs Launch Library 2 获取全球火箭发射排期与结果,并关联本地火箭型号", + )) + await db.flush() + logger.info("已创建默认定时任务:%s(%s)", DEFAULT_JOB_NAME, DEFAULT_CRON) + return True diff --git a/backend/app/services/rocket_preset_service.py b/backend/app/services/rocket_preset_service.py new file mode 100644 index 0000000..32e0641 --- /dev/null +++ b/backend/app/services/rocket_preset_service.py @@ -0,0 +1,314 @@ +"""高频运载火箭型号预置。 + +发射事件按型号关联到 rocket_configs,因此模拟器和事件列表里应当总有当下发射 +最频繁的型号。这里登记一批公开资料里的型号参数,启动时按 code 补齐缺失项: +已存在的型号一律不动(管理端改过的参数以管理端为准),被删掉的型号会在下次 +启动时重新补上(与默认系统设置的行为一致)。 + +stage_1 沿用库里既有约定:捆绑助推器的发动机数量与推力并入一级登记 +(长征五号 10 台 = 芯级 2 台 + 4 个助推器各 2 台)。 +""" +import logging +from typing import Any + +from sqlalchemy import func, select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.models.db import RocketConfig + +logger = logging.getLogger(__name__) + +HIGH_FREQUENCY_ROCKETS: list[dict[str, Any]] = [ + { + "code": "starship", + "name": "Starship", + "name_zh": "星舰", + "manufacturer": "SpaceX", + "country": "美国", + "launch_site_name": "Starbase 星港", + "launch_latitude_deg": 25.9972, + "launch_longitude_deg": -97.1575, + "description": "两级完全可重复使用超重型运载火箭,一级为超重型助推器(33 台猛禽),二级为星舰飞船。", + "color": "#c9ced4", + "height_m": 122.5, + "diameter_m": 9.0, + "payload_mass_kg": 100000, + "drag_coefficient": 0.45, + "reference_area_m2": 63.62, + "target_orbit_km": 400, + "target_velocity_mps": 7800, + "separation_delay_seconds": 1.0, + "second_stage_ignition_delay_seconds": 0.6, + "stage_1": { + "name": "超重型助推器", + "dry_mass_kg": 240000, + "fuel_mass_kg": 3400000, + "max_thrust_n": 72000000, + "specific_impulse_s": 327, + "engine_count": 33, + "length_ratio": 0.58, + }, + "stage_2": { + "name": "星舰飞船", + "dry_mass_kg": 120000, + "fuel_mass_kg": 1200000, + "max_thrust_n": 13800000, + "specific_impulse_s": 350, + "engine_count": 6, + "length_ratio": 0.42, + }, + }, + { + "code": "electron", + "name": "Electron", + "name_zh": "电子号", + "manufacturer": "Rocket Lab", + "country": "新西兰", + "launch_site_name": "LC-1 马希亚发射场", + "launch_latitude_deg": -39.2618, + "launch_longitude_deg": -177.864, + "description": "小型液体运载火箭,一级 9 台卢瑟福发动机电动泵压循环,用于小卫星专属与拼车发射。", + "color": "#242a30", + "height_m": 33.0, + "diameter_m": 1.2, + "payload_mass_kg": 300, + "drag_coefficient": 0.35, + "reference_area_m2": 1.13, + "target_orbit_km": 500, + "target_velocity_mps": 7600, + "separation_delay_seconds": 2.0, + "second_stage_ignition_delay_seconds": 1.0, + "stage_1": { + "name": "一级(9 台卢瑟福)", + "dry_mass_kg": 1100, + "fuel_mass_kg": 8900, + "max_thrust_n": 189000, + "specific_impulse_s": 319, + "engine_count": 9, + "length_ratio": 0.66, + }, + "stage_2": { + "name": "二级(真空卢瑟福)", + "dry_mass_kg": 200, + "fuel_mass_kg": 700, + "max_thrust_n": 19600, + "specific_impulse_s": 339, + "engine_count": 1, + "length_ratio": 0.34, + }, + }, + { + "code": "long-march-2f", + "name": "Long March 2F", + "name_zh": "长征二号F", + "manufacturer": "中国运载火箭技术研究院", + "country": "中国", + "launch_site_name": "酒泉卫星发射中心", + "launch_latitude_deg": 40.958, + "launch_longitude_deg": 100.291, + "description": "带四个液体助推器的两级载人运载火箭,用于神舟载人飞船与空间实验室任务。", + "color": "#eef1f5", + "height_m": 58.34, + "diameter_m": 3.35, + "payload_mass_kg": 8150, + "drag_coefficient": 0.4, + "reference_area_m2": 8.81, + "target_orbit_km": 400, + "target_velocity_mps": 7670, + "separation_delay_seconds": 2.5, + "second_stage_ignition_delay_seconds": 1.2, + "stage_1": { + "name": "芯一级与四个助推器", + "dry_mass_kg": 50000, + "fuel_mass_kg": 340000, + "max_thrust_n": 5958000, + "specific_impulse_s": 264, + "engine_count": 8, + "length_ratio": 0.6, + }, + "stage_2": { + "name": "芯二级(YF-24B)", + "dry_mass_kg": 5000, + "fuel_mass_kg": 55000, + "max_thrust_n": 720000, + "specific_impulse_s": 315, + "engine_count": 1, + "length_ratio": 0.4, + }, + }, + { + "code": "long-march-7", + "name": "Long March 7", + "name_zh": "长征七号", + "manufacturer": "中国运载火箭技术研究院", + "country": "中国", + "launch_site_name": "文昌航天发射场", + "launch_latitude_deg": 19.6145, + "launch_longitude_deg": 110.951, + "description": "4 米级液氧煤油中型运载火箭,四个助推器各两台 YF-100,用于天舟货运飞船等高频次发射。", + "color": "#e6ebf1", + "height_m": 53.1, + "diameter_m": 3.35, + "payload_mass_kg": 13800, + "drag_coefficient": 0.4, + "reference_area_m2": 8.81, + "target_orbit_km": 400, + "target_velocity_mps": 7670, + "separation_delay_seconds": 2.5, + "second_stage_ignition_delay_seconds": 1.2, + "stage_1": { + "name": "芯一级与四个助推器(10 台 YF-100)", + "dry_mass_kg": 40000, + "fuel_mass_kg": 470000, + "max_thrust_n": 7200000, + "specific_impulse_s": 300, + "engine_count": 10, + "length_ratio": 0.62, + }, + "stage_2": { + "name": "芯二级(2 台 YF-115)", + "dry_mass_kg": 3000, + "fuel_mass_kg": 40000, + "max_thrust_n": 360000, + "specific_impulse_s": 334, + "engine_count": 2, + "length_ratio": 0.38, + }, + }, + { + "code": "long-march-6a", + "name": "Long March 6A", + "name_zh": "长征六号甲", + "manufacturer": "上海航天技术研究院", + "country": "中国", + "launch_site_name": "太原卫星发射中心", + "launch_latitude_deg": 38.846, + "launch_longitude_deg": 111.608, + "description": "液氧煤油芯级捆绑四台固体助推器的中型运载火箭,面向太阳同步轨道高频次拼车发射。", + "color": "#e9eef4", + "height_m": 50.5, + "diameter_m": 3.35, + "payload_mass_kg": 6500, + "drag_coefficient": 0.4, + "reference_area_m2": 8.81, + "target_orbit_km": 500, + "target_velocity_mps": 7600, + "separation_delay_seconds": 2.2, + "second_stage_ignition_delay_seconds": 1.0, + "stage_1": { + "name": "芯一级与四台固体助推器", + "dry_mass_kg": 45000, + "fuel_mass_kg": 405000, + "max_thrust_n": 6400000, + "specific_impulse_s": 285, + "engine_count": 10, + "length_ratio": 0.6, + }, + "stage_2": { + "name": "二级(2 台 YF-115)", + "dry_mass_kg": 3000, + "fuel_mass_kg": 40000, + "max_thrust_n": 360000, + "specific_impulse_s": 334, + "engine_count": 2, + "length_ratio": 0.4, + }, + }, + { + "code": "long-march-8", + "name": "Long March 8", + "name_zh": "长征八号", + "manufacturer": "中国运载火箭技术研究院", + "country": "中国", + "launch_site_name": "文昌航天发射场", + "launch_latitude_deg": 19.6145, + "launch_longitude_deg": 110.951, + "description": "两级液氧煤油中型运载火箭,捆绑两个助推器,主打太阳同步轨道商业星座发射。", + "color": "#e6ebf1", + "height_m": 50.4, + "diameter_m": 3.35, + "payload_mass_kg": 7600, + "drag_coefficient": 0.4, + "reference_area_m2": 8.81, + "target_orbit_km": 500, + "target_velocity_mps": 7600, + "separation_delay_seconds": 2.2, + "second_stage_ignition_delay_seconds": 1.0, + "stage_1": { + "name": "芯一级与两个助推器(6 台 YF-100)", + "dry_mass_kg": 38000, + "fuel_mass_kg": 380000, + "max_thrust_n": 7194000, + "specific_impulse_s": 300, + "engine_count": 6, + "length_ratio": 0.6, + }, + "stage_2": { + "name": "二级(2 台 YF-115)", + "dry_mass_kg": 3500, + "fuel_mass_kg": 55000, + "max_thrust_n": 360000, + "specific_impulse_s": 334, + "engine_count": 2, + "length_ratio": 0.4, + }, + }, + { + "code": "falcon-heavy", + "name": "Falcon Heavy", + "name_zh": "猎鹰重型", + "manufacturer": "SpaceX", + "country": "美国", + "launch_site_name": "LC-39A 肯尼迪航天中心", + "launch_latitude_deg": 28.6083, + "launch_longitude_deg": -80.6041, + "description": "三枚猎鹰 9 一芯级并联的重型运载火箭;载荷按三芯级回收构型登记(一次性构型约 63.8 吨)。", + "color": "#f8fafc", + "height_m": 70.0, + "diameter_m": 3.7, + "payload_mass_kg": 27700, + "drag_coefficient": 0.4, + "reference_area_m2": 10.75, + "target_orbit_km": 200, + "target_velocity_mps": 7800, + "separation_delay_seconds": 2.2, + "second_stage_ignition_delay_seconds": 1.0, + "stage_1": { + "name": "三芯级(27 台梅林 1D)", + "dry_mass_kg": 76800, + "fuel_mass_kg": 1233000, + "max_thrust_n": 22821000, + "specific_impulse_s": 282, + "engine_count": 27, + "length_ratio": 0.65, + }, + "stage_2": { + "name": "二级(梅林真空型)", + "dry_mass_kg": 4000, + "fuel_mass_kg": 107500, + "max_thrust_n": 981000, + "specific_impulse_s": 348, + "engine_count": 1, + "length_ratio": 0.35, + }, + }, +] + + +async def ensure_high_frequency_rockets(db: AsyncSession) -> list[str]: + """补齐缺失的高频型号,返回新入库的 code 列表。""" + existing = set((await db.execute(select(RocketConfig.code))).scalars().all()) + next_order = (await db.scalar(select(func.max(RocketConfig.sort_order)))) or 0 + + added: list[str] = [] + for preset in HIGH_FREQUENCY_ROCKETS: + if preset["code"] in existing: + continue + next_order += 1 + db.add(RocketConfig(**preset, sort_order=next_order)) + added.append(preset["code"]) + + if added: + await db.flush() + logger.info("火箭型号预置补齐:%s", ", ".join(added)) + return added diff --git a/docker-compose.yml b/docker-compose.yml index 9119e08..382278e 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -85,6 +85,9 @@ services: # Proxy (for accessing NASA JPL Horizons API) HTTP_PROXY: ${HTTP_PROXY:-} HTTPS_PROXY: ${HTTPS_PROXY:-} + # 火箭发射事件数据源(The Space Devs Launch Library 2) + # 匿名也能同步,注册令牌后速率限制更宽松 + LAUNCH_LIBRARY_TOKEN: ${LAUNCH_LIBRARY_TOKEN:-} volumes: - /opt/cosmo/data/upload:/app/upload # 仓库内置资源(火箭模拟的昼/夜地球贴图、滴答音效)随 git 分发,