昆仑的山头

/**
 * 统一的返回值
 */
struct Retu{
    1: i32 code, //返回码
    2: string msg, //返回错误时的详细信息
    3: map<string, string> data//map/字典 类型的返回值
}
 
/**
* 异常信息
*/
exception UException{
    1:i32 errorCode,      //错误码      1=参数错误，2=没有结果 99=系统异常
    2:string errorMessage    //错误描述
}
 
service PiMessService{
	Retu c(1:string action, 2:map<string, string> params) throws (1:UException ex),
}

#coding:utf-8
import sys, glob, os
import event  #这里是自己封装的python事件中心，可以订阅、触发事件，以后有机会单独给大家分享
rootPath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(rootPath + '/lib/gen-py')  #thrift库文件位置
 
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
 
import piMess.PiMessService as PiMessService
import piMess.ttypes as ttypes
 
#####server start#####
class PiMessHandler:
    def __init__(self):
        self.log = {}
    #会被client调用的方法
    def c(self, action, params):
        #收到一次调用，其实是触发一次特定事件，程序其他部分可以去订阅这个事件，返回给出返回值
        rets    = event.trigger('tele_' + action, params)  
        msg     = ''
        data    = {}
        if(len(rets) > 0): #以第一个绑定的返回值为准，后续可以根据实际需求在扩展
            if(type(rets[0]) == type('')):#只使用字符串和字典值
                msg     = rets[0]
            elif(type(rets[0]) == type({})):
                data    = rets[0]
        return ttypes.Retu(200, msg, data)
#启动服务
def serviceStart():
    print 'PiMessService start on 9001 ...'
    handler     = PiMessHandler()
    processor   = PiMessService.Processor(handler)
    transport   = TSocket.TServerSocket(port=9001) #python server端的端口
    tfactory    = TTransport.TBufferedTransportFactory()
    pfactory    = TBinaryProtocol.TBinaryProtocolFactory()
    server      = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
    server.serve()
    print 'done~'
#####server end#######
 
#####client start#####
__transport = TSocket.TSocket('localhost', 9002)   #nodejs server端的端口
__transport = TTransport.TBufferedTransport(__transport)
__protocol  = TBinaryProtocol.TBinaryProtocol(__transport)
__client    = PiMessService.Client(__protocol)
def clientOpen():
    __transport.open()
 
#供外部调用的向nodejs端发送消息的方法
def send(action, params):
    r = __client.c(action, params)
    print('call nodejs:', action, params, r)
    return r
 
def clientClose():
    __transport.close()
#####client end#######
 
if __name__ == "__main__":
    clientOpen()
    send('py-client', {'QQQ': 'ZZZ', 'abc':'PPP'})
    serviceStart()

var thrift          = require('thrift');
var Thrift          = thrift.Thrift;
 
var piMessService   = require('../gen-nodejs/PiMessService'),
  ttypes            = require('../gen-nodejs/piMess_types');
 
 
/***server start***/
var server          = thrift.createServer(piMessService, {
  c: function(action, params, result){  
    //server，可以根据action值，调用对应的外部方法
    console.log('piMessService.c:', action, params);
    retu            = new ttypes.Retu({code:200, msg:'ok', data:null});
    result(null, retu);
  }
}, {});
server.listen(9002);
/***server end*****/
 
/***client start***/
var connection      = thrift.createConnection('localhost', 9001),
  client            = thrift.createClient(piMessService, connection);
 
//对外暴漏一个send方法
exports.send = function(action, params, callback){
  console.log('exports.send:', action, params);
  client.c(action, params, function(err, response){
    if(response){
      console.log('response:', response);
    }
    callback && callback(err, response);
  });
};
 
exports.clientEnd = function(){
  connection.end();
};
/***client end*****/