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