dbusjs / node-dbus-next Goto Github PK

The api assumes that interfaces are exported on names when they are not. They are exported on the bus directly. Names are not like namespaces for interfaces like I originally thought. They are just an alias for the unique name.

Methods with inSignature: 'x' should be required to give parameters of Long.js Long types. Instead they come in as truncated js numbers.

Return values are not affected (they are already required to be Long).

This is a screenshot from a Trisquel VM, I noticed that something fails on this platform when initializing dbus-next. Dbus is installed as a service and running.

I'm trying to debug this myself. We're using mpris-service to access dbus.

If you need to see how we're using it, the relevant code is here: https://github.com/nukeop/nuclear/blob/b1e972b0827c512d0feba29cd1cdd8700869285b/packages/main/src/services/%40linux/system-api.ts

Rename MethodError to DBusError and let users throw them in property getters and setters. This would be useful if a property is not implemented and you just want a stub.

Hello, Please can you help me to understand this issue I am having when attempting to export multiple interfaces in a single JavaScript App. I am finding in the case where two or more bus.export() are used, investigation of the resulting D-BUS structure in d-feet shows that multiple interfaces have been exported/created for each bus.export(). For example in this simplified case:

const EventEmitter = require ('events');
const dbus = require('dbus-next');
const {Interface} = dbus.interface;

class Iface01 extends Interface {
    constructor() { 
      super('org.test.Interface1'); 
    }
}
  
class Iface02 extends Interface {
    constructor() { 
      super('org.test.Interface2');
    }
}

var bus = dbus.systemBus(); 
interface1 = new Iface01();
interface2 = new Iface02();

async function main() {
 await bus.requestName('org.test.services');
 bus.export('/org/test/path1', interface1); 
 bus.export('/org/test/path2', interface2);
}

main().catch(console.log);

the d-feet output looks like this

where it appears that each of the two interfaces has been created four times.

further observations are:

• the issue on ly occurs when multiple bus.export() are used.
• if the two interfaces were to be exported to the same path, then the repeating does not occur.
• the number or replications is proportional to the number of / in the path for the given interface export.

I am trying to create the interface structure needed to create a bluetooth GATT application structure as set out in the last section of https://git.kernel.org/pub/scm/bluetooth/bluez.git/tree/doc/gatt-api.txt

However am struggling to get over this apparent issue. Thanks in advance for any advice.

happy to investigate further and report given any direction.
Regards, Simon

Some properties, methods, or signals might be optional. Mpris for instance has optional properties. Optional members should be omitted from introspection xml and ignored when they are gotten/set/called.

Maybe like this:

iface.disableProperty('OptionalProp');

Or maybe like this for more extensibility:

iface.getPropertyInfo('OptionalProp').disabled = true;

https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces

org.freedesktop.DBus.ObjectManager has a method and two signals which can be implemented on services.

• GetManagedObjects() - get the objects of the child node.
• signal InterfacesAdded()
• signal InterfacesRemoved()

These can also be used on clients to automatically update the proxy when the interface changes.

I have a simple D-Bus service. The service has only one signal called test and the service emits every ten seconds the current date.

import * as dbus from 'dbus-next';

class MyInterface extends dbus.interface.Interface {

    /* https://github.com/dbusjs/node-dbus-next/blob/master/lib/service/interface.js#L266 */
    static configureDBusIntf() {
        MyInterface.configureMembers({
            signals: {
                test: {
                    signature: 's'
                }
            }
        });
    }

    constructor() {
        super('org.test.iface');
    }

    test(msg: string) {
        return msg;
    }
}

async function main() {
    MyInterface.configureDBusIntf();
    const example = new MyInterface();

    const bus = dbus.sessionBus();
    await bus.requestName('org.test.test', 0);
    bus.export('/org/test/test', example);

    setInterval(
        () => {
            const date = new Date();
            console.log(date);
            example.test(date.toUTCString());
        },
        10000
    );
}

main().catch((err) => {
    console.log('Error:' + err);
});

/*
$ node dist/dbus_service.js 
2021-02-16T00:17:52.457Z
2021-02-16T00:18:02.469Z
2021-02-16T00:18:12.480Z
*/

