zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/docker-compose.yml

@@ -344,10 +344,11 @@ services:
     profiles:
     - monolith
     healthcheck:
-      test: ["CMD-SHELL", "curl --fail http://localhost:${APP_PORT:-8080}/readiness || exit 1"]
-      interval: 5s
+      test: curl --fail http://localhost:${APP_GATEWAY_PORT:-8080}/readiness || killall uvicorn
+      interval: 20s
       timeout: 3s
       retries: 10
+      start_period: 20s
     networks:
     - zrb
 
@@ -381,10 +382,11 @@ services:
     profiles:
     - microservices
     healthcheck:
-      test: ["CMD-SHELL", "curl --fail http://localhost:${APP_GATEWAY_PORT:-8080}/readiness || exit 1"]
-      interval: 5s
+      test:  curl --fail http://localhost:${APP_GATEWAY_PORT:-8080}/readiness || killall uvicorn
+      interval: 20s
       timeout: 3s
       retries: 10
+      start_period: 20s
     networks:
     - zrb
 
@@ -414,12 +416,11 @@ services:
     profiles:
     - microservices
     healthcheck:
-      test:
-      - CMD-SHELL
-      - curl --fail http://localhost:${APP_AUTH_MODULE_PORT:-8081}/readiness || exit 1
-      interval: 5s
+      test: curl --fail http://localhost:${APP_AUTH_MODULE_PORT:-8081}/readiness || killall uvicorn
+      interval: 20s
       timeout: 3s
       retries: 10
+      start_period: 20s
     networks:
     - zrb
 
@@ -449,11 +450,10 @@ services:
     profiles:
     - microservices
     healthcheck:
-      test:
-      - CMD-SHELL
-      - curl --fail http://localhost:${APP_LOG_MODULE_PORT:-8082}/readiness || exit 1
-      interval: 5s
+      test: curl --fail http://localhost:${APP_LOG_MODULE_PORT:-8082}/readiness || killall uvicorn
+      interval: 20s
       timeout: 3s
       retries: 10
+      start_period: 20s
     networks:
     - zrb

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/loadtest/locustfile.py

@@ -1,11 +1,12 @@
-from locust import HttpUser, task, between
 import os
 
+from locust import HttpUser, between, task
+
 access_token_cookie_key = os.getenv(
-    'PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY', 'access_token'
+    "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"
 )
-admin_username = os.getenv('APP_AUTH_ADMIN_USERNAME', 'root')
-admin_password = os.getenv('APP_AUTH_ADMIN_PASSWORD', 'toor')
+admin_username = os.getenv("APP_AUTH_ADMIN_USERNAME", "root")
+admin_password = os.getenv("APP_AUTH_ADMIN_PASSWORD", "toor")
 
 
 class QuickstartUser(HttpUser):
@@ -13,20 +14,17 @@ class QuickstartUser(HttpUser):
 
     @task(2)
     def homepage(self):
-        self.client.get('/')
+        self.client.get("/")
 
     @task
     def permissions(self):
-        self.client.get('/api/v1/auth/permissions')
+        self.client.get("/api/v1/auth/permissions")
 
     def on_start(self):
         login_response = self.client.post(
-            '/api/v1/auth/login',
-            json={
-                'identity': admin_username,
-                'password': admin_password
-            }
+            "/api/v1/auth/login",
+            json={"identity": admin_username, "password": admin_password},
         )
         login_response_json = login_response.json()
-        access_token = login_response_json.get('access_token')
+        access_token = login_response_json.get("access_token")
         self.client.cookies.set(access_token_cookie_key, access_token)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/Dockerfile

@@ -10,6 +10,7 @@ ENV APP_HOST 0.0.0.0
 ENV APP_PORT 8080
 WORKDIR /home
 COPY requirements.txt .
+RUN apt update && apt install curl psmisc -y
 RUN pip install -r requirements.txt
 COPY . .
 COPY --from=frontend-builder /frontend/build /home/frontend/build

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/app.py

