[IMP] fastapi: Improves app cache lifecycle

This commit improves the lifecycle of the fastapi app cache.
It first ensures that the cache is effectively invalidated when changes
are made to the app configuration even if theses changes occur into an
other server instance.
It also remove the use of a locking mechanism put in place to ensure a thread
safe access to a value into the cache to avoid potential concurrency issue when
a default value is set to the cache at access time. This lock could lead
to unnecessary contention and reduce the performance benefits of queue.Queue's
fine-grained internal synchronization for a questionable gain. The only
expected gain was to avoid the useless creation of a queue.Queue instance
that would never be used since at the time of puting the value into the cache
we are sure that a value is already present into the dictionary.

Author: lmignon

fastapi/fastapi_dispatcher.py

@@ -25,7 +25,7 @@ def dispatch(self, endpoint, args):
         root_path = "/" + environ["PATH_INFO"].split("/")[1]
         # TODO store the env into contextvar to be used by the odoo_env
         # depends method
-        with fastapi_app_pool.get_app(root_path, request.env) as app:
+        with fastapi_app_pool.get_app(env=request.env, root_path=root_path) as app:
             uid = request.env["fastapi.endpoint"].sudo().get_uid(root_path)
             data = BytesIO()
             with self._manage_odoo_env(uid):

fastapi/models/fastapi_endpoint.py

@@ -16,7 +16,6 @@
 
 from .. import dependencies
 from ..middleware import ASGIMiddleware
-from ..pools import fastapi_app_pool
 
 _logger = logging.getLogger(__name__)
 
@@ -122,10 +121,10 @@ def _registered_endpoint_rule_keys(self):
         return tuple(res)
 
     @api.model
-    def _routing_impacting_fields(self) -> tuple[str]:
+    def _routing_impacting_fields(self) -> Tuple[str, ...]:
         """The list of fields requiring to refresh the mount point of the pp
         into odoo if modified"""
-        return ("root_path",)
+        return ("root_path", "save_http_session")
 
     #
     # end of endpoint.route.sync.mixin methods implementation
@@ -200,7 +199,17 @@ def _endpoint_registry_route_unique_key(self, routing: dict[str, Any]):
         return f"{self._name}:{self.id}:{path}"
 
     def _reset_app(self):
-        fastapi_app_pool.invalidate(self.root_path, self.env)
+        self._reset_app_cache_marker.clear_cache(self)
+
+    @tools.ormcache()
+    def _reset_app_cache_marker(self):
+        """This methos is used to get a way to mark the orm cache as dirty
+        when the app is reset. By marking the cache as dirty, the system
+        will signal to others instances that the cache is not up to date
+        and that they should invalidate their cache as well. This is required
+        to ensure that any change requiring a reset of the app is propagated
+        to all the running instances.
+        """
 
     @api.model
     def get_app(self, root_path):

fastapi/pools/fastapi_app.py

@@ -1,6 +1,6 @@
 # Copyright 2025 ACSONE SA/NV
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL).
-
+import logging
 import queue
 import threading
 from collections import defaultdict
@@ -11,19 +11,65 @@
 
 from fastapi import FastAPI
 
+_logger = logging.getLogger(__name__)
+
 
 class FastApiAppPool:
