Blog

Websockety w JavaScripcie: ponowne połączenia, kolejność i co może zginąć

· Andrij Tkachenko · 9 min czytania

Okno przeglądarki i serwer połączone przerywaną linią, która urywa się pośrodku, zakrzywiona strzałka nad przerwą i kafelki wiadomości oznaczone od jednej do czterech kropek, ustawione po kolei wzdłuż linii

WebSocket w JavaScripcie to jedna linijka, new WebSocket(url), i w dobrej sieci po prostu działa: wiadomości docierają w kolejności, w jakiej je wysłano, w obie strony. Nie potrafi za to wrócić po zerwaniu, zauważyć połączenia, które po cichu umarło, ani powiedzieć, czy wiadomość dotarła, więc każda aplikacja, która utrzymuje je otwarte, pisze te trzy części sama.

Ten wpis pokazuje, co robi przeglądarka, gdy połączenie się zrywa, zmierzone w Chromium 156, potem klienta na około 60 linijek, który łączy się ponownie, nadrabia to, co go ominęło, i wysyła jeszcze raz to, czego nie potwierdzono, razem z małym serwerem Node.js, z którym rozmawia. Oba uruchomiliśmy z serwerem, który odcinaliśmy, restartowaliśmy i uciszaliśmy. Na koniec: jak te same trzy części wyglądają, gdy połączenie utrzymuje chmura czasu rzeczywistego.

Co daje przeglądarka

WebSocket API w każdej przeglądarce ma cztery zdarzenia, open, message, error i close, metodę send() i readyState:

JavaScript
// Całe API: otwórz, wyślij, odbierz, zamknij.
const ws = new WebSocket('wss://example.com/live');

ws.onopen = () => ws.send(JSON.stringify({ hello: 'server' }));
ws.onmessage = ({ data }) => console.log('got', data);
ws.onclose = ({ code, reason }) => console.log('closed', code, reason);

W ramach jednego połączenia nic nie zmienia kolejności: protokół działa na jednym połączeniu TCP (RFC 6455), a TCP przekazuje bajty w kolejności, w jakiej je wysłano. Kłopoty zaczynają się tam, gdzie to jedno połączenie się kończy.

Co się dzieje, gdy połączenie się zrywa

Otworzyliśmy połączenie z Chromium 156 do serwera Node.js, zerwaliśmy je od strony serwera, a potem wywołaliśmy na nim send():

Co zrobiliśmy Co zrobiła przeglądarka
send() przed open rzuciła InvalidStateError
Serwer zerwał połączenie close z kodem 1006, wasClean false
send() po zamknięciu bez błędu, bufferedAmount większe o 12 bajtów, nic nie wysłano

To ostatni wiersz gubi dane. Wiadomość wysłana po zamknięciu połączenia nie zgłasza niczego: standard WHATWG mówi, że gdy połączenie jest zamknięte, bufferedAmount będzie „tylko rosnąć z każdym wywołaniem” (WebSockets Standard), a sama wiadomość nigdzie nie trafia. Kod, który wywołuje send() bez sprawdzenia readyState, wyrzuca wszystko, co wyśle między zerwaniem a chwilą, w której to zauważy.

Jeszcze trzy luki:

  • Brak ponownego łączenia. Zamknięty WebSocket zostaje zamknięty. Nic w standardzie nie otwiera go znowu.
  • Brak pingu z Twojego kodu. Protokół ma ramki ping i pong, a każda ze stron może wysłać ping w dowolnej chwili, ale standard celowo zostawia je poza API. Przeglądarka może je wysyłać z własnych powodów. Twoja strona nie może, więc nie może zapytać, czy druga strona wciąż tam jest.
  • Brak potwierdzenia. send() niczego nie zwraca. Wiadomość może opuścić stronę, poczekać w buforze i przepaść razem z połączeniem, a strona nigdy się o tym nie dowie.

Kod 1006 oznacza, że połączenie zakończyło się bez ramki zamknięcia: RFC 6455 zabrania wysyłania 1006 w takiej ramce, więc to przeglądarka mówi, co się stało, a nigdy kod, który wysłał Twój serwer. Co mówią pozostałe kody i jak sprawdzić adres, który w ogóle się nie łączy, opisuje wpis WebSocket connection failed.

Klient, który wraca sam

Poprawka każdej luki jest mała, a razem tworzą jeden moduł. On:

  1. Łączy się ponownie po zerwaniu, czekając dłużej po każdej nieudanej próbie, losową część tego czasu, najwyżej 30 sekund.
  2. Nadrabia: podaje serwerowi id najnowszego zdarzenia, jakie ma, a serwer wysyła to, co przyszło po nim.
  3. Wysyła ponownie każdą wiadomość, której serwer nie potwierdził, każdą z własnym id (ref), więc wiadomość wysłana dwa razy i tak zostaje przyjęta raz.
  4. Zauważa ciszę: serwer wysyła sygnał co 20 sekund, a gdy przez 45 nic nie słychać, strona otwiera nowe połączenie, zamiast czekać na martwe.
