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,
