Send power distribution results from the component manager

Until now, the PowerDistributingActor has supported only distributing
power to batteries.  Batteries are (supposed to be) always available,
so the distribution takes place once when the power distributor
receives a request.

This changes when distributing power to EV chargers, because power
needs to be:

- distributed when an EV is connected
- redistributed to other EVs when an EV is disconnected
- redistributed to other EVs if an EV appears to be not charging, etc.

So a power distribution manager for EVs would be best implemented with
its own `select` loop, where distribution happens.

Because of this, a call to the `distribute_power` method on the EV
charger manager can't immediately return a single distribution result,
but that call is not the only thing that triggers the distribution,
but other events too.

So the manager needs to be what sends out the distribution results.

Signed-off-by: Sahas Subramanian <[email protected]>

Author: shsms

src/frequenz/sdk/actor/power_distributing/_component_managers/_battery_manager.py

@@ -127,8 +127,18 @@ class BatteryManager(ComponentManager):
     def __init__(
         self,
         component_pool_status_sender: Sender[ComponentPoolStatus],
+        results_sender: Sender[Result],
     ):
-        """Initialize the battery data manager."""
+        """Initialize the battery data manager.
+
+        Args:
+            component_pool_status_sender: Channel sender to send the status of the
+                battery pool to.  This status is used by the battery pool metric
+                streams, to dynamically adjust the values based on the health of the
+                individual batteries.
+            results_sender: Channel sender to send the power distribution results to.
+        """
+        self._results_sender = results_sender
         self._batteries = connection_manager.get().component_graph.components(
             component_categories={ComponentCategory.BATTERY}
         )
@@ -181,20 +191,18 @@ async def stop(self) -> None:
         await self._component_pool_status_tracker.stop()
 
     @override
-    async def distribute_power(self, request: Request) -> Result:
+    async def distribute_power(self, request: Request) -> None:
         """Distribute the requested power to the components.
 
         Args:
             request: Request to get the distribution for.
-
-        Returns:
-            Result of the distribution.
         """
         distribution_result = await self._get_distribution(request)
         if not isinstance(distribution_result, DistributionResult):
-            return distribution_result
-        result = await self._distribute_power(request, distribution_result)
-        return result
+            result = distribution_result
+        else:
+            result = await self._distribute_power(request, distribution_result)
+        await self._results_sender.send(result)
 
     async def _get_distribution(self, request: Request) -> DistributionResult | Result:
         """Get the distribution of the batteries.

src/frequenz/sdk/actor/power_distributing/_component_managers/_component_manager.py

@@ -20,12 +20,14 @@ class ComponentManager(abc.ABC):
     def __init__(
         self,
         component_pool_status_sender: Sender[ComponentPoolStatus],
+        results_sender: Sender[Result],
     ):
         """Initialize the component data manager.
 
         Args:
             component_pool_status_sender: Channel for sending information about which
                 components are expected to be working.
+            results_sender: Channel for sending the results of power distribution.
         """
 
     @abc.abstractmethod
@@ -37,7 +39,7 @@ async def start(self) -> None:
         """Start the component data manager."""
 
     @abc.abstractmethod
-    async def distribute_power(self, request: Request) -> Result:
+    async def distribute_power(self, request: Request) -> None:
         """Distribute the requested power to the components.
 
         Args:

src/frequenz/sdk/actor/power_distributing/power_distributing.py

@@ -86,7 +86,9 @@ def __init__(  # pylint: disable=too-many-arguments
 
         self._component_manager: ComponentManager
         if component_category == ComponentCategory.BATTERY:
-            self._component_manager = BatteryManager(component_pool_status_sender)
+            self._component_manager = BatteryManager(
+                component_pool_status_sender, results_sender
+            )
         else:
             raise ValueError(
                 f"PowerDistributor doesn't support controlling: {component_category}"
@@ -107,8 +109,7 @@ async def _run(self) -> None:  # pylint: disable=too-many-locals
         await asyncio.sleep(self._wait_for_data_sec)
 
         async for request in self._requests_receiver:
-            result = await self._component_manager.distribute_power(request)
-            await self._result_sender.send(result)
+            await self._component_manager.distribute_power(request)
 
     async def stop(self, msg: str | None = None) -> None:
         """Stop this actor.