The client adds a listener to the test D-Bus signal three times => Instead of receiving the signal three times the client receives the signal nine times!

import * as dbus from 'dbus-next';

async function main() {

    const log1 = (str: string) => { console.log('1  ', str) };
    const log2 = (str: string) => { console.log(' 2 ', str) };
    const log3 = (str: string) => { console.log('  3', str) };

    const bus = dbus.sessionBus();
    const obj = await bus.getProxyObject('org.test.test', '/org/test/test');
    const testIface = obj.getInterface('org.test.iface');
    testIface.on('test', log1);
    testIface.on('test', log2);
    testIface.on('test', log3);
}

main().catch((err) => {
    console.log('Error:' + err);
});

/*
$ node dist/dbus_client.js
1   Tue, 16 Feb 2021 00:17:52 GMT
 2  Tue, 16 Feb 2021 00:17:52 GMT
  3 Tue, 16 Feb 2021 00:17:52 GMT
1   Tue, 16 Feb 2021 00:17:52 GMT
 2  Tue, 16 Feb 2021 00:17:52 GMT
  3 Tue, 16 Feb 2021 00:17:52 GMT
1   Tue, 16 Feb 2021 00:17:52 GMT
 2  Tue, 16 Feb 2021 00:17:52 GMT
  3 Tue, 16 Feb 2021 00:17:52 GMT

1   Tue, 16 Feb 2021 00:18:02 GMT
 2  Tue, 16 Feb 2021 00:18:02 GMT
  3 Tue, 16 Feb 2021 00:18:02 GMT
1   Tue, 16 Feb 2021 00:18:02 GMT
 2  Tue, 16 Feb 2021 00:18:02 GMT
  3 Tue, 16 Feb 2021 00:18:02 GMT
1   Tue, 16 Feb 2021 00:18:02 GMT
 2  Tue, 16 Feb 2021 00:18:02 GMT
  3 Tue, 16 Feb 2021 00:18:02 GMT

1   Tue, 16 Feb 2021 00:18:12 GMT
 2  Tue, 16 Feb 2021 00:18:12 GMT
  3 Tue, 16 Feb 2021 00:18:12 GMT
1   Tue, 16 Feb 2021 00:18:12 GMT
 2  Tue, 16 Feb 2021 00:18:12 GMT
  3 Tue, 16 Feb 2021 00:18:12 GMT
1   Tue, 16 Feb 2021 00:18:12 GMT
 2  Tue, 16 Feb 2021 00:18:12 GMT
  3 Tue, 16 Feb 2021 00:18:12 GMT
*/

I found a fix for this issue but maybe not the best: Simply check the amount of listeners

lib/client/proxy-interface.js

...
    this.on('removeListener', (eventName, listener) => {
      // FIX
      if (this.listeners(eventName).length > 0) {
        return;
      }

      const [signal, detailedEvent] = getEventDetails(eventName);

      if (!signal) {
        return;
      }

      if (this.$object.bus._connection.stream.writable) {
        this.$object.bus._removeMatch(this._signalMatchRuleString(eventName))
          .catch(error => {
            this.$object.bus.emit('error', error);
          });
      }
      this.$object.bus._signals.removeListener(detailedEvent, this._getEventListener(signal));
    });

    this.on('newListener', (eventName, listener) => {
      // FIX
      if (this.listeners(eventName).length > 0) {
        return;
      }

      const [signal, detailedEvent] = getEventDetails(eventName);

      if (!signal) {
        return;
      }

      this.$object.bus._addMatch(this._signalMatchRuleString(eventName))
        .catch(error => {
          this.$object.bus.emit('error', error);
        });
      this.$object.bus._signals.on(detailedEvent, this._getEventListener(signal));
    });
  }
...

Right now the name of the method, property, or signal must be the same as the name of the function.

Provide an option to set the name from the decorator.

@method({ name: "SomeName" })
someOtherName() {
  // will appear on the bus to be named "SomeName"
}

Right now to connect to a session bus, it is required that the DBUS_SESSION_BUS_ADDRESS variable is set. I know that some custom session managers like xinit will not set these environment variables automatically, and there might be some other session managers that don't either.

There is a section in the DBus specification for getting the address from a window property on X11 that is not currently followed by this library.

