בלוג

WebSockets ב-JavaScript: התחברויות מחדש, סדר ומה שיכול ללכת לאיבוד

· Andrij Tkachenko · 8 דקות קריאה

חלון דפדפן ושרת שמחובר ביניהם קו מקווקו שנשבר באמצע, חץ מעוגל שמגשר על השבר, ואריחי הודעות המסומנים בנקודה אחת עד ארבע מסודרים לאורכו לפי הסדר

WebSocket ב-JavaScript הוא שורה אחת, new WebSocket(url), וברשת טובה הוא פשוט עובד: ההודעות מגיעות לפי הסדר שבו נשלחו, בשני הכיוונים. מה שהוא לא עושה הוא לחזור אחרי ניתוק, לשים לב לחיבור שמת בשקט, או לומר לכם אם הודעה הגיעה, ולכן כל אפליקציה שמחזיקה חיבור כזה פתוח כותבת את שלושת החלקים האלה בעצמה.

הפוסט הזה מראה מה הדפדפן עושה כשחיבור נופל, במדידה ב-Chromium 156, ואז לקוח של כ-60 שורות שמתחבר מחדש, משלים את מה שפספס ושולח שוב את מה שלא אושר, יחד עם שרת Node.js הקטן שהוא מדבר איתו. שניהם הורצו מול שרת שנותק, הופעל מחדש והושתק. בסוף: איך שלושת החלקים האלה נראים כשענן זמן אמת מחזיק את החיבור.

מה הדפדפן נותן לכם

ל-API של WebSocket בכל דפדפן יש ארבעה events, open, message, error ו-close, מתודת send() ו-readyState:

JavaScript
// כל ה-API: לפתוח, לשלוח, לשמוע, לסגור.
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);

בתוך חיבור אחד שום דבר לא מחליף מקום: הפרוטוקול רץ על חיבור TCP יחיד (RFC 6455), ו-TCP מוסר את הבתים לפי הסדר שבו נשלחו. הצרות מתחילות במקום שבו החיבור הזה נגמר.

מה קורה כשהחיבור נופל

פתחנו חיבור מ-Chromium 156 לשרת Node.js, ניתקנו אותו מצד השרת, ואז קראנו עליו ל-send():

מה עשינו מה הדפדפן עשה
send() לפני open זרק InvalidStateError
השרת ניתק את החיבור close עם קוד 1006, wasClean false
send() אחרי הסגירה בלי שגיאה, bufferedAmount עלה ב-12 בתים, שום דבר לא נשלח

השורה האחרונה היא זו שמאבדת נתונים. הודעה שנשלחת אחרי שהחיבור נסגר לא מעלה שום שגיאה: התקן של WHATWG אומר ש-bufferedAmount "רק יגדל עם כל קריאה" אחרי שהחיבור נסגר (WebSockets Standard), וההודעה עצמה לא מגיעה לשום מקום. קוד שקורא ל-send() בלי לבדוק את readyState זורק כל מה שהוא שולח בין הניתוק לרגע שבו הוא שם לב.

עוד שלושה חסרים:

  • אין התחברות מחדש. WebSocket שנסגר נשאר סגור. שום דבר בתקן לא פותח אותו שוב.
  • אין ping מהקוד שלכם. בפרוטוקול יש מסגרות ping ו-pong, וכל צד רשאי לשלוח ping בכל רגע, אבל התקן אומר במפורש שהן לא חשופות כרגע ב-API. הדפדפן עשוי לשלוח אותן מסיבות משלו. הדף שלכם לא יכול, ולכן הוא לא יכול לשאול אם הצד השני עדיין שם.
  • אין אישור קבלה. send() לא מחזיר כלום. הודעה יכולה לצאת מהדף, לשבת ב-buffer וללכת לאיבוד יחד עם החיבור, והדף לעולם לא שומע על כך.

קוד 1006 אומר שהחיבור הסתיים בלי מסגרת סגירה: RFC 6455 אוסר לשלוח 1006 בתוך מסגרת כזו, כך שזה הדפדפן שמספר מה קרה, אף פעם לא קוד שהשרת שלכם שלח. מה אומרים הקודים האחרים, ואיך לבדוק כתובת שלא מתחברת בכלל, נמצא ב-חיבור WebSocket נכשל.

לקוח שחוזר מעצמו

