nats.deno: Suggestion: Possibility for higher resilience for connect-once, never-disconnects use cases.

Hi,

This is not an issue but a suggestion, or question maybe, and posting here instead of nats.ws as this seems to related to some logic within base-client.

We’re using nats.js / nats.ws in unstable edge-networks (powered by 4G or 3G), the application connects & subs once, and is expected to stay connected forever (and reconnects quickly)

Thus: a relatively aggressive pinging / reconnecting config is used here:

{
    noEcho: true,
    noRandomize: true,
    maxReconnectAttempts: -1,
    waitOnFirstConnect: true,
    reconnectTimeWait: 500,
    pingInterval: 3 * 1000, 
    maxPingOut: 3
}

Lately we’ve noticed when devices doing PUBs, sometimes the client will be in closed state, which causes error, and I’m sure there’s no application logic that close() the client. It seems that _close() is being called from the inside.

In this state, all subs are lost as close() cleans those up, and heartbeat also stops… If the dev wants to create a never-ending connection, he or she must re-init the connection manually, and re-init all subs manually which introduces a ‘loop like’ structure.

async function init() {
    await connect(); 
    //..all subs
}

on("closed", init);

This forces all subs into a function, or will introduce event-emitter alike structure into end-users’ code.

My suggestion here is, if reconnect == -1 which suggests ‘it never ends’, can we keep the client instance intact no matter what? & keep trying and pinging until the end of application? This will simplify edge-app complexity.

For now, we’re monkey patching _close

io.protocol._close = async () => {
        //it never dies!
        reset("Underlying structure breaks");
};

var cc = io.protocol.heartbeats.cancel.bind(io.protocol.heartbeats);
io.protocol.heartbeats.cancel = (stale) => {
   if (stale) {
      cc(stale);
      if (io.protocol.connected) {
          reset("Protocol hidden crash!");
      }
   }
   else {
       cc(stale);
   }
}

var reset_busy = false;
async function reset(e) {
    try {
        if (reset_busy) {
            console.warn("io busy", e);
            return;
        }
        reset_busy = true;
        try {
            io.protocol.transport.close();
        }
        catch (e) {
        }
        io.protocol.prepare();
        await io.protocol.dialLoop();
        io._closed = false;
        io.protocol._closed = false;
        reset_busy = false;
    } catch (e) {
        console.error(e);
    }
}

Above are some horrible logic, but keeps the problem away…

Thank you for your attention.