telemersive-bus 0.6.16 → 0.6.17

package/lib/BusManager.js

@@ -32,10 +32,19 @@ 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;
+        // promise set while a housekeeping cycle is actively running (from subscribe
+        // through cleanOut's unsubscribe), null otherwise. startHousekeeping awaits it
+        // so a new cycle cannot start its own subscribe/ping sequence while a prior
+        // cycle — even an interrupted one — is still unwinding. without this, an
+        // interrupted cycle A and a new cycle B overlap: B resets peerHousekeep and
+        // re-subscribes, but retained peer-join messages arrive after B's ping timer,
+        // causing every alive peer to be rejected as "not joined anymore".
+        this.housekeepingCycleInProgress = null;
+        // resolver for the current cycle's promise. pingAllPeersAlive schedules
+        // cleanOut which calls this when the cycle is fully done (subscriptions
+        // cleaned up). if a cycle is interrupted, cleanOut still runs its unsubscribe
+        // path and resolves the promise.
+        this.resolveHousekeepingCycle = null;
         this.chatManagers = {};
         this.switchBoardURI = null;
     }
@@ -124,11 +133,15 @@ 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;
+        // wait for any in-flight cycle to fully unwind (subscriptions cleaned up and
+        // rooms mutations settled) before starting a new one. this guards two races:
+        //  1. a still-running cleanOut's slow stopServerSidePortScripts finishes (and
+        //     deletes from this.rooms) after a new cycle already snapshotted them.
+        //  2. an interrupted cycle's pingAllPeersAlive/cleanOut is still pending while
+        //     a new cycle resets peerHousekeep and pings — every response then gets
+        //     rejected as "not joined anymore" because peerHousekeep was wiped.
+        if (this.housekeepingCycleInProgress) {
+            await this.housekeepingCycleInProgress;
         }
         // we dont want to start another housekeeping process until the previous one has finished
         if(!this.houseKeepingInProgress){
@@ -137,6 +150,11 @@ class BusManager {
             // they no longer own the housekeeping state and bail out.
             this.housekeepingId += 1;
             const myId = this.housekeepingId;
+            // claim the cycle promise up front so any overlapping startHousekeeping call
+            // will await this cycle's completion rather than racing it.
+            this.housekeepingCycleInProgress = new Promise((resolve) => {
+                this.resolveHousekeepingCycle = resolve;
+            });
             console.log(`  -> starting housekeeping -> gather all peers ...`);
             this.peerHousekeep = {};
             this.roomHousekeep = Object.assign({}, this.rooms); // clone the current room list
@@ -275,79 +293,82 @@ class BusManager {
      */
     cleanOut = async (myId) => {
         // if a newer cycle has started, this callback belongs to an interrupted cycle — drop it.
+        // note: this can only happen if housekeepingId was bumped without awaiting the prior
+        // cycle's promise (shouldn't happen with the await in startHousekeeping), but we keep
+        // the guard as defense in depth.
         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);
-                        }
+        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
                     };
-                    await housekeeping();
 
-                    console.log(`      -> housekeeping DONE`);
-                } else {
-                    console.log(`      -> housekeeping was interrupted`);
+                    // 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();
 
-                // 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;
+                console.log(`      -> housekeeping DONE`);
+            } else {
+                console.log(`      -> housekeeping was interrupted`);
             }
-        })();
-        await this.cleanOutInProgress;
+
+            // 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 {
+            // resolve the cycle promise so any awaiting startHousekeeping can proceed.
+            // done in finally so an exception inside the try block cannot deadlock the next cycle.
+            const resolve = this.resolveHousekeepingCycle;
+            this.housekeepingCycleInProgress = null;
+            this.resolveHousekeepingCycle = null;
+            if (resolve) resolve();
+        }
     }
 
     /**

package/package.json

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