flwr-nightly 1.23.0.dev20250930__py3-none-any.whl → 1.26.0.dev20260121__py3-none-any.whl

flwr/supernode/cli/flower_supernode.py

@@ -18,14 +18,12 @@
 import argparse
 from logging import DEBUG, INFO, WARN
 from pathlib import Path
-from typing import Optional
 
+import yaml
 from cryptography.exceptions import UnsupportedAlgorithm
-from cryptography.hazmat.primitives.asymmetric import ec
-from cryptography.hazmat.primitives.serialization import (
-    load_ssh_private_key,
-    load_ssh_public_key,
-)
+from cryptography.hazmat.primitives.asymmetric import ec, ed25519
+from cryptography.hazmat.primitives.serialization import load_ssh_private_key
+from cryptography.hazmat.primitives.serialization.ssh import load_ssh_public_key
 
 from flwr.common import EventType, event
 from flwr.common.args import try_obtain_root_certificates
@@ -61,9 +59,19 @@ def flower_supernode() -> None:
             "Ignoring `--flwr-dir`.",
         )
 
+    trusted_entities = _try_obtain_trusted_entities(args.trusted_entities)
+    if trusted_entities:
+        _validate_public_keys_ed25519(trusted_entities)
     root_certificates = try_obtain_root_certificates(args, args.superlink)
     authentication_keys = _try_setup_client_authentication(args)
 
+    # Warn if authentication keys are provided but transport is not grpc-rere
+    if authentication_keys is not None and args.transport != TRANSPORT_TYPE_GRPC_RERE:
+        log(
+            WARN,
+            "SuperNode Authentication is only supported with the grpc-rere transport.",
+        )
+
     log(DEBUG, "Isolation mode: %s", args.isolation)
 
     start_client_internal(
@@ -81,6 +89,7 @@ def flower_supernode() -> None:
         isolation=args.isolation,
         clientappio_api_address=args.clientappio_api_address,
         health_server_address=args.health_server_address,
+        trusted_entities=trusted_entities,
     )
 
 
@@ -120,6 +129,18 @@ def _parse_args_run_supernode() -> argparse.ArgumentParser:
         help="ClientAppIo API (gRPC) server address (IPv4, IPv6, or a domain name). "
         f"By default, it is set to {CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS}.",
     )
+    parser.add_argument(
+        "--trusted-entities",
+        type=Path,
+        default=None,
+        metavar="YAML_FILE",
+        help=(
+            "Path to a YAML file defining trusted entities. "
+            "The file must map public key IDs to public keys. "
+            "Example: { fpk_UUID1: 'ssh-ed25519 <key1> [comment1]', "
+            "fpk_UUID2: 'ssh-ed25519 <key2> [comment2]' }"
+        ),
+    )
     add_args_health(parser)
 
     return parser
@@ -188,12 +209,12 @@ def _parse_args_common(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--auth-supernode-private-key",
         type=str,
-        help="The SuperNode's private key (as a path str) to enable authentication.",
+        help="Path to the SuperNode's private key to enable authentication.",
     )
     parser.add_argument(
         "--auth-supernode-public-key",
         type=str,
-        help="The SuperNode's public key (as a path str) to enable authentication.",
+        help="This argument is deprecated and will be removed in a future release.",
     )
     parser.add_argument(
         "--node-config",
@@ -206,13 +227,10 @@ def _parse_args_common(parser: argparse.ArgumentParser) -> None:
 
 def _try_setup_client_authentication(
     args: argparse.Namespace,
-) -> Optional[tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]]:
-    if not args.auth_supernode_private_key and not args.auth_supernode_public_key:
+) -> tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None:
+    if not args.auth_supernode_private_key:
         return None
 