JavaScript
// socket.js: websocket do Twojego własnego serwera, który wraca sam
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
  let ws, retry, silence;
  let lastId = 0;   // najnowsze zdarzenie, jakie ma ta strona
  let attempt = 0;  // nieudane próby od ostatniego dobrego połączenia
  const unconfirmed = new Map(); // ref → data, dopóki serwer tego nie potwierdzi

  function open() {
    clearTimeout(retry);
    const mine = (ws = new WebSocket(`${url}?after=${lastId}`));

    mine.onopen = () => {
      if (mine !== ws) return mine.close(); // zastąpiony, gdy jeszcze się łączył
      attempt = 0;
      heard(mine);
      for (const [ref, data] of unconfirmed) mine.send(JSON.stringify({ ref, data }));
    };

    mine.onmessage = ({ data }) => {
      if (mine !== ws) return;
      heard(mine);
      const msg = JSON.parse(data);
      if (msg.ack) return void unconfirmed.delete(msg.ack);
      if (msg.gap) return void onGap?.();
      if (!msg.id || msg.id <= lastId) return; // sygnał albo zdarzenie już pokazane
      lastId = msg.id;
      onEvent(msg);
    };

    mine.onclose = () => {
      if (mine !== ws) return;
      // Do 0,5 s, 1 s, 2 s… najwyżej 30 s, za każdym razem losowa część, żeby tłum nie wrócił naraz.
      const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
      retry = setTimeout(open, delay);
    };
  }

  // Zbyt długo nic nie słychać: połączenie jest martwe, nawet jeśli przeglądarka tego nie zauważyła.
  function heard(mine) {
    clearTimeout(silence);
    silence = setTimeout(() => {
      if (mine === ws) { open(); mine.close(); }
    }, quiet);
  }

  // Z powrotem w sieci: spróbuj teraz, a nie wtedy, gdy powie timer.
  addEventListener('online', () => {
    if (ws.readyState === WebSocket.CLOSED) open();
  });

  open();

  return {
    send(data) {
      const ref = crypto.randomUUID();
      unconfirmed.set(ref, data);
      if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ ref, data }));
    },
  };
}

Strona używa go tak:

app.js
import { connect } from './socket.js';

const live = connect('wss://example.com/live', {
  onEvent: ({ id, data }) => showMessage(data),
  onGap: () => reloadFromApi(), // zbyt długo nieobecna: serwer nie ma już wszystkiego
});

live.send({ text: 'Hi' });

Każdy socket sprawdza mine !== ws, zanim cokolwiek zrobi, a to ma większe znaczenie, niż się wydaje. Timer ciszy i zdarzenie online otwierają nowy socket, gdy stary może się jeszcze zamykać, a bez tego sprawdzenia stary socket, który zamknie się późno, zaplanowałby drugie ponowne połączenie, a taki, który otworzy się późno, wysyłałby równolegle z nowym.

Losowa część czasu oczekiwania jest dla Twojego serwera, nie dla strony. Gdy serwer się restartuje, każda strona, którą obsługiwał, widzi zerwanie w tej samej sekundzie. Przy stałym czasie oczekiwania wszystkie wracają też w tej samej sekundzie, raz za razem. Losowa część rosnącego czasu oczekiwania rozkłada je w czasie.

Serwer, z którym rozmawia

Serwer nadaje każdemu zdarzeniu id, przechowuje ostatnie 500 i wysyła stronie, która wraca, wszystko po id, które ona podaje. W Node.js z pakietem ws:

JavaScript
// server.mjs: każde zdarzenie dostaje id, ostatnie 500 jest przechowywanych, a strona, która wraca, dostaje to, co ją ominęło
import { WebSocketServer } from 'ws';

const KEEP = 500;
const log = [];         // ostatnie KEEP zdarzeń, od najstarszego
const seen = new Set(); // już przyjęte refy: trzymaj je przez dobę w Redisie, a nie w pamięci na zawsze
let lastId = 0;

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (ws, req) => {
  const after = Number(new URL(req.url, 'http://localhost').searchParams.get('after')) || 0;

  // Nieobecna dłużej, niż sięga log: powiedz to, a strona wczyta wszystko ponownie z Twojego API.
  if (after && log.length && log[0].id > after + 1) ws.send(JSON.stringify({ gap: true }));
  for (const event of log) if (event.id > after) ws.send(JSON.stringify(event));

  ws.on('message', (raw) => {
    const { ref, data } = JSON.parse(raw);
    ws.send(JSON.stringify({ ack: ref }));
    if (seen.has(ref)) return; // wysłana ponownie po zerwaniu i już przyjęta
    seen.add(ref);

    const event = { id: ++lastId, data };
    log.push(event);
    if (log.length > KEEP) log.shift();
    for (const client of wss.clients) client.send(JSON.stringify(event));
  });
});

