aes70 1.3.3 → 1.3.7

package/src/controller/make_control_class.js

@@ -58,15 +58,35 @@ function implement_method(cls, method) {
 
   const [name, level, index, argumentTypes, returnTypes] = method;
 
-  cls.prototype[name] = function () {
+  cls.prototype[name] = function (...args) {
+    const argumentCount = argumentTypes.length;
+    let callback = null;
+
+    // If there are too few arguments, this might mean
+    //
+    // - that some of them use the default encoding (e.g. 0)
+    // - that the method signature has change in the AES70 version
+    //   used
+    //
+    // this is why we do not error here, yet.
+    if (argumentCount < args.length) {
+      if (
+        argumentCount + 1 === args.length &&
+        typeof args[argumentCount] === 'function'
+      ) {
+        callback = args[argumentCount];
+        args.length = argumentCount;
+      }
+    }
+
     const cmd = new CommandRrq(
       this.ono,
       level,
       index,
-      argumentTypes.length,
-      new EncodedArguments(argumentTypes, Array.from(arguments))
+      argumentCount,
+      new EncodedArguments(argumentTypes, args)
     );
-    return this.device.send_command(cmd, returnTypes);
+    return this.device.send_command(cmd, returnTypes, callback);
   };
 }
 

package/src/controller/remote_device.d.ts

@@ -47,7 +47,7 @@ export declare class RemoteDevice {
    * The Subscription manager object.
    */
   SubscriptionManager: OcaSubscriptionManager;
-                       
+
   /**
    * The Power manager object.
    */

package/src/controller/remote_device.js

@@ -105,6 +105,14 @@ function tree_to_rolemap(tree, s) {
   });
 }
 
+const subscriberMethod = {
+  ONo: 1055,
+  MethodID: {
+    DefLevel: 1,
+    MethodIndex: 1,
+  },
+};
+
 /**
  * Controller class for a remote OCA device.
  *
@@ -239,18 +247,31 @@ export class RemoteDevice extends Events {
     this.connection.close();
   }
 
-  send_command(cmd, returnType) {
-    return this.connection.send_command(cmd, returnType);
+  send_command(cmd, returnType, callback) {
+    return this.connection.send_command(cmd, returnType, callback);
   }
 
-  add_subscription(event, callback) {
+  _doSubscribe(event) {
+    return this.SubscriptionManager.AddSubscription(
+      event,
+      subscriberMethod,
+      new Uint8Array(0),
+      OcaNotificationDeliveryMode.Reliable,
+      new Uint8Array(0)
+    );
+  }
+
+  async add_subscription(event, callback) {
     const key = eventToKey(event);
+    const subscriptions = this.subscriptions;
 
-    const S = this.subscriptions.get(key);
+    {
+      const info = subscriptions.get(key);
 
-    if (S) {
-      S.callbacks.add(callback);
-      return Promise.resolve(true);
+      if (info) {
+        info.callbacks.add(callback);
+        return true;
+      }
     }
 
     /* do the actual subscription */
@@ -258,7 +279,7 @@ export class RemoteDevice extends Events {
     const cb = (o) => {
       const S = this.subscriptions.get(key);
       if (!S) {
-        warn('Subscription lost.\n');
+        warn('Subscription lost.');
         return;
       }
       const a = S.callbacks;
@@ -271,38 +292,41 @@ export class RemoteDevice extends Events {
       });
     };
 
-    const method = this.connection.get_new_subscriber(cb);
+    this.connection._addSubscriber(event, cb);
 
-    this.subscriptions.set(key, {
+    const info = {
       callbacks: new Set([callback]),
-      method: method,
       callback: cb,
-    });
+    };
 
