telemersive-bus 0.6.14 → 0.6.16

package/lib/BusManager.js

@@ -32,6 +32,10 @@ class BusManager {
         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;
     }
@@ -120,6 +124,12 @@ 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;
@@ -168,6 +178,8 @@ class BusManager {
             console.log(`      -> housekeeping -> pinging all rooms ...`);
             const keys = Object.keys(this.rooms);
 
+            // clean up auto-generated subscriptions from prior cycles before subscribing again
+            await this.communicator.unsubscribe(this.busTopics.baseRoomAlivePing("+").build());
             // subscribe to all room ping alive topic
             await this.communicator.subscribe(new BusMsgSub(this.busTopics.baseRoomAlivePing("+").build(), this.onRoomAlive, PeerCredentials, 0));
 
@@ -266,62 +278,76 @@ class BusManager {
         if (myId !== this.housekeepingId) {
             return;
         }
-        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);
+        // 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`);
                 }
-            };
-            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;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telemersive-bus",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "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": {