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.3.2",
  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 cloudeebus.ProxyObject = function(session, busConnection, busName, objectPath) {
 405         this.wampSession = session;
 406         this.busConnection = busConnection;
 407         this.busName = busName;
 408         this.objectPath = objectPath;
 409         this.interfaceProxies = {};
 410         return this;
 411 };
 412
 413
 414 cloudeebus.ProxyObject.prototype.getInterface = function(ifName) {
 415         return this.interfaceProxies[ifName];
 416 };
 417
 418
 419 cloudeebus.ProxyObject.prototype._introspect = function(successCB, errorCB) {
 420
 421         var self = this;
 422
 423         function getAllPropertiesSuccessCB(props) {
 424                 var ifProxy = self.interfaceProxies[self.propInterfaces[self.propInterfaces.length-1]];
 425                 for (var prop in props)
 426                         ifProxy[prop] = self[prop] = props[prop];
 427                 getAllPropertiesNextInterfaceCB();
 428         }
 429
 430         function getAllPropertiesNextInterfaceCB() {
 431                 self.propInterfaces.pop();
 432                 if (self.propInterfaces.length > 0)
 433                         self.callMethod("org.freedesktop.DBus.Properties",
 434                                 "GetAll",
 435                                 [self.propInterfaces[self.propInterfaces.length-1]],
 436                                 getAllPropertiesSuccessCB,
 437                                 errorCB ? errorCB : getAllPropertiesNextInterfaceCB);
 438                 else {
 439                         self.propInterfaces = null;
 440                         if (successCB)
 441                                 successCB(self);
 442                 }
 443         }
 444
 445         function introspectSuccessCB(str) {
 446                 var parser = new DOMParser();
 447                 var xmlDoc = parser.parseFromString(str, "text/xml");
 448                 var interfaces = xmlDoc.getElementsByTagName("interface");
 449                 self.propInterfaces = [];
 450                 var supportDBusProperties = false;
 451                 for (var i=0; i < interfaces.length; i++) {
 452                         var ifName = interfaces[i].attributes.getNamedItem("name").value;
 453                         self.interfaceProxies[ifName] = new cloudeebus.ProxyObject(self.wampSession, self.busConnection, self.busName, self.objectPath);
 454                         if (ifName == "org.freedesktop.DBus.Properties")
 455                                 supportDBusProperties = true;
 456                         var hasProperties = false;
 457                         var ifChild = interfaces[i].firstChild;
 458                         while (ifChild) {
 459                                 if (ifChild.nodeName == "method") {
 460                                         var nArgs = 0;
 461                                         var metChild = ifChild.firstChild;
 462                                         while (metChild) {
 463                                                 if (metChild.nodeName == "arg" &&
 464                                                         metChild.attributes.getNamedItem("direction").value == "in")
 465                                                                 nArgs++;
 466                                                 metChild = metChild.nextSibling;
 467                                         }
 468                                         var metName = ifChild.attributes.getNamedItem("name").value;
 469                                         if (!self[metName])
 470                                                 self._addMethod(ifName, metName, nArgs);
 471                                         self.interfaceProxies[ifName]._addMethod(ifName, metName, nArgs);
 472                                 }
 473                                 else if (ifChild.nodeName == "property") {
 474                                         if (!hasProperties)
 475                                                 self.propInterfaces.push(ifName);
 476                                         hasProperties = true;
 477                                 }
 478                                 ifChild = ifChild.nextSibling;
 479                         }
 480                 }
 481                 if (supportDBusProperties && self.propInterfaces.length > 0) {
 482                         self.callMethod("org.freedesktop.DBus.Properties",
 483                                 "GetAll",
 484                                 [self.propInterfaces[self.propInterfaces.length-1]],
 485                                 getAllPropertiesSuccessCB,
 486                                 errorCB ? errorCB : getAllPropertiesNextInterfaceCB);
 487                 }
 488                 else {
 489                         self.propInterfaces = null;
 490                         if (successCB)
 491                                 successCB(self);
 492                 }
 493         }
 494
 495         // call Introspect on self
 496         self.callMethod("org.freedesktop.DBus.Introspectable", "Introspect", [], introspectSuccessCB, errorCB);
 497 };
 498
 499
 500 cloudeebus.ProxyObject.prototype._addMethod = function(ifName, method, nArgs) {
 501
 502         var self = this;
 503
 504         self[method] = function() {
 505                 if (arguments.length < nArgs || arguments.length > nArgs + 2)
 506                         throw "Error: method " + method + " takes " + nArgs + " parameters, got " + arguments.length + ".";
 507                 var args = [];
 508                 var successCB = null;
 509                 var errorCB = null;
 510                 for (var i=0; i < nArgs; i++ )
 511                         args.push(arguments[i]);
 512                 if (arguments.length > nArgs)
 513                         successCB = arguments[nArgs];
 514                 if (arguments.length > nArgs + 1)
 515                         errorCB = arguments[nArgs + 1];
 516                 self.callMethod(ifName, method, args, successCB, errorCB);
 517         };
 518
 519 };
 520
 521
 522 cloudeebus.ProxyObject.prototype.callMethod = function(ifName, method, args, successCB, errorCB) {
 523
 524         var self = this;
 525
 526         function callMethodSuccessCB(str) {
 527                 if (successCB) {
 528                         try { // calling dbus hook object function for un-translated types
 529                                 successCB.apply(self, eval(str));
 530                         }
 531                         catch (e) {
 532                                 cloudeebus.log("Method callback exception: " + e);
 533                                 if (errorCB)
 534                                         errorCB(e);
 535                         }
 536                 }
 537         }
 538
 539         function callMethodErrorCB(error) {
 540                 cloudeebus.log("Error calling method: " + method + " on object: " + self.objectPath + " : " + error.desc);
 541                 if (errorCB)
 542                         errorCB(error.desc);
 543         }
 544
 545         var arglist = [
 546                 self.busConnection.name,
 547                 self.busName,
 548                 self.objectPath,
 549                 ifName,
 550                 method,
 551                 JSON.stringify(args)
 552         ];
 553
 554         // call dbusSend with bus type, destination, object, message and arguments
 555         self.wampSession.call("dbusSend", arglist).then(callMethodSuccessCB, callMethodErrorCB);
 556 };
 557
 558
 559 cloudeebus.ProxyObject.prototype.connectToSignal = function(ifName, signal, successCB, errorCB) {
 560
 561         var self = this;
 562
 563         function signalHandler(id, data) {
 564                 if (successCB) {
 565                         try { // calling dbus hook object function for un-translated types
 566                                 successCB.apply(self, eval(data));
 567                         }
 568                         catch (e) {
 569                                 cloudeebus.log("Signal handler exception: " + e);
 570                                 if (errorCB)
 571                                         errorCB(e);
 572                         }
 573                 }
 574         }
 575
 576         function connectToSignalSuccessCB(str) {
 577                 try {
 578                         self.wampSession.subscribe(str, signalHandler);
 579                 }
 580                 catch (e) {
 581                         cloudeebus.log("Subscribe error: " + e);
 582                 }
 583         }
 584
 585         function connectToSignalErrorCB(error) {
 586                 cloudeebus.log("Error connecting to signal: " + signal + " on object: " + self.objectPath + " : " + error.desc);
 587                 if (errorCB)
 588                         errorCB(error.desc);
 589         }
 590
 591         var arglist = [
 592                 self.busConnection.name,
 593                 self.busName,
 594                 self.objectPath,
 595                 ifName,
 596                 signal
 597         ];
 598
 599         // call dbusSend with bus type, destination, object, message and arguments
 600         self.wampSession.call("dbusRegister", arglist).then(connectToSignalSuccessCB, connectToSignalErrorCB);
 601 };
 602
 603
 604 cloudeebus.ProxyObject.prototype.disconnectSignal = function(ifName, signal) {
 605         try {
 606                 this.wampSession.unsubscribe(this.busConnection.name + "#" + this.busName + "#" + this.objectPath + "#" + ifName + "#" + signal);
 607         }
 608         catch (e) {
 609                 cloudeebus.log("Unsubscribe error: " + e);
 610         }
 611 };