Skip to content

一分钟搭建影视站,支持Docker等部署方式

19.9 KB
Raw Blame
import { NextResponse } from 'next/server';
import { guardRequest, jsonError } from '@/lib/api-guard';
import { fetchUpstreamWithMeta } from '@/lib/fetch-utils';
import { withHostLimit } from '@/lib/host-gate';

export const runtime = 'nodejs';
export const dynamic = 'force-dynamic';

/**
 * 直播频道批量测活(分片级)。
 * POST /api/live/probe  body: { urls: string[] }
 *
 * 单级「manifest 可访问」不足以判断可播:大量 IPTV 源 manifest 正常但
 * 分片请求被拒(token/Referer 校验、源瞬断)。因此探测追到真实分片:
 *
 *   m3u8 → [master playlist → 第一个 variant] → media playlist → 初始化段/最新分片
 *   分片以 Range: bytes=0-1 请求,收到响应头即 cancel body,不下载媒体数据。
 *   manifest 请求**不带 Range**(部分源会严格按 Range 截断,只回 2 字节)。
 *
 * 非 m3u8(FLV 等)维持单级探测。结果 level 标识探测深度:
 *   segment=分片级(最可信)/ manifest=仅 manifest 级 / head=单级直探
 * 200/206 响应头视为可达;仍不保证编码可解码(H.265 等)。
 *
 * 性能与准确性要点:
 * - 每个频道有整体时间预算(URL_BUDGET_MS),三级探测共享,避免逐级 5s 叠加成长尾;
 * - 结果带短 TTL 缓存(成功 30min / 失败 2min),多用户重复测活不再重复打上游;
 * - 全局按 host 限并发(单 host 在途 ≤3):同一运营商的频道常共用 host,
 *   批量测活不限流会以 16×N 的并发冲击同一弱源,被打挂甚至封服务器 IP(越测越红);
 * - 请求带源站 Referer,消除「源校验 Referer 导致的可播却测不通」假阴性;
 * - 校验 m3u8 的 #EXTM3U 前缀与直链的 content-type,剔除 200 的 HTML/JSON 错误页;
 * - master playlist 解析 CODECS 一并返回,前端据此提示 H.265 等浏览器无法解码的情况;
 * - 分片级通过后额外采样 128KB 实际吞吐(kbps),识别「可达但限速」的源;
 * - 走直播侧 SSRF 口径(allowPrivate):LIVE_ALLOW_PRIVATE=1 时自建内网 IPTV 同样能测通;
 * - `?stream=1` 以 NDJSON 逐条推送结果(命中缓存的立即返回),前端状态点可边测边亮;
 *   不带该参数时仍返回整批 JSON,保持向后兼容。
 */

const MAX_URLS = 50;
const CONCURRENCY = 16;
/**
 * 单个频道三级探测的总预算(含各级请求)。
 * 6s 对跨网慢 CDN 不够用:实测存在 TCP 0.4s + TLS 1.5s 的源,
 * 单是 variant 就要 3~4s,会导致"能播却超时判红"。放宽到 10s。
 */
const URL_BUDGET_MS = 10_000;
/** 单级请求上限(入口/variant),避免某一级吃光总预算 */
const LEVEL_TIMEOUT_MS = 5000;
/** 分片级最长等待:分片只需响应头;部分服务器忽略 Range 会整段返回,留足余量 */
const SEGMENT_TIMEOUT_MS = 4000;
/**
 * 分片吞吐采样:Range 拉 128KB(或 2.5s 截止)估算实际带宽。
 * Range: bytes=0-1 只能验证「分片可达」,覆盖不了「限速源」——
 * 实测存在 206 秒回但整段下载仅 ~58kbps 的源,永远缓冲不起来(绿点却播不了)。
 */
const THROUGHPUT_BYTES = 128 * 1024;
const THROUGHPUT_BUDGET_MS = 2500;
/** 吞吐采样所需的最低剩余预算:预算不足时跳过采样,避免拖长探测长尾 */
const THROUGHPUT_MIN_REMAINING_MS = 1500;
/**
 * 结果缓存:成功结果稳定,失败可能是瞬断,分开设置。
 * 成功 30min:客户端结果本身有 6h TTL,这里覆盖多用户/多轮补测场景,避免重复打上游;
 * 容量需 ≥ 典型全量频道数:几千频道的列表一轮测完若把缓存挤爆(逐出最旧),重测时会全部穿透。
 */
