class GeventServer(StreamServer): def __init__(self, processor, *args, **kwargs): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory() super(GeventServer, self).__init__(*args, **kwargs) def serve_forever(self, stop_timeout=None): signal.signal(signal.SIGINT, lambda sig, frame: self.stop()) signal.signal(signal.SIGTERM, lambda sig, frame: self.stop()) super(GeventServer, self).serve_forever(stop_timeout=stop_timeout) def handle(self, client_socket, address): client = TSocket() client.setHandle(client_socket) itrans = self.transport_factory.getTransport(client) iprot = self.protocol_factory.getProtocol(itrans) otrans = self.transport_factory.getTransport(client) oprot = self.protocol_factory.getProtocol(otrans) server_context = TRpcConnectionContext(client, iprot, oprot) try: while self.started: self.processor.process(iprot, oprot, server_context) except TTransportException: pass finally: itrans.close() otrans.close()
def __init__(self, processor: TProcessor, *args: Any, **kwargs: Any): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory( # allow non-headerprotocol clients to talk with us allowed_client_types=[ THeaderClientType.HEADERS, THeaderClientType.FRAMED_BINARY, THeaderClientType.UNFRAMED_BINARY, ]) super().__init__(*args, **kwargs)
def __init__(self, processor, *args, **kwargs): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory( # allow non-headerprotocol clients to talk with us client_types=[ THeaderTransport.HEADERS_CLIENT_TYPE, THeaderTransport.FRAMED_DEPRECATED, THeaderTransport.UNFRAMED_DEPRECATED, ], ) super(GeventServer, self).__init__(*args, **kwargs)
def start_server_process(self): """ Starts a test server, returns the (pid, port) pair. The server needs to be in a subprocess because we need to run a TThreadedServer for the concurrency tests. And the only way to stop a TThreadedServer is to kill it. So we can't just use a thread. """ self.pid = os.fork() if self.pid != 0: logging.info("Started SimpleThriftServer (pid %s) on port %s" % (self.pid, self.port)) self._ensure_online() return # Child process runs the thrift server loop try: processor = TestService.Processor(self) transport = TSocket.TServerSocket(self.port) server = TServer.TThreadedServer(processor, transport, TBufferedTransportFactory(), TBinaryProtocolFactory()) server.serve() except: sys.exit(1)
class GeventServer(StreamServer): def __init__(self, processor: TProcessor, *args: Any, **kwargs: Any): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory( # allow non-headerprotocol clients to talk with us allowed_client_types=[ THeaderClientType.HEADERS, THeaderClientType.FRAMED_BINARY, THeaderClientType.UNFRAMED_BINARY, ]) super().__init__(*args, **kwargs) # pylint: disable=method-hidden,unused-argument def handle(self, client_socket: socket.socket, address: Address) -> None: client = TSocket() client.setHandle(client_socket) trans = self.transport_factory.getTransport(client) prot = self.protocol_factory.getProtocol(trans) try: while self.started: self.processor.process(prot, prot) except TTransportException: pass finally: trans.close()
class GeventServer(StreamServer): def __init__(self, processor, *args, **kwargs): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory( # allow non-headerprotocol clients to talk with us allowed_client_types=[ THeaderClientType.HEADERS, THeaderClientType.FRAMED_BINARY, THeaderClientType.UNFRAMED_BINARY, ], ) super(GeventServer, self).__init__(*args, **kwargs) def serve_forever(self, stop_timeout=None): signal.signal(signal.SIGINT, lambda sig, frame: self.stop()) signal.signal(signal.SIGTERM, lambda sig, frame: self.stop()) super(GeventServer, self).serve_forever(stop_timeout=stop_timeout) # pylint: disable=method-hidden def handle(self, client_socket, _): client = TSocket() client.setHandle(client_socket) trans = self.transport_factory.getTransport(client) prot = self.protocol_factory.getProtocol(trans) try: while self.started: self.processor.process(prot, prot) except TTransportException: pass finally: trans.close()
def main(): """ main() loop, called from jobsubd management command. """ LOG.info("Starting daemon on port %s" % PORT) sock = TServerSocket(PORT) sock.host = HOST TThreadedServer(JobSubmissionService.Processor(JobSubmissionServiceImpl()), sock, TBufferedTransportFactory(), TBinaryProtocolFactory()).serve()
class GeventServer(StreamServer): def __init__(self, processor, *args, **kwargs): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory( # allow non-headerprotocol clients to talk with us client_types=[ THeaderTransport.HEADERS_CLIENT_TYPE, THeaderTransport.FRAMED_DEPRECATED, THeaderTransport.UNFRAMED_DEPRECATED, ], ) super(GeventServer, self).__init__(*args, **kwargs) def serve_forever(self, stop_timeout=None): signal.signal(signal.SIGINT, lambda sig, frame: self.stop()) signal.signal(signal.SIGTERM, lambda sig, frame: self.stop()) super(GeventServer, self).serve_forever(stop_timeout=stop_timeout) # pylint: disable=method-hidden def handle(self, client_socket, _): client = TSocket() client.setHandle(client_socket) itrans = self.transport_factory.getTransport(client) iprot = self.protocol_factory.getProtocol(itrans) otrans = self.transport_factory.getTransport(client) oprot = self.protocol_factory.getProtocol(otrans) server_context = TRpcConnectionContext(client, iprot, oprot) try: while self.started: self.processor.process(iprot, oprot, server_context) except TTransportException: pass finally: itrans.close() otrans.close()
def __init__(self, processor, *args, **kwargs): self.processor = processor self.transport_factory = TBufferedTransportFactory() self.protocol_factory = THeaderProtocolFactory() super(GeventServer, self).__init__(*args, **kwargs)
# coding=utf-8 import inspect import functools import time import logging from thrift.protocol.TBinaryProtocol import TBinaryProtocolAcceleratedFactory from thrift.transport.TTransport import TBufferedTransportFactory from thrift.transport.TSocket import TSocket logger = logging.getLogger(__name__) DEFAULT_THRIFT_PROTOCOL_FACTORY = TBinaryProtocolAcceleratedFactory() DEFAULT_THRIFT_TRANSPORT_FACTORY = TBufferedTransportFactory() SECS_FOR_DISCONNECT = 10 REQUEST_NUM_FOR_DISCONNECT = 1 class EnsureConnectionClient(type): def __new__(mcs, class_name, class_bases, class_dict): thrift_client_class = class_bases[0] # thrift client def __init__(self, host_selector, req_timeout=5000, socket_connection_timeout=1000, retry_count=3, protocol_factory=DEFAULT_THRIFT_PROTOCOL_FACTORY, transport_factory=DEFAULT_THRIFT_TRANSPORT_FACTORY): self._host_selector = host_selector # 选择host host = self._host_selector.get_host() ip, port = host.split(':') self._ip = ip
sys.path.append( os.path.abspath(os.path.dirname(os.path.abspath( os.path.dirname(__file__))))) sys.path.append( os.path.abspath( os.path.abspath(os.path.dirname(__file__)) + os.sep + "gen-py")) from thrift.transport.TSocket import TServerSocket from thrift.protocol.TBinaryProtocol import TBinaryProtocolAcceleratedFactory from thrift.transport.TTransport import TBufferedTransportFactory from thrift.server.TProcessPoolServer import TProcessPoolServer from example.Example import Processor class Handler(object): def add(self, a, b): return a + b if __name__ == "__main__": handler = Handler() processor = Processor(handler) transport = TServerSocket(port=20000) tfactory = TBufferedTransportFactory() protocol = TBinaryProtocolAcceleratedFactory() server = TProcessPoolServer(processor, transport, tfactory, protocol) server.setNumWorkers(10) server.serve()