aview-app 1.0.2

package/aardio/lib/process/rpc/jsonClient.aardio

@@ -0,0 +1,285 @@
+//jsonClient 客户端
+import web.json;  
+import process.popen;
+import string.encoding;
+import process.job.limitKill;
+
+namespace process.rpc; 
+ 
+class jsonClient {
+	ctor( process,... ) { 
+		if( type.isString(process)){
+			var err;
+			process,err = ..process.popen(process,...);
+			if(!process) return null,err;
+			
+			process.codepage = 65001;
+			..process.job.limitKill.assignProcess(process);
+		}
+		
+		this.rpc = { 
+			process = process;
+			stillActive = lambda() process.stillActive();
+			
+			charset = "UTF-8"; 
+			version = "2.0";
+			endCallback = {};
+			varargs = true;
+			
+			postData = function( reqData ){
+				owner.lastResponseData = null;
+				owner.lastStatusCode = null;
+				
+				var jsonData = ..web.json.stringify(reqData);
+				if( owner.afterJsonStringify ) {
+					jsonData = owner.afterJsonStringify(jsonData);
+					if(!jsonData) return;
+				};
+				
+				if(!process.write(jsonData,'\n')){
+					return null,"目标进程已关闭标准输入";
+				}
+				
+				var isTransaction = ( #reqData && owner.transaction);
+				
+				if( reqData.id === null){
+					if(!isTransaction)return;
+					else {
+						var rep;
+						for(i,v in reqData){
+							if(v.id){
+								rep = true;
+								break;
+							}
+						} 
+						
+						if(!rep) return;
+					}
+				}
+				
+				var repData;
+				var stdout,stderr = "";   
+				
+				if(owner.beforeJsonParse){
+					var pattern = isTransaction?"%[]\r*\n":"%{}\r*\n";
+					repData,stderr = process.expect(pattern);
+					
+					if(repData){
+						owner.lastResponseData = repData;
+						repData = owner.beforeJsonParse(repData);
+						if(!#repData) return;
+					 
+						repData,err = ..web.json.tryParse(repData);
+						if(!repData) return null,err;
+					} 
+				}
+				else{
+					var pattern = isTransaction?"\[.+\]\s*":"\{.+\}\s*";
+					
+					for( all,out,err in process.each() ){
+	    				if( #out ){
+	    					stdout = stdout ++ out;
+	    					json = ..string.match(stdout,pattern);
+	    					
+	    					if(json){
+	    						repData = ..web.json.tryParse(json);
+	    						
+	    						if( (repData[["id"]] == reqData.id)
+	    							|| ( isTransaction && type(repData)=="table" && repData[1][["id"]]) 
+	    							|| repData[["error"]] ){
+	    							
+	    						    owner.lastResponseData = json; 
+	    							break;
+	    						}
+	    					} 
+	    				}
+	    				elseif(#err){
+	    			    	stderr = err; 
+	    			    	if( this.rpc.onError ) 	this.rpc.onError( stderr ); 
+	    			    	if(!process.stillActive()){
+	    			    		break;
+	    			    	}
+	    				}
+					}
+				}
+		
+				if( repData ) {  
+					if(isTransaction){
+						if(#repData){
+							for(i=1;#repData;1){
+								if(repData[i].id){
+									var cb = owner.endCallback[repData[i].id];
+    								if(cb){
+    									owner.endCallback[repData[i].id] = null;
+    									if( cb.end ){
+    										cb.end( repData[i].result,repData[i].error )
+    									}
+    								};
+    							}
+							}
+						}
+						return true;
+					} 
+					
+					if(repData[["error"]]){
+						return repData,..web.json.stringify(repData[["error"]],true);
+					}
+					return repData;
+				}
+				else {
+					owner.lastResponseData = stderr; 
+					return null,stderr : "未知错误";
+				}
+			}; 
+			notify = function(method,...){  
+				var reqData = {
+					jsonrpc = owner.version;
+					method = method;
+				}
+				
+				if( owner.varargs ){
+					reqData.params = {@{_type="array"};...};
+				}
+				else {
+					reqData.params = ...;
+				}
+				
+				if( owner[["beforeRequest"]] ){
+					reqData = owner.beforeRequest(reqData);
+				}; 
+				
+				if( owner[["transaction"]]  ){ 
+					..table.push(owner.transaction,reqData);
+					return;
+				}; 
+				
+				var _,err = owner.postData( reqData );
+				if(!err) return true;
+			};
+			xcall = function(method,...){   
+				
+				var reqData = {
+					jsonrpc = owner.version;
+					method = method;
+					id = method;
+				}
+				
+				if( owner.varargs ){
+					reqData.params = {@{_type="array"};...};
+				}
+				else {
+					reqData.params = ...;
+				}
+				
+				if( owner[["beforeRequest"]] ){
+					reqData = owner.beforeRequest(reqData);
+				}; 
+				
+				if( owner[["transaction"]]  ){
+					var cb = {};
+					cb.method = method; 
+					reqData.id = ..table.push(owner.endCallback,cb);
+					
+					..table.push(owner.transaction,reqData);
+					return cb;
+				} 
+				return owner.postData( reqData );
+			}; 
+			beginTrans = function(){
+				owner.transaction = {};
+				owner.endCallback = {};
+			};
+			commitTrans = function(){
+				var ok,err = owner.postData(owner.transaction);
+				owner.transaction = null;
+				owner.endCallback = null;
+				return ok,err;
+			};
+			rollbackTrans = function(){
+				owner.transaction = null;
+				owner.endCallback = null;
+			}; 
+			lastResponse = function(){ 
+				var s = owner[["lastResponseData"]];
+				if( ..console && _STUDIO_INVOKED ) ..console.log(s) else ..io.print(s);
+				return s;
+			};
+			close = function(){
+				if(process){
+					process.close();
+					process = null;
+				} 
+			};
+		};
+	}
+	@_meta
+}
+
+namespace jsonClient {  
+ 
+	_meta = {
+  	
+    	_get = function(k){
+        	
+    		if( type(k) == type.string ){
+    			
+    			if( owner[["method"]] ){
+    				k = owner[["method"]] + "." + k;
+    			}
+    			
+    			owner[[k]] = {
+    				rpc = owner[["rpc"]];
+    				method = k;
+    				@_meta;
+    			}
+    			return owner[[k]];
+    		}
+    	} 
+    	_call = function( ... ){ 
+				return owner.rpc.xcall( owner.method, ...) ;
+		}
+	}
+	
+	charset2Codepage = ..string.encoding.getCodepage;
+}
+
+/**intellisense()
+process.rpc.jsonClient = 基于进程管道通过读写进程标准输入输出实现的 JSON-RPC 客户端。\n用法参考『范例 / 调用其他语言 / Go / RPC』，或 process.r 扩展库范例。\n\n规则说明：\n1、 所有 JSON-RPC 消息必须置于 { } 或 [ ] 内，aardio 输出 JSON 时以换行符结束。\n2、\naardio 读取进程输出时获取第一个能成功解析为响应对象的 JSON，\n└── 单次调用的响应对象应当是 { } 包含的对象且包含 id 字段。\n└── 批量调用的响应对象应当是 [ ] 包含的非空数组且数组元素存在 id 字段。\n响应对象 JSON 不要求以换行符结束，忽略进程的其他输出。\n客户端总是在发送请求后再读取回复（应答对象的 id 字段必须与请求对象的 id 字段相同）。\n\n关于 [ JSON-RPC 2.0](http://www.jsonrpc.org/specification)
+process.rpc.jsonClient( = 创建 JSON-RPC 2.0 客户端，兼容 JSON-RPC 1.0 。\n用法请参考『范例 / 调用其他语言 / Go / RPC』，\n或 process.r 扩展库范例
+process.rpc.jsonClient(.(进程管道) = 创建 JSON-RPC 客户端。\n参数 @1 必须指定 process.popen 对象
+process.rpc.jsonClient(.(执行文件,命令行参数,STARTUPINFO) = 启动目标进程，并返回 JSON-RPC 客户端。\n目标进程自动绑定作业对象 process.job.limitKill 。\n进程管道默认编码设为 UTF-8。\n\n命令行参数可以是一个数组、一个或多个字符串参数,\n\n数组或多个命令行参数调用 process.joinArguments 合并,\n不在双引号内、且包含空白或需要转义的参数转义处理后首尾添加双引号
+process.rpc.jsonClient() = !process_rpcJsonClient. 
+!process_rpcJsonClient.? = 远程对象名或远程方法名字。\n远程函数调用成功则第一个返回值为表对象，\n└── 该对象的 result 字段为返回值，error 为错误对象，两个字段不会同时存在。\n└── error 对象的 message 为错误信息，code 为错误代码，data 为错误附加数据。\n└── 如果存在 error 对象，则第 2 个返回值为 error 对象的 JSON 文本格式。\n调用失败第一个返回值为 null ，第二个返回值为错误信息\n\n如果调用 rpc.beginTrans 函数开始一个批量调用，\n则返回一个可以指定 end 成员函数的对象，服务器应答时自动回调此 end 函数\n!process_rpcJsonClient.
+!process_rpcJsonClient.rpc = RPC 本地客户端对象\n所以本地函数放在这个对象里面\n用户不得添加、删除、修改此对象的任何成员
+end intellisense**/ 
+
+/**intellisense(!process_rpcJsonClient.rpc)
+stillActive() = 目标进程是否仍然运行
+lastResponse() = 获取最后一次服务器返回的原始数据,\n如果控制台已打开或在开发环境中导入 console 库则在控制台输出数据\n下载文件时该值为空
+beginTrans() = 开始批量调用，注意服务器并不一定支持批量调用。\n批量调用时单次调用的返回值是一个表\n可对返回值指定end成员函数，\nend 函数会在 commitTrans 提交批量调用成功后被触发
+commitTrans() = 完成批量调用，注意服务器并不一定支持批量调用。
+rollbackTrans() = 撤消尚未提交的批量调用
+notify(.("函数名",参数) = 发送通知,服务器不返回值,\n如果 varargs 属性指定为 true 时将不定个数参数合为数组，\nvarargs为 false 时直接发送参数\n\n成功返回 true，失败返回 null,错误信息
+xcall(.("函数名",参数) = 调用远程函数。\n如果 varargs 属性指定为 true 时将不定个数参数合为数组，\nvarargs 为 false 时直接发送参数\n\n远程函数调用成功则第一个返回值为表对象，\n└── 该对象的 result 字段为返回值，error 为错误对象，两个字段不会同时存在。\n└── error 对象的 message 为错误信息，code 为错误代码，data 为错误附加数据。\n└── 如果存在 error 对象，则第 2 个返回值为 error 对象的 JSON 文本格式。\n调用失败第一个返回值为 null ，第二个返回值为错误信息\n\n如果调用 rpc.beginTrans 函数开始一个批量调用，\n则返回一个可以指定 end 成员函数的对象，服务器应答时自动回调此 end 函数
+charset = 获取或修改编码,此值必须为大写，默认为"UTF-8",\n因为 JSON 规定了 Unicode 编码方案,所以不建议也不应该修改这个值
+version = 值为 JSON-RPC 协议版本："2.0"\n不应该修改这个值
+varargs = 默认值为 true,\n值为 true 时将不定个数的参数放入数组发送给服务端\n值为 false 时直接将单个参数发送给服务端\n\nJSON-RPC 2.0 一个会制造混乱的地方：\n如果params是一个数组，并没有规定是展开为一个参数，还是作为一个数组参数。\n\n目前 aardio 的 RPC 服务端会负责展开数组作为多个参数，\n但客户端需要在这里手动设置
+kwargs = 是否支持 Python 命名参数（kwargs ）。\n仅适用于 process.python.jsonRpc，仅 varargs 属性为 true 时有效。\n\n调用时命名参数必须写在参数列表最前面，\n其后第一个出现的位置参数对应服务端的第一个位置参数
+beforeRequest(请求数据) = @.beforeRequest = function(reqData){
+	__/*此回调事件在发送请求前触发。\nreqData.params 是即将发送的参数。*/
+	return reqData;
+}
+beforeJsonParse = @.beforeJsonParse = function(jsonData){
+    __/*可以在这里解密服务端数据，返回 null 中止本次调用。\n定义此函数以后，服务端每次输出的 JSON 必须以换行符结束*/
+	return jsonData;
+}
+afterJsonStringify = @.afterJsonStringify = function(jsonData){
+    __/*可以在这里加密客户端JSON，返回 null 中止本次调用。*/
+	return jsonData;
+}
+onError = @.onError = function(message){
+	__/*目标进程存在标准库错误输出时触发此函数*/
+}
+process = 进程管道对象\n!process_popen.
+close() = 关闭客户端
+end intellisense**/ 

package/aardio/lib/process/rpc/jsonServer.aardio

@@ -0,0 +1,293 @@
+//jsonServer 服务端
+import web.json;
+import string.aasdl;
+
+namespace process.rpc;
+
+class jsonServer{
+	ctor(external){};
+	rpc = {
+		external = external;
+		_rpcResponse = function(reqData){
+	 	
+			if( ! reqData  ){
+				return { 
+					error = {
+						code = -32700;
+						message = "Invalid JSON was received by the server." 
+					};
+				};  
+			};
+		  	
+			if( ! (reqData[["method"]] ) ){
+				return { 
+					id = reqData[["id"]];
+					error = {
+						code = -32600;
+						message = "Invalid Request	The JSON sent is not a valid Request object."
+					};
+				}
+			};
+			
+			if(!owner.external){
+				return {
+					id = reqData[["id"]];
+					error = {
+						code = -32601;
+						message = "The method does not exist / is not available.."
+					};
+				}
+			}
+			
+			var method = reqData[["method"]];
+			if(method=="?"){
+				if(!owner.aasdl){
+					owner.aasdl = ..string.aasdl(owner.external);
+				}
+				
+				return {
+					result = owner.aasdl;
+					id = reqData.id;
+				}
+			}
+			
+			var success,result,err; 
+			var ns,m = ..string.match(method,"(.+)\.([^.]+)$");
+			if( ns && m ){
+				var obj = ..table.getByNamespace(ns,owner.external);
+				if( (type(obj) == type.table ) && obj[m] ){
+					if(reqData.params) success,result,err = call(obj[m],obj,..table.unpackArgs(reqData.params) );
+					else success,result,err= call(obj[m],obj);
+				}
+				else {
+					return {
+						id = reqData[["id"]];
+						error = {
+							code = -32601;
+							message = "The method does not exist / is not available.."
+						};
+					}
+				}
+				
+			}
+			else {
+				if(owner.external[method] ){
+					if(reqData.params) success,result,err = call(owner.external[method],owner.external,..table.unpackArgs(reqData.params) );
+					else success,result,err = call(owner.external[method],owner.external);
+				}
+				else {
+					return {
+						id = reqData[["id"]];
+						error = {
+							code = -32601;
+							message = "The method does not exist / is not available.."
+						};
+					}
+				}	
+			} 
+			
+			if(!success){
+				err = result;
+			}
+			
+			if((result === null) && (err!==null)){ 
+				if( type(err) == type.string ){
+					err = {
+						code =-32603;
+						message = err;
+					} 
+				}
+				elseif( type(err) == type.number ){
+					err = {
+						code = err;  
+						message = (err == -32602 ? "Invalid params" : "Server error");
+					} 
+				}	
+				elseif( err[["code"]] || err[["message"]] ){
+				 	
+				}
+				else {
+					err = {
+						code =-32603;  
+						message = "Internal error";
+					}
+				} 
+			}
+			else {
+				err = null;
+			}
+			
+			
+			return {
+				@{ _defined = (err === null ? {"result"} : null); _type="object"};
+				error = err;
+				result = result;
+				id = reqData.id;
+			}
+		}
+		_beginRpcResponse = function(){
+		
+			if(!owner.external) owner.external=this;
+			
+			var reqData;
+			owner.lastRequstData = null;
+			if(owner.beforeJsonParse){ 
+				while( var json =  stdin.read() ) { 
+					owner.lastRequstData = json;
+					json = owner.beforeJsonParse(json);
+					reqData = ..web.json.tryParse(json);
+	    			if(reqData && type(reqData)=="table"){
+	    			    if(reqData[["id"]] || reqData[1][["id"]]) break; 
+	    			}
+				}	
+			}
+			else{
+				var json,jsonEnd,jsonEndStr;
+				while( var c =  stdin.read(1) ){
+					if(c=="[") {
+						json = "[";
+						jsonEnd =']'#;
+						jsonEndStr =']';
+						break;
+					}
+					else if(c=="{") {
+						json = "{";
+						jsonEnd = '}'#;
+						jsonEndStr ='}';
+						break;
+					}
+				}
+				
+				if(json){
+					while( var block =  stdin.readTo(jsonEnd)) {
+				 	
+						json = json ++ block ++ jsonEndStr;
+						
+						owner.lastRequstData = json;
+						reqData = ..web.json.tryParse(json);
+					
+	    				if(reqData[["id"]]
+	    					|| ( type(reqData)=="table" && reqData[1][["id"]]) ) {
+	    			    	break; 
+	    				}
+					}	
+				}
+			}
+			
+			if( ! reqData  ){
+				if(owner.lastRequstData){
+					return owner._write({error = {
+						code = -32700;
+						message = ..string.concat("Invalid JSON was received by the server.");
+					}});	
+				}
+				
+				return;
+			};
+			
+			if(#reqData){
+				var transaction = ..table.array();
+				for(i=1;#reqData;1){
+					var repData  = owner._rpcResponse(reqData[i]);
+					if( reqData[i].id ) {
+						repData.id = reqData[i].id;
+						repData.jsonrpc =  "2.0";
+						..table.push(transaction,repData); 
+					};
+				}
+				
+				if(#transaction){
+					return owner._write(transaction);
+				};
+				return true;
+			};
+			
+			var repData = owner._rpcResponse(reqData); 
+			if(reqData.id!=null) {
+				repData.id = reqData.id;
+				return owner._write(repData);
+			}
+		};
+		_write = function(repData){
+			repData.jsonrpc =  "2.0";
+			
+			var jsonData = ..web.json.stringify(repData);
+			if( owner.afterJsonStringify ) {
+				jsonData = owner.afterJsonStringify(jsonData);
+				if(!jsonData) return true;
+			}
+			
+			var ok,err,errno = stdout.write(jsonData,'\n');
+			if(ok){
+				return stdout.flush();
+			}
+			
+			return ok,err,errno;
+		}; 
+		run = function(){
+			if( stdout.type() != 0x3/*_FILE_TYPE_PIPE*/ ) return;
+			
+			var this = owner;
+
+		 	var ok,err,errno;
+		 	do{
+		 		try{
+		 			ok,err,errno = this._beginRpcResponse()
+		 		}
+		 		catch(e){
+		 			if( this.onError ) {
+						this.onError(e,this.lastRequstData);
+					}
+					
+					ok,err,errno = this._write({
+						error = {
+							code = -32603/*_JSONRPC_INTERNAL_ERROR*/; 
+							message = ..string.concat( "Internal JSON-RPC Error:",e);
+						};
+					})	
+		 		}
+		 	}while(ok)
+		 	
+		 	return ok,err,errno;
+		}
+		
+	}
+}
+
+namespace jsonServer{ 
+    stdout = ..io.stdout;
+    stderr = ..io.stderr;  
+    stdin = ..io.stdin; 
+}
+
+
+/**intellisense()
+process.rpc.jsonServer = 基于进程管道实现的 JSON-RPC 2.0 服务端，\n对应的客户端实现为 process.rpc.jsonClient 。\n\n规则如下：\n1、客户端不应当向服务端发送任何不符合 JSON-RPC 规范的内容。\n2、客户端应当仅将包含 jsonrpc 字段的对象解析为 JSON-RPC 响应对象。\n在批量调用时，应当仅将包含上述对象的非空数组解析为 JSON-RPC 响应对象。\n客户端应当允许服务端进程的存在其他输出或错误输出。\n3、服务端在发送每个 JSON-RPC 响应对象不会包含换行且在尾部添加换行符'\n'。\n\n[关于JSON-RPC 2.0](http://www.jsonrpc.org/specification)
+process.rpc.jsonServer() = 创建 JSON-RPC 2.0 服务端\n可选在构造参数中指定监听客户端调用的监听器对象\n如果不指定参数,保用对象自身监听客户端调用\n!processRpcJsonServer.
+!processRpcJsonServer.? = 客户端可以调用的远程对象名或远程方法名字,\n客户端传过来的params参数必须是数组\n服务端会展开此数组作为函数的调用参数\n函数第一个返回值指定为客户端获取的result返回值\n函数的第二个返回值指定为客户端error错误对象\n错误对象可以是数值，字符串、或符合JSON-RPC2.0协议的表对象,\n!web_rpcJsonClient.
+end intellisense**/
+
+/**intellisense(!processRpcJsonServer)
+rpc.run() = 运行JSON-RPC服务端响应用户请求
+rpc.external = 指定包含客户端可以调用的远程函数的表对象,可嵌套子表,\n如果创建服务端对象的构造参数中没有指定表,\n这个对象默认指向对象自身\n可在调用run函数之前更改此对象
+rpc.onError = @.onError = function(err,requestData){
+	__/*服务器内部错误时触发此事件\nerr为抛出的异常对象,一般为错误信息\nrequestData为客户端发送的请求数据*/
+} 
+rpc.aasdl = 指定自定义的aasdl\n如果不指定,服务端会根据external自动生成aasdl\n如果客户端请求的方法名为"?"时,返回此属性,\n[关于aasdl](http://bbs.aardio.com/doc/aasdl)
+rpc.beforeJsonParse = @.beforeJsonParse = function(jsonData){
+    __/*可以在这里解密客户端数据,返回null中止本次调用*/
+	return jsonData;
+}
+rpc.afterJsonStringify = @.afterJsonStringify = function(jsonData){
+    __/*可以在这里加密服务端JSON,返回null中止本次调用*/
+	return jsonData;
+}
+end intellisense**/
+
+ /**intellisense()
+_JSONRPC_PARSE_ERROR=@-32700/*_JSONRPC_PARSE_ERROR*/
+_JSONRPC_INVALID_REQUEST=@-32600/*_JSONRPC_INVALID_REQUEST*/
+_JSONRPC_METHOD_NOTFOUND=@-32601/*_JSONRPC_METHOD_NOTFOUND*/
+_JSONRPC_INVALID_PARAMS=@-32602/*_JSONRPC_INVALID_PARAMS*/
+_JSONRPC_INTERNAL_ERROR=@-32603/*_JSONRPC_INTERNAL_ERROR*/
+end intellisense**/

package/aardio/lib/process/rpc/tcpJsonClient.aardio

@@ -0,0 +1,36 @@
+//tcpJsonClient 客户端
+import process.popen;
+import process.job.limitKill;
+import wsock.tcp.jsonClient;
+
+namespace process.rpc;
+
+class tcpJsonClient{
+	ctor( ... ){
+		var prcs,err,errCode = ..process.popen(...);
+		if(!prcs) return null,err,errCode;
+		
+		prcs.codepage = 65001 
+		prcs.assignToJobObject( ..process.job.limitKill );
+		
+		while( var url = prcs.read()  ) {
+			if(..string.find(url,"<127.0.0.1>|<localhost>\:\d+")  ){
+				var client = ..wsock.tcp.jsonClient(url);
+				client[["process"]] = prcs;
+				return client;
+			}
+		}
+		
+		var err = prcs.readErr(-1);
+		prcs.close();
+		
+		return null,err;
+	}; 
+}
+
+/**intellisense()
+process.rpc.tcpJsonClient = 调用启动 JSON-PRC 服务端的目标程序
+process.rpc.tcpJsonClient( = 调用启动 JSON-PRC 服务端的目标程序，\n创建管道并隐藏子进程的控制台黑窗口。\n自进程输出读取 "127.0.0.1:端口" 或 "localhost:端口" 格式地址，\n并创建 JSON-RPC 客户端连接该地址。\n\n成功返回 wsock.tcp.jsonClient 客户端，\n失败返回 3 个值：null,错误信息,错误代码
+process.rpc.tcpJsonClient(.(执行文件,命令行参数,STARTUPINFO) = 调用启动 JSON-PRC 服务端的目标程序。\n命令行参数可以是一个数组、一个或多个字符串参数,\n\n数组或多个命令行参数调用 process.joinArguments 合并,\n不在双引号内、且包含空白或需要转义的参数转义处理后首尾添加双引号
+process.rpc.tcpJsonClient() = !wsock_rpcJsonClient.
+end intellisense**/