aes70 2.0.14 → 2.0.16

package/src/controller/node_udp.js

@@ -1,14 +1,16 @@
 /* eslint-env node */
 
 import { createSocket } from 'dgram';
-import { isIP } from 'net';
+import { isIP, isIPv4 } from 'net';
 import { lookup } from 'dns';
+import { Subscriptions } from '../utils/subscriptions.js';
+import { subscribeEvent } from '../utils/subscribeEvent.js';
 
-function lookup_address(host) {
+function lookup_address(host, family) {
   if (isIP(host)) return Promise.resolve(host);
 
   return new Promise((resolve, reject) => {
-    lookup(host, { family: 4 }, (err, address) => {
+    lookup(host, { family }, (err, address) => {
       if (err) reject(err);
       else resolve(address);
     });
@@ -52,7 +54,11 @@ export class NodeUDP {
     this._inbuf = [];
 
     for (let i = 0; i < inbuf.length; i++) {
-      onmessage(inbuf[i].buffer);
+      try {
+        onmessage(inbuf[i].buffer);
+      } catch (err) {
+        console.error(err);
+      }
     }
   }
 
@@ -73,30 +79,11 @@ export class NodeUDP {
     this.socket.send(Buffer.from(buf));
   }
 
-  receiveMessage(timeout) {
-    return new Promise((resolve, reject) => {
-      if (this._error) {
-        reject(this._error);
-      } else if (this._inbuf.length) {
-        resolve(this._inbuf.shift());
-      } else {
-        this.onmessage = (msg) => {
-          this.onmessage = null;
-          this.onerror = null;
-          resolve(msg);
-        };
-        this.onerror = (err) => {
-          this.onmessage = null;
-          this.onerror = null;
-          reject(err);
-        };
-      }
-    });
-  }
-
   close() {
-    this.socket.close();
-    this.socket = null;
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
   }
 
   constructor(socket) {
@@ -114,14 +101,63 @@ export class NodeUDP {
     });
   }
 
-  static connect(host, port, type) {
-    return lookup_address(host).then((ip) => {
-      return new Promise((resolve, reject) => {
-        const socket = createSocket(type || 'udp4');
+  /**
+   * Creates a new udp socket and connects it to the target address.
+   * @param {string} options.host
+   *  The hostname or ip address to connect to.
+   * @param {number} options.port
+   *  The port.
+   * @param {'udp4' | 'udp6'} [options.type]
+   *  The ip protocol to use. This is only relevant if host is
+   *  not an ip address and hostname lookup is used.
+   * @param {Abortsignal} [options.signal]
+   *  An optional AbortSignal to abort the connect operation.
+   * @returns
+   */
+  static connect(options) {
+    const { host, port, type, signal } = options;
+
+    signal?.throwIfAborted();
+
+    const subscriptions = new Subscriptions();
+
+    return new Promise((resolve, reject) => {
+      let socket;
+
+      if (signal) {
+        subscriptions.add(
+          subscribeEvent(signal, 'abort', (reason) => {
+            const err = signal.reason;
+            reject(err);
+          })
+        );
+      }
+
+      const lookupFamily =
+        type === 'udp4' ? 4 : type === 'udp6' ? 6 : undefined;
+      lookup_address(host, lookupFamily).then((ip) => {
+        if (signal?.aborted) {
+          // IF the abort signal was triggered during the ip lookup,
+          // we have to simply ignore the resolve result.
+          return;
+        }
+        const type = isIPv4(ip) ? 'udp4' : 'udp6';
+        socket = createSocket(type);
+
+        if (signal) {
+          subscriptions.add(
+            subscribeEvent(signal, 'abort', () => {
+              socket.close();
+            })
+          );
+        }
+
         const onerror = function (ev) {
           reject(ev);
+          socket.close();
         };
-        socket.on('error', onerror);
+        subscriptions.add(subscribeEvent(socket, 'error', onerror));
+
         socket.bind(
           {
             exclusive: true,
@@ -129,12 +165,11 @@ export class NodeUDP {
           () => {
             socket.on('connect', () => {
               resolve(new this(socket));
-              socket.removeListener('error', onerror);
             });
-            socket.connect(port, host);
+            socket.connect(port, ip);
           }
         );
-      });
-    });
+      }, reject);
+    }).finally(() => subscriptions.unsubscribe());
   }
 }

package/src/controller/property.js

@@ -56,8 +56,7 @@ export class Property {
    * @returns {Function} The getter. If none could be found, null is returned.
    */
   getter(o, no_bind) {
-    let name = this.name;
-    let i = 0;
+    const name = this.name;
     const aliases = this.aliases;
     const accessors = this.accessors;
 
@@ -99,10 +98,13 @@ export class Property {
       return no_bind ? fun : fun.bind(o);
     }
 
-    do {
+    // iterate all possible names
+    const possibleNames = aliases ? [name, ...aliases] : [name];
+
+    for (const possibleName of possibleNames) {
       if (this.static) {
         const c = o.constructor;
-        const v = c[name];
+        const v = c[possibleName];
 
         if (v !== void 0) {
           return function () {
@@ -110,16 +112,11 @@ export class Property {
           };
         }
       } else {
-        const fun = o['Get' + name];
+        const fun = o['Get' + possibleName];
 
         if (fun) return no_bind ? fun : fun.bind(o);
       }
-
-      if (aliases && i < aliases.length) {
-        name = aliases[i++];
-        continue;
-      }
-    } while (false);
+    }
 
     return null;
   }
@@ -135,20 +132,15 @@ export class Property {
   setter(o, no_bind) {
     if (this.readonly || this.static) return null;
 
-    let name = this.name,
-      i = 0;
+    const name = this.name;
     const aliases = this.aliases;
+    const possibleNames = aliases ? [name, ...aliases] : [name];
 
-    do {
-      const fun = o['Set' + name];
+    for (const possibleName of possibleNames) {
+      const fun = o['Set' + possibleName];
 
       if (fun) return no_bind ? fun : fun.bind(o);
-
-      if (aliases && i < aliases.length) {
-        name = aliases[i++];
-        continue;
-      }
-    } while (false);
+    }
 
     return null;
   }

package/src/events.js

@@ -4,12 +4,13 @@
 export class Events {
   constructor() {
     this.event_handlers = new Map();
+    this.event_handlers_cleared = false;
   }
 
   /**
    * Emit an event.
    *
-   * @param {String} name - Name of the event.
+   * @param {string} name - Name of the event.
    * @param {...*} args - Extra arguments.
    */
   emit(name) {
@@ -30,7 +31,7 @@ export class Events {
   /**
    * Subscribe to an event.
    *
-   * @param {String} name - Name of the event.
+   * @param {string} name - Name of the event.
    * @param {Function} cb - Callback function.
    */
   on(name, cb) {
@@ -54,14 +55,17 @@ export class Events {
   /**
    * Removes an event handler.
    *
-   * @param {String} name - Name of the event.
+   * @param {string} name - Name of the event.
    * @param {Function} cb - Callback function.
    */
   removeEventListener(name, cb) {
     const handlers = this.event_handlers.get(name);
 
     if (!handlers || !handlers.has(cb)) {
-      throw new Error('removeEventListeners(): not installed.');
+      if (!this.event_handlers_cleared) {
+        console.warn('removeEventListeners(): not installed:', name, cb);
+      }
+      return;
     }
 
     handlers.delete(cb);
@@ -70,7 +74,7 @@ export class Events {
   /**
    * Removes an event handler.
    *
-   * @param {strign} name
+   * @param {string} name
    * @param {Function} cb
    */
   off(name, cb) {
@@ -82,6 +86,7 @@ export class Events {
    */
   removeAllEventListeners() {
     this.event_handlers.clear();
+    this.event_handlers_cleared = true;
   }
 
   /**

package/src/utils/subscribeEvent.js

@@ -0,0 +1,32 @@
+function addEvent(target, name, callback) {
+  if (target.addEventListener) {
+    target.addEventListener(name, callback);
+  } else if (target.on) {
+    target.on(name, callback);
+  } else {
+    throw new TypeError('Unsupported event target ', target);
+  }
+}
+
+function removeEvent(target, name, callback) {
+  if (target.removeEventListener) {
+    target.removeEventListener(name, callback);
+  } else if (target.off) {
+    target.off(name, callback);
+  } else {
+    throw new TypeError('Unsupported event target ', target);
+  }
+}
+
+/**
+ *
+ * @param {EventTarget|Events} target
+ * @param {string} name
+ * @param {callback} callback
+ */
+export function subscribeEvent(target, name, callback) {
+  addEvent(target, name, callback);
+  return () => {
+    removeEvent(target, name, callback);
+  };
+}

package/src/utils/subscriptions.js

@@ -0,0 +1,27 @@
+export class Subscriptions {
+  constructor() {
+    this._callbacks = [];
+  }
+
+  /**
+   * Add a subscription.
+   *
+   * @param {Function[]} cbs
+   */
+  add(...cbs) {
+    cbs.forEach((cb) => {
+      this._callbacks.push(cb);
+    });
+  }
+
+  unsubscribe() {
+    this._callbacks.forEach((cb) => {
+      try {
+        cb();
+      } catch (err) {
+        console.error(err);
+      }
+    });
+    this._callbacks.length = 0;
+  }
+}

package/src/utils/timer.js

@@ -0,0 +1,123 @@
+function isItTime(target, now) {
+  // We are ok with 1ms accuracy.
+  return target - now < 1;
+}
+
+export class Timer {
+  constructor(callback, getNow) {
+    this._callback = callback;
+    this._getNow = getNow;
+    this._targetTime = undefined;
+    this._timerId = undefined;
+    this._timerAt = undefined;
+  }
+
+  poll() {
+    const now = this._getNow();
+
+    if (this._targetTime === undefined) return;
+
+    if (isItTime(this._targetTime, now)) {
+      this._targetTime = undefined;
+      try {
+        this._callback();
+      } catch (err) {
+        console.error('Timer callback threw an exception', err);
+      }
+    } else {
+      this._reschedule();
+    }
+  }
+
+  _reschedule() {
+    const target = this._targetTime;
+    const interval = target - this._getNow();
+
+    if (this._timerId !== undefined) {
+      if (target >= this._timerAt) {
+        // The timer will fire before target. We will then reschedule it.
+        return;
+      }
+
+      clearTimeout(this._timerId);
+      this._timerId = undefined;
+    }
+
+    this._timerAt = target;
+    this._timerId = setTimeout(() => {
+      this._timerId = undefined;
+      this._timerAt = undefined;
+      this.poll();
+    }, Math.max(0, interval));
+  }
+
+  /**
+   *
+   * @param {number} interval
+   *   Interval in milliseconds.
+   */
+  scheduleIn(interval) {
+    if (!(interval >= 0)) {
+      throw new TypeError(`Expected positive interval.`);
+    }
+
+    this._targetTime = this._getNow() + interval;
+    this._reschedule();
+  }
+
+  /**
+   * Schedule the timer in a given number of milliseconds. If the timer
+   * is already running and scheduled to run before, do not modify it.
+   *
+   * @param {number} interval
+   */
+  scheduleDeadlineIn(interval) {
+    if (!(interval >= 0)) {
+      throw new TypeError(`Expected positive interval.`);
+    }
+
+    const target = this._getNow() + interval;
+
+    if (this._targetTime !== undefined && this._targetTime <= target) {
+      this.poll();
+      return;
+    }
+
+    this.scheduleAt(target);
+  }
+
+  /**
+   *
+   * @param {number} target
+   *   Target time in milliseconds.
+   */
+  scheduleAt(target) {
+    if (!(target >= 0)) {
+      throw new TypeError();
+    }
+
+    this._targetTime = target;
+    this._reschedule();
+  }
+
+  stop() {
+    this._targetTime = undefined;
+  }
+
+  cancel() {
+    this.stop();
+    this._clearTimeout();
+  }
+
+  _clearTimeout() {
+    if (this._timerId) {
+      clearTimeout(this._timerId);
+      this._timerId = undefined;
+      this._timerAt = undefined;
+    }
+  }
+
+  dispose() {
+    this.cancel();
+  }
+}