@quakejs/master 1.0.17 → 1.0.18

package/master-client.js

@@ -2,40 +2,36 @@ import MasterBase from './master-base.js';
 
 class MasterClient extends MasterBase {
   #onserver;
-  #master;
 
   constructor (onserver) {
     super();
 
     this.#onserver = onserver;
-    this.#master = null;
   }
 
   subscribe (host, port) {
-    let resendTimeout;
-
-    if (this.#master) {
-      try {
-        this.#master.close();
-      } catch (e) {
-        console.error(e);
-      } finally {
-        this.#master = null;
-      }
-    }
+    const session = new WebTransport(`${host}:${port}`);
 
-    this.#master = new WebTransport(`${host}:${port}`);
+    /* prevent unhandled rejections before main loop */
+    session.ready.catch(() => {});
+    session.closed.catch(() => {});
 
     (async () => {
       try {
-        await this.#master.ready;
+        const sessionClosed = session.closed.then(
+          () => ({ done: true, value: null }),
+          (err) => { throw err; }
+        );
 
-        const writer = this.#master.datagrams.writable.getWriter();
-        const reader = this.#master.datagrams.readable.getReader();
+        await session.ready;
+
+        const writer = session.datagrams.writable.getWriter();
+        const reader = session.datagrams.readable.getReader();
+        let resendTimeout;
 
         /* send until a response is received */
         const send = () => {
-          writer.write(this.encode('subscribe'));
+          writer.write(this.encode('subscribe')).catch(() => {});
 
           resendTimeout = setTimeout(send, 1000);
         };
@@ -44,7 +40,10 @@ class MasterClient extends MasterBase {
 
         /* read responses */
         while (true) {
-          const { done, value } = await reader.read();
+          const { done, value } = await Promise.race([
+            reader.read(),
+            sessionClosed
+          ]);
 
           clearTimeout(resendTimeout);
 
@@ -62,100 +61,146 @@ class MasterClient extends MasterBase {
             }
           }
         }
+
+        console.log(`Disconnected from master server`);
       } catch (e) {
-        console.error(`Stream error, connection to ${host}:${port} lost`, e);
+        console.error('Disconnected from master server due to error', e);
       } finally {
-        this.#master = null;
+        clearTimeout(resendTimeout);
       }
     })();
   }
 
   async getinfo (addr, port) {
     const session = new WebTransport(`https://${addr}:${port}`);
-    const writer = session.datagrams.writable.getWriter();
-    const reader = session.datagrams.readable.getReader();
     let resendTimeout;
-    let begin;
+    let res;
 
-    await session.ready;
+    session.ready.catch(() => {});
+    session.closed.catch(() => {});
 
-    /* send request multiple times until something is read back */
-    const send = () => {
-      begin = performance.now();
+    try {
+      const sessionClosed = session.closed.then(
+        () => ({ done: true, value: null }),
+        (err) => { throw err; }
+      );
 
-      writer.write(this.encode('getinfo'));
+      await session.ready;
 
-      resendTimeout = setTimeout(send, 3000);
-    };
+      const writer = session.datagrams.writable.getWriter();
+      const reader = session.datagrams.readable.getReader();
+      let begin;
 
-    send();
+      /* send request multiple times until something is read back */
+      const send = () => {
+        begin = performance.now();
 
-    /* read response */
-    const { done, value } = await reader.read();
+        writer.write(this.encode('getinfo')).catch(() => {});
 
-    clearTimeout(resendTimeout);
+        resendTimeout = setTimeout(send, 3000);
+      };
 
-    if (done) {
-      throw new Error('getinfo failed, no response received');
-    }
+      send();
 
-    console.log(`${addr}:${port} ---> ${this.pretty(value)}`);
+      /* read response */
+      const { done, value } = await Promise.race([
+        reader.read(),
+        sessionClosed
+      ]);
 
-    const msg = this.decode(value);
+      clearTimeout(resendTimeout);
 
-    if (!msg || msg.type !== 'infoResponse') {
-      throw new Error('getinfo failed, didn\'t receive infoResponse');
-    }
+      if (done) {
+        throw new Error('stream closed');
+      }
+
+      console.log(`${addr}:${port} ---> ${this.pretty(value)}`);
 
-    msg.info.ping = Math.min((performance.now() - begin) >>> 0, 999);
+      const msg = this.decode(value);
 
-    session.close();
+      if (!msg || msg.type !== 'infoResponse') {
+        throw new Error('invalid response type');
+      }
 
-    return msg.info;
+      msg.info.ping = Math.min((performance.now() - begin) >>> 0, 999);
+
+      res = msg.info;
+    } catch (e) {
+      console.error('getinfo failed', e);
+      throw e;
+    } finally {
+      clearTimeout(resendTimeout);
+
+      session.close();
+    }
+
+    return res;
   }
 
   async getstatus (addr, port) {
     const session = new WebTransport(`https://${addr}:${port}`);
-    const writer = session.datagrams.writable.getWriter();
-    const reader = session.datagrams.readable.getReader();
     let resendTimeout;
-    let begin;
+    let res;
 
-    await session.ready;
+    session.ready.catch(() => {});
+    session.closed.catch(() => {});
 
-    /* send request multiple times until something is read back */
-    const send = () => {
-      begin = performance.now();
+    try {
+      const sessionClosed = session.closed.then(
+        () => ({ done: true, value: null }),
+        (err) => { throw err; }
+      );
 
-      writer.write(this.encode('getstatus'));
+      await session.ready;
 
-      resendTimeout = setTimeout(send, 3000);
-    };
+      const writer = session.datagrams.writable.getWriter();
+      const reader = session.datagrams.readable.getReader();
+      let begin;
 
-    send();
+      /* send request multiple times until something is read back */
+      const send = () => {
+        begin = performance.now();
 
-    /* read response */
-    const { done, value } = await reader.read();
+        writer.write(this.encode('getstatus')).catch(() => {});
 
-    clearTimeout(resendTimeout);
+        resendTimeout = setTimeout(send, 3000);
+      };
 
-    if (done) {
-      throw new Error('getstatus failed, no response received');
-    }
+      send();
 
-    console.log(`${addr}:${port} ---> ${this.pretty(value)}`);
+      /* read response */
+      const { done, value } = await Promise.race([
+        reader.read(),
+        sessionClosed
+      ]);
 
-    const msg = this.decode(value);
+      clearTimeout(resendTimeout);
 
-    if (!msg || msg.type !== 'statusResponse') {
-      throw new Error('getstatus failed, didn\'t receive statusResponse');
-    }
+      if (done) {
+        throw new Error('stream closed');
+      }
 
-    msg.info.ping = Math.min((performance.now() - begin) >>> 0, 999);
+      console.log(`${addr}:${port} ---> ${this.pretty(value)}`);
 
-    session.close();
+      const msg = this.decode(value);
+
+      if (!msg || msg.type !== 'statusResponse') {
+        throw new Error('invalid response type');
+      }
+
+      msg.info.ping = Math.min((performance.now() - begin) >>> 0, 999);
+
+      res = { info: msg.info, players: msg.players };
+    } catch (e) {
+      console.error('getstatus failed', e);
+      throw e;
+    } finally {
+      clearTimeout(resendTimeout);
+
+      session.close();
+    }
 
-    return { info: msg.info, players: msg.players };
+    return res;
   }
 }
 