התיקון לכל חסר הוא קטן, ויחד הם מודול אחד. הוא:

  1. מתחבר מחדש אחרי ניתוק, ומחכה יותר אחרי כל ניסיון שנכשל, חלק אקראי מההמתנה, עד 30 שניות.
  2. משלים את מה שפספס: הוא אומר לשרת את ה-id של ה-event החדש ביותר שיש לו, והשרת שולח את מה שבא אחריו.
  3. שולח שוב כל הודעה שהשרת לא אישר, כל אחת עם id משלה (ref), כך שהודעה שנשלחה פעמיים עדיין נלקחת פעם אחת.
  4. שם לב לשקט: השרת שולח פעימה כל 20 שניות, ואם לא נשמע כלום במשך 45 הדף פותח חיבור חדש במקום לחכות על חיבור מת.
JavaScript
// socket.js: websocket לשרת שלכם שחוזר מעצמו
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
  let ws, retry, silence;
  let lastId = 0;   // ה-event החדש ביותר שיש לדף הזה
  let attempt = 0;  // ניסיונות שנכשלו מאז החיבור הטוב האחרון
  const unconfirmed = new Map(); // ref → data, עד שהשרת מאשר אותו

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

    mine.onopen = () => {
      if (mine !== ws) return mine.close(); // הוחלף בזמן שהתחבר
      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; // פעימה, או event שכבר הוצג
      lastId = msg.id;
      onEvent(msg);
    };

    mine.onclose = () => {
      if (mine !== ws) return;
      // עד 0.5 s, 1 s, 2 s… לכל היותר 30 s, בכל פעם חלק אקראי מזה, כדי שקהל לא יחזור בבת אחת.
      const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
      retry = setTimeout(open, delay);
    };
  }

  // לא נשמע כלום יותר מדי זמן: החיבור מת, גם אם הדפדפן עוד לא שם לב.
  function heard(mine) {
    clearTimeout(silence);
    silence = setTimeout(() => {
      if (mine === ws) { open(); mine.close(); }
    }, quiet);
  }

  // חזרנו לרשת: לנסות עכשיו ולא כשהטיימר אומר.
  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 }));
    },
  };
}

דף משתמש בו כך:

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

const live = connect('wss://example.com/live', {
  onEvent: ({ id, data }) => showMessage(data),
  onGap: () => reloadFromApi(), // נעדר יותר מדי זמן: לשרת כבר אין את כל מה שהיה
});

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

כל socket בודק mine !== ws לפני שהוא פועל, וזה חשוב יותר ממה שנראה. טיימר השקט וה-event online פותחים שניהם socket חדש בזמן שהישן אולי עדיין נסגר, ובלי הבדיקה socket ישן שנסגר באיחור היה מתזמן התחברות מחדש שנייה, או socket שנפתח באיחור היה שולח במקביל לחדש.

החלק האקראי של ההמתנה נמצא שם בשביל השרת שלכם, לא בשביל הדף. כששרת מופעל מחדש, כל דף שהוא החזיק רואה את הניתוק באותה שנייה. עם המתנה קבועה כולם גם חוזרים באותה שנייה, שוב ושוב. חלק אקראי מהמתנה שגדלה מפזר אותם.

השרת שהוא מדבר איתו

השרת נותן לכל event מזהה, שומר את 500 האחרונים, ושולח לדף שחוזר את כל מה שבא אחרי ה-id שהוא מציין. ב-Node.js עם החבילה ws:

JavaScript
// server.mjs: כל event מקבל id, 500 האחרונים נשמרים, ודף שחוזר מקבל את מה שפספס
import { WebSocketServer } from 'ws';

const KEEP = 500;
const log = [];         // KEEP ה-events האחרונים, הישן ביותר ראשון
const seen = new Set(); // refs שכבר נלקחו: לשמור אותם יום ב-Redis, לא לנצח בזיכרון
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;

  // נעדר יותר ממה שהיומן מגיע אליו: לומר את זה, והדף טוען מחדש מה-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; // נשלח שוב אחרי ניתוק, וכבר נלקח
    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));
  });
});