-    if not args.auth_supernode_private_key or not args.auth_supernode_public_key:
-        flwr_exit(ExitCode.SUPERNODE_NODE_AUTH_KEYS_REQUIRED)
-
     try:
         ssh_private_key = load_ssh_private_key(
             Path(args.auth_supernode_private_key).read_bytes(),
@@ -222,23 +240,53 @@ def _try_setup_client_authentication(
             raise ValueError()
     except (ValueError, UnsupportedAlgorithm):
         flwr_exit(
-            ExitCode.SUPERNODE_NODE_AUTH_KEYS_INVALID,
+            ExitCode.SUPERNODE_NODE_AUTH_KEY_INVALID,
             "Unable to parse the private key file.",
         )
 
-    try:
-        ssh_public_key = load_ssh_public_key(
-            Path(args.auth_supernode_public_key).read_bytes()
+    if args.auth_supernode_public_key:
+        log(
+            WARN,
+            "The `--auth-supernode-public-key` flag is deprecated and will be "
+            "removed in a future release. The public key is now derived from the "
+            "private key provided by `--auth-supernode-private-key`.",
         )
-        if not isinstance(ssh_public_key, ec.EllipticCurvePublicKey):
-            raise ValueError()
-    except (ValueError, UnsupportedAlgorithm):
+    return ssh_private_key, ssh_private_key.public_key()
+
+
+def _try_obtain_trusted_entities(
+    trusted_entities_path: Path | None,
+) -> dict[str, str] | None:
+    """Validate and return the trust entities."""
+    if not trusted_entities_path:
+        return None
+    if not trusted_entities_path.is_file():
         flwr_exit(
-            ExitCode.SUPERNODE_NODE_AUTH_KEYS_INVALID,
-            "Unable to parse the public key file.",
+            ExitCode.SUPERNODE_INVALID_TRUSTED_ENTITIES,
+            "Path argument `--trusted-entities` does not point to a file.",
         )
+    try:
+        with trusted_entities_path.open("r", encoding="utf-8") as f:
+            trusted_entities = yaml.safe_load(f)
+        if not isinstance(trusted_entities, dict):
+            raise ValueError("Invalid trusted entities format.")
+    except (yaml.YAMLError, ValueError) as e:
+        flwr_exit(
+            ExitCode.SUPERNODE_INVALID_TRUSTED_ENTITIES,
+            f"Failed to read YAML file '{trusted_entities_path}': {e}",
+        )
+    return trusted_entities
 
-    return (
-        ssh_private_key,
-        ssh_public_key,
-    )
+
+def _validate_public_keys_ed25519(trusted_entities: dict[str, str]) -> None:
+    """Validate public keys for the trust entities are Ed25519."""
+    for public_key_id in trusted_entities.keys():
+        verifier_public_key = load_ssh_public_key(
+            trusted_entities[public_key_id].encode("utf-8")
+        )
+        if not isinstance(verifier_public_key, ed25519.Ed25519PublicKey):
+            flwr_exit(
+                ExitCode.SUPERNODE_INVALID_TRUSTED_ENTITIES,
+                "The provided public key associated with "
+                f"trusted entity {public_key_id} is not Ed25519.",
+            )

flwr/supernode/nodestate/in_memory_nodestate.py

@@ -15,18 +15,28 @@
 """In-memory NodeState implementation."""
 
 
-import secrets
 from collections.abc import Sequence
 from dataclasses import dataclass
-from threading import Lock
-from typing import Optional
-
-from flwr.common import Context, Message
-from flwr.common.constant import FLWR_APP_TOKEN_LENGTH
+from threading import Lock, RLock
+
+from flwr.common import Context, Error, Message, now
+from flwr.common.constant import ErrorCode
+from flwr.common.inflatable import (
+    get_all_nested_objects,
+    get_object_tree,
+    no_object_id_recompute,
+)
 from flwr.common.typing import Run
+from flwr.supercore.constant import MESSAGE_TIME_ENTRY_MAX_AGE_SECONDS
+from flwr.supercore.corestate.in_memory_corestate import InMemoryCoreState
+from flwr.supercore.object_store import ObjectStore
 
 from .nodestate import NodeState
 
+CLIENT_APP_CRASHED_ERROR = Error(
+    ErrorCode.CLIENT_APP_CRASHED, "ClientApp stopped responding."
+)
+
 
 @dataclass
 class MessageEntry:
@@ -36,27 +46,37 @@ class MessageEntry:
     is_retrieved: bool = False
 
 
-class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attributes
+@dataclass
+class TimeEntry:
+    """Data class to represent a time entry."""
+
+    starting_at: float
+    finished_at: float | None = None
+
+
+class InMemoryNodeState(
+    NodeState, InMemoryCoreState
+):  # pylint: disable=too-many-instance-attributes
     """In-memory NodeState implementation."""
 
-    def __init__(self) -> None:
+    def __init__(self, object_store: ObjectStore) -> None:
+        super().__init__(object_store)
         # Store node_id
-        self.node_id: Optional[int] = None
+        self.node_id: int | None = None
         # Store Object ID to MessageEntry mapping
         self.msg_store: dict[str, MessageEntry] = {}
-        self.lock_msg_store = Lock()
+        self.lock_msg_store = RLock()
         # Store run ID to Run mapping
         self.run_store: dict[int, Run] = {}
         self.lock_run_store = Lock()
         # Store run ID to Context mapping
         self.ctx_store: dict[int, Context] = {}
         self.lock_ctx_store = Lock()
-        # Store run ID to token mapping and token to run ID mapping
-        self.token_store: dict[int, str] = {}
-        self.token_to_run_id: dict[str, int] = {}
-        self.lock_token_store = Lock()
+        # Store msg ID to TimeEntry mapping
+        self.time_store: dict[str, TimeEntry] = {}
+        self.lock_time_store = Lock()
 
-    def set_node_id(self, node_id: Optional[int]) -> None:
+    def set_node_id(self, node_id: int | None) -> None:
         """Set the node ID."""
         self.node_id = node_id
 
@@ -66,8 +86,10 @@ class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attribu
             raise ValueError("Node ID not set")
         return self.node_id
 
-    def store_message(self, message: Message) -> Optional[str]:
+    def store_message(self, message: Message) -> str | None:
         """Store a message."""
+        # No need to check for expired tokens here
+        # The ClientAppIo servicer will first verify the token before storing messages
         with self.lock_msg_store:
             msg_id = message.metadata.message_id
             if msg_id == "" or msg_id in self.msg_store:
@@ -78,13 +100,14 @@ class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attribu
     def get_messages(
         self,
         *,
-        run_ids: Optional[Sequence[int]] = None,
-        is_reply: Optional[bool] = None,
-        limit: Optional[int] = None,
+        run_ids: Sequence[int] | None = None,
+        is_reply: bool | None = None,
+        limit: int | None = None,
     ) -> Sequence[Message]:
         """Retrieve messages based on the specified filters."""
-        selected_messages: list[Message] = []
+        self._cleanup_expired_tokens()
 
+        selected_messages: list[Message] = []
         with self.lock_msg_store:
             # Iterate through all messages in the store
             for object_id in list(self.msg_store.keys()):
@@ -122,7 +145,7 @@ class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attribu
     def delete_messages(
         self,
         *,
-        message_ids: Optional[Sequence[str]] = None,
+        message_ids: Sequence[str] | None = None,
     ) -> None:
         """Delete messages based on the specified filters."""
         with self.lock_msg_store:
@@ -140,7 +163,7 @@ class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attribu
         with self.lock_run_store:
             self.run_store[run.run_id] = run
 
-    def get_run(self, run_id: int) -> Optional[Run]:
+    def get_run(self, run_id: int) -> Run | None:
         """Retrieve a run by its ID."""
         with self.lock_run_store:
             return self.run_store.get(run_id)
@@ -150,7 +173,7 @@ class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attribu
         with self.lock_ctx_store:
             self.ctx_store[context.run_id] = context
 
-    def get_context(self, run_id: int) -> Optional[Context]:
+    def get_context(self, run_id: int) -> Context | None:
         """Retrieve a context by its run ID."""
         with self.lock_ctx_store:
             return self.ctx_store.get(run_id)
@@ -171,29 +194,78 @@ class InMemoryNodeState(NodeState):  # pylint: disable=too-many-instance-attribu
             ret -= set(self.token_store.keys())
             return list(ret)
 
-    def create_token(self, run_id: int) -> Optional[str]:
-        """Create a token for the given run ID."""
-        token = secrets.token_hex(FLWR_APP_TOKEN_LENGTH)  # Generate a random token
-        with self.lock_token_store:
-            if run_id in self.token_store:
-                return None  # Token already created for this run ID
-            self.token_store[run_id] = token
-            self.token_to_run_id[token] = run_id
-        return token
-
-    def verify_token(self, run_id: int, token: str) -> bool:
-        """Verify a token for the given run ID."""
-        with self.lock_token_store:
-            return self.token_store.get(run_id) == token
-
-    def delete_token(self, run_id: int) -> None:
-        """Delete the token for the given run ID."""
-        with self.lock_token_store:
-            token = self.token_store.pop(run_id, None)
-            if token is not None:
-                self.token_to_run_id.pop(token, None)
-
-    def get_run_id_by_token(self, token: str) -> Optional[int]:
-        """Get the run ID associated with a given token."""
-        with self.lock_token_store:
-            return self.token_to_run_id.get(token)
+    def _on_tokens_expired(self, expired_records: list[tuple[int, float]]) -> None:
+        """Insert error replies for messages associated with expired tokens."""
+        with self.lock_msg_store:
+            # Find all retrieved messages associated with expired run IDs
+            expired_run_ids = {run_id for run_id, _ in expired_records}
+            messages_to_reply: list[Message] = []
+            for entry in self.msg_store.values():
+                msg = entry.message
+                if msg.metadata.run_id in expired_run_ids and entry.is_retrieved:
+                    messages_to_reply.append(msg)
+
+            # Create and store error replies for each message
+            for msg in messages_to_reply:
+                error_reply = Message(CLIENT_APP_CRASHED_ERROR, reply_to=msg)
+
+                # Insert objects of the error reply into the object store
+                with no_object_id_recompute():
+                    # pylint: disable-next=W0212
+                    error_reply.metadata._message_id = error_reply.object_id  # type: ignore
+                    object_tree = get_object_tree(error_reply)
+                    self.object_store.preregister(msg.metadata.run_id, object_tree)
+                    for obj_id, obj in get_all_nested_objects(error_reply).items():
+                        self.object_store.put(obj_id, obj.deflate())
+
+                # Store the error reply message
+                self.store_message(error_reply)
+
+    def record_message_processing_start(self, message_id: str) -> None:
+        """Record the start time of message processing based on the message ID."""
+        with self.lock_time_store:
+            self.time_store[message_id] = TimeEntry(starting_at=now().timestamp())
+
+    def record_message_processing_end(self, message_id: str) -> None:
+        """Record the end time of message processing based on the message ID."""
+        with self.lock_time_store:
+            if message_id not in self.time_store:
+                raise ValueError(
+                    f"Cannot record end time: Message ID {message_id} not found."
+                )
+            entry = self.time_store[message_id]
+            entry.finished_at = now().timestamp()
+
+    def get_message_processing_duration(self, message_id: str) -> float:
+        """Get the message processing duration based on the message ID."""
+        # Cleanup old message processing times
+        self._cleanup_old_message_times()
+        with self.lock_time_store:
+            if message_id not in self.time_store:
+                raise ValueError(f"Message ID {message_id} not found.")
+
+            entry = self.time_store[message_id]
+            if entry.starting_at is None or entry.finished_at is None:
+                raise ValueError(
+                    f"Start time or end time for message ID {message_id} is missing."
+                )
+
+            duration = entry.finished_at - entry.starting_at
+            return duration
+
+    def _cleanup_old_message_times(self) -> None:
+        """Remove time entries older than MESSAGE_TIME_ENTRY_MAX_AGE_SECONDS."""
+        with self.lock_time_store:
+            cutoff = now().timestamp() - MESSAGE_TIME_ENTRY_MAX_AGE_SECONDS
+            # Find message IDs for entries that have a finishing_at time
+            # before the cutoff, and those that don't exist in msg_store
+            to_delete = [
+                msg_id
+                for msg_id, entry in self.time_store.items()
+                if (entry.finished_at and entry.finished_at < cutoff)
+                or msg_id not in self.msg_store
+            ]
+
+            # Delete the identified entries
+            for msg_id in to_delete:
+                del self.time_store[msg_id]

flwr/supernode/nodestate/nodestate.py

@@ -17,7 +17,6 @@
 
 from abc import abstractmethod
 from collections.abc import Sequence
-from typing import Optional
 
 from flwr.common import Context, Message
 from flwr.common.typing import Run
@@ -36,7 +35,7 @@ class NodeState(CoreState):
         """Get the node ID."""
 
     @abstractmethod
-    def store_message(self, message: Message) -> Optional[str]:
+    def store_message(self, message: Message) -> str | None:
         """Store a message.
 
         Parameters
@@ -54,9 +53,9 @@ class NodeState(CoreState):
     def get_messages(
         self,
         *,
-        run_ids: Optional[Sequence[int]] = None,
-        is_reply: Optional[bool] = None,
-        limit: Optional[int] = None,
+        run_ids: Sequence[int] | None = None,
+        is_reply: bool | None = None,
+        limit: int | None = None,
     ) -> Sequence[Message]:
         """Retrieve messages based on the specified filters.
 
@@ -89,7 +88,7 @@ class NodeState(CoreState):
     def delete_messages(
         self,
         *,
-        message_ids: Optional[Sequence[str]] = None,
+        message_ids: Sequence[str] | None = None,
     ) -> None:
         """Delete messages based on the specified filters.
 
@@ -118,7 +117,7 @@ class NodeState(CoreState):
         """
 
     @abstractmethod
-    def get_run(self, run_id: int) -> Optional[Run]:
+    def get_run(self, run_id: int) -> Run | None:
         """Retrieve a run by its ID.
 
         Parameters
@@ -143,7 +142,7 @@ class NodeState(CoreState):
         """
 
     @abstractmethod
-    def get_context(self, run_id: int) -> Optional[Context]:
+    def get_context(self, run_id: int) -> Context | None:
         """Retrieve a context by its run ID.
 
         Parameters
@@ -169,3 +168,48 @@ class NodeState(CoreState):
         Sequence[int]
             Sequence of run IDs with pending messages.
         """
+
+    @abstractmethod
+    def record_message_processing_start(self, message_id: str) -> None:
+        """Record the start time of message processing based on the message ID.
+
+        Parameters
+        ----------
+        message_id : str
+            The ID of the message associated with the start time.
+        """
+
+    @abstractmethod
+    def record_message_processing_end(self, message_id: str) -> None:
+        """Record the end time of message processing based on the message ID.
+
+        Parameters
+        ----------
+        message_id : str
+            The ID of the message associated with the end time.
+
+        Raises
+        ------
+        ValueError
+            If the message ID is not found.
+        """
+
+    @abstractmethod
+    def get_message_processing_duration(self, message_id: str) -> float:
+        """Get the message processing duration based on the message ID.
+
+        Parameters
+        ----------
+        message_id : str
+            The ID of the message.
+
+        Returns
+        -------
+        float
+            The processing duration in seconds.
+
+        Raises
+        ------
+        ValueError
+            If the message ID is not found, or if start/end times are missing.
+        """

flwr/supernode/nodestate/nodestate_factory.py

@@ -16,7 +16,8 @@
 
 
 import threading
-from typing import Optional
+
+from flwr.supercore.object_store import ObjectStoreFactory
 
 from .in_memory_nodestate import InMemoryNodeState
 from .nodestate import NodeState
@@ -25,8 +26,9 @@ from .nodestate import NodeState
 class NodeStateFactory:
     """Factory class that creates NodeState instances."""
 
-    def __init__(self) -> None:
-        self.state_instance: Optional[NodeState] = None
+    def __init__(self, objectstore_factory: ObjectStoreFactory) -> None:
+        self.objectstore_factory = objectstore_factory
+        self.state_instance: NodeState | None = None
         self.lock = threading.RLock()
 
     def state(self) -> NodeState:
@@ -34,5 +36,6 @@ class NodeStateFactory:
         # Lock access to NodeStateFactory to prevent returning different instances
         with self.lock:
             if self.state_instance is None:
-                self.state_instance = InMemoryNodeState()
+                object_store = self.objectstore_factory.store()
+                self.state_instance = InMemoryNodeState(object_store)
             return self.state_instance

flwr/supernode/runtime/run_clientapp.py

@@ -15,19 +15,18 @@
 """Flower ClientApp process."""
 
 
-import gc
 from logging import DEBUG, ERROR, INFO
-from typing import Optional
 
 import grpc
 
 from flwr.app.error import Error
 from flwr.cli.install import install_from_fab
-from flwr.client.client_app import ClientApp, LoadClientAppError
-from flwr.client.clientapp.utils import get_load_client_app_fn
+from flwr.clientapp.client_app import ClientApp, LoadClientAppError
+from flwr.clientapp.utils import get_load_client_app_fn
 from flwr.common import Context, Message
 from flwr.common.config import get_flwr_dir
 from flwr.common.constant import ErrorCode
+from flwr.common.exit import ExitCode, flwr_exit, register_signal_handlers
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.inflatable import (
     get_all_nested_objects,
@@ -50,6 +49,7 @@ from flwr.common.serde import (
     message_to_proto,
     run_from_proto,
 )
+from flwr.common.telemetry import EventType, event
 from flwr.common.typing import Fab, Run
 from flwr.proto.appio_pb2 import (  # pylint: disable=E0611
     PullAppInputsRequest,
@@ -63,27 +63,41 @@ from flwr.proto.appio_pb2 import (  # pylint: disable=E0611
 from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.supercore.app_utils import start_parent_process_monitor
+from flwr.supercore.heartbeat import HeartbeatSender, make_app_heartbeat_fn_grpc
 from flwr.supercore.utils import mask_string
 
 
 def run_clientapp(  # pylint: disable=R0913, R0914, R0917
     clientappio_api_address: str,
     token: str,
-    flwr_dir: Optional[str] = None,
-    certificates: Optional[bytes] = None,
-    parent_pid: Optional[int] = None,
+    flwr_dir: str | None = None,
+    certificates: bytes | None = None,
+    parent_pid: int | None = None,
 ) -> None:
     """Run Flower ClientApp process."""
     # Monitor the main process in case of SIGKILL
     if parent_pid is not None:
         start_parent_process_monitor(parent_pid)
 
+    event(EventType.FLWR_CLIENTAPP_RUN_ENTER)
+
     channel = create_channel(
         server_address=clientappio_api_address,
         insecure=(certificates is None),
         root_certificates=certificates,
     )
     channel.subscribe(on_channel_state_change)
+    heartbeat_sender = None
+
+    def on_exit() -> None:
+        if heartbeat_sender is not None and heartbeat_sender.is_running:
+            heartbeat_sender.stop()
+        channel.close()
+
+    register_signal_handlers(
+        event_type=EventType.FLWR_CLIENTAPP_RUN_LEAVE,
+        exit_handlers=[on_exit],
+    )
 
     # Resolve directory where FABs are installed
     flwr_dir_ = get_flwr_dir(flwr_dir)
@@ -91,22 +105,27 @@ def run_clientapp(  # pylint: disable=R0913, R0914, R0917
         stub = ClientAppIoStub(channel)
         _wrap_stub(stub, _make_simple_grpc_retry_invoker())
 
+        # Start app heartbeat
+        heartbeat_sender = HeartbeatSender(make_app_heartbeat_fn_grpc(stub, token))
+        heartbeat_sender.start()
+
         # Pull Message, Context, Run and (optional) FAB from SuperNode
         message, context, run, fab = pull_clientappinputs(stub=stub, token=token)
 
-        # Install FAB, if provided
-        if fab:
-            log(DEBUG, "[flwr-clientapp] Start FAB installation.")
-            install_from_fab(fab.content, flwr_dir=flwr_dir_, skip_prompt=True)
+        try:
 
-        load_client_app_fn = get_load_client_app_fn(
-            default_app_ref="",
-            app_path=None,
-            multi_app=True,
-            flwr_dir=str(flwr_dir_),
-        )
+            # Install FAB, if provided
+            if fab:
+                log(DEBUG, "[flwr-clientapp] Start FAB installation.")
+                install_from_fab(fab.content, flwr_dir=flwr_dir_, skip_prompt=True)
+
+            load_client_app_fn = get_load_client_app_fn(
+                default_app_ref="",
+                app_path=None,
+                multi_app=True,
+                flwr_dir=str(flwr_dir_),
+            )
 
-        try:
             # Load ClientApp
             log(DEBUG, "[flwr-clientapp] Start `ClientApp` Loading.")
             client_app: ClientApp = load_client_app_fn(
@@ -137,18 +156,18 @@ def run_clientapp(  # pylint: disable=R0913, R0914, R0917
             stub=stub, token=token, message=reply_message, context=context
         )
 
-        del client_app, message, context, run, fab, reply_message
-        gc.collect()
-
     except grpc.RpcError as e:
         log(ERROR, "GRPC error occurred: %s", str(e))
-    finally:
-        channel.close()
+
+    flwr_exit(
+        code=ExitCode.SUCCESS,
+        event_type=EventType.FLWR_CLIENTAPP_RUN_LEAVE,
+    )
 
 
 def pull_clientappinputs(
     stub: ClientAppIoStub, token: str
-) -> tuple[Message, Context, Run, Optional[Fab]]:
+) -> tuple[Message, Context, Run, Fab | None]:
     """Pull ClientAppInputs from SuperNode."""
     masked_token = mask_string(token)
     log(INFO, "[flwr-clientapp] Pull `ClientAppInputs` for token %s", masked_token)