const CACHE_TTL_OK_MS = 30 * 60 * 1000;
const CACHE_TTL_FAIL_MS = 2 * 60 * 1000;
const CACHE_MAX_ENTRIES = 20_000;
const UA =
  process.env.USER_AGENT ||
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36';

interface ProbeOutcome {
  url: string;
  ok: boolean;
  status?: number;
  ms?: number;
  level?: 'segment' | 'manifest' | 'head';
  error?: string;
  /** master playlist 的 CODECS 属性(如 hvc1.1.6.L93.B0,mp4a.40.2),用于前端提示编码兼容性 */
  codec?: string;
  /** 因超出时间预算而失败(源可能只是慢,不代表不可播),前端据此区分展示 */
  timedOut?: boolean;
  /** 分片吞吐估算(kbps):低于阈值的源前端标记为「源限速」琥珀色 */
  kbps?: number;
}

interface FetchHeadResult {
  ok: boolean;
  status: number;
  text?: string;
  finalUrl: string;
  contentType: string;
  isM3u8: boolean;
}

/**
 * 错误占位资源:不少 IPTV 服务在令牌失效/账号异常时 302 到一段错误提示视频或图片
 * (如 `https://static.xxx/status/error_account_pirated.mp4`)。
 * 响应是 200 的合法媒体,单看可达性会误判为可用,这里按最终 URL 路径特征识别。
 * 仅在发生重定向时判定,避免误伤正常路径。
 */
const ERROR_PLACEHOLDER_RE =
  /(^|\/)(error|errors|status|denied|forbidden|expired|invalid|pirated|unauthorized)([_\-./]|$)/i;

/** 明显的网页/接口响应(200 的 HTML/JSON 错误页不能当成流) */
function isWebPageType(contentType: string): boolean {
  const ct = contentType.toLowerCase();
  return (
    ct.includes('text/html') ||
    ct.includes('application/xhtml') ||
    ct.includes('application/json') ||
    ct.includes('text/xml') ||
    ct.includes('application/xml')
  );
}

/** 源站 Referer:部分 IPTV 源校验 Referer 才放行列表/分片,缺失会误判为不可用 */
function refererOf(url: string): string | undefined {
  try {
    return `${new URL(url).origin}/`;
  } catch {
    return undefined;
  }
}

/**
 * 请求一个资源,拿到响应头即断开 body(m3u8 额外读取文本以供解析)。
 *
 * range 仅用于分片级探测:部分源(openresty 等)对 Range 请求严格截断,
 * 若给 manifest 也带 `Range: bytes=0-1` 会只拿到 2 字节(如 `#E`),
 * 导致 m3u8 解析与 #EXTM3U 校验失败而被误判为不可用。
 */
async function fetchHeadersOnly(
  url: string,
  timeoutMs: number,
  referer?: string,
  range = false
): Promise<FetchHeadResult> {
  const headers: Record<string, string> = {
    'User-Agent': UA,
    Accept: '*/*',
  };
  if (range) headers.Range = 'bytes=0-1';
  if (referer) headers.Referer = referer;

  // allowPrivate:与直播流代理同一把尺子,LIVE_ALLOW_PRIVATE=1 时自建内网 IPTV 才能测通;
  // fetchUpstreamWithMeta 内部逐跳做 SSRF 校验,此处不再重复预检(省一次 DNS 解析)
  const { res, finalUrl } = await fetchUpstreamWithMeta(url, {
    timeoutMs,
    retries: 0,
    headers,
    allowPrivate: true,
  });
  const contentType = res.headers.get('content-type') || '';
  const isM3u8 =
    contentType.includes('mpegurl') || contentType.includes('x-mpegurl') ||
    url.toLowerCase().split('?')[0].endsWith('.m3u8');

  let text: string | undefined;
  if (isM3u8) {
    // m3u8 是小文本,读取以供解析;分片则不读取
    text = await res.text();
  } else if (res.body) {
    try { await res.body.cancel(); } catch { /* 忽略 */ }
  }
  return { ok: res.ok, status: res.status, text, finalUrl, contentType, isM3u8 };
}

/**
 * 从 media playlist 中选一个用于探测的分片:优先初始化段(EXT-X-MAP),
 * 否则取**窗口内最后一个**(最新)分片。
 *
 * 不取第一个:直播是滑动窗口,列表首个分片最接近过期,
 * manifest 解析与分片请求之间的几十毫秒延迟就可能让它 404 而在测活中误判为不可用。
 */
