Persisting a socket on disconnect until a condition is met?

[scalemaildev]

Hello~

As part of an app I'm writing, each connected user's socket has an array of tasks to perform. Every few milliseconds, this array is accessed by a coroutine that runs server-side. When a user disconnects from the server, I'd like their socket to persist until this array is empty.

Is there some way to keep a user's socket alive until a condition is met? In this case: until their socket's array is length 0?

Thanks.

Edit: Or, if there's better architecture for this sort of thing feel free to redirect.

[scalemaildev]

This is the pattern I ended up using:

The server has a "post office", and when a user creates a game their socket is given an entry in the post office. Each game that user creates has its own entry as well (because the user might start a new game while the old game is still sending messages). The function of the post office is to hold a queue of messages to send, and then run a daemon that occasionally checks for the queue new messages (using setInterval).

This continues until the socket's disconnect message tells the post office their socket is no longer active. Then the post office will teardown the entries for that socket's games once their message queues are empty. When all of an inactive socket's queues are emptied it's scrubbed from the post office.

/* Post Office */
var postOffice = {};

const addGameToPostOffice = function(socketId, gameId) {
    // each game gets its own post daemon
    postOffice[socketId].games[gameId] = {};
    postOffice[socketId].games[gameId].letterBox = new TinyQueue;
    postOffice[socketId].games[gameId].sending = false;
    
    postOffice[socketId].games[gameId].postDaemon = messageCoroutine(async function*() {
        while (postOffice[socketId].games[gameId].letterBox.length > 0 || postOffice[socketId].activeSocket) {
            
            yield; // loop entry point for setInterval
            
            if (postOffice[socketId].games[gameId].sending) {
                // daemon is still working
                // TODO: this check might not be necessary
                continue;
            }
                
            if (postOffice[socketId].games[gameId].letterBox.length == 0) {
                // letterbox is empty. wait for next interval
                continue;
            }

            while (postOffice[socketId].games[gameId].letterBox.length > 0) {
                // send all message
                postOffice[socketId].games[gameId].sending = true;
                let message = postOffice[socketId].games[gameId].letterBox.first.item;
                let response = await Hashgraph.sendTopicMessage(postOffice[socketId].hederaClient, gameId, message);
                if (response) {
                    postOffice[socketId].games[gameId].letterBox.shift();
                    
                    // TODO: tell socket to clear any failed send warning

                    // give hcs a little time to see it
                    await new Promise(r => setTimeout(r, 250)); // TODO: not needed after next refactor
                } else {
                    // TODO: emit a failed send warning to the socket here
                    // TODO: socket should use that to tell player

                    // wait 3 seconds before trying again
                    await new Promise(r => setTimeout(r, 3000));
                }
            }

            postOffice[socketId].games[gameId].sending = false;
        }

        // socket has disconnected. delete this routine from the postOffice
        console.log(`Deleting game ${gameId} from socket ${socketId}'s post daemon...`);
        await new Promise(r => setTimeout(r, 2000)); // ensure hcs has time to catch up
        delete postOffice[socketId].games[gameId];
        scrubSocketFromPostOffice(socketId);
    });
};

Helpers:

const checkPostOfficeForGame = function(gameId) {
    for (const [key, value] of Object.entries(postOffice)) {
        for (const [game, gameVals] of Object.entries(value.games)) {
            if (game == gameId) { return true; }
        }
    }

    return false;
};

const scrubSocketFromPostOffice = async function(socketId) {
    if (Object.keys(postOffice[socketId].games).length === 0) {
        console.log(`Removing ${socketId} from the post office...`);
        delete postOffice[socketId];
    }
};

However, the teardown aspect still doesn't feel very eloquent. In order to fully remove a player from the server once all their messages are sent, the post office has to be checked using a nested for loop. I don't think there will be more than a few hundred or so players on a single server though, and each player likely won't have more than one game going for very long. The teardown of the games as opposed to the socket is also desegmented so that there won't be orphaned daemons checking empty queues for a players past games.

I think I will continue to refactor this.

[darrachequesne]

That sounds a bit complicated, but if it fixes your issue, then that's great!