aes70 1.3.7 → 1.4.0

package/src/controller/abstract_udp_connection.js

@@ -0,0 +1,215 @@
+/* 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 = [];
+    let pos = 0;
+
+    pos = decodeMessage(new DataView(buffer), 0, pdus);
+
+    if (pdus.length !== 1) throw new Error('Expected keepalive response.');
+
+    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.
+ */
+export class AbstractUDPConnection extends ClientConnection {
+  constructor(socket, options) {
+    // allow us to batch 128 bytes max
+    // Set this to a higher value, e.g. close to MTU
+    // if you are sure that the device can handle it.
+    if (!(options.batch >= 0)) options.batch = 128;
+    super(options);
+    this.socket = socket;
+    this.delay = options.delay >= 0 ? options.delay : 5;
+    this.retry_interval =
+      options.retry_interval >= 0 ? options.retry_interval : 250;
+    this.retry_count = options.retry_count >= 0 ? options.retry_count : 3;
+    this._write_out_id = -1;
+    this._write_out_callback = () => {
+      this._write_out_id = -1;
+      this._write_out();
+    };
+    this._retry_id =
+      this.retry_interval > 0
+        ? setInterval(() => this._retryCommands(), this.retry_interval)
+        : -1;
+    this.q = [];
+    socket.onmessage = (buffer) => {
+      try {
+        this.read(buffer);
+      } catch (err) {
+        console.warn('Failed to parse incoming AES70 packet: %o', err);
+      }
+      if (this.inbuf !== null) this.close();
+    };
+    socket.onerror = (err) => this.error(err);
+    this.set_keepalive_interval(1);
+  }
+
+  get is_reliable() {
+    return false;
+  }
+
+  /**
+   * Connect to the given endpoint.
+   *
+   * @param {String} options.host - hostname or ip
+   * @param {number} options.port - port number
+   * @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.
+   * @param {number} [options.retry_interval=250] - Delay in ms after which a
+   *    command should be automatically re-sent if no response has been
+   *    received, yet.
+   * @param {number} [options.retry_count=3] - Number of times to retry sending
+   *    commands. If no response has been received after all retries, the
+   *    command will fail with an error.
+   * @param {number} [options.batch=128] - Maximum number of bytes to send
+   *    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>}
+   *    The connection.
+   */
+  static async connect(udpApi, options) {
+    const socket = await udpApi.connect(
+      options.host,
+      options.port,
+      options.type
+    );
+
+    await waitForKeepalive(socket, options);
+
+    return new this(socket, options);
+  }
+
+  write(buf) {
+    this.q.push(buf);
+
+    if (this.tx_idle_time() >= this.delay) this._write_out();
+    else this._schedule_write_out();
+  }
+
+  flush() {
+    super.flush();
+    if (this.tx_idle_time() > this.delay) this._write_out();
+  }
+
+  cleanup() {
+    super.cleanup();
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+    if (this._write_out_id !== -1) {
+      clearTimeout(this._write_out_id);
+      this._write_out_id = -1;
+    }
+    if (this._retry_id !== -1) {
+      clearInterval(this._retry_id);
+      this._retry_id = -1;
+    }
+  }
+
+  _estimate_next_tx_time() {
+    return this._now() + (this.delay + 2) * this.q.length;
+  }
+
+  _write_out() {
+    if (!this.socket) return;
+    const q = this.q;
+
+    if (!q.length) return;
+
+    const buf = q.shift();
+
+    this.socket.send(buf);
+    super.write(buf);
+
+    if (q.length) this._schedule_write_out();
+  }
+
+  _schedule_write_out() {
+    const tx_idle_time = this.tx_idle_time();
+    const delay = this.delay;
+
+    if (tx_idle_time >= delay) {
+      this._write_out();
+      return;
+    }
+
+    // Already scheduled.
+    if (this._write_out_id !== -1) return;
+
+    this._write_out_id = setTimeout(
+      this._write_out_callback,
+      delay - tx_idle_time
+    );
+  }
+
+  _retryCommands() {
+    const now = this._now();
+    const retryTime = now - this.retry_interval;
+    // This is an estimate for how many commands we would manage to send
+    // off.
+    const max = 5 * (this.retry_interval / this.delay) - this.q.length;
+    const pendingCommands = this._pendingCommands;
+
+    const retries = [];
+    const failed = [];
+
+    for (const entry of pendingCommands) {
+      const [, pendingCommand] = entry;
+
+      // All later commands are newer than the cutoff.
+      if (pendingCommand.lastSent > retryTime) break;
+      if (pendingCommand.retries >= this.retry_count) {
+        failed.push(entry);
+      } else if (retries.length < max) {
+        retries.push(entry);
+      }
+    }
+
+    if (failed.length) {
+      const timeoutError = new Error('Timeout.');
+
+      failed.forEach(([handle, pendingCommand]) => {
+        pendingCommands.delete(handle);
+        pendingCommand.reject(timeoutError);
+      });
+    }
+
+    retries.forEach(([handle, pendingCommand]) => {
+      pendingCommands.delete(handle);
+      pendingCommands.set(handle, pendingCommand);
+      this.send(pendingCommand.command);
+      pendingCommand.lastSent = now;
+      pendingCommand.retries++;
+    });
+  }
+}