// פעימה כל 20 שניות, כדי שדף יוכל להבדיל בין חיבור שקט לחיבור מת.
setInterval(() => {
  for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);

היומן וקבוצת ה-refs חיים כאן בזיכרון, כך שהפעלה מחדש שוכחת אותם. ב-production הם נשמרים ב-Redis או במסד הנתונים שלכם, וכשיש יותר משרת אחד, כל שרת צריך לקרוא את אותו יומן, ועל זה עובר חיבורי websocket ב-Node.js מעבר לשרת אחד.

מה הבדיקה הראתה

הרצנו את הלקוח הזה בשני דפים של Chromium 156, Ann ו-Ben, מול השרת הזה, ושברנו דברים בכוונה:

מה שברנו מה הדפים ראו
ניתקנו את Ann אחרי שהשרת לקח את ההודעה שלה אבל לפני שאישר אותה Ann שלחה אותה שוב, השרת לקח אותה פעם אחת
עצרנו את השרת, Ann שלחה שתי הודעות, ואז הפעלנו אותו שוב שתיהן הגיעו, כל אחת פעם אחת
השרת השתתק בלי לסגור שני הדפים פתחו חיבור חדש כשהשקט נגמר (3 שניות בבדיקה, 45 בקוד)
דף שלישי, מנותק בזמן שהגיעו יותר ממה שהיומן שמר הוא קיבל את מה שעוד היה ביומן, ואז onGap

תוצאה אחת שווה מבט שני. Ann שלחה את שתי ההודעות שלה בזמן שהשרת היה למטה, ו-Ben שלח את שלו מיד אחרי שהשרת חזר. של Ben הגיעה ראשונה: עד ש-Ann התחברה מחדש, להודעה שלו כבר היה id נמוך יותר. שום דבר לא אבד וכל דף ראה את אותו סדר, אבל זה היה הסדר של השרת, לא הסדר שבו שניהם לחצו על שליחה. זה הסדר שאפליקציית זמן אמת יכולה להבטיח לאורך התחברויות מחדש: סדר אחד, שנקבע במקום אחד, זהה לכולם. צ׳אט שחייב להציג הודעות לפי מתי שנכתבו ממיין לפי זמן שכל דף מצרף, לא לפי מתי שהגיעו.

מה שהלקוח הזה עדיין לא יכול להציל: הודעה שהוקלדה בלשונית שנסגרת לפני שהיא מתחברת מחדש. ה-map unconfirmed חי בדף. כדי לשמור גם אותן, שימו אותן ב-IndexedDB ושלחו אותן בביקור הבא.

כשענן זמן אמת מחזיק את החיבור

כל מה שלמעלה הוא עבודה שהאפליקציה שלכם אחראית לה: ההתחברויות מחדש, המזהים, היומן, ה-refs, הפעימה, ויומן משותף בין השרתים ברגע שיש יותר מאחד. WordPlus Cloud מחזיק את החיבורים במקומכם, והחבילה @wordplus/realtime שלו עושה את החלקים האלה בדף. השרת שלכם מגדיר חדר פעם אחת, עם כלל שקובע מי רשאי להצטרף וכמה events הוא שומר לדפים שחוזרים:

JavaScript
// server.mjs, לצד ה-routes שלכם: הלוח של צוות, board:7
realtime.room('board:{id}', async (user, { id }) => {
  return user !== null && (await db.boards.isMember(id, user));
}, {
  emit: ['card', 'cursor'], // מה שהדפים רשאים לשלוח
  history: 100,             // 100 האחרונים נשמרים לדפים שמתחברים מחדש
});
board.js
import { connect } from '@wordplus/realtime';

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

// events שפוספסו מגיעים ראשונים, לפי הסדר, מסומנים replayed, ואחריהם החדשים.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());

// מחכה עד ש-WordPlus Cloud בדק את ה-event, שמר אותו והעביר אותו הלאה.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });

// סמן לא שווה כלום באיחור: נזרק בזמן ניתוק, אף פעם לא נשמר.
board.volatile.emit('cursor', { x: 120, y: 80 });
  • התחברויות מחדש קורות מעצמן, גם לשרת אחר שלנו, ו-rt.on('disconnected') ו-rt.on('connected') אומרים לדף מתי.
  • השלמת מה שפוספס: דף שחוזר בתוך 5 דקות מקבל קודם את ה-events שפספס, לפי הסדר, עם meta.replayed, מההיסטוריה של החדר (עד 1,000 events לחדר, כל אחד עד 64 KB). אם נעדר יותר זמן, הוא מקבל gap ושואל את ה-API שלכם, כמו שהשרת שלמעלה עושה.
  • שליחות מאושרות: emitWithAck מחזיר את ה-id והזמן שה-event קיבל, או נדחה עם הסיבה, למשל not_allowed.
  • כל הלשוניות: הלשוניות של דפדפן אחד חולקות חיבור אחד.

איך חדרים שומרים היסטוריה ומה כל אפשרות עושה: חדרים ו-events בתיעוד. לפני שאתם כותבים לקוח משלכם, אפשר לנסות את השרת שלכם ב-בדיקת WebSocket, לקוח websocket בדפדפן שרושם כל הודעה שנשלחה והתקבלה ומסביר מה אומר קוד סגירה. באחסון serverless, שבו פונקציה לא יכולה להחזיק חיבור בכלל, חיבורי websocket ב-Next.js מראה את אותו מודל.

Websockets לאפליקציה שלכם

WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, בלי שום דבר להריץ על השרתים שלכם. ראו websockets לאפליקציות, או את המחירים לאפליקציות. שאלות על האינטגרציה שלכם? כתבו לנו.