def handle(self, listener, client, 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) self.notify() except TTransportException: pass 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()
def test_read_long_data(): val = 'z' * 97 * 1024 def serve(): server_sock = TServerSocket( unix_socket="./thriftpy_test.sock") server_sock.listen() client = server_sock.accept() t = TCyBufferedTransport(client) proto.write_val(t, TType.STRING, val) t.flush() p = multiprocessing.Process(target=serve) p.start() time.sleep(0.1) try: sock = TSocket(unix_socket="./thriftpy_test.sock") b = TCyBufferedTransport(sock) b.open() assert val == proto.read_val(b, TType.STRING) sock.close() finally: p.terminate() try: os.remove("./thriftpy_test.sock") except IOError: pass
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) self.notify() except TTransportException: pass 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()
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): 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) elif host and port: 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 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 __getattr__(self, item): socket = TSocket(self.host, self.port) socket.set_timeout(self.timeout) transport = TRANS_FACTORY().get_transport(socket) protocol = PROTO_FACTORY().get_protocol(transport) client = TClient(self.service, protocol) attr = getattr(client, item) return _wrapper_api(attr, transport)
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) protocol = self._protocol_class(self.transport, decode_response=False) self.client = TClient(Hbase, protocol)
def make_client(service, host, port, proto_factory=TBinaryProtocolFactory(), transport_factory=TBufferedTransportFactory(), timeout=None): socket = TSocket(host, port) if timeout: socket.set_timeout(timeout) transport = transport_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() return TClient(service, protocol)
def make_client(service, host, port, proto_factory=TBinaryProtocolFactory(), trans_factory=TBufferedTransportFactory(), timeout=None): socket = TSocket(host, port) if timeout: socket.set_timeout(timeout) transport = trans_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() return TClient(service, protocol)
def client_context(service, host, port, proto_factory=TBinaryProtocolFactory(), transport_factory=TBufferedTransportFactory(), timeout=None): try: socket = TSocket(host, port) if timeout: socket.set_timeout(timeout) transport = transport_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() yield TClient(service, protocol) finally: transport.close()
def client_context(service, host, port, proto_factory=TBinaryProtocolFactory(), trans_factory=TBufferedTransportFactory(), timeout=None): try: socket = TSocket(host, port) if timeout: socket.set_timeout(timeout) transport = trans_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() yield TClient(service, protocol) finally: transport.close()
def make_client(service, host="localhost", port=9090, unix_socket=None, proto_factory=TBinaryProtocolFactory(), trans_factory=TBufferedTransportFactory(), timeout=None): if unix_socket: socket = TSocket(unix_socket=unix_socket) elif host and port: 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 get_new_client(self): """ 轮询在每个ip:port的连接池中获取连接(线程安全) 从当前队列右侧取出ip:port信息,获取client 将连接池对象放回到当前队列的左侧 请求或连接超时时间,默认30秒 :return: """ with self.lock: if self.pool_size < self.maxActive: try: ip = self.load_balance_queue.pop() except IndexError: raise CTECThriftClientError('没有可用的服务提供者列表!') if ip: self.load_balance_queue.appendleft(ip) # 创建新的thrift client t_socket = TSocket(ip.split(':')[0], int(ip.split(':')[1]), socket_timeout=1000 * self.socket_timeout) proto_factory = TBinaryProtocolFactory() trans_factory = TBufferedTransportFactory() transport = trans_factory.get_transport(t_socket) protocol = proto_factory.get_protocol(transport) transport.open() client = TClient(self.service, protocol) self.pool_size += 1 return client else: return None
def test_transport_handle(): from thriftpy._compat import CYTHON if not CYTHON: return from thriftpy.transport import TSocket from thriftpy.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 __create_client(self): socket = TSocket(self.__host, self.__port, socket_timeout=self.__timeout) self.__transport = TCyFramedTransportFactory().get_transport(socket) protocol = TCyBinaryProtocolFactory().get_protocol(self.__transport) self.__client = TClient(recs_thrift.RecommendationsService, protocol)
def client_context(service, host, port, proto_factory=TBinaryProtocolFactory()): try: transport = TBufferedTransport(TSocket(host, port)) protocol = proto_factory.get_protocol(transport) transport.open() yield TClient(service, protocol) finally: transport.close()
def make_client(service, host="localhost", port=9090, unix_socket=None, proto_factory=TBinaryProtocolFactory(), trans_factory=TBufferedTransportFactory(), timeout=None): if unix_socket: socket = TSocket(unix_socket=unix_socket) elif host and port: socket = TSocket(host, port) else: raise ValueError("Either host/port or unix_socket must be provided.") if timeout: socket.set_timeout(timeout) transport = trans_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() return TClient(service, protocol)
def test_exceptions(monkeypatch): import socket from folklore.service import FolkloreService, Processor, \ CloseConnectionError, FolkloreBinaryProtocol from thriftpy.transport import TTransportException, TSocket from thriftpy.protocol.exc import TProtocolException service = FolkloreService() service.api_map = {} service.context.update({ 'client_addr': 'localhost', 'client_port': 1, }) t_exc = TTransportException() t_exc.message = 'end of file' sock = TSocket() sock.sock = socket.socket() mock_close = mock.Mock() monkeypatch.setattr(FolkloreBinaryProtocol, 'close', mock_close) t_exc.type = TTransportException.END_OF_FILE with mock.patch.object(Processor, 'process', side_effect=t_exc): service.run(sock) service.logger = mock.Mock(exception=mock.Mock()) t_exc.type = TTransportException.ALREADY_OPEN with mock.patch.object(Processor, 'process', side_effect=t_exc): service.run(sock) service.logger.exception.assert_called_with(t_exc) p_exc = TProtocolException() p_exc.type = TProtocolException.BAD_VERSION with mock.patch.object(Processor, 'process', side_effect=p_exc): service.run(sock) service.logger.warn.assert_called_with('[%s:%s] protocol error: %s', 'localhost', 1, p_exc) c_exc = CloseConnectionError() with mock.patch.object(Processor, 'process', side_effect=c_exc): service.run(sock) mock_close.assert_called_with()
def __init__(self): super(ThriftLocust, self).__init__() socket = TSocket('127.0.0.1', 9999) proto_factory = TBinaryProtocolFactory() trans_factory = TBufferedTransportFactory() transport = trans_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() hash_thrift = thriftpy.load("hash.thrift", module_name="hash_thrift") self.client = ThriftClient(hash_thrift.HashService, 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 open(self): if self.transport and self.transport.is_open(): logger.debug("transport was opened.") return logger.debug("new transport...") socket = TSocket(host=self.host, port=self.port, socket_timeout=self.timeout) self.transport = self.transport_class(socket) self.protocol = self.protocol_class(self.transport) self.client = TClient(hbase_thrift.Hbase, self.protocol) self.transport.open()
def __init__(self, service, socket_config, service_name=None): trans_socket = TSocket(**socket_config) self.__transport = TBufferedTransportFactory()\ .get_transport(trans_socket) if service_name: protocol_factory = TMultiplexedProtocolFactory( TBinaryProtocolFactory(), service_name) else: protocol_factory = TBinaryProtocolFactory() protocol = protocol_factory.get_protocol(self.__transport) self.__client = TClient(service, protocol) self.__is_open = False
def client_context(service, host="localhost", port=9090, unix_socket=None, proto_factory=TBinaryProtocolFactory(), trans_factory=TBufferedTransportFactory(), timeout=None): if unix_socket: socket = TSocket(unix_socket=unix_socket) elif host and port: socket = TSocket(host, port) else: raise ValueError("Either host/port or unix_socket must be provided.") if timeout: socket.set_timeout(timeout) try: transport = trans_factory.get_transport(socket) protocol = proto_factory.get_protocol(transport) transport.open() yield TClient(service, protocol) finally: transport.close()
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, tracker) yield client_class(*args) finally: trans.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: 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 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): 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) try: while True: self.app.thrift_app.process(iprot, oprot) except TTransportException: pass except Exception as e: logger.exception(e) finally: itrans.close() otrans.close()
def init_client(self, ip, port): """Establish a connection to thrift server of ZLP Service. Init client opening sockets and init events handler. Args: ip (str): ipv6 network address of ZLP-Service port (str): port number on which ZLP-Service listens for requests """ client_socket = TSocket(ip, port, socket_family=socket.AF_INET, socket_timeout=50000) transport = TBufferedTransportFactory().get_transport(client_socket) protocol = TBinaryProtocolFactory().get_protocol(transport) transport.open() super().__init__(self.thrift_interface.ServiceInterface, 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.transport_factory.get_transport(result) otrans = self.app.transport_factory.get_transport(result) iprot = self.app.protocol_factory.get_protocol(itrans) oprot = self.app.protocol_factory.get_protocol(otrans) processor = self.get_thrift_processor() try: while True: self.handle_processor_receive(listener, client, addr) processor.process(iprot, oprot) self.notify() except TTransportException: pass # except thrift.Thrift.TException as e: # self.log.error(e.message) 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 _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) if self.use_kerberos: self.transport = TSaslClientTransport(self.transport, self.host, self.sasl_service_name) sasl_auth = 'GSSAPI' def sasl_factory(): sasl_client = sasl.Client() sasl_client.setAttr('host', self.host) sasl_client.setAttr('service', self.sasl_service_name) sasl_client.init() return sasl_client self.transport = TSaslClientTransport(sasl_factory, sasl_auth, socket) protocol = self._protocol_class(self.transport, decode_response=False) self.client = TClient(Hbase, protocol)
def make_client(service, host, port, proto_factory=TBinaryProtocolFactory()): transport = TBufferedTransport(TSocket(host, port)) protocol = proto_factory.get_protocol(transport) transport.open() return TClient(service, protocol)