jararaca 0.3.10__py3-none-any.whl → 0.3.11__py3-none-any.whl

jararaca/cli.py

@@ -1,3 +1,4 @@
+import asyncio
 import importlib
 import importlib.resources
 import multiprocessing
@@ -7,22 +8,28 @@ import time
 from codecs import StreamWriter
 from pathlib import Path
 from typing import Any
-from urllib.parse import urlparse, urlunsplit
+from urllib.parse import parse_qs, urlparse
 
+import aio_pika
 import click
 import uvicorn
-from mako.template import Template  # type: ignore
+from mako.template import Template
 
-from jararaca.messagebus import worker as worker_v1
-from jararaca.messagebus import worker_v2 as worker_v2_mod
+from jararaca.messagebus import worker as worker_mod
+from jararaca.messagebus.decorators import MessageBusController, MessageHandler
 from jararaca.microservice import Microservice
 from jararaca.presentation.http_microservice import HttpMicroservice
 from jararaca.presentation.server import create_http_server
-from jararaca.scheduler.scheduler import Scheduler
-from jararaca.scheduler.scheduler_v2 import SchedulerV2
+from jararaca.reflect.controller_inspect import (
+    ControllerMemberReflect,
+    inspect_controller,
+)
+from jararaca.scheduler.beat_worker import BeatWorker
+from jararaca.scheduler.decorators import ScheduledAction
 from jararaca.tools.typescript.interface_parser import (
     write_microservice_to_typescript_interface,
 )
+from jararaca.utils.rabbitmq_utils import RabbitmqUtils
 
 LIBRARY_FILES_PATH = importlib.resources.files("jararaca.files")
 ENTITY_TEMPLATE_PATH = LIBRARY_FILES_PATH / "entity.py.mako"
@@ -67,89 +74,328 @@ def find_microservice_by_module_path(module_path: str) -> Microservice:
     return app
 
 
