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")
