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 test_read_long_data():
val = 'z' * 97 * 1024
unix_sock = "/tmp/thriftpy_test.sock"
def serve():
server_sock = TServerSocket(unix_socket=unix_sock)
server_sock.listen()
client = server_sock.accept()
t = TCyBufferedTransport(client)
proto.write_val(t, TType.STRING, val)
t.flush()
# wait for client to read
time.sleep(1)
p = multiprocessing.Process(target=serve)
p.start()
time.sleep(0.1)
try:
sock = TSocket(unix_socket=unix_sock)
b = TCyBufferedTransport(sock)
b.open()
assert val == proto.read_val(b, TType.STRING)
sock.close()
finally:
p.terminate()
try:
os.remove(unix_sock)
except IOError:
pass
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,
url=""):
if url:
parsed_url = urllib.parse.urlparse(url)
host = parsed_url.hostname or host
port = parsed_url.port or port
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 or url 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 handle(self, listener, client, addr):
self.cfg.on_connected(self, addr)
if self.app.cfg.thrift_client_timeout is not None:
client.settimeout(self.app.cfg.thrift_client_timeout)
result = TSocket()
result.set_handle(client)
try:
itrans = self.app.tfactory.get_transport(result)
otrans = self.app.tfactory.get_transport(result)
iprot = self.app.pfactory.get_protocol(itrans)
oprot = self.app.pfactory.get_protocol(otrans)
processor = self.get_thrift_processor()
try:
while True:
self.nr += 1
if self.alive and (
self.nr >= self.max_requests or
(self.cfg.worker_timeout
and int(self.tmp.last_update()) -
int(os.fstat(self.tmp.fileno()).st_mtime) >
self.cfg.worker_timeout)):
self.log.info(
"Autorestarting worker after current process.")
self.alive = False
processor.process(iprot, oprot)
except TTransportException:
pass
except (TProtocolException, ProtocolError) as err:
self.log.warning("Protocol error, is client(%s) correct? %s", addr,
err)
except TDecodeException as err:
self.log.exception('%r: %r', addr, err)
self.cfg.on_tdecode_exception(err)
except socket.timeout:
self.log.warning('Client timeout: %r', addr)
except socket.error as e:
if e.args[0] == errno.ECONNRESET:
self.log.debug('%r: %r', addr, e)
elif e.args[0] == errno.EPIPE:
self.log.warning('%r: %r', addr, e)
else:
self.log.exception('%r: %r', addr, e)
except Exception as e:
self.log.exception('%r: %r', addr, e)
finally:
itrans.close()
otrans.close()
self.cfg.post_connect_closed(self)
def _refresh_thrift_client(self):
"""Refresh the Thrift socket, transport, and client."""
socket = TSocket(host=self.host, port=self.port, socket_timeout=self.timeout)
self.transport = self._transport_class(socket)
protocol = self._protocol_class(self.transport, decode_response=False)
self.client = TClient(Hbase, protocol)
def test_transport_handle():
from thriftpy2._compat import CYTHON
if not CYTHON:
return
from thriftpy2.transport import TSocket
from thriftpy2.transport.memory import TCyMemoryBuffer
s = TSocket()
s.set_handle('the sock')
assert TCyBufferedTransport(s).sock == 'the sock'
assert TCyFramedTransport(s).sock == 'the sock'
assert TCyMemoryBuffer().sock is None
assert TCyBufferedTransport(TCyFramedTransport(s)).sock == 'the sock'
assert TCyBufferedTransport(TCyMemoryBuffer()).sock is None
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 handle(self, listener, client, addr):
self.cfg.on_connected(self, addr)
if self.app.cfg.thrift_client_timeout is not None:
client.settimeout(self.app.cfg.thrift_client_timeout)
result = TSocket()
result.set_handle(client)
try:
itrans = self.app.tfactory.get_transport(result)
otrans = self.app.tfactory.get_transport(result)
iprot = self.app.pfactory.get_protocol(itrans)
oprot = self.app.pfactory.get_protocol(otrans)
processor = self.get_thrift_processor()
try:
while True:
processor.process(iprot, oprot)
except TTransportException:
pass
except (TProtocolException, ProtocolError) as err:
self.log.warning(
"Protocol error, is client(%s) correct? %s", addr, err
)
except TDecodeException as err:
self.log.exception('%r: %r', addr, err)
self.cfg.on_tdecode_exception(err)
except socket.timeout:
self.log.warning('Client timeout: %r', addr)
except socket.error as e:
if e.args[0] == errno.ECONNRESET:
self.log.debug('%r: %r', addr, e)
elif e.args[0] == errno.EPIPE:
self.log.warning('%r: %r', addr, e)
else:
self.log.exception('%r: %r', addr, e)
except Exception as e:
self.log.exception('%r: %r', addr, e)
finally:
itrans.close()
otrans.close()
self.cfg.post_connect_closed(self)
def handle(self, listener, client, addr):
self.cfg.on_connected(self, addr)
if self.app.cfg.thrift_client_timeout is not None:
client.settimeout(self.app.cfg.thrift_client_timeout)
result = TSocket()
result.set_handle(client)
try:
itrans = self.app.tfactory.get_transport(result)
otrans = self.app.tfactory.get_transport(result)
iprot = self.app.pfactory.get_protocol(itrans)
oprot = self.app.pfactory.get_protocol(otrans)
processor = self.get_thrift_processor()
try:
while True:
self.nr += 1
if self.alive and self.nr >= self.max_requests:
self.log.info(
"Autorestarting worker after current process.")
self.alive = False
processor.process(iprot, oprot)
self.notify()
except TTransportException:
pass
except TDecodeException as err:
self.log.exception('%r: %r', addr, err)
self.cfg.on_tdecode_exception(err)
except socket.timeout:
self.log.warning('Client timeout: %r', addr)
except socket.error as e:
if e.args[0] == errno.ECONNRESET:
self.log.debug(e)
else:
self.log.exception(e)
except Exception as e:
self.log.exception(e)
finally:
itrans.close()
otrans.close()
self.cfg.post_connect_closed(self)
def handle(self, listener, client, addr):
self.cfg.on_connected(self, addr)
if self.app.cfg.thrift_client_timeout is not None:
client.settimeout(self.app.cfg.thrift_client_timeout)
result = TSocket()
result.set_handle(client)
try:
itrans = self.app.tfactory.get_transport(result)
otrans = self.app.tfactory.get_transport(result)
iprot = self.app.pfactory.get_protocol(itrans)
oprot = self.app.pfactory.get_protocol(otrans)
processor = self.get_thrift_processor()
try:
while True:
processor.process(iprot, oprot)
except TTransportException:
pass
except (TProtocolException, ProtocolError) as err:
self.log.warning("Protocol error, is client(%s) correct? %s", addr,
err)
except TDecodeException as err:
self.log.exception('%r: %r', addr, err)
self.cfg.on_tdecode_exception(err)
except socket.timeout:
self.log.warning('Client timeout: %r', addr)
except socket.error as e:
if e.args[0] == errno.ECONNRESET:
self.log.debug('%r: %r', addr, e)
elif e.args[0] == errno.EPIPE:
self.log.warning('%r: %r', addr, e)
else:
self.log.exception('%r: %r', addr, e)
except Exception as e:
self.log.exception('%r: %r', addr, e)
finally:
itrans.close()
otrans.close()
self.cfg.post_connect_closed(self)
def _refresh_thrift_client(self):
"""Refresh the Thrift socket, transport, and client."""
socket = TSocket(self.host, self.port)
if self.timeout is not None:
socket.set_timeout(self.timeout)
self.transport = self._transport_class(socket)
if self.use_kerberos:
self.transport = TSaslClientTransport(self.transport, self.host, self.sasl_service_name)
protocol = self._protocol_class(self.transport, decode_response=False)
self.client = TClient(Hbase, protocol)
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 _refresh_thrift_client(self):
"""Refresh the Thrift sockets, transports, and clients."""
self.subconnections = []
for server in self.servers:
socket = TSocket(host=server["host"],
port=server["port"],
socket_timeout=self.timeout)
transport = self._transport_class(socket)
protocol = self._protocol_class(transport, decode_response=False)
client = TClient(Hbase, protocol)
subconnection = Subconnection(server=server,
transport=transport,
client=client,
status=0)
self.subconnections.append(subconnection)
self.client = HAClient(self.subconnections)
def _refresh_thrift_client(self):
"""Refresh the Thrift socket, transport, and client."""
socket = TSocket(self.host, self.port)
if self.timeout is not None:
socket.set_timeout(self.timeout)
self.transport = self._transport_class(socket)
if self.use_kerberos:
self.transport = TSaslClientTransport(
self.transport,
self.host,
self.sasl_service_name,
generate_tickets=self.generate_tickets,
using_keytab=self.using_keytab,
principal=self.principal,
keytab_file=self.keytab_file,
ccache_file=self.ccache_file,
password=self.password)
protocol = self._protocol_class(self.transport, decode_response=False)
self.client = TClient(Hbase, protocol)
