X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cloudeebus%2Fcloudeebus.js;h=25a9532899e362154ed59cd09f3740230b8f2152;hb=cc2fb13ff58f2fe855764c145a06dbfe689935d9;hp=70615d0557b0c1a3c231455251869a90fd01feb2;hpb=ce98621bfe3dd5bc836b45628687245ff762352a;p=contrib%2Fcloudeebus.git diff --git a/cloudeebus/cloudeebus.js b/cloudeebus/cloudeebus.js index 70615d0..25a9532 100644 --- a/cloudeebus/cloudeebus.js +++ b/cloudeebus/cloudeebus.js @@ -29,7 +29,7 @@ var dbus = { // hook object for dbus types not translated by python-json /*****************************************************************************/ var cloudeebus = window.cloudeebus = { - version: "0.5.0", + version: "0.5.1", minVersion: "0.3.2" }; @@ -44,6 +44,19 @@ cloudeebus.reset = function() { cloudeebus.log = function(msg) { }; +cloudeebus.getError = function(error) { + if (error.desc && error.uri) + return error.desc + " : " + error.uri; + if (error.desc) + return error.desc; + if (error.uri) + return error.uri; + if (error.name && error.message) + return error.name + " : " + error.message; + if (error.message) + return error.message; + return error; +}; cloudeebus.versionCheck = function(version) { var ver = version.split("."); @@ -76,9 +89,10 @@ cloudeebus.connect = function(uri, manifest, successCB, errorCB) { } function onWAMPSessionAuthErrorCB(error) { - cloudeebus.log("Authentication error: " + error.desc); + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Authentication error: " + errorStr); if (errorCB) - errorCB(error.desc); + errorCB(errorStr); } function onWAMPSessionAuthenticatedCB(permissions) { @@ -148,6 +162,332 @@ cloudeebus.BusConnection.prototype.getObject = function(busName, objectPath, int }; +cloudeebus.BusConnection.prototype.addService = function(serviceName) { + var self = this; + + var promise = new cloudeebus.Promise(function (resolver) { + cloudeebusService = new cloudeebus.Service(self.wampSession, self, serviceName); + + function ServiceAddedSuccessCB(serviceName) { + try { // calling dbus hook object function for un-translated types + cloudeebusService.isCreated = true; + var result = [ cloudeebusService ]; + resolver.fulfill(result[0], true); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Method callback exception: " + errorStr); + resolver.reject(errorStr, true); + } + } + + function ServiceAddedErrorCB(error) { + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Error adding service method: " + self.name + ", error: " + errorStr); + self.promise.resolver.reject(errorStr, true); + } + + var arglist = [ + self.name, + serviceName + ]; + + // call dbusSend with bus type, destination, object, message and arguments + self.wampSession.call("serviceAdd", arglist).then(ServiceAddedSuccessCB, ServiceAddedErrorCB); + }); + + return promise; +}; + + +/*****************************************************************************/ +//Generic definition for an agent. An agent need : +//srvDbusName : the DBus parent service +//objPath : a DBus path to access it +//jsHdl : a Javascript handler to process methods, +//xml : the xml which describe interface/methods/signals... +cloudeebus.Agent = function(srvDbusName, objPath, jsHdl, xml) { + this.srvName = srvDbusName; + this.registered = false; + this.xml = xml; + this.objectPath = objPath; + this.jsHdl = jsHdl; + return this; +}; + + +cloudeebus.Service = function(session, busConnection, name) { + this.wampSession = session; + this.busConnection = busConnection; + this.name = name; + this.agents = []; + this.isCreated = false; + return this; +}; + +cloudeebus.Service.prototype.remove = function() { + var self = this; + + var promise = new cloudeebus.Promise(function (resolver) { + function ServiceRemovedSuccessCB(serviceName) { + try { // calling dbus hook object function for un-translated types + var result = [ serviceName ]; + resolver.fulfill(result[0], true); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Method callback exception: " + errorStr); + resolver.reject(errorStr, true); + } + } + + function ServiceRemovedErrorCB(error) { + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Error removing service : " + self.name + ", error: " + errorStr); + self.promise.resolver.reject(errorStr, true); + } + + for (var idx in self.agents) { + if (self.agents[idx]) { + self.delAgent(self.agents[idx]); + } + } + + var arglist = [ + self.name + ]; + + // call dbusSend with bus type, destination, object, message and arguments + self.wampSession.call("serviceRelease", arglist).then(ServiceRemovedSuccessCB, ServiceRemovedErrorCB); + }); + + return promise; +}; + +cloudeebus.Service.prototype._searchMethod = function(ifName, method, objectJS) { + + var funcToCall = null; + + // Check if 'objectJS' has a member 'interfaceProxies' with an interface named 'ifName' + // and a method named 'method' + if (objectJS.interfaceProxies && objectJS.interfaceProxies[ifName] && + objectJS.interfaceProxies[ifName][method]) { + funcToCall = objectJS.interfaceProxies[ifName][method]; + } else { + // retrieve the method directly from 'root' of objectJs + funcToCall = objectJS[method]; + } + + return funcToCall; +}; + +cloudeebus.Service.prototype._addMethod = function(ifName, method, agent) { + + var service = this; + var methodId = this.name + "#" + agent.objectPath + "#" + ifName + "#" + method; + var funcToCall = this._searchMethod(ifName, method, agent.jsHdl); + + if (funcToCall == null) + cloudeebus.log("Method " + method + " doesn't exist in Javascript object"); + else { + agent.jsHdl.wrapperFunc[method] = function() { + var result; + var methodId = arguments[0]; + var callDict = {}; + // affectation of callDict in eval, otherwise dictionary(='{}') interpreted as block of code by eval + eval("callDict = " + arguments[1]); + try { + result = funcToCall.apply(agent.jsHdl, callDict.args); + service._returnMethod(methodId, callDict.callIndex, true, result); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Method " + ifName + "." + method + " call on " + agent.objectPath + " exception: " + errorStr); + service._returnMethod(methodId, callDict.callIndex, false, errorStr); + } + }; + agent.jsHdl.methodId[agent.objectPath].push(methodId); + cloudeebus.log("subscribe " + methodId); + this.wampSession.subscribe(methodId, agent.jsHdl.wrapperFunc[method]); + } +}; + +cloudeebus.Service.prototype._addSignal = function(ifName, signal, agent) { + var service = this; + var methodExist = false; + + if (agent.jsHdl.interfaceProxies && agent.jsHdl.interfaceProxies[ifName]) + if (agent.jsHdl.interfaceProxies[ifName][signal]) { + methodExist = true; + } else { + agent.jsHdl.interfaceProxies[ifName][signal] = function() { + service._emitSignal(agent.objectPath, signal, arguments[0]); + }; + return; + } + + if ((agent.jsHdl[signal] == undefined || agent.jsHdl[signal] == null) && !methodExist) + agent.jsHdl[signal] = function() { + service._emitSignal(agent.objectPath, signal, arguments[0]); + }; + else + cloudeebus.log("Can not create new method to emit signal '" + signal + "' in object JS this method already exist!"); +}; + +cloudeebus.Service.prototype._createWrapper = function(agent) { + var self = this; + var parser = new DOMParser(); + var xmlDoc = parser.parseFromString(agent.xml, "text/xml"); + var ifXml = xmlDoc.getElementsByTagName("interface"); + agent.jsHdl.wrapperFunc = []; + agent.jsHdl.methodId = []; + agent.jsHdl.methodId[agent.objectPath] = []; + for (var i=0; i < ifXml.length; i++) { + var ifName = ifXml[i].attributes.getNamedItem("name").value; + var ifChild = ifXml[i].firstChild; + while (ifChild) { + if (ifChild.nodeName == "method") { + var metName = ifChild.attributes.getNamedItem("name").value; + self._addMethod(ifName, metName, agent); + } + if (ifChild.nodeName == "signal") { + var metName = ifChild.attributes.getNamedItem("name").value; + self._addSignal(ifName, metName, agent); + } + ifChild = ifChild.nextSibling; + } + } +}; + +cloudeebus.Service.prototype.addAgent = function(agent) { + var self = this; + + var promise = new cloudeebus.Promise(function (resolver) { + function ServiceAddAgentSuccessCB(objPath) { + try { // calling dbus hook object function for un-translated types + self.agents.push(agent); + agent.registered = true; + var result = [ objPath ]; + resolver.fulfill(result[0], true); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Method callback exception: " + errorStr); + resolver.reject(errorStr, true); + } + } + + function ServiceAddAgenterrorCB(error) { + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Error adding agent : " + agent.objectPath + ", error: " + errorStr); + self.promise.resolver.reject(errorStr, true); + } + + try { + self._createWrapper(agent); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Exception creating agent wrapper " + agent.objectPath + " : " + errorStr); + resolver.reject(errorStr, true); + return; + } + + var arglist = [ + agent.objectPath, + agent.xml + ]; + + // call dbusSend with bus type, destination, object, message and arguments + self.wampSession.call("serviceAddAgent", arglist).then(ServiceAddAgentSuccessCB, ServiceAddAgenterrorCB); + }); + + return promise; +}; + +cloudeebus.Service.prototype._deleteWrapper = function(agent) { + var objJs = agent.jsHdl; + if (objJs.methodId[agent.objectPath]) { + for (var idx in objJs.methodId[agent.objectPath]) { + try { + cloudeebus.log("unsubscribe " + objJs.methodId[agent.objectPath][idx]); + this.wampSession.unsubscribe(objJs.methodId[agent.objectPath][idx]); + objJs.methodId[agent.objectPath][idx] = null; + } + catch (e) { + cloudeebus.log("Unsubscribe error: " + cloudeebus.getError(e)); + } + } + delete objJs.methodId[agent.objectPath]; + } +}; + +cloudeebus.Service.prototype.delAgent = function(rmAgent, successCB, errorCB) { + var self = this; + + var promise = new cloudeebus.Promise(function (resolver) { + function ServiceDelAgentSuccessCB(agent) { + try { // calling dbus hook object function for un-translated types + self.agents.push(agent); + agent.registered = true; + var result = [ agent ]; + resolver.fulfill(result[0], true); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Method callback exception: " + errorStr); + resolver.reject(errorStr, true); + } + } + + function ServiceDelAgentErrorCB(error) { + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Error removing agent : " + rmAgent.objectPath + ", error: " + errorStr); + self.promise.resolver.reject(errorStr, true); + } + + try { + self._deleteWrapper(rmAgent); + } + catch (e) { + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Exception removing wrapper of agent " + rmAgent.objectPath + " : " + errorStr); + errorCB(errorStr); + } + + var arglist = [ + rmAgent.objectPath + ]; + + // call dbusSend with bus type, destination, object, message and arguments + self.wampSession.call("serviceDelAgent", arglist).then(ServiceDelAgentSuccessCB, ServiceDelAgentErrorCB); + }); + + return promise; +}; + +cloudeebus.Service.prototype._returnMethod = function(methodId, callIndex, success, result, successCB, errorCB) { + var arglist = [ + methodId, + callIndex, + success, + result + ]; + + this.wampSession.call("returnMethod", arglist).then(successCB, errorCB); +}; + +cloudeebus.Service.prototype._emitSignal = function(objectPath, signalName, result, successCB, errorCB) { + var arglist = [ + objectPath, + signalName, + result + ]; + + this.wampSession.call("emitSignal", arglist).then(successCB, errorCB); +}; + + /*****************************************************************************/ @@ -170,131 +510,131 @@ function _processWrappersAsync(wrappers, value) { /*****************************************************************************/ -cloudeebus.FutureResolver = function(future) { - this.future = future; +cloudeebus.PromiseResolver = function(promise) { + this.promise = promise; this.resolved = null; return this; }; -cloudeebus.FutureResolver.prototype.resolve = function(value, sync) { +cloudeebus.PromiseResolver.prototype.resolve = function(value, sync) { if (this.resolved) return; var then = (value && value.then && value.then.apply) ? value.then : null; if (then) { var self = this; - var acceptCallback = function(arg) { + var fulfillCallback = function(arg) { self.resolve(arg, true); }; var rejectCallback = function(arg) { self.reject(arg, true); }; try { - then.apply(value, [acceptCallback, rejectCallback]); + then.apply(value, [fulfillCallback, rejectCallback]); } catch (e) { - this.reject(e, true); + this.reject(cloudeebus.getError(e), true); } } - this.accept(value, sync); + this.fulfill(value, sync); }; -cloudeebus.FutureResolver.prototype.accept = function(value, sync) { +cloudeebus.PromiseResolver.prototype.fulfill = function(value, sync) { if (this.resolved) return; - var future = this.future; - future.state = "accepted"; - future.result = value; + var promise = this.promise; + promise.state = "fulfilled"; + promise.result = value; this.resolved = true; if (sync) - _processWrappers(future._acceptWrappers, value); + _processWrappers(promise._fulfillWrappers, value); else - _processWrappersAsync(future._acceptWrappers, value); + _processWrappersAsync(promise._fulfillWrappers, value); }; -cloudeebus.FutureResolver.prototype.reject = function(value, sync) { +cloudeebus.PromiseResolver.prototype.reject = function(value, sync) { if (this.resolved) return; - var future = this.future; - future.state = "rejected"; - future.result = value; + var promise = this.promise; + promise.state = "rejected"; + promise.result = value; this.resolved = true; if (sync) - _processWrappers(future._rejectWrappers, value); + _processWrappers(promise._rejectWrappers, value); else - _processWrappersAsync(future._rejectWrappers, value); + _processWrappersAsync(promise._rejectWrappers, value); }; /*****************************************************************************/ -cloudeebus.Future = function(init) { +cloudeebus.Promise = function(init) { this.state = "pending"; this.result = null; - this._acceptWrappers = []; + this._fulfillWrappers = []; this._rejectWrappers = []; - this.resolver = new cloudeebus.FutureResolver(this); + this.resolver = new cloudeebus.PromiseResolver(this); if (init) { try { init.apply(this, [this.resolver]); } catch (e) { - this.resolver.reject(e, true); + this.resolver.reject(cloudeebus.getError(e), true); } } return this; }; -cloudeebus.Future.prototype.appendWrappers = function(acceptWrapper, rejectWrapper) { - if (acceptWrapper) - this._acceptWrappers.push(acceptWrapper); +cloudeebus.Promise.prototype.appendWrappers = function(fulfillWrapper, rejectWrapper) { + if (fulfillWrapper) + this._fulfillWrappers.push(fulfillWrapper); if (rejectWrapper) this._rejectWrappers.push(rejectWrapper); - if (this.state == "accepted") - _processWrappersAsync(this._acceptWrappers, this.result); + if (this.state == "fulfilled") + _processWrappersAsync(this._fulfillWrappers, this.result); if (this.state == "rejected") _processWrappersAsync(this._rejectWrappers, this.result); }; -cloudeebus.Future.prototype.then = function(acceptCB, rejectCB) { - var future = new cloudeebus.Future(); - var resolver = future.resolver; - var acceptWrapper, rejectWrapper; +cloudeebus.Promise.prototype.then = function(fulfillCB, rejectCB) { + var promise = new cloudeebus.Promise(); + var resolver = promise.resolver; + var fulfillWrapper, rejectWrapper; - if (acceptCB) - acceptWrapper = function(arg) { + if (fulfillCB) + fulfillWrapper = function(arg) { try { - var value = acceptCB.apply(future, [arg]); + var value = fulfillCB.apply(promise, [arg]); resolver.resolve(value, true); } catch (e) { - resolver.reject(e, true); + resolver.reject(cloudeebus.getError(e), true); } }; else - acceptWrapper = function(arg) { - resolver.accept(arg, true); + fulfillWrapper = function(arg) { + resolver.fulfill(arg, true); }; if (rejectCB) rejectWrapper = function(arg) { try { - var value = rejectCB.apply(future, [arg]); + var value = rejectCB.apply(promise, [arg]); resolver.resolve(value, true); } catch (e) { - resolver.reject(e, true); + resolver.reject(cloudeebus.getError(e), true); } }; else @@ -302,46 +642,46 @@ cloudeebus.Future.prototype.then = function(acceptCB, rejectCB) { resolver.reject(arg, true); }; - this.appendWrappers(acceptWrapper,rejectWrapper); - return future; + this.appendWrappers(fulfillWrapper,rejectWrapper); + return promise; }; -cloudeebus.Future.prototype["catch"] = function(rejectCB) { +cloudeebus.Promise.prototype["catch"] = function(rejectCB) { return this.then(undefined,rejectCB); }; -cloudeebus.Future.prototype.done = function(acceptCB, rejectCB) { - this.appendWrappers(acceptCB,rejectCB); +cloudeebus.Promise.prototype.done = function(fulfillCB, rejectCB) { + this.appendWrappers(fulfillCB,rejectCB); }; -cloudeebus.Future.resolve = function(value) { - var future = new cloudeebus.Future(); - future.resolver.resolve(value); - return future; +cloudeebus.Promise.resolve = function(value) { + var promise = new cloudeebus.Promise(); + promise.resolver.resolve(value); + return promise; }; -cloudeebus.Future.accept = function(value) { - var future = new cloudeebus.Future(); - future.resolver.accept(value); - return future; +cloudeebus.Promise.fulfill = function(value) { + var promise = new cloudeebus.Promise(); + promise.resolver.fulfill(value); + return promise; }; -cloudeebus.Future.reject = function(value) { - var future = new cloudeebus.Future(); - future.resolver.reject(value); - return future; +cloudeebus.Promise.reject = function(value) { + var promise = new cloudeebus.Promise(); + promise.resolver.reject(value); + return promise; }; -cloudeebus.Future.any = function() { - var future = new cloudeebus.Future(); - var resolver = future.resolver; - var acceptCallback = function(arg) { +cloudeebus.Promise.any = function() { + var promise = new cloudeebus.Promise(); + var resolver = promise.resolver; + var fulfillCallback = function(arg) { resolver.resolve(arg, true); }; var rejectCallback = function(arg) { @@ -351,14 +691,14 @@ cloudeebus.Future.any = function() { resolver.resolve(undefined, true); else for (i in arguments) - Future.resolve(arguments[i]).appendWrappers(acceptCallback,rejectCallback); - return future; + Promise.resolve(arguments[i]).appendWrappers(fulfillCallback,rejectCallback); + return promise; }; -cloudeebus.Future.every = function() { - var future = new cloudeebus.Future(); - var resolver = future.resolver; +cloudeebus.Promise.every = function() { + var promise = new cloudeebus.Promise(); + var resolver = promise.resolver; var index = 0; var countdown = arguments.length; var args = new Array(countdown); @@ -369,27 +709,27 @@ cloudeebus.Future.every = function() { resolver.resolve(undefined, true); else for (i in arguments) { - var acceptCallback = function(arg) { + var fulfillCallback = function(arg) { args[index] = arg; countdown--; if (countdown == 0) resolver.resolve(args, true); }; index++; - Future.resolve(arguments[i]).appendWrappers(acceptCallback,rejectCallback); + Promise.resolve(arguments[i]).appendWrappers(fulfillCallback,rejectCallback); } - return future; + return promise; }; -cloudeebus.Future.some = function() { - var future = new cloudeebus.Future(); - var resolver = future.resolver; +cloudeebus.Promise.some = function() { + var promise = new cloudeebus.Promise(); + var resolver = promise.resolver; var index = 0; var countdown = arguments.length; var args = new Array(countdown); - var acceptCallback = function(arg) { + var fulfillCallback = function(arg) { resolver.resolve(arg, true); }; if (arguments.length == 0) @@ -403,10 +743,10 @@ cloudeebus.Future.some = function() { resolver.reject(args, true); }; index++; - Future.resolve(arguments[i]).appendWrappers(acceptCallback,rejectCallback); + Promise.resolve(arguments[i]).appendWrappers(fulfillCallback,rejectCallback); } - return future; + return promise; }; @@ -527,21 +867,23 @@ cloudeebus.ProxyObject.prototype.callMethod = function(ifName, method, args, sig var self = this; - var future = new cloudeebus.Future(function (resolver) { + var promise = new cloudeebus.Promise(function (resolver) { function callMethodSuccessCB(str) { try { // calling dbus hook object function for un-translated types var result = eval(str); - resolver.accept(result[0], true); + resolver.fulfill(result[0], true); } catch (e) { - cloudeebus.log("Method callback exception: " + e); - resolver.reject(e, true); + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Method callback exception: " + errorStr); + resolver.reject(errorStr, true); } } function callMethodErrorCB(error) { - cloudeebus.log("Error calling method: " + method + " on object: " + self.objectPath + " : " + error.desc); - resolver.reject(error.desc, true); + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Error calling method: " + method + " on object: " + self.objectPath + " : " + errorStr); + resolver.reject(errorStr, true); } var arglist = [ @@ -557,7 +899,7 @@ cloudeebus.ProxyObject.prototype.callMethod = function(ifName, method, args, sig self.wampSession.call("dbusSend", arglist).then(callMethodSuccessCB, callMethodErrorCB); }); - return future; + return promise; }; @@ -571,9 +913,10 @@ cloudeebus.ProxyObject.prototype.connectToSignal = function(ifName, signal, hand handlerCB.apply(self, eval(data)); } catch (e) { - cloudeebus.log("Signal handler exception: " + e); + var errorStr = cloudeebus.getError(e); + cloudeebus.log("Signal handler exception: " + errorStr); if (errorCB) - errorCB(e); + errorCB(errorStr); } } } @@ -583,14 +926,15 @@ cloudeebus.ProxyObject.prototype.connectToSignal = function(ifName, signal, hand self.wampSession.subscribe(str, signalHandler); } catch (e) { - cloudeebus.log("Subscribe error: " + e); + cloudeebus.log("Subscribe error: " + cloudeebus.getError(e)); } } function connectToSignalErrorCB(error) { - cloudeebus.log("Error connecting to signal: " + signal + " on object: " + self.objectPath + " : " + error.desc); + var errorStr = cloudeebus.getError(error); + cloudeebus.log("Error connecting to signal: " + signal + " on object: " + self.objectPath + " : " + errorStr); if (errorCB) - errorCB(error.desc); + errorCB(cloudeebus.getError(errorStr)); } var arglist = [ @@ -611,6 +955,6 @@ cloudeebus.ProxyObject.prototype.disconnectSignal = function(ifName, signal) { this.wampSession.unsubscribe(this.busConnection.name + "#" + this.busName + "#" + this.objectPath + "#" + ifName + "#" + signal); } catch (e) { - cloudeebus.log("Unsubscribe error: " + e); + cloudeebus.log("Unsubscribe error: " + cloudeebus.getError(e)); } };