telemersive-bus 0.6.13 → 0.6.15

package/lib/BusManager.js

@@ -31,6 +31,11 @@ class BusManager {
         this.peerHousekeep = {};
         this.roomHousekeep = {};
         this.houseKeepingInProgress = false;
+        this.housekeepingId = 0;
+        // promise set while cleanOut is actively mutating this.rooms, null otherwise.
+        // startHousekeeping awaits it before snapshotting this.rooms, so a new cycle
+        // cannot start before the previous one's room deletions have fully settled.
+        this.cleanOutInProgress = null;
         this.chatManagers = {};
         this.switchBoardURI = null;
     }
@@ -119,9 +124,19 @@ class BusManager {
      *      when peer leaves a room
      */
     startHousekeeping = async () => {
+        // wait for any in-flight cleanOut to fully settle before snapshotting this.rooms.
+        // this prevents overlap where a still-running cleanOut's slow stopServerSidePortScripts
+        // finishes (and deletes from this.rooms) after a new cycle already snapshotted them.
+        if (this.cleanOutInProgress) {
+            await this.cleanOutInProgress;
+        }
         // we dont want to start another housekeeping process until the previous one has finished
         if(!this.houseKeepingInProgress){
             this.houseKeepingInProgress = true;
+            // each cycle gets a unique id so stale timers from an interrupted cycle can detect
+            // they no longer own the housekeeping state and bail out.
+            this.housekeepingId += 1;
+            const myId = this.housekeepingId;
             console.log(`  -> starting housekeeping -> gather all peers ...`);
             this.peerHousekeep = {};
             this.roomHousekeep = Object.assign({}, this.rooms); // clone the current room list
@@ -130,7 +145,7 @@ class BusManager {
             await this.communicator.subscribe(new BusMsgSub(this.busTopics.roomPeerJoin('+', '+').build(), this.onAllPeers, PeerInfo, 0));
 
             // now we have to wait a moment
-            setTimeout(this.pingAllPeersAlive, houseKeepingTimeOut);
+            setTimeout(() => this.pingAllPeersAlive(myId), houseKeepingTimeOut);
         } else {
             // if there is already a housekeeping going on,
             // we wait for some time to finish it and try again.
@@ -154,7 +169,11 @@ class BusManager {
     /**
      * ping all peers that are subscribed to each individual rooms
      */
-    pingAllPeersAlive = async () => {
+    pingAllPeersAlive = async (myId) => {
+        // if a newer cycle has started, this callback belongs to an interrupted cycle — drop it.
+        if (myId !== this.housekeepingId) {
+            return;
+        }
         if(this.houseKeepingInProgress) {
             console.log(`      -> housekeeping -> pinging all rooms ...`);
             const keys = Object.keys(this.rooms);
@@ -174,11 +193,11 @@ class BusManager {
                 ));
             }
             // now we have to wait a moment
-            setTimeout(this.cleanOut, houseKeepingTimeOut);
+            setTimeout(() => this.cleanOut(myId), houseKeepingTimeOut);
         } else {
             // this means the housekeeping got interrupted and
             //  needs to finish as fast as possible to cleaning up all subscriptions.
-            setTimeout(this.cleanOut, 0);
+            setTimeout(() => this.cleanOut(myId), 0);
         }
     }
 
@@ -252,63 +271,81 @@ class BusManager {
     /**
      * cleanout dead peers and rooms
      */
-    cleanOut = async () => {
-        if(this.houseKeepingInProgress) {
-            console.log(`      -> housekeeping -> cleaning out ...`);
-            // flag the room as being in the process to be removed
-            const flag4cleanupRooms = (currentRoom) => this.rooms[currentRoom.roomName].flagRoom4cleanup = true;
-            Object.values(this.roomHousekeep).forEach(flag4cleanupRooms);
-
-            // kick out the non-responding peers
-            const kickOutPeer = async (currentPeer) => {
-                console.log(`       <- remove peer '${currentPeer.peerName}' from room '${currentPeer.roomName}' `);
-                // first we send clear retain message to peer joined addresses that have not replied:
-                await this.communicator.clearRetain(this.busTopics.roomPeerJoin(currentPeer.roomName, currentPeer.peerId).build());
-
-                // create the payload for the leave message
-                const infoPayload = {
-                    timestamp: Math.round(new Date().getTime() / 1000),
-                    peerId: currentPeer.peerId,
-                    peerName: currentPeer.peerName,
-                    roomName: currentPeer.roomName
-                };
-
-                // sends the left message to all peers joined in the same room
-                await this.communicator.publish(
-                    new BusMsgPub(
-                        this.busTopics.roomPeerLeft(currentPeer.roomName, currentPeer.peerId).build(),
-                        PeerInfo, 2, true).encode(infoPayload));
-            }
-            const peerCleanup = async () => {
-                for (const peer of Object.values(this.peerHousekeep)) {
-                    await kickOutPeer(peer);
-                }
-            };
-            await peerCleanup();
-            
-            // And now remove the rooms
-            const cleanupRooms = async (currentRoom) => await this.deleteRoom(currentRoom.roomName);
-            const housekeeping = async () => {
-                for (const room of Object.values(this.roomHousekeep)) {
-                    await cleanupRooms(room);
-                }
-            };
-            await housekeeping();
-            
-            console.log(`      -> housekeeping DONE`);
-        } else {
-            console.log(`      -> housekeeping was interrupted`);
+    cleanOut = async (myId) => {
+        // if a newer cycle has started, this callback belongs to an interrupted cycle — drop it.
+        if (myId !== this.housekeepingId) {
+            return;
         }
+        // expose the in-flight cleanOut as a promise so the next startHousekeeping can await it
+        // and avoid snapshotting this.rooms while deleteRoom is still mutating it.
+        this.cleanOutInProgress = (async () => {
+            try {
+                if(this.houseKeepingInProgress) {
+                    console.log(`      -> housekeeping -> cleaning out ...`);
+                    // flag the room as being in the process to be removed. the entry may already have
+                    // been deleted from this.rooms by an earlier overlapping cleanOut whose slow
+                    // stopServerSidePortScripts only just finished — in that case, nothing to flag.
+                    const flag4cleanupRooms = (currentRoom) => {
+                        const room = this.rooms[currentRoom.roomName];
+                        if (room) room.flagRoom4cleanup = true;
+                    };
+                    Object.values(this.roomHousekeep).forEach(flag4cleanupRooms);
+
+                    // kick out the non-responding peers
+                    const kickOutPeer = async (currentPeer) => {
+                        console.log(`       <- remove peer '${currentPeer.peerName}' from room '${currentPeer.roomName}' `);
+                        // first we send clear retain message to peer joined addresses that have not replied:
+                        await this.communicator.clearRetain(this.busTopics.roomPeerJoin(currentPeer.roomName, currentPeer.peerId).build());
+
+                        // create the payload for the leave message
+                        const infoPayload = {
+                            timestamp: Math.round(new Date().getTime() / 1000),
+                            peerId: currentPeer.peerId,
+                            peerName: currentPeer.peerName,
+                            roomName: currentPeer.roomName
+                        };
+
+                        // sends the left message to all peers joined in the same room
+                        await this.communicator.publish(
+                            new BusMsgPub(
+                                this.busTopics.roomPeerLeft(currentPeer.roomName, currentPeer.peerId).build(),
+                                PeerInfo, 2, true).encode(infoPayload));
+                    }
+                    const peerCleanup = async () => {
+                        for (const peer of Object.values(this.peerHousekeep)) {
+                            await kickOutPeer(peer);
+                        }
+                    };
+                    await peerCleanup();
+
+                    // And now remove the rooms
+                    const cleanupRooms = async (currentRoom) => await this.deleteRoom(currentRoom.roomName);
+                    const housekeeping = async () => {
+                        for (const room of Object.values(this.roomHousekeep)) {
+                            await cleanupRooms(room);
+                        }
+                    };
+                    await housekeeping();
+
+                    console.log(`      -> housekeeping DONE`);
+                } else {
+                    console.log(`      -> housekeeping was interrupted`);
+                }
 
-        // and we stop by unsubscribing to all peer info messages inside all rooms
-        await this.communicator.unsubscribe(this.busTopics.roomPeerJoin('+', '+').build());
-        // unsubscribing to all room ping alive topic
-        await this.communicator.unsubscribe(this.busTopics.baseRoomAlivePing("+").build());
-        // cleanup the communicator
-        this.communicator.clearAutoGeneratedSubscriptions();
-        // set this flag to false at the end to make sure a new houskeeping cycle can only be started once
-        // all topics are unsubscribed - otherwise it won't gather the joined peers inside the room.
-        this.houseKeepingInProgress = false;
+                // and we stop by unsubscribing to all peer info messages inside all rooms
+                await this.communicator.unsubscribe(this.busTopics.roomPeerJoin('+', '+').build());
+                // unsubscribing to all room ping alive topic
+                await this.communicator.unsubscribe(this.busTopics.baseRoomAlivePing("+").build());
+                // cleanup the communicator
+                this.communicator.clearAutoGeneratedSubscriptions();
+                // set this flag to false at the end to make sure a new houskeeping cycle can only be started once
+                // all topics are unsubscribed - otherwise it won't gather the joined peers inside the room.
+                this.houseKeepingInProgress = false;
+            } finally {
+                this.cleanOutInProgress = null;
+            }
+        })();
+        await this.cleanOutInProgress;
     }
 
     /**
@@ -511,7 +548,7 @@ class BusManager {
         // Generate short UUID as peerId
         let roomUUID = this.translator.new(); // mhvXdrZT4jP5T8vBxuvm75
 
-        if(roomID === null)
+        if(roomID === null || roomID === undefined)
             roomID = this.findUnusedRoomId();
         this.rooms[_roomName] = {
             roomName: _roomName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telemersive-bus",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "MQTT based data protocol to manage unlimited peers, connected by rooms, where all peers joined to a room can exchange private data. It provides a simple chat mechanism, latency pinging, publish-subscribe mechanism (based on mqtt) and a OSC-like data stream.  ",
   "main": "index.js",
   "directories": {
@@ -11,7 +11,7 @@
     "crypto-js": "^4.0.0",
     "internal-ip": "^6.2.0",
     "mqtt": "^5.3.5",
-    "protobufjs": "^6.10.2",
+    "protobufjs": "^7.5.5",
     "public-ip": "^4.0.2",
     "sha1": "^1.1.1",
     "short-uuid": "^4.1.0",