This is stubbed out in lib/address-x11.js but not implemented.

https://github.com/acrisci/node-dbus-next/blob/8a287c2a7995c785df8b2ac9622cd930a9def8e1/lib/address-x11.js#L7-L36

If this code can be made to work, it would require an optional dependency on the node-x11 library.

An alternative to this would be to look in $HOME/.dbus/session-bus for the session bus address based on the machine id and DISPLAY environment variable. This contains the location of the session bus that we need and might be sufficient to accomplishing the goal of not requiring the DBUS_SESSION_BUS_ADDRESS to be set in the environment. That should be tried first.

ref: martpie/museeks#93

I'm pretty happy with how things are right now so I think I'm going to mark all the apis of the library as stable in the next release.

Im trying to monitor notifications but it stops listening after the first notification.

var dbus = require('dbus-next')
const bus = dbus.sessionBus();

bus.getProxyObject('org.freedesktop.DBus', '/org/freedesktop/DBus').then((obj) => {
  let monitor = obj.getInterface('org.freedesktop.DBus.Monitoring');

  monitor.BecomeMonitor([
    "type='signal',member='Notify',path='/org/freedesktop/Notifications',interface='org.freedesktop.Notifications'",
    "type='method_call',member='Notify',path='/org/freedesktop/Notifications',interface='org.freedesktop.Notifications'",
    "type='method_return',member='Notify',path='/org/freedesktop/Notifications',interface='org.freedesktop.Notifications'",
    "type='error',member='Notify',path='/org/freedesktop/Notifications',interface='org.freedesktop.Notifications'"
  ], 0);


  bus.on('message', (msg) => {
    console.log(msg);
  });

});

As mentioned in #23
There's a issue with this line:
https://github.com/acrisci/node-dbus-next/blob/4283e0e535cf6ca519e8d839bc9216ec30b45830/lib/handshake.js#L21
On my set-up, getUserHome() returns undefined (this may be due to mine running in the Electron renderer process). This causes path.join to fail (this happens in the upstream repo as well).

I know that this is probably not the right place to ask, but I just created a small app which is checking a MediaPlayer for its status. The service is running great when manually started from the command line. But fails miserably when I try to create a systemd service to automatically start it when the system restarts.

Has anyone an idea how to tackle that issue?

Hi, Any chance you could provide non-decorator examples of usage?

I love that you are using new syntax, but currently decorators are unusable in other variants like Coffeescript, Lightscript, Typescript etc..

Also expecting users to run Babel on the Node.js side requires a lot of overhead that will keep people from using your package. Unless of course you are prepared to support explaining how to set up babel, node.js and get that running with the various compilers.

Hi. Thank you for you work. Keep it going.
But i'd like to know do you plan to add typescript support for your lib?

I know this is not an issue with your code but I think you guys are onto something here and would be willing to share my native-dbus issue list if interested.

A low-level api would allow clients to send and receive arbitrary messages on the bus. This api would be needed for implementing dbus-send or dbus-monitor with this library.

let serial = bus.serial();
let msg = {
  type: METHOD_CALL,
  serial: serial,
  interface: 'org.test.interface',
  destination: 'org.test.name',
  member: 'SomeMethod',
  signature: 's',
  body: 'hello world'
};

bus.sendMessage(msg);

bus.on('message', (msg) => {
  if (msg.replySerial === serial) {
    // handle reply
  }
});

What's the proper way to clean up an interface? I'm using dbus-next (thank you, I appreciate it) for a NetworkManager implementation in a long running process. There is a lot of object turnover; when I set up an object I add a listener to 'PropertiesChanged' and when I destroy it I remove all listeners, but my process inevitably crashes on the following unhandled error:

Connection ":1.104" is not allowed to add more match rules (increase limits in configuration file if required; max_match_rules_per_connection=2048)

DBusError: Connection ":1.104" is not allowed to add more match rules (increase limits in configuration file if required; max_match_rules_per_connection=2048)
    at _methodReturnHandlers.(anonymous function) (/path/to/external/node_modules/dbus-next/lib/bus.js:326:27)
    at handleMessage (/path/to/external/node_modules/dbus-next/lib/bus.js:86:11)
    at EventEmitter.MessageBus.conn.on (/path/to/external/node_modules/dbus-next/lib/bus.js:135:9)
    at EventEmitter.emit (events.js:189:13)
    at /path/to/external/node_modules/dbus-next/lib/connection.js:112:14
    at Socket.<anonymous> (/path/to/external/node_modules/dbus-next/lib/message.js:55:9)