// Sygnał co 20 sekund, żeby strona odróżniła ciche połączenie od martwego.
setInterval(() => {
  for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);

Log i zbiór refów żyją tu w pamięci, więc restart o nich zapomina. W produkcji trafiają do Redisa albo Twojej bazy danych, a przy więcej niż jednym serwerze każdy serwer musi czytać ten sam log, co omawia wpis websockety w Node.js przy więcej niż jednym serwerze.

Co pokazał test

Uruchomiliśmy tego klienta na dwóch stronach w Chromium 156, Ann i Ben, z tym serwerem i celowo psuliśmy różne rzeczy:

Co zepsuliśmy Co zobaczyły strony
Odcięliśmy Ann, gdy serwer przyjął jej wiadomość, ale jeszcze jej nie potwierdził Ann wysłała ją ponownie, serwer przyjął ją raz
Zatrzymaliśmy serwer, Ann wysłała dwie wiadomości, potem znów go uruchomiliśmy Obie dotarły, każda raz
Serwer zamilkł, nie zamykając połączenia Obie strony otworzyły nowe połączenie, gdy minął czas ciszy (3 sekundy w teście, 45 w kodzie)
Trzecia strona, offline, gdy przyszło więcej, niż mieścił log Dostała to, co log jeszcze miał, a potem onGap

Jeden wynik warto obejrzeć drugi raz. Ann wysłała swoje dwie wiadomości, gdy serwer nie działał, a Ben wysłał swoją tuż po tym, jak wrócił. Wiadomość Bena była pierwsza: zanim Ann połączyła się ponownie, jego miała już niższe id. Nic nie zginęło i każda strona widziała tę samą kolejność, ale była to kolejność serwera, a nie kolejność, w jakiej oboje nacisnęli „wyślij”. Taką kolejność aplikacja czasu rzeczywistego może obiecać przy ponownych połączeniach: jedną kolejność, ustaloną w jednym miejscu, taką samą dla wszystkich. Czat, który musi pokazywać wiadomości według tego, kiedy je napisano, sortuje według czasu, który dołącza każda strona, a nie według chwili, w której dotarły.

Czego ten klient wciąż nie uratuje: wiadomości wpisanej w karcie, która zamknie się, zanim połączy się ponownie. Mapa unconfirmed żyje w stronie. Żeby je zachować, zapisz je w IndexedDB i wyślij przy następnej wizycie.

Gdy połączenie utrzymuje chmura czasu rzeczywistego

Wszystko powyżej to praca, która należy do Twojej aplikacji: ponowne połączenia, id, log, refy, sygnał i log wspólny dla serwerów, gdy jest ich więcej niż jeden. WordPlus Cloud utrzymuje połączenia zamiast niej, a jego pakiet @wordplus/realtime robi te części na stronie. Twój serwer raz deklaruje pokój, z regułą określającą, kto może dołączyć i ile zdarzeń przechowuje on dla stron, które wracają:

JavaScript
// server.mjs, obok Twoich tras: tablica zespołu, board:7
realtime.room('board:{id}', async (user, { id }) => {
  return user !== null && (await db.boards.isMember(id, user));
}, {
  emit: ['card', 'cursor'], // co mogą wysyłać strony
  history: 100,             // ostatnie 100 przechowywane dla stron, które łączą się ponownie
});
board.js
import { connect } from '@wordplus/realtime';

const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');

// Pominięte zdarzenia przychodzą najpierw, po kolei, oznaczone jako odtworzone, a potem nowe.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());

// Czeka, aż WordPlus Cloud sprawdzi zdarzenie, zachowa je i prześle dalej.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });

// Kursor nic nie jest wart po czasie: pomijany offline, nigdy nie przechowywany.
board.volatile.emit('cursor', { x: 120, y: 80 });
  • Ponowne połączenia dzieją się same, także na inny z naszych serwerów, a rt.on('disconnected') i rt.on('connected') mówią stronie kiedy.
  • Nadrabianie: strona, która wraca w ciągu 5 minut, dostaje najpierw zdarzenia, które ją ominęły, po kolei, z meta.replayed, z historii pokoju (do 1000 zdarzeń na pokój, każde do 64 KB). Nieobecna dłużej dostaje gap i pyta Twoje własne API, tak jak przy serwerze powyżej.
  • Potwierdzone wysyłanie: emitWithAck zwraca id i czas, które dostało zdarzenie, albo odrzuca z powodem, na przykład not_allowed.
  • Każda karta: karty jednej przeglądarki dzielą jedno połączenie.

Jak pokoje przechowują historię i co robi każda opcja: pokoje i zdarzenia w dokumentacji. Zanim napiszesz własnego klienta, możesz sprawdzić swój serwer w Teście WebSocket, kliencie websocket w przeglądarce, który zapisuje każdą wysłaną i odebraną wiadomość i wyjaśnia, co znaczy kod zamknięcia. Na hostingu serverless, gdzie funkcja w ogóle nie może utrzymać połączenia, ten sam model pokazuje wpis websockety w Next.js.

Websockety dla Twojej aplikacji

WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, bez niczego do uruchamiania na Twoich serwerach. Zobacz websockety dla aplikacji albo cennik dla aplikacji. Masz pytania o swoją integrację? Napisz do nas.