vimp-engine 0.35.6 → 0.36.0

package/src/client/network/WebRtcManager.js

@@ -16,8 +16,85 @@ import Publisher from '../../lib/Publisher.js';
 // Клиент — инициатор (offerer): создаёт каналы и оффер, обменивается с хостом
 // SDP/ICE через сигнальный WebSocket (SignalingClient). RTCPeerConnection
 // инъектируется фабрикой ради тестируемости.
+//
+// Хост может открыть третий канал — standby (host-migration этап 6): только
+// у назначенного мастером преемника; он отдаётся событием 'standby'.
+
+/**
+ * Тип своего локального ICE-кандидата в выбранной паре (host-migration этап
+ * 6): 'relay' значит, что этому игроку для связи нужен ретранслятор.
+ * Выбранная пара — по transport.selectedCandidatePairId, а без него — пара
+ * nominated && succeeded.
+ * @param {RTCStatsReport|Map} stats
+ * @returns {string|null} 'host'|'srflx'|'prflx'|'relay' или null.
+ */
+export function selectedLocalCandidateType(stats) {
+  if (!stats) {
+    return null;
+  }
+
+  const reports = [...stats.values()];
+  let pair = null;
+
+  for (const report of reports) {
+    if (report.type === 'transport' && report.selectedCandidatePairId) {
+      pair = stats.get(report.selectedCandidatePairId) ?? null;
+
+      if (pair) {
+        break;
+      }
+    }
+  }
+
+  pair ??=
+    reports.find(
+      report =>
+        report.type === 'candidate-pair' &&
+        report.nominated === true &&
+        report.state === 'succeeded',
+    ) ?? null;
+
+  if (!pair) {
+    return null;
+  }
+
+  return stats.get(pair.localCandidateId)?.candidateType ?? null;
+}
+
 export default class WebRtcManager {
-  constructor(signaling, { iceServers, peerFactory } = {}) {
+  /**
+   * @param {SignalingClient} signaling
+   * @param {Object} [opts]
+   * @param {Array} [opts.iceServers]
+   * @param {Function} [opts.peerFactory] - фабрика RTCPeerConnection (тесты).
+   * @param {string} [opts.memberId] - id вкладки (ключ участника на мастере).
+   * @param {boolean} [opts.resume] - переподключение к матчу: хост не начнёт
+   *   хендшейк, а будет ждать RESUME_REQUEST (host-migration этап 4).
+   * @param {number} [opts.minEpoch] - эпоха хоста, известная клиенту: ответы
+   *   более старых эпох — чужие (сообщения прежнего хоста).
+   * @param {number} [opts.connectTimeoutMs] - каналы не открылись за это
+   *   время — close('connectTimeout'); 0 — без таймаута.
+   * @param {number} [opts.offerRetryMs] - пауза перед повтором оффера, на
+   *   который мастер ответил error {code: 'migrating'} (комната в плановой
+   *   передаче хоста, host-migration этап 8).
+   * @param {number} [opts.iceStatsIntervalMs] - период перечитывания типа
+   *   ICE-кандидата после открытия каналов; 0 — только один раз.
+   * @param {Object} [opts.timers] - { setTimeout, clearTimeout } (тесты).
+   */
+  constructor(
+    signaling,
+    {
+      iceServers,
+      peerFactory,
+      memberId,
+      resume = false,
+      minEpoch = null,
+      connectTimeoutMs = 0,
+      offerRetryMs = 1000,
+      iceStatsIntervalMs = 30000,
+      timers = globalThis,
+    } = {},
+  ) {
     this._signaling = signaling;
     this._iceServers = iceServers || signaling.iceServers;
     this._peerFactory =
@@ -26,20 +103,51 @@ export default class WebRtcManager {
     this._pc = null;
     this._meta = null;
     this._state = null;
-    this._hostId = null;
+    this._roomId = null;
+    // id вкладки — хост хранит его рядом с clientId пира
+    this._memberId = memberId ?? null;
+    this._resume = resume === true;
+    this._minEpoch = minEpoch;
+    // эпоха хоста, ответившего на этот оффер: дальше чужие эпохи отсекаются
+    this._epoch = null;
+    this._connectTimeoutMs = connectTimeoutMs;
+    this._timers = timers;
+    this._connectTimer = null;
+    this._offerRetryMs = offerRetryMs;
+    this._retryTimer = null;
+    this._offerSent = false;
+    // свои ICE-кандидаты: повтор оффера отправляет их заново — прежние
+    // ушли хосту, который оффер не принял
+    this._sentCandidates = [];
     this._openChannels = 0;
     this._closed = false;
+    // тип своего ICE-кандидата в выбранной паре (null — ещё не известен)
+    this._iceType = null;
+    this._iceStatsIntervalMs = iceStatsIntervalMs;
+    this._iceTimer = null;
 
     this.publisher = new Publisher();
 
-    // подписки на сигнальные ответы конкретно этого соединения
+    // подписки на сигнальные ответы конкретно этого соединения; destroy()
+    // их снимает — иначе брошенный менеджер ел бы ответы нового
     this._signaling.publisher.on('webrtc_answer', 'onAnswer', this);
     this._signaling.publisher.on('ice_candidate', 'onRemoteCandidate', this);
+    this._signaling.publisher.on('error', 'onSignalingError', this);
+  }
+
+  // эпоха хоста, ответившего на оффер (null — ответа ещё не было)
+  get epoch() {
+    return this._epoch;
+  }
+
+  // тип своего локального ICE-кандидата в выбранной паре с хостом
+  get iceType() {
+    return this._iceType;
   }
 
-  // инициирует установку соединения с хостом
-  async connect(hostId) {
-    this._hostId = hostId;
+  // инициирует установку соединения с текущим хостом комнаты
+  async connect(roomId) {
+    this._roomId = roomId;
 
     const pc = this._peerFactory({ iceServers: this._iceServers });
 
@@ -59,9 +167,20 @@ export default class WebRtcManager {
     this._wireChannel(this._meta);
     this._wireChannel(this._state);
 
+    // канал standby открывает хост — только преемнику (этап 6)
+    pc.ondatachannel = event => {
+      if (event.channel?.label === 'standby') {
+        event.channel.binaryType = 'arraybuffer';
+        this.publisher.emit('standby', event.channel);
+      }
+    };
+
+    this._startConnectTimer();
+
     pc.onicecandidate = event => {
       if (event.candidate) {
-        this._signaling.sendIceCandidate(hostId, event.candidate);
+        this._sentCandidates.push(event.candidate);
+        this._signaling.sendIceCandidate(roomId, event.candidate);
       }
     };
 
@@ -79,21 +198,108 @@ export default class WebRtcManager {
 
     await pc.setLocalDescription(offer);
 
-    this._signaling.sendOffer(hostId, pc.localDescription);
+    // менеджер могли закрыть, пока собирался оффер
+    if (this._closed) {
+      return;
+    }
+
+    this._offerSent = true;
+    this._sendOffer();
+  }
+
+  _sendOffer() {
+    this._signaling.sendOffer(
+      this._roomId,
+      this._pc.localDescription,
+      this._memberId,
+      { resume: this._resume },
+    );
   }
 
-  // приём SDP-ответа хоста (подписка на сигнальный канал)
+  // отказ мастера на оффер этой попытки: комната передаёт хоста (этап 8) —
+  // тот же оффер через offerRetryMs, к хосту, который будет к тому времени.
+  // Окно connectTimeoutMs отсчитывается заново: передача ограничена
+  // таймаутом мастера, ожидание не бесконечно
+  onSignalingError(msg) {
+    // ответ про другую комнату или на другой запрос (join_room, голосование)
+    // к этому офферу не относится
+    if (msg?.roomId && msg.roomId !== this._roomId) {
+      return;
+    }
+
+    if (msg?.re && msg.re !== 'webrtc_offer') {
+      return;
+    }
+
+    if (
+      msg?.code !== 'migrating' ||
+      this._closed ||
+      !this._offerSent ||
+      this._epoch !== null ||
+      this._retryTimer !== null
+    ) {
+      return;
+    }
+
+    this._clearConnectTimer();
+    this._retryTimer = this._timers.setTimeout(() => {
+      this._retryTimer = null;
+
+      if (this._closed) {
+        return;
+      }
+
+      this._startConnectTimer();
+      this._sendOffer();
+
+      for (const candidate of this._sentCandidates) {
+        this._signaling.sendIceCandidate(this._roomId, candidate);
+      }
+    }, this._offerRetryMs);
+  }
+
+  // сообщение этой попытки: своя комната и эпоха не старше известной.
+  // Эпоха фиксируется первым ответом — кандидаты прежнего хоста той же
+  // комнаты после этого отсекаются
+  _isOwnEpoch(epoch) {
+    if (epoch === undefined || epoch === null) {
+      return true;
+    }
+
+    if (this._epoch !== null) {
+      return epoch === this._epoch;
+    }
+
+    return this._minEpoch === null || epoch >= this._minEpoch;
+  }
+
+  // приём SDP-ответа хоста (подписка на сигнальный канал); hostId — алиас
+  // roomId от мастера до host-migration этапа 2
   async onAnswer(msg) {
-    if (!this._pc || msg.hostId !== this._hostId) {
+    if (
+      !this._pc ||
+      this._closed ||
+      (msg.roomId ?? msg.hostId) !== this._roomId ||
+      !this._isOwnEpoch(msg.epoch)
+    ) {
       return;
     }
 
+    if (msg.epoch !== undefined && msg.epoch !== null) {
+      this._epoch = msg.epoch;
+    }
+
     await this._pc.setRemoteDescription(msg.sdp);
   }
 
   // приём удалённого ICE-кандидата (от хоста)
   async onRemoteCandidate(msg) {
-    if (!this._pc || msg.fromId !== this._hostId) {
+    if (
+      !this._pc ||
+      this._closed ||
+      msg.fromId !== this._roomId ||
+      !this._isOwnEpoch(msg.epoch)
+    ) {
       return;
     }
 
@@ -117,13 +323,127 @@ export default class WebRtcManager {
     this._emitClose();
   }
 
+  // тихое закрытие: отписка от сигналинга и закрытие pc без события 'close'
+  // (менеджер брошен владельцем — например, супервизор сменил попытку)
+  destroy() {
+    this._unsubscribe();
+
+    if (this._closed) {
+      return;
+    }
+
+    this._closed = true;
+    this._clearConnectTimer();
+    this._clearRetryTimer();
+    this._clearIceTimer();
+    this._dropChannelHandlers();
+    this._pc?.close();
+  }
+
+  _unsubscribe() {
+    this._signaling.publisher.off('webrtc_answer', 'onAnswer', this);
+    this._signaling.publisher.off('ice_candidate', 'onRemoteCandidate', this);
+    this._signaling.publisher.off('error', 'onSignalingError', this);
+  }
+
+  // оба канала открыты и менеджер не закрыт
+  get isOpen() {
+    return this._openChannels === 2 && !this._closed;
+  }
+
+  // перечитывает тип ICE-кандидата; смена — событие 'iceType'
+  async refreshIceType() {
+    if (!this._pc || this._closed || typeof this._pc.getStats !== 'function') {
+      return this._iceType;
+    }
+
+    let type = null;
+
+    try {
+      type = selectedLocalCandidateType(await this._pc.getStats());
+    } catch {
+      return this._iceType; // pc закрылся посреди запроса
+    }
+
+    if (!this._closed && type !== this._iceType) {
+      this._iceType = type;
+      this.publisher.emit('iceType', type);
+    }
+
+    return this._iceType;
+  }
+
+  // после открытия каналов — сразу и далее раз в iceStatsIntervalMs: пара
+  // может смениться (ICE restart, смена сети)
+  _watchIceType() {
+    this.refreshIceType();
+
+    if (this._iceStatsIntervalMs > 0) {
+      this._iceTimer = this._timers.setTimeout(() => {
+        this._iceTimer = null;
+        this._watchIceType();
+      }, this._iceStatsIntervalMs);
+    }
+  }
+
+  _clearIceTimer() {
+    if (this._iceTimer !== null) {
+      this._timers.clearTimeout(this._iceTimer);
+      this._iceTimer = null;
+    }
+  }
+
+  // каналы не открылись вовремя (хост молчит, ICE не сошёлся) — попытка
+  // провалена; 'failed' браузер может объявлять десятки секунд
+  _startConnectTimer() {
+    if (this._connectTimeoutMs > 0) {
+      this._connectTimer = this._timers.setTimeout(() => {
+        this._connectTimer = null;
+        this._emitClose();
+      }, this._connectTimeoutMs);
+    }
+  }
+
+  _clearRetryTimer() {
+    if (this._retryTimer !== null) {
+      this._timers.clearTimeout(this._retryTimer);
+      this._retryTimer = null;
+    }
+  }
+
+  _clearConnectTimer() {
+    if (this._connectTimer !== null) {
+      this._timers.clearTimeout(this._connectTimer);
+      this._connectTimer = null;
+    }
+  }
+
+  // поздние события каналов закрытого менеджера не должны ничего эмитить
+  _dropChannelHandlers() {
+    for (const channel of [this._meta, this._state]) {
+      if (channel) {
+        channel.onopen = null;
+        channel.onmessage = null;
+        channel.onclose = null;
+      }
+    }
+
+    if (this._pc) {
+      this._pc.onicecandidate = null;
+      this._pc.onconnectionstatechange = null;
+      this._pc.ondatachannel = null;
+    }
+  }
+
   _wireChannel(channel) {
     channel.onopen = () => {
       this._openChannels += 1;
 
       // оба канала открыты — транспорт готов (как ws.onopen)
       if (this._openChannels === 2) {
+        this._clearConnectTimer();
         this.publisher.emit('open');
+        this._watchIceType();
       }
     };
 
@@ -131,12 +451,19 @@ export default class WebRtcManager {
     channel.onclose = () => this._emitClose();
   }
 
+  // кода закрытия у data channel нет: 'close' эмитится без аргумента, как
+  // и раньше (код приходит только от WebSocket-транспорта dedicated)
   _emitClose() {
     if (this._closed) {
       return;
     }
 
     this._closed = true;
+    this._clearConnectTimer();
+    this._clearRetryTimer();
+    this._clearIceTimer();
+    this._unsubscribe();
+    this._dropChannelHandlers();
 
     if (this._pc) {
       this._pc.close();

package/src/client/network/policyClose.js

@@ -24,8 +24,15 @@
 
 import closeCodes from '../../config/closeCodes.js';
 
-const { invalidOrigin, roomFull, handshakeTimeout, tooManyConnections } =
-  closeCodes;
+const {
+  invalidOrigin,
+  roomFull,
+  handshakeTimeout,
+  tooManyConnections,
+  kickIdle,
+  kickForMaxLatency,
+  kickForMissedPings,
+} = closeCodes;
 
 const NO_RELOAD_CLOSE_CODES = new Set([
   invalidOrigin,
@@ -52,3 +59,26 @@ export const POLICY_CLOSE_INFORMS = {
 export function shouldReloadAfterClose(closeCode) {
   return !NO_RELOAD_CLOSE_CODES.has(closeCode);
 }
+
+// Кики хоста (host/HostGame.js). В P2P кода закрытия нет вовсе — причина
+// приезжает только TECH_INFORM-ключом перед закрытием (индексы
+// TECH_CODES из host/meta/SocketManager.js = индексы techInformList);
+// в dedicated есть и код. Лобби-режим уводит кикнутого на главную без
+// перезагрузки (client/lib/roomLink.js decideExitRoute): быстрая игра по
+// hash вернула бы его в ту же комнату
+const KICK_CLOSE_CODES = new Set([
+  kickIdle,
+  kickForMaxLatency,
+  kickForMissedPings,
+]);
+
+export const KICK_TECH_KEYS = new Set([3, 4, 5]);
+
+/**
+ * @param {number} [closeCode] - Код закрытия транспорта (только WebSocket).
+ * @param {number|null} [techKey] - Последний терминальный TECH_INFORM-ключ.
+ * @returns {boolean} Закрыто ли соединение киком хоста.
+ */
+export function isKickClose(closeCode, techKey) {
+  return KICK_CLOSE_CODES.has(closeCode) || KICK_TECH_KEYS.has(techKey);
+}

package/src/client/network/standbyChunks.js

@@ -0,0 +1,185 @@
+// Нарезка контрольной точки для канала standby (host-migration этап 6):
+// хост → преемник. SCTP-сообщение ограничено maxMessageSize, поэтому точка
+// идёт кусками ≤ standbyChunkBytes. Общий модуль отправителя
+// (StandbySender) и приёмника (StandbyReceiver).
+//
+// Логический поток одной точки: [u16 descLen][desc JSON utf-8][байты
+// точки], desc = { checkpointId, createdAt, mode, game } — приёмнику не
+// нужно распаковывать точку, чтобы сообщить мастеру её id и свежесть, а
+// прогреву — чтобы узнать игру (game: { id, version } или null; хост старше
+// поля его не шлёт, старый приёмник его игнорирует).
+//
+// Кусок: 24-байтный заголовок (little-endian) + данные потока:
+//   0  u32 wireId      — номер точки у отправителя (растёт)
+//   4  u32 index       — номер куска
+//   8  u32 count       — кусков в точке
+//   12 u32 totalBytes  — длина логического потока
+//   16 u32 seq         — номер кадра хоста на момент точки
+//   20 u8  final       — финальная точка (плановая передача, этап 8)
+//   21 u8  version     — версия формата куска
+//   22 u16 reserved
+
+export const STANDBY_HEADER_BYTES = 24;
+export const STANDBY_CHUNK_VERSION = 1;
+
+const DESC_LEN_BYTES = 2;
+const GAME_FIELD_MAX_LENGTH = 64;
+
+/**
+ * Режет точку на куски.
+ * @param {Object} checkpoint - { checkpointId, createdAt, mode, game, seq,
+ *   final, bytes } (как отдаёт HostController.onCheckpoint).
+ * @param {number} wireId
+ * @param {number} chunkBytes - потолок размера куска вместе с заголовком.
+ * @returns {Uint8Array[]}
+ */
+export function encodeStandbyChunks(checkpoint, wireId, chunkBytes) {
+  const payloadBytes = chunkBytes - STANDBY_HEADER_BYTES;
+
+  if (!(payloadBytes > 0)) {
+    throw new Error(`standby chunk must exceed ${STANDBY_HEADER_BYTES} bytes`);
+  }
+
+  const desc = new TextEncoder().encode(
+    JSON.stringify({
+      checkpointId: checkpoint.checkpointId,
+      createdAt: checkpoint.createdAt,
+      mode: checkpoint.mode ?? null,
+      game: parseGame(checkpoint.game),
+    }),
+  );
+  const bytes = checkpoint.bytes;
+  const stream = new Uint8Array(
+    DESC_LEN_BYTES + desc.byteLength + bytes.byteLength,
+  );
+
+  new DataView(stream.buffer).setUint16(0, desc.byteLength, true);
+  stream.set(desc, DESC_LEN_BYTES);
+  stream.set(bytes, DESC_LEN_BYTES + desc.byteLength);
+
+  const count = Math.max(1, Math.ceil(stream.byteLength / payloadBytes));
+  const chunks = [];
+
+  for (let index = 0; index < count; index += 1) {
+    const data = stream.subarray(
+      index * payloadBytes,
+      (index + 1) * payloadBytes,
+    );
+    const chunk = new Uint8Array(STANDBY_HEADER_BYTES + data.byteLength);
+    const view = new DataView(chunk.buffer);
+
+    view.setUint32(0, wireId >>> 0, true);
+    view.setUint32(4, index, true);
+    view.setUint32(8, count, true);
+    view.setUint32(12, stream.byteLength, true);
+    view.setUint32(16, (checkpoint.seq ?? 0) >>> 0, true);
+    view.setUint8(20, checkpoint.final ? 1 : 0);
+    view.setUint8(21, STANDBY_CHUNK_VERSION);
+    chunk.set(data, STANDBY_HEADER_BYTES);
+    chunks.push(chunk);
+  }
+
+  return chunks;
+}
+
+/**
+ * Читает заголовок куска.
+ * @param {ArrayBuffer|Uint8Array} raw
+ * @returns {Object|null} { wireId, index, count, totalBytes, seq, final,
+ *   data } или null для битого/чужого куска.
+ */
+export function decodeStandbyChunk(raw) {
+  const bytes = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+
+  if (bytes.byteLength < STANDBY_HEADER_BYTES) {
+    return null;
+  }
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  if (view.getUint8(21) !== STANDBY_CHUNK_VERSION) {
+    return null;
+  }
+
+  const chunk = {
+    wireId: view.getUint32(0, true),
+    index: view.getUint32(4, true),
+    count: view.getUint32(8, true),
+    totalBytes: view.getUint32(12, true),
+    seq: view.getUint32(16, true),
+    final: view.getUint8(20) === 1,
+    data: bytes.subarray(STANDBY_HEADER_BYTES),
+  };
+
+  if (chunk.count === 0 || chunk.index >= chunk.count) {
+    return null;
+  }
+
+  return chunk;
+}
+
+/**
+ * Разбирает собранный логический поток.
+ * @param {Uint8Array} stream
+ * @returns {{ checkpointId: string, createdAt: number, mode: string|null,
+ *   game: { id: string, version: string }|null, bytes: Uint8Array }|null}
+ */
+export function parseStandbyStream(stream) {
+  if (stream.byteLength < DESC_LEN_BYTES) {
+    return null;
+  }
+
+  const descLen = new DataView(
+    stream.buffer,
+    stream.byteOffset,
+    stream.byteLength,
+  ).getUint16(0, true);
+
+  if (DESC_LEN_BYTES + descLen > stream.byteLength) {
+    return null;
+  }
+
+  let desc;
+
+  try {
+    desc = JSON.parse(
+      new TextDecoder().decode(
+        stream.subarray(DESC_LEN_BYTES, DESC_LEN_BYTES + descLen),
+      ),
+    );
+  } catch {
+    return null;
+  }
+
+  if (
+    !desc ||
+    typeof desc.checkpointId !== 'string' ||
+    !Number.isFinite(desc.createdAt)
+  ) {
+    return null;
+  }
+
+  return {
+    checkpointId: desc.checkpointId,
+    createdAt: desc.createdAt,
+    mode: typeof desc.mode === 'string' ? desc.mode : null,
+    game: parseGame(desc.game),
+    // своя копия: буфер можно отдать в Worker списком переноса
+    bytes: stream.slice(DESC_LEN_BYTES + descLen),
+  };
+}
+
+// игра дескриптора — только { id, version } из непустых коротких строк:
+// дескриптор шлёт хост, то есть другой игрок
+function parseGame(game) {
+  const isField = value =>
+    typeof value === 'string' &&
+    value.length > 0 &&
+    value.length <= GAME_FIELD_MAX_LENGTH;
+
+  if (!game || typeof game !== 'object' || !isField(game.id)) {
+    return null;
+  }
+
+  return isField(game.version) ? { id: game.id, version: game.version } : null;
+}