def deserialize(protocol_factory, data, thr_out): # type: (Any, AnyStr, T) -> T """Convenience method for deserializing objects using the given protocol factory and a TMemoryBuffer. returns its thr_out argument.""" transport = TTransport.TMemoryBuffer(data) try: # pyre-fixme[16]: `T` has no attribute `thrift_spec`. protocol = protocol_factory.getProtocol( transport, thr_out.thrift_spec) # noqa: T484 except TypeError: protocol = protocol_factory.getProtocol(transport) if isinstance(protocol, THeaderProtocol.THeaderProtocol): # this reads the THeader headers to detect what the underlying # protocol is, as well as looking at transforms, etc. protocol.trans.readFrame(0) protocol.reset_protocol() # pyre-fixme[16]: `T` has no attribute `read`. thr_out.read(protocol) # noqa: T484 return thr_out
def DeserializeThriftMsg(msg, data, protocol_type=TBinaryProtocol.TBinaryProtocol): """Deserialize a thrift message using the given protocol. The default protocol is binary. Args: msg: the Thrift object to serialize. data: the data to read from. protocol_type: the Thrift protocol class to use. Returns: Message object passed in (post-parsing). """ transportIn = TTransport.TMemoryBuffer(data) protocolIn = protocol_type(transportIn) msg.read(protocolIn) msg.validate() return msg
def make_data(self, pfactory=None): trans = TTransport.TMemoryBuffer() if pfactory: prot = pfactory.getProtocol(trans) else: prot = TBinaryProtocol.TBinaryProtocol(trans) x = Xtruct() x.string_thing = "Zero" x.byte_thing = 0 x.write(prot) x = Xtruct() x.string_thing = "One" x.byte_thing = 1 x.write(prot) return trans.getvalue()
def testOversizeFrameRecv(self): """Test that an oversize frame on recv gets a TTransportException""" self.trans.set_max_frame_size(200) self.x.write(self.prot) self.trans.flush() inTrans = TTransport.TMemoryBuffer(self.trans.getTransport().getvalue()) inTrans = THeaderTransport(inTrans) inProt = TBinaryProtocol.TBinaryProtocol(inTrans) inTrans.set_max_frame_size(2) try: self.x.read(inProt) except TTransport.TTransportException: return self.fail("Should have gotten TTransportException")
def eofTestHelper(self, pfactory): trans = TTransport.TMemoryBuffer(self.make_data(pfactory)) prot = pfactory.getProtocol(trans) x = Xtruct() x.read(prot) self.assertEqual(x.string_thing, "Zero") self.assertEqual(x.byte_thing, 0) x = Xtruct() x.read(prot) self.assertEqual(x.string_thing, "One") self.assertEqual(x.byte_thing, 1) try: x = Xtruct() x.read(prot) except EOFError: return self.fail("Should have gotten EOFError")
def _read_next(self, start, end): for idx in range(start, end): try: trans = TTransport.TMemoryBuffer(self._data_slice(idx)) proto = self._protocol(trans) tstruct = ThriftStruct.read( proto, max_fields=ThriftStructFile.MAX_FIELDS, max_list_size=ThriftStructFile.MAX_LIST_SIZE, max_map_size=ThriftStructFile.MAX_MAP_SIZE, max_set_size=ThriftStructFile.MAX_SET_SIZE, read_values=self._read_values) skipped = idx - start return (tstruct, None) if skipped == 0 else (tstruct, (start, skipped)) except Exception as ex: if self._debug: print('Bad message: %s (idx=%d)' % (ex, idx)) # nothing found return (None, None)
def thrift_write(obj, spec, _force_native=False): transport = TTransport.TMemoryBuffer() protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) transport.open() if protocol.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and \ spec is not None and \ fastbinary is not None and \ not _force_native: protocol.trans.write( fastbinary.encode_binary(obj, (obj.__class__, spec))) else: _write_struct(obj, protocol, ( None, spec, )) bytes = transport.getvalue() transport.close() return bytes
def fastproto_decode(q, protoid): hp = hpy() p = psutil.Process(os.getpid()) before = hp.heap() for i in range(iters): trans = TTransport.TMemoryBuffer(binary_buf if protoid == 0 else compact_buf) ooe_local = OneOfEach() fastproto.decode(ooe_local, trans, [OneOfEach, OneOfEach.thrift_spec, False], utf8strings=0, protoid=protoid) if (i + 1) % 100000 == 0: q.put((i + 1, p.memory_info())) gc.collect() after = hp.heap() leftover = after - before q.put("Memory leftover in Python after {} times: {}".format( iters, leftover))
def serialize(self, message): '''Given a Broker Message returns a Message object properly serialized to be sent using a Transport''' atom = ttypes.Atom() action = ttypes.Action() #now it depends on the message type code = self.__dispatch_serialize[message.__class__] code(message, action) atom.action = action #serialization objects transportOut = TTransport.TMemoryBuffer() protocolOut = TBinaryProtocol.TBinaryProtocol(transportOut) atom.write(protocolOut) #get the message binary payload payload = transportOut.getvalue() return TransportMessage(payload=payload, encoding_type=self.encoding_type, encoding_version=self.encoding_version)
def parseClientUnrouteableMessage(self, msg, channel, queue, thriftClient, iprot_factory=None): tr = TTransport.TMemoryBuffer(msg.content.body) if iprot_factory is None: iprot = self.factory.iprot_factory.getProtocol(tr) else: iprot = iprot_factory.getProtocol(tr) (fname, mtype, rseqid) = iprot.readMessageBegin() # log.msg('Got unroutable. fname = %r, rseqid = %s, mtype = %r, routing key = %r, client = %r, msg.content.body = %r' % (fname, rseqid, mtype, msg.routing_key, thriftClient, msg.content.body)) try: d = thriftClient._reqs.pop(rseqid) except KeyError: # KeyError will occur if the remote Thrift method is oneway, # since there is no outstanding local request deferred for # oneway calls. pass else: d.errback( TTransport.TTransportException( type=TTransport.TTransportException.NOT_OPEN, message= 'Unrouteable message, routing key = %r calling function %r' % (msg.routing_key, fname))) d = queue.get() d.addCallback(self.parseClientUnrouteableMessage, channel, queue, thriftClient, iprot_factory=iprot_factory) d.addErrback(self.catchClosedClientQueue) d.addErrback(self.handleClientQueueError)
def eofTestHelper(self, pfactory): trans = TTransport.TMemoryBuffer(self.data) prot = pfactory.getProtocol(trans) x = Xtruct() x.read(prot) self.assertEqual(x.string_thing, b"Zero") self.assertEqual(x.byte_thing, 0) x = Xtruct() x.read(prot) self.assertEqual(x.string_thing, b"One") self.assertEqual(x.byte_thing, 1) try: x = Xtruct() x.read(prot) except TTransport.TTransportException as e: if e.type == TTransport.TTransportException.END_OF_FILE: return raise self.fail("Should have gotten TTransportException")
def _start_receiving(self): while True: try: frame = yield self._transport.readFrame() except TTransport.TTransportException as e: for future in self._reqs.itervalues(): future.set_exception(e) self._reqs = {} return tr = TTransport.TMemoryBuffer(frame) iprot = self._iprot_factory.getProtocol(tr) (fname, mtype, rseqid) = iprot.readMessageBegin() future = self._reqs.pop(rseqid, None) if not future: # future has already been discarded continue method = getattr(self, 'recv_' + fname) try: result = method(iprot, mtype, rseqid) except Exception as e: future.set_exception(e) else: future.set_result(result)
def create_event(src, msgFrom, msgTo, msgSubject, msgDate): """Create Thrift event from a message Keyword arguments: src -- unique identifier for the source of the page (e.g. Nagios, Pages, ...) msgFrom -- email FROM header msgTo -- email TO header msgSubject -- email subject msgDate -- time when the message was received (seconds since epoch) """ transportOut = TTransport.TMemoryBuffer() protocolOut = TBinaryProtocol.TBinaryProtocol(transportOut) timeInMilliSinceEpoch = msgDate * 1000 opsAlert = OpsAlert(src, msgFrom, msgTo, msgSubject, timeInMilliSinceEpoch) opsAlert.write(protocolOut) opsAlertInBytes = transportOut.getvalue() log.debug('Created: %s', str(opsAlert)) return scribe.LogEntry( "OpsAlert", str(timeInMilliSinceEpoch) + ":" + base64.b64encode(opsAlertInBytes))
def parseClientMessage(self, msg, channel, queue, thriftClient, iprot_factory=None): deliveryTag = msg.delivery_tag tr = TTransport.TMemoryBuffer(msg.content.body) if iprot_factory is None: iprot = self.factory.iprot_factory.getProtocol(tr) else: iprot = iprot_factory.getProtocol(tr) (fname, mtype, rseqid) = iprot.readMessageBegin() if rseqid in thriftClient._reqs: # log.msg('Got reply: fname = %r, rseqid = %s, mtype = %r, routing key = %r, client = %r, msg.content.body = %r' % (fname, rseqid, mtype, msg.routing_key, thriftClient, msg.content.body)) pass else: log.msg( 'Missing rseqid! fname = %r, rseqid = %s, mtype = %r, routing key = %r, client = %r, msg.content.body = %r' % (fname, rseqid, mtype, msg.routing_key, thriftClient, msg.content.body)) method = getattr(thriftClient, 'recv_' + fname) method(iprot, mtype, rseqid) channel.basic_ack(deliveryTag, True) d = queue.get() d.addCallback(self.parseClientMessage, channel, queue, thriftClient, iprot_factory=iprot_factory) d.addErrback(self.catchClosedClientQueue) d.addErrback(self.handleClientQueueError)
def do_POST(self): # Don't care about the request path. thttpserver._replied = False iftrans = TTransport.TFileObjectTransport(self.rfile) itrans = TTransport.TBufferedTransport( iftrans, int(self.headers['Content-Length'])) otrans = TTransport.TMemoryBuffer() iprot = thttpserver.inputProtocolFactory.getProtocol(itrans) oprot = thttpserver.outputProtocolFactory.getProtocol(otrans) try: thttpserver.processor.on_message_begin(self.on_begin) thttpserver.processor.process(iprot, oprot) except ResponseException as exn: exn.handler(self) else: if not thttpserver._replied: # If the request was ONEWAY we would have replied already data = otrans.getvalue() self.send_response(200) self.send_header("Content-Length", len(data)) self.send_header("Content-Type", "application/x-thrift") self.end_headers() self.wfile.write(data)
def test_TJSONProtol_read(self): expected = "{'software':'thrift','1':[23,1.2010000000000001,32767,2147483647,9223372036854775807],'base64':'hello thrift','bool':False}" read_data = '{"software":"thrift","1":[23,1.2010000000000001,32767,2147483647,9223372036854775807],"base64":"aGVsbG8gdGhyaWZ0","bool":0}' buff = TTransport.TMemoryBuffer(read_data.encode('utf-8')) transport = TTransport.TBufferedTransportFactory().getTransport(buff) protocol = TJSONProtocol(transport) protocol.readJSONObjectStart() u_1 = protocol.readString() u_2 = protocol.readString() u_3 = protocol.readString() protocol.readJSONArrayStart() u_4 = protocol.readNumber() u_5 = protocol.readDouble() u_6 = protocol.readI16() u_7 = protocol.readI32() u_8 = protocol.readI64() protocol.readJSONArrayEnd() u_9 = protocol.readString() u_10 = protocol.readJSONBase64() u_11 = protocol.readString() u_12 = protocol.readBool() protocol.writeJSONObjectEnd() result_read = {} result_read[u_1] = u_2 result_read[u_3] = [] result_read[u_3].append(u_4) result_read[u_3].append(u_5) result_read[u_3].append(u_6) result_read[u_3].append(u_7) result_read[u_3].append(u_8) result_read[u_9] = u_10.decode('utf-8') result_read[u_11] = u_12 self.assertEqual(eval(expected), result_read)
def _buildSerializationContext(self, bytes=None): self.transport = TTransport.TMemoryBuffer(bytes) protocol = SelfDescribingBinaryProtocol.SelfDescribingBinaryProtocol( self.transport) return ThriftSerializationContext.ThriftSerializationContext( self, protocol)
def _serialize(self, obj): trans = TTransport.TMemoryBuffer() prot = self.protocol_factory.getProtocol(trans) obj.write(prot) return trans.getvalue()
def _deserialize(self, objtype, data): prot = self.protocol_factory.getProtocol( TTransport.TMemoryBuffer(data)) ret = objtype() ret.read(prot) return ret
def createPackage(args, static_input, num_iterations): ''' Creates a Storm submission package for the given dispel4py graph. :param module_name: name of the graph module that creates a graph :param attr: name of the graph attribute within the module - if None the first WorkflowGraph is used :param res: resource directory - if None the default is "resources" :rtype: name of the temporary directory that contains the submission package ''' module_name = args.module attr = args.attr res = args.resources if res is None: res = 'resources' graph = loadGraph(module_name, attr) # we don't want any nested subgraphs graph.flatten() # create a temporary directory tmpdir = tempfile.mkdtemp() resources_dir = tmpdir + '/' + res # copy dependencies of PEs in the graph to resources in temp directory shutil.copytree(res, resources_dir) dispel4py_dir = resources_dir + '/dispel4py' _mkdir_ifnotexists(dispel4py_dir) _mkdir_ifnotexists(dispel4py_dir + '/storm') shutil.copy('dispel4py/__init__.py', dispel4py_dir) shutil.copy('dispel4py/core.py', dispel4py_dir) shutil.copy('dispel4py/base.py', dispel4py_dir) shutil.copy('dispel4py/__init__.py', dispel4py_dir + '/storm/') shutil.copy('dispel4py/storm/utils.py', dispel4py_dir + '/storm/') # copy client and dependencies for storm submission to the temp directory dispel4py_dir = tmpdir + '/dispel4py' _mkdir_ifnotexists(dispel4py_dir) _mkdir_ifnotexists(dispel4py_dir + '/storm') shutil.copy('dispel4py/__init__.py', dispel4py_dir) shutil.copy('dispel4py/__init__.py', dispel4py_dir + '/storm/') shutil.copy('dispel4py/storm/client.py', dispel4py_dir + '/storm/') shutil.copy('dispel4py/storm/storm_submission_client.py', tmpdir) shutil.copy('java/src/dispel4py/storm/ThriftSubmit.java', tmpdir + '/dispel4py/storm/') shutil.copytree('storm', tmpdir + '/storm') sources = [] for node in graph.graph.nodes(): pe = node.getContainedObject() is_source = True for edge in graph.graph.edges(node, data=True): if pe == edge[2]['DIRECTION'][1]: is_source = False break if is_source: sources.append(pe) print "Sources: %s" % [pe.id for pe in sources] for pe in sources: pe._static_input = static_input pe._num_iterations = num_iterations # create the storm topology topology = buildTopology(graph) # cache PE dependencies imported from the registry to resources_dir #registry.createResources(resources_dir, registry.currentRegistry()) # write thrift representation of the topology to a file transportOut = TTransport.TMemoryBuffer() protocolOut = TBinaryProtocol.TBinaryProtocol(transportOut) topology.write(protocolOut) bytes = transportOut.getvalue() with open(tmpdir + '/' + TOPOLOGY_THRIFT_FILE, "w") as thrift_file: thrift_file.write(bytes) return tmpdir
def set_py_cmd2msg(cmd, msg_name): return ff.ffscene_obj.set_py_cmd2msg(cmd, msg_name) def json_to_value(val_): return json.loads(val_) def protobuf_to_value(msg_type_, val_): dest = msg_type_() dest.ParseFromString(val_) return dest g_protocol = 0 #1 json g_ReadTMemoryBuffer = TTransport.TMemoryBuffer() g_ReadTBinaryProtocol = TBinaryProtocol.TBinaryProtocol(g_ReadTMemoryBuffer) def set_protocol_type(s): global g_protocol if s == "json": g_protocol = 1 print('set_protocol_type', g_protocol) return True def decode_buff(dest, val_): global g_ReadTMemoryBuffer, g_ReadTBinaryProtocol g_ReadTMemoryBuffer.cstringio_buf.truncate() g_ReadTMemoryBuffer.cstringio_buf.seek(0)
# Apache Thrift Memory Transport in Python import pickle from thrift.transport import TTransport class Trade: def __init__(self, symbol="", price=0.0, size=0): self.symbol = symbol self.price = price self.size = size trans = TTransport.TMemoryBuffer() trade = Trade("F", 13.10, 2500) trans.write(pickle.dumps(trade)) trans.cstringio_buf.seek(0) bstr = trans.read(4096) trade_read = pickle.loads(bstr) print("Trade(%d): %s %d @ %f" % (len(bstr), trade_read.symbol, trade_read.size, trade_read.price))
def encode_response(self, obj): trans = TTransport.TMemoryBuffer() prot = TJSONProtocol.TJSONProtocolFactory().getProtocol(trans) obj.write(prot) return trans.getvalue()
def serialize(thrift_obj): transportOut = TTransport.TMemoryBuffer() protocolOut = TBinaryProtocol.TBinaryProtocol(transportOut) thrift_obj.write(protocolOut) return transportOut.getvalue()
def deserialize(thrift_obj, binary): transportIn = TTransport.TMemoryBuffer(binary) protocolIn = TBinaryProtocol.TBinaryProtocol(transportIn) thrift_obj.read(protocolIn) return thrift_obj
def serialize(thrift_object, protocol_factory=TBinaryProtocol.TBinaryProtocolFactory()): transport = TTransport.TMemoryBuffer() protocol = protocol_factory.getProtocol(transport) thrift_object.write(protocol) return transport.getvalue()
def do_POST(self): """ Handles POST queries, which are usually Thrift messages. """ client_host, client_port = self.client_address self.auth_session = self.__check_session_cookie() LOG.info("%s:%s -- [%s] POST %s", client_host, str(client_port), self.auth_session.user if self.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 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', '/Configuration')) and \ not self.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( "%s:%s Invalid access, credentials not found " "- session refused.", client_host, str(client_port)) self.send_thrift_exception("Error code 401: Unauthorized!", iprot, oprot, otrans) 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, self.auth_session, self.server.config_session) processor = AuthAPI_v6.Processor(auth_handler) elif request_endpoint == 'Configuration': conf_handler = ConfigHandler_v6( self.auth_session, self.server.config_session) processor = ConfigAPI_v6.Processor(conf_handler) elif request_endpoint == 'Products': prod_handler = ProductHandler_v6( self.server, self.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, self.auth_session, self.server.config_session, checker_md_docs, checker_md_docs_map, version, self.server.context) 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: error_msg = "The API version you are using is not supported " \ "by this server (server API version: {0})!".format( get_version_str()) self.send_thrift_exception(error_msg, iprot, oprot, otrans) return 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: LOG.warning(str(exn)) import traceback traceback.print_exc() cstringio_buf = itrans.cstringio_buf.getvalue() if cstringio_buf: itrans = TTransport.TMemoryBuffer(cstringio_buf) iprot = input_protocol_factory.getProtocol(itrans) self.send_thrift_exception(str(exn), iprot, oprot, otrans) return
def __thrift_to_json(x): trans = TTransport.TMemoryBuffer() proto = TSimpleJSONProtocol.TSimpleJSONProtocol(trans) x.write(proto) return json.loads(trans.getvalue())
def _serialize(self, obj): trans = TTransport.TMemoryBuffer() prot = TSimpleJSONProtocolFactory().getProtocol(trans) obj.write(prot) return trans.getvalue()
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.debug("%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.server.get_product(product_endpoint) self.__check_prod_db(product) 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.server.get_product(product_endpoint) self.__check_prod_db(product) 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.error(exn.message) import traceback traceback.print_exc() ex = TApplicationException(TApplicationException.INTERNAL_ERROR, exn.message) 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