-@click.group()
-def cli() -> None:
-    pass
+# The v1 infrastructure declaration function has been removed as part of the CLI simplification
 
 
-@cli.command()
-@click.argument(
-    "app_path",
-    type=str,
-)
-@click.option(
-    "--url",
-    type=str,
-    envvar="BROKER_URL",
-)
-@click.option(
-    "--username",
-    type=str,
-    default=None,
-)
-@click.option(
-    "--password",
-    type=str,
-    default=None,
-)
-@click.option(
-    "--exchange",
-    type=str,
-    default="jararaca_ex",
-)
-@click.option(
-    "--prefetch-count",
-    type=int,
-    default=1,
-)
-@click.option(
-    "--passive-declare",
-    is_flag=True,
-    default=False,
-)
-def worker(
-    app_path: str,
-    url: str,
-    username: str | None,
-    password: str | None,
+async def declare_worker_infrastructure(
+    broker_url: str,
+    app: Microservice,
+    force: bool = False,
+    interactive_mode: bool = False,
+) -> None:
+    """
+    Declare the infrastructure (exchanges and queues) for worker.
+    """
+    parsed_url = urlparse(broker_url)
+    if parsed_url.scheme not in ["amqp", "amqps"]:
+        raise ValueError(f"Unsupported broker URL scheme: {parsed_url.scheme}")
+
+    if not parsed_url.query:
+        raise ValueError("Query string must be set for AMQP URLs")
+
+    query_params = parse_qs(parsed_url.query)
+
+    if "exchange" not in query_params or not query_params["exchange"]:
+        raise ValueError("Exchange must be set in the query string")
+
+    exchange = query_params["exchange"][0]
+
+    # Create a connection that will be used to create channels for each operation
+    connection = await aio_pika.connect(broker_url)
+
+    try:
+        # Step 1: Setup infrastructure (exchanges and dead letter queues)
+        # Creating a dedicated channel for infrastructure setup
+        await setup_infrastructure(connection, exchange, force, interactive_mode)
+
+        # Step 2: Declare all message handlers and scheduled actions queues
+        # Creating a dedicated channel for controller queues
+        await declare_controller_queues(
+            connection, app, exchange, force, interactive_mode
+        )
+    finally:
+        # Always close the connection in the finally block
+        await connection.close()
+
+
+async def setup_infrastructure(
+    connection: aio_pika.abc.AbstractConnection,
     exchange: str,
-    prefetch_count: int,
-    passive_declare: bool,
+    force: bool = False,
+    interactive_mode: bool = False,
 ) -> None:
+    """
+    Setup the basic infrastructure (exchanges and dead letter queues).
+    """
+    # Check if infrastructure exists
+    infrastructure_exists = await check_infrastructure_exists(connection, exchange)
+
+    # If it exists and force or user confirms, delete it
+    if not infrastructure_exists and should_recreate_infrastructure(
+        force,
+        interactive_mode,
+        f"Existing infrastructure found for exchange '{exchange}'. Delete and recreate?",
+    ):
+        await delete_infrastructure(connection, exchange)
+
+    # Try to declare required infrastructure
+    await declare_infrastructure(connection, exchange, force, interactive_mode)
+
+
+async def check_infrastructure_exists(
+    connection: aio_pika.abc.AbstractConnection, exchange: str
+) -> bool:
+    """
+    Check if the infrastructure exists by trying passive declarations.
+    """
+    # Create a dedicated channel for checking infrastructure existence using async context manager
+    async with connection.channel() as channel:
+        try:
+            await RabbitmqUtils.declare_main_exchange(
+                channel=channel,
+                exchange_name=exchange,
+                passive=True,
+            )
+            await RabbitmqUtils.declare_dl_exchange(channel=channel, passive=True)
+            await RabbitmqUtils.declare_dl_queue(channel=channel, passive=True)
+            return True
+        except Exception:
+            # Infrastructure doesn't exist, which is fine for fresh setup
+            return False
 
-    app = find_microservice_by_module_path(app_path)
 
-    parsed_url = urlparse(url)
+def should_recreate_infrastructure(
+    force: bool, interactive_mode: bool, confirmation_message: str
+) -> bool:
+    """
+    Determine if infrastructure should be recreated based on force flag and user input.
+    """
+    return force or (interactive_mode and click.confirm(confirmation_message))
 
-    if password is not None:
-        parsed_url = urlparse(
-            urlunsplit(
-                parsed_url._replace(
-                    netloc=f"{parsed_url.username or ''}:{password}@{parsed_url.netloc}"
-                )
+
+async def delete_infrastructure(
+    connection: aio_pika.abc.AbstractConnection, exchange: str
+) -> None:
+    """
+    Delete existing infrastructure (exchanges and queues).
+    """
+    # Create a dedicated channel for deleting infrastructure using async context manager
+    async with connection.channel() as channel:
+        click.echo(f"→ Deleting existing infrastructure for exchange: {exchange}")
+        await RabbitmqUtils.delete_exchange(channel, exchange)
+        await RabbitmqUtils.delete_exchange(channel, RabbitmqUtils.DEAD_LETTER_EXCHANGE)
+        await RabbitmqUtils.delete_queue(channel, RabbitmqUtils.DEAD_LETTER_QUEUE)
+
+
+async def declare_infrastructure(
+    connection: aio_pika.abc.AbstractConnection,
+    exchange: str,
+    force: bool,
+    interactive_mode: bool,
+) -> None:
+    """
+    Declare the required infrastructure (exchanges and dead letter queues).
+    """
+    # Using async context manager for channel creation
+    async with connection.channel() as channel:
+        try:
+            # Declare main exchange
+            await RabbitmqUtils.declare_main_exchange(
+                channel=channel,
+                exchange_name=exchange,
+                passive=False,
             )
-        )
 
-    if username is not None:
-        parsed_url = urlparse(
-            urlunsplit(
-                parsed_url._replace(
-                    netloc=f"{username}{':%s' % password if password is not None else ''}@{parsed_url.netloc}"
-                )
+            # Declare dead letter exchange and queue
+            dlx = await RabbitmqUtils.declare_dl_exchange(
+                channel=channel, passive=False
+            )
+            dlq = await RabbitmqUtils.declare_dl_queue(channel=channel, passive=False)
+            await dlq.bind(dlx, routing_key=RabbitmqUtils.DEAD_LETTER_EXCHANGE)
+
+        except Exception as e:
+            click.echo(f"Error during exchange declaration: {e}")
+
+            # If interactive mode and user confirms, or if forced, try again after deletion
+            if should_recreate_infrastructure(
+                force, interactive_mode, "Delete existing infrastructure and recreate?"
+            ):
+                # Delete infrastructure with a new channel
+                await delete_infrastructure(connection, exchange)
+
+                # Try again with a new channel
+                async with connection.channel() as new_channel:
+                    # Try again after deletion
+                    await RabbitmqUtils.declare_main_exchange(
+                        channel=new_channel,
+                        exchange_name=exchange,
+                        passive=False,
+                    )
+                    dlx = await RabbitmqUtils.declare_dl_exchange(
+                        channel=new_channel, passive=False
+                    )
+                    dlq = await RabbitmqUtils.declare_dl_queue(
+                        channel=new_channel, passive=False
+                    )
+                    await dlq.bind(dlx, routing_key=RabbitmqUtils.DEAD_LETTER_EXCHANGE)
+            elif force:
+                # If force is true but recreation failed, propagate the error
+                raise
+            else:
+                click.echo("Skipping main exchange declaration due to error")
+
+
+async def declare_controller_queues(
+    connection: aio_pika.abc.AbstractConnection,
+    app: Microservice,
+    exchange: str,
+    force: bool,
+    interactive_mode: bool,
+) -> None:
+    """
+    Declare all message handler and scheduled action queues for controllers.
+    """
+    for instance_type in app.controllers:
+        controller_spec = MessageBusController.get_messagebus(instance_type)
+        if controller_spec is None:
+            continue
+
+        _, members = inspect_controller(instance_type)
+
+        # Process each member (method) in the controller
+        for _, member in members.items():
+            # Check if it's a message handler
+            await declare_message_handler_queue(
+                connection, member, exchange, force, interactive_mode
+            )
+
+            # Check if it's a scheduled action
+            await declare_scheduled_action_queue(
+                connection, member, exchange, force, interactive_mode
             )
+
+
+async def declare_message_handler_queue(
+    connection: aio_pika.abc.AbstractConnection,
+    member: ControllerMemberReflect,
+    exchange: str,
+    force: bool,
+    interactive_mode: bool,
+) -> None:
+    """
+    Declare a queue for a message handler if the member is one.
+    """
+    message_handler = MessageHandler.get_message_incoming(member.member_function)
+    if message_handler is not None:
+        queue_name = f"{message_handler.message_type.MESSAGE_TOPIC}.{member.member_function.__module__}.{member.member_function.__qualname__}"
+        routing_key = f"{message_handler.message_type.MESSAGE_TOPIC}.#"
+
+        await declare_and_bind_queue(
+            connection,
+            queue_name,
+            routing_key,
+            exchange,
+            force,
+            interactive_mode,
+            is_scheduled_action=False,
         )
 
-    url = parsed_url.geturl()
 
-    config = worker_v1.AioPikaWorkerConfig(
-        url=url,
-        exchange=exchange,
-        prefetch_count=prefetch_count,
-    )
+async def declare_scheduled_action_queue(
+    connection: aio_pika.abc.AbstractConnection,
+    member: ControllerMemberReflect,
+    exchange: str,
+    force: bool,
+    interactive_mode: bool,
+) -> None:
+    """
+    Declare a queue for a scheduled action if the member is one.
+    """
+    scheduled_action = ScheduledAction.get_scheduled_action(member.member_function)
+    if scheduled_action is not None:
+        queue_name = (
+            f"{member.member_function.__module__}.{member.member_function.__qualname__}"
+        )
+        routing_key = queue_name
+
+        await declare_and_bind_queue(
+            connection,
+            queue_name,
+            routing_key,
+            exchange,
+            force,
+            interactive_mode,
+            is_scheduled_action=True,
+        )
+
+
+async def declare_and_bind_queue(
+    connection: aio_pika.abc.AbstractConnection,
+    queue_name: str,
+    routing_key: str,
+    exchange: str,
+    force: bool,
+    interactive_mode: bool,
+    is_scheduled_action: bool,
+) -> None:
+    """
+    Declare and bind a queue to the exchange with the given routing key.
+    """
+    queue_type = "scheduled action" if is_scheduled_action else "message handler"
+
+    # Using async context manager for channel creation
+    async with connection.channel() as channel:
+        try:
+            # Try to declare queue using the appropriate method
+            if is_scheduled_action:
+                queue = await RabbitmqUtils.declare_scheduled_action_queue(
+                    channel=channel, queue_name=queue_name, passive=False
+                )
+            else:
+                queue = await RabbitmqUtils.declare_worker_queue(
+                    channel=channel, queue_name=queue_name, passive=False
+                )
+
+            # Bind the queue to the exchange
+            await queue.bind(exchange=exchange, routing_key=routing_key)
+            click.echo(
+                f"✓ Declared {queue_type} queue: {queue_name} (routing key: {routing_key})"
+            )
+        except Exception as e:
+            click.echo(f"⚠ Error declaring {queue_type} queue {queue_name}: {e}")
+
+            # If interactive mode and user confirms, or if forced, recreate the queue
+            if force or (
+                interactive_mode
+                and click.confirm(f"Delete and recreate queue {queue_name}?")
+            ):
+                # Create a new channel for deletion and recreation
+                async with connection.channel() as new_channel:
+                    # Delete the queue
+                    await RabbitmqUtils.delete_queue(new_channel, queue_name)
+
+                    # Try to declare queue again using the appropriate method
+                    if is_scheduled_action:
+                        queue = await RabbitmqUtils.declare_scheduled_action_queue(
+                            channel=new_channel, queue_name=queue_name, passive=False
+                        )
+                    else:
+                        queue = await RabbitmqUtils.declare_worker_queue(
+                            channel=new_channel, queue_name=queue_name, passive=False
+                        )
+
+                    # Bind the queue to the exchange
+                    await queue.bind(exchange=exchange, routing_key=routing_key)
+                    click.echo(
+                        f"✓ Recreated {queue_type} queue: {queue_name} (routing key: {routing_key})"
+                    )
+            else:
+                click.echo(f"⚠ Skipping {queue_type} queue {queue_name}")
 
-    worker_v1.MessageBusWorker(app, config=config).start_sync(
-        passive_declare=passive_declare,
-    )
+
+@click.group()
+def cli() -> None:
+    pass
 
 
 @cli.command()
@@ -162,20 +408,37 @@ def worker(
     "--broker-url",
     type=str,
     envvar="BROKER_URL",
+    required=True,
+    help="The URL for the message broker",
 )
 @click.option(
     "--backend-url",
     type=str,
     envvar="BACKEND_URL",
+    required=True,
+    help="The URL for the message broker backend",
 )
-def worker_v2(app_path: str, broker_url: str, backend_url: str) -> None:
-
+@click.option(
+    "--handlers",
+    type=str,
+    help="Comma-separated list of handler names to listen to. If not specified, all handlers will be used.",
+)
+def worker(
+    app_path: str, broker_url: str, backend_url: str, handlers: str | None
+) -> None:
+    """Start a message bus worker that processes asynchronous messages from a message queue."""
     app = find_microservice_by_module_path(app_path)
 
-    worker_v2_mod.MessageBusWorker(
+    # Parse handler names if provided
+    handler_names: set[str] | None = None
+    if handlers:
+        handler_names = {name.strip() for name in handlers.split(",") if name.strip()}
+
+    worker_mod.MessageBusWorker(
         app=app,
         broker_url=broker_url,
         backend_url=backend_url,
+        handler_names=handler_names,
     ).start_sync()
 
 
@@ -218,25 +481,6 @@ def server(app_path: str, host: str, port: int) -> None:
     uvicorn.run(asgi_app, host=host, port=port)
 
 
-@cli.command()
-@click.argument(
-    "app_path",
-    type=str,
-)
-@click.option(
-    "--interval",
-    type=int,
-    default=1,
-)
-def scheduler(
-    app_path: str,
-    interval: int,
-) -> None:
-    app = find_microservice_by_module_path(app_path)
-
-    Scheduler(app, interval=interval).run()
-
-
 @cli.command()
 @click.argument(
     "app_path",
@@ -258,21 +502,34 @@ def scheduler(
     type=str,
     required=True,
 )
-def scheduler_v2(
+@click.option(
+    "--actions",
+    type=str,
+    help="Comma-separated list of action names to run (only run actions with these names)",
+)
+def beat(
     interval: int,
     broker_url: str,
     backend_url: str,
     app_path: str,
+    actions: str | None = None,
 ) -> None:
 
     app = find_microservice_by_module_path(app_path)
-    scheduler = SchedulerV2(
+
+    # Parse scheduler names if provided
+    scheduler_names: set[str] | None = None
+    if actions:
+        scheduler_names = {name.strip() for name in actions.split(",") if name.strip()}
+
+    beat_worker = BeatWorker(
         app=app,
         interval=interval,
         backend_url=backend_url,
         broker_url=broker_url,
+        scheduled_action_names=scheduler_names,
     )
-    scheduler.run()
+    beat_worker.run()
 
 
 def generate_interfaces(
@@ -303,7 +560,7 @@ def generate_interfaces(
             file.write(content)
             file.flush()
 
-        print(
+        click.echo(
             f"Generated TypeScript interfaces at {time.strftime('%H:%M:%S')} at {str(Path(file_path).absolute())}"
         )
 
@@ -311,19 +568,19 @@ def generate_interfaces(
             import subprocess
 
             try:
-                print(f"Running post-process command: {post_process_cmd}")
+                click.echo(f"Running post-process command: {post_process_cmd}")
                 subprocess.run(
                     post_process_cmd.replace("{file}", file_path),
                     shell=True,
                     check=True,
                 )
-                print(f"Post-processing completed successfully")
+                click.echo(f"Post-processing completed successfully")
             except subprocess.CalledProcessError as e:
-                print(f"Post-processing command failed: {e}", file=sys.stderr)
+                click.echo(f"Post-processing command failed: {e}", file=sys.stderr)
 
         return content
     except Exception as e:
-        print(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
+        click.echo(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
         return ""
 
 
@@ -367,18 +624,20 @@ def gen_tsi(
     """Generate TypeScript interfaces from a Python microservice."""
 
     if stdout and watch:
-        print(
+        click.echo(
             "Error: --watch and --stdout options cannot be used together",
             file=sys.stderr,
         )
         return
 
     if not file_path and not stdout:
-        print("Error: either file_path or --stdout must be provided", file=sys.stderr)
+        click.echo(
+            "Error: either file_path or --stdout must be provided", file=sys.stderr
+        )
         return
 
     if post_process and stdout:
-        print(
+        click.echo(
             "Error: --post-process and --stdout options cannot be used together",
             file=sys.stderr,
         )
@@ -388,7 +647,7 @@ def gen_tsi(
     content = generate_interfaces(app_path, file_path, stdout, post_process)
 
     if stdout:
-        print(content)
+        click.echo(content)
         return
 
     # If watch mode is not enabled, exit
@@ -399,7 +658,7 @@ def gen_tsi(
         from watchdog.events import FileSystemEvent, FileSystemEventHandler
         from watchdog.observers import Observer
     except ImportError:
-        print(
+        click.echo(
             "Watchdog is required for watch mode. Install it with: pip install watchdog",
             file=sys.stderr,
         )
@@ -414,7 +673,7 @@ def gen_tsi(
                 else str(event.src_path)
             )
             if not event.is_directory and src_path.endswith(".py"):
-                print(f"File changed: {src_path}")
+                click.echo(f"File changed: {src_path}")
                 # Create a completely detached process to ensure classes are reloaded
                 process = multiprocessing.get_context("spawn").Process(
                     target=generate_interfaces,
@@ -445,16 +704,16 @@ def gen_tsi(
 
     # Set up observer
     observer = Observer()
-    observer.schedule(PyFileChangeHandler(), src_dir, recursive=True)
-    observer.start()
+    observer.schedule(PyFileChangeHandler(), src_dir, recursive=True)  # type: ignore
+    observer.start()  # type: ignore
 
-    print(f"Watching for changes in {os.path.abspath(src_dir)}...")
+    click.echo(f"Watching for changes in {os.path.abspath(src_dir)}...")
     try:
         while True:
             time.sleep(1)
     except KeyboardInterrupt:
-        observer.stop()
-        print("Watch mode stopped")
+        observer.stop()  # type: ignore
+        click.echo("Watch mode stopped")
     observer.join()
 
 
@@ -491,3 +750,88 @@ def gen_entity(entity_name: str, file_path: StreamWriter) -> None:
             entityNameKebabCase=entity_kebab_case,
         )
     )
+
+
+@cli.command()
+@click.argument(
+    "app_path",
+    type=str,
+    envvar="APP_PATH",
+)
+@click.option(
+    "--broker-url",
+    type=str,
+    envvar="BROKER_URL",
+    help="Broker URL (e.g., amqp://guest:guest@localhost/) [env: BROKER_URL]",
+)
+@click.option(
+    "-i",
+    "--interactive-mode",
+    is_flag=True,
+    default=False,
+    help="Enable interactive mode for queue declaration (confirm before deleting existing queues)",
+)
+@click.option(
+    "-f",
+    "--force",
+    is_flag=True,
+    default=False,
+    help="Force recreation by deleting existing exchanges and queues before declaring them",
+)
+def declare(
+    app_path: str,
+    broker_url: str,
+    force: bool,
+    interactive_mode: bool,
+) -> None:
+    """
+    Declare RabbitMQ infrastructure (exchanges and queues) for message handlers and schedulers.
+
+    This command pre-declares the necessary exchanges and queues for message handlers and schedulers,
+    without starting the actual consumption processes.
+
+    Environment variables:
+    - BROKER_URL: Broker URL (e.g., amqp://guest:guest@localhost/)
+    - EXCHANGE: Exchange name (defaults to 'jararaca_ex')
+
+    Examples:
+
+    \b
+    # Declare infrastructure
+    jararaca declare myapp:app --broker-url amqp://guest:guest@localhost/
+
+    \b
+    # Force recreation of queues and exchanges
+    jararaca declare myapp:app --broker-url amqp://guest:guest@localhost/ --force
+
+    \b
+    # Use environment variables
+    export BROKER_URL="amqp://guest:guest@localhost/"
+    export EXCHANGE="my_exchange"
+    jararaca declare myapp:app
+    """
+
+    app = find_microservice_by_module_path(app_path)
+
+    async def run_declarations() -> None:
+        if not broker_url:
+            click.echo(
+                "ERROR: --broker-url is required or set BROKER_URL environment variable",
+                err=True,
+            )
+            return
+
+        try:
+            # Create the broker URL with exchange parameter
+
+            click.echo(f"→ Declaring worker infrastructure (URL: {broker_url})")
+            await declare_worker_infrastructure(
+                broker_url, app, force, interactive_mode
+            )
+
+            click.echo("✓ Workers infrastructure declared successfully!")
+        except Exception as e:
+            click.echo(f"ERROR: Failed to declare infrastructure: {e}", err=True)
+            raise
+
+    asyncio.run(run_declarations())