server/sockets.js

   1 const url = require('url');
   2
   3 // Node version in Ubuntu 16.04 does not know about URL class
   4 // NOTE: url is already transformed, without ?xxx=yyy... parts
   5 function getJsonFromUrl(url) {
   6   const query = url.substr(2); //starts with "/?"
   7   let result = {};
   8   query.split("&").forEach((part) => {
   9     const item = part.split("=");
  10     result[item[0]] = decodeURIComponent(item[1]);
  11   });
  12   return result;
  13 }
  14
  15 // Helper to safe-send some message through a (web-)socket:
  16 function send(socket, message) {
  17   if (!!socket && socket.readyState == 1)
  18     socket.send(JSON.stringify(message));
  19 }
  20
  21 module.exports = function(wss) {
  22   // Associative array page --> sid --> tmpId --> socket
  23   // "page" is either "/" for hall or "/game/some_gid" for Game,
  24   // or "/mygames" for Mygames page (simpler: no 'people' array).
  25   // tmpId is required if a same user (browser) has different tabs
  26   let clients = {};
  27   // NOTE: only purpose of sidToPages = know when to delete keys in idToSid
  28   let sidToPages = {};
  29   let idToSid = {};
  30   wss.on("connection", (socket, req) => {
  31     const query = getJsonFromUrl(req.url);
  32     const sid = query["sid"];
  33     const id = query["id"];
  34     const tmpId = query["tmpId"];
  35     const page = query["page"];
  36     const notifyRoom = (page, code, obj={}, except) => {
  37       if (!clients[page]) return;
  38       except = except || [];
  39       Object.keys(clients[page]).forEach(k => {
  40         if (except.includes(k)) return;
  41         Object.keys(clients[page][k]).forEach(x => {
  42           if (k == sid && x == tmpId) return;
  43           send(
  44             clients[page][k][x].socket,
  45             Object.assign({ code: code, from: [sid, tmpId] }, obj)
  46           );
  47         });
  48       });
  49     };
  50     const deleteConnexion = () => {
  51       if (!clients[page] || !clients[page][sid] || !clients[page][sid][tmpId])
  52         return; //job already done
  53       delete clients[page][sid][tmpId];
  54       if (Object.keys(clients[page][sid]).length == 0) {
  55         delete clients[page][sid];
  56         const pgIndex = sidToPages[sid].findIndex(pg => pg == page);
  57         sidToPages[sid].splice(pgIndex, 1);
  58         if (Object.keys(clients[page]).length == 0)
  59           delete clients[page];
  60         // Am I totally offline?
  61         if (sidToPages[sid].length == 0) {
  62           delete sidToPages[sid];
  63           delete idToSid[id];
  64         }
  65       }
  66     };
  67
  68     const doDisconnect = () => {
  69       deleteConnexion();
  70       // Nothing to notify when disconnecting from MyGames page:
  71       if (page != "/mygames") {
  72         notifyRoom(page, "disconnect");
  73         if (page.indexOf("/game/") >= 0)
  74           notifyRoom("/", "gdisconnect", { page: page });
  75       }
  76     };
  77     const messageListener = (objtxt) => {
  78       let obj = JSON.parse(objtxt);
  79       switch (obj.code) {
  80         // Wait for "connect" message to notify connection to the room,
  81         // because if game loading is slow the message listener might
  82         // not be ready too early.
  83         case "connect": {
  84           notifyRoom(page, "connect");
  85           if (page.indexOf("/game/") >= 0)
  86             notifyRoom("/", "gconnect", { page: page });
  87           break;
  88         }
  89         case "disconnect":
  90           // When page changes:
  91           doDisconnect();
  92           break;
  93         case "pollclients": {
  94           // From Game
  95           let sockIds = {};
  96           Object.keys(clients[page]).forEach(k => {
  97             sockIds[k] = {};
  98             Object.keys(clients[page][k]).forEach(x => {
  99               // Avoid polling my tmpId: no information to get
 100               if (k != sid || x != tmpId)
 101                 sockIds[k][x] = { focus: clients[page][k][x].focus };
 102             });
 103           });
 104           send(socket, { code: "pollclients", sockIds: sockIds });
 105           break;
 106         }
 107         case "pollclientsandgamers": {
 108           // From Hall
 109           let sockIds = {};
 110           Object.keys(clients["/"]).forEach(k => {
 111             sockIds[k] = {};
 112             Object.keys(clients[page][k]).forEach(x => {
 113               // Avoid polling my tmpId: no information to get
 114               if (k != sid || x != tmpId) {
 115                 sockIds[k][x] = {
 116                   page: "/",
 117                   focus: clients[page][k][x].focus
 118                 };
 119               }
 120             });
 121           });
 122           // NOTE: a "gamer" could also just be an observer
 123           Object.keys(clients).forEach(p => {
 124             if (p.indexOf("/game/") >= 0) {
 125               Object.keys(clients[p]).forEach(k => {
 126                 if (!sockIds[k]) sockIds[k] = {};
 127                 Object.keys(clients[p][k]).forEach(x => {
 128                   if (k != sid || x != tmpId) {
 129                     sockIds[k][x] = {
 130                       page: p,
 131                       focus: clients[p][k][x].focus
 132                     };
 133                   }
 134                 });
 135               });
 136             }
 137           });
 138           send(socket, { code: "pollclientsandgamers", sockIds: sockIds });
 139           break;
 140         }
 141
 142         // Asking something: from is fully identified,
 143         // but the requested resource can be from any tmpId (except current!)
 144         case "askidentity":
 145         case "asklastate":
 146         case "askchallenges":
 147         case "askgame": {
 148           const pg = obj.page || page; //required for askidentity and askgame
 149           if (!!clients[pg] && !!clients[pg][obj.target]) {
 150             let tmpIds = Object.keys(clients[pg][obj.target]);
 151             if (obj.target == sid) {
 152               // Targetting myself
 153               const idx_myTmpid = tmpIds.findIndex(x => x == tmpId);
 154               if (idx_myTmpid >= 0) tmpIds.splice(idx_myTmpid, 1);
 155             }
 156             if (tmpIds.length > 0) {
 157               const ttmpId = tmpIds[Math.floor(Math.random() * tmpIds.length)];
 158               send(
 159                 clients[pg][obj.target][ttmpId].socket,
 160                 { code: obj.code, from: [sid,tmpId,page] }
 161               );
 162             }
 163           }
 164           break;
 165         }
 166
 167         // Special situation of the previous "case":
 168         // Full game can be asked to any observer.
 169         case "askfullgame": {
 170           if (!!clients[page]) {
 171             let sids = Object.keys(clients[page]).filter(k => k != sid);
 172             if (sids.length > 0) {
 173               // Pick a SID at random in this set, and ask full game:
 174               const rid = sids[Math.floor(Math.random() * sids.length)];
 175               // ..to a random tmpId:
 176               const tmpIds = Object.keys(clients[page][rid]);
 177               const rtmpId = tmpIds[Math.floor(Math.random() * tmpIds.length)];
 178               send(
 179                 clients[page][rid][rtmpId].socket,
 180                 { code: "askfullgame", from: [sid,tmpId] }
 181               );
 182             } else {
 183               // I'm the only person who have the game for the moment:
 184               send(socket, { code: "fullgame", data: { empty: true } });
 185             }
 186           }
 187           break;
 188         }
 189
 190         // Some Hall events: target all tmpId's (except mine),
 191         case "refusechallenge":
 192         case "startgame":
 193           Object.keys(clients[page][obj.target]).forEach(x => {
 194             if (obj.target != sid || x != tmpId)
 195               send(
 196                 clients[page][obj.target][x].socket,
 197                 { code: obj.code, data: obj.data }
 198               );
 199           });
 200           break;
 201
 202         // Notify all room: mostly game events
 203         case "newchat":
 204         case "newchallenge":
 205         case "deletechallenge_s":
 206         case "newgame":
 207         case "resign":
 208         case "abort":
 209         case "drawoffer":
 210         case "rematchoffer":
 211         case "draw":
 212           // "newgame" message can provide a page (corr Game --> Hall)
 213           notifyRoom(
 214             obj.page || page, obj.code, {data: obj.data}, obj.excluded);
 215           break;
 216
 217         case "rnewgame":
 218           // A rematch game started:
 219           notifyRoom(page, "newgame", {data: obj.data});
 220           // Explicitely notify Hall if gametype == corr.
 221           // Live games will be polled from Hall after gconnect event.
 222           if (obj.data.cadence.indexOf('d') >= 0)
 223             notifyRoom("/", "newgame", {data: obj.data});
 224           break;
 225
 226         case "newmove": {
 227           const dataWithFrom = { from: [sid,tmpId], data: obj.data };
 228           // Special case re-send newmove only to opponent:
 229           if (!!obj.target && !!clients[page][obj.target]) {
 230             Object.keys(clients[page][obj.target]).forEach(x => {
 231               send(
 232                 clients[page][obj.target][x].socket,
 233                 Object.assign({ code: "newmove" }, dataWithFrom)
 234               );
 235             });
 236           } else {
 237             // NOTE: data.from is useful only to opponent
 238             notifyRoom(page, "newmove", dataWithFrom);
 239           }
 240           break;
 241         }
 242         case "gotmove":
 243           if (
 244             !!clients[page][obj.target[0]] &&
 245             !!clients[page][obj.target[0]][obj.target[1]]
 246           ) {
 247             send(
 248               clients[page][obj.target[0]][obj.target[1]].socket,
 249               { code: "gotmove" }
 250             );
 251           }
 252           break;
 253
 254         case "result":
 255           // Special case: notify all, 'transroom': Game --> Hall
 256           notifyRoom("/", "result", { gid: obj.gid, score: obj.score });
 257           break;
 258
 259         case "mabort": {
 260           const gamePg = "/game/" + obj.gid;
 261           if (!!clients[gamePg] && !!clients[gamePg][obj.target]) {
 262             Object.keys(clients[gamePg][obj.target]).forEach(x => {
 263               send(
 264                 clients[gamePg][obj.target][x].socket,
 265                 { code: "abort" }
 266               );
 267             });
 268           }
 269           break;
 270         }
 271
 272         case "notifyscore":
 273         case "notifyturn":
 274         case "notifynewgame":
 275           if (!!clients["/mygames"]) {
 276             obj.targets.forEach(t => {
 277               const k = t.sid || idToSid[t.id];
 278               if (!!clients["/mygames"][k]) {
 279                 Object.keys(clients["/mygames"][k]).forEach(x => {
 280                   send(
 281                     clients["/mygames"][k][x].socket,
 282                     { code: obj.code, data: obj.data }
 283                   );
 284                 });
 285               }
 286             });
 287           }
 288           break;
 289
 290         case "getfocus":
 291         case "losefocus":
 292           if (
 293             !!clients[page] &&
 294             !!clients[page][sid] &&
 295             !!clients[page][sid][tmpId]
 296           ) {
 297             clients[page][sid][tmpId].focus = (obj.code == "getfocus");
 298           }
 299           if (page == "/") notifyRoom("/", obj.code, { page: "/" }, [sid]);
 300           else {
 301             // Notify game room + Hall:
 302             notifyRoom(page, obj.code, {}, [sid]);
 303             notifyRoom("/", obj.code, { page: page }, [sid]);
 304           }
 305           break;
 306
 307         // Passing, relaying something: from isn't needed,
 308         // but target is fully identified (sid + tmpId)
 309         case "challenges":
 310         case "fullgame":
 311         case "game":
 312         case "identity":
 313         case "lastate":
 314         {
 315           const pg = obj.target[2] || page; //required for identity and game
 316           // NOTE: if in game we ask identity to opponent still in Hall, but
 317           // leaving Hall, clients[pg] or clients[pg][target] could be undef.
 318           if (!!clients[pg] && !!clients[pg][obj.target[0]]) {
 319             send(
 320               clients[pg][obj.target[0]][obj.target[1]].socket,
 321               { code:obj.code, data:obj.data }
 322             );
 323           }
 324           break;
 325         }
 326       }
 327     };
 328     const closeListener = () => {
 329       // For browser or tab closing (including page reload):
 330       doDisconnect();
 331     };
 332     // Update clients object: add new connexion
 333     const newElt = { socket: socket, focus: true };
 334     if (!clients[page])
 335       clients[page] = { [sid]: {[tmpId]: newElt } };
 336     else if (!clients[page][sid])
 337       clients[page][sid] = { [tmpId]: newElt };
 338     else
 339       clients[page][sid][tmpId] = newElt;
 340     // Also update helper correspondances
 341     if (!idToSid[id]) idToSid[id] = sid;
 342     if (!sidToPages[sid]) sidToPages[sid] = [];
 343     const pgIndex = sidToPages[sid].findIndex(pg => pg == page);
 344     if (pgIndex === -1) sidToPages[sid].push(page);
 345     socket.on("message", messageListener);
 346     socket.on("close", closeListener);
 347   });
 348 }