cloudeebus/cloudeebus.js

   1 /******************************************************************************
   2  * Copyright 2012 Intel Corporation.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *****************************************************************************/
  16
  17
  18
  19 /*****************************************************************************/
  20
  21 var dbus = { // hook object for dbus types not translated by python-json
  22                 Double: function(value, level) {
  23                         return value;
  24                 }
  25 };
  26
  27
  28
  29 /*****************************************************************************/
  30
  31 var cloudeebus = window.cloudeebus = {
  32                 version: "0.4.0",
  33                 minVersion: "0.3.2"
  34 };
  35
  36 cloudeebus.reset = function() {
  37         cloudeebus.sessionBus = null;
  38         cloudeebus.systemBus = null;
  39         cloudeebus.wampSession = null;
  40         cloudeebus.uri = null;
  41 };
  42
  43
  44 cloudeebus.log = function(msg) {
  45 };
  46
  47
  48 cloudeebus.versionCheck = function(version) {
  49         var ver = version.split(".");
  50         var min = cloudeebus.minVersion.split(".");
  51         for (var i=0; i<ver.length; i++) {
  52                 if (Number(ver[i]) > Number(min[i]))
  53                         return true;
  54                 if (Number(ver[i]) < Number(min[i]))
  55                         return false;
  56         }
  57         return true;
  58 };
  59
  60
  61 cloudeebus.connect = function(uri, manifest, successCB, errorCB) {
  62         cloudeebus.reset();
  63         cloudeebus.uri = uri;
  64
  65         function onCloudeebusVersionCheckCB(version) {
  66                 if (cloudeebus.versionCheck(version)) {
  67                         cloudeebus.log("Connected to " + cloudeebus.uri);
  68                         if (successCB)
  69                                 successCB();
  70                 } else {
  71                         var errorMsg = "Cloudeebus server version " + version + " unsupported, need version " + cloudeebus.minVersion + " or superior";
  72                         cloudeebus.log(errorMsg);
  73                         if (errorCB)
  74                                 errorCB(errorMsg);
  75                 }
  76         }
  77
  78         function onWAMPSessionAuthErrorCB(error) {
  79                 cloudeebus.log("Authentication error: " + error.desc);
  80                 if (errorCB)
  81                         errorCB(error.desc);
  82         }
  83
  84         function onWAMPSessionAuthenticatedCB(permissions) {
  85                 cloudeebus.sessionBus = new cloudeebus.BusConnection("session", cloudeebus.wampSession);
  86                 cloudeebus.systemBus = new cloudeebus.BusConnection("system", cloudeebus.wampSession);
  87                 cloudeebus.wampSession.call("getVersion").then(onCloudeebusVersionCheckCB, errorCB);
  88         }
  89
  90         function onWAMPSessionChallengedCB(challenge) {
  91                 var signature = cloudeebus.wampSession.authsign(challenge, manifest.key);
  92                 cloudeebus.wampSession.auth(signature).then(onWAMPSessionAuthenticatedCB, onWAMPSessionAuthErrorCB);
  93         }
  94
  95         function onWAMPSessionConnectedCB(session) {
  96                 cloudeebus.wampSession = session;
  97                 if (manifest)
  98                         cloudeebus.wampSession.authreq(
  99                                         manifest.name,
 100                                         {permissions: manifest.permissions}
 101                                 ).then(onWAMPSessionChallengedCB, onWAMPSessionAuthErrorCB);
 102                 else
 103                         cloudeebus.wampSession.authreq().then(function() {
 104                                 cloudeebus.wampSession.auth().then(onWAMPSessionAuthenticatedCB, onWAMPSessionAuthErrorCB);
 105                                 }, onWAMPSessionAuthErrorCB);
 106         }
 107
 108         function onWAMPSessionErrorCB(code, reason) {
 109                 if (code == ab.CONNECTION_UNSUPPORTED) {
 110                         cloudeebus.log("Browser is not supported");
 111                 }
 112                 else {
 113                         cloudeebus.log("Failed to open session, code = " + code + ", reason = " + reason);
 114                 }
 115                 if (errorCB)
 116                         errorCB(reason);
 117         }
 118
 119         return ab.connect(cloudeebus.uri, onWAMPSessionConnectedCB, onWAMPSessionErrorCB);
 120 };
 121
 122
 123 cloudeebus.SessionBus = function() {
 124         return cloudeebus.sessionBus;
 125 };
 126
 127
 128 cloudeebus.SystemBus = function() {
 129         return cloudeebus.systemBus;
 130 };
 131
 132
 133
 134 /*****************************************************************************/
 135
 136 cloudeebus.BusConnection = function(name, session) {
 137         this.name = name;
 138         this.wampSession = session;
 139         this.service = null;
 140         return this;
 141 };
 142
 143
 144 cloudeebus.BusConnection.prototype.getObject = function(busName, objectPath, introspectCB, errorCB) {
 145         var proxy = new cloudeebus.ProxyObject(this.wampSession, this, busName, objectPath);
 146         if (introspectCB)
 147                 proxy._introspect(introspectCB, errorCB);
 148         return proxy;
 149 };
 150
 151
 152 cloudeebus.BusConnection.prototype.addService = function(serviceName, successCB, errorCB) {
 153         var self = this;
 154
 155         cloudeebusService = new cloudeebus.Service(this.wampSession, this, serviceName);
 156
 157         function busServiceAddedSuccessCB(service) {
 158                 self.service = cloudeebusService;
 159                 if (successCB)
 160                         successCB(cloudeebusService);
 161         }
 162
 163         cloudeebusService.add(busServiceAddedSuccessCB, errorCB);
 164         return cloudeebusService;
 165 };
 166
 167 cloudeebus.BusConnection.prototype.removeService = function(serviceName, successCB, errorCB) {
 168         var self = this;
 169
 170         function busServiceRemovedSuccessCB(serviceName) {
 171                 // Be sure we are removing the service requested...
 172                 if (serviceName == self.service.name) {
 173                         self.service = null;
 174                         if (successCB)
 175                                 successCB(serviceName);
 176                 }
 177         }
 178
 179         cloudeebusService.remove(busServiceRemovedSuccessCB, errorCB);
 180 };
 181
 182
 183 /*****************************************************************************/
 184
 185 cloudeebus.Service = function(session, busConnection, name) {
 186         this.wampSession = session;
 187         this.busConnection = busConnection;
 188         this.name = name;
 189         this.isCreated = false;
 190         return this;
 191 };
 192
 193 cloudeebus.Service.prototype.add = function(successCB, errorCB) {
 194         var self = this;
 195
 196         function ServiceAddedSuccessCB(serviceName) {
 197                 if (successCB) {
 198                         try {
 199                                 successCB(self);
 200                         }
 201                         catch (e) {
 202                                 alert("Exception adding service " + serviceName + " : " + e);
 203                         }
 204                 }
 205         }
 206
 207         var arglist = [
 208             this.busConnection,
 209             this.name
 210             ];
 211
 212         // call dbusSend with bus type, destination, object, message and arguments
 213         this.wampSession.call("serviceAdd", arglist).then(ServiceAddedSuccessCB, errorCB);
 214 };
 215
 216 cloudeebus.Service.prototype.remove = function(successCB, errorCB) {
 217         function ServiceRemovedSuccessCB(serviceName) {
 218                 if (successCB) {
 219                         try {
 220                                 successCB(serviceName);
 221                         }
 222                         catch (e) {
 223                                 alert("Exception removing service " + serviceName + " : " + e);
 224                         }
 225                 }
 226         }
 227
 228         var arglist = [
 229             this.name
 230             ];
 231
 232         // call dbusSend with bus type, destination, object, message and arguments
 233         this.wampSession.call("serviceRelease", arglist).then(ServiceRemovedSuccessCB, errorCB);
 234 };
 235
 236 cloudeebus.Service.prototype._searchMethod = function(ifName, method, objectJS) {
 237
 238         var funcToCall = null;
 239
 240         // Check if 'objectJS' has a member 'interfaceProxies' with an interface named 'ifName'
 241         // and a method named 'method'
 242         if (objectJS.interfaceProxies && objectJS.interfaceProxies[ifName] &&
 243                 objectJS.interfaceProxies[ifName][method]) {
 244                 funcToCall = objectJS.interfaceProxies[ifName][method];
 245         } else {
 246                 // retrieve the method directly from 'root' of objectJs
 247                 funcToCall = objectJS[method];
 248         }
 249
 250         return funcToCall;
 251 };
 252
 253 cloudeebus.Service.prototype._addMethod = function(objectPath, ifName, method, objectJS) {
 254
 255         var service = this;
 256         var methodId = this.name + "#" + objectPath + "#" + ifName + "#" + method;
 257         var funcToCall = this._searchMethod(ifName, method, objectJS);
 258
 259         if (funcToCall == null)
 260                 cloudeebus.log("Method " + method + " doesn't exist in Javascript object");
 261         else {
 262                 objectJS.wrapperFunc[method] = function() {
 263                         var result;
 264                         var methodId = arguments[0];
 265                         var callDict = {};
 266                         // affectation of callDict in eval, otherwise dictionary(='{}') interpreted as block of code by eval
 267                         eval("callDict = " + arguments[1]);
 268                         try {
 269                                 result = funcToCall.apply(objectJS, callDict.args);
 270                                 service._returnMethod(methodId, callDict.callIndex, true, result);
 271                         }
 272                         catch (e) {
 273                                 cloudeebus.log("Method " + ifName + "." + method + " call on " + objectPath + " exception: " + e);
 274                                 service._returnMethod(methodId, callDict.callIndex, false, e.message);
 275                         }
 276                 };
 277                 this._registerMethod(methodId, objectJS.wrapperFunc[method]);
 278         }
 279 };
 280
 281 cloudeebus.Service.prototype._addSignal = function(objectPath, ifName, signal, objectJS) {
 282         var service = this;
 283         var methodExist = false;
 284
 285         if (objectJS.interfaceProxies && objectJS.interfaceProxies[ifName])
 286                 if (objectJS.interfaceProxies[ifName][signal]) {
 287                         methodExist = true;
 288                 } else {
 289                         objectJS.interfaceProxies[ifName][signal] = function() {
 290                                 service.emitSignal(objectPath, signal, arguments[0]);
 291                         };
 292                 return;
 293         }
 294
 295         if ((objectJS[signal] == undefined || objectJS[signal] == null) && !methodExist)
 296                 objectJS[signal] = function() {
 297                         service.emitSignal(objectPath, signal, arguments[0]);
 298                 };
 299         else
 300                 cloudeebus.log("Can not create new method to emit signal '" + signal + "' in object JS this method already exist!");
 301 };
 302
 303 cloudeebus.Service.prototype._createWrapper = function(xmlTemplate, objectPath, objectJS) {
 304         var self = this;
 305         var parser = new DOMParser();
 306         var xmlDoc = parser.parseFromString(xmlTemplate, "text/xml");
 307         var ifXml = xmlDoc.getElementsByTagName("interface");
 308         objectJS.wrapperFunc = [];
 309         for (var i=0; i < ifXml.length; i++) {
 310                 var ifName = ifXml[i].attributes.getNamedItem("name").value;
 311                 var ifChild = ifXml[i].firstChild;
 312                 while (ifChild) {
 313                         if (ifChild.nodeName == "method") {
 314                                 var metName = ifChild.attributes.getNamedItem("name").value;
 315                                 self._addMethod(objectPath, ifName, metName, objectJS);
 316                         }
 317                         if (ifChild.nodeName == "signal") {
 318                                 var metName = ifChild.attributes.getNamedItem("name").value;
 319                                 self._addSignal(objectPath, ifName, metName, objectJS);
 320                         }
 321                         ifChild = ifChild.nextSibling;
 322                 }
 323         }
 324 };
 325
 326 cloudeebus.Service.prototype.addAgent = function(objectPath, xmlTemplate, objectJS, successCB, errorCB) {
 327         function ServiceAddAgentSuccessCB(objPath) {
 328                 if (successCB) {
 329                         try {
 330                                 successCB(objPath);
 331                         }
 332                         catch (e) {
 333                                 alert("Exception adding agent " + objectPath + " : " + e);
 334                         }
 335                 }
 336         }
 337
 338         try {
 339                 this._createWrapper(xmlTemplate, objectPath, objectJS);
 340         }
 341         catch (e) {
 342                 alert("Exception creating agent wrapper " + objectPath + " : " + e);
 343                 errorCB(e.desc);
 344                 return;
 345         }
 346
 347         var arglist = [
 348             objectPath,
 349             xmlTemplate
 350             ];
 351
 352         // call dbusSend with bus type, destination, object, message and arguments
 353         this.wampSession.call("serviceAddAgent", arglist).then(ServiceAddAgentSuccessCB, errorCB);
 354 };
 355
 356 cloudeebus.Service.prototype.delAgent = function(objectPath, successCB, errorCB) {
 357         function ServiceDelAgentSuccessCB(agent) {
 358                 if (successCB) {
 359                         try {
 360                                 successCB(agent);
 361                         }
 362                         catch (e) {
 363                                 alert("Exception deleting agent " + objectPath + " : " + e);
 364                         }
 365                 }
 366         }
 367
 368         var arglist = [
 369             objectPath
 370             ];
 371
 372         // call dbusSend with bus type, destination, object, message and arguments
 373         this.wampSession.call("serviceDelAgent", arglist).then(ServiceDelAgentSuccessCB, errorCB);
 374 };
 375
 376 cloudeebus.Service.prototype._registerMethod = function(methodId, methodHandler) {
 377         this.wampSession.subscribe(methodId, methodHandler);
 378 };
 379
 380 cloudeebus.Service.prototype._returnMethod = function(methodId, callIndex, success, result, successCB, errorCB) {
 381         var arglist = [
 382             methodId,
 383             callIndex,
 384             success,
 385             result
 386             ];
 387
 388         this.wampSession.call("returnMethod", arglist).then(successCB, errorCB);
 389 };
 390
 391 cloudeebus.Service.prototype.emitSignal = function(objectPath, signalName, result, successCB, errorCB) {
 392         var arglist = [
 393             objectPath,
 394             signalName,
 395             result
 396             ];
 397
 398         this.wampSession.call("emitSignal", arglist).then(successCB, errorCB);
 399 };
 400
 401
 402 /*****************************************************************************/
 403
 404 function _processWrappers(wrappers, value) {
 405         for (var i=0; i<wrappers.length; i++)
 406                 wrappers[i](value);
 407 }
 408
 409
 410 function _processWrappersAsync(wrappers, value) {
 411         var taskid = -1;
 412         function processAsyncOnce() {
 413                 _processWrappers(wrappers, value);
 414                 clearInterval(taskid);
 415         }
 416         taskid = setInterval(processAsyncOnce, 200);
 417 }
 418
 419
 420
 421 /*****************************************************************************/
 422
 423 cloudeebus.FutureResolver = function(future) {
 424         this.future = future;
 425         this.resolved = null;
 426     return this;
 427 };
 428
 429
 430 cloudeebus.FutureResolver.prototype.resolve = function(value, sync) {
 431         if (this.resolved)
 432                 return;
 433
 434         var then = (value && value.then && value.then.apply) ? value.then : null;
 435         if (then) {
 436                 var self = this;
 437                 var acceptCallback = function(arg) {
 438                         self.accept(arg, true);
 439                 };
 440                 var rejectCallback = function(arg) {
 441                         self.reject(arg, true);
 442                 };
 443                 try {
 444                         then.apply(value, [acceptCallback, rejectCallback]);
 445                 }
 446                 catch (e) {
 447                         this.reject(e, true);
 448                 }
 449         }
 450
 451         this.accept(value, sync);
 452 };
 453
 454
 455 cloudeebus.FutureResolver.prototype.accept = function(value, sync) {
 456         if (this.resolved)
 457                 return;
 458
 459         var future = this.future;
 460         future.state = "accepted";
 461         future.result = value;
 462
 463         this.resolved = true;
 464         if (sync)
 465                 _processWrappers(future._acceptWrappers, value);
 466         else
 467                 _processWrappersAsync(future._acceptWrappers, value);
 468 };
 469
 470
 471 cloudeebus.FutureResolver.prototype.reject = function(value, sync) {
 472         if (this.resolved)
 473                 return;
 474
 475         var future = this.future;
 476         future.state = "rejected";
 477         future.result = value;
 478
 479         this.resolved = true;
 480         if (sync)
 481                 _processWrappers(future._rejectWrappers, value);
 482         else
 483                 _processWrappersAsync(future._rejectWrappers, value);
 484 };
 485
 486
 487
 488 /*****************************************************************************/
 489
 490 cloudeebus.Future = function(init) {
 491         this.state = "pending";
 492         this.result = null;
 493         this._acceptWrappers = [];
 494         this._rejectWrappers = [];
 495         this.resolver = new cloudeebus.FutureResolver(this);
 496         if (init) {
 497                 try {
 498                         init.apply(this, [this.resolver]);
 499                 }
 500                 catch (e) {
 501                         this.resolver.reject(e, true);
 502                 }
 503         }
 504     return this;
 505 };
 506
 507
 508 cloudeebus.Future.prototype.appendWrappers = function(acceptWrapper, rejectWrapper) {
 509         this._acceptWrappers.push(acceptWrapper);
 510         this._rejectWrappers.push(rejectWrapper);
 511         if (this.state == "accepted")
 512                 _processWrappersAsync(this._acceptWrappers, this.result);
 513         if (this.state == "rejected")
 514                 _processWrappersAsync(this._rejectWrappers, this.result);
 515 };
 516
 517
 518 cloudeebus.Future.prototype.then = function(acceptCB, rejectCB) {
 519         var future = new cloudeebus.Future();
 520         var resolver = future.resolver;
 521         var acceptWrapper, rejectWrapper;
 522
 523         if (acceptCB)
 524                 acceptWrapper = function(arg) {
 525                         try {
 526                                 var value = acceptCB.apply(future, [arg]);
 527                                 resolver.resolve(value, true);
 528                         }
 529                         catch (e) {
 530                                 resolver.reject(e, true);
 531                         }
 532                 };
 533         else
 534                 acceptWrapper = function(arg) {
 535                         resolver.accept(arg, true);
 536                 };
 537
 538         if (rejectCB)
 539                 rejectWrapper = function(arg) {
 540                         try {
 541                                 var value = rejectCB.apply(future, [arg]);
 542                                 resolver.resolve(value, true);
 543                         }
 544                         catch (e) {
 545                                 resolver.reject(e, true);
 546                         }
 547                 };
 548         else
 549                 rejectWrapper = function(arg) {
 550                         resolver.reject(arg, true);
 551                 };
 552
 553         this.appendWrappers(acceptWrapper,rejectWrapper);
 554         return future;
 555 };
 556
 557
 558
 559 /*****************************************************************************/
 560
 561 cloudeebus.ProxyObject = function(session, busConnection, busName, objectPath) {
 562         this.wampSession = session;
 563         this.busConnection = busConnection;
 564         this.busName = busName;
 565         this.objectPath = objectPath;
 566         this.interfaceProxies = {};
 567         return this;
 568 };
 569
 570
 571 cloudeebus.ProxyObject.prototype.getInterface = function(ifName) {
 572         return this.interfaceProxies[ifName];
 573 };
 574
 575
 576 cloudeebus.ProxyObject.prototype._introspect = function(successCB, errorCB) {
 577
 578         var self = this;
 579
 580         function getAllPropertiesSuccessCB(props) {
 581                 var ifProxy = self.interfaceProxies[self.propInterfaces[self.propInterfaces.length-1]];
 582                 for (var prop in props)
 583                         ifProxy[prop] = self[prop] = props[prop];
 584                 getAllPropertiesNextInterfaceCB();
 585         }
 586
 587         function getAllPropertiesNextInterfaceCB() {
 588                 self.propInterfaces.pop();
 589                 if (self.propInterfaces.length > 0)
 590                         self.callMethod("org.freedesktop.DBus.Properties",
 591                                 "GetAll",
 592                                 [self.propInterfaces[self.propInterfaces.length-1]]).then(getAllPropertiesSuccessCB,
 593                                 errorCB ? errorCB : getAllPropertiesNextInterfaceCB);
 594                 else {
 595                         self.propInterfaces = null;
 596                         if (successCB)
 597                                 successCB(self);
 598                 }
 599         }
 600
 601         function introspectSuccessCB(str) {
 602                 var parser = new DOMParser();
 603                 var xmlDoc = parser.parseFromString(str, "text/xml");
 604                 var interfaces = xmlDoc.getElementsByTagName("interface");
 605                 self.propInterfaces = [];
 606                 var supportDBusProperties = false;
 607                 for (var i=0; i < interfaces.length; i++) {
 608                         var ifName = interfaces[i].attributes.getNamedItem("name").value;
 609                         self.interfaceProxies[ifName] = new cloudeebus.ProxyObject(self.wampSession, self.busConnection, self.busName, self.objectPath);
 610                         if (ifName == "org.freedesktop.DBus.Properties")
 611                                 supportDBusProperties = true;
 612                         var hasProperties = false;
 613                         var ifChild = interfaces[i].firstChild;
 614                         while (ifChild) {
 615                                 if (ifChild.nodeName == "method") {
 616                                         var nArgs = 0;
 617                                         var signature = "";
 618                                         var metChild = ifChild.firstChild;
 619                                         while (metChild) {
 620                                                 if (metChild.nodeName == "arg" &&
 621                                                         metChild.attributes.getNamedItem("direction").value == "in") {
 622                                                                 signature += metChild.attributes.getNamedItem("type").value;
 623                                                                 nArgs++;
 624                                                 }
 625                                                 metChild = metChild.nextSibling;
 626                                         }
 627                                         var metName = ifChild.attributes.getNamedItem("name").value;
 628                                         if (!self[metName])
 629                                                 self._addMethod(ifName, metName, nArgs, signature);
 630                                         self.interfaceProxies[ifName]._addMethod(ifName, metName, nArgs, signature);
 631                                 }
 632                                 else if (ifChild.nodeName == "property") {
 633                                         if (!hasProperties)
 634                                                 self.propInterfaces.push(ifName);
 635                                         hasProperties = true;
 636                                 }
 637                                 ifChild = ifChild.nextSibling;
 638                         }
 639                 }
 640                 if (supportDBusProperties && self.propInterfaces.length > 0) {
 641                         self.callMethod("org.freedesktop.DBus.Properties",
 642                                 "GetAll",
 643                                 [self.propInterfaces[self.propInterfaces.length-1]]).then(getAllPropertiesSuccessCB,
 644                                 errorCB ? errorCB : getAllPropertiesNextInterfaceCB);
 645                 }
 646                 else {
 647                         self.propInterfaces = null;
 648                         if (successCB)
 649                                 successCB(self);
 650                 }
 651         }
 652
 653         // call Introspect on self
 654         self.callMethod("org.freedesktop.DBus.Introspectable", "Introspect", []).then(introspectSuccessCB, errorCB);
 655 };
 656
 657
 658 cloudeebus.ProxyObject.prototype._addMethod = function(ifName, method, nArgs, signature) {
 659
 660         var self = this;
 661
 662         self[method] = function() {
 663                 var args = [];
 664                 for (var i=0; i < nArgs; i++ )
 665                         args.push(arguments[i]);
 666                 return self.callMethod(ifName, method, args, signature);
 667         };
 668 };
 669
 670
 671 cloudeebus.ProxyObject.prototype.callMethod = function(ifName, method, args, signature) {
 672
 673         var self = this;
 674
 675         var future = new cloudeebus.Future(function (resolver) {
 676                 function callMethodSuccessCB(str) {
 677                         try { // calling dbus hook object function for un-translated types
 678                                 var result = eval(str);
 679                                 resolver.accept(result[0], true);
 680                         }
 681                         catch (e) {
 682                                 cloudeebus.log("Method callback exception: " + e);
 683                                 resolver.reject(e, true);
 684                         }
 685                 }
 686
 687                 function callMethodErrorCB(error) {
 688                         cloudeebus.log("Error calling method: " + method + " on object: " + self.objectPath + " : " + error.desc);
 689                         resolver.reject(error.desc, true);
 690                 }
 691
 692                 var arglist = [
 693                         self.busConnection.name,
 694                         self.busName,
 695                         self.objectPath,
 696                         ifName,
 697                         method,
 698                         JSON.stringify(args)
 699                 ];
 700
 701                 // call dbusSend with bus type, destination, object, message and arguments
 702                 self.wampSession.call("dbusSend", arglist).then(callMethodSuccessCB, callMethodErrorCB);
 703         });
 704
 705         return future;
 706 };
 707
 708
 709 cloudeebus.ProxyObject.prototype.connectToSignal = function(ifName, signal, successCB, errorCB) {
 710
 711         var self = this;
 712
 713         function signalHandler(id, data) {
 714                 if (successCB) {
 715                         try { // calling dbus hook object function for un-translated types
 716                                 successCB.apply(self, eval(data));
 717                         }
 718                         catch (e) {
 719                                 cloudeebus.log("Signal handler exception: " + e);
 720                                 if (errorCB)
 721                                         errorCB(e);
 722                         }
 723                 }
 724         }
 725
 726         function connectToSignalSuccessCB(str) {
 727                 try {
 728                         self.wampSession.subscribe(str, signalHandler);
 729                 }
 730                 catch (e) {
 731                         cloudeebus.log("Subscribe error: " + e);
 732                 }
 733         }
 734
 735         function connectToSignalErrorCB(error) {
 736                 cloudeebus.log("Error connecting to signal: " + signal + " on object: " + self.objectPath + " : " + error.desc);
 737                 if (errorCB)
 738                         errorCB(error.desc);
 739         }
 740
 741         var arglist = [
 742                 self.busConnection.name,
 743                 self.busName,
 744                 self.objectPath,
 745                 ifName,
 746                 signal
 747         ];
 748
 749         // call dbusSend with bus type, destination, object, message and arguments
 750         self.wampSession.call("dbusRegister", arglist).then(connectToSignalSuccessCB, connectToSignalErrorCB);
 751 };
 752
 753
 754 cloudeebus.ProxyObject.prototype.disconnectSignal = function(ifName, signal) {
 755         try {
 756                 this.wampSession.unsubscribe(this.busConnection.name + "#" + this.busName + "#" + this.objectPath + "#" + ifName + "#" + signal);
 757         }
 758         catch (e) {
 759                 cloudeebus.log("Unsubscribe error: " + e);
 760         }
 761 };