C++博客-socketref,再见！高德-随笔分类-TCE

TCE －小型的RPC通信引擎库介绍

放屁阿狗 — Sun, 18 Sep 2016 08:03:00 GMT

摘要: 项目地址: http://github.com/adoggie/TCE 从12年的时候开始想做一个rpc的东东，这些年来陆陆续续往里面增加不同的功能、特点。
tce是一个全栈的东西，并不是 protocalbuf，或者接近 thrift。支持语言: csharp,python,java,objc,javascript,actionscript,c++,我想这些够了。
阅读全文

放屁阿狗 2016-09-18 16:03 发表评论

RPC demo: 实现认证服务器接口

放屁阿狗 — Mon, 25 Nov 2013 16:53:00 GMT

接口定义：

1 interface IAuthServer{
2 CallReturn_t userAuth(string user,string passwd,int device_type);
3 CallReturn_t registerUser(UserRegisterInfo_t reginfo); // tested
4 };

定义认证服务器接口，userAuth()返回认证用户的token

接口服务实现：

1 import os,os.path,sys,struct,time,traceback,signal,threading,copy,base64
2 import datetime,base64
3
4 from datetime import datetime
5 from base import *
6 import tcelib as tce
7 from showbox import *
8 import utils.misc
9 import utils.config
10 import utils.cipher
11
12
13 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "database.showbox.showbox.settings")
14
15 from django.db import connection
16 from django.db.models import Sum
17 from django.db import transaction
18 # import sns.core.models as cm
19 import database.showbox.core.models as  core
20 import database.showbox.nosql.models as nosql
21
22 class AuthServerImpl(IAuthServer):
23     def __init__(self,app):
24         IAuthServer.__init__(self)
25         self.app = app
26
27     def userAuth(self, user, passwd, device_type, ctx):
28         cr = CallReturn_t()
29         try:
30             r = core.User.objects.get(user=user,passwd=passwd)
31             userinfo = {
32                 "id":r.id,
33                 "user":user,
34                 "name":r.name,
35                 "login_time":int(time.time()),
36                 "user_type":SnsConsts.Authorized_User
37             }
38             token = utils.cipher.encryptToken(userinfo)
39             cr.value = token
40         except:
41             print traceback.format_exc()
42             cr = CallReturn_Error()
43         return cr
44
45     def registerUser(self, reginfo, ctx):
46         return IAuthServer.registerUser(self, reginfo, ctx)
47
48
49
50 class ServerApp:
51     def __init__(self):
52         pass
53
54     def getConfig(self):
55         #return self.app.getConfig()
56         pass
57
58     _handle = None
59     @classmethod
60     def instance(cls):
61         if cls._handle == None:
62             cls._handle = cls()
63         return cls._handle
64
65     def run(self):
66         tce.RpcCommunicator.instance().init('authserver').initMessageRoute('./services.xml')
67         server = tce.RpcCommunicator.instance().currentServer().findEndPointByName('mq_authserver').impl
68         adapter  = tce.RpcAdapterEasyMQ.create('server',server)
69         #没有主动发送消息的情形
70         servant = AuthServerImpl(self)
71         adapter.addServant(servant)
72         tce.RpcCommunicator.instance().waitForShutdown()
73
74 if __name__ == '__main__':
75     ServerApp.instance().run()

服务器很简单，实现接口IAuthService的功能函数，定义一个ServerApp，然后运行

客户调用测试：

1 from datetime import datetime
2 from base import *
3 import tcelib as tce
4 from showbox import *
5 import utils.misc
6 import utils.config
7 import utils.cipher
8
9
10 def userAuthResult(result,prx):
11     print result
12
13 # queue:client 必须在调用服务器的write 队列mq
14 communicator =tce.RpcCommunicator.instance().init()
15 conn = tce.RpcConnectionEasyMQ.create('127.0.0.1',12301,'queue:mq_authserver')
16 local = tce.RpcConnectionEasyMQ.create('127.0.0.1',12301,'queue:mq_test_client',tce.AF_READ)
17 conn.setLoopbackMQ(local)
18
19
20 prx = IAuthServerPrx(conn)
21 prx.userAuth_async('test','111111',1,userAuthResult)    #异步调用
22 print prx.userAuth('test','111111',1)           #同步调用

21,22行分别测试两种调用模式

client与server通过EasyMQ进行传递
easyMQ是个最简单的消息队列实现

放屁阿狗 2013-11-26 00:53 发表评论

tce for python

放屁阿狗 — Tue, 01 Oct 2013 19:18:00 GMT