function lastSegmentUrl(content: string, baseUrl: string): string | undefined {
  let last: string | undefined;
  for (const rawLine of content.split(/\r?\n/)) {
    const line = rawLine.trim();
    if (!line) continue;
    if (line.startsWith('#EXT-X-MAP')) {
      const m = line.match(/URI="([^"]+)"/);
      if (m) return new URL(m[1], baseUrl).href;
      continue;
    }
    if (line.startsWith('#')) continue;
    last = new URL(line, baseUrl).href;
  }
  return last;
}

/** 从 master playlist 中取第一个 variant 的地址(无 STREAM-INF 则视为 media playlist 返回 null) */
function firstVariantUrl(content: string, baseUrl: string): string | undefined | null {
  if (!content.includes('#EXT-X-STREAM-INF')) return null;
  const lines = content.split(/\r?\n/).map((l) => l.trim());
  for (let i = 0; i < lines.length; i++) {
    if (lines[i].startsWith('#EXT-X-STREAM-INF')) {
      for (let j = i + 1; j < lines.length; j++) {
        const next = lines[j];
        if (!next) continue;
        if (next.startsWith('#')) continue;
        return new URL(next, baseUrl).href;
      }
    }
  }
  return undefined;
}

/** 提取 master playlist 的 CODECS 属性 */
function extractCodecs(content: string): string | undefined {
  const m = content.match(/CODECS="([^"]+)"/i);
  return m?.[1]?.trim() || undefined;
}

const HEADER_OK = /^#EXTM3U/;

function elapsed(start: number): number {
  return Math.round(performance.now() - start);
}

/**
 * 分片吞吐采样:Range 拉 128KB(或 2.5s 截止),按实际收到的字节数估算 kbps。
 * 与分片可达性检查是两次独立请求(前者只取响应头即 cancel)。
 * 服务器忽略 Range 时按整段返回,读到 THROUGHPUT_BYTES 即停,不影响估算。
 */
async function measureThroughput(segmentUrl: string, referer?: string): Promise<number | undefined> {
  const start = performance.now();
  try {
    const { res } = await fetchUpstreamWithMeta(segmentUrl, {
      timeoutMs: 3000,
      retries: 0,
      headers: {
        'User-Agent': UA,
        Accept: '*/*',
        Range: `bytes=0-${THROUGHPUT_BYTES - 1}`,
        ...(referer ? { Referer: referer } : {}),
      },
      allowPrivate: true,
    });
    if (!res.ok || !res.body) return undefined;
    const reader = res.body.getReader();
    let bytes = 0;
    for (;;) {
      const remaining = THROUGHPUT_BUDGET_MS - (performance.now() - start);
      if (remaining <= 0) break;
      const chunk = await Promise.race([
        reader.read(),
        new Promise<null>((resolve) => setTimeout(() => resolve(null), remaining)),
      ]);
      if (!chunk || chunk.done) break;
      bytes += chunk.value?.length ?? 0;
      if (bytes >= THROUGHPUT_BYTES) break;
    }
    try { await reader.cancel(); } catch { /* 忽略 */ }
    try { await res.body.cancel(); } catch { /* 忽略 */ }
    const secs = (performance.now() - start) / 1000;
    if (bytes <= 0 || secs < 0.05) return undefined;
    return Math.round((bytes * 8) / secs / 1000);
  } catch {
    return undefined;
  }
}

