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)