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