+    """Pool of FastAPI apps.
+
+    This class manages a pool of FastAPI apps. The pool is organized by database name
+    and root path. Each pool is a queue of FastAPI apps.
+
+    The pool is used to reuse FastAPI apps across multiple requests. This is useful
+    to avoid the overhead of creating a new FastAPI app for each request. The pool
+    ensures that only one request at a time uses an app.
+
+    The proper way to use the pool is to use the get_app method as a context manager.
+    This ensures that the app is returned to the pool after the context manager exits.
+    The get_app method is designed to ensure that the app made available to the
+    caller is unique and not used by another caller at the same time.
+
+    .. code-block:: python
+
+        with fastapi_app_pool.get_app(env=request.env, root_path=root_path) as app:
+            # use the app
+
+    The pool is invalidated when the cache registry is updated. This ensures that
+    the pool is always up-to-date with the latest app configuration. It also
+    ensures that the invalidation is done even in the case of a modification occurring
+    in a different worker process or thread or server instance. This mechanism
+    works because every time an attribute of the fastapi.endpoint model is modified
+    and this attribute is part of the list returned by the `_fastapi_app_fields`,
+    or `_routing_impacting_fields` methods, we reset the cache of a marker method
+    `_reset_app_cache_marker`. As side effect, the cache registry is marked to be
+    updated by the increment of the `cache_sequence` SQL sequence.  This cache sequence
+    on the registry is reloaded from the DB on each request made to a specific database.
+    When an app is retrieved from the pool, we always compare the cache sequence of
+    the pool with the cache sequence of the registry. If the two sequences are different,
+    we invalidate the pool and save the new cache sequence on the pool.
+
+    The cache is based on a defaultdict of defaultdict of queue.Queue. We are cautious
+    that the use of defaultdict is not thread-safe for operations that modify the
+    dictionary. However the only operation that modifies the dictionary is the
+    first access to a new key. If two threads access the same key at the same time,
+    the two threads will create two different queues. This is not a problem since
+    at the time of returning an app to the pool, we are sure that a queue exists
+    for the key into the cache and all the created apps are returned to the same
+    valid queue. And the end, the lack of thread-safety for the defaultdict could
+    only lead to a negligible overhead of creating a new queue that will never be
+    used. This is why we consider that the use of defaultdict is safe in this context.
+    """
+
     def __init__(self):
         self._queue_by_db_by_root_path: dict[
             str, dict[str, queue.Queue[FastAPI]]
         ] = defaultdict(lambda: defaultdict(queue.Queue))
+        self.__cache_sequence = 0
         self._lock = threading.Lock()
 
     def __get_pool(self, env: Environment, root_path: str) -> queue.Queue[FastAPI]:
         db_name = env.cr.dbname
-        with self._lock:
-            # default dict is not thread safe but the use
-            return self._queue_by_db_by_root_path[db_name][root_path]
+        return self._queue_by_db_by_root_path[db_name][root_path]
 
     def __get_app(self, env: Environment, root_path: str) -> FastAPI:
         pool = self.__get_pool(env, root_path)
@@ -39,7 +85,7 @@ def __return_app(self, env: Environment, app: FastAPI, root_path: str) -> None:
 
     @contextmanager
     def get_app(
-        self, root_path: str, env: Environment
+        self, env: Environment, root_path: str
     ) -> Generator[FastAPI, None, None]:
         """Return a  FastAPI app to be used in a context manager.
 
@@ -49,13 +95,36 @@ def get_app(
         When used into the FastApiDispatcher class this ensures that the app is reused
         across multiple requests but only one request at a time uses an app.
         """
+        self._check_cache(env)
         app = self.__get_app(env, root_path)
         try:
             yield app
         finally:
             self.__return_app(env, app, root_path)
 
-    def invalidate(self, root_path: str, env: Environment) -> None:
-        with self._lock:
-            db_name = env.cr.dbname
+    @property
+    def cache_sequence(self) -> int:
+        return self.__cache_sequence
+
+    @cache_sequence.setter
+    def cache_sequence(self, value: int) -> None:
+        if value != self.__cache_sequence:
+            with self._lock:
+                self.__cache_sequence = value
+
+    def _check_cache(self, env: Environment) -> None:
+        cache_sequence = env.registry.cache_sequence
+        if cache_sequence != self.cache_sequence and self.cache_sequence != 0:
+            _logger.info(
+                "Cache registry updated, reset fastapi_app pool for the current "
+                "database"
+            )
+            self.invalidate(env)
+        self.cache_sequence = cache_sequence
+
+    def invalidate(self, env: Environment, root_path: str | None = None) -> None:
+        db_name = env.cr.dbname
+        if root_path:
             self._queue_by_db_by_root_path[db_name][root_path] = queue.Queue()
+        elif db_name in self._queue_by_db_by_root_path:
+            del self._queue_by_db_by_root_path[db_name]