idl的保留关键字：'byte','bool','short','int','long','float','double','string' ,均不能用于定义module,class,interface和变量名称

定义的变量名称如果包含以下单词：'def','import','from','type','str','int','float','class' , tce生成python代码时自动给添加'_'后缀，比如：

struct xx{

string name;

string from;

}

xx结构的from变量名将生成from_

接口定义：

module test{

dictionary Properties_t;

sequence IpAddressList_t;

interface ITerminal{

void onGetServerMessage(string text);

}

interface Server{

IpAddressList_t getIpAddresses();

Properties_t getProperties();

void ping(string fromhost);

string login(string user,string passwd,ctx);

};

}

struct:

tce将结构struct映射为class对象，初始化成员变量并创建散列函数 marshall/unmarshall

sequence:

tce将数组类型直接映射为[]

例如 :

dictionary

tce将字典映射为 {}

python实现Server接口的getIpAddresses()方法:

def getIpAddresses():

return ['192.168.14.101','192.168.12.50']

定义服务器接口实现：

tce为interface生成接口基类: class Server

我们提供一个实现类 :

class ServerImpl(Server):

def __init__(self):

Server.__init__(self)

def getIpAddresses(self,ctx):

return []

在这里我们提供了ServerImpl类，然后编写实现函数getIpAddresses. 每个接口函数都携带ctx参数，ctx携带rpc请求的附属信息，比如：外带数据(dict),底部的连接对象等等。

服务接口被称为一个服务类servant ,接下来演示如何将这个servant装配并提供客户。

tce.RpcCommunicator.instance().init()

ep = tce.RpcEndPoint(host='127.0.0.1',port=16005) 定义一个通信端点

adapter = tce.RpcCommunicator.instance().createAdapter('first_server',ep) 创建一个通信适配器

servant = ServerImpl() 创建服务接口对象

adapter.addServant(servant) 添加进适配器
tce.RpcCommunicator.instance().waitForShutdown() 进入通信循环

调用服务：

tce.RpcCommunicator.instance().init()

prx = test.ServerProxy.create(127.0.0.1,16005)

ips = prx.getIpAddresses()

多种呼叫模式:

tce将接口函数自动生成 normal,oneway,async三种调用接口方法，rpc调用出现异常，底部将抛出异常，所以用户需要异常捕获。

1.normal:

原型: fun_name(参数..,timeout=0,extra=None)

调用函数自动添加timeout,extra参数。timeout默认为0，将自动采用tce默认的30s等待调用返回时间；

extra 指此次调用携带的附属数据，extra ={'name':'scott','age':100}

extra数据在服务端接口函数的ctx中获取： ctx.msg.extra

函数调用时将阻塞客户线程，直到timeout超时或者服务器数据返回

2. oneway

fun_name_oneway(参数...,extra=None)

只有类型void的接口函数才会生成oneway调用方法.oneway调用不会阻塞用户线程，通常用于单向传输的场景，例如 Server接口的ping()函数

3. async

fun_name_async(参数,async_callback,extra=None)

异步调用模式不会阻塞客户线程，async_callback指定了rpc调用的返回接收函数

接收函数原型: void fun_name_CallBack(result,proxy)

例如：　

def getIpAddressesResult(result,proxy):

print result #result - IpAddressList_t

prx.getIpAddresses_async(getIpAddressesResult)

*连接复用

在互联网应用场景，服务器将接入大量的客户端设备，客户端是不能被寻址，所以服务器要完成推送消息给客户端，必须在客户端建立的连接上反向传输。

tce使这个工作变得相当简单：

1. 客户端定义接收消息的接口 ITerminal,定义接收函数onGetServerMessage()

class TermnialImpl(ITerminal):

...

2. 创建到服务器的连接代理

tce.RpcCommunicator.instance().init()

prx = test.ServerProxy.create(127.0.0.1,16005) 创建但并不马上连接

3. 添加服务类实现

adapter = tce.RpcCommAdapter('adapter')

          impl = TerminalImpl()
          adapter.addConnection(prx.conn)
          adapter.addServant(impl) 加到通信器对象

3. 请求一次调用

prx.login('scott','1234')

4. 服务器端反向调用ITerminal的onGetServerMessage()

def login(self,user,passwd,ctx):

prx = ITerminalProxy(ctx.conn)

prx.onGetServerMessage('server message..') 完成一次对设备端的接口调用

放屁阿狗 2013-10-02 03:18 发表评论

C++博客-socketref,再见！高德-随笔分类-TCE

TCE － 小型的RPC通信引擎库 介绍

RPC demo: 实现认证服务器接口

tce for python

TCE －小型的RPC通信引擎库介绍