/** 两级探测:manifest →(master 时穿透 variant)→ 分片 */
async function probeOne(url: string): Promise<ProbeOutcome> {
  const start = performance.now();
  const deadline = start + URL_BUDGET_MS;
  const remaining = () => deadline - performance.now();

  const referer = refererOf(url);
  const timeout = () => Math.min(LEVEL_TIMEOUT_MS, Math.max(500, Math.round(remaining())));

  try {
    // 第一级:入口地址
    const entry = await fetchHeadersOnly(url, timeout(), referer);
    if (!entry.ok) {
      return { url, ok: false, status: entry.status, ms: elapsed(start), error: `入口响应 ${entry.status}` };
    }

    // 令牌失效/账号异常时,源常重定向到错误提示资源:本质不可用,但 HTTP 层是 200。
    // 仍以 m3u8 结尾的重定向视为正常播放列表(如 /status/live.m3u8),不按占位资源处理。
    if (entry.finalUrl !== url) {
      try {
        const pathname = new URL(entry.finalUrl).pathname;
        if (!/\.m3u8?$/i.test(pathname) && ERROR_PLACEHOLDER_RE.test(pathname)) {
          return {
            url,
            ok: false,
            status: entry.status,
            ms: elapsed(start),
            error: '源返回错误占位内容(令牌失效 / 账号异常)',
          };
        }
      } catch { /* 忽略 URL 解析失败 */ }
    }

    // 非 m3u8(FLV/TS 直链):拒绝明显的网页/接口响应,其余仅标记"可达"(level=head,未验证可播性)
    if (!entry.isM3u8) {
      if (isWebPageType(entry.contentType)) {
        return {
          url,
          ok: false,
          status: entry.status,
          ms: elapsed(start),
          error: `返回内容不是流媒体(${entry.contentType.split(';')[0]})`,
        };
      }
      return { url, ok: true, status: entry.status, ms: elapsed(start), level: 'head' };
    }

    // m3u8 必须含 #EXTM3U 头,否则是伪装的 HTML/错误页
    const entryText = (entry.text || '').replace(/^\uFEFF/, '').trimStart();
    if (!HEADER_OK.test(entryText)) {
      return { url, ok: false, status: entry.status, ms: elapsed(start), error: '返回内容不是有效的 m3u8' };
    }

    // 第二级:media playlist(master 则先穿透 variant)。
    // 相对地址一律以重定向后的最终 URL 为 base(gslb 调度源 302 后路径会变)
    let mediaUrl = entry.finalUrl;
    let mediaText = entryText;
    let codec = extractCodecs(entryText);
    const variant = firstVariantUrl(entryText, entry.finalUrl);
    if (variant === undefined) {
      return { url, ok: false, ms: elapsed(start), error: 'playlist 中没有可用的流地址' };
    }
    if (variant !== null) {
      const variantRes = await fetchHeadersOnly(variant, timeout(), referer);
      const variantText = (variantRes.text || '').replace(/^\uFEFF/, '').trimStart();
      if (!variantRes.ok || !HEADER_OK.test(variantText)) {
        return {
          url,
          ok: false,
          status: variantRes.status,
          ms: elapsed(start),
          error: `子播放列表响应 ${variantRes.status}`,
        };
      }
      mediaUrl = variantRes.finalUrl;
      mediaText = variantText;
      codec = codec ?? extractCodecs(variantText);
    }

    // 第三级:分片
    const segmentUrl = lastSegmentUrl(mediaText, mediaUrl);
    if (!segmentUrl) {
      // 空 media playlist(直播源刚启动/无分片)视为 manifest 级通过
      return { url, ok: true, status: entry.status, ms: elapsed(start), level: 'manifest', codec };
    }
    const segmentStart = performance.now();
    const segment = await fetchHeadersOnly(
      segmentUrl,
      Math.min(timeout(), SEGMENT_TIMEOUT_MS),
      referer,
      true
    );
    // ms 只统计分片往返:三级累计耗时当作「延迟」对用户没有参考意义
    const segmentMs = elapsed(segmentStart);
    if (!segment.ok) {
      return {
        url,
        ok: false,
        status: segment.status,
        ms: segmentMs,
        level: 'segment',
        codec,
        error: `分片响应 ${segment.status}`,
      };
    }
    // 分片可达:采样实际吞吐,识别「可达但限速」的源(绿点却播不了的主因)
    const kbps =
      remaining() > THROUGHPUT_MIN_REMAINING_MS
        ? await measureThroughput(segmentUrl, referer)
        : undefined;
    return {
      url,
      ok: true,
      status: segment.status,
      ms: segmentMs,
      level: 'segment',
      codec,
      kbps,
    };
  } catch (err) {
    const timedOut = performance.now() >= deadline;
    return {
      url,
      ok: false,
      ms: elapsed(start),
      timedOut: timedOut || undefined,
      error: timedOut ? `探测超时(${URL_BUDGET_MS}ms)` : err instanceof Error ? err.message : '探测失败',
    };
  }
}

const NDJSON_HEADERS = {
  'Content-Type': 'application/x-ndjson; charset=utf-8',
  'Cache-Control': 'no-store, no-transform',
  // 禁用反代缓冲,保证每条结果立即到达客户端
  'X-Accel-Buffering': 'no',
};

/**
 * 流式测活:命中缓存的结果立即推送,其余探测完成一条推一条(NDJSON)。
 * 相比整批等待最慢的一条,前端状态点可以边测边亮。
 * 客户端断开(切筛选/关页)时 req.signal 触发,worker 停止且不再写入。
 */
