def process_sendChatCheckedByWatermark(self, seqid, iprot, oprot):
args = sendChatCheckedByWatermark_args()
args.read(iprot)
iprot.readMessageEnd()
result = sendChatCheckedByWatermark_result()
try:
self._handler.sendChatCheckedByWatermark(args.seq, args.mid,
args.watermark,
args.sessionId)
msg_type = TMessageType.REPLY
except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
raise
except TalkException as e:
msg_type = TMessageType.REPLY
result.e = e
except Exception as ex:
msg_type = TMessageType.EXCEPTION
logging.exception(ex)
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("sendChatCheckedByWatermark", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_run_command(self, seqid, iprot, oprot):
args = run_command_args()
args.read(iprot)
iprot.readMessageEnd()
result = run_command_result()
try:
result.success = self._handler.run_command(args.block_id,
args.arguments)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("run_command", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_getDataSetFileOfVariableAtTimeIndex(self, seqid, iprot, oprot):
args = getDataSetFileOfVariableAtTimeIndex_args()
args.read(iprot)
iprot.readMessageEnd()
result = getDataSetFileOfVariableAtTimeIndex_result()
try:
result.success = self._handler.getDataSetFileOfVariableAtTimeIndex(
args.simulationDataSetRef, args.varInfo, args.timeIndex)
msg_type = TMessageType.REPLY
except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
raise
except ThriftDataAccessException as dataAccessException:
msg_type = TMessageType.REPLY
result.dataAccessException = dataAccessException
except Exception as ex:
msg_type = TMessageType.EXCEPTION
logging.exception(ex)
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("getDataSetFileOfVariableAtTimeIndex",
msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_getStruct(self, seqid, iprot, oprot):
args = getStruct_args()
args.read(iprot)
iprot.readMessageEnd()
result = getStruct_result()
msg_type = TMessageType.REPLY
try:
result.success = yield gen.maybe_future(
self._handler.getStruct(args.key))
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("getStruct", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_displayPostProcessingDataInVCell(self, seqid, iprot, oprot):
args = displayPostProcessingDataInVCell_args()
args.read(iprot)
iprot.readMessageEnd()
result = displayPostProcessingDataInVCell_result()
try:
self._handler.displayPostProcessingDataInVCell(
args.simulationDataSetRef)
msg_type = TMessageType.REPLY
except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
raise
except ThriftDataAccessException as dataAccessException:
msg_type = TMessageType.REPLY
result.dataAccessException = dataAccessException
except Exception as ex:
msg_type = TMessageType.EXCEPTION
logging.exception(ex)
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("displayPostProcessingDataInVCell", msg_type,
seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_EstimateWalkPoints(self, seqid, iprot, oprot):
args = EstimateWalkPoints_args()
args.read(iprot)
iprot.readMessageEnd()
result = EstimateWalkPoints_result()
try:
result.success = self._handler.EstimateWalkPoints(
args.sceneObjects, args.target, args.amount, args.properties)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("EstimateWalkPoints", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def _handle_request(self, listener_name, sock, addr):
client = TFileObjectTransport(sock.makefile())
itrans = self.tfactory.getTransport(client)
otrans = self.tfactory.getTransport(client)
iprot = self.pfactory.getProtocol(itrans)
oprot = self.pfactory.getProtocol(otrans)
try:
while True:
(name, type, seqid) = iprot.readMessageBegin()
request_start = time.time()
try:
timeout_con = Timeout(self.cfg.timeout, Timeout)
timeout_con.start()
if name not in self.wsgi._processMap:
iprot.skip(TType.STRUCT)
iprot.readMessageEnd()
x = TApplicationException(
TApplicationException.UNKNOWN_METHOD,
"Unknown function %s" % (name))
oprot.writeMessageBegin(name, TMessageType.EXCEPTION,
seqid)
x.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
raise ThriftFuncNotFound
else:
self.wsgi._processMap[name](self.wsgi, seqid, iprot,
oprot)
except ThriftFuncNotFound, ex:
self.log.error("Unknown function %s" % (name))
self.log.access(addr, name, "FUNC_NOT_FOUND",
time.time() - request_start)
except Timeout, ex:
self.log.error("A greenlet process timeout.")
self.log.access(addr, name, "TIMEOUT",
time.time() - request_start)
async def callback(transport):
iprot = protocol_factory.get_protocol(transport)
ctx = iprot.read_request_headers()
mname, _, _ = iprot.readMessageBegin()
if mname != op:
iprot.skip(TType.STRUCT)
iprot.readMessageEnd()
raise TApplicationException(
TApplicationExceptionType.UNKNOWN_METHOD)
req = []
(_, elem4) = iprot.readListBegin()
for _ in range(elem4):
elem5 = Album()
elem5.read(iprot)
req.append(elem5)
iprot.readListEnd()
iprot.readMessageEnd()
try:
ret = method([ctx, req])
if inspect.iscoroutine(ret):
await ret
except:
traceback.print_exc()
sys.exit(1)
def process_getAlgorithmStatus(self, seqid, iprot, oprot):
args = getAlgorithmStatus_args()
args.read(iprot)
iprot.readMessageEnd()
result = getAlgorithmStatus_result()
try:
result.success = self._handler.getAlgorithmStatus(
args.requestId, args.algorithmId)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("getAlgorithmStatus", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_Multiplication(self, seqid, iprot, oprot):
args = Multiplication_args()
args.read(iprot)
iprot.readMessageEnd()
result = Multiplication_result()
try:
result.success = self._handler.Multiplication(
args.firstNumber, args.secondNumber)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("Multiplication", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_sendEmailMessage(self, seqid, iprot, oprot):
args = sendEmailMessage_args()
args.read(iprot)
iprot.readMessageEnd()
result = sendEmailMessage_result()
try:
result.success = self._handler.sendEmailMessage(
args.email, args.message)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("sendEmailMessage", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_updateChinaProvienceData(self, seqid, iprot, oprot):
args = updateChinaProvienceData_args()
args.read(iprot)
iprot.readMessageEnd()
result = updateChinaProvienceData_result()
try:
result.success = self._handler.updateChinaProvienceData(
args.provience)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("updateChinaProvienceData", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_savetodb(self, seqid, iprot, oprot):
args = savetodb_args()
args.read(iprot)
iprot.readMessageEnd()
result = savetodb_result()
try:
self._handler.savetodb(args.movie_name, args.country,
args.language, args.type, args.score)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("savetodb", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_RetargetToTarget(self, seqid, iprot, oprot):
args = RetargetToTarget_args()
args.read(iprot)
iprot.readMessageEnd()
result = RetargetToTarget_result()
try:
result.success = self._handler.RetargetToTarget(
args.intermediatePostureValues)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("RetargetToTarget", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_SetBlendingMask(self, seqid, iprot, oprot):
args = SetBlendingMask_args()
args.read(iprot)
iprot.readMessageEnd()
result = SetBlendingMask_result()
try:
result.success = self._handler.SetBlendingMask(
args.mask, args.avatarID)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("SetBlendingMask", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_sendMessage(self, seqid, iprot, oprot):
args = sendMessage_args()
args.read(iprot)
iprot.readMessageEnd()
result = sendMessage_result()
try:
result.success = self._handler.sendMessage(args.reqSeq,
args.squareChatMid,
args.squareMessage)
msg_type = TMessageType.REPLY
except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
raise
except SquareException as e:
msg_type = TMessageType.REPLY
result.e = e
except Exception as ex:
msg_type = TMessageType.EXCEPTION
logging.exception(ex)
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("sendMessage", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_face_sim(self, seqid, iprot, oprot):
args = face_sim_args()
args.read(iprot)
iprot.readMessageEnd()
result = face_sim_result()
try:
result.success = self._handler.face_sim(args.img_base64_1,
args.img_base64_2)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("face_sim", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_postSnsInvitationMessage(self, seqid, iprot, oprot):
args = postSnsInvitationMessage_args()
args.read(iprot)
iprot.readMessageEnd()
result = postSnsInvitationMessage_result()
try:
self._handler.postSnsInvitationMessage(args.snsIdType,
args.snsAccessToken,
args.toSnsUserId)
msg_type = TMessageType.REPLY
except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
raise
except TalkException as e:
msg_type = TMessageType.REPLY
result.e = e
except Exception as ex:
msg_type = TMessageType.EXCEPTION
logging.exception(ex)
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("postSnsInvitationMessage", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def process_myMethod(self, seqid, iprot, oprot):
args = myMethod_args()
args.read(iprot)
iprot.readMessageEnd()
result = myMethod_result()
try:
self._handler.myMethod(args.first, args.second, args.third,
args.fourth)
msg_type = TMessageType.REPLY
except TTransport.TTransportException:
raise
except TApplicationException as ex:
logging.exception('TApplication exception in handler')
msg_type = TMessageType.EXCEPTION
result = ex
except Exception:
logging.exception('Unexpected exception in handler')
msg_type = TMessageType.EXCEPTION
result = TApplicationException(
TApplicationException.INTERNAL_ERROR, 'Internal error')
oprot.writeMessageBegin("myMethod", msg_type, seqid)
result.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
def do_POST(self):
"""
Handles POST queries, which are usually Thrift messages.
"""
client_host, client_port = self.client_address
auth_session = self.__check_session_cookie()
LOG.info("%s:%s -- [%s] POST %s", client_host, str(client_port),
auth_session.user if auth_session else "Anonymous",
self.path)
# Create new thrift handler.
checker_md_docs = self.server.checker_md_docs
checker_md_docs_map = self.server.checker_md_docs_map
suppress_handler = self.server.suppress_handler
version = self.server.version
protocol_factory = TJSONProtocol.TJSONProtocolFactory()
input_protocol_factory = protocol_factory
output_protocol_factory = protocol_factory
itrans = TTransport.TFileObjectTransport(self.rfile)
itrans = TTransport.TBufferedTransport(itrans,
int(self.headers[
'Content-Length']))
otrans = TTransport.TMemoryBuffer()
iprot = input_protocol_factory.getProtocol(itrans)
oprot = output_protocol_factory.getProtocol(otrans)
if self.server.manager.is_enabled and \
not self.path.endswith('/Authentication') and \
not auth_session:
# Bail out if the user is not authenticated...
# This response has the possibility of melting down Thrift clients,
# but the user is expected to properly authenticate first.
LOG.debug(client_host + ":" + str(client_port) +
" Invalid access, credentials not found " +
"- session refused.")
self.send_error(401)
return
# Authentication is handled, we may now respond to the user.
try:
product_endpoint, api_ver, request_endpoint = \
routing.split_client_POST_request(self.path)
product = None
if product_endpoint:
# The current request came through a product route, and not
# to the main endpoint.
product = self.__check_prod_db(product_endpoint)
version_supported = routing.is_supported_version(api_ver)
if version_supported:
major_version, _ = version_supported
if major_version == 6:
if request_endpoint == 'Authentication':
auth_handler = AuthHandler_v6(
self.server.manager,
auth_session,
self.server.config_session)
processor = AuthAPI_v6.Processor(auth_handler)
elif request_endpoint == 'Products':
prod_handler = ProductHandler_v6(
self.server,
auth_session,
self.server.config_session,
product,
version)
processor = ProductAPI_v6.Processor(prod_handler)
elif request_endpoint == 'CodeCheckerService':
# This endpoint is a product's report_server.
if not product:
error_msg = "Requested CodeCheckerService on a " \
"nonexistent product: '{0}'." \
.format(product_endpoint)
LOG.error(error_msg)
raise ValueError(error_msg)
if product_endpoint:
# The current request came through a
# product route, and not to the main endpoint.
product = self.__check_prod_db(product_endpoint)
acc_handler = ReportHandler_v6(
self.server.manager,
product.session_factory,
product,
auth_session,
self.server.config_session,
checker_md_docs,
checker_md_docs_map,
suppress_handler,
version)
processor = ReportAPI_v6.Processor(acc_handler)
else:
LOG.debug("This API endpoint does not exist.")
error_msg = "No API endpoint named '{0}'." \
.format(self.path)
raise ValueError(error_msg)
else:
if request_endpoint == 'Authentication':
# API-version checking is supported on the auth endpoint.
handler = BadAPIHandler(api_ver)
processor = AuthAPI_v6.Processor(handler)
else:
# Send a custom, but valid Thrift error message to the
# client requesting this action.
error_msg = "Incompatible client/server API." \
"API versions supported by this server {0}." \
.format(get_version_str())
raise ValueError(error_msg)
processor.process(iprot, oprot)
result = otrans.getvalue()
self.send_response(200)
self.send_header("content-type", "application/x-thrift")
self.send_header("Content-Length", len(result))
self.end_headers()
self.wfile.write(result)
return
except Exception as exn:
# Convert every Exception to the proper format which can be parsed
# by the Thrift clients expecting JSON responses.
LOG.warning(str(exn))
import traceback
traceback.print_exc()
ex = TApplicationException(TApplicationException.INTERNAL_ERROR,
str(exn))
fname, _, seqid = iprot.readMessageBegin()
oprot.writeMessageBegin(fname, TMessageType.EXCEPTION, seqid)
ex.write(oprot)
oprot.writeMessageEnd()
oprot.trans.flush()
result = otrans.getvalue()
self.send_response(200)
self.send_header("content-type", "application/x-thrift")
self.send_header("Content-Length", len(result))
self.end_headers()
self.wfile.write(result)
return
def testUncheckedTApplicationException(self, ctx):
raise TApplicationException(400, 'Unchecked TApplicationException')
def process(self, iproto, oproto):
"""Processes a single client request.
"""
pname, _, seqid = iproto.readMessageBegin()
# perf.begin('process')
try:
# find the procedure to call
if not pname in self._procedures:
iproto.skip(TType.STRUCT)
iproto.readMessageEnd()
raise TApplicationException(
TApplicationException.UNKNOWN_METHOD,
"Unknown method '{0}'".format(pname))
procedure = self._procedures[
pname] # TApplicationException.UNKNOWN_METHOD
server_info.client_ip = None
server_info.client_port = None
try:
if isinstance(iproto.trans, TFramedTransport):
info = iproto.trans._TFramedTransport__trans.handle.getpeername(
)
else:
info = iproto.trans.handle.getpeername()
server_info.client_ip = str(info[0])
if server_info.client_ip[0:7] == '::ffff:':
server_info.client_ip = server_info.client_ip[7:]
server_info.client_port = int(info[1])
except:
pass
logging.debug('Server serving client: %s:%s, %s',
server_info.client_ip, server_info.client_port,
pname)
# parse arguments
# perf.begin('recv')
arguments = self.recv_struct(procedure.parameters_struct, iproto)
iproto.readMessageEnd()
# perf.end('recv')
# call the registered implementation
# perf.begin('call')
result = procedure.results_struct.get_class()()
try:
args = {}
for parameter in procedure.parameters:
if getattr(arguments, parameter.name) is not None:
args[parameter.name] = getattr(arguments,
parameter.name)
result.result = procedure.implementation(**args)
except Exception as ex:
logging.exception('Exception in procedure: %s:%s, %s',
server_info.client_ip,
server_info.client_port, pname)
handled = False
for field in procedure.results_struct.fields:
if (field.name != 'result') and isinstance(
ex, field.type.get_class()):
setattr(result, field.name, ex)
handled = True
break
if not handled:
raise TApplicationException(
TApplicationException.UNKNOWN,
'Unknown exception in procedure')
# perf.end('call')
# send the reply
# perf.begin('send')
oproto.writeMessageBegin(pname, TMessageType.REPLY, seqid)
self.send_struct(result, procedure.results_struct, oproto)
oproto.writeMessageEnd()
# perf.end('send')
except TApplicationException as ex:
# handle protocol errors
# perf.begin('except')
oproto.writeMessageBegin(pname, TMessageType.EXCEPTION, seqid)
ex.write(oproto)
oproto.writeMessageEnd()
# perf.end('except')
finally:
# perf.begin('flush')
oproto.trans.flush()
def make_unknown_function_exception(name):
return TApplicationException(
TApplicationException.UNKNOWN_METHOD,
'Unknown function {!r}'.format(name),
)
def rpc_test_definitions():
"""
Defines and returns shared tests for all python frugal implementations.
:return: dictionary with:
keys=rpc name
values= dict with array of args and expected test result
"""
tests = {}
tests['testVoid'] = dict(args=None, expected_result=None)
thing = "thing"
tests['testString'] = dict(args=[thing], expected_result=thing)
tests['testBool'] = dict(args=[True], expected_result=True)
byte = 42
tests['testByte'] = dict(args=[byte], expected_result=byte)
i32 = 4242
tests['testI32'] = dict(args=[i32], expected_result=i32)
i64 = 424242
tests['testI64'] = dict(args=[i64], expected_result=i64)
dbl = 42.42
tests['testDouble'] = dict(args=[dbl], expected_result=dbl)
binary = b'101010'
tests['testBinary'] = dict(args=[binary], expected_result=binary)
struct = Xtruct()
struct.string_thing = thing
struct.byte_thing = byte
struct.i32_thing = i32
struct.i64_thing = i64
tests['testStruct'] = dict(args=[struct], expected_result=struct)
struct2 = Xtruct2()
struct2.struct_thing = struct
struct2.byte_thing = 0
struct2.i32_thing = 0
tests['testNest'] = dict(args=[struct2], expected_result=struct2)
dictionary = {1: 2, 3: 4, 5: 42}
tests['testMap'] = dict(args=[dictionary], expected_result=dictionary)
string_map = {"a": "2", "b": "blah", "some": "thing"}
tests['testStringMap'] = dict(args=[string_map],
expected_result=string_map)
set = {1, 2, 2, 42}
tests['testSet'] = dict(args=[set], expected_result=set)
list = [1, 2, 42]
tests['testList'] = dict(args=[list], expected_result=list)
enum = Numberz.TWO
tests['testEnum'] = dict(args=[enum], expected_result=enum)
type_def = 42
tests['testTypedef'] = dict(args=[type_def], expected_result=type_def)
d = {4: 4, 3: 3, 2: 2, 1: 1}
e = {-4: -4, -3: -3, -2: -2, -1: -1}
mapmap = {-4: e, 4: d}
tests['testMapMap'] = dict(args=[42], expected_result=mapmap)
tests['TestUppercaseMethod'] = dict(args=[True], expected_result=True)
truck1 = Xtruct("Goodbye4", 4, 4, 4)
truck2 = Xtruct("Hello2", 2, 2, 2)
insanity = Insanity()
insanity.userMap = {Numberz.FIVE: 5, Numberz.EIGHT: 8}
insanity.xtructs = [truck1, truck2]
expected_result = {
1: {
2:
Insanity(xtructs=[
Xtruct(string_thing='Goodbye4',
byte_thing=4,
i32_thing=4,
i64_thing=4),
Xtruct(string_thing='Hello2',
byte_thing=2,
i32_thing=2,
i64_thing=2)
],
userMap={
8: 8,
5: 5
}),
3:
Insanity(xtructs=[
Xtruct(string_thing='Goodbye4',
byte_thing=4,
i32_thing=4,
i64_thing=4),
Xtruct(string_thing='Hello2',
byte_thing=2,
i32_thing=2,
i64_thing=2)
],
userMap={
8: 8,
5: 5
})
},
2: {}
}
tests['testInsanity'] = dict(args=[insanity],
expected_result=expected_result)
multi = Xtruct()
multi.string_thing = "Hello2"
multi.byte_thing = byte
multi.i32_thing = i32
multi.i64_thing = i64
tests['testMulti'] = dict(
args=[byte, i32, i64, {
1: "blah",
2: thing
}, Numberz.EIGHT, 24],
expected_result=multi)
tests['testException'] = dict(args=['Xception'],
expected_result=Xception(errorCode=1001,
message='Xception'))
struct_thing = Xtruct()
struct_thing.string_thing = 'This is an Xception2'
struct_thing.byte_thing = 0
struct_thing.i32_thing = 0
struct_thing.i64_thing = 0
e = Xception2(errorCode=2002, struct_thing=struct_thing)
tests['testMultiException'] = dict(args=['Xception2', 'ignoreme'],
expected_result=e)
e = TApplicationException(TApplicationException.INTERNAL_ERROR,
'An uncaught error')
tests['testUncaughtException'] = dict(args=[], expected_result=e)
e = TApplicationException(400, 'Unchecked TApplicationException')
tests['testUncheckedTApplicationException'] = dict(args=[],
expected_result=e)
return tests
def read_header_format(self, sz, header_size, data):
# clear out any previous transforms
self.__read_transforms = []
header_size = header_size * 4
if header_size > sz:
raise TTransportException(TTransportException.INVALID_FRAME_SIZE,
"Header size is larger than frame")
end_header = header_size + data.tell()
self.__proto_id = readVarint(data)
num_headers = readVarint(data)
if self.__proto_id == 1 and self.__client_type != \
self.HTTP_CLIENT_TYPE:
raise TTransportException(
TTransportException.INVALID_CLIENT_TYPE,
"Trying to recv JSON encoding over binary")
# Read the headers. Data for each header varies.
hmac_sz = 0
for h in range(0, num_headers):
trans_id = readVarint(data)
if trans_id == self.ZLIB_TRANSFORM:
self.__read_transforms.insert(0, trans_id)
elif trans_id == self.SNAPPY_TRANSFORM:
self.__read_transforms.insert(0, trans_id)
elif trans_id == self.HMAC_TRANSFORM:
hmac_sz = ord(data.read(1))
data.seek(-1, os.SEEK_CUR)
data.write(b'\0')
else:
# TApplicationException will be sent back to client
raise TApplicationException(
TApplicationException.INVALID_TRANSFORM,
"Unknown transform in client request: %i" % trans_id)
# Clear out previous info headers.
self.__read_headers.clear()
# Read the info headers.
while data.tell() < end_header:
info_id = readVarint(data)
if info_id == self.INFO_KEYVALUE:
THeaderTransport._read_info_headers(data, end_header,
self.__read_headers)
elif info_id == self.INFO_PKEYVALUE:
THeaderTransport._read_info_headers(
data, end_header, self.__read_persistent_headers)
else:
break # Unknown header. Stop info processing.
if self.__read_persistent_headers:
self.__read_headers.update(self.__read_persistent_headers)
# Skip the rest of the header
data.seek(end_header)
payload = data.read(sz - header_size - hmac_sz)
# Verify the mac
if self.__hmac_verify_func:
hmac = data.read(hmac_sz)
verify_data = data.getvalue()[:-hmac_sz]
if not self.__hmac_verify_func(verify_data, hmac):
raise TTransportException(
TTransportException.INVALID_TRANSFORM,
"HMAC did not verify")
# Read the data section.
self.__rbuf = StringIO(self.untransform(payload))
def read_header_format(self, sz, header_size, data):
# clear out any previous transforms
self.__read_transforms = []
header_size = header_size * 4
if header_size > sz:
raise TTransportException(
TTransportException.INVALID_FRAME_SIZE,
"Header size is larger than frame",
)
end_header = header_size + data.tell()
self.__proto_id = readVarint(data)
num_headers = readVarint(data)
if self.__proto_id == 1 and self.__client_type != CLIENT_TYPE.HTTP_SERVER:
raise TTransportException(
TTransportException.INVALID_CLIENT_TYPE,
"Trying to recv JSON encoding over binary",
)
# Read the headers. Data for each header varies.
for _ in range(0, num_headers):
trans_id = readVarint(data)
if trans_id in (TRANSFORM.ZLIB, TRANSFORM.SNAPPY, TRANSFORM.ZSTD):
self.__read_transforms.insert(0, trans_id)
elif trans_id == TRANSFORM.HMAC:
raise TApplicationException(
TApplicationException.INVALID_TRANSFORM,
"Hmac transform is no longer supported: %i" % trans_id,
)
else:
# TApplicationException will be sent back to client
raise TApplicationException(
TApplicationException.INVALID_TRANSFORM,
"Unknown transform in client request: %i" % trans_id,
)
# Clear out previous info headers.
self.__read_headers.clear()
# Read the info headers.
while data.tell() < end_header:
info_id = readVarint(data)
if info_id == INFO.NORMAL:
_read_info_headers(data, end_header, self.__read_headers)
elif info_id == INFO.PERSISTENT:
_read_info_headers(data, end_header, self.__read_persistent_headers)
else:
break # Unknown header. Stop info processing.
if self.__read_persistent_headers:
self.__read_headers.update(self.__read_persistent_headers)
# Skip the rest of the header
data.seek(end_header)
payload = data.read(sz - header_size)
# Read the data section.
self.__rbuf = StringIO(self.untransform(payload))
def _handle_timeout(self, fname, seqid):
exc = TApplicationException(TApplicationException.TIMEOUT,
"Call to {} timed out".format(fname))
serialized_exc = self.serialize_texception(fname, seqid, exc)
self._handle_message(serialized_exc, clear_timeout=False)
def init(self,
int1=None,
int2=None,
int3=None,
int4=None,
int5=None,
int6=None,
int7=None,
int8=None,
int9=None,
int10=None,
int11=None,
int12=None,
int13=None,
int14=None,
int15=None,
int16=None):
"""
Parameters:
- int1
- int2
- int3
- int4
- int5
- int6
- int7
- int8
- int9
- int10
- int11
- int12
- int13
- int14
- int15
- int16
"""
if (self._fbthrift_cpp_transport):
args = init_args()
args.int1 = int1
args.int2 = int2
args.int3 = int3
args.int4 = int4
args.int5 = int5
args.int6 = int6
args.int7 = int7
args.int8 = int8
args.int9 = int9
args.int10 = int10
args.int11 = int11
args.int12 = int12
args.int13 = int13
args.int14 = int14
args.int15 = int15
args.int16 = int16
result = self._fbthrift_cpp_transport._send_request(
"TestService", "init", args, init_result)
if result.success is not None:
return result.success
raise TApplicationException(TApplicationException.MISSING_RESULT)
self.send_init(int1, int2, int3, int4, int5, int6, int7, int8, int9,
int10, int11, int12, int13, int14, int15, int16)
return self.recv_init()