package/master-server.js

@@ -158,11 +158,20 @@ class MasterServer extends MasterBase {
             break;
           }
 
+          /* prevent unhandled rejections before main loop */
+          session.ready.catch(() => {});
+          session.closed.catch(() => {});
+
           (async () => {
             try {
+              const sessionClosed = session.closed.then(
+                () => ({ done: true, value: null }),
+                (err) => { throw err; }
+              );
+
               await session.ready;
 
-              const writer = session.datagrams.createWritable().getWriter();
+              const writer = session.datagrams.writable.getWriter();
               const reader = session.datagrams.readable.getReader();
               const [addr, port] = session.peerAddress.split(':');
               let first = true;
@@ -171,11 +180,14 @@ class MasterServer extends MasterBase {
               session.port = port;
 
               session.write = (data) => {
-                writer.write(data);
+                writer.write(data).catch(e => {});
               };
 
               while (true) {
-                const { done, value } = await reader.read();
+                const { done, value } = await Promise.race([
+                  reader.read(),
+                  sessionClosed
+                ]);
 
                 if (done) {
                   break;
@@ -214,10 +226,8 @@ class MasterServer extends MasterBase {
                     break;
                 }
               }
-
-              console.log(`Client ${session.addr}:${session.port} disconnected`);
             } catch (e) {
-              console.error(`Client ${session.addr}:${session.port} disconnected due to error`, e);
+              console.error(`Client ${session.addr}:${session.port} terminated`, e);
             } finally {
               this.#removeClient(session);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quakejs/master",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "type": "module",
   "main": "index.js",
   "bin": {