Edit/Appended: I use the same require('dbus-next').systemBus() instance for every object (AccessPoint,Connection,Device,etc), would it be recommended to use a new instance in each case?

Correct me if I am wrong but I did not find a way to archive async execution in a Service function.
There is neither a callback nor can I return a Promise in a Service function.
So all execution inside a method call needs to be synchronous.
This breaks for example if you want to do a database lookup in response the the method call.

Consider following example:

class BluezAgent {
  @method({inSignatur: "os", outSignatur: "b"})
  RequestConfirmation(device, passkey) {
    // check if the key is in the database
    // this is an async operation that returns a promise
    const res = database.isKeyValid(passkey);
    // call a callback once the key is checked
    res.then(callback);
    // or return res as a promise
    return res;
  }
}

Implementing the promise return could be as easy as adding an await to the handler function call. See:

how can i listen for messages when wifi and LAN adapters are connected/disconnect?

i already tried:

// add a custom handler for a particular method bus.addMethodHandler((msg) => { if (String(msg.path).startsWith('/org/freedesktop/NetworkManager')) { console.log(msg); } });

bus.on('message', (msg) => { console.log('got a message: ', msg); });

but no success.

@acrisci

Thank you for an awesomely simplified library to deal with dbus in node.

I've a request. Can you please include generators from bin directory in packaging?

When using python to access ofono, it is possible to listen to a specific signal and interface instance by specifying the signal name and path. dbus-next getInterface() only has a string for the interface name but it would be nice to also select the instance of the interface with a path.

Python example to listen for a specific modem:
systemBus.add_signal_receiver(someCallbackForSignalsToPhone, signal_name="CallAdded", bus_name="org.ofono", dbus_interface="org.ofono.VoiceCallManager", path="/hfp/org/bluez/hci0/dev_FC_D4_36_C0_2A_5A")

When a DBusError is thrown, it should contain the error reply when possible. This change should affect the high-level client and the low-level client.

Message interface here:

In the help:

let methodCall = new Message({
  destination: 'org.freedesktop.DBus',
  path: '/org/freedesktop/DBus',
  interface: 'org.freedesktop.DBus',
  member: 'ListNames'
});

Message is exposed as interface in typescript file, so I have to do this in order to get the class.

import dbus from "dbus-next";
let Message = (<any>dbus).Message;

Looks like an unintended mismatch.

In this method:

    <method name="ResolveService">
      <arg name="interface" type="i" direction="in"/>
      <arg name="protocol" type="i" direction="in"/>
      <arg name="name" type="s" direction="in"/>
      <arg name="type" type="s" direction="in"/>
      <arg name="domain" type="s" direction="in"/>
      <arg name="aprotocol" type="i" direction="in"/>
      <arg name="flags" type="u" direction="in"/>

      <arg name="interface" type="i" direction="out"/>
      <arg name="protocol" type="i" direction="out"/>
      <arg name="name" type="s" direction="out"/>
      <arg name="type" type="s" direction="out"/>
      <arg name="domain" type="s" direction="out"/>
      <arg name="host" type="s" direction="out"/>
      <arg name="aprotocol" type="i" direction="out"/>
      <arg name="address" type="s" direction="out"/>
      <arg name="port" type="q" direction="out"/>
      <arg name="txt" type="aay" direction="out"/>
      <arg name="flags" type="u" direction="out"/>
    </method>

The txt out parameter has a type of aay, so using a client proxy object I would expect it to be unmarshaled as and Array of Buffer objects since ay is treated as a special type (according to the README). However it seems to be unmarshaled as an Array of Array objects.

I was messing about with the MPRIS example on my KDE based desktop and discovered that KDE's browser intergration was casusing issues with this libary as its bus name is org.mpris.MediaPlayer2.plasma-browser-integration and is causing this error

