Navaid¶

def ddr_source(config: TangramNavaidConfig) -> Source:
    return Source(
        "ddr",
        "ddr",
        config.ddr_archive_url,
        ".zip",
        "application/zip",
    )

def xplane_source(config: TangramNavaidConfig, dataset: XplaneDataset) -> Source:
    if dataset == "nav":
        url = config.xplane.nav_url
    elif dataset == "fix":
        url = config.xplane.fix_url
    else:
        url = config.xplane.awy_url
    return Source(f"xplane-{dataset}", "xplane", url, ".dat", "text/plain")

def faa_source(config: TangramNavaidConfig, dataset: FaaDataset) -> Source:
    if dataset == "airports":
        url = config.faa.airports_url
    elif dataset == "routes":
        url = config.faa.routes_url
    elif dataset == "points":
        url = config.faa.points_url
    else:
        url = config.faa.navaids_url
    return Source(
        f"faa-{dataset}",
        "faa",
        url,
        ".geojson",
        "application/geo+json",
        required=config.enable_faa,
    )

def iter_sources(config: TangramNavaidConfig) -> Iterator[Source]:
    yield ddr_source(config)
    yield from (xplane_source(config, dataset) for dataset in ("nav", "fix", "awy"))
    yield from (
        faa_source(config, dataset)
        for dataset in ("airports", "routes", "points", "navaids")
    )

def cache_path(source: Source, path_cache: Path) -> Path:
    digest = hashlib.sha256(source.url.encode()).hexdigest()
    return path_cache.expanduser() / f"{source.name}-{digest}{source.suffix}"

async def ensure(
    client: httpx.AsyncClient,
    source: Source,
    path_cache: Path,
) -> Path:
    destination = cache_path(source, path_cache)
    if destination.exists():
        return destination

    lock = _download_locks.setdefault(destination, asyncio.Lock())
    async with lock:
        if not destination.exists():
            await _download(client, source, destination)
    return destination

def iter_cache_entries(config: TangramNavaidConfig) -> Iterator[CacheEntry]:
    for source in iter_sources(config):
        destination = cache_path(source, config.path_cache)
        ready = destination.exists()
        yield CacheEntry(
            name=source.name,
            group=source.group,
            required=source.required,
            ready=ready,
            source_url=source.url,
            path=str(destination),
            size_bytes=destination.stat().st_size if ready else None,
        )

def cache_status(config: TangramNavaidConfig) -> CacheStatus:
    entries = list(iter_cache_entries(config))
    return CacheStatus(
        ready=all(entry["ready"] for entry in entries if entry["required"]),
        entries=entries,
    )

async def prewarm(
    client: httpx.AsyncClient,
    config: TangramNavaidConfig,
) -> CacheOperation:
    required = tuple(source for source in iter_sources(config) if source.required)
    cached = {
        source.name
        for source in required
        if cache_path(source, config.path_cache).exists()
    }
    await asyncio.gather(
        *(ensure(client, source, config.path_cache) for source in required)
    )
    return CacheOperation(
        status=cache_status(config),
        updated=[source.name for source in required if source.name not in cached],
        unchanged=[source.name for source in required if source.name in cached],
    )

async def prewarm_faa(
    client: httpx.AsyncClient,
    config: TangramNavaidConfig,
) -> None:
    faa = tuple(source for source in iter_sources(config) if source.group == "faa")
    results = await asyncio.gather(
        *(ensure(client, source, config.path_cache) for source in faa),
        return_exceptions=True,
    )
    for source, result in zip(faa, results, strict=True):
        if isinstance(result, Exception):
            log.warning("could not cache %s: %s", source.name, result)

async def refresh_faa(
    client: httpx.AsyncClient,
    config: TangramNavaidConfig,
) -> CacheOperation:
    faa = tuple(
        faa_source(config, dataset)
        for dataset in ("airports", "routes", "points", "navaids")
    )

    async def refresh(source: Source) -> None:
        destination = cache_path(source, config.path_cache)
        async with _download_locks.setdefault(destination, asyncio.Lock()):
            # Assume FAA ArcGIS returned the requested collection; traffic.js parses it.
            await _download(client, source, destination)

    await asyncio.gather(*(refresh(source) for source in faa))
    return CacheOperation(
        status=cache_status(config),
        updated=[source.name for source in faa],
        unchanged=[],
    )