jararaca 0.3.11a16__py3-none-any.whl → 0.4.0a5__py3-none-any.whl

jararaca/presentation/websocket/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later

jararaca/presentation/websocket/base_types.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from typing import ClassVar
 
 from pydantic import BaseModel

jararaca/presentation/websocket/context.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from contextlib import contextmanager, suppress
 from contextvars import ContextVar
 from typing import Generator, Protocol

jararaca/presentation/websocket/decorators.py

@@ -1,6 +1,11 @@
-from typing import TypedDict, TypeVar, cast
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import TypedDict, TypeVar
 
 from jararaca.presentation.websocket.base_types import WebSocketMessageBase
+from jararaca.reflect.decorators import StackableDecorator
 
 DECORATED_CLASS = TypeVar("DECORATED_CLASS")
 
@@ -8,9 +13,8 @@ DECORATED_CLASS = TypeVar("DECORATED_CLASS")
 class WebSocketEndpointOptions(TypedDict): ...
 
 
-class WebSocketEndpoint:
+class WebSocketEndpoint(StackableDecorator):
 
-    WEBSOCKET_ENDPOINT_ATTR = "__websocket_endpoint__"
     ORDER_COUNTER = 0
 
     def __init__(self, path: str, options: WebSocketEndpointOptions = {}) -> None:
@@ -19,48 +23,11 @@ class WebSocketEndpoint:
         WebSocketEndpoint.ORDER_COUNTER += 1
         self.order = WebSocketEndpoint.ORDER_COUNTER
 
-    @staticmethod
-    def register(cls: DECORATED_CLASS, instance: "WebSocketEndpoint") -> None:
-        setattr(cls, WebSocketEndpoint.WEBSOCKET_ENDPOINT_ATTR, instance)
-
-    @staticmethod
-    def get(cls: DECORATED_CLASS) -> "WebSocketEndpoint | None":
-        if not hasattr(cls, WebSocketEndpoint.WEBSOCKET_ENDPOINT_ATTR):
-            return None
-
-        return cast(
-            WebSocketEndpoint, getattr(cls, WebSocketEndpoint.WEBSOCKET_ENDPOINT_ATTR)
-        )
-
-    def __call__(self, cls: DECORATED_CLASS) -> DECORATED_CLASS:
-        WebSocketEndpoint.register(cls, self)
-        return cls
-
 
 INHERITS_WS_MESSAGE = TypeVar("INHERITS_WS_MESSAGE", bound=WebSocketMessageBase)
 
 
-class RegisterWebSocketMessage:
-
-    REGISTER_WEBSOCKET_MESSAGE_ATTR = "__register_websocket_message__"
+class RegisterWebSocketMessage(StackableDecorator):
 
     def __init__(self, *message_types: type[INHERITS_WS_MESSAGE]) -> None:
         self.message_types = message_types
-
-    @staticmethod
-    def register(cls: DECORATED_CLASS, instance: "RegisterWebSocketMessage") -> None:
-        setattr(cls, RegisterWebSocketMessage.REGISTER_WEBSOCKET_MESSAGE_ATTR, instance)
-
-    @staticmethod
-    def get(cls: DECORATED_CLASS) -> "RegisterWebSocketMessage | None":
-        if not hasattr(cls, RegisterWebSocketMessage.REGISTER_WEBSOCKET_MESSAGE_ATTR):
-            return None
-
-        return cast(
-            RegisterWebSocketMessage,
-            getattr(cls, RegisterWebSocketMessage.REGISTER_WEBSOCKET_MESSAGE_ATTR),
-        )
-
-    def __call__(self, cls: DECORATED_CLASS) -> DECORATED_CLASS:
-        RegisterWebSocketMessage.register(cls, self)
-        return cls

jararaca/presentation/websocket/redis.py

@@ -1,4 +1,9 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import asyncio
+import logging
 from dataclasses import dataclass
 from typing import Any
 