package/src/controller/client_connection.d.ts

@@ -1,6 +1,6 @@
 import { IConnectionOptions, Connection } from '../connection';
 
-export type IClientConnectionOptions = IConnectionOptions
+export type IClientConnectionOptions = IConnectionOptions;
 
 /**
  * A generic base class for all client connections.

package/src/controller/node_udp.js

@@ -0,0 +1,140 @@
+/* eslint-env node */
+
+import { createSocket } from 'dgram';
+import { isIPv4, isIPv6 } from 'net';
+import { lookup } from 'dns';
+
+function lookup_address(host) {
+  if (isIPv4(host)) return Promise.resolve(host);
+
+  return new Promise((resolve, reject) => {
+    lookup(host, { family: 4 }, (err, address) => {
+      if (err) reject(err);
+      else resolve(address);
+    });
+  });
+}
+
+export class NodeUDP {
+  get onmessage() {
+    return this._onmessage;
+  }
+
+  set onmessage(cb) {
+    if (this._onmessage && cb)
+      throw new Error('Cannot install more than one message callback.');
+
+    this._onmessage = cb;
+    this._notifyMessage();
+  }
+
+  get onerror() {
+    return this._onerror;
+  }
+
+  set onerror(cb) {
+    if (this._onerror && cb)
+      throw new Error('Cannot install more than one error callback.');
+
+    this._onerror = cb;
+    this._notifyError();
+  }
+
+  _notifyMessage() {
+    const onmessage = this.onmessage;
+
+    if (!onmessage) return;
+
+    const inbuf = this._inbuf;
+
+    if (!inbuf.length) return;
+
+    this._inbuf = [];
+
+    for (let i = 0; i < inbuf.length; i++) {
+      onmessage(inbuf[i].buffer);
+    }
+  }
+
+  _notifyError() {
+    const onerror = this.onerror;
+
+    if (!onerror) return;
+
+    const error = this._error;
+
+    if (!error) return;
+    this._error = null;
+
+    onerror(error);
+  }
+
+  send(buf) {
+    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;
+  }
+
+  constructor(socket) {
+    this._inbuf = [];
+    this._onmessage = null;
+    this._onerror = null;
+    this.socket = socket;
+    socket.on('message', (msg, rinfo) => {
+      this._inbuf.push(msg);
+      this._notifyMessage();
+    });
+    socket.on('error', (err) => {
+      this._error = err;
+      this._notifyError(err);
+    });
+  }
+
+  static connect(host, port, type) {
+    return lookup_address(host).then((ip) => {
+      return new Promise((resolve, reject) => {
+        const socket = createSocket(type || 'udp4');
+        const onerror = function (ev) {
+          reject(ev);
+        };
+        socket.on('error', onerror);
+        socket.bind(
+          {
+            exclusive: true,
+          },
+          () => {
+            socket.on('connect', () => {
+              resolve(new this(socket));
+              socket.removeListener('error', onerror);
+            });
+            socket.connect(port, host);
+          }
+        );
+      });
+    });
+  }
+}

package/src/controller/property_event.js

