Change ConfigManagingActor: move creating FileWatcher to constructor

FileWatcher instance should be create in constructor instead
of in _run() method. Otherwise, if the actor restarts,
we will lost all events that happened while the actor was down.

Signed-off-by: Elzbieta Kotulska <[email protected]>

Author: ela-kotulska-frequenz

src/frequenz/sdk/config/_config_managing.py

@@ -106,9 +106,42 @@ def __init__(
             for config_path in config_paths
         ]
         self._output: Sender[abc.Mapping[str, Any]] = output
-        self._event_types: abc.Set[EventType] = event_types
-        self._force_polling: bool = force_polling
-        self._polling_interval: timedelta = polling_interval
+
+        # FileWatcher instance should be create here instead of in _run().
+        # Otherwise, if the actor restarts, we will lost all the events that happened
+        # while the actor was down.
+        self._file_watcher = self._create_file_watcher(
+            force_polling, polling_interval, event_types
+        )
+
+    def _create_file_watcher(
+        self,
+        force_polling: bool,
+        polling_interval: timedelta,
+        event_types: abc.Set[EventType],
+    ) -> FileWatcher:
+        """Create a FileWatcher instance to monitor the configuration files.
+
+        Args:
+            force_polling: Whether to force file polling to check for changes.
+            polling_interval: The interval to poll for changes. Only relevant if
+                polling is enabled.
+            event_types: The set of event types to monitor.
+
+        Returns:
+            A FileWatcher instance.
+        """
+        parent_paths = {p.parent for p in self._config_paths}
+
+        # FileWatcher can't watch for non-existing files, so we need to watch for the
+        # parent directories instead just in case a configuration file doesn't exist yet
+        # or it is deleted and recreated again.
+        return FileWatcher(
+            paths=list(parent_paths),
+            event_types=event_types,
+            force_polling=force_polling,
+            polling_interval=polling_interval,
+        )
 
     def _read_config(self) -> abc.Mapping[str, Any]:
         """Read the contents of the configuration file.
@@ -156,51 +189,36 @@ async def _run(self) -> None:
         """
         await self.send_config()
 
-        parent_paths = {p.parent for p in self._config_paths}
-
-        # FileWatcher can't watch for non-existing files, so we need to watch for the
-        # parent directories instead just in case a configuration file doesn't exist yet
-        # or it is deleted and recreated again.
-        file_watcher = FileWatcher(
-            paths=list(parent_paths),
-            event_types=self._event_types,
-            force_polling=self._force_polling,
-            polling_interval=self._polling_interval,
-        )
-
-        try:
-            async for event in file_watcher:
-                # Since we are watching the whole parent directories, we need to make
-                # sure we only react to events related to the configuration files we
-                # are interested in.
-                if not any(event.path.samefile(p) for p in self._config_paths):
-                    continue
-
-                match event.type:
-                    case EventType.CREATE:
-                        _logger.info(
-                            "%s: The configuration file %s was created, sending new config...",
-                            self,
-                            event.path,
-                        )
-                        await self.send_config()
-                    case EventType.MODIFY:
-                        _logger.info(
-                            "%s: The configuration file %s was modified, sending update...",
-                            self,
-                            event.path,
-                        )
-                        await self.send_config()
-                    case EventType.DELETE:
-                        _logger.info(
-                            "%s: The configuration file %s was deleted, ignoring...",
-                            self,
-                            event.path,
-                        )
-                    case _:
-                        assert_never(event.type)
-        finally:
-            del file_watcher
+        async for event in self._file_watcher:
+            # Since we are watching the whole parent directories, we need to make
+            # sure we only react to events related to the configuration files we
+            # are interested in.
+            if not any(event.path.samefile(p) for p in self._config_paths):
+                continue
+
+            match event.type:
+                case EventType.CREATE:
+                    _logger.info(
+                        "%s: The configuration file %s was created, sending new config...",
+                        self,
+                        event.path,
+                    )
+                    await self.send_config()
+                case EventType.MODIFY:
+                    _logger.info(
+                        "%s: The configuration file %s was modified, sending update...",
+                        self,
+                        event.path,
+                    )
+                    await self.send_config()
+                case EventType.DELETE:
+                    _logger.info(
+                        "%s: The configuration file %s was deleted, ignoring...",
+                        self,
+                        event.path,
+                    )
+                case _:
+                    assert_never(event.type)
 
 
 def _recursive_update(