@@ -10,6 +15,8 @@ from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketConnectionBackend,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class BroadcastMessage:
@@ -55,6 +62,8 @@ class RedisWebSocketConnectionBackend(WebSocketConnectionBackend):
         send_pubsub_channel: str,
         consume_broadcast_timeout: int = 1,
         consume_send_timeout: int = 1,
+        retry_delay: float = 5.0,
+        max_concurrent_tasks: int = 1000,
     ) -> None:
 
         self.redis = conn
@@ -63,89 +72,307 @@ class RedisWebSocketConnectionBackend(WebSocketConnectionBackend):
 
         self.lock = asyncio.Lock()
         self.tasks: set[asyncio.Task[Any]] = set()
+        self.max_concurrent_tasks = max_concurrent_tasks
+        self.task_semaphore = asyncio.Semaphore(max_concurrent_tasks)
 
         self.consume_broadcast_timeout = consume_broadcast_timeout
         self.consume_send_timeout = consume_send_timeout
+        self.retry_delay = retry_delay
+        self.__shutdown_event: asyncio.Event | None = None
+
+        self.__send_func: SendFunc | None = None
+        self.__broadcast_func: BroadcastFunc | None = None
+
+    @property
+    def shutdown_event(self) -> asyncio.Event:
+        if self.__shutdown_event is None:
+            raise RuntimeError(
+                "Shutdown event is not set. Please configure the backend before using it."
+            )
+        return self.__shutdown_event
+
+    @property
+    def send_func(self) -> SendFunc:
+        if self.__send_func is None:
+            raise RuntimeError(
+                "Send function is not set. Please configure the backend before using it."
+            )
+        return self.__send_func
+
+    @property
+    def broadcast_func(self) -> BroadcastFunc:
+        if self.__broadcast_func is None:
+            raise RuntimeError(
+                "Broadcast function is not set. Please configure the backend before using it."
+            )
+        return self.__broadcast_func
 
     async def broadcast(self, message: bytes) -> None:
-        await self.redis.publish(
-            self.broadcast_pubsub_channel,
-            BroadcastMessage.from_message(message).encode(),
-        )
+        try:
+            await self.redis.publish(
+                self.broadcast_pubsub_channel,
+                BroadcastMessage.from_message(message).encode(),
+            )
+        except Exception as e:
+            logger.error(
+                "Failed to publish broadcast message to Redis: %s", e, exc_info=True
+            )
+            raise
 
     async def send(self, rooms: list[str], message: bytes) -> None:
-        await self.redis.publish(
-            self.send_pubsub_channel,
-            SendToRoomsMessage.from_message(rooms, message).encode(),
-        )
+        try:
+            await self.redis.publish(
+                self.send_pubsub_channel,
+                SendToRoomsMessage.from_message(rooms, message).encode(),
+            )
+        except Exception as e:
+            logger.error(
+                "Failed to publish send message to Redis: %s", e, exc_info=True
+            )
+            raise
 
     def configure(
         self, broadcast: BroadcastFunc, send: SendFunc, shutdown_event: asyncio.Event
     ) -> None:
+        if self.__shutdown_event is not None:
+            raise RuntimeError("Backend is already configured.")
+        self.__shutdown_event = shutdown_event
+        self.__send_func = send
+        self.__broadcast_func = broadcast
+        self.setup_send_consumer()
+        self.setup_broadcast_consumer()
 
-        broadcast_task = asyncio.get_event_loop().create_task(
-            self.consume_broadcast(broadcast, shutdown_event)
-        )
+    def setup_send_consumer(self) -> None:
 
         send_task = asyncio.get_event_loop().create_task(
-            self.consume_send(send, shutdown_event)
+            self.consume_send(self.send_func, self.shutdown_event)
         )
 
-        self.tasks.add(broadcast_task)
-        self.tasks.add(send_task)
-
-    async def consume_broadcast(
-        self, broadcast: BroadcastFunc, shutdown_event: asyncio.Event
-    ) -> None:
+        # Use lock when modifying tasks set to prevent race conditions
+        async def add_task() -> None:
+            async with self.lock:
+                self.tasks.add(send_task)
 
