def run_panini(): app = panini_app.App( service_name="test_logs_in_separate_process", host="127.0.0.1", port=4222, logger_required=True, logger_in_separate_process=True, ) log = app.logger @app.listen("test_logs_in_separate_process.foo") async def subject_for_requests(msg): log.info(f"Got subject: {msg.subject}", message=msg.data) return {"success": True} @app.listen("test_logs_in_separate_process.foo.*.bar") async def composite_subject_for_requests(msg): log.error(f"Got subject: {msg.subject}", message=msg.data) return {"success": True} @app.listen("test_logs_in_separate_process.kill.logs") async def kill_logs(msg): app.logger_process.kill() return {"success": True} app.start()
def run_panini(): app = panini_app.App( service_name="test_validator", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) class DataValidator(Validator): data = Field(type=int) @app.listen("test_validator.foo", validator=DataValidator) async def publish(msg): return {"success": True} @app.listen("test_validator.check") async def check(msg): try: DataValidator.validated_message(msg.data) except ValidationError: return {"success": False} return {"success": True} app.start()
def run_panini(): app = panini_app.App( service_name="test_web_server", host="127.0.0.1", port=4222, app_strategy="asyncio", web_server=True, web_port=8084, logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) @app.listen("test_web_server.foo") async def foo(msg): msg.data["data"] += 1 return msg.data @app.http.post("/test_web_server/bar") async def post_listener(request): data = await request.json() data["data"] += 2 return web.json_response(data) app.start()
def run_panini(): app = panini_app.App( service_name="test_non_blocking_request", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_non_blocking_request.start") async def non_blocking_requests(msg): def handle_response(msg): app.publish_sync( "test_non_blocking_request.finalize", {"success": True, "data_type": type(msg.data).__name__}, ) for _ in range(msg_num): await app.request( subject="test_non_blocking_request.foo", message={"data": 1}, callback=handle_response, ) return {"success": True} @app.listen("test_non_blocking_request.foo") async def subject_for_requests_listener(msg): await asyncio.sleep(0.5) return {"success": True, "data": "request has been processed"} app.start()
def run_panini(): app = panini_app.App( service_name="test_validator", host="127.0.0.1", port=4222, app_strategy="asyncio", logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) class DataValidator(Validator): data = Field(type=int) @app.listen("test_validator.foo", validator=DataValidator) async def publish(msg): await app.publish(subject="test_validator.bar", message={"data": 1}) @app.listen("test_validator.check") async def check(msg): try: DataValidator.validated_message(msg.data) except ValidationError: return {"success": False} return {"success": True} app.start()
def run_panini(): app = panini_app.App( service_name="test_web_server_separately", host="127.0.0.1", port=4222, web_server=True, web_port=8083, logger_in_separate_process=False, ) @app.http.get("/test_web_server_separately/get") async def get_listener(request): return web.Response(text="get response") @app.http.post("/test_web_server_separately/post") async def post_listener(request): data = await request.json() data["data"] += 1 return web.json_response(data) @app.http.view("/test_web_server_separately/rest/endpoint") class RESTView(web.View): async def get(self): return await get_listener(self.request) async def post(self): return await post_listener(self.request) app.start()
def run_panini(): app = panini_app.App( service_name="test_middleware", host="127.0.0.1", port=4222, logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) @app.listen("test_middleware.publish") async def publish(msg): try: await app.publish( subject="test_middleware.publish.response", message={"data": msg.data["data"] + 1}, ) except Exception: app.logger.exception("test_middleware.publish") @app.listen("test_middleware.request") async def request(msg): try: response = await app.request( subject="test_middleware.request.helper", message={"data": msg.data["data"]}, ) return {"data": response["data"] + 2} except Exception: app.logger.exception("test_middleware.request") @app.listen("test_middleware.request.helper") async def helper(msg): try: return {"data": msg.data["data"] + 2} except Exception: app.logger.exception("test_middleware.request.helper") @app.listen("test_middleware.listen.publish") async def request(msg): try: await app.publish( subject="test_middleware.listen.publish.response", message={"data": msg.data["data"] + 3}, ) except Exception: app.logger.exception("test_middleware.listen.publish") @app.listen("test_middleware.listen.request") async def request(msg): try: return {"data": msg.data["data"] + 4} except Exception: app.logger.exception("test_middleware.listen.request") app.add_middleware(AddMiddleware) app.start()
def run_panini(): app = panini_app.App( service_name="test_request_listen_response", host="127.0.0.1", port=4222 ) @app.listen("test_request_listen_response.start") async def start(msg): await app.request("test_request_listen_response.app.started", {"success": True}) return {"success": True} app.start()
def run_panini(): app = panini_app.App( service_name="async_test_client_test_error_handling", host="127.0.0.1", port=4222, ) @app.listen("async_test_client.test_error_handling") async def listen(msg): error = 1 // 0 return {"success": False if error else True} app.start()
def app(): app = panini_app.App( service_name="test_middleware_dict_factory", host="127.0.0.1", port=4222, ) _MiddlewareManager.MIDDLEWARE = { "send_publish_middleware": [], "listen_publish_middleware": [], "send_request_middleware": [], "listen_request_middleware": [], } return app
def run_panini(): app = panini_app.App( service_name="test_publish", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_publish.foo") async def publish(msg): await app.publish(subject="test_publish.bar", message={"data": 1}) app.start()
def run_panini(): app = panini_app.App( service_name="test_timer_task", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.timer_task(0.1) async def publish_periodically(): await app.publish(subject="test_timer_task.foo", message={}) app.start()
def run_panini(): app = panini_app.App( service_name="test_request", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_request.start") async def publish_request(msg): await asyncio.sleep(1.1) return msg.data app.start()
def run_panini(): app = panini_app.App( service_name="test_request", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_request.start") async def publish_request(msg): response = await app.request(subject="test_request.foo", message={"data": 1}) return response app.start()
def run_panini(): app = panini_app.App( service_name="test_timeout", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_timeout.publish.request.not.existing.subject") async def publish_request(msg): return await app.request(subject="test_timeout.not-existing-subject", message={"data": 1}) app.start()
def run_panini(): app = panini_app.App( service_name="test_task", host="127.0.0.1", port=4222, app_strategy="asyncio", logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) @app.task() async def publish(): await app.publish(subject="test_task.foo", message={"data": 1}) app.start()
def run_panini(): app = panini_app.App( service_name="async_test_client_test_panini", host="127.0.0.1", port=4222, ) @app.listen("async_test_client.test_panini") async def listen(msg): helper_subject = "async_test_client.test_panini_helper" response = await app.request(helper_subject, {}) assert response["success"] is True assert response["subject"] == helper_subject return {"success": True, "subject": msg.subject} app.start()
def run_panini(): app = panini_app.App( service_name="test_listen", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_listen.foo") async def subject_for_requests(msg): return {"data": msg.data["data"] + 1} @app.listen("test_listen.foo.*.bar") async def composite_subject_for_requests(msg): return {"data": msg.subject + str(msg.data["data"])} app.start()
def app(): app = panini_app.App( service_name="test_middleware_manager", host="127.0.0.1", port=4222, ) _MiddlewareManager.MIDDLEWARE = { "send_publish_middleware": [], "listen_publish_middleware": [], "send_request_middleware": [], "listen_request_middleware": [], } yield app _MiddlewareManager.MIDDLEWARE = { "send_publish_middleware": [], "listen_publish_middleware": [], "send_request_middleware": [], "listen_request_middleware": [], }
def run_panini(): app = ant_app.App( service_name="test_wss", host="127.0.0.1", port=4222, app_strategy="asyncio", web_server=True, web_port=1111, logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) manager = WSSManager(app) @app.listen("test_wss.start") async def publish(msg): await app.publish(subject="test_wss.foo.bar", message={"data": 1}) @app.http.get("/test_wss/stream") async def web_endpoint_listener(request): ws = web.WebSocketResponse() await ws.prepare(request) connection_id = str(uuid.uuid4())[:10] await ws.send_str( json.dumps({ "success": True, "data": "Successfully connected" })) await manager.client_listener(ws, connection_id) await ws.close() return ws async def incoming_messages_callback(subscriber, msg): await subscriber.send_str( json.dumps({ "subject": msg.subject, "data": msg.data })) manager.callback = incoming_messages_callback app.http_server.web_app["subscribers"] = {} app.start()
def run_panini(): app = panini_app.App( service_name="test_encoding", host="127.0.0.1", port=4222, app_strategy="asyncio", logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) @app.listen("test_encoding.foo") async def foo(msg): return {"len": len(msg.data["data"])} @app.listen("test_encoding.helper.correct") async def helper(msg): return {"data": "data"} @app.listen("test_encoding.helper.incorrect") async def helper(msg): return "message not dict" @app.listen("test_encoding.message.incorrect") async def bar(msg): await app.request(subject="test_encoding.helper.correct", message="message not dict") return {"success": True} @app.listen("test_encoding.message.correct") async def bar(msg): await app.request(subject="test_encoding.helper.incorrect", message={"data": "some data"}) return {"success": True} @app.listen("test_encoding.correct") async def bar(msg): await app.request(subject="test_encoding.helper.correct", message={"data": "some data"}) return {"success": True} app.start()
def run_panini(): app = panini_app.App( service_name="test_parameter_listen_subject_only_if_exclude", host="127.0.0.1", port=4222, listen_subject_only_if_exclude=["start"], logger_in_separate_process=False, ) @app.listen("test_parameter_listen_subject_only_if_exclude.start") async def start(msg): return {"data": 1} @app.listen("test_parameter_listen_subject_only_if_exclude.foo") async def foo(msg): return {"data": 2} @app.listen("test_parameter_listen_subject_only_if_exclude.bar") async def start(msg): return {"data": 3} app.start()
def run_panini(): app = panini_app.App( service_name="test_reply_to", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("test_reply_to.start") async def reply_to(msg): await app.publish( message={"data": 1}, subject="test_reply_to.foo", reply_to="test_reply_to.bar", ) @app.listen("test_reply_to.foo") async def helper(msg): msg.data["data"] += 2 return msg.data app.start()
def run_panini(): app = panini_app.App( service_name="test_logs", host="127.0.0.1", port=4222, app_strategy="asyncio", logger_required=True, logger_files_path=testing_logs_directory_path, logger_in_separate_process=False, ) log = app.logger @app.listen("test_logs.foo") async def subject_for_requests(msg): log.info(f"Got subject: {msg.subject}", message=msg.data) return {"success": True} @app.listen("test_logs.foo.*.bar") async def composite_subject_for_requests(msg): log.error(f"Got subject: {msg.subject}", message=msg.data) return {"success": True} app.start()
def run_panini(): app = panini_app.App( service_name="test_listen_subject_only_if_include", host="127.0.0.1", port=4222, listen_subject_only_if_include=["foo", "bar"], app_strategy="asyncio", logger_in_separate_process=False, logger_files_path=get_logger_files_path(), ) @app.listen("test_parameter_listen_subject_only_if_include.start") async def start(msg): return {"data": 1} @app.listen("test_parameter_listen_subject_only_if_include.foo") async def foo(msg): return {"data": 2} @app.listen("test_parameter_listen_subject_only_if_include.bar") async def start(msg): return {"data": 3} app.start()
import os from panini import app as panini_app app = panini_app.App( service_name="microservice2", host="nats-server" if "HOSTNAME" in os.environ else "127.0.0.1", port=4222, ) log = app.logger @app.listen("some.publish.subject") async def receive_messages(subject, message): log.warning(f"got message {message}") if __name__ == "__main__": app.start()
""" example from https://github.com/lwinterface/panini/blob/master/examples/simple_examples/async_wss_web_server.py """ import uuid import random import json from aiohttp import web from panini import app as panini_app from wss._wss_manager import WSSManager, html app = panini_app.App( service_name="async_NATS_WSS_bridge", host="127.0.0.1", port=4222, web_server=True, web_port=2222, ) log = app.logger test_msg = { "key1": "value1", "key2": 2, "key3": 3.0, "key4": [1, 2, 3, 4], "key5": { "1": 1, "2": 2, "3": 3, "4": 4, "5": 5 }, "key6": {
from panini import app as panini_app app = panini_app.App( service_name="separate_file", host="127.0.0.1", port=4222, logger_in_separate_process=False, ) @app.listen("separate_file.async_test_client.listen_request") async def listen_request(msg): return { "success": True, "message": "separate_file.async_test_client.listen_request", } if __name__ == "__main__": app.start()
import json from panini import app as panini_app app = panini_app.App( service_name="request_for_location_history", host="127.0.0.1", port=4222, ) log = app.logger def _process_request(subject, message): return f'processed {subject}: {message}' @app.listen('aircraft_location_history_request.*') async def request_listener(msg): subject = msg.subject message = msg.data result = _process_request(subject, message) return {'success': True, 'data': result} if __name__ == "__main__": app.start()
from panini import app as panini_app from panini.middleware.nats_timeout import NATSTimeoutMiddleware app = panini_app.App( service_name="async_nats_timeout_middleware", host="127.0.0.1", port=4222, ) log = app.logger message = { "key1": "value1", "key2": 2, "key3": 3.0, "key4": [1, 2, 3, 4], "key5": { "1": 1, "2": 2, "3": 3, "4": 4, "5": 5 }, "key6": { "subkey1": "1", "subkey2": 2, "3": 3, "4": 4, "5": 5 }, "key7": None,