aview-app 1.0.2

package/aardio/lib/wsock/tcp/jsonClient.aardio

@@ -0,0 +1,243 @@
+//jsonClient RPC客户端
+import wsock.tcp.client;
+import web.json;
+
+namespace wsock.tcp;
+
+class jsonClient{
+	ctor( ip,port ){
+		this.rpc = {
+			url = url;
+			client = ..wsock.tcp.client();
+			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.client.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 len = 100;
+				var slp = ..win ? ..win.delay : sleep;
+				var json = "";
+				var inputCodepage;
+				if(!utf8) inputCodepage = 0;
+				
+				while( slp(10) ){
+					var c,err = owner.client.peek(len);
+					if( err ){
+						owner.client.close();
+						return null,"服务端已断开";
+					}
+					
+					if(#c){
+						owner.client.read(#c);
+						json = json ++ c;
+						
+						repData = ..web.json.tryParse(json,,inputCodepage);  
+						if( (repData[["id"]] == reqData.id)
+	    					|| ( isTransaction && type(repData)=="table" && repData[1][["id"]]) 
+	    					|| repData[["error"]] ){
+	    					owner.lastResponseData = json;
+	    					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;
+				}
+			}; 
+			notify = function(method,...){  
+				var reqData = {
+					jsonrpc = owner.version;
+					method = method;
+				}
+				
+				if( owner.varargs ){
+					reqData.params = {...};
+				}
+				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 = {...};
+				}
+				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(){
+				return owner.postData(owner.transaction);
+			};
+			rollbackTrans = function(){
+				owner.transaction = null;
+				owner.endCallback = null;
+			}; 
+			lastStatusMessage = function(){
+				if(owner.lastStatusCode)return ..inet.httpStatusCode[owner.lastStatusCode],owner.lastStatusCode;
+			};
+			lastResponse = function(){ 
+				var s = owner[["lastResponseData"]];
+				if( ..console && _STUDIO_INVOKED ) ..console.log(s) else ..io.print(s);
+				return s;
+			};
+			close = function(){
+				if(owner.client){
+					owner.client.close();
+					owner.client = null;
+				} 
+			};
+		};
+		
+		if( ! this.rpc.client.connect( ip,port ) ){
+			return 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, ...) ;
+		}
+	}
+}
+ 
+ 
+/**intellisense()
+wsock.tcp.jsonClient = JSON-RPC 2.0 客户端\naardio 输出的请求 JSON 不包含换行并以换行符'\n'结束。\n服务器应答 JSON 对象的 id 字段必须与请求 id 一致，\n在批量请求时应答数组应当包含 id 一致的对象（不需要返回空数组）\n[关于 JSON-RPC 2.0](http://www.jsonrpc.org/specification)
+wsock.tcp.jsonClient(.(主机,端口) = 创建REST客户端\n也可以在第一个参数中使用冒号分隔主机与端口
+wsock.tcp.jsonClient() = !wsock_rpcJsonClient.
+!wsock_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!wsock_rpcJsonClient.
+!wsock_rpcJsonClient.rpc = RPC本地客户端对象\n所以本地函数放在这个对象里面\n用户不得添加、删除、修改此对象的任何成员
+!wsock_rpcJsonClient.process = 如果使用 process.rpc.tcpJsonClient 创建对象，\n则此属性为 process.popen 对象，否则为空。\n!process_popen.
+end intellisense**/ 
+
+/**intellisense(!wsock_rpcJsonClient.rpc)
+setAuth(.("用户名","密码") = 设置HTTP登录用户名,密码 
+lastStatusCode = 获取最近一次请求返回的HTTP状态码\n100 ~ 101 为信息提示\n200 ~ 206 表示请求成功\n300 ~ 305 表示重定向\n400 ~ 415 表求客户端请求出错\n500 ~ 505 表示服务端错误
+lastStatusMessage() = 获取最近返回的HTTP状态码文本描述\n第二个返回值为状态码
+lastResponse() = 获取最后一次服务器返回的原始数据,\n如果控制台已打开或在开发环境中导入console库则在控制台输出数据\n下载文件时该值为空
+client = 用于执行请求的 wsock.tcp.client 对象\n!stdtcpclient.
+close() = 关闭RPC客户端并释放资源
+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 编码方案，所以不建议也不应该修改这个值\n\n如果指定为除"UTF-8"之外的值，则按本机默认代码页转换服务端编码
+version = 值为 JSON-RPC 协议版本："2.0"\n不应该修改这个值
+varargs = 默认值为 true,\n值为 true 时将不定个数的参数放入数组发送给服务端\n值为false时直接将单个参数发送给服务端\n\nJSON-RPC 2.0 一个会制造混乱的地方：\n如果 params 是一个数组，并没有规定是展开为一个参数，还是作为一个数组参数。\n\n目前aardio的RPC服务端会负责展开数组作为多个参数，\n但客户端需要在这里手动设置
+beforeRequest(请求数据) = @.beforeRequest = function(reqData){
+	__/*此回调事件在发送请求前触发\nreqData.params是即将发送的参数*/
+	return reqData;
+}
+end intellisense**/ 