@@ -1,28 +1,35 @@
+from component.app_lifespan import app_lifespan, app_state
+from component.frontend_index import frontend_index_response
+from config import (
+    app_cors_allow_credentials,
+    app_cors_allow_headers,
+    app_cors_allow_methods,
+    app_cors_allow_origin_regex,
+    app_cors_allow_origins,
+    app_cors_expose_headers,
+    app_cors_max_age,
+    app_enable_frontend,
+    public_auth_access_token_cookie_key,
+    public_auth_refresh_token_cookie_key,
+    public_brand,
+    public_title,
+    zrb_app_name,
+)
 from fastapi import FastAPI, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from config import (
-    zrb_app_name, app_enable_frontend, app_cors_allow_credentials,
-    app_cors_allow_headers, app_cors_allow_methods,
-    app_cors_allow_origin_regex, app_cors_allow_origins,
-    app_cors_expose_headers, app_cors_max_age, public_brand,
-    public_title, public_auth_access_token_cookie_key,
-    public_auth_refresh_token_cookie_key
-)
 from schema.frontend_config import FrontendConfig
-from component.app_lifespan import app_state
-from component.app_lifespan import app_lifespan
-from component.frontend_index import frontend_index_response
 
 app = FastAPI(title=zrb_app_name, lifespan=app_lifespan)
 
 if app_enable_frontend:
+
     @app.middleware("http")
     async def catch_all(request, call_next):
         response = await call_next(request)
         if response.status_code != 404:
             return response
-        api_error = str(response.headers.get('api-error', '')).lower() == 'yes'
+        api_error = str(response.headers.get("api-error", "")).lower() == "yes"
         if api_error:
             return response
         return frontend_index_response
@@ -40,55 +47,53 @@ app.add_middleware(
 )
 
 
-@app.head('/liveness')
-@app.get('/liveness')
+@app.head("/liveness")
+@app.get("/liveness")
 def get_application_liveness_status():
-    '''
+    """
     Get application liveness status.
     Will return HTTP response status 200 if application is alive,
     or return 503 otherwise.
     Orchestrator like Kubernetes will restart
     any application with non-healthy liveness status.
-    '''
+    """
     if app_state.get_liveness():
         return JSONResponse(
-            content={'app': zrb_app_name, 'alive': True},
-            status_code=status.HTTP_200_OK
+            content={"app": zrb_app_name, "alive": True}, status_code=status.HTTP_200_OK
         )
     return JSONResponse(
-        content={'message': 'Service is not alive'},
+        content={"message": "Service is not alive"},
         status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-        headers={'api-error': 'yes'}
+        headers={"api-error": "yes"},
     )
 
 
-@app.head('/readiness')
-@app.get('/readiness')
+@app.head("/readiness")
+@app.get("/readiness")
 def get_application_readiness_status():
-    '''
+    """
     Get application readiness status.
     Will return HTTP response status 200 if application is ready,
     or return 503 otherwise.
     Orchestrator like Kubernetes will only send user request
     to any application with healthy readiness status.