-        async with self.redis.pubsub() as pubsub:
-            await pubsub.subscribe(self.broadcast_pubsub_channel)
+        asyncio.get_event_loop().create_task(add_task())
+        send_task.add_done_callback(self.handle_send_task_done)
 
-            while not shutdown_event.is_set():
-                message: dict[str, Any] | None = await pubsub.get_message(
-                    ignore_subscribe_messages=True,
-                    timeout=self.consume_broadcast_timeout,
-                )
+    def setup_broadcast_consumer(self) -> None:
 
-                if message is None:
-                    continue
-
-                broadcast_message = BroadcastMessage.decode(message["data"])
-
-                async with self.lock:
-                    task = asyncio.get_event_loop().create_task(
-                        broadcast(message=broadcast_message.message)
-                    )
+        broadcast_task = asyncio.get_event_loop().create_task(
+            self.consume_broadcast(self.broadcast_func, self.shutdown_event)
+        )
 
-                    self.tasks.add(task)
+        # Use lock when modifying tasks set to prevent race conditions
+        async def add_task() -> None:
+            async with self.lock:
+                self.tasks.add(broadcast_task)
+
+        asyncio.get_event_loop().create_task(add_task())
+
+        broadcast_task.add_done_callback(self.handle_broadcast_task_done)
+
+    def handle_broadcast_task_done(self, task: asyncio.Task[Any]) -> None:
+        # Remove task from set safely with lock
+        async def remove_task() -> None:
+            async with self.lock:
+                self.tasks.discard(task)
+
+        asyncio.get_event_loop().create_task(remove_task())
+
+        if task.cancelled():
+            logger.warning("Broadcast task was cancelled.")
+        elif task.exception() is not None:
+            logger.exception(
+                "Broadcast task raised an exception:", exc_info=task.exception()
+            )
+        else:
+            logger.warning("Broadcast task somehow completed successfully.")
+
+        if not self.shutdown_event.is_set():
+            logger.warning(
+                "Broadcast task completed, but shutdown event is not set. This is unexpected."
+            )
+            # Add delay before retrying to avoid excessive CPU usage
+            asyncio.get_event_loop().create_task(
+                self._retry_broadcast_consumer_with_delay()
+            )
+
+    def handle_send_task_done(self, task: asyncio.Task[Any]) -> None:
+        # Remove task from set safely with lock
+        async def remove_task() -> None:
+            async with self.lock:
+                self.tasks.discard(task)
+
+        asyncio.get_event_loop().create_task(remove_task())
+
+        if task.cancelled():
+            logger.warning("Send task was cancelled.")
+        elif task.exception() is not None:
+            logger.exception(
+                "Send task raised an exception:", exc_info=task.exception()
+            )
+        else:
+            logger.warning("Send task somehow completed successfully.")
+
+        if not self.shutdown_event.is_set():
+            logger.warning(
+                "Send task completed, but shutdown event is not set. This is unexpected."
+            )
+            # Add delay before retrying to avoid excessive CPU usage
+            asyncio.get_event_loop().create_task(self._retry_send_consumer_with_delay())
+
+    async def _retry_broadcast_consumer_with_delay(self) -> None:
+        """Retry setting up broadcast consumer after a delay to avoid excessive CPU usage."""
+        logger.warning(
+            "Waiting %s seconds before retrying broadcast consumer...", self.retry_delay
+        )
+        await asyncio.sleep(self.retry_delay)
 
-                    task.add_done_callback(self.tasks.discard)
+        if not self.shutdown_event.is_set():
+            logger.warning("Retrying broadcast consumer setup...")
+            self.setup_broadcast_consumer()
 
-    async def consume_send(self, send: SendFunc, shutdown_event: asyncio.Event) -> None:
-
-        async with self.redis.pubsub() as pubsub:
-            await pubsub.subscribe(self.send_pubsub_channel)
+    async def _retry_send_consumer_with_delay(self) -> None:
+        """Retry setting up send consumer after a delay to avoid excessive CPU usage."""
+        logger.warning(
+            "Waiting %s seconds before retrying send consumer...", self.retry_delay
+        )
+        await asyncio.sleep(self.retry_delay)
 
