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)