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
