orionis 0.732.0__tar.gz → 0.733.0__tar.gz

{orionis-0.732.0/orionis.egg-info → orionis-0.733.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.732.0
+Version: 0.733.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

orionis-0.733.0/orionis/console/commands/server.py

@@ -0,0 +1,140 @@
+import os
+import sys
+import subprocess
+import time
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from orionis.console.base.command import BaseCommand
+from orionis.console.exceptions import CLIOrionisRuntimeError
+from orionis.support.facades.application import Application
+
+class ServerCommand(BaseCommand):
+    """
+    Starts the Orionis HTTP server using Granian.
+
+    This command initializes the Orionis server with the configuration
+    specified in the application settings. It sets up the server interface,
+    host, port, worker count, and reload options, then launches the server
+    process. The command also displays a styled message in the console
+    indicating the server status and handles graceful shutdown on interruption.
+
+    Returns
+    -------
+    None
+        This method does not return any value.
+    """
+    timestamps = False
+    signature = "serve"
+    description = "Initializes the Orionis server with Granian."
+
+    def handle(self):
+        """
+        Handles the execution of the server command.
+
+        Reads configuration from the application, constructs the command to
+        start the Granian server, displays a status panel, and manages the
+        server process lifecycle including graceful shutdown on interruption.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        try:
+
+            # Retrieve application configuration for server settings
+            app_config: dict = Application.config("app")
+            host: str = app_config.get("host", "127.0.0.1")
+            port: int = app_config.get("port", 8000)
+            workers: int = app_config.get("workers", 1)
+            reload: bool = app_config.get("reload", False)
+            interface: str = app_config.get("interface", "asgi")
+            app_path: str = "bootstrap.app:app"
+
+            # Build the command to launch the Granian server
+            cmd = [
+                sys.executable, "-B", "-m", "granian",
+                "--interface", interface,
+                "--host", host,
+                "--port", str(port),
+                "--workers", "1" if os.name == "nt" else str(workers),
+                "--no-log",
+                app_path
+            ]
+            if reload:
+                cmd.append("--reload")
+
+            # Initialize Rich console for styled output
+            rich_console = Console()
+            rich_console.clear()
+            rich_console.line()
+            now = time.strftime("%Y-%m-%d %H:%M:%S")
+
+            # Prepare the panel content with server status information
+            panel_content = Text.assemble(
+                ("🚀 Orionis HTTP Server ", "bold white on green"),
+                ("\n\n", ""),
+                ("✅ The HTTP server has started successfully.\n", "white"),
+                (f"🔗 Service running at: http://{host}:{port}\n", "bold cyan"),
+                (f"🕒 Started at: {now} | 🆔 PID: {os.getpid()}\n", "dim"),
+                ("🛑 To stop the server, press ", "white"),
+                ("Ctrl+C", "bold yellow")
+            )
+
+            # Display the message in a styled panel
+            rich_console.print(
+                Panel(panel_content, border_style="green", padding=(1, 2))
+            )
+
+            # Add another blank line for better formatting
+            rich_console.line()
+
+            # Ensure the current working directory is in the import path
+            sys.path.insert(0, os.getcwd())
+
+            # Start the Granian server process
+            # IMPORTANT: Do not use creationflags on Windows to allow child to share the console.
+            process = subprocess.Popen(
+                cmd,
+                stdout=sys.stdout,
+                stderr=sys.stderr,
+                stdin=None,
+                shell=False,
+            )
+
+            def shutdown():
+                """
+                Gracefully shuts down the server process.
+
+                Terminates the server process if it is still running and waits
+                for it to exit. If termination fails, forcibly kills the process.
+
+                Returns
+                -------
+                None
+                    This method does not return any value.
+                """
+                if process.poll() is None:
+                    self.writeLine("Shutting down Orionis server...")
+                    try:
+                        process.terminate()
+                        process.wait(timeout=5)
+                    except Exception:
+                        process.kill()
+                    self.info("Orionis server stopped.")
+
+            # Wait for the server process to exit, handling Ctrl+C for graceful shutdown
+            try:
+                process.wait()
+            except KeyboardInterrupt:
+                shutdown()
+
+            # Report non-zero exit codes as errors
+            if process.returncode not in (0, None):
+                self.error(f"Orionis server exited with code {process.returncode}")
+
+        except Exception as e:
+
+            # Raise a CLI-specific runtime error if server startup fails
+            raise CLIOrionisRuntimeError(f"Failed to start Orionis server: {e}") from e

{orionis-0.732.0 → orionis-0.733.0}/orionis/console/core/reactor.py

@@ -289,6 +289,7 @@ class Reactor(IReactor):
         from orionis.console.commands.test import TestCommand
         from orionis.console.commands.version import VersionCommand
         from orionis.console.commands.make_scheduler_listener import MakeSchedulerListenerCommand
+        from orionis.console.commands.server import ServerCommand
 
         # List of core command classes to load (extend this list as more core commands are added)
         core_commands = [
@@ -300,7 +301,8 @@ class Reactor(IReactor):
             ScheduleWorkCommand,
             TestCommand,
             VersionCommand,
-            MakeSchedulerListenerCommand
+            MakeSchedulerListenerCommand,
+            ServerCommand
         ]
 
         # Iterate through the core command classes and register them

{orionis-0.732.0 → orionis-0.733.0}/orionis/foundation/application.py

@@ -68,6 +68,38 @@ class Application(Container, IApplication):
 
     CONFIGURATION_LOCKED_ERROR_MESSAGE = "Cannot modify configuration after application has been booted."
 
+    async def __call__(self, *args) -> None:
+        """
+        Asynchronous entry point for handling ASGI/RSGI requests via the HTTP kernel.
+
+        This method is invoked by ASGI/RSGI-compatible servers to process incoming requests.
+        It retrieves the IKernelHTTP instance from the application's dependency injection container
+        and delegates the request handling to the kernel's `handle` method, passing all received arguments.
+
+        Parameters
+        ----------
+        *args : tuple
+            Variable-length argument list to be forwarded to the kernel's handle method.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It delegates request handling to the HTTP kernel.
+
+        Notes
+        -----
+        - Designed for use with ASGI/RSGI servers.
+        - The kernel instance is resolved from the application's dependency injection container.
+        - Ensures separation of concerns by delegating request processing to the kernel.
+        """
+
+        # Retrieve the HTTP kernel instance from the container
+        from orionis.http.contracts.kernel import IKernelHTTP
+        kernel: IKernelHTTP = self.make(IKernelHTTP)
+
+        # Delegate request handling to the kernel's handle method
+        await kernel.handle(*args)
+
     @property
     def isBooted(
         self
@@ -177,11 +209,13 @@ class Application(Container, IApplication):
         # Import core framework kernels
         from orionis.test.kernel import TestKernel, ITestKernel
         from orionis.console.kernel import KernelCLI, IKernelCLI
+        from orionis.http.kernel import KernelHTTP, IKernelHTTP
 
         # Core framework kernels
         core_kernels = {
             ITestKernel: TestKernel,
-            IKernelCLI: KernelCLI
+            IKernelCLI: KernelCLI,
+            IKernelHTTP: KernelHTTP
         }
 
         # Register each kernel instance

{orionis-0.732.0 → orionis-0.733.0}/orionis/foundation/config/app/entities/app.py

@@ -19,8 +19,8 @@ class App(BaseEntity):
         The environment in which the application is running. Default is 'DEVELOPMENT'.
     debug : bool, optional
         Whether debug mode is enabled. Default is True.
-    url : str, optional
-        The base URL of the application. Default is 'http://127.0.0.1'.
+    host : str, optional
+        The host address of the application.
     port : int, optional
         The port on which the application will run. Default is 8000.
     workers : int, optional
@@ -70,11 +70,11 @@ class App(BaseEntity):
         }
     )
 
-    url: str = field(
-        default_factory = lambda: Env.get('APP_URL', 'http://127.0.0.1'),
+    host: str = field(
+        default_factory = lambda: Env.get('APP_HOST', '127.0.0.1'),
         metadata = {
-            "description": "The base URL of the application. Defaults to 'http://127.0.0.1'.",
-            "default": 'http://127.0.0.1'
+            "description": "Host address of the application. Loaded from 'APP_HOST' or defaults to '127.0.0.1'. For production or to listen on all interfaces, use '0.0.0.0'.",
+            "default": '127.0.0.1'
         }
     )
 
@@ -188,9 +188,9 @@ class App(BaseEntity):
         if not isinstance(self.debug, bool):
             raise OrionisIntegrityException("The 'debug' attribute must be a boolean.")
 
-        # Validate `url` attribute
-        if not isinstance(self.url, str) or not self.url.strip():
-            raise OrionisIntegrityException("The 'url' attribute must be a non-empty string.")
+        # Validate `host` attribute
+        if not isinstance(self.host, str) or not self.host.strip():
+            raise OrionisIntegrityException("The 'host' attribute must be a non-empty string.")
 
         # Validate `port` attribute
         if not isinstance(self.port, int):

orionis-0.733.0/orionis/http/contracts/kernel.py

@@ -0,0 +1,45 @@
+from abc import ABC, abstractmethod
+
+class IKernelHTTP(ABC):
+    """
+    Interface for implementing the HTTP kernel.
+
+    The HTTP kernel is responsible for handling incoming HTTP requests,
+    as well as WebSocket requests. It also determines whether to start
+    an ASGI or RSGI server and manages the pipelines and middlewares
+    required to process HTTP requests.
+
+    Methods
+    -------
+    handle(*args)
+        Handles incoming requests for ASGI or RSGI servers.
+
+    Returns
+    -------
+    None
+        This method does not return any value.
+    """
+
+    @abstractmethod
+    async def handle(self, *args) -> None:
+        """
+        Handles incoming requests for ASGI or RSGI servers.
+
+        The *args parameter is used to accommodate the different signatures
+        required by ASGI and RSGI server handlers. For example, ASGI uses
+        (async def app(scope, receive, send):) while RSGI uses
+        (async def app(scope, proto):).
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not overridden by a subclass.
+        """
+
+        # This method must be implemented by subclasses.
+        raise NotImplementedError("This method should be overridden by subclasses.")

orionis-0.733.0/orionis/http/core/asgi.py

@@ -0,0 +1,20 @@
+class ASGIHandler:
+
+    async def __call__(self, scope, receive, send):
+
+        assert scope['type'] == 'http'
+
+        await send({
+            'type': 'http.response.start',
+            'status': 200,
+            'headers': [
+                [b'content-type', b'text/plain'],
+            ],
+        })
+
+        await send({
+            'type': 'http.response.body',
+            'body': b'Hello, world!',
+        })
+
+ASGIGateway = ASGIHandler()

orionis-0.733.0/orionis/http/core/rsgi.py

@@ -0,0 +1,17 @@
+from granian.rsgi import Scope
+
+class RSGIHandler:
+
+    async def __call__(self, scope: Scope, proto):
+
+        assert scope.proto == 'http'
+
+        proto.response_str(
+            status=200,
+            headers=[
+                ('content-type', 'text/plain')
+            ],
+            body="Hello, world!"
+        )
+
+RSGIGateway = RSGIHandler()

orionis-0.733.0/orionis/http/kernel.py

@@ -0,0 +1,54 @@
+from orionis.console.exceptions import CLIOrionisValueError
+from orionis.failure.contracts.catch import ICatch
+from orionis.foundation.contracts.application import IApplication
+from orionis.http.contracts.kernel import IKernelHTTP
+from granian._granian import RSGIHTTPScope
+from orionis.http.core.asgi import ASGIGateway
+from orionis.http.core.rsgi import RSGIGateway
+
+class KernelHTTP(IKernelHTTP):
+
+    def __init__(
+        self,
+        app: IApplication
+    ) -> None:
+        """
+        Initializes the KernelCLI instance with the provided application container.
+
+        Parameters
+        ----------
+        app : IApplication
+            The application container instance that provides access to services and dependencies.
+
+        Returns
+        -------
+        None
+            This constructor does not return a value. It initializes internal dependencies required for CLI operations.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If the provided `app` argument is not an instance of `IApplication`.
+        """
+
+        # Validate that the app is an instance of IApplication
+        if not isinstance(app, IApplication):
+            raise CLIOrionisValueError(
+                f"Failed to initialize TestKernel: expected IApplication, got {type(app).__module__}.{type(app).__name__}."
+            )
+
+        # Retrieve and initialize the catch instance from the application container.
+        self.__catch: ICatch = app.make(ICatch)
+
+    async def handle(self, *args) -> None:
+        if args and isinstance(args[0], dict):
+            scope = args[0]
+            method = scope.get("method")
+            path = scope.get("path")
+            print(f"[{method}] - {path}")
+            await ASGIGateway(*args)
+        elif args and isinstance(args[0], RSGIHTTPScope):
+            method = args[0].method
+            path = args[0].path
+            print(f"[{method}] - {path}")
+            await RSGIGateway(*args)

{orionis-0.732.0 → orionis-0.733.0}/orionis/metadata/framework.py

@@ -6,7 +6,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.732.0"
+VERSION = "0.733.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

{orionis-0.732.0 → orionis-0.733.0/orionis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.732.0
+Version: 0.733.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.732.0 → orionis-0.733.0}/orionis.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ orionis/console/commands/make_command.py
 orionis/console/commands/make_scheduler_listener.py
 orionis/console/commands/scheduler_list.py
 orionis/console/commands/scheduler_work.py
+orionis/console/commands/server.py
 orionis/console/commands/test.py
 orionis/console/commands/version.py
 orionis/console/contracts/__init__.py
@@ -216,6 +217,13 @@ orionis/foundation/providers/reactor_provider.py
 orionis/foundation/providers/scheduler_provider.py
 orionis/foundation/providers/testing_provider.py
 orionis/foundation/providers/workers_provider.py
+orionis/http/__init__.py
+orionis/http/kernel.py
+orionis/http/contracts/__init__.py
+orionis/http/contracts/kernel.py
+orionis/http/core/__init__.py
+orionis/http/core/asgi.py
+orionis/http/core/rsgi.py
 orionis/metadata/__init__.py
 orionis/metadata/framework.py
 orionis/metadata/package.py