-    '''
+    """
     if app_state.get_readiness():
         return JSONResponse(
-            content={'app': zrb_app_name, 'ready': True},
-            status_code=status.HTTP_200_OK
+            content={"app": zrb_app_name, "ready": True}, status_code=status.HTTP_200_OK
         )
     return JSONResponse(
-        content={'message': 'Service is not ready'},
+        content={"message": "Service is not ready"},
         status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-        headers={'api-error': 'yes'}
+        headers={"api-error": "yes"},
     )
 
 
-@app.get('/api/v1/frontend/configs', response_model=FrontendConfig)
+@app.get("/api/v1/frontend/configs", response_model=FrontendConfig)
 def get_configs() -> FrontendConfig:
     return FrontendConfig(
         brand=public_brand,
         title=public_title,
         access_token_cookie_key=public_auth_access_token_cookie_key,
-        refresh_token_cookie_key=public_auth_refresh_token_cookie_key
+        refresh_token_cookie_key=public_auth_refresh_token_cookie_key,
     )

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/app_lifespan.py

@@ -1,23 +1,27 @@
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
-from config import (
-    zrb_app_name, app_enable_event_handler, app_enable_rpc_server,
-    app_enable_frontend, app_db_auto_migrate
-)
-from config import app_src_dir
-from migrate import migrate
+import os
+from contextlib import asynccontextmanager
+
 from component.app_state import app_state, set_not_ready_on_error
+from component.log import logger
 from component.messagebus import consumer
 from component.rpc import rpc_server
-from component.log import logger
+from config import (
+    app_db_auto_migrate,
+    app_enable_event_handler,
+    app_enable_frontend,
+    app_enable_rpc_server,
+    app_src_dir,
+    zrb_app_name,
+)
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
 from helper.async_task import create_task
-from contextlib import asynccontextmanager
-import os
+from migrate import migrate
 
 
 @asynccontextmanager
 async def app_lifespan(app: FastAPI):
-    logger.info(f'{zrb_app_name} started')
+    logger.info(f"{zrb_app_name} started")
     if app_db_auto_migrate:
         await migrate()
     app_state.set_liveness(True)
@@ -26,15 +30,15 @@ async def app_lifespan(app: FastAPI):
     if app_enable_rpc_server:
         create_task(rpc_server.start(), on_error=set_not_ready_on_error)
     if app_enable_frontend:
-        build_path = os.path.join(app_src_dir, 'frontend', 'build')
+        build_path = os.path.join(app_src_dir, "frontend", "build")
         app.mount(
-            path='',
+            path="",
             app=StaticFiles(directory=build_path, html=True),
-            name='frontend-static-resources'
+            name="frontend-static-resources",
         )
     app_state.set_readiness(True)
-    logger.info(f'{zrb_app_name} started')
+    logger.info(f"{zrb_app_name} started")
     yield
     if app_enable_event_handler:
         await consumer.stop()
-    logger.info(f'{zrb_app_name} closed')
+    logger.info(f"{zrb_app_name} closed")

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/app_state.py

@@ -1,9 +1,10 @@
+import asyncio
+
 from component.log import logger
 from config import app_max_not_ready
-import asyncio
 
 
-class AppState():
+class AppState:
     __instance = None
 
     def __new__(cls):

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/db_connection.py

@@ -1,32 +1,30 @@
-from sqlalchemy import create_engine, Engine
-from sqlalchemy import event
-from config import app_db_connection, app_db_engine_show_log
-from component.log import logger
 import time
 
+from component.log import logger
+from config import app_db_connection, app_db_engine_show_log
+from sqlalchemy import Engine, create_engine, event
+
 
 @event.listens_for(Engine, "before_cursor_execute")
-def before_cursor_execute(
-    conn, cursor, statement, parameters, context, executemany
-):
+def before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
     context._query_start_time = time.time()
-    one_line_statement = ' '.join(statement.split('\n'))
-    logger.info(
-        f'💽 [start query] SQL:`{one_line_statement}`, parameters {parameters}'
-    )
+    one_line_statement = " ".join(statement.split("\n"))
+    logger.info(f"💽 [start query] SQL:`{one_line_statement}`, parameters {parameters}")
 
 
 @event.listens_for(Engine, "after_cursor_execute")
-def after_cursor_execute(
-    conn, cursor, statement,  parameters, context, executemany
-):
+def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
     total = time.time() - context._query_start_time
-    one_line_statement = ' '.join(statement.split('\n'))
-    logger.info(' '.join([
-        f'💽 [query completed] Elapsed time: {total} ms,',
-        f'SQL: `{one_line_statement}`,',
-        f'parameters {parameters}'
-    ]))
+    one_line_statement = " ".join(statement.split("\n"))
+    logger.info(
+        " ".join(
+            [
+                f"💽 [query completed] Elapsed time: {total} ms,",
+                f"SQL: `{one_line_statement}`,",
+                f"parameters {parameters}",
+            ]
+        )
+    )
 
 
 engine: Engine = create_engine(app_db_connection, echo=app_db_engine_show_log)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/frontend_index.py

@@ -1,11 +1,10 @@
-from fastapi.responses import HTMLResponse
-from config import app_src_dir
 import os
 
-index_html_path = os.path.join(app_src_dir, 'frontend', 'build', 'index.html')
+from config import app_src_dir
+from fastapi.responses import HTMLResponse
+
+index_html_path = os.path.join(app_src_dir, "frontend", "build", "index.html")
 with open(index_html_path, "r") as f:
     index_html_content = f.read()
 
-frontend_index_response = HTMLResponse(
-    content=index_html_content, status_code=200
-)
+frontend_index_response = HTMLResponse(content=index_html_content, status_code=200)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/log.py

@@ -1,19 +1,15 @@
-from config import (
-    app_logging_level, app_enable_otel, app_otel_exporter_otlp_endpoint
-)
+import logging
+
+from config import app_enable_otel, app_logging_level, app_otel_exporter_otlp_endpoint
 from opentelemetry._logs import set_logger_provider
-from opentelemetry.exporter.otlp.proto.grpc._log_exporter import (
-    OTLPLogExporter
-)
+from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 
-import logging
-
 ##############################################################################
 # Create logger
 ##############################################################################
-logger = logging.getLogger('src')
+logger = logging.getLogger("src")
 logger.setLevel(app_logging_level)
 
 ##############################################################################
@@ -23,9 +19,7 @@ logger.setLevel(app_logging_level)
 stream_handler = logging.StreamHandler()
 stream_handler.setLevel(app_logging_level)
 # create formatter
-formatter = logging.Formatter(
-    '%(levelname)s:\t%(message)s'
-)
+formatter = logging.Formatter("%(levelname)s:\t%(message)s")
 # set stream handler's formatter
 stream_handler.setFormatter(formatter)
 # add ch to logger
@@ -40,9 +34,7 @@ if app_enable_otel:
     otlp_logger_provider = LoggerProvider()
     # set the providers
     set_logger_provider(otlp_logger_provider)
-    otlp_log_exporter = OTLPLogExporter(
-        endpoint=app_otel_exporter_otlp_endpoint
-    )
+    otlp_log_exporter = OTLPLogExporter(endpoint=app_otel_exporter_otlp_endpoint)
     # add the batch processors to the trace provider
     otlp_logger_provider.add_log_record_processor(
         BatchLogRecordProcessor(otlp_log_exporter)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/messagebus.py

@@ -1,27 +1,37 @@
+from component.log import logger
 from config import (
-    zrb_app_name, app_broker_type, app_rmq_connection_string,
-    app_kafka_bootstrap_servers, app_kafka_security_protocol,
-    app_kafka_sasl_mechanism, app_kafka_sasl_user, app_kafka_sasl_pass
+    app_broker_type,
+    app_kafka_bootstrap_servers,
+    app_kafka_sasl_mechanism,
+    app_kafka_sasl_pass,
+    app_kafka_sasl_user,
+    app_kafka_security_protocol,
+    app_rmq_connection_string,
+    zrb_app_name,
 )
 from core.messagebus import (
-    Admin, Consumer, MessageSerializer, Publisher,
-    MockAdmin, MockConsumer, MockPublisher,
-    KafkaAdmin, KafkaConsumer, KafkaPublisher,
-    RMQAdmin, RMQConsumer, RMQPublisher
+    Admin,
+    Consumer,
+    KafkaAdmin,
+    KafkaConsumer,
+    KafkaPublisher,
+    MessageSerializer,
+    MockAdmin,
+    MockConsumer,
+    MockPublisher,
+    Publisher,
+    RMQAdmin,
+    RMQConsumer,
+    RMQPublisher,
 )
-from component.log import logger
 
 
-def init_admin(
-    default_admin: Admin
-) -> Admin:
-    if app_broker_type == 'rabbitmq':
+def init_admin(default_admin: Admin) -> Admin:
+    if app_broker_type == "rabbitmq":
         return RMQAdmin(
-            logger=logger,
-            connection_string=app_rmq_connection_string,
-            configs={}
+            logger=logger, connection_string=app_rmq_connection_string, configs={}
         )
-    if app_broker_type == 'kafka':
+    if app_broker_type == "kafka":
         return KafkaAdmin(
             logger=logger,
             bootstrap_servers=app_kafka_bootstrap_servers,
@@ -29,24 +39,22 @@ def init_admin(
             sasl_mechanism=app_kafka_sasl_mechanism,
             sasl_plain_username=app_kafka_sasl_user,
             sasl_plain_password=app_kafka_sasl_pass,
-            configs={}
+            configs={},
         )
     return default_admin
 
 
 def init_publisher(
-    serializer: MessageSerializer,
-    admin: Admin,
-    default_publisher: Publisher
+    serializer: MessageSerializer, admin: Admin, default_publisher: Publisher
 ) -> Publisher:
-    if app_broker_type == 'rabbitmq':
+    if app_broker_type == "rabbitmq":
         return RMQPublisher(
             logger=logger,
             connection_string=app_rmq_connection_string,
             serializer=serializer,
-            rmq_admin=admin
+            rmq_admin=admin,
         )
-    if app_broker_type == 'kafka':
+    if app_broker_type == "kafka":
         return KafkaPublisher(
             logger=logger,
             bootstrap_servers=app_kafka_bootstrap_servers,
@@ -55,24 +63,22 @@ def init_publisher(
             sasl_plain_username=app_kafka_sasl_user,
             sasl_plain_password=app_kafka_sasl_pass,
             serializer=serializer,
-            kafka_admin=admin
+            kafka_admin=admin,
         )
     return default_publisher
 
 
 def init_consumer(
-    serializer: MessageSerializer,
-    admin: Admin,
-    default_consumer: Consumer
+    serializer: MessageSerializer, admin: Admin, default_consumer: Consumer
 ) -> Consumer:
-    if app_broker_type == 'rabbitmq':
+    if app_broker_type == "rabbitmq":
         return RMQConsumer(
             logger=logger,
             connection_string=app_rmq_connection_string,
             serializer=serializer,
-            rmq_admin=admin
+            rmq_admin=admin,
         )
-    if app_broker_type == 'kafka':
+    if app_broker_type == "kafka":
         return KafkaConsumer(
             logger=logger,
             bootstrap_servers=app_kafka_bootstrap_servers,
@@ -82,7 +88,7 @@ def init_consumer(
             sasl_plain_password=app_kafka_sasl_pass,
             group_id=zrb_app_name,
             serializer=serializer,
-            kafka_admin=admin
+            kafka_admin=admin,
         )
     return default_consumer
 
@@ -103,7 +109,5 @@ consumer = init_consumer(
     serializer=message_serializer, admin=admin, default_consumer=mock_consumer
 )
 publisher = init_publisher(
-    serializer=message_serializer,
-    admin=admin,
-    default_publisher=mock_publisher
+    serializer=message_serializer, admin=admin, default_publisher=mock_publisher
 )

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/component/rpc.py

@@ -1,48 +1,49 @@
-from core.rpc import Caller, Server, MessagebusCaller, MessagebusServer
-from core.messagebus import RMQConsumer, KafkaConsumer
+from component.log import logger
 from component.messagebus import (
-    admin, consumer, publisher, message_serializer, mock_consumer
+    admin,
+    consumer,
+    message_serializer,
+    mock_consumer,
+    publisher,
 )
-from component.log import logger
 from config import (
-    zrb_app_name, app_broker_type, app_rmq_connection_string,
-    app_kafka_bootstrap_servers
+    app_broker_type,
+    app_kafka_bootstrap_servers,
+    app_rmq_connection_string,
+    zrb_app_name,
 )
+from core.messagebus import KafkaConsumer, RMQConsumer
+from core.rpc import Caller, MessagebusCaller, MessagebusServer, Server
 from ulid import ULID
 
 
 def create_consumer():
-    if app_broker_type == 'rabbitmq':
+    if app_broker_type == "rabbitmq":
         return RMQConsumer(
             logger=logger,
             connection_string=app_rmq_connection_string,
             serializer=message_serializer,
             rmq_admin=admin,
-            identifier='rmq-rpc-reply-consumer'
+            identifier="rmq-rpc-reply-consumer",
         )
-    if app_broker_type == 'kafka':
+    if app_broker_type == "kafka":
         random_uuid = str(ULID())
-        group_id = f'{zrb_app_name}-reply-{random_uuid}'
+        group_id = f"{zrb_app_name}-reply-{random_uuid}"
         return KafkaConsumer(
             logger=logger,
             bootstrap_servers=app_kafka_bootstrap_servers,
             group_id=group_id,
             serializer=message_serializer,
             kafka_admin=admin,
-            identifier='kafka-rpc-reply-consumer'
+            identifier="kafka-rpc-reply-consumer",
         )
     return mock_consumer
 
 
 rpc_caller: Caller = MessagebusCaller(
-    logger=logger,
-    admin=admin,
-    publisher=publisher,
-    consumer_factory=create_consumer
+    logger=logger, admin=admin, publisher=publisher, consumer_factory=create_consumer
 )
 
 rpc_server: Server = MessagebusServer(
-    logger=logger,
-    consumer=consumer,
-    publisher=publisher
+    logger=logger, consumer=consumer, publisher=publisher
 )