def make_server(service,
handler,
host="localhost",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory()):
processor = TProcessor(service, handler)
if unix_socket:
server_socket = TServerSocket(unix_socket=unix_socket)
elif host and port:
server_socket = TServerSocket(host=host, port=port)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
server = TThreadedServer(processor,
server_socket,
iprot_factory=proto_factory,
itrans_factory=trans_factory)
return server
def make_server(host="localhost",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
client_timeout=3000,
certfile=None):
"""Creates a Thrift RPC server and serves it with configuration
"""
_init_django()
processor = get_rpc_application()
if unix_socket:
server_socket = TServerSocket(unix_socket=unix_socket)
if certfile:
logging.error("SSL only works with host:port, not unix_socket.")
elif host and port:
if certfile:
server_socket = TSSLServerSocket(host=host,
port=port,
client_timeout=client_timeout,
certfile=certfile)
else:
server_socket = TServerSocket(host=host,
port=port,
client_timeout=client_timeout)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
server = TThreadedServer(processor,
server_socket,
iprot_factory=proto_factory,
itrans_factory=trans_factory)
try:
return server
except KeyboardInterrupt:
print()
print("Stopping Server from Keyboard Interruption")
exit()
def create_multiplexed_server(services,
socket_config,
server_cls=TThreadedServer):
"""
创建多路复用的Thrift Server
:param services: 多路复用服务定义，如：[(service1, handler1, service_name1),
(service2, handler2, service_name2),...]
:param socket_config: Server的socket参数
:param server_cls: 启动的服务器类型
:return: Server对象
"""
processor = TMultiplexedProcessor()
for service, handler, service_name in services:
processor.register_processor(service_name,
TProcessor(service, handler))
return server_cls(
processor, # processor
TServerSocket(**socket_config), # transport
TBufferedTransportFactory(), # transportFactory
TBinaryProtocolFactory()) # protocolFactory
def make_client(service,
host="localhost",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
timeout=None):
if unix_socket:
socket = TSocket(unix_socket=unix_socket)
elif host and port:
socket = TSocket(host, port)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
if timeout:
socket.set_timeout(timeout)
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, protocol)
def main():
binary_factory = TBinaryProtocolFactory()
dd_factory = TMultiplexedProtocolFactory(binary_factory, DD_SERVICE_NAME)
with client_context(dd_thrift.DingService,
'127.0.0.1',
9090,
proto_factory=dd_factory,
socket_timeout=100000) as c:
# ring that doorbell
dong = c.ding()
print(dong)
pp_factory = TMultiplexedProtocolFactory(binary_factory, PP_SERVICE_NAME)
with client_context(pp_thrift.PingService,
'127.0.0.1',
9090,
proto_factory=pp_factory,
socket_timeout=100000) as c:
# play table tennis like a champ
pong = c.ping()
print(pong)
def make_server(host="0.0.0.0",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
client_timeout=3000,
certfile=None):
"""Creates a Thrift RPC server and serves it with configuration"""
processor = create_processor()
if unix_socket:
server_socket = TServerSocket(unix_socket=unix_socket)
if certfile:
warnings.warn("SSL only works with host:port, not unix_socket.")
elif host and port:
if certfile:
server_socket = TSSLServerSocket(host=host,
port=port,
client_timeout=client_timeout,
certfile=certfile)
else:
server_socket = TServerSocket(host=host,
port=port,
client_timeout=client_timeout)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
server = TThreadedServer(processor,
server_socket,
iprot_factory=proto_factory,
itrans_factory=trans_factory)
print('Starting Thrift RPC server running @ %s:%s' % (host, port))
try:
server.serve()
except KeyboardInterrupt:
print()
print("Stopping Server from Keyboard Interruption")
exit()
def server(request):
p1 = TProcessor(mux.ThingOneService, DispatcherOne())
p2 = TProcessor(mux.ThingTwoService, DispatcherTwo())
mux_proc = TMultiplexedProcessor()
mux_proc.register_processor("ThingOneService", p1)
mux_proc.register_processor("ThingTwoService", p2)
_server = TThreadedServer(mux_proc, TServerSocket(unix_socket=sock_path),
iprot_factory=TBinaryProtocolFactory(),
itrans_factory=TBufferedTransportFactory())
ps = multiprocessing.Process(target=_server.serve)
ps.start()
time.sleep(0.1)
def fin():
if ps.is_alive():
ps.terminate()
try:
os.remove(sock_path)
except IOError:
pass
request.addfinalizer(fin)
def get_client(thrift_file,
thrift_name,
url,
port,
service_name,
is_multiplexer=False,
timeout=20 * 1000):
'''
获取RPC client 链接
:param thrift_file: thriftpy服务文件路径
:param thrift_name:thritpy定义的类名称 # service 【CarsServices】
:param url:rpc服务ip或域名
:param port:服务端口
:param service_name: 服务名称
:param is_multiplexer:是否是多服务
:return:
'''
try:
my_service = getattr(
thriftpy.load(thrift_file,
module_name=thrift_file.split('/')[-1].replace(
'.', '_')), thrift_name)
if is_multiplexer:
binary_factory = TBinaryProtocolFactory()
dd_factory = TMultiplexedProtocolFactory(binary_factory,
service_name)
client = make_client(my_service,
url,
port,
proto_factory=dd_factory,
timeout=timeout)
else:
client = make_client(my_service, url, port, timeout=timeout)
return client
except Exception as ex:
logger.error()
return None
def get_nimbus_client(env_config=None, host=None, port=None, timeout=7000):
"""Get a Thrift RPC client for Nimbus given project's config file.
:param env_config: The project's parsed config.
:type env_config: `dict`
:param host: The host to use for Nimbus. If specified, `env_config` will
not be consulted.
:type host: `str`
:param port: The port to use for Nimbus. If specified, `env_config` will
not be consulted.
:type port: `int`
:param timeout: The time to wait (in milliseconds) for a response from
Nimbus.
:param timeout: `int`
:returns: a ThriftPy RPC client to use to communicate with Nimbus
"""
if host is None:
host, port = get_nimbus_host_port(env_config)
nimbus_client = make_client(storm_thrift.Nimbus, host=host, port=port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TFramedTransportFactory(),
timeout=timeout)
return nimbus_client
def get_protoco_factory(self):
from thriftpy.protocol import TBinaryProtocolFactory
return TBinaryProtocolFactory().get_protocol
def decode(n, proto_factory=TBinaryProtocolFactory()):
ab = make_addressbook()
encoded = serialize(ab)
for i in range(n):
deserialize(ab, encoded, proto_factory)
def encode(n, proto_factory=TBinaryProtocolFactory()):
for i in range(n):
ab = make_addressbook()
serialize(ab, proto_factory)
import os
import logging
import thriftpy
from thriftpy.rpc import make_server
from thriftpy.protocol import TBinaryProtocolFactory
from thriftpy.transport import TBufferedTransportFactory
# 使用 thriftpy（https://github.com/eleme/thriftpy）的例子
HERE = os.path.abspath(os.path.dirname(__file__))
logging.basicConfig() # 这一步很重要，可以收到Thrift发出来的异常日志
calc_thrift = thriftpy.load(os.path.join(HERE, 'calc.thrift'),
module_name='calc_thrift')
class Dispatcher(object):
def add(self, a, b):
return a + b
server = make_server(calc_thrift.CalcService,
Dispatcher(),
'127.0.0.1',
8300,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory())
print 'serving...'
server.serve()
def make_client(service, host, port, proto_factory=TBinaryProtocolFactory()):
transport = TBufferedTransport(TSocket(host, port))
protocol = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, protocol)
