aes70 1.3.6 → 1.3.8

package/src/controller/udp_connection.js

@@ -1,280 +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();
   }
 
-  _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 [handle, 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/tests/device/locking.js

@@ -44,7 +44,8 @@ class Locking extends ObjectTest
   cleanup()
   {
     super.cleanup();
-    this.other_device.close();
+    this.close_device(this.other_device);
+    this.other_device = null;
   }
 }
 

package/tests/device/method_callback.js

@@ -0,0 +1,24 @@
+import { Test } from './test.js';
+
+class CheckCallbackMethod extends Test {
+  async run() {
+    const root = this.device.Root;
+
+    const result = await root.GetMembers();
+
+    const result2 = await new Promise((resolve, reject) => {
+      const tmp = root.GetMembers((ok, result) => {
+        (ok ? resolve : reject)(result);
+      });
+      if (tmp) {
+        console.error('got %o', tmp);
+        throw new Error('Unexpected return value.');
+      }
+    });
+
+    if (result.length !== result2.length)
+      throw new Error('Result mismatch.');
+  }
+}
+
+export default [ CheckCallbackMethod ];

package/tests/device/test.js

@@ -44,16 +44,22 @@ export class Test {
   {
   }
 
-  cleanup()
+  close_device(device)
   {
-    if (this.device !== null)
+    if (device !== null)
     {
-      this.device.connection.emit('test_done');
-      this.device.close();
-      this.device = null;
+      device.connection.emit('test_done');
+      device.close();
+      device = null;
     }
   }
 
+  cleanup()
+  {
+    this.close_device(this.device);
+    this.device = null;
+  }
+
   static focus()
   {
     return false;

package/tests/device.js

@@ -13,6 +13,7 @@ import CheckTreeTests from './device/check_tree.js';
 import KeepaliveTests from './device/keepalive.js';
 import LockingTests from './device/locking.js';
 import PropertyChangesTests from './device/property_changes.js';
+import MethodCallbackTests from './device/method_callback.js';
 
 if (argv.length < 3)
 {
@@ -169,7 +170,8 @@ function get_runner(get_device)
     CheckTreeTests,
     //KeepaliveTests,
     LockingTests,
-    PropertyChangesTests
+    PropertyChangesTests,
+    MethodCallbackTests
   ].flat();
 
   // require('./device/property_changes'),

package/bin/connectMany.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-
-import { stdout, argv, exit } from 'process';
-import { RemoteDevice } from '../src/controller/remote_device.js';
-import { TCPConnection } from '../src/controller/tcp_connection.js';
-import { format } from 'util';
-
-if (argv.length < 4)
-{
-  console.log('Usage: node print_tree.js <ip> <port>');
-  exit(1);
-}
-
-function delay(n) {
-  if (!n) return Promise.resolve();
-  return new Promise((resolve) => setTimeout(resolve, n));
-}
-
-const host = argv[2];
-const port = parseInt(argv[3]);
-const N = 1000;
-
-const destinations = new Array(N).fill(0).map((_, index) => {
-  return { host: host, port: port + index };
-});
-
-async function connectAndDiscover(destination) {
-  const con = await TCPConnection.connect(destination);
-
-  const device = new RemoteDevice(con);
-
-  const objectTree = await device.get_device_tree();
-
-  device.close();
-
-  return objectTree;
-}
-
-async function run() {
-  for (let i = 0; i < destinations.length;) {
-    let tasks = [];
-
-    while (tasks.length < 5) {
-      tasks.push(connectAndDiscover(destinations[i++]));
-    }
-
-    await Promise.all(tasks);
-
-    stdout.write(format('\r %d %% done.',
-                        Math.floor(100 * i / destinations.length)));
-
-    await delay(50);
-  }
-}
-
-run().then(
-  () => {
-    console.log('\nDone');
-  },
-  (err) => {
-    console.error(err);
-    exit(1);
-  }
-);