-    return this.SubscriptionManager.AddSubscription(
-      event,
-      method,
-      new Uint8Array(0),
-      OcaNotificationDeliveryMode.Reliable,
-      new Uint8Array(0)
-    );
+    subscriptions.set(key, info);
+
+    try {
+      await this._doSubscribe(event);
+    } catch (err) {
+      subscriptions.delete(key);
+      throw err;
+    }
   }
 
   remove_subscription(event, callback) {
     const key = eventToKey(event);
 
-    const S = this.subscriptions.get(key);
+    const info = this.subscriptions.get(key);
 
-    if (!S) return Promise.reject('Callback not registered.');
+    if (!info) return Promise.reject('Callback not registered.');
 
-    const a = S.callbacks;
+    const a = info.callbacks;
 
     a.delete(callback);
 
     if (!a.size) {
-      this.connection.remove_subscriber(S.method);
+      this.connection._removeSubscriber(event);
       this.subscriptions.delete(key);
-      return this.SubscriptionManager.RemoveSubscription(event, S.method);
+      return this.SubscriptionManager.RemoveSubscription(
+        event,
+        subscriberMethod
+      );
     }
 
     return Promise.resolve(true);

package/src/controller/udp_connection.js

@@ -25,8 +25,7 @@ async function waitForKeepalive(socket, options) {
 
       pos = decodeMessage(new DataView(data.buffer), 0, pdus);
 
-      if (pdus.length !== 1)
-        throw new Error('Expected keepalive response.');
+      if (pdus.length !== 1) throw new Error('Expected keepalive response.');
 
       socket.off('message', onMessage);
       socket.off('error', reject);
@@ -43,8 +42,7 @@ async function waitForKeepalive(socket, options) {
   for (let i = 0; i < 3; i++) {
     socket.send(msg);
 
-    if (await Promise.race([ waiter, delay(t) ]))
-      return;
+    if (await Promise.race([waiter, delay(t)])) return;
   }
 
   throw new Error('Failed to connect.');
@@ -101,8 +99,10 @@ export class UDPConnection extends ClientConnection {
       this._write_out_id = -1;
       this._write_out();
     };
-    this._retry_id = (this.retry_interval > 0) ?
-      setInterval(() => this._retryCommands(), this.retry_interval) : -1;
+    this._retry_id =
+      this.retry_interval > 0
+        ? setInterval(() => this._retryCommands(), this.retry_interval)
+        : -1;
     this.q = [];
     socket.on('message', (data, rinfo) => {
       try {
@@ -176,16 +176,13 @@ export class UDPConnection extends ClientConnection {
   write(buf) {
     this.q.push(buf);
 
-    if (this.tx_idle_time() >= this.delay)
-      this._write_out();
-    else
-      this._schedule_write_out();
+    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();
+    if (this.tx_idle_time() > this.delay) this._write_out();
   }
 
   cleanup() {
@@ -208,6 +205,10 @@ export class UDPConnection extends ClientConnection {
     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;
@@ -219,8 +220,7 @@ export class UDPConnection extends ClientConnection {
     this.socket.send(Buffer.from(buf));
     super.write(buf);
 
-    if (q.length)
-      this._schedule_write_out();
+    if (q.length) this._schedule_write_out();
   }
 
   _schedule_write_out() {
@@ -233,10 +233,12 @@ export class UDPConnection extends ClientConnection {
     }
 
     // Already scheduled.
-    if (this._write_out_id !== -1)
-      return;
+    if (this._write_out_id !== -1) return;
 
-    this._write_out_id = setTimeout(this._write_out_callback, delay - tx_idle_time);
+    this._write_out_id = setTimeout(
+      this._write_out_callback,
+      delay - tx_idle_time
+    );
   }
 
   _retryCommands() {
@@ -251,7 +253,7 @@ export class UDPConnection extends ClientConnection {
     const failed = [];
 
     for (const entry of pendingCommands) {
-      const [ handle, pendingCommand ] = entry;
+      const [, pendingCommand] = entry;
 
       // All later commands are newer than the cutoff.
       if (pendingCommand.lastSent > retryTime) break;
@@ -265,13 +267,13 @@ export class UDPConnection extends ClientConnection {
     if (failed.length) {
       const timeoutError = new Error('Timeout.');
 
-      failed.forEach(([ handle, pendingCommand ]) => {
+      failed.forEach(([handle, pendingCommand]) => {
         pendingCommands.delete(handle);
         pendingCommand.reject(timeoutError);
       });
     }
 
-    retries.forEach(([ handle, pendingCommand ]) => {
+    retries.forEach(([handle, pendingCommand]) => {
       pendingCommands.delete(handle);
       pendingCommands.set(handle, pendingCommand);
       this.send(pendingCommand.command);

package/src/controller/websocket_connection.js

@@ -52,7 +52,9 @@ export class WebSocketConnection extends ClientConnection {
   cleanup() {
     super.cleanup();
     if (this.ws) {
-      try { this.ws.close(); } catch (err) {}
+      try {
+        this.ws.close();
+      } catch (err) {}
       this.ws = null;
     }
   }

package/src/controller/websocket_connection_node.js

@@ -54,7 +54,9 @@ export class WebSocketConnection extends ClientConnection {
   cleanup() {
     super.cleanup();
     if (this.ws) {
-      try { this.ws.close(); } catch (err) {}
+      try {
+        this.ws.close();
+      } catch (err) {}
       this.ws.removeAllListeners();
       this.ws = null;
     }

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,15 +44,22 @@ export class Test {
   {
   }
 
-  cleanup()
+  close_device(device)
   {
-    if (this.device !== null)
+    if (device !== null)
     {
-      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'),
@@ -187,12 +189,23 @@ function timeout(n)
 
 async function run_tests(type, target)
 {
+  let onClose = null;
+
+  const close_p = new Promise((resolve, reject) => {
+    onClose = () => setTimeout(() => reject(new Error('Closed.')), 1000);
+  });
+
   const get_device = async () => {
     const connection = await type.connect(connect_options(target));
     const device = new RemoteDevice(connection);
 
     device.set_keepalive_interval(1);
 
+    connection.on('close', onClose);
+    connection.on('test_done', () => {
+      connection.removeEventListener('close', onClose);
+    });
+
     return device;
   };
 
@@ -203,7 +216,7 @@ async function run_tests(type, target)
     const timeout_p = timeout(60*1000);
     const test_p = test_runner.run();
 
-    await Promise.race([ timeout_p.then(() => { timed_out = true; }), test_p ]);
+    await Promise.race([ timeout_p.then(() => { timed_out = true; }), test_p, close_p ]);
 
     if (timed_out)
     {

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

package/src/OCP1/OcaClassID.js

@@ -1,16 +0,0 @@
-/*
- * This file has been generated.
- */
-import { Struct } from './Struct.js';
-import { FieldType } from './FieldType.js';
-import { OcaUint16 } from './OcaUint16.js';
-
-import { OcaClassID as type } from '../types/OcaClassID.js';
-
-export const OcaClassID = Struct(
-  {
-    FieldCount: OcaUint16,
-    Fields: FieldType,
-  },
-  type
-);