def _buyAlbum(self, ctx, ASIN, acct):
buffer = TMemoryOutputBuffer(self._transport.get_request_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin('buyAlbum', TMessageType.CALL, 0)
args = buyAlbum_args()
args.ASIN = ASIN
args.acct = acct
args.write(oprot)
oprot.writeMessageEnd()
response_transport = yield self._transport.request(
ctx, buffer.getvalue())
iprot = self._protocol_factory.get_protocol(response_transport)
iprot.read_response_headers(ctx)
_, mtype, _ = iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = buyAlbum_result()
result.read(iprot)
iprot.readMessageEnd()
if result.error is not None:
raise result.error
if result.success is not None:
raise gen.Return(result.success)
raise TApplicationException(TApplicationExceptionType.MISSING_RESULT,
"buyAlbum failed: unknown result")
def _enterAlbumGiveaway(self, ctx, email, name):
buffer = TMemoryOutputBuffer(self._transport.get_request_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin('enterAlbumGiveaway', TMessageType.CALL, 0)
args = enterAlbumGiveaway_args()
args.email = email
args.name = name
args.write(oprot)
oprot.writeMessageEnd()
response_transport = yield self._transport.request(
ctx, buffer.getvalue())
iprot = self._protocol_factory.get_protocol(response_transport)
iprot.read_response_headers(ctx)
_, mtype, _ = iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = enterAlbumGiveaway_result()
result.read(iprot)
iprot.readMessageEnd()
if result.success is not None:
raise gen.Return(result.success)
raise TApplicationException(
TApplicationExceptionType.MISSING_RESULT,
"enterAlbumGiveaway failed: unknown result")
def _basePing(self, ctx):
buffer = TMemoryOutputBuffer(self._transport.get_request_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin('basePing', TMessageType.CALL, 0)
args = basePing_args()
args.write(oprot)
oprot.writeMessageEnd()
response_transport = yield self._transport.request(
ctx, buffer.getvalue())
iprot = self._protocol_factory.get_protocol(response_transport)
iprot.read_response_headers(ctx)
_, mtype, _ = iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = basePing_result()
result.read(iprot)
iprot.readMessageEnd()
async def _on_message_callback(self, message):
"""The function to be executed when a message is received."""
if not message.reply:
logger.warn('no reply present, discarding message')
return
frame_size = struct.unpack('!I', message.data[:4])[0]
if frame_size > _NATS_MAX_MESSAGE_SIZE - 4:
logger.warning('frame size too large, dropping message')
return
# process frame, first four bytes are the frame size
iprot = self._protocol_factory.get_protocol(
TMemoryBuffer(message.data[4:]))
otrans = TMemoryOutputBuffer(_NATS_MAX_MESSAGE_SIZE)
oprot = self._protocol_factory.get_protocol(otrans)
try:
await self._processor.process(iprot, oprot)
except TApplicationException:
# Continue so the exception is sent to the client
pass
except Exception:
return
if len(otrans) == 4:
return
await self._nats_client.publish(message.reply, otrans.getvalue())
def _publish_Winner(self, ctx, req):
op = 'Winner'
prefix = 'v1.music.'
topic = '{}AlbumWinners{}{}'.format(prefix, self._DELIMITER, op)
buffer = TMemoryOutputBuffer(self._transport.get_publish_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin(op, TMessageType.CALL, 0)
req.write(oprot)
oprot.writeMessageEnd()
self._transport.publish(topic, buffer.getvalue())
def _publish_SomeInt(self, ctx, user, req):
op = 'SomeInt'
prefix = 'foo.{}.'.format(user)
topic = '{}Events{}{}'.format(prefix, self._DELIMITER, op)
buffer = TMemoryOutputBuffer(self._transport.get_publish_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin(op, TMessageType.CALL, 0)
oprot.writeI64(req)
oprot.writeMessageEnd()
self._transport.publish(topic, buffer.getvalue())
def _publish_EventCreated(self, ctx, user, req):
ctx.set_request_header('_topic_user', user)
op = 'EventCreated'
prefix = 'foo.{}.'.format(user)
topic = '{}Events{}{}'.format(prefix, self._DELIMITER, op)
buffer = TMemoryOutputBuffer(self._transport.get_publish_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin(op, TMessageType.CALL, 0)
req.write(oprot)
oprot.writeMessageEnd()
yield self._transport.publish(topic, buffer.getvalue())
def _publish_ContestStart(self, ctx, req):
op = 'ContestStart'
prefix = 'v1.music.'
topic = '{}AlbumWinners{}{}'.format(prefix, self._DELIMITER, op)
buffer = TMemoryOutputBuffer(self._transport.get_publish_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin(op, TMessageType.CALL, 0)
oprot.writeListBegin(TType.STRUCT, len(req))
for elem3 in req:
elem3.write(oprot)
oprot.writeListEnd()
oprot.writeMessageEnd()
self._transport.publish(topic, buffer.getvalue())
def _publish_SomeList(self, ctx, user, req):
op = 'SomeList'
prefix = 'foo.{}.'.format(user)
topic = '{}Events{}{}'.format(prefix, self._DELIMITER, op)
buffer = TMemoryOutputBuffer(self._transport.get_publish_size_limit())
oprot = self._protocol_factory.get_protocol(buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin(op, TMessageType.CALL, 0)
oprot.writeListBegin(TType.MAP, len(req))
for elem56 in req:
oprot.writeMapBegin(TType.I64, TType.STRUCT, len(elem56))
for elem58, elem57 in elem56.items():
oprot.writeI64(elem58)
elem57.write(oprot)
oprot.writeMapEnd()
oprot.writeListEnd()
oprot.writeMessageEnd()
self._transport.publish(topic, buffer.getvalue())
def test_process_missing_function(self):
processor = FBaseProcessor()
frame = bytearray(
b'\x00\x00\x00\x004\x00\x00\x00\x04_cid\x00\x00\x00\x06someid'
b'\x00\x00\x00\x05_opid\x00\x00\x00\x011\x00\x00\x00\x08_timeout'
b'\x00\x00\x00\x045000' # End of context
b'\x80\x01\x00\x02\x00\x00\x00\x08basePing\x00\x00\x00\x00\x00')
itrans = TMemoryBuffer(value=frame)
iprot = FProtocolFactory(TBinaryProtocolFactory()).get_protocol(itrans)
otrans = TMemoryOutputBuffer(1000)
oprot = FProtocolFactory(TBinaryProtocolFactory()).get_protocol(otrans)
yield processor.process(iprot, oprot)
expected_response = bytearray(
b'\x80\x01\x00\x03\x00\x00\x00\x08basePing\x00\x00'
b'\x00\x00\x0b\x00\x01\x00\x00\x00\x1aUnknown function: basePing'
b'\x08\x00\x02\x00\x00\x00\x01\x00')
self.assertEqual(otrans.getvalue()[41:], expected_response)
async def _getAuthQrcode(self, ctx, keepLoggedIn, systemName,
returnCallbackUrl):
memory_buffer = TMemoryOutputBuffer(
self._transport.get_request_size_limit())
oprot = self._protocol_factory.get_protocol(memory_buffer)
oprot.write_request_headers(ctx)
oprot.writeMessageBegin('getAuthQrcode', TMessageType.CALL, 0)
args = getAuthQrcode_args()
args.keepLoggedIn = keepLoggedIn
args.systemName = systemName
args.returnCallbackUrl = returnCallbackUrl
args.write(oprot)
oprot.writeMessageEnd()
response_transport = await self._transport.request(
ctx, memory_buffer.getvalue())
iprot = self._protocol_factory.get_protocol(response_transport)
iprot.read_response_headers(ctx)
_, mtype, _ = iprot.readMessageBegin()
if mtype == TMessageType.EXCEPTION:
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
if x.type == TApplicationExceptionType.RESPONSE_TOO_LARGE:
raise TTransportException(
type=TTransportExceptionType.RESPONSE_TOO_LARGE,
message=x.message)
raise x
result = getAuthQrcode_result()
result.read(iprot)
iprot.readMessageEnd()
if result.e is not None:
raise result.e
if result.success is not None:
return result.success
raise TApplicationException(TApplicationExceptionType.MISSING_RESULT,
"getAuthQrcode failed: unknown result")
def post(self):
self.set_header('content-type', 'application/x-frugal')
# check for response size limit
response_limit = 0
limit_header_name = "x-frugal-payload-limit"
if self.request.headers.get(limit_header_name) is not None:
response_limit = int(self.request.headers[limit_header_name])
# decode payload and process
payload = base64.b64decode(self.request.body)
iprot = self._protocol_factory.get_protocol(TMemoryBuffer(payload[4:]))
# TODO could be better with this limit
otrans = TMemoryOutputBuffer(0)
oprot = self._protocol_factory.get_protocol(otrans)
try:
yield gen.maybe_future(self._processor.process(iprot, oprot))
except TApplicationException:
# Continue so the exception is sent to the client
pass
except Exception:
self.send_error(status_code=400)
return
# write back response
output_data = otrans.getvalue()
if len(output_data) > response_limit > 0:
self.send_error(status_code=413)
return
output_payload = base64.b64encode(output_data)
self.set_header('content-transfer-encoding', 'base64')
self.write(output_payload)
class TestTOutputMemoryBuffer(unittest.TestCase):
def setUp(self):
super(TestTOutputMemoryBuffer, self).setUp()
self.buffer = TMemoryOutputBuffer(10)
def test_write(self):
self.buffer.write(b'foo')
self.assertSequenceEqual(b'\x00\x00\x00\x03foo', self.buffer.getvalue())
def test_write_size_exception(self):
self.assertEqual(4, len(self.buffer))
self.buffer.write(bytearray(6))
self.assertEqual(10, len(self.buffer))
with self.assertRaises(TTransportException) as cm:
self.buffer.write(bytearray(1))
self.assertEqual(TTransportExceptionType.REQUEST_TOO_LARGE,
cm.exception.type)
self.assertEqual(4, len(self.buffer))
def test_len(self):
self.buffer.write(b'12345')
self.assertEqual(len(self.buffer), 9)
def setUp(self):
super(TestTOutputMemoryBuffer, self).setUp()
self.buffer = TMemoryOutputBuffer(10)
