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