Error: Invalid interface name: org.mpris.MediaPlayer2.plasma-browser-integration
    at assertInterfaceNameValid (/home/iloosley/node_modules/dbus-next/lib/validators.js:108:11)
    at new ProxyObject (/home/iloosley/node_modules/dbus-next/lib/client/proxy-object.js:35:5)
    at MessageBus.getProxyObject (/home/iloosley/node_modules/dbus-next/lib/bus.js:162:15)
    at main (/home/iloosley/mpris.js:111:23)
    at processTicksAndRejections (internal/process/task_queues.js:86:5)

This appears to be because the library is incorrectly validating the bus name as an interface. MPRIS player addresses are bus names, interfaces are things like

org.mpris.MediaPlayer2.Player
org.mpris.MediaPlayer2.TrackList
org.mpris.MediaPlayer2.Playlists

The low-level api is a bit rough right now. It can't be public in the shape it's in.

Make the low level api private including the underlying dbus connection. Anything that doesn't have a use documented in the readme, examples, or test cases should be private.

If you have a use case for the low-level api, let me know and we'll work on exposing it in a better way.

So for simplicity sake I'm not using decorators. I created few services without properties no problem. But when i wanted define notifying property I'm faced with weird problem.

throw new Error(got properties changed with unknown property: ${p});
        ^

Error: got properties changed with unknown property: Speed
    at Function.emitPropertiesChanged (/home/kryq/Projects/nodejs/dbus_service_test/node_modules/dbus-next/lib/service/interface.js:382:15)

class SpeedListenerInterface extends Interface {
  constructor() {
    super('pl.kryq.SpeedListener1');
  }

  _speed = 0.0;

  get Speed() {
    return this._speed;
  }
  set Speed(value) {
    this._speed = value;

    Interface.emitPropertiesChanged(this, {
      Speed: value
    }, ['invalid']);
  }

  SSpeed(val) {
    return val;
  }
}