function ndjsonResponse(urls: string[], reqSignal: AbortSignal): Response {
  const encoder = new TextEncoder();
  const cachedOutcomes: ProbeOutcome[] = [];
  const pending: string[] = [];
  for (const u of urls) {
    const hit = cacheGet(u);
    if (hit) cachedOutcomes.push(hit);
    else pending.push(u);
  }

  let closed = false;
  const stream = new ReadableStream<Uint8Array>({
    start(controller) {
      const send = (o: ProbeOutcome) => {
        if (closed) return;
        try {
          controller.enqueue(encoder.encode(JSON.stringify(o) + '\n'));
        } catch {
          closed = true;
        }
      };
      const finish = () => {
        if (closed) return;
        closed = true;
        try { controller.close(); } catch { /* 已关闭 */ }
      };
      reqSignal.addEventListener('abort', () => { closed = true; }, { once: true });

      for (const o of cachedOutcomes) send(o);

      let cursor = 0;
      const worker = async () => {
        while (cursor < pending.length) {
          if (closed || reqSignal.aborted) return;
          const url = pending[cursor++];
          const outcome = await withHostLimit(url, () => probeOne(url));
          if (closed || reqSignal.aborted) return;
          cacheSet(url, outcome);
          send(outcome);
        }
      };
      void Promise.all(Array.from({ length: Math.min(CONCURRENCY, pending.length) }, worker))
        .then(finish)
        .catch(finish);
    },
    cancel() {
      // 客户端主动断开
      closed = true;
    },
  });

  return new NextResponse(stream, { headers: NDJSON_HEADERS });
}

/** 结果短 TTL 缓存:成功 30min、失败 2min(TTL 见上方 CACHE_TTL_*_MS),避免多用户重复测活打爆上游 */
const probeCache = new Map<string, { outcome: ProbeOutcome; expiresAt: number }>();

function cacheGet(url: string): ProbeOutcome | undefined {
  const entry = probeCache.get(url);
  if (!entry) return undefined;
  if (Date.now() > entry.expiresAt) {
    probeCache.delete(url);
    return undefined;
  }
  return entry.outcome;
}

function cacheSet(url: string, outcome: ProbeOutcome): void {
  if (probeCache.size >= CACHE_MAX_ENTRIES) {
    const now = Date.now();
    for (const [k, v] of probeCache) {
      if (now > v.expiresAt) probeCache.delete(k);
    }
    if (probeCache.size >= CACHE_MAX_ENTRIES) {
      const oldest = probeCache.keys().next().value;
      if (oldest !== undefined) probeCache.delete(oldest);
    }
  }
  probeCache.set(url, {
    outcome,
    expiresAt: Date.now() + (outcome.ok ? CACHE_TTL_OK_MS : CACHE_TTL_FAIL_MS),
  });
}

export async function POST(req: Request) {
  const guarded = guardRequest(req);
  if (guarded) return guarded;

  let body: { urls?: unknown };
  try {
    body = (await req.json()) as { urls?: unknown };
  } catch {
    return jsonError('无效请求体', 400);
  }
  if (!Array.isArray(body.urls)) return jsonError('urls 必须为字符串数组', 400);

  const urls = [...new Set(
    body.urls.filter((u): u is string => typeof u === 'string' && /^https?:\/\//.test(u))
  )].slice(0, MAX_URLS);
  const stream = new URL(req.url).searchParams.get('stream') === '1';
  if (urls.length === 0) {
    return stream
      ? new NextResponse('', { headers: NDJSON_HEADERS })
      : NextResponse.json({ results: [] });
  }

  if (stream) return ndjsonResponse(urls, req.signal);

  const outcomes = new Map<string, ProbeOutcome>();
  // 先命中缓存,减少需要真实探测的目标
  const pending: string[] = [];
  for (const u of urls) {
    const hit = cacheGet(u);
    if (hit) outcomes.set(u, hit);
    else pending.push(u);
  }

  // 简单并发池:固定 worker 数从游标取任务(单线程内 cursor++ 无 await 间隙,无竞态)
  let cursor = 0;
  const worker = async () => {
    while (cursor < pending.length) {
      const url = pending[cursor++];
      const outcome = await withHostLimit(url, () => probeOne(url));
      cacheSet(url, outcome);
      outcomes.set(url, outcome);
    }
  };
  await Promise.all(Array.from({ length: Math.min(CONCURRENCY, pending.length) }, worker));

  return NextResponse.json(
    { results: urls.map((u) => outcomes.get(u)!) },
    { headers: { 'Cache-Control': 'no-store' } }
  );
}