vox-core/submodules/vox-core-ipc/src/VW/IPC/ShareMethods.js

Runtime de aplicaciones multiplataforma

/* 
* Por medio de VW.IPC
* esta clase permita compartir métodos para ejecutar y devolver respuesta 
*/

var events= require("events").EventEmitter;
var ShareMethods= module.exports=function(/* Comunication */ipc){
	this.ipc= ipc;
	events.call(this);
	this.shared= {};
	this.callbacks= {};

	this.start();
}
ShareMethods.id= (Math.random()*15)|0;
ShareMethods.prototype= Object.create(events.prototype);
ShareMethods.prototype.constructor= ShareMethods;


ShareMethods.prototype._sendResponse= function(dataOriginal, resultado, isError){

	if(isError){
		var ex= {}
		ex.message= resultado.message
		if(resultado.stack)
			ex.stack= resultado.stack
		for(var id in resultado){
			ex[id]= resultado[id]
		}
		resultado= ex
	}

	var obj={
		"id": dataOriginal.id,
		"response":true,
		"isfaulted":isError
	}
	if(isError){
		obj.error= resultado;
	}
	else{
		obj.result= resultado;
	}
	this.$tk= this.ipc.writeAsync(obj, this.$tk);
}



ShareMethods.prototype.addMethod= function(/*string*/method, /*string*/name ){
	if(!name){
		name=method.name;
	}

	if(!name){
		throw new core.System.ArgumentNullException("Debe especificar el argumento name");
	}

	this.shared[name]=method;
	return this;
}



ShareMethods.prototype.addObject= function(/*string*/obj, /*string*/name){
	if(!name){
		name=obj.name;
	}

	if(!name){
		throw new core.System.ArgumentNullException("Debe especificar el argumento name");
	}

	this.shared[name]=obj
	return this;
}


ShareMethods.prototype.callAsync= function(/* string*/method, /*Array*/args){




	var task= core.VW.Task.get(arguments);
	var id= ++ShareMethods.id;
	var obj={
		"id": id,
		"request":true,
		"method": method,
		"arguments":args||[]
	}

	var $tk= this.ipc.writeAsync(obj, true);
	$tk.oncomplete= function(){
		if($tk.exception){
			task.exception= $tk.exception
			task.finish()
		}
	}

	this.callbacks[id]= function(err,data){
		if(err){
			task.exception= err;
		}
		else{
			task.result= data;
		}
		task.finish();
	}

	return task;
}


ShareMethods.prototype.stop=function(){
	if(this.task){
		this.task.cancel();
	}
	return this;
}


ShareMethods.prototype.start= function(){
	
	var task= this.task= this.ipc.readAsync();
	var self= this;

	var complete= task.oncomplete= function(){
		var data= task.result;
		//process.stderr.write("Data: " + JSON.stringify(data))
		if(self.isCancelled){
			return; 
		}

		//task.oncomplete= complete;
		if(data.request){
			var er,r;

			try{
				try{
					var p= data.method.split(".");
					var s= self.shared;
					var p1;
					for(var i=0;i<p.length;i++){
						p1= s;
						s= s[p[i]];
					}
				}
				catch(er){
					throw new core.VW.IPC.SharedMethodNotFoundException(er.message, er)
				}
				if(!s){
					return self._sendResponse(data, new core.VW.IPC.SharedMethodNotFoundException(data.method), true);	
				}
				r=s.apply(p1, data.arguments);
			}
			catch(e){
				er=e;
			}
			if(r && typeof r.then =="function"){
				// Método asíncrono ...
				r.then(function(result){
					self._sendResponse(data, result);						
				}, function(er){
					self._sendResponse(data, er, true);
				})
			}
			else{
				self._sendResponse(data, er?er:r, !!er);	
			}

		}
		else if(data.response){

			var id= data.id;
			var callback=self.callbacks[id];
			if(callback){
				self.callbacks[id]=undefined;
			}
			if(callback)
				callback(data.error, data.result);

		}
		//task= self.task= self.ipc.readAsync();
		setImmediate(function(){
			self.start()
		})
	}

	task.alwaysonerror=function(err){
		this.lastException= err;
		this.emit("error", err);
	}
	return this;
}