package/aardio/lib/wsock/tcp/server.aardio

@@ -0,0 +1,153 @@
+//server 服务端
+import wsock.err; 
+import wsock.tcp.client;
+namespace wsock.tcp;
+
+class server{
+	ctor(ip,port,backlog){{
+		if(! ..wsock.open() ){ 
+			error( ( ..wsock.err.lasterr() ),2 ) 
+		}
+		 
+		var hSocket= ..wsock.socket(0x2/*_AF_INET*/,0x1/*_SOCK_STREAM 建立流式套接口*/,0x6/*_IPPROTO_TCP*/ )
+		if( hSocket = _INVALID_SOCKET ){ 
+			..wsock.close() //关闭wsock
+			return null,..wsock.err.lasterr();
+		} 
+		this.hSocket = hSocket;
+		this._serverAddress = ..wsock.sockaddr_in();  
+		
+		this.bind = function(ip,port){
+			var service = ..wsock.sockaddr_in( ip,port : 0 ); 
+			service.sin_family = 0x2/*_AF_INET*/ 
+			if ..wsock.bind( this.hSocket,service,..raw.sizeof(service)) =-1/*_SOCKET_ERROR*/	{ 
+				return null, ..wsock.err.lasterr() ;
+			} 
+			..wsock.getsockname(this.hSocket, this._serverAddress,..raw.sizeof(this._serverAddress) );
+			return true;
+		}
+		this.listen = function(backlog){ 
+			if( ..wsock.listen(this.hSocket,backlog : 5 )=-1/*_SOCKET_ERROR*/){
+				return null, ..wsock.err.lasterr() ;
+			}
+			return true;
+		};
+		
+		var ok,err = this.bind (ip,port);
+		if( ! ok ){
+			..wsock.closesocket(this.hSocket); 
+			..wsock.close() //关闭wsock
+			return null,err;
+		}
+		
+		var ok,err = this.listen ( backlog );
+		if( ! ok ){
+			..wsock.closesocket(this.hSocket); 
+			..wsock.close() //关闭wsock
+			return null,err;
+		}
+		
+		
+		this.getLocalIp = function(){
+			return ..wsock.inet_ntoa(this._serverAddress.sin_addr),..wsock.ntohs( this._serverAddress.sin_port );
+		};
+		
+		var ip,port = this.getLocalIp();
+		this.id = "wsock.tcp.server["+ip +":"+port+"]";
+		
+		..thread.set(this.id,true);
+	}};
+	close = function(){
+		if( this.hSocket ){
+			..wsock.closesocket(this.hSocket); 
+			..wsock.close();
+			this.hSocket = null;
+		}
+	};
+	forever = function(handle){
+		if( type(handle) != type.function ) error("参数@1必须是一个函数对象",2);
+	 
+		while( true ){
+			var acceptSocket = ..wsock.accept(this.hSocket)
+			if( acceptSocket!= _INVALID_SOCKET ){ 
+				if( ! ..thread.get(this.id)) {
+     				..wsock.closesocket(acceptSocket);
+     				break;
+     			}
+     				
+				this.lastRequestSocket = acceptSocket;
+				if( handle(acceptSocket) ===  false ){
+					break;
+				}
+			}
+			else {
+				if( ! ..thread.get(this.id))  break;
+			}
+		}
+
+		if(this._beforeClose){this._beforeClose();}
+		if(this.beforeClose){this.beforeClose();}
+		this.close();
+	};
+};
+
+namespace server{
+    
+    closeById = function(id){
+    	var ip,port = ..string.match(id,"^wsock\.tcp\.server\[(.+)\:(\d+)\]$");
+    	if(ip=="0.0.0.0") ip =  "localhost";
+    	
+    	..thread.set(id,null);
+    	var client = ..wsock.tcp.client(); 
+		client.connect(ip,tonumber(port));
+		client.close();
+		sleep(10);
+    }
+    
+	getFreePort = function(ip,ports,...){
+		if(ports){
+			if(type(ports)!="table") ports = {ports,...}
+
+			for(i=1;#ports){
+				var server = ..wsock.tcp.server(ip,ports[i]);
+				if( server ){
+					server.close();
+					return ports[i];
+				}
+			}
+		}
+
+		return ..wsock.getFreePort(ip);
+	}
+	
+	isFreePort = function(port,ip){
+		var server = ..wsock.tcp.server(ip,port);
+		if( server ){ 
+			server.close(); 
+			return true;	
+		}	
+	} 
+}
+
+/*
+http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
+*/
+
+/**intellisense()
+wsock.tcp.server = TCP服务端
+wsock.tcp.server(.(IP,端口,请求队列大小) = 创建TCP服务端,所有参数可选,\n\n如果不写IP，则默认设为"0.0.0.0"也即监听本机所有IP,访问此服务端也不限制IP\n限制仅本机可以访问建议写127.0.0.1\n\n端口为0或省略则自动查找1025以后的空闲端口\n注意0-1023为系统通用服务保留端口,\n1024-49151为用户服务端口,其中大约%9已由IANA注册分配\n49152-65535为私有或动态分配的临时端口
+wsock.tcp.server() = !stdWsockTcpServer.
+wsock.tcp.server.closeById(.(serverId) = 参数指定wsock.tcp.server对象的ID属性\n关闭指定ID的服务器
+wsock.tcp.server.getFreePort(.(ip,->->->) =  获取空闲TCP服务端口，\nIP参数需要与实际创建服务器使用的IP参数完全一致，\n可选在参数中使用数值数组或任意个数值参数指定优先测试的端口号，\n如果没有找到参数指定的空闲凋口,则自动分配空闲端口，\n动态分配空闲端口为49152到65535之间的值，\nXP系统则为 1025到5000之间的值，\n命令行输入 netsh int ipv4 show dynamicport tcp 看动态端口范围，\n安装 Hyper-V 会导致动态起始端口变为 1024 导致常用端口冲突
+wsock.tcp.server.isFreePort(.(port,ip) = 检查参数指定的端口号是否空闲\n如果不写IP，则默认设为"0.0.0.0"
+!stdWsockTcpServer.id = 服务器唯一ID,字符串
+!stdWsockTcpServer.bind(.(IP,端口) = 绑定IP端口
+!stdWsockTcpServer.listen(.(请求队列大小) = 监听指定的IP端口
+!stdWsockTcpServer.close() = 关闭TCP服务端
+!stdWsockTcpServer.getLocalIp() = 返回当前绑定的IP,端口号
+!stdWsockTcpServer.forever(回调函数) = @.forever(\n	function(acceptSocket){\n		var request = wsock.tcp.client(,acceptSocket)\n	}\n)	
+!stdWsockTcpServer._serverAddress = 服务端监听地址\n!sockaddr_in.
+!stdWsockTcpServer.beforeClose() = @.beforeClose = function(){
+	__/*服务器关闭前调用此函数*/
+}
+end intellisense**/