aes70 2.0.14 → 2.0.15

package/dist/AES70.es5.js

@@ -31,12 +31,13 @@
   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) {
@@ -57,7 +58,7 @@
     /**
      * 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) {
@@ -81,14 +82,17 @@
     /**
      * 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);
@@ -97,7 +101,7 @@
     /**
      * Removes an event handler.
      *
-     * @param {strign} name
+     * @param {string} name
      * @param {Function} cb
      */
     off(name, cb) {
@@ -109,6 +113,7 @@
      */
     removeAllEventListeners() {
       this.event_handlers.clear();
+      this.event_handlers_cleared = true;
     }
 
     /**
@@ -1585,6 +1590,67 @@
     }
   }
 
+  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;
+    }
+  }
+
+  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
+   */
+  function subscribeEvent(target, name, callback) {
+    addEvent(target, name, callback);
+    return () => {
+      removeEvent(target, name, callback);
+    };
+  }
+
   class PendingCommand {
     get handle() {
       return this.command.handle;
@@ -1829,35 +1895,34 @@
      * the connection will be closed and the returned promise will reject.
      * @param {number} interval
      *   Keepalive interval in seconds.
+     * @param {AbortSignal} [signal]
+     *   Optional abort signal which can be used to abort
+     *   the process.
      */
-    wait_for_keepalive(interval) {
-      return new Promise((resolve, reject) => {
-        const subscriptions = [];
+    wait_for_keepalive(interval, signal) {
+      const subscriptions = new Subscriptions();
 
-        const cleanup = () => {
-          subscriptions.forEach((cb) => {
-            try {
-              cb();
-            } catch (e) {}
-          });
-          subscriptions.length = 0;
-        };
-        subscriptions.push(
+      return new Promise((resolve, reject) => {
+        if (signal) {
+          subscriptions.add(
+            subscribeEvent(signal, 'abort', () => {
+              reject(signal.reason);
+            })
+          );
+        }
+        subscriptions.add(
           this.subscribe('error', (error) => {
             reject(error);
-            cleanup();
           }),
           this.subscribe('close', () => {
             reject(new CloseError());
-            cleanup();
           }),
           this.subscribe('keepalive', () => {
             resolve();
-            cleanup();
           })
         );
         this.set_keepalive_interval(interval);
-      });
+      }).finally(() => subscriptions.unsubscribe());
     }
   }
 
@@ -3486,8 +3551,7 @@
      * @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;
 
@@ -3529,10 +3593,13 @@
         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 () {
@@ -3540,16 +3607,11 @@
             };
           }
         } 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;
     }
@@ -3565,20 +3627,15 @@
     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;
     }
@@ -28733,35 +28790,6 @@
 
   /* eslint-env node */
 
-
-  function delay(n) {
-    return new Promise((resolve) => setTimeout(resolve, n));
-  }
-
-  async function waitForKeepalive(socket, options) {
-    const waiter = socket.receiveMessage().then((buffer) => {
-      const pdus = [];
-      const pos = decodeMessage(new DataView(buffer), 0, pdus);
-
-      if (pdus.length !== 1) throw new Error('Expected keepalive response.');
-      if (pos !== buffer.byteLength)
-        throw new Error('Trailing data in initial keepalive pdu.');
-
-      return true;
-    });
-
-    const msg = encodeMessage(new KeepAlive(1000));
-    const t = 5 * (options.retry_interval || 250);
-
-    for (let i = 0; i < 3; i++) {
-      socket.send(msg);
-
-      if (await Promise.race([waiter, delay(t)])) return;
-    }
-
-    throw new Error('Failed to connect.');
-  }
-
   /**
    * :class:`ClientConnection` subclass which implements OCP.1 with UDP
    * transport.
@@ -28807,8 +28835,12 @@
     /**
      * Connect to the given endpoint.
      *
-     * @param {String} options.host - hostname or ip
-     * @param {number} options.port - port number
+     * @param {String} options.host
+     *  Hostname or ip address.
+     * @param {number} options.port
+     *  Port number.
+     * @param {'udp4' | 'udp6'} [options.type]
+     *  Optional ip protocol type.
      * @param {number} [options.delay=10] - Delay in ms between individual packets.
      *    This can be a useful strategy when communicating with devices which
      *    cannot handle high packet rates.
@@ -28822,23 +28854,33 @@
      *    in an individual UDP packet. Note that AES70 messages which are larger
      *    than this limit are sent anyway. This only limits how many seperate
      *    messages are batched into a single packet.
-     * @returns {Promise<UDPConnection>}
+     * @param {AbortSignal} [options.connectSignal]
+     *    An optional AbortSignal which can be used to abort the connect attempt.
+     *    Note that this is different from the `signal` option which will destroy
+     *    the socket also after the connect attempt has been successful.
+     * @returns {Promise<AbstractUDPConnection>}
      *    The connection.
      */
     static async connect(udpApi, options) {
-      const socket = await udpApi.connect(
-        options.host,
-        options.port,
-        options.type
-      );
+      const { host, port, type, connectSignal } = options;
+      const socket = await udpApi.connect({
+        host,
+        port,
+        type,
+        signal: connectSignal,
+      });
+
+      const connection = new this(socket, options);
 
       try {
-        await waitForKeepalive(socket, options);
-        return new this(socket, options);
+        await connection.wait_for_keepalive(1, connectSignal);
+        connectSignal?.throwIfAborted();
       } catch (err) {
-        socket.close();
+        connection.close();
         throw err;
       }
+
+      return connection;
     }
 
     write(buf) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aes70",
-  "version": "2.0.14",
+  "version": "2.0.15",
   "description": "A controller library for the AES70 protocol.",
   "type": "module",
   "main": "src/index.js",

package/src/controller/abstract_udp_connection.js

@@ -1,38 +1,6 @@
 /* eslint-env node */
-
-import { encodeMessage } from '../OCP1/encode_message.js';
-import { decodeMessage } from '../OCP1/decode_message.js';
-import { KeepAlive } from '../OCP1/keepalive.js';
 import { ClientConnection } from './client_connection.js';
 
-function delay(n) {
-  return new Promise((resolve) => setTimeout(resolve, n));
-}
-
-async function waitForKeepalive(socket, options) {
-  const waiter = socket.receiveMessage().then((buffer) => {
-    const pdus = [];
-    const pos = decodeMessage(new DataView(buffer), 0, pdus);
-
-    if (pdus.length !== 1) throw new Error('Expected keepalive response.');
-    if (pos !== buffer.byteLength)
-      throw new Error('Trailing data in initial keepalive pdu.');
-
-    return true;
-  });
-
-  const msg = encodeMessage(new KeepAlive(1000));
-  const t = 5 * (options.retry_interval || 250);
-
-  for (let i = 0; i < 3; i++) {
-    socket.send(msg);
-
-    if (await Promise.race([waiter, delay(t)])) return;
-  }
-
-  throw new Error('Failed to connect.');
-}
-
 /**
  * :class:`ClientConnection` subclass which implements OCP.1 with UDP
  * transport.
@@ -78,8 +46,12 @@ export class AbstractUDPConnection extends ClientConnection {
   /**
    * Connect to the given endpoint.
    *
-   * @param {String} options.host - hostname or ip
-   * @param {number} options.port - port number
+   * @param {String} options.host
+   *  Hostname or ip address.
+   * @param {number} options.port
+   *  Port number.
+   * @param {'udp4' | 'udp6'} [options.type]
+   *  Optional ip protocol type.
    * @param {number} [options.delay=10] - Delay in ms between individual packets.
    *    This can be a useful strategy when communicating with devices which
    *    cannot handle high packet rates.
@@ -93,23 +65,33 @@ export class AbstractUDPConnection extends ClientConnection {
    *    in an individual UDP packet. Note that AES70 messages which are larger
    *    than this limit are sent anyway. This only limits how many seperate
    *    messages are batched into a single packet.
-   * @returns {Promise<UDPConnection>}
+   * @param {AbortSignal} [options.connectSignal]
+   *    An optional AbortSignal which can be used to abort the connect attempt.
+   *    Note that this is different from the `signal` option which will destroy
+   *    the socket also after the connect attempt has been successful.
+   * @returns {Promise<AbstractUDPConnection>}
    *    The connection.
    */
   static async connect(udpApi, options) {
-    const socket = await udpApi.connect(
-      options.host,
-      options.port,
-      options.type
-    );
+    const { host, port, type, connectSignal } = options;
+    const socket = await udpApi.connect({
+      host,
+      port,
+      type,
+      signal: connectSignal,
+    });
+
+    const connection = new this(socket, options);
 
     try {
-      await waitForKeepalive(socket, options);
-      return new this(socket, options);
+      await connection.wait_for_keepalive(1, connectSignal);
+      connectSignal?.throwIfAborted();
     } catch (err) {
-      socket.close();
+      connection.close();
       throw err;
     }
+
+    return connection;
   }
 
   write(buf) {

package/src/controller/client_connection.js

@@ -9,6 +9,8 @@ import { Arguments } from './arguments.js';
 import { OcaStatus } from '../types/OcaStatus.js';
 import { EncodedArguments } from '../OCP1/encoded_arguments.js';
 import { CloseError } from '../close_error.js';
+import { Subscriptions } from '../utils/subscriptions.js';
+import { subscribeEvent } from '../utils/subscribeEvent.js';
 
 class PendingCommand {
   get handle() {
@@ -254,34 +256,33 @@ export class ClientConnection extends Connection {
    * the connection will be closed and the returned promise will reject.
    * @param {number} interval
    *   Keepalive interval in seconds.
+   * @param {AbortSignal} [signal]
+   *   Optional abort signal which can be used to abort
+   *   the process.
    */
-  wait_for_keepalive(interval) {
+  wait_for_keepalive(interval, signal) {
+    const subscriptions = new Subscriptions();
+
     return new Promise((resolve, reject) => {
-      const subscriptions = [];
-
-      const cleanup = () => {
-        subscriptions.forEach((cb) => {
-          try {
-            cb();
-          } catch (e) {}
-        });
-        subscriptions.length = 0;
-      };
-      subscriptions.push(
+      if (signal) {
+        subscriptions.add(
+          subscribeEvent(signal, 'abort', () => {
+            reject(signal.reason);
+          })
+        );
+      }
+      subscriptions.add(
         this.subscribe('error', (error) => {
           reject(error);
-          cleanup();
         }),
         this.subscribe('close', () => {
           reject(new CloseError());
-          cleanup();
         }),
         this.subscribe('keepalive', () => {
           resolve();
-          cleanup();
         })
       );
       this.set_keepalive_interval(interval);
-    });
+    }).finally(() => subscriptions.unsubscribe());
   }
 }

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;
+  }
+}