-            while not shutdown_event.is_set():
+        if not self.shutdown_event.is_set():
+            logger.warning("Retrying send consumer setup...")
+            self.setup_send_consumer()
 
-                message: dict[str, Any] | None = await pubsub.get_message(
-                    ignore_subscribe_messages=True, timeout=self.consume_send_timeout
+    async def consume_broadcast(
+        self, broadcast: BroadcastFunc, shutdown_event: asyncio.Event
+    ) -> None:
+        logger.debug("Starting broadcast consumer...")
+        try:
+            # Validate Redis connection before starting
+            try:
+                await self.redis.ping()
+                logger.debug("Redis connection validated for broadcast consumer")
+            except Exception as e:
+                logger.error("Redis connection validation failed: %s", e, exc_info=True)
+                raise
+
+            async with self.redis.pubsub() as pubsub:
+                await pubsub.subscribe(self.broadcast_pubsub_channel)
+                logger.debug(
+                    "Subscribed to broadcast channel: %s", self.broadcast_pubsub_channel
                 )
 
-                if message is None:
-                    continue
-
-                send_message = SendToRoomsMessage.decode(message["data"])
+                while not shutdown_event.is_set():
+                    message: dict[str, Any] | None = await pubsub.get_message(
+                        ignore_subscribe_messages=True,
+                        timeout=self.consume_broadcast_timeout,
+                    )
 
-                async with self.lock:
+                    if message is None:
+                        continue
+
+                    broadcast_message = BroadcastMessage.decode(message["data"])
+
+                    # Use semaphore for backpressure control
+                    acquired = False
+                    try:
+                        await self.task_semaphore.acquire()
+                        acquired = True
+
+                        async def broadcast_with_cleanup(msg: bytes) -> None:
+                            try:
+                                await broadcast(message=msg)
+                            finally:
+                                self.task_semaphore.release()
+
+                        async with self.lock:
+                            task = asyncio.get_event_loop().create_task(
+                                broadcast_with_cleanup(broadcast_message.message)
+                            )
+
+                            self.tasks.add(task)
+
+                            task.add_done_callback(self.tasks.discard)
+                    except Exception as e:
+                        # Release semaphore if we acquired it but failed to create task
+                        if acquired:
+                            self.task_semaphore.release()
+                        logger.error(
+                            "Error processing broadcast message: %s", e, exc_info=True
+                        )
+                        # Continue processing other messages
+                        continue
+        except Exception as e:
+            logger.error(
+                "Fatal error in broadcast consumer, will retry: %s", e, exc_info=True
+            )
+            raise
 
-                    task = asyncio.get_event_loop().create_task(
-                        send(send_message.rooms, send_message.message)
+    async def consume_send(self, send: SendFunc, shutdown_event: asyncio.Event) -> None:
+        logger.debug("Starting send consumer...")
+        try:
+            # Validate Redis connection before starting
+            try:
+                await self.redis.ping()
+                logger.debug("Redis connection validated for send consumer")
+            except Exception as e:
+                logger.error("Redis connection validation failed: %s", e, exc_info=True)
+                raise
+
+            async with self.redis.pubsub() as pubsub:
+                await pubsub.subscribe(self.send_pubsub_channel)
+                logger.debug("Subscribed to send channel: %s", self.send_pubsub_channel)
+
+                while not shutdown_event.is_set():
+                    message: dict[str, Any] | None = await pubsub.get_message(
+                        ignore_subscribe_messages=True,
+                        timeout=self.consume_send_timeout,
                     )
 
-                    self.tasks.add(task)
-
-                    task.add_done_callback(self.tasks.discard)
+                    if message is None:
+                        continue
+
+                    send_message = SendToRoomsMessage.decode(message["data"])
+
+                    # Use semaphore for backpressure control
+                    acquired = False
+                    try:
+                        await self.task_semaphore.acquire()
+                        acquired = True
+
+                        async def send_with_cleanup(
+                            rooms: list[str], msg: bytes
+                        ) -> None:
+                            try:
+                                await send(rooms, msg)
+                            finally:
+                                self.task_semaphore.release()
+
+                        async with self.lock:
+
+                            task = asyncio.get_event_loop().create_task(
+                                send_with_cleanup(
+                                    send_message.rooms, send_message.message
+                                )
+                            )
+
+                            self.tasks.add(task)
+
+                            task.add_done_callback(self.tasks.discard)
+                    except Exception as e:
+                        # Release semaphore if we acquired it but failed to create task
+                        if acquired:
+                            self.task_semaphore.release()
+                        logger.error(
+                            "Error processing send message: %s", e, exc_info=True
+                        )
+                        # Continue processing other messages
+                        continue
+        except Exception as e:
+            logger.error(
+                "Fatal error in send consumer, will retry: %s", e, exc_info=True
+            )
+            raise
 
     async def shutdown(self) -> None:
         async with self.lock:

jararaca/presentation/websocket/types.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from jararaca.presentation.websocket.base_types import WebSocketMessageBase
 from jararaca.presentation.websocket.context import use_ws_message_sender
 

jararaca/presentation/websocket/websocket_interceptor.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import asyncio
 import inspect
 from contextlib import asynccontextmanager
@@ -85,13 +89,24 @@ class WebSocketConnectionManagerImpl(WebSocketConnectionManager):
         await self.backend.broadcast(message)
 
     async def _broadcast_from_backend(self, message: bytes) -> None:
-        for websocket in self.all_websockets:
+        # Create a copy of the websockets set to avoid modification during iteration
+        async with self.lock:
+            websockets_to_send = list(self.all_websockets)
+
+        disconnected_websockets: list[WebSocket] = []
+
+        for websocket in websockets_to_send:
             try:
                 if websocket.client_state == WebSocketState.CONNECTED:
                     await websocket.send_bytes(message)
             except WebSocketDisconnect:
-                async with self.lock:  # TODO: check if this can cause concurrency slowdown issues
-                    self.all_websockets.remove(websocket)
+                disconnected_websockets.append(websocket)
+
+        # Clean up disconnected websockets in a single lock acquisition
+        if disconnected_websockets:
+            async with self.lock:
+                for websocket in disconnected_websockets:
+                    self.all_websockets.discard(websocket)
 
     async def send(self, rooms: list[str], message: WebSocketMessageBase) -> None:
 
@@ -103,16 +118,28 @@ class WebSocketConnectionManagerImpl(WebSocketConnectionManager):
         )
 
     async def _send_from_backend(self, rooms: list[str], message: bytes) -> None:
+        # Create a copy of room memberships to avoid modification during iteration
         async with self.lock:
-            for room in rooms:
-                for websocket in self.rooms.get(room, set()):
-                    try:
-                        if websocket.client_state == WebSocketState.CONNECTED:
-                            await websocket.send_bytes(message)
-                    except WebSocketDisconnect:
-                        async with self.lock:
-                            if websocket in self.rooms[room]:
-                                self.rooms[room].remove(websocket)
+            room_websockets: dict[str, list[WebSocket]] = {
+                room: list(self.rooms.get(room, set())) for room in rooms
+            }
+
+        disconnected_by_room: dict[str, list[WebSocket]] = {room: [] for room in rooms}
+
+        for room, websockets in room_websockets.items():
+            for websocket in websockets:
+                try:
+                    if websocket.client_state == WebSocketState.CONNECTED:
+                        await websocket.send_bytes(message)
+                except WebSocketDisconnect:
+                    disconnected_by_room[room].append(websocket)
+
+        # Clean up disconnected websockets in a single lock acquisition
+        async with self.lock:
+            for room, disconnected_websockets in disconnected_by_room.items():
+                if room in self.rooms:
+                    for websocket in disconnected_websockets:
+                        self.rooms[room].discard(websocket)
 
     async def join(self, rooms: list[str], websocket: WebSocket) -> None:
         for room in rooms:
@@ -222,13 +249,15 @@ class WebSocketInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
 
         for controller_type in app.controllers:
 
-            rest_controller = RestController.get_controller(controller_type)
+            rest_controller = RestController.get_last(controller_type)
             controller: Any = container.get_by_type(controller_type)
 
-            members = inspect.getmembers(controller_type, predicate=inspect.isfunction)
+            members = inspect.getmembers_static(
+                controller_type, predicate=inspect.isfunction
+            )
 
             for name, member in members:
-                if (ws_endpoint := WebSocketEndpoint.get(member)) is not None:
+                if (ws_endpoint := WebSocketEndpoint.get_last(member)) is not None:
                     final_path = (
                         rest_controller.path + ws_endpoint.path
                         if rest_controller
@@ -236,7 +265,7 @@ class WebSocketInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
                     )
 
                     route_dependencies: list[Depends] = []
-                    for middlewares_by_hook in UseMiddleware.get_middlewares(
+                    for middlewares_by_hook in UseMiddleware.get(
                         getattr(controller_type, name)
                     ):
                         middleware_instance = container.get_by_type(
@@ -246,9 +275,7 @@ class WebSocketInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
                             Depends(middleware_instance.intercept)
                         )
 
-                    for dependency in UseDependency.get_dependencies(
-                        getattr(controller_type, name)
-                    ):
+                    for dependency in UseDependency.get(getattr(controller_type, name)):
                         route_dependencies.append(DependsF(dependency.dependency))
 
                     api_router.add_api_websocket_route(

jararaca/reflect/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later

jararaca/reflect/controller_inspect.py

@@ -1,24 +1,28 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import inspect
 from dataclasses import dataclass
 from typing import Any, Callable, Mapping, Tuple, Type
 
 from frozendict import frozendict
 
-from jararaca.reflect.metadata import ControllerInstanceMetadata, SetMetadata
+from jararaca.reflect.metadata import SetMetadata, TransactionMetadata
 
 
 @dataclass(frozen=True)
 class ControllerReflect:
 
     controller_class: Type[Any]
-    metadata: Mapping[str, ControllerInstanceMetadata]
+    metadata: Mapping[str, TransactionMetadata]
 
 
 @dataclass(frozen=True)
 class ControllerMemberReflect:
     controller_reflect: ControllerReflect
     member_function: Callable[..., Any]
-    metadata: Mapping[str, ControllerInstanceMetadata]
+    metadata: Mapping[str, TransactionMetadata]
 
 
 def inspect_controller(
@@ -37,8 +41,8 @@ def inspect_controller(
 
     controller_metadata_map = frozendict(
         {
-            metadata.key: ControllerInstanceMetadata(
-                value=metadata.value, inherited=False
+            metadata.key: TransactionMetadata(
+                value=metadata.value, inherited_from_controller=False
             )
             for metadata in controller_metadata_list
         }
@@ -55,21 +59,23 @@ def inspect_controller(
             metadata=frozendict(
                 {
                     **{
-                        key: ControllerInstanceMetadata(
-                            value=value.value, inherited=True
+                        key: TransactionMetadata(
+                            value=value.value, inherited_from_controller=True
                         )
                         for key, value in controller_metadata_map.items()
                     },
                     **{
-                        metadata.key: ControllerInstanceMetadata(
-                            value=metadata.value, inherited=False
+                        metadata.key: TransactionMetadata(
+                            value=metadata.value, inherited_from_controller=False
                         )
                         for metadata in SetMetadata.get(member)
                     },
                 }
             ),
         )
-        for name, member in inspect.getmembers(controller, predicate=inspect.isfunction)
+        for name, member in inspect.getmembers_static(
+            controller, predicate=inspect.isfunction
+        )
     }
 
     return controller_reflect, members