新增火箭发射事件表与 Launch Library 同步,预置高频火箭型号

main
mula.liu 2026-10-08 01:57:17 +08:00
parent 05e1c02128
commit a19b78be3b
10 changed files with 888 additions and 0 deletions

View File

@ -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
# ======================

View File

@ -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

View File

@ -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

View File

@ -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)}

View File

@ -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)

View File

@ -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",
]

View File

@ -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"<RocketEvent(id={self.id}, name='{self.name}', net={self.net})>"

View File

@ -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

View File

@ -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

View File

@ -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 分发,