def test_after_flushd_write_then_read(self): buff = TTransport.TMemoryBuffer() trans = TTransport.TBufferedTransportFactory().getTransport(buff) zlib_trans = TZlibTransport.TZlibTransport(trans) data_w_1 = "hello thrift !@#" * 50 zlib_trans.write(data_w_1.encode('utf-8')) zlib_trans.flush() data_w_2 = "{'name': 'thrift', 1: ['abcd' , 233, ('a','c')]}" * 20 zlib_trans.write(data_w_2.encode('utf-8')) zlib_trans.flush() value = buff.getvalue() zlib_trans.close() buff = TTransport.TMemoryBuffer(value) trans = TTransport.TBufferedTransportFactory().getTransport(buff) zlib_trans = TZlibTransport.TZlibTransport(trans) data_r = zlib_trans.read(len(data_w_1) + len(data_w_2)) zlib_trans.close() try: self.assertEqual(data_w_1 + data_w_2, data_r.decode('utf-8')) self.assertEqual( len(data_w_1) + len(data_w_2), len(data_r.decode('utf-8'))) except AssertionError: raise
def setUp(self): if options.http_path: self.transport = THttpClient.THttpClient(options.host, port=options.port, path=options.http_path) else: if options.ssl: from thrift.transport import TSSLSocket socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False) else: socket = TSocket.TSocket(options.host, options.port) # frame or buffer depending upon args self.transport = TTransport.TBufferedTransport(socket) if options.trans == 'framed': self.transport = TTransport.TFramedTransport(socket) elif options.trans == 'buffered': self.transport = TTransport.TBufferedTransport(socket) elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) if options.zlib: self.transport = TZlibTransport.TZlibTransport( self.transport, 9) self.transport.open() protocol = self.protocol_factory.getProtocol(self.transport) self.client = ThriftTest.Client(protocol)
def Connect(self, host, port, use_zlib=True, serialise_api=False): self.transport = TTransport.TBufferedTransport(TSocket.TSocket(host, port)) if use_zlib: self.transport = TZlibTransport.TZlibTransport(self.transport) self.client = RunTimeEnvironment.Client(TBinaryProtocol.TBinaryProtocol(self.transport)) # post apply decorators self.client.design_load = RteReturnHandler('Loading firmware failed')(self.client.design_load) self.client.design_unload = RteReturnHandler('Unloading firmware failed')(self.client.design_unload) self.client.design_reconfig = RteReturnHandler('Reload of user config failed')(self.client.design_reconfig) self.client.sys_log_level_set = RteReturnHandler('Set log level failed')(self.client.sys_log_level_set) self.client.table_entry_add = RteReturnHandler('Adding table entry failed')(self.client.table_entry_add) self.client.table_entry_edit = RteReturnHandler('Editing table entry failed')(self.client.table_entry_edit) self.client.table_entry_delete = RteReturnHandler('Deleting table entry failed')(self.client.table_entry_delete) self.client.p4_counter_clear = RteReturnHandler('P4 counter clear failed')(self.client.p4_counter_clear) self.client.p4_counter_clear_all = RteReturnHandler('P4 counter clear allfailed')(self.client.p4_counter_clear_all) self.client.sys_counter_clear_all = RteReturnHandler('System counter clear all failed')(self.client.sys_counter_clear_all) self.client.register_clear = RteReturnHandler('Register clear failed')(self.client.register_clear) self.client.register_field_set = RteReturnHandler('Register field set failed')(self.client.register_field_set) self.client.register_set = RteReturnHandler('Register set failed')(self.client.register_set) self.client.mcast_config_set = RteReturnHandler('Multicast config set failed')(self.client.mcast_config_set) self.client.meter_config_set = RteReturnHandler('Meter config set failed')(self.client.meter_config_set) self.client.digest_deregister = RteReturnHandler('Digest deregister failed')(self.client.digest_deregister) self.client.parser_value_set_add = RteReturnHandler('Parser value set add failed')(self.client.parser_value_set_add) self.client.parser_value_set_clear = RteReturnHandler('Parser value set clear failed')(self.client.parser_value_set_clear) try: self.transport.open() except TException, err: raise RTECommError, "Communication failure with RPC server: %s"%str(err)
def setUp(self): if options.http_path: self.transport = THttpClient.THttpClient(options.host, port=options.port, path=options.http_path) else: if options.ssl: from thrift.transport import TSSLSocket socket = TSSLSocket.TSSLSocket(options.host, options.port, validate=False) else: socket = TSocket.TSocket(options.host, options.port) # frame or buffer depending upon args if options.framed: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) if options.zlib: self.transport = TZlibTransport.TZlibTransport( self.transport, 9) self.transport.open() protocol = self.protocol_factory.getProtocol(self.transport) if options.multiple: p = TMultiplexedProtocol.TMultiplexedProtocol( protocol, "ThriftTest") self.client = ThriftTest.Client(p) p = TMultiplexedProtocol.TMultiplexedProtocol( protocol, "SecondService") self.client2 = SecondService.Client(p) else: self.client = ThriftTest.Client(protocol) self.client2 = None
def __initialize(self): pfactory = ThriftServer.__protocol_type[self._protocol]() if self._server_type == 'http': self._server = THttpServer.THttpServer(\ self._processor, (self._ip, self._port), pfactory) return transport = TSocket.TServerSocket(self._ip, self._port) if self._transport == 'zlib': transport = TZlibTransport.TZlibTransport(transport) tfactory = TZlibTransport.TZlibTransportFactory() else: tfactory = TTransport.TBufferedTransportFactory() if self._server_type == 'noblock': self._server = TNonblockingServer.TNonblockingServer(\ self._processor, transport, inputProtocolFactory=pfactory) else: self._server_type = ThriftServer.__server_type.get(self._server_type, 'TSimpleServer') ServerClass = getattr(TServer, self._server_type) self._server = ServerClass(self._processor, transport, tfactory, pfactory)
def test_write_then_read(self): buff = TTransport.TMemoryBuffer() trans = TTransport.TBufferedTransportFactory().getTransport(buff) zlib_trans = TZlibTransport.TZlibTransport(trans) data_w = generate_random_buff() zlib_trans.write(data_w.encode('utf-8')) zlib_trans.flush() value = buff.getvalue() zlib_trans.close() buff = TTransport.TMemoryBuffer(value) trans = TTransport.TBufferedTransportFactory().getTransport(buff) zlib_trans = TZlibTransport.TZlibTransport(trans) data_r = zlib_trans.read(len(data_w)) zlib_trans.close() try: self.assertEqual(data_w, data_r.decode('utf-8')) self.assertEqual(len(data_w), len(data_r.decode('utf-8'))) except AssertionError: raise
def _get_rte_client(self, cfg): transport = TZlibTransport.TZlibTransport( TTransport.TBufferedTransport( TSocket.TSocket(cfg["stamper_ssh"], cfg["thrift_port"]))) rte_client = RunTimeEnvironment.Client( TBinaryProtocol.TBinaryProtocol(transport)) try: transport.open() except TTransport.TTransportException: self.execute_ssh(cfg, "sudo systemctl start nfp-sdk6-rte.service") time.sleep(1) transport.open() return rte_client
def set_factory(self): if settings.THRIFTSERVER_BUFFERED: self._tfactory = TTransport.TBufferedTransportFactory() if settings.THRIFTSERVER_ZLIB: self._tfactory = TZlibTransport.TZlibTransportFactory() if settings.THRIFTSERVER_FRAMED: self._tfactory = TTransport.TFramedTransportFactory() if settings.THRIFTSERVER_PROTOCOL == Protocol.BINARY: self._pfactory = TBinaryProtocol.TBinaryProtocolFactory() elif settings.THRIFTSERVER_PROTOCOL == Protocol.COMPACT: self._pfactory = TCompactProtocol.TCompactProtocolFactory() elif settings.THRIFTSERVER_PROTOCOL == Protocol.JSON: self._pfactory = TJSONProtocol.TJSONProtocolFactory() else: raise RuntimeError( "invalid configuration for THRIFTSERVER_PROTOCOL: {}".format( settings.THRIFTSERVER_PROTOCOL))
def __initialize(self): if self._transport == 'http': # self._transport = THttpClient.THttpClient(self._ip, self._port) self._transport = THttpClient.THttpClient('http://%s:%d/' % (self._ip, self._port)) else: socket = TSocket.TSocket(self._ip, self._port) socket.setTimeout(self._timeout) if self._transport == 'frame': self._transport = TTransport.TFramedTransport(socket) else: self._transport = TTransport.TBufferedTransport(socket) if self._transport == 'zlib': self._transport = TZlibTransport.TZlibTransport( self._transport) self._protocol = ThriftClient.__protocol_type[self._protocol]( self._transport)
options.port, certfile=abs_key_path) else: transport = TSocket.TServerSocket(host, options.port) tfactory = TTransport.TBufferedTransportFactory() if options.trans == 'buffered': tfactory = TTransport.TBufferedTransportFactory() elif options.trans == 'framed': tfactory = TTransport.TFramedTransportFactory() elif options.trans == '': raise AssertionError('Unknown --transport option: %s' % options.trans) else: tfactory = TTransport.TBufferedTransportFactory() # if --zlib, then wrap server transport, and use a different transport factory if options.zlib: transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib tfactory = TZlibTransport.TZlibTransportFactory() # do server-specific setup here: if server_type == "TNonblockingServer": server = TNonblockingServer.TNonblockingServer( processor, transport, inputProtocolFactory=pfactory) elif server_type == "TProcessPoolServer": import signal from thrift.server import TProcessPoolServer server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory) server.setNumWorkers(5) def set_alarm(): def clean_shutdown(signum, frame):
type=str, help="Thrift RPC port (DEFAULT: 20206)") parser.set_defaults() args = parser.parse_args() use_zlib = 1 host = args.rpc_server port = int(args.rpc_port) socket = TSocket.TSocket(host, port) transport = TTransport.TBufferedTransport(socket) if use_zlib: transport = TZlibTransport.TZlibTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = RunTimeEnvironment.Client(protocol) transport.open() try: client.sys_ping() except TException: transport.close() sys.stderr.write("Basic communication with RPC server failed\n") sys.exit(1) # grab all the digest info digests = client.digest_list_all()
def connect(self, host=None, port=None, uri=None, timeout=10000): """ Connect method should be called before any operations. Server will be connected after connect return OK :type host: str :type port: str :type uri: str :type timeout: int :param timeout: (Optional) connection timeout, ms / 1000 :param host: (Optional) host of the server, default host is 127.0.0.1 :param port: (Optional) port of the server, default port is 9090 :param uri: (Optional) only support tcp proto now, default uri is `tcp://127.0.0.1:9090` :return: Status, indicate if connect is successful :rtype: Status """ if self.status and self.status == Status.SUCCESS: raise RepeatingConnectError("You have already connected!") config_uri = urlparse(config.THRIFTCLIENT_TRANSPORT) _uri = urlparse(uri) if uri else config_uri if not host: if _uri.scheme == 'tcp': host = _uri.hostname port = _uri.port or 9090 else: if uri: raise RuntimeError('Invalid parameter uri: {}'.format(uri)) raise RuntimeError( 'Invalid configuration for THRIFTCLIENT_TRANSPORT: {transport}' .format(transport=config.THRIFTCLIENT_TRANSPORT)) else: host = host port = port or 9090 self._transport = TSocket.TSocket(host, port) if timeout: self._transport.setTimeout(int(timeout)) if config.THRIFTCLIENT_BUFFERED: self._transport = TTransport.TBufferedTransport(self._transport) if config.THRIFTCLIENT_ZLIB: self._transport = TZlibTransport.TZlibTransport(self._transport) if config.THRIFTCLIENT_FRAMED: self._transport = TTransport.TFramedTransport(self._transport) if config.THRIFTCLIENT_PROTOCOL == Protocol.BINARY: protocol = TBinaryProtocol.TBinaryProtocol(self._transport) elif config.THRIFTCLIENT_PROTOCOL == Protocol.COMPACT: protocol = TCompactProtocol.TCompactProtocol(self._transport) elif config.THRIFTCLIENT_PROTOCOL == Protocol.JSON: protocol = TJSONProtocol.TJSONProtocol(self._transport) else: raise RuntimeError( "invalid configuration for THRIFTCLIENT_PROTOCOL: {protocol}". format(protocol=config.THRIFTCLIENT_PROTOCOL)) self._client = MilvusService.Client(protocol) try: self._transport.open() self.status = Status(Status.SUCCESS, 'Connected') return self.status except TTransport.TTransportException as e: self.status = Status(code=e.type, message=e.message) LOGGER.error(e) raise NotConnectError('Connection failed')
import sys sys.path.append("gen-py") from thrift.transport import TTransport from thrift.transport import TZlibTransport from thrift.protocol import TBinaryProtocol from radio_observation import ttypes #Read in the serialized compressed UDT ep_trans = TTransport.TFileObjectTransport(open("data.z", "rb")) trans = TZlibTransport.TZlibTransport(ep_trans) trans.open() proto = TBinaryProtocol.TBinaryProtocol(trans) ro = ttypes.RadioObservation() ro.read(proto) trans.close() #Display the contents of the UDT print("\nReading Observations") print("-------------------------") print("Telescope Count: %d" % ro.telescope_count) print("System : %s" % ttypes.RadioObservationSystem._VALUES_TO_NAMES[ro.system]) print("Time : %f" % ro.time) if None != ro.pos.icrfpos: print("Position : %f dec - %f ra [%s]" % (ro.pos.icrfpos.declination, ro.pos.icrfpos.right_ascension, "" if None == ro.pos.icrfpos.ecliptic_year else str( ro.pos.icrfpos.ecliptic_year))) print("Frequency Magnitude")