def get_new_client(self):
"""
轮询在每个ip:port的连接池中获取连接（线程安全）
从当前队列右侧取出ip:port信息，获取client
将连接池对象放回到当前队列的左侧
请求或连接超时时间，默认30秒
:return:
"""
with self.lock:
if self.pool_size < self.maxActive:
try:
ip = self.load_balance_queue.pop()
except IndexError:
raise CTECThriftClientError('没有可用的服务提供者列表！')
if ip:
self.load_balance_queue.appendleft(ip)
# 创建新的thrift client
t_socket = TSocket(ip.split(':')[0], int(ip.split(':')[1]),
socket_timeout=1000 * self.socket_timeout)
proto_factory = TBinaryProtocolFactory()
trans_factory = TBufferedTransportFactory()
transport = trans_factory.get_transport(t_socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
client = TClient(self.service, protocol)
self.pool_size += 1
return client
else:
return None
class ThriftClient(object):
"""
Thrift Client类封装。
"""
def __init__(self, service, socket_config, service_name=None):
trans_socket = TSocket(**socket_config)
self.__transport = TBufferedTransportFactory()\
.get_transport(trans_socket)
if service_name:
protocol_factory = TMultiplexedProtocolFactory(
TBinaryProtocolFactory(), service_name)
else:
protocol_factory = TBinaryProtocolFactory()
protocol = protocol_factory.get_protocol(self.__transport)
self.__client = TClient(service, protocol)
self.__is_open = False
def __del__(self):
if self.__is_open:
self.__transport.close()
def __getattr__(self, item):
if not self.__is_open:
self.__transport.open()
self.__is_open = True
return getattr(self.__client, item)
def __init__(self):
super(ThriftLocust, self).__init__()
socket = TSocket('127.0.0.1', 9999)
proto_factory = TBinaryProtocolFactory()
trans_factory = TBufferedTransportFactory()
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
hash_thrift = thriftpy.load("hash.thrift", module_name="hash_thrift")
self.client = ThriftClient(hash_thrift.HashService, protocol)
def __init__(self, service, socket_config, service_name=None):
trans_socket = TSocket(**socket_config)
self.__transport = TBufferedTransportFactory()\
.get_transport(trans_socket)
if service_name:
protocol_factory = TMultiplexedProtocolFactory(
TBinaryProtocolFactory(), service_name)
else:
protocol_factory = TBinaryProtocolFactory()
protocol = protocol_factory.get_protocol(self.__transport)
self.__client = TClient(service, protocol)
self.__is_open = False
def client(client_class=TTrackedClient, port=6029):
socket = TSocket("localhost", port)
try:
trans = TBufferedTransportFactory().get_transport(socket)
proto = TBinaryProtocolFactory().get_protocol(trans)
trans.open()
args = [addressbook.AddressBookService, proto]
if client_class.__name__ == TTrackedClient.__name__:
args.insert(0, tracker)
yield client_class(*args)
finally:
trans.close()
def init_client(self, ip, port):
"""Establish a connection to thrift server of ZLP Service. Init client opening sockets and init events handler.
Args:
ip (str): ipv6 network address of ZLP-Service
port (str): port number on which ZLP-Service listens for requests
"""
client_socket = TSocket(ip,
port,
socket_family=socket.AF_INET,
socket_timeout=50000)
transport = TBufferedTransportFactory().get_transport(client_socket)
protocol = TBinaryProtocolFactory().get_protocol(transport)
transport.open()
super().__init__(self.thrift_interface.ServiceInterface, protocol)
def make_server(service,
handler,
host="localhost",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
client_timeout=3000,
certfile=None):
processor = TProcessor(service, handler)
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)
return server
def client_context(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)
try:
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
yield TClient(service, protocol)
finally:
transport.close()
def server(request):
p1 = TProcessor(mux.ThingOneService, DispatcherOne())
p2 = TProcessor(mux.ThingTwoService, DispatcherTwo())
mux_proc = TMultiplexingProcessor()
mux_proc.register_processor(p1)
mux_proc.register_processor(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 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"""
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 client_context(service, host="localhost", port=9090, unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
timeout=None, socket_timeout=3000, connect_timeout=3000,
cafile=None, ssl_context=None, certfile=None, keyfile=None):
if timeout:
warnings.warn("`timeout` deprecated, use `socket_timeout` and "
"`connect_timeout` instead.")
socket_timeout = connect_timeout = timeout
if unix_socket:
socket = TSocket(unix_socket=unix_socket,
connect_timeout=connect_timeout,
socket_timeout=socket_timeout)
elif host and port:
socket = TSocket(host, port,
connect_timeout=connect_timeout,
socket_timeout=socket_timeout)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
try:
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
yield TClient(service, protocol)
finally:
transport.close()
def make_client(service,
host="localhost",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
timeout=None,
cafile=None,
ssl_context=None,
certfile=None,
keyfile=None):
if unix_socket:
socket = TSocket(unix_socket=unix_socket)
if certfile:
warnings.warn("SSL only works with host:port, not unix_socket.")
elif host and port:
if cafile or ssl_context:
socket = TSSLSocket(host,
port,
socket_timeout=timeout,
cafile=cafile,
certfile=certfile,
keyfile=keyfile,
ssl_context=ssl_context)
else:
socket = TSocket(host, port, socket_timeout=timeout)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, protocol)
def _make_server(app, host, port, daemon=True):
processor = TProcessor(app.service, app)
server_socket = TServerSocket(host=host, port=port)
server = TThreadedServer(processor, server_socket,
iprot_factory=TBinaryProtocolFactory(),
itrans_factory=TBufferedTransportFactory(),
daemon=daemon)
return server
def create_thrift_server(service, handler, socket_config,
server_cls=TThreadedServer):
"""
创建Thrift Server对象。
"""
return server_cls(TProcessor(service, handler), # processor
TServerSocket(**socket_config), # transport
TBufferedTransportFactory(), # transportFactory
TBinaryProtocolFactory()) # protocolFactory
def make_server(service, handler, host, port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory()):
processor = TProcessor(service, handler)
server_socket = TServerSocket(host=host, port=port)
server = TThreadedServer(processor, server_socket,
iprot_factory=proto_factory,
itrans_factory=trans_factory)
return server
def make_client(service, host, port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
timeout=None):
socket = TSocket(host, port)
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 gen_server(port=16029, tracker=tracker, processor=TTrackedProcessor):
args = [processor, addressbook.AddressBookService, Dispatcher()]
if tracker:
args.insert(1, tracker)
processor = TProcessorFactory(*args)
server_socket = TServerSocket(host="localhost", port=port)
server = TSampleServer(processor, server_socket,
prot_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory())
ps = multiprocessing.Process(target=server.serve)
ps.start()
return ps, server
def main():
dd_proc = TProcessor(dd_thrift.DingService, DingDispatcher())
pp_proc = TProcessor(pp_thrift.PingService, PingDispatcher())
mux_proc = TMultiplexedProcessor()
mux_proc.register_processor(DD_SERVICE_NAME, dd_proc)
mux_proc.register_processor(PP_SERVICE_NAME, pp_proc)
server = TThreadedServer(mux_proc, TServerSocket(),
iprot_factory=TBinaryProtocolFactory(),
itrans_factory=TBufferedTransportFactory())
server.serve()
def __init__(self,
processor,
trans,
itrans_factory=None,
iprot_factory=None,
otrans_factory=None,
oprot_factory=None):
self.processor = processor
self.trans = trans
self.itrans_factory = itrans_factory or TBufferedTransportFactory()
self.iprot_factory = iprot_factory or TBinaryProtocolFactory()
self.otrans_factory = otrans_factory or self.itrans_factory
self.oprot_factory = oprot_factory or self.iprot_factory
def client_context(service, host, port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
timeout=None):
try:
socket = TSocket(host, port)
if timeout:
socket.set_timeout(timeout)
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
yield TClient(service, protocol)
finally:
transport.close()
def __init__(self, ip="10.60.118.158", port=9888):
self.ip = ip
self.port = port
try:
self.client = make_client(
interface_thrift.Suggestion,
self.ip,
self.port,
trans_factory=TBufferedTransportFactory(),
timeout=100000)
#trans_factory=TFramedTransportFactory(), timeout=10000)
print(self.client)
except Exception as err:
print err
traceback.print_exc()
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, socket_timeout=timeout)
else:
raise ValueError("Either host/port or unix_socket must be provided.")
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, protocol)
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 __init__(self, service, host, port, proto_factory=None, trans_factory=None):
if not proto_factory:
from thriftpy.protocol import TBinaryProtocolFactory
proto_factory_value = TBinaryProtocolFactory()
else:
proto_factory_value = proto_factory
if not trans_factory:
from thriftpy.transport import TBufferedTransportFactory
trans_factory_value = TBufferedTransportFactory()
else:
trans_factory_value = trans_factory
self.client = make_client(
service, host, port,
proto_factory=proto_factory_value,
trans_factory=trans_factory_value
)
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 client(client_class=TTrackedClient, port=PORT):
socket = TSocket("localhost", port)
try:
trans = TBufferedTransportFactory().get_transport(socket)
proto = TBinaryProtocolFactory().get_protocol(trans)
trans.open()
args = [addressbook.AddressBookService, proto]
if client_class.__name__ == TTrackedClient.__name__:
args.insert(0, tracker)
yield client_class(*args)
finally:
trans.close()
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()
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 get_transport_factory(self):
from thriftpy.transport import TBufferedTransportFactory
return TBufferedTransportFactory().get_transport
