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()
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()
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)
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()
def __init__(self, processor, *args, **kwargs):
self.processor = processor
self.transport_factory = TBufferedTransportFactory()
self.protocol_factory = THeaderProtocolFactory()
super(GeventServer, self).__init__(*args, **kwargs)
