def make_server(service,
handler,
host,
port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory()):
processor = TProcessor(service, handler)
server = THttpServer(processor, (host, port),
itrans_factory=trans_factory,
iprot_factory=proto_factory)
return server
def gen_server(port, 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 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)
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,
connect_timeout=connect_timeout,
socket_timeout=socket_timeout,
cafile=cafile,
certfile=certfile,
keyfile=keyfile,
ssl_context=ssl_context)
else:
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 __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
class Connection:
# TODO: Auto generate these?
THRIFT_TRANSPORTS = dict(
buffered=TBufferedTransportFactory(),
framed=TFramedTransportFactory(),
)
THRIFT_PROTOCOLS = dict(
binary=TBinaryProtocolFactory(decode_response=False),
compact=TCompactProtocolFactory(decode_response=False),
)
THRIFT_CLIENTS = dict(
socket=make_client,
http=make_http_client,
)
def _autoconnect(self):
self.open()
def make_client(service, host='localhost', port=9090, path='', scheme='http',
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
ssl_context_factory=None,
timeout=DEFAULT_HTTP_CLIENT_TIMEOUT_MS, url=''):
if url:
parsed_url = urllib.parse.urlparse(url)
host = parsed_url.hostname or host
port = parsed_url.port or port
scheme = parsed_url.scheme or scheme
path = parsed_url.path or path
uri = HTTP_URI.format(scheme=scheme, host=host, port=port, path=path)
http_socket = THttpClient(uri, timeout, ssl_context_factory)
transport = trans_factory.get_transport(http_socket)
iprot = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, iprot)
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, SampleTracker("test_client", "test_server"))
yield client_class(*args)
finally:
trans.close()
def make_client(service,
host="localhost",
port=9090,
unix_socket=None,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TBufferedTransportFactory(),
timeout=3000,
cafile=None,
ssl_context=None,
certfile=None,
keyfile=None,
url="",
socket_family=socket.AF_INET):
if url:
parsed_url = urllib.parse.urlparse(url)
host = parsed_url.hostname or host
port = parsed_url.port or port
if unix_socket:
socket = TSocket(unix_socket=unix_socket, socket_timeout=timeout)
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,
socket_family=socket_family,
cafile=cafile,
certfile=certfile,
keyfile=keyfile,
ssl_context=ssl_context)
else:
socket = TSocket(host,
port,
socket_family=socket_family,
socket_timeout=timeout)
else:
raise ValueError(
"Either host/port or unix_socket or url must be provided.")
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, protocol)
def get_transport_factory(self):
from thriftpy2.transport import TBufferedTransportFactory
return TBufferedTransportFactory().get_transport
