async def main():
# Declare the protocol stack used for serialization.
# Protocol stacks must match between clients and servers.
prot_factory = FProtocolFactory(TBinaryProtocol.TBinaryProtocolFactory())
# Open a NATS connection to send requests
nats_client = NatsClient()
options = {"verbose": True, "servers": ["nats://127.0.0.1:4222"]}
await nats_client.connect(**options)
# Create a nats transport using the connected client
# The transport sends data on the music-service NATS topic
nats_transport = FNatsTransport(nats_client, "music-service")
try:
await nats_transport.open()
except TTransportException as ex:
root.error(ex)
return
# Using the configured transport and protocol, create a client
# to talk to the music store service.
store_client = FStoreClient(FServiceProvider(nats_transport, prot_factory),
middleware=logging_middleware)
album = await store_client.buyAlbum(FContext(), str(uuid.uuid4()),
"ACT-12345")
root.info("Bought an album %s\n", album.tracks[0].title)
await store_client.enterAlbumGiveaway(FContext(), "*****@*****.**",
"Kevin")
# Close transport and nats client
await nats_transport.close()
await nats_client.close()
def test_handle_response_none(self):
transport = FAsyncTransport()
ctx = FContext()
future = Future()
transport._futures[str(ctx._get_op_id())] = future
yield transport.handle_response(None)
self.assertFalse(future.done())
def main():
logging.info("Starting...")
# Declare the protocol stack used for serialization.
# Protocol stacks must match between clients and servers.
prot_factory = FProtocolFactory(TBinaryProtocol.TBinaryProtocolFactory())
# Create an HTTP transport for the server URL
transport = THttpTransport(URL)
transport.open()
# Using the configured transport and protocol, create a client
# to talk to the music store service.
store_client = FStoreClient(FServiceProvider(transport, prot_factory))
album = store_client.buyAlbum(FContext(),
str(uuid.uuid4()),
"ACT-12345")
root.info("Bought an album %s\n", album)
store_client.enterAlbumGiveaway(FContext(),
"*****@*****.**",
"Kevin")
# Close the transport
transport.close()
async def main():
# Declare the protocol stack used for serialization.
# Protocol stacks must match between publishers and subscribers.
prot_factory = FProtocolFactory(TBinaryProtocol.TBinaryProtocolFactory())
# Open a aiostomp connection, default stomp port in activemq is 61613
stomp_client = AioStomp('localhost', 61613)
await stomp_client.connect()
# Create a pub sub scope using the configured transport and protocol
transport_factory = FStompPublisherTransportFactory(stomp_client)
provider = FScopeProvider(transport_factory, None, prot_factory)
# Create a publisher
publisher = AlbumWinnersPublisher(provider)
await publisher.open()
# Publish an album win event
album = Album()
album.ASIN = str(uuid.uuid4())
album.duration = 12000
album.tracks = [
Track(title="Comme des enfants",
artist="Coeur de pirate",
publisher="Grosse Boîte",
composer="Béatrice Martin",
duration=169,
pro=PerfRightsOrg.ASCAP)
]
await publisher.publish_Winner(FContext(), album)
await publisher.publish_ContestStart(FContext(), [album, album])
# Close publisher and nats client
await publisher.close()
stomp_client.close()
def read_request_headers(self):
"""
Reads the request headers out of the underlying TTransportBase and
return an FContext
Returns:
FContext
"""
headers = _Headers._read(self.get_transport())
context = FContext()
for key, value in headers.items():
context.set_request_header(key, value)
op_id = headers[_OPID_HEADER]
context._set_response_op_id(op_id)
# Put a new opid in the request headers so this context an be
# used/propagated on the receiver
context.set_request_header(_OPID_HEADER, _get_next_op_id())
cid = context.correlation_id
if cid:
context.set_response_header(_CID_HEADER, cid)
return context
def test_handle_response_unregistered_op_id(self):
transport = FAsyncTransport()
ctx1 = FContext()
ctx2 = FContext()
future = Future()
transport._futures[str(ctx1._get_op_id())] = future
yield transport.handle_response(utils.mock_frame(ctx2))
self.assertFalse(future.done())
def test_oneway_not_open(self):
ctx = FContext("fooid")
ctx.timeout = 10
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl(is_open=False)
with self.assertRaises(TTransportException) as cm:
yield transport.oneway(ctx, frame)
self.assertEqual(TTransportExceptionType.NOT_OPEN, cm.exception.type)
self.assertIsNone(transport._payload)
async def test_oneway_timeout(self):
ctx = FContext("fooid")
ctx.timeout = 10
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl(flush_wait=1)
with self.assertRaises(TTransportException) as cm:
await transport.oneway(ctx, frame)
self.assertEqual(TTransportExceptionType.TIMED_OUT, cm.exception.type)
self.assertEqual(frame, transport._payload)
def test_oneway_size_exception(self):
ctx = FContext("fooid")
ctx.timeout = 10
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl(request_size_limit=1)
with self.assertRaises(TTransportException) as cm:
yield transport.oneway(ctx, frame)
self.assertEqual(TTransportExceptionType.REQUEST_TOO_LARGE,
cm.exception.type)
self.assertIsNone(transport._payload)
def test_read_response_headers(self, mock_read):
headers = {_OPID_HEADER: "0", "_cid": "someid"}
mock_read.return_value = headers
context = FContext("someid")
self.protocol.read_response_headers(context)
self.assertEqual("0", context.get_response_header(_OPID_HEADER))
self.assertEqual("someid", context.get_response_header("_cid"))
async def test_request_not_open(self):
ctx = FContext("fooid")
ctx.timeout = 10
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl(is_open=False)
with self.assertRaises(TTransportException) as cm:
await transport.request(ctx, frame)
self.assertEqual(TTransportExceptionType.NOT_OPEN, cm.exception.type)
self.assertEqual(0, len(transport._futures))
self.assertIsNone(transport._payload)
def test_request_response_timeout(self):
ctx = FContext("fooid")
ctx.timeout = 10
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl()
with self.assertRaises(TTransportException) as cm:
yield transport.request(ctx, frame)
self.assertEqual(TTransportExceptionType.TIMED_OUT, cm.exception.type)
self.assertEqual("request timed out", cm.exception.message)
self.assertEqual(0, len(transport._futures))
self.assertEqual(frame, transport._payload)
def test_read_response_headers(self, mock_read):
headers = {_OPID_HEADER: "0", "_cid": "someid"}
mock_read.return_value = headers
context = FContext("someid")
self.protocol.read_response_headers(context)
# Ensure the opid is not set when the response headers are read in
self.assertIsNone(context.get_response_header(_OPID_HEADER))
self.assertEqual("someid", context.get_response_header("_cid"))
def test_write_header_given_fcontext(self):
ctx = FContext("corrId")
# Manually set the op id to avoid changes to global op id
ctx._set_op_id(0)
expected = bytearray(b'\x00\x00\x00\x00 \x00\x00\x00\x05_opid\x00\x00'
b'\x00\x010\x00\x00\x00\x04_cid\x00\x00\x00\x06'
b'corrId\x00\x00\x00\x08_timeout\x00\x00\x00'
b'\x044000')
buff = self.headers._write_to_bytearray(ctx.get_request_headers())
self.assertEqual(len(expected), len(buff))
def test_write_response_headers(self, mock_write):
context = FContext("foo")
mock_write.return_value = "bar"
mock_trans = mock.Mock()
self.protocol.trans = mock_trans
self.protocol.write_response_headers(context)
mock_write.assert_called_with(context.get_response_headers())
mock_trans.write.assert_called_with("bar")
def test_write_read(self):
context = FContext("corrId")
context.set_request_header("foo", "bar")
expected = context.get_request_headers()
buff = self.headers._write_to_bytearray(expected)
actual = self.headers._read(BytesIO(buff))
self.assertEqual(expected["_opid"], actual["_opid"])
self.assertEqual(expected["_cid"], actual["_cid"])
self.assertEqual(expected["foo"], actual["foo"])
def test_request_pending(self):
ctx = FContext("fooid")
ctx.timeout = 100
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl()
with self.assertRaises(TTransportException) as cm:
transport.request(ctx, frame),
yield transport.request(ctx, frame)
self.assertEqual(TTransportExceptionType.UNKNOWN, cm.exception.type)
self.assertEqual("request already in flight for context",
cm.exception.message)
# We still have one request pending
self.assertEqual(1, len(transport._futures))
def test_oneway(self):
ctx = FContext("fooid")
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl()
response = yield transport.oneway(ctx, frame)
self.assertIsNone(response)
self.assertEqual(frame, transport._payload)
def __init__(self): self.context = FContext() self.transport = HttpClient(config.BASE_URL + "/LIFF1") self.protocol_factory = TCompactProtocolAcceleratedFactory() self.wrapper_factory = LegyProtocolFactory(self.protocol_factory) self.service_provider = FServiceProvider(self.transport, self.wrapper_factory) self.client = self.LiffClients()
def test_request(self):
self.transport._http = self.http_mock
request_data = bytearray([4, 5, 6, 8, 9, 10, 11, 13, 12, 3])
request_frame = bytearray([0, 0, 0, 10]) + request_data
response_mock = mock.Mock(spec=HTTPResponse)
response_data = bytearray([23, 24, 25, 26, 27, 28, 29])
response_frame = bytearray([0, 0, 0, 10]) + response_data
response_encoded = base64.b64encode(response_frame)
response_mock.body = response_encoded
response_future = Future()
response_future.set_result(response_mock)
self.http_mock.fetch.return_value = response_future
ctx = FContext()
response_transport = yield self.transport.request(ctx, request_frame)
self.assertEqual(response_data, response_transport.getvalue())
self.assertTrue(self.http_mock.fetch.called)
request = self.http_mock.fetch.call_args[0][0]
self.assertEqual(request.url, self.url)
self.assertEqual(request.method, 'POST')
self.assertEqual(request.body, base64.b64encode(request_frame))
self.assertEqual(request.headers, self.headers)
async def test_get_auth_qrcode(api: TalkApi):
"""`getAuthQrcode`のテストコード
この関数で実際にAPIとの疎通が出来るか確認する
"""
res = await api.getAuthQrcode(FContext(), False, "pyne", False)
assert bool(res)
async def test_request_extra_headers_with_context(self):
def generate_test_header(fcontext):
return {
'first-header': fcontext.correlation_id,
'second-header': 'test'
}
transport_with_headers = FHttpTransport(
self.url,
request_capacity=self.request_capacity,
response_capacity=self.response_capacity,
get_request_headers=generate_test_header)
transport_with_headers._make_request = self.make_request_mock
request_data = bytearray([4, 5, 6, 7, 8, 9, 10, 11, 13, 12, 3])
request_frame = bytearray([0, 0, 0, 11]) + request_data
response_data = bytearray([23, 24, 25, 26, 27, 28, 29])
response_frame = bytearray([0, 0, 0, 7]) + response_data
response_encoded = base64.b64encode(response_frame)
response_future = Future()
response_future.set_result((200, response_encoded))
self.make_request_mock.return_value = response_future
ctx = FContext()
response_transport = await transport_with_headers.request(
ctx, request_frame)
self.assertEqual(response_data, response_transport.getvalue())
self.assertTrue(self.make_request_mock.called)
request_args = self.make_request_mock.call_args[0]
self.assertEqual(request_args[0], ctx)
self.assertEqual(request_args[1], base64.b64encode(request_frame))
async def test_rpc(client, ctx, transport):
test_failed = False
# Iterate over all expected RPC results
for rpc, vals in rpc_test_definitions(transport):
method = getattr(client, rpc)
args = vals['args']
expected_result = vals['expected_result']
ctx = FContext(rpc)
result = None
try:
if args:
result = await method(ctx, *args)
else:
result = await method(ctx)
except Exception as e:
result = e
test_failed = check_for_failure(result, expected_result) or test_failed
# oneWay RPC call (no response)
seconds = 1
try:
await client.testOneway(ctx, seconds)
except Exception as e:
print("Unexpected error in testOneway() call: {}".format(e))
test_failed = True
if test_failed:
exit(1)
def test_request_response_error(self):
self.transport._http = self.http_mock
self.http_mock.fetch.side_effect = HTTPError(code=404)
with self.assertRaises(TTransportException):
yield self.transport.request(FContext(), bytearray([0, 0, 0, 1,
0]))
def test_request(self):
ctx = FContext("fooid")
frame = utils.mock_frame(ctx)
transport = FAsyncTransportImpl(response=frame)
response_transport = yield transport.request(ctx, frame)
self.assertEqual(frame, response_transport.getvalue())
self.assertEqual(0, len(transport._futures))
self.assertEqual(frame, transport._payload)
def main():
parser = argparse.ArgumentParser(description="Run a python tornado client")
parser.add_argument('--port', dest='port', default='9090')
parser.add_argument('--protocol',
dest='protocol_type',
default="binary",
choices="binary, compact, json")
parser.add_argument('--transport',
dest='transport_type',
default=NATS_NAME,
choices="nats, http")
args = parser.parse_args()
protocol_factory = get_protocol_factory(args.protocol_type)
nats_client = NATS()
logging.debug("Connecting to NATS")
yield nats_client.connect(**get_nats_options())
transport = None
if args.transport_type == NATS_NAME:
transport = FNatsTransport(nats_client,
"frugal.foo.bar.rpc.{}".format(args.port))
elif args.transport_type == HTTP_NAME:
# Set request and response capacity to 1mb
max_size = 1048576
transport = FHttpTransport("http://localhost:" + str(args.port),
request_capacity=max_size,
response_capacity=max_size)
else:
print("Unknown transport type: {}".format(args.transport_type))
sys.exit(1)
try:
yield transport.open()
except TTransportException as ex:
logging.error(ex)
raise gen.Return()
client = FrugalTestClient(FServiceProvider(transport, protocol_factory),
client_middleware)
ctx = FContext("test")
yield test_rpc(client, ctx, args.transport_type)
if transport == NATS_NAME:
yield test_pub_sub(nats_client, protocol_factory, args.port)
global middleware_called
if not middleware_called:
print("Client middleware never invoked")
exit(1)
# Cleanup after tests
yield nats_client.close()
def test_timeout(self):
# Check default timeout (5 seconds).
context = FContext()
self.assertEqual(5000, context.timeout)
self.assertEqual("5000", context.get_request_header("_timeout"))
# Set timeout and check expected values.
context.set_timeout(10000)
self.assertEqual(10000, context.timeout)
self.assertEqual("10000", context.get_request_header("_timeout"))
# Check timeout passed to constructor.
context = FContext(timeout=1000)
self.assertEqual(1000, context.timeout)
self.assertEqual("1000", context.get_request_header("_timeout"))
def test_request_response_too_large(self):
self.transport._http = self.http_mock
self.http_mock.fetch.side_effect = HTTPError(code=413)
with self.assertRaises(TTransportException) as cm:
yield self.transport.request(FContext(), bytearray([0, 0, 0, 1,
0]))
self.assertEqual(cm.exception.message, 'response was too large')
def test_request_timeout(self):
self.transport._http = self.http_mock
self.http_mock.fetch.side_effect = HTTPError(code=599)
with self.assertRaises(TTransportException) as cm:
yield self.transport.request(FContext(), bytearray([0, 0, 0, 1,
0]))
self.assertEqual(TTransportExceptionType.TIMED_OUT, cm.exception.type)
self.assertEqual("request timed out", cm.exception.message)
async def test_oneway(self):
response_encoded = base64.b64encode(bytearray([0, 0, 0, 0]))
response_future = Future()
response_future.set_result((200, response_encoded))
self.make_request_mock.return_value = response_future
self.assertIsNone(await self.transport.oneway(
FContext(), bytearray([0, 0, 0, 3, 1, 2, 3])))
self.assertTrue(self.make_request_mock.called)
