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         return this;
 140 };
 141
 142
 143 cloudeebus.BusConnection.prototype.getObject = function(busName, objectPath, introspectCB, errorCB) {
 144         var proxy = new cloudeebus.ProxyObject(this.wampSession, this, busName, objectPath);
 145         if (introspectCB)
 146                 proxy._introspect(introspectCB, errorCB);
 147         return proxy;
 148 };
 149
 150
 151
 152 /*****************************************************************************/
 153
 154 function _processWrappers(wrappers, value) {
 155         for (var i=0; i<wrappers.length; i++)
 156                 wrappers[i](value);
 157 }
 158
 159
 160 function _processWrappersAsync(wrappers, value) {
 161         var taskid = -1;
 162         function processAsyncOnce() {
 163                 _processWrappers(wrappers, value);
 164                 clearInterval(taskid);
 165         }
 166         taskid = setInterval(processAsyncOnce, 200);
 167 }
 168
 169
 170
 171 /*****************************************************************************/
 172
 173 cloudeebus.FutureResolver = function(future) {
 174         this.future = future;
 175         this.resolved = null;
 176     return this;
 177 };
 178
 179
 180 cloudeebus.FutureResolver.prototype.resolve = function(value, sync) {
 181         if (this.resolved)
 182                 return;
 183
 184         var then = (value && value.then && value.then.apply) ? value.then : null;
 185         if (then) {
 186                 var self = this;
 187                 var acceptCallback = function(arg) {
 188                         self.resolve(arg, true);
 189                 };
 190                 var rejectCallback = function(arg) {
 191                         self.reject(arg, true);
 192                 };
 193                 try {
 194                         then.apply(value, [acceptCallback, rejectCallback]);
 195                 }
 196                 catch (e) {
 197                         this.reject(e, true);
 198                 }
 199         }
 200
 201         this.accept(value, sync);
 202 };
 203
 204
 205 cloudeebus.FutureResolver.prototype.accept = function(value, sync) {
 206         if (this.resolved)
 207                 return;
 208
 209         var future = this.future;
 210         future.state = "accepted";
 211         future.result = value;
 212
 213         this.resolved = true;
 214         if (sync)
 215                 _processWrappers(future._acceptWrappers, value);
 216         else
 217                 _processWrappersAsync(future._acceptWrappers, value);
 218 };
 219
 220
 221 cloudeebus.FutureResolver.prototype.reject = function(value, sync) {
 222         if (this.resolved)
 223                 return;
 224
 225         var future = this.future;
 226         future.state = "rejected";
 227         future.result = value;
 228
 229         this.resolved = true;
 230         if (sync)
 231                 _processWrappers(future._rejectWrappers, value);
 232         else
 233                 _processWrappersAsync(future._rejectWrappers, value);
 234 };
 235
 236
 237
 238 /*****************************************************************************/
 239
 240 cloudeebus.Future = function(init) {
 241         this.state = "pending";
 242         this.result = null;
 243         this._acceptWrappers = [];
 244         this._rejectWrappers = [];
 245         this.resolver = new cloudeebus.FutureResolver(this);
 246         if (init) {
 247                 try {
 248                         init.apply(this, [this.resolver]);
 249                 }
 250                 catch (e) {
 251                         this.resolver.reject(e, true);
 252                 }
 253         }
 254     return this;
 255 };
 256
 257
 258 cloudeebus.Future.prototype.appendWrappers = function(acceptWrapper, rejectWrapper) {
 259         if (acceptWrapper)
 260                 this._acceptWrappers.push(acceptWrapper);
 261         if (rejectWrapper)
 262                 this._rejectWrappers.push(rejectWrapper);
 263         if (this.state == "accepted")
 264                 _processWrappersAsync(this._acceptWrappers, this.result);
 265         if (this.state == "rejected")
 266                 _processWrappersAsync(this._rejectWrappers, this.result);
 267 };
 268
 269
 270 cloudeebus.Future.prototype.then = function(acceptCB, rejectCB) {
 271         var future = new cloudeebus.Future();
 272         var resolver = future.resolver;
 273         var acceptWrapper, rejectWrapper;
 274
 275         if (acceptCB)
 276                 acceptWrapper = function(arg) {
 277                         try {
 278                                 var value = acceptCB.apply(future, [arg]);
 279                                 resolver.resolve(value, true);
 280                         }
 281                         catch (e) {
 282                                 resolver.reject(e, true);
 283                         }
 284                 };
 285         else
 286                 acceptWrapper = function(arg) {
 287                         resolver.accept(arg, true);
 288                 };
 289
 290         if (rejectCB)
 291                 rejectWrapper = function(arg) {
 292                         try {
 293                                 var value = rejectCB.apply(future, [arg]);
 294                                 resolver.resolve(value, true);
 295                         }
 296                         catch (e) {
 297                                 resolver.reject(e, true);
 298                         }
 299                 };
 300         else
 301                 rejectWrapper = function(arg) {
 302                         resolver.reject(arg, true);
 303                 };
 304
 305         this.appendWrappers(acceptWrapper,rejectWrapper);
 306         return future;
 307 };
 308
 309
 310 cloudeebus.Future.prototype["catch"] = function(rejectCB) {
 311         return this.then(undefined,rejectCB);
 312 };
 313
 314
 315 cloudeebus.Future.prototype.done = function(acceptCB, rejectCB) {
 316         this.appendWrappers(acceptCB,rejectCB);
 317 };
 318
 319
 320 cloudeebus.Future.resolve = function(value) {
 321         var future = new cloudeebus.Future();
 322         future.resolver.resolve(value);
 323         return future;
 324 };
 325
 326
 327 cloudeebus.Future.accept = function(value) {
 328         var future = new cloudeebus.Future();
 329         future.resolver.accept(value);
 330         return future;
 331 };
 332
 333
 334 cloudeebus.Future.reject = function(value) {
 335         var future = new cloudeebus.Future();
 336         future.resolver.reject(value);
 337         return future;
 338 };
 339
 340
 341 cloudeebus.Future.any = function() {
 342         var future = new cloudeebus.Future();
 343         var resolver = future.resolver;
 344         var acceptCallback = function(arg) {
 345                 resolver.resolve(arg, true);
 346         };
 347         var rejectCallback = function(arg) {
 348                 resolver.reject(arg, true);
 349         };
 350         if (arguments.length == 0)
 351                 resolver.resolve(undefined, true);
 352         else
 353                 for (i in arguments)
 354                         Future.resolve(arguments[i]).appendWrappers(acceptCallback,rejectCallback);
 355         return future;
 356 };
 357
 358
 359 cloudeebus.Future.every = function() {
 360         var future = new cloudeebus.Future();
 361         var resolver = future.resolver;
 362         var index = 0;
 363         var countdown = arguments.length;
 364         var args = new Array(countdown);
 365         var rejectCallback = function(arg) {
 366                 resolver.reject(arg, true);
 367         };
 368         if (arguments.length == 0)
 369                 resolver.resolve(undefined, true);
 370         else
 371                 for (i in arguments) {
 372                         var acceptCallback = function(arg) {
 373                                 args[index] = arg;
 374                                 countdown--;
 375                                 if (countdown == 0)
 376                                         resolver.resolve(args, true);
 377                         };
 378                         index++;
 379                         Future.resolve(arguments[i]).appendWrappers(acceptCallback,rejectCallback);
 380                 }
 381
 382         return future;
 383 };
 384
 385
 386 cloudeebus.Future.some = function() {
 387         var future = new cloudeebus.Future();
 388         var resolver = future.resolver;
 389         var index = 0;
 390         var countdown = arguments.length;
 391         var args = new Array(countdown);
 392         var acceptCallback = function(arg) {
 393                 resolver.resolve(arg, true);
 394         };
 395         if (arguments.length == 0)
 396                 resolver.resolve(undefined, true);
 397         else
 398                 for (i in arguments) {
 399                         var rejectCallback = function(arg) {
 400                                 args[index] = arg;
 401                                 countdown--;
 402                                 if (countdown == 0)
 403                                         resolver.reject(args, true);
 404                         };
 405                         index++;
 406                         Future.resolve(arguments[i]).appendWrappers(acceptCallback,rejectCallback);
 407                 }
 408
 409         return future;
 410 };
 411
 412
 413
 414 /*****************************************************************************/
 415
 416 cloudeebus.ProxyObject = function(session, busConnection, busName, objectPath) {
 417         this.wampSession = session;
 418         this.busConnection = busConnection;
 419         this.busName = busName;
 420         this.objectPath = objectPath;
 421         this.interfaceProxies = {};
 422         return this;
 423 };
 424
 425
 426 cloudeebus.ProxyObject.prototype.getInterface = function(ifName) {
 427         return this.interfaceProxies[ifName];
 428 };
 429
 430
 431 cloudeebus.ProxyObject.prototype._introspect = function(successCB, errorCB) {
 432
 433         var self = this;
 434
 435         function getAllPropertiesSuccessCB(props) {
 436                 var ifProxy = self.interfaceProxies[self.propInterfaces[self.propInterfaces.length-1]];
 437                 for (var prop in props)
 438                         ifProxy[prop] = self[prop] = props[prop];
 439                 getAllPropertiesNextInterfaceCB();
 440         }
 441
 442         function getAllPropertiesNextInterfaceCB() {
 443                 self.propInterfaces.pop();
 444                 if (self.propInterfaces.length > 0)
 445                         self.callMethod("org.freedesktop.DBus.Properties",
 446                                 "GetAll",
 447                                 [self.propInterfaces[self.propInterfaces.length-1]]).then(getAllPropertiesSuccessCB,
 448                                 errorCB ? errorCB : getAllPropertiesNextInterfaceCB);
 449                 else {
 450                         self.propInterfaces = null;
 451                         if (successCB)
 452                                 successCB(self);
 453                 }
 454         }
 455
 456         function introspectSuccessCB(str) {
 457                 var parser = new DOMParser();
 458                 var xmlDoc = parser.parseFromString(str, "text/xml");
 459                 var interfaces = xmlDoc.getElementsByTagName("interface");
 460                 self.propInterfaces = [];
 461                 var supportDBusProperties = false;
 462                 for (var i=0; i < interfaces.length; i++) {
 463                         var ifName = interfaces[i].attributes.getNamedItem("name").value;
 464                         self.interfaceProxies[ifName] = new cloudeebus.ProxyObject(self.wampSession, self.busConnection, self.busName, self.objectPath);
 465                         if (ifName == "org.freedesktop.DBus.Properties")
 466                                 supportDBusProperties = true;
 467                         var hasProperties = false;
 468                         var ifChild = interfaces[i].firstChild;
 469                         while (ifChild) {
 470                                 if (ifChild.nodeName == "method") {
 471                                         var nArgs = 0;
 472                                         var signature = "";
 473                                         var metChild = ifChild.firstChild;
 474                                         while (metChild) {
 475                                                 if (metChild.nodeName == "arg" &&
 476                                                         metChild.attributes.getNamedItem("direction").value == "in") {
 477                                                                 signature += metChild.attributes.getNamedItem("type").value;
 478                                                                 nArgs++;
 479                                                 }
 480                                                 metChild = metChild.nextSibling;
 481                                         }
 482                                         var metName = ifChild.attributes.getNamedItem("name").value;
 483                                         if (!self[metName])
 484                                                 self._addMethod(ifName, metName, nArgs, signature);
 485                                         self.interfaceProxies[ifName]._addMethod(ifName, metName, nArgs, signature);
 486                                 }
 487                                 else if (ifChild.nodeName == "property") {
 488                                         if (!hasProperties)
 489                                                 self.propInterfaces.push(ifName);
 490                                         hasProperties = true;
 491                                 }
 492                                 ifChild = ifChild.nextSibling;
 493                         }
 494                 }
 495                 if (supportDBusProperties && self.propInterfaces.length > 0) {
 496                         self.callMethod("org.freedesktop.DBus.Properties",
 497                                 "GetAll",
 498                                 [self.propInterfaces[self.propInterfaces.length-1]]).then(getAllPropertiesSuccessCB,
 499                                 errorCB ? errorCB : getAllPropertiesNextInterfaceCB);
 500                 }
 501                 else {
 502                         self.propInterfaces = null;
 503                         if (successCB)
 504                                 successCB(self);
 505                 }
 506         }
 507
 508         // call Introspect on self
 509         self.callMethod("org.freedesktop.DBus.Introspectable", "Introspect", []).then(introspectSuccessCB, errorCB);
 510 };
 511
 512
 513 cloudeebus.ProxyObject.prototype._addMethod = function(ifName, method, nArgs, signature) {
 514
 515         var self = this;
 516
 517         self[method] = function() {
 518                 var args = [];
 519                 for (var i=0; i < nArgs; i++ )
 520                         args.push(arguments[i]);
 521                 return self.callMethod(ifName, method, args, signature);
 522         };
 523 };
 524
 525
 526 cloudeebus.ProxyObject.prototype.callMethod = function(ifName, method, args, signature) {
 527
 528         var self = this;
 529
 530         var future = new cloudeebus.Future(function (resolver) {
 531                 function callMethodSuccessCB(str) {
 532                         try { // calling dbus hook object function for un-translated types
 533                                 var result = eval(str);
 534                                 resolver.accept(result[0], true);
 535                         }
 536                         catch (e) {
 537                                 cloudeebus.log("Method callback exception: " + e);
 538                                 resolver.reject(e, true);
 539                         }
 540                 }
 541
 542                 function callMethodErrorCB(error) {
 543                         cloudeebus.log("Error calling method: " + method + " on object: " + self.objectPath + " : " + error.desc);
 544                         resolver.reject(error.desc, true);
 545                 }
 546
 547                 var arglist = [
 548                         self.busConnection.name,
 549                         self.busName,
 550                         self.objectPath,
 551                         ifName,
 552                         method,
 553                         JSON.stringify(args)
 554                 ];
 555
 556                 // call dbusSend with bus type, destination, object, message and arguments
 557                 self.wampSession.call("dbusSend", arglist).then(callMethodSuccessCB, callMethodErrorCB);
 558         });
 559
 560         return future;
 561 };
 562
 563
 564 cloudeebus.ProxyObject.prototype.connectToSignal = function(ifName, signal, successCB, errorCB) {
 565
 566         var self = this;
 567
 568         function signalHandler(id, data) {
 569                 if (successCB) {
 570                         try { // calling dbus hook object function for un-translated types
 571                                 successCB.apply(self, eval(data));
 572                         }
 573                         catch (e) {
 574                                 cloudeebus.log("Signal handler exception: " + e);
 575                                 if (errorCB)
 576                                         errorCB(e);
 577                         }
 578                 }
 579         }
 580
 581         function connectToSignalSuccessCB(str) {
 582                 try {
 583                         self.wampSession.subscribe(str, signalHandler);
 584                 }
 585                 catch (e) {
 586                         cloudeebus.log("Subscribe error: " + e);
 587                 }
 588         }
 589
 590         function connectToSignalErrorCB(error) {
 591                 cloudeebus.log("Error connecting to signal: " + signal + " on object: " + self.objectPath + " : " + error.desc);
 592                 if (errorCB)
 593                         errorCB(error.desc);
 594         }
 595
 596         var arglist = [
 597                 self.busConnection.name,
 598                 self.busName,
 599                 self.objectPath,
 600                 ifName,
 601                 signal
 602         ];
 603
 604         // call dbusSend with bus type, destination, object, message and arguments
 605         self.wampSession.call("dbusRegister", arglist).then(connectToSignalSuccessCB, connectToSignalErrorCB);
 606 };
 607
 608
 609 cloudeebus.ProxyObject.prototype.disconnectSignal = function(ifName, signal) {
 610         try {
 611                 this.wampSession.unsubscribe(this.busConnection.name + "#" + this.busName + "#" + this.objectPath + "#" + ifName + "#" + signal);
 612         }
 613         catch (e) {
 614                 cloudeebus.log("Unsubscribe error: " + e);
 615         }
 616 };