SpeedListenerInterface.configureMembers({
  properties: {
    Speed: {
      name: 'lel',
      signature: 'd',
      access: 'read'
    }
  },
  /*methods: {
    SetBrightness: {
      inSignature: 'u',
      outSignature: 'n'
    }
  },*/
  signals: {
    SSpeed: {
      signature: 'd'
    }
  }
});```

Add some docs and make it clear what the current supported api is.

• server: interface
• server: name
• bus
• client: proxy object
• client: proxy interface
• module toplevel

I'm looking for the way to register my custom service on D-Bus with dbus-next API. But I'm not getting it working.

What I did is:

• Create a couple of classes inheriting dbus-next Interface
• Invoke dbus.systemBus().export('/service/path', aboveObject) for each dbus-next Interface object to be exported

Then when I got a ProxyObject of the service path, I couldn't find anything in interfaces property of the ProxyObject. What am I missing?

# dbus.systemBus().getProxyObject(':1.2', '/service/path').then(x => console.log(x))
=>
ProxyObject {
  bus: MessageBus {
    _events: [Object: null prototype] {},
    _eventsCount: 0,
    _maxListeners: undefined,
    _builder: Builder { options: [Object] },
    _connection: EventEmitter {
      (snip)
    },
    _serial: 8,
    _methodReturnHandlers: {},
    _signals: EventEmitter {
      (snip)
    },
    _nameOwners: {
      'org.freedesktop.DBus': 'org.freedesktop.DBus',
      'org.bluez': ':1.428',
      'org.freedesktop.DBus.ObjectManager': 'org.freedesktop.DBus',
      ':1.2': ':1.2'
    },
    _methodHandlers: [ [Function] ],
    _serviceObjects: {  ======================> Exported paths are described here
      '/service/path': [ServiceObject],
      '/service/path/subpath': [ServiceObject],
      (snip) 
    }, 
  name: ':1.420',
    [Symbol(kCapture)]: false
  },
  name: ':1.2',
  path: '/service/path',
  interfaces: {},  ==========================> but no exported interfaces appear
  (snip) 
}

With node-dbus, it has dbus.registerService() to register a Service Object (not Interface). I'd say the Service Object registration function is required to register a set of D-Bus interfaces but I don't have any idea of the equivalent function in dbus-next.

The library has diverged so significantly from dbus-native that I don't believe it can be used as a drop-in replacement as a path to upgrade anymore. I'm not testing the old interfaces and they are probably all broken.

Remove the old high-level interfaces.

Make all the low-level interfaces private and work on making them public at a later time if that is worthwhile in the future.

I cant find direct connecti functionality which is need for e.g 'org.PulseAudio.Core1.Device'

const pulseServerClient = dbusNative.createClient({
socket: unixSocketPath,
direct: true,
});

Hey,

if I initialize a system or session bus, the program won't terminate.

// example.js
'use strict' // happens without strict mode as well

const dbus = require('dbus-next')

const bus = dbus.systemBus() // happens with dbus.sessionBus() as well

When I run it on the terminal like this, it will run forever:

$ node example.js

I have to use Strg+C to terminate it.

Those are the versions I'm using:

Ubuntu: 20.10
node:  14.16.0
dbus-next: ^0.9.2

As I couldn't find any information that dbus needs to be closed/terminated/unset in some way, I assume that this is a bug.

I started to use dbus-next just a couple of days ago (when 0.9.2 was already released) but I still think that I didn't have this issue yesterday :-P But I'm not certain and I have no idea what could have introduced the issue.

Any ideas what's going on here?

Cheers
Fred

Hi,

Property getters seem to be executed as soon as you call configureMembers. This can result in errors as instance state is not initialized yet.

Running the below script with node results in a TypeError, since the private property is initialized in the constructor.

const dbus = require('dbus-next')

const { Interface } = dbus.interface

class TestInterface extends Interface {
   constructor() {
     this._myPrivateProperty = 'HELLO'
   }

   get myProperty() {
     console.log('--> get myProperty')
     return this._myPrivateProperty.toLowerCase()
   }
}

TestInterface.configureMembers({
  properties: {
    myProperty: { signature: 's' }
  }
})

Terminal output:

--> get myProperty
/private/tmp/test-dbus/index.js:12
     return this._myPrivateProperty.toLowerCase()
                                    ^

TypeError: Cannot read property 'toLowerCase' of undefined
    at Interface.get myProperty [as myProperty] (/private/tmp/test-dbus/index.js:12:37)
    at applyDecorator (/private/tmp/test-dbus/node_modules/dbus-next/lib/service/interface.js:314:32)
    at Function.configureMembers (/private/tmp/test-dbus/node_modules/dbus-next/lib/service/interface.js:323:7)
    at Object.<anonymous> (/private/tmp/test-dbus/index.js:16:15)
    at Module._compile (internal/modules/cjs/loader.js:1200:30)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1220:10)
    at Module.load (internal/modules/cjs/loader.js:1049:32)
    at Function.Module._load (internal/modules/cjs/loader.js:937:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)
    at internal/main/run_main_module.js:17:47

The issue seems to originate here:

The types.d.ts file is referenced in the package.json but the file not included when installing the package via npm.

https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces

org.freedesktop.DBus.Peer has two methods.

• Ping() - just return a method call.
• GetMachineId() - probably just return the contents of /var/lib/dbus/machine-id.

Right now if a service throws an error that's not a DBusError, it crashes the service.

We should catch all errors and return a friendly message to the client that something went wrong.

Hi, I'm using node-dbus-next to connect to a remote dbus server from macOS. To successfully perform authentication, the correct uid (1000) must be passed with the EXTERNAL authentication handshake. However, the default user account id on macOS is 501. It would be really helpful if there would be some way of overriding the uid for authentication purposes, for example by passing an env var.

Currently, engine.node in packege.json file is

https://github.com/acrisci/node-dbus-next/blob/96ef3f49cd8f03241eda44aba4129555e3ed422d/package.json#L59-L61

and we are using BigInt iteral here

https://github.com/acrisci/node-dbus-next/blob/96ef3f49cd8f03241eda44aba4129555e3ed422d/lib/constants.js#L1-L5

But according to node.green , BigInt isn't supported until Node 10.8.0. I think we definitely should change this.

hi, that's a great library :)...but i have a problem using it :(
i'm wasn't able to find a method to remove the listeners from the internal interfaces of the library .
i'm working on an app that use bluez and bluetooth , and client can connect/disconnect very rapidly.
every time i connect a device a proxy obj is created and i read some property(mac address,name ecc ecc) , if the device is of a specific type, i put a call .on('PropertiesChanged') on the interface that i need to check.
after a few devices connection/disconnection , node tells a warn saying that i am adding too mutch event listeners for the same event ('PropertiesChanged event) but every time a device is removed i call removeListeners method on the all interfaces that listen to this event and i've got no errors ,also i destroy the interfaces with
iface=null
so ... there is a right way to remove obj and interfaces? what iam i doing wrong?

Hey,

this is some code I wrote to scan for available wireless access points on a given device and get their properties.

I can't guarantee that this example works as I stripped out some stuff to simplify it. But it should serve the purpose to illustrate how the result below is created.

'use strict'

// params:
const device_name = 'wlan0'

// config:
const dbusBaseName = 'org.freedesktop.NetworkManager'
const dbusBasePath = '/org/freedesktop/NetworkManager'
const dbusPropertiesName = 'org.freedesktop.DBus.Properties'

// setup dbus stuff:
const bus = dbus.systemBus()
const proxyObject = await this.bus.getProxyObject(dbusBaseName, dbusBasePath)
const propertiesInterface = proxyObject.getInterface(dbusPropertiesName)
const managerInterface = proxyObject.getInterface(dbusBaseName)

// get list of network interfaces on the given device:
const device_path = await managerInterface.GetDeviceByIpIface(device_name)
const deviceProxyObject = await this.bus.getProxyObject(this.dbusBaseName, device_path)
const deviceInterfaceNames = Object.keys(deviceProxyObject.interfaces)

// check if it has wireless capabilities:
if (deviceInterfaceNames.includes(this.dbusBaseName + '.Device.Wireless')) {
    // get the wireless interface:
    const deviceManagerInterface = deviceProxyObject.getInterface(dbusBaseName + '.Device.Wireless')

    // request a scan for available access points, then fetch the list:
    deviceManagerInterface.RequestScan({})
    const accessPointPaths = await new Promise(async (resolve, reject) => {
        const promiseScan = new Promise((resolve, reject) => {
            deviceManagerInterface.on('AccessPointAdded', (iface, changed, invalidated) => {
                resolve()
            })
        })

        const promiseTimeout = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve()
            }, 5000)
        })

        await Promise.race([promiseScan, promiseTimeout])
        
        resolve(deviceManagerInterface.GetAllAccessPoints())
    })

    // Get properties of access points (this is a loop, I picked one item as an example):
    const apProxyObject = await bus.getProxyObject(dbusBaseName, accessPointPaths[0])
    const apPropertiesInterface = apProxyObject.getInterface(dbusPropertiesName)
    const allProperties = await apPropertiesInterface.GetAll(dbusBaseName + '.AccessPoint')

    // print:
    console.log(allProperties)
}

It took me ages to get to this point because the docs neither DBus, nor NetworkManager, nor this library are very helpful if you don't already know how this stuff works.

The above code prints the following:

{
  Flags: Variant { signature: 'u', value: 1 },
  WpaFlags: Variant { signature: 'u', value: 0 },
  RsnFlags: Variant { signature: 'u', value: 392 },
  Ssid: Variant { signature: 'ay', value: <Buffer 46 52 49 54 5a 21 42 6f 78 20 47 61 73 74 7a 75 67 61 6e 67> },
  Frequency: Variant { signature: 'u', value: 5220 },
  HwAddress: Variant { signature: 's', value: 'E0:18:60:6F:50:46' },
  Mode: Variant { signature: 'u', value: 2 },
  MaxBitrate: Variant { signature: 'u', value: 540000 },
  Strength: Variant { signature: 'y', value: 78 },
  LastSeen: Variant { signature: 'i', value: 28070 }
}

I understand the signatures approach of DBus and I spent quite some time to figure out if there is any mechanism to unmarshal those values with some built-in functions of dbus-next. I found it in the code but I didn't figure out how to apply it. Do I have to load some function to unmarshal this. Or should there be any method I can use on Variants to get the value?

The result should be an object with the same structure as the above, but instead of the Variant I would like to have the unmarshalled values. Which function can I use to do this?

Is this even the right approach? Shouldn't this be way easier?

Thanks in advance,
Fred

Provide debug logging to make issues on the bug tracker easier to handle.

Just importing dbus-next in a new javascript file causes this error:

DBus.js :

import { sessionBus, } from 'dbus-next';

Environment Info:

  System:
    OS: Linux 5.3 Ubuntu 18.04.4 LTS (Bionic Beaver)
    CPU: (8) x64 Intel(R) Core(TM) i7-4790K CPU @ 4.00GHz
  Binaries:
    Node: 14.3.0 - ~/.nvm/versions/node/v14.3.0/bin/node
    Yarn: 1.22.4 - /usr/bin/yarn
    npm: 6.14.5 - ~/.nvm/versions/node/v14.3.0/bin/npm
  Browsers:
    Chrome: 83.0.4103.116
    Firefox: 78.0.1
  npmGlobalPackages:
    @vue/cli: 4.4.4

"dbus-next": "^0.8.2"

How to solve the problem?

Marco

I'm trying to use this library as a way to consume signal-cli's bus service. However, dbus-next won't ever return after calling
let obj = await bus.getProxyObject('org.asamk.Signal', '/org/asamk/Signal');

I also run into a similar issue when running the following lower level code:

  let methodCall = new Message({
    destination: 'org.asamk.Signal',
    path: '/org/asamk/Signal',
    interface: 'org.asamk.Signal',
    member: 'sendMessage',
    signature: 'sass',
    body: ['MessageText2', [], '17876776273']
  });

  let reply = await bus.call(methodCall);
  console.log(reply) #never runs

It would be nice to include the bin/ directory in the package so that the tools are available without having to clone the source code repository.

Try to support earlier node versions by hiding new language features for versions that don't support them.

@CyDragon80 proposed a solution here: sidorares/dbus-native#251 (comment)

function getNodeMajor()
{
    var reg = /^[^\d]*(\d+)/;
    var temp = reg.exec(process.version);
    return (temp==null||temp[1]==null?0:parseInt(temp[1]));
}
module.exports.NodeMajor = getNodeMajor(); // only need to compute once
. . .
if (module.exports.NodeMajor >= 7)
{
    // new feature just for 7+
    const OptionalBit = require('optional-bit'); // module containing newer language features
    module.exports.newThing = OptionalBit.newThing; // new package feature export
    // etc etc
}
else
{
    // fallback if any? or leave new stuff undefined?
    module.exports.newThing = null; // ?
    module.exports.newThing = function() { throw new Error('Feature needs Node 7+')}; // ?
}

There appears to currently be no way to use a numeric key for a dict variant.

I'm trying to add BlueZ manufacture data which requires the signature "a{qay}". E.g. {0xFFFF, [0x70, 0x74]}

When attempting to pass a variant of {0xFFFF, [0x70, 0x74]}, dbus-next converts it to { '65535': [ 112, 116 ] }. Where Object.keys converts 0xFFF to a string '65535'. Is there anyway to allow non-string keys for dict entries? (Possibly parsing strings for numeric signature types or allowing arrays in addition to objects. e.g. [[Key,Value],[Key,[Key,Value]]] for {Key:Value, Key:{Key:Value}}.)

Thanks

It would be nice to have an access to a message in method handler. Currently, we only have message body but sometimes you need to know, for example, who is sending the message (sender). It can be added without a breaking change by adding it as a last argument:

class ExampleInterface extends Interface {
    // ....

    @method({inSignature: 's', outSignature: 's'})
    Echo(what, message) {
        return what;
    }
    
    // Or it can be an object that contains any other additional info
    @method({inSignature: 's', outSignature: 's'})
    Echo(what, { message }) {
        return what;
    }
}

When calling getProxyObject() it optionally asynchronous calls the D-Bus introspection method and then asynchronously parses XML before resolving the promise. During this time, it is possible to receive signals for this object, but they are missed since we can't attach signal handlers yet (even if XML is supplied and introspection step is skipped, it takes too long).

Real-world case: I'm trying to use this library with Avahi. It has methods (e.g. ServiceBrowserNew) that create a new D-Bus object and return the object path. Then we take the path and create a new proxy object. However, these objects immediately start receiving signals (e.g. ItemNew) as can be seen using the dbus-monitor command line tool. However dbus-next misses these because the signals happen before we ever get a proxy object.

How can we avoid this race condition?