Throw or return errors on disconnected connection

When an operation is attempted on a closed connection, throw a
Node-level error instead of allowing the C++ to surface an error. In
order to do this, we keep track of whether a bus is still connected or
whether it has already been disconnected.

serviceInterface.emitSignal does not have a callback and will throw an
error if the connection is already disconnected. All other methods that
try to use a disconnected connection will return the error in the
callback.

Author: bryanburgers

lib/bus.js

@@ -51,6 +51,12 @@ var Bus = module.exports = function(dbus, busName) {
 
 util.inherits(Bus, events.EventEmitter);
 
+Object.defineProperty(Bus.prototype, 'connected', {
+	get: function() {
+		return this.connection !== null;
+	}
+});
+
 Bus.prototype.disconnect = function(callback) {
 	var self = this;
 
@@ -97,6 +103,13 @@ Bus.prototype.reconnect = function(callback) {
 Bus.prototype.introspect = function(serviceName, objectPath, callback) {
 	var self = this;
 
+	if (!self.connected) {
+		process.nextTick(function() {
+			callback(new Error('Bus is no longer connected'));
+		});
+		return;
+	}
+
 	// Getting scheme of specific object
 	self.dbus.callMethod(self.connection,
 		serviceName,

lib/interface.js

@@ -15,6 +15,12 @@ var Interface = module.exports = function(bus, serviceName, objectPath, interfac
 
 util.inherits(Interface, events.EventEmitter);
 
+Object.defineProperty(Interface.prototype, 'connected', {
+	get: function() {
+		return this.bus.connected;
+	}
+});
+
 Interface.prototype.init = function(callback) {
 	var self = this;
 
@@ -48,6 +54,10 @@ Interface.prototype.init = function(callback) {
 				var error = this[method].error || null
 
 				process.nextTick(function() {
+					if (!self.connected) {
+						callback(new Error('Bus is no longer connected'));
+						return;
+					}
 
 					try {
 						self.bus.dbus.callMethod(self.bus.connection,
@@ -90,6 +100,13 @@ Interface.prototype.init = function(callback) {
 Interface.prototype.setProperty = function(propertyName, value, callback) {
 	var self = this;
 
+	if (!self.connected) {
+		process.nextTick(function() {
+			callback(new Error('Bus is no longer connected'));
+		});
+		return;
+	}
+
 	self.bus.dbus.callMethod(self.bus.connection,
 		self.serviceName,
 		self.objectPath,
@@ -108,6 +125,13 @@ Interface.prototype.setProperty = function(propertyName, value, callback) {
 Interface.prototype.getProperty = function(propertyName, callback) {
 	var self = this;
 
+	if (!self.connected) {
+		process.nextTick(function() {
+			callback(new Error('Bus is no longer connected'));
+		});
+		return;
+	}
+
 	self.bus.dbus.callMethod(self.bus.connection,
 		self.serviceName,
 		self.objectPath,
@@ -126,6 +150,13 @@ Interface.prototype.getProperty = function(propertyName, callback) {
 Interface.prototype.getProperties = function(callback) {
 	var self = this;
 
+	if (!self.connected) {
+		process.nextTick(function() {
+			callback(new Error('Bus is no longer connected'));
+		});
+		return;
+	}
+
 	self.bus.dbus.callMethod(self.bus.connection,
 		self.serviceName,
 		self.objectPath,

lib/service.js

@@ -22,6 +22,12 @@ var Service = module.exports = function(bus, serviceName) {
 
 util.inherits(Service, events.EventEmitter);
 
+Object.defineProperty(Service.prototype, 'connected', {
+	get: function() {
+		return this.bus.connected;
+	}
+});
+
 Service.prototype.createObject = function(objectPath) {
 	var self = this;
 

lib/service_interface.js

@@ -166,6 +166,11 @@ ServiceInterface.prototype.getProperties = function(callback) {
 ServiceInterface.prototype.emitSignal = function() {
 	var self = this;
 
+	var service = self.object.service;
+	if (!service.connected) {
+		throw new Error('Service is no longer connected');
+	}
+
 	var conn = self.object.service.bus.connection;
 	var objPath = self.object.path;
 	var interfaceName = self.name;

test/client-use-after-disconnect.test.js

@@ -0,0 +1,44 @@
+var tap = require('tap');
+var DBus = require('../');
+
+var dbus = new DBus();
+var bus = dbus.getBus('session');
+
+tap.plan(11);
+
+var timeout = setTimeout(function() {
+	tap.fail('Should have disconnected by now');
+	process.exit();
+}, 1000);
+timeout.unref();
+
+tap.ok('This is a dummy test. The real test is whether the tap.fail gets called on the timeout.');
+
+bus.getInterface('org.freedesktop.DBus', '/', 'org.freedesktop.DBus', function(err, iface) {
+	setTimeout(function() {
+		bus.disconnect();
+	}, 50);
+
+	setTimeout(function() {
+		iface.getProperty('Test', function(err, value) {
+			tap.type(err, Error);
+			tap.match(err.message, /no.*connected/, 'getProperty returns the correct error');
+		});
+		iface.setProperty('Test', 'Value', function(err) {
+			tap.type(err, Error);
+			tap.match(err.message, /no.*connected/, 'setProperty returns the correct error');
+		});
+		iface.getProperties(function(err, values) {
+			tap.type(err, Error);
+			tap.match(err.message, /no.*connected/, 'getProperties returns the correct error');
+		});
+		iface.NameHasOwner('Test', function(err, result) {
+			tap.type(err, Error);
+			tap.match(err.message, /no.*connected/, 'call returns the correct error');
+		});
+		bus.getInterface('org.freedesktop.DBus', '/obj', 'org.freedesktop.DBus', function(err, iface) {
+			tap.type(err, Error);
+			tap.match(err.message, /no.*connected/, 'getInterface returns the correct error');
+		});
+	}, 100);
+});

test/service-emit-after-disconnect.test.js

@@ -0,0 +1,27 @@
+var tap = require('tap');
+var DBus = require('../');
+
+tap.plan(2);
+
+var dbus = new DBus();
+var service = dbus.registerService('session', 'test.dbus.TestService');
+var object = service.createObject('/test/dbus/TestService');
+var iface = object.createInterface('test.dbus.TestService.Interface1');
+
+iface.addSignal('Test', { types: [DBus.Define(String)] });
+
+var timeout = setTimeout(function() {
+	tap.fail('Should have disconnected by now');
+	process.exit();
+}, 1000);
+timeout.unref();
+
+tap.ok('This is a dummy test. The real test is whether the tap.fail gets called on the timeout.');
+setTimeout(function() {
+	service.disconnect();
+}, 50);
+setTimeout(function() {
+	tap.throws(function() {
+		iface.emitSignal('Test', 'test');
+	}, /no.*connected/, 'Emit throws an error after disconnect');
+}, 100);