@@ -12,7 +12,7 @@ import { error } from '../log.js';
 export class PropertyEvent extends BaseEvent {
   constructor(object, id, propertyType) {
     super(object, id, propertyType);
-    this.callback = (id, dataView, changeType) => {
+    this.callback = ([id, dataView, changeType]) => {
       if (
         id.DefLevel !== this.id.DefLevel ||
         id.PropertyIndex !== this.id.PropertyIndex

package/src/controller/udp_connection.js

@@ -1,284 +1,19 @@
 /* eslint-env node */
 
-import { createSocket } from 'dgram';
-import { Buffer } from 'buffer';
+import { NodeUDP } from './node_udp.js';
 import { performance } from 'perf_hooks';
-import { encodeMessage } from '../OCP1/encode_message.js';
-import { decodeMessage } from '../OCP1/decode_message.js';
-import { KeepAlive } from '../OCP1/keepalive.js';
-
-import { lookup } from 'dns';
-
-import { ClientConnection } from './client_connection.js';
-
-function delay(n) {
-  return new Promise((resolve) => setTimeout(resolve, n));
-}
-
-async function waitForKeepalive(socket, options) {
-  const waiter = new Promise((resolve, reject) => {
-    let onMessage;
-
-    onMessage = (data, rinfo) => {
-      const pdus = [];
-      let pos = 0;
-
-      pos = decodeMessage(new DataView(data.buffer), 0, pdus);
-
-      if (pdus.length !== 1) throw new Error('Expected keepalive response.');
-
-      socket.off('message', onMessage);
-      socket.off('error', reject);
-      resolve(true);
-    };
-
-    socket.on('message', onMessage);
-    socket.on('error', reject);
-  });
-
-  const msg = Buffer.from(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.');
-}
-
-function is_ip(host) {
-  let tmp = host.split('.');
-
-  if (tmp.length !== 4) return false;
-
-  tmp = tmp.map(parseInt);
-
-  return !tmp.some(function (v) {
-    return v < 0 || v > 255;
-  });
-}
-
-// TODO: handle IPv6
-function lookup_address(options) {
-  const host = options.host;
-  const port = parseInt(options.port);
-
-  const o = { port: port };
-
-  if (is_ip(host))
-    return Promise.resolve(Object.assign({}, options, o, { address: host }));
-
-  return new Promise(function (resolve, reject) {
-    lookup(host, { family: 4 }, function (err, address) {
-      if (err) reject(err);
-      else resolve(Object.assign({}, options, o, { address: address }));
-    });
-  });
-}
+import { AbstractUDPConnection } from './abstract_udp_connection.js';
 
 /**
  * :class:`ClientConnection` subclass which implements OCP.1 with UDP
  * transport.
  */
-export class UDPConnection extends ClientConnection {
-  constructor(socket, options) {
-    // allow us to batch 128 bytes max
-    // Set this to a higher value, e.g. close to MTU
-    // if you are sure that the device can handle it.
-    if (!(options.batch >= 0)) options.batch = 128;
-    super(options);
-    this.socket = socket;
-    this.delay = options.delay >= 0 ? options.delay : 5;
-    this.retry_interval =
-      options.retry_interval >= 0 ? options.retry_interval : 250;
-    this.retry_count = options.retry_count >= 0 ? options.retry_count : 3;
-    this._write_out_id = -1;
-    this._write_out_callback = () => {
-      this._write_out_id = -1;
-      this._write_out();
-    };
-    this._retry_id =
-      this.retry_interval > 0
-        ? setInterval(() => this._retryCommands(), this.retry_interval)
-        : -1;
-    this.q = [];
-    socket.on('message', (data, rinfo) => {
-      try {
-        this.read(data.buffer);
-      } catch (err) {
-        console.warn('Failed to parse incoming AES70 packet: %o', err);
-      }
-      if (this.inbuf !== null) this.close();
-    });
-    socket.on('error', (err) => this.error(err));
-    this.set_keepalive_interval(1);
-  }
-
-  get is_reliable() {
-    return false;
-  }
-
-  /**
-   * Connect to the given endpoint.
-   *
-   * @param {String} options.host - hostname or ip
-   * @param {number} options.port - port number
-   * @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.
-   * @param {number} [options.retry_interval=250] - Delay in ms after which a
-   *    command should be automatically re-sent if no response has been
-   *    received, yet.
-   * @param {number} [options.retry_count=3] - Number of times to retry sending
-   *    commands. If no response has been received after all retries, the
-   *    command will fail with an error.
-   * @param {number} [options.batch=128] - Maximum number of bytes to send
-   *    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>}
-   *    The connection.
-   */
-  static connect(options) {
-    return lookup_address(options).then((options) => {
-      return new Promise((resolve, reject) => {
-        const socket = createSocket(options.type || 'udp4');
-        const onerror = function (ev) {
-          reject(ev);
-        };
-        socket.on('error', onerror);
-        socket.bind(
-          {
-            exclusive: true,
-          },
-          () => {
-            socket.on('connect', async () => {
-              try {
-                await waitForKeepalive(socket, options);
-
-                socket.removeListener('error', onerror);
-
-                const connection = new this(socket, options);
-                resolve(connection);
-              } catch (err) {
-                reject(err);
-              }
-            });
-            socket.connect(options.port, options.host);
-          }
-        );
-      });
-    });
-  }
-
-  write(buf) {
-    this.q.push(buf);
-
-    if (this.tx_idle_time() >= this.delay) this._write_out();
-    else this._schedule_write_out();
-  }
-
-  flush() {
-    super.flush();
-    if (this.tx_idle_time() > this.delay) this._write_out();
-  }
-
-  cleanup() {
-    super.cleanup();
-    if (this.socket) {
-      this.socket.close();
-      this.socket = null;
-    }
-    if (this._write_out_id !== -1) {
-      clearTimeout(this._write_out_id);
-      this._write_out_id = -1;
-    }
-    if (this._retry_id !== -1) {
-      clearInterval(this._retry_id);
-      this._retry_id = -1;
-    }
-  }
-
+export class UDPConnection extends AbstractUDPConnection {
   _now() {
     return performance.now();
   }
 
-  _estimate_next_tx_time() {
-    return this._now() + (this.delay + 2) * this.q.length;
-  }
-
-  _write_out() {
-    if (!this.socket) return;
-    const q = this.q;
-
-    if (!q.length) return;
-
-    const buf = q.shift();
-
-    this.socket.send(Buffer.from(buf));
-    super.write(buf);
-
-    if (q.length) this._schedule_write_out();
-  }
-
-  _schedule_write_out() {
-    const tx_idle_time = this.tx_idle_time();
-    const delay = this.delay;
-
-    if (tx_idle_time >= delay) {
-      this._write_out();
-      return;
-    }
-
-    // Already scheduled.
-    if (this._write_out_id !== -1) return;
-
-    this._write_out_id = setTimeout(
-      this._write_out_callback,
-      delay - tx_idle_time
-    );
-  }
-
-  _retryCommands() {
-    const now = this._now();
-    const retryTime = now - this.retry_interval;
-    // This is an estimate for how many commands we would manage to send
-    // off.
-    const max = 5 * (this.retry_interval / this.delay) - this.q.length;
-    const pendingCommands = this._pendingCommands;
-
-    const retries = [];
-    const failed = [];
-
-    for (const entry of pendingCommands) {
-      const [, pendingCommand] = entry;
-
-      // All later commands are newer than the cutoff.
-      if (pendingCommand.lastSent > retryTime) break;
-      if (pendingCommand.retries >= this.retry_count) {
-        failed.push(entry);
-      } else if (retries.length < max) {
-        retries.push(entry);
-      }
-    }
-
-    if (failed.length) {
-      const timeoutError = new Error('Timeout.');
-
-      failed.forEach(([handle, pendingCommand]) => {
-        pendingCommands.delete(handle);
-        pendingCommand.reject(timeoutError);
-      });
-    }
-
-    retries.forEach(([handle, pendingCommand]) => {
-      pendingCommands.delete(handle);
-      pendingCommands.set(handle, pendingCommand);
-      this.send(pendingCommand.command);
-      pendingCommand.lastSent = now;
-      pendingCommand.retries++;
-    });
+  static connect(options) {
+    return AbstractUDPConnection.connect.call(this, NodeUDP, options);
   }
 }

package/src/index.browser.js

@@ -16,6 +16,7 @@ import { define_custom_class } from './controller/define_custom_class.js';
 import * as RemoteControlClasses from './controller/ControlClasses.js';
 import * as Types from './types.js';
 import { WebSocketConnection } from './controller/websocket_connection.js';
+import { AbstractUDPConnection } from './controller/abstract_udp_connection.js';
 
 const controller = {
   Connection: ClientConnection,
@@ -43,4 +44,5 @@ export {
   warn,
   WebSocketConnection,
   RemoteControlClasses,
+  AbstractUDPConnection,
 };

package/src/index.js

@@ -18,6 +18,7 @@ import * as Types from './types.js';
 import { WebSocketConnection } from './controller/websocket_connection_node.js';
 import { TCPConnection } from './controller/tcp_connection.js';
 import { UDPConnection } from './controller/udp_connection.js';
+import { AbstractUDPConnection } from './controller/abstract_udp_connection.js';
 
 export const controller = {
   Connection: ClientConnection,
@@ -47,4 +48,5 @@ export {
   WebSocketConnection,
   TCPConnection,
   UDPConnection,
+  AbstractUDPConnection,
 };

package/src/types/OcaBlockMember.d.ts

@@ -1,10 +1,9 @@
 /*
  * This file has been generated.
  */
-
 import {
-  OcaObjectIdentification,
   IOcaObjectIdentification,
+  OcaObjectIdentification,
 } from './OcaObjectIdentification';
 
 export declare interface IOcaBlockMember {