Websocketi u JavaScriptu: ponovno spajanje, redoslijed i što se gubi

Websocket u JavaScriptu jedan je redak, new WebSocket(url), i na dobroj mreži jednostavno radi: poruke stižu redom kojim su poslane, u oba smjera. Ono što ne radi jest vratiti se nakon prekida, primijetiti vezu koja je tiho umrla ili vam reći je li poruka stigla, pa svaka aplikacija koja drži otvorenu vezu ta tri dijela piše sama.
Ovaj članak pokazuje što preglednik radi kad se veza prekine, izmjereno u Chromiumu 156, a zatim klijent od šezdesetak redaka koji se ponovno spaja, nadoknađuje ono što je propustio i ponovno šalje ono što nije potvrđeno, uz mali Node.js poslužitelj s kojim razgovara. Oboje smo pokrenuli protiv poslužitelja kojem smo prekidali vezu, koji smo ponovno pokretali i utišavali. Na kraju: kako ista tri dijela izgledaju kad vezu drži oblak za rad u stvarnom vremenu.
Što vam preglednik daje
WebSocket API u svakom pregledniku ima četiri događaja, open, message, error i close, metodu send() i readyState:
// Cijeli API: otvori, pošalji, primi, zatvori.
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);Unutar jedne veze ništa ne mijenja redoslijed: protokol radi preko jedne TCP veze (RFC 6455), a TCP predaje bajtove redom kojim su poslani. Nevolje počinju ondje gdje ta jedna veza završava.
Što se događa kad se veza prekine
Otvorili smo vezu iz Chromiuma 156 prema Node.js poslužitelju, prekinuli je sa strane poslužitelja, a zatim na njoj pozvali send():
| Što smo napravili | Što je napravio preglednik |
|---|---|
send() prije open |
bacio InvalidStateError |
| Poslužitelj je prekinuo vezu | close s kodom 1006, wasClean false |
send() nakon zatvaranja |
bez pogreške, bufferedAmount veći za 12 bajtova, ništa poslano |
Zadnji redak je onaj koji gubi podatke. Poruka poslana nakon zatvaranja veze ne izaziva ništa: standard WHATWG kaže da će bufferedAmount, kad je veza zatvorena, „samo rasti sa svakim pozivom“ (WebSockets Standard), a sama poruka ne odlazi nikamo. Kod koji poziva send() bez provjere readyState baca sve što pošalje između prekida i trenutka kad ga primijeti.
Još tri praznine:
- Nema ponovnog spajanja. Zatvoreni WebSocket ostaje zatvoren. Ništa ga u standardu ponovno ne otvara.
- Nema pinga iz vašeg koda. Protokol ima okvire ping i pong i svaka strana smije poslati ping u bilo kojem trenutku, ali ih standard namjerno izostavlja iz API-ja. Preglednik ih može slati iz svojih razloga. Vaša stranica ne može, pa ne može ni pitati je li druga strana još ondje.
- Nema potvrde.
send()ne vraća ništa. Poruka može napustiti stranicu, stajati u međuspremniku i nestati s vezom, a stranica za to nikad ne sazna.
Kod 1006 znači da je veza završila bez okvira za zatvaranje: RFC 6455 zabranjuje slanje koda 1006 u njemu, pa je to preglednik koji kaže što se dogodilo, nikad kod koji je poslao vaš poslužitelj. Što znače ostali kodovi i kako testirati adresu koja se uopće ne spaja, piše u članku WebSocket veza nije uspjela.
Klijent koji se vraća sam
Rješenje za svaku prazninu je malo, a zajedno čine jedan modul. On:
- Ponovno se spaja nakon prekida, čekajući dulje nakon svakog neuspjelog pokušaja, nasumičan dio tog čekanja, najviše 30 sekundi.
- Nadoknađuje: poslužitelju javlja id najnovijeg događaja koji ima, a poslužitelj šalje ono što je došlo nakon njega.
- Ponovno šalje svaku poruku koju poslužitelj nije potvrdio, svaku s vlastitim id-jem (
ref), pa se poruka poslana dvaput i dalje prihvaća jednom. - Primjećuje tišinu: poslužitelj svakih 20 sekundi šalje otkucaj, a kad 45 sekundi ništa ne stigne, stranica otvara novu vezu umjesto da čeka na mrtvoj.
// socket.js: websocket prema vašem poslužitelju koji se vraća sam
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
let ws, retry, silence;
let lastId = 0; // najnoviji događaj koji ova stranica ima
let attempt = 0; // neuspjeli pokušaji od zadnje dobre veze
const unconfirmed = new Map(); // ref → data, dok ga poslužitelj ne potvrdi
function open() {
clearTimeout(retry);
const mine = (ws = new WebSocket(`${url}?after=${lastId}`));
mine.onopen = () => {
if (mine !== ws) return mine.close(); // zamijenjen dok se spajao
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; // otkucaj ili događaj koji je već prikazan
lastId = msg.id;
onEvent(msg);
};
mine.onclose = () => {
if (mine !== ws) return;
// Do 0,5 s, 1 s, 2 s… najviše 30 s, svaki put nasumičan dio toga, da se gomila ne vrati odjednom.
const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
retry = setTimeout(open, delay);
};
}
// Predugo ništa nije stiglo: veza je mrtva, čak i ako preglednik to nije primijetio.
function heard(mine) {
clearTimeout(silence);
silence = setTimeout(() => {
if (mine === ws) { open(); mine.close(); }
}, quiet);
}
// Ponovno na mreži: pokušaj sada, a ne kad to kaže tajmer.
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 }));
},
};
}Stranica ga koristi ovako:
import { connect } from './socket.js';
const live = connect('wss://example.com/live', {
onEvent: ({ id, data }) => showMessage(data),
onGap: () => reloadFromApi(), // predugo odsutna: poslužitelj više nema sve
});
live.send({ text: 'Hi' });Svaki socket prije nego što išta napravi provjerava mine !== ws, a to je važnije nego što izgleda. Tajmer tišine i događaj online oba otvaraju novi socket dok se stari možda još zatvara, a bez te provjere stari socket koji se zatvori kasno zakazao bi drugo ponovno spajanje, ili bi onaj koji se otvori kasno slao preko novoga.
Nasumični dio čekanja postoji zbog vašeg poslužitelja, a ne zbog stranice. Kad se poslužitelj ponovno pokrene, svaka stranica koju je držao vidi prekid u istoj sekundi. Uz fiksno čekanje sve se i vrate u istoj sekundi, uvijek iznova. Nasumičan udio čekanja koje raste raspoređuje ih.
Poslužitelj s kojim razgovara
Poslužitelj svakom događaju daje id, čuva zadnjih 500 i stranici koja se vrati šalje sve nakon id-ja koji navede. U Node.js-u s paketom ws:
// server.mjs: svaki događaj dobiva id, čuva se zadnjih 500, a stranica koja se vrati dobiva ono što je propustila
import { WebSocketServer } from 'ws';
const KEEP = 500;
const log = []; // zadnjih KEEP događaja, najstariji prvi
const seen = new Set(); // već prihvaćeni refovi: čuvajte ih dan u Redisu, a ne zauvijek u memoriji
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;
// Odsutna dulje nego što log seže: recite to, a stranica ponovno učitava iz vašeg API-ja.
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; // ponovno poslano nakon prekida i već prihvaćeno
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));
});
});
// Otkucaj svakih 20 sekundi, da stranica razlikuje tihu vezu od mrtve.
setInterval(() => {
for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);Log i skup refova ovdje žive u memoriji, pa ih ponovno pokretanje zaboravlja. U produkciji idu u Redis ili vašu bazu podataka, a s više od jednog poslužitelja svaki poslužitelj mora čitati isti log, o čemu govori članak websocketi u Node.js-u s više poslužitelja.
Što je pokazao test
Pokrenuli smo ovaj klijent na dvije stranice u Chromiumu 156, Ann i Ben, protiv ovog poslužitelja i namjerno kvarili stvari:
| Što smo pokvarili | Što su stranice vidjele |
|---|---|
| Prekinuli smo Ann nakon što je poslužitelj primio njezinu poruku, ali prije potvrde | Ann ju je poslala ponovno, poslužitelj ju je prihvatio jednom |
| Zaustavili smo poslužitelj, Ann je poslala dvije poruke, zatim smo ga ponovno pokrenuli | Obje su stigle, svaka jednom |
| Poslužitelj je utihnuo bez zatvaranja | Obje stranice otvorile su novu vezu čim je tišina istekla (3 sekunde u testu, 45 u kodu) |
| Treća stranica, izvan mreže dok je stiglo više nego što log čuva | Dobila je ono što je log još imao, zatim onGap |
Jedan rezultat zaslužuje drugi pogled. Ann je poslala svoje dvije poruke dok poslužitelj nije radio, a Ben je svoju poslao odmah nakon što se vratio. Benova je stigla prva: dok se Ann ponovno spojila, njegova je već imala manji id. Ništa nije izgubljeno i svaka je stranica vidjela isti redoslijed, ali to je bio redoslijed poslužitelja, a ne redoslijed kojim su njih dvoje pritisnuli slanje. To je redoslijed koji aplikacija u stvarnom vremenu može obećati kroz ponovna spajanja: jedan redoslijed, određen na jednom mjestu, isti za sve. Chat koji poruke mora prikazivati prema tome kad su napisane razvrstava ih prema vremenu koje dodaje svaka stranica, a ne prema tome kad su stigle.
Što ovaj klijent i dalje ne može spasiti: poruku upisanu u karticu koja se zatvori prije ponovnog spajanja. Mapa unconfirmed živi u stranici. Da biste ih sačuvali, spremite ih u IndexedDB i pošaljite pri sljedećem posjetu.
Kad vezu drži oblak za rad u stvarnom vremenu
Sve gore navedeno posao je vaše aplikacije: ponovna spajanja, id-jevi, log, refovi, otkucaj i log koji dijele poslužitelji čim ih je više od jednog. WordPlus Cloud umjesto toga drži veze, a njegov paket @wordplus/realtime te dijelove radi na stranici. Vaš poslužitelj jednom definira sobu, s pravilom o tome tko joj se smije pridružiti i koliko događaja čuva za stranice koje se vrate:
// server.mjs, uz vaše rute: ploča tima, board:7
realtime.room('board:{id}', async (user, { id }) => {
return user !== null && (await db.boards.isMember(id, user));
}, {
emit: ['card', 'cursor'], // što stranice smiju slati
history: 100, // zadnjih 100 čuva se za stranice koje se ponovno spoje
});import { connect } from '@wordplus/realtime';
const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');
// Propušteni događaji dolaze prvi, redom, označeni kao ponovljeni, zatim novi.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());
// Čeka dok WordPlus Cloud ne provjeri događaj, sačuva ga i pošalje dalje.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });
// Pokazivač ne vrijedi ništa ako kasni: odbacuje se izvan mreže i nikad se ne čuva.
board.volatile.emit('cursor', { x: 120, y: 80 });- Ponovna spajanja događaju se sama, i na neki drugi od naših poslužitelja, a
rt.on('disconnected')irt.on('connected')javljaju stranici kada. - Nadoknađivanje: stranica koja se vrati unutar 5 minuta prvo dobiva događaje koje je propustila, redom, s
meta.replayed, iz povijesti sobe (do 1.000 događaja po sobi, svaki do 64 KB). Ako je odsutna dulje, dobivagapi pita vaš API, kao i gornji poslužitelj. - Potvrđena slanja:
emitWithAckse razrješava s id-jem i vremenom koje je događaj dobio ili se odbija s razlogom, primjericenot_allowed. - Svaka kartica: kartice jednog preglednika dijele jednu vezu.
Kako sobe čuvaju povijest i što radi svaka opcija: sobe i događaji u dokumentaciji. Prije nego što napišete vlastiti klijent, svoj poslužitelj možete isprobati u WebSocket testu, websocket klijentu u pregledniku koji bilježi svaku poslanu i primljenu poruku i objašnjava što znači kod zatvaranja. Na serverless hostingu, gdje funkcija uopće ne može držati vezu, websocketi u Next.js-u pokazuju isti model.
Websocketi za vašu aplikaciju
WordPlus Cloud for Apps ima cijenu prema istodobnim vezama, od 1.000 naviše, naplaćuje se mjesečno ili godišnje, a na vašim poslužiteljima ne treba ništa pokretati. Pogledajte websockete za aplikacije ili cijene za aplikacije. Imate pitanja o svojoj integraciji? Pišite nam.