mrok 0.2.1__tar.gz → 0.2.3__tar.gz

{mrok-0.2.1 → mrok-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.2.1
+Version: 0.2.3
 Summary: MPT Extensions OpenZiti Orchestrator
 Author: SoftwareOne AG
 License:                                  Apache License

{mrok-0.2.1 → mrok-0.2.3}/mrok/controller/app.py

@@ -51,9 +51,15 @@ def setup_app():
 
     # TODO: Add healthcheck
     app.include_router(
-        extensions_router, prefix="/extensions", dependencies=[Depends(authenticate)]
+        extensions_router,
+        prefix="/extensions",
+        dependencies=[Depends(authenticate)],
+    )
+    app.include_router(
+        instances_router,
+        prefix="/instances",
+        dependencies=[Depends(authenticate)],
     )
-    app.include_router(instances_router, prefix="/instances", dependencies=[Depends(authenticate)])
 
     settings = get_settings()
 

{mrok-0.2.1 → mrok-0.2.3}/mrok/controller/routes/extensions.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Annotated
+from typing import Annotated, Literal
 
 from fastapi import APIRouter, Body, HTTPException, status
 
@@ -116,8 +116,26 @@ async def create_extension(
 async def get_extension_by_id_or_extension_id(
     mgmt_api: ZitiManagementAPI,
     id_or_extension_id: str,
+    with_instances: Literal["none", "online", "offline"] = "none",
 ):
-    return ExtensionRead(**(await fetch_extension_or_404(mgmt_api, id_or_extension_id)))
+    extension = await fetch_extension_or_404(mgmt_api, id_or_extension_id)
+
+    if with_instances == "none":
+        return ExtensionRead(**extension)
+
+    instances = list(
+        filter(
+            lambda ir: ir.status == with_instances,
+            [
+                InstanceRead(**identity)
+                async for identity in mgmt_api.identities(
+                    {"filter": f'tags.{MROK_SERVICE_TAG_NAME} = "{extension["name"]}"'}
+                )
+            ],
+        )
+    )
+
+    return ExtensionRead(**extension, instances=instances)
 
 
 @router.delete(
@@ -272,11 +290,7 @@ async def get_instance_by_id_or_instance_id(
     id_or_instance_id: str,
 ):
     identity = await fetch_instance_or_404(mgmt_api, id_or_extension_id, id_or_instance_id)
-    return InstanceRead(
-        id=identity["id"],
-        name=identity["name"],
-        tags=identity["tags"],
-    )
+    return InstanceRead(**identity)
 
 
 @router.delete(

{mrok-0.2.1 → mrok-0.2.3}/mrok/controller/routes/instances.py

@@ -6,6 +6,7 @@ from mrok.controller.dependencies import ZitiManagementAPI
 from mrok.controller.openapi import examples
 from mrok.controller.pagination import LimitOffsetPage, paginate
 from mrok.controller.schemas import InstanceRead
+from mrok.ziti.constants import MROK_IDENTITY_TYPE_TAG_NAME, MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE
 
 logger = logging.getLogger("mrok.controller")
 
@@ -68,4 +69,7 @@ async def get_instance_by_id_or_instance_id(
 async def get_instances(
     mgmt_api: ZitiManagementAPI,
 ):
-    return await paginate(mgmt_api, "/identities", InstanceRead)
+    params = {
+        "filter": f'tags.{MROK_IDENTITY_TYPE_TAG_NAME}="{MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE}"'
+    }
+    return await paginate(mgmt_api, "/identities", InstanceRead, extra_params=params)

{mrok-0.2.1 → mrok-0.2.3}/mrok/controller/schemas.py

@@ -1,4 +1,6 @@
-from typing import Annotated, Any
+from __future__ import annotations
+
+from typing import Annotated, Any, Literal
 
 from pydantic import (
     BaseModel,
@@ -34,6 +36,7 @@ class ExtensionBase(BaseSchema):
 
 class ExtensionRead(BaseSchema, IdSchema):
     name: str
+    instances: list[InstanceRead] | None = None
 
     @computed_field
     def extension(self) -> dict:
@@ -51,6 +54,11 @@ class InstanceBase(BaseSchema):
 class InstanceRead(BaseSchema, IdSchema):
     name: str
     identity: dict[str, Any] | None = None
+    has_edge_router_connection: bool | None = Field(
+        False,
+        alias="hasEdgeRouterConnection",
+        exclude=True,
+    )
 
     @computed_field
     def instance(self) -> dict:
@@ -62,6 +70,10 @@ class InstanceRead(BaseSchema, IdSchema):
         _, extension_id = self.name.split(".", 1)
         return {"id": extension_id.upper()}
 
+    @computed_field
+    def status(self) -> Literal["online", "offline"]:
+        return "online" if bool(self.has_edge_router_connection) else "offline"
+
 
 class InstanceCreate(InstanceBase):
     pass

mrok-0.2.3/mrok/http/master.py

@@ -0,0 +1,132 @@
+import logging
+import os
+import signal
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+from watchfiles import watch
+from watchfiles.filters import PythonFilter
+from watchfiles.run import CombinedProcess, start_process
+
+logger = logging.getLogger("mrok.agent")
+
+MONITOR_THREAD_JOIN_TIMEOUT = 5
+MONITOR_THREAD_CHECK_DELAY = 1
+MONITOR_THREAD_ERROR_DELAY = 3
+
+
+def print_path(path):
+    try:
+        return f'"{path.relative_to(Path.cwd())}"'
+    except ValueError:
+        return f'"{path}"'
+
+
+class Master:
+    def __init__(
+        self,
+        start_fn: Callable,
+        workers: int,
+        reload: bool,
+    ):
+        self.start_fn = start_fn
+        self.workers = workers
+        self.reload = reload
+        self.worker_processes: dict[int, CombinedProcess] = {}
+        self.stop_event = threading.Event()
+        self.watch_filter = PythonFilter(ignore_paths=None)
+        self.watcher = watch(
+            Path.cwd(),
+            watch_filter=self.watch_filter,
+            stop_event=self.stop_event,
+            yield_on_timeout=True,
+        )
+        self.setup_signals_handler()
+        self.monitor_thread = None
+
+    def setup_signals_handler(self):
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            signal.signal(sig, self.handle_signal)
+
+    def handle_signal(self, *args, **kwargs):
+        self.stop_event.set()
+
+    def start_worker(self, worker_id: int):
+        """Start a single worker process"""
+        p = start_process(
+            self.start_fn,
+            "function",
+            (),
+            None,
+        )
+        logger.info(f"Worker {worker_id} [{p.pid}] started")
+        return p
+
+    def start(self):
+        for i in range(self.workers):
+            p = self.start_worker(i)
+            self.worker_processes[i] = p
+
+    def stop(self):
+        for process in self.worker_processes.values():
+            process.stop(sigint_timeout=5, sigkill_timeout=1)
+        self.worker_processes.clear()
+
+    def restart(self):
+        self.stop()
+        self.start()
+
+    def monitor_workers(self):
+        while not self.stop_event.is_set():
+            try:
+                for worker_id, process in self.worker_processes.items():
+                    if not process.is_alive():
+                        logger.warning(f"Worker {worker_id} [{process.pid}] died unexpectedly")
+                        process.stop(sigint_timeout=1, sigkill_timeout=1)
+                        new_process = self.start_worker(worker_id)
+                        self.worker_processes[worker_id] = new_process
+                        logger.info(
+                            f"Restarted worker {worker_id} [{process.pid}] -> [{new_process.pid}]"
+                        )
+
+                time.sleep(MONITOR_THREAD_CHECK_DELAY)
+
+            except Exception as e:
+                logger.error(f"Error in worker monitoring: {e}")
+                time.sleep(MONITOR_THREAD_ERROR_DELAY)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        changes = next(self.watcher)
+        if changes:
+            return list({Path(change[1]) for change in changes})
+        return None
+
+    def run(self):
+        self.start()
+        logger.info(f"Master process started: {os.getpid()}")
+
+        # Start worker monitoring thread
+        self.monitor_thread = threading.Thread(target=self.monitor_workers, daemon=True)
+        self.monitor_thread.start()
+        logger.debug("Worker monitoring thread started")
+
+        try:
+            if self.reload:
+                for files_changed in self:
+                    if files_changed:
+                        logger.warning(
+                            f"{', '.join(map(print_path, files_changed))} changed, reloading...",
+                        )
+                        self.restart()
+            else:
+                self.stop_event.wait()
+        finally:
+            if self.monitor_thread and self.monitor_thread.is_alive():  # pragma: no cover
+                logger.debug("Wait for monitor worker to exit")
+                self.monitor_thread.join(timeout=MONITOR_THREAD_JOIN_TIMEOUT)
+            self.stop()

{mrok-0.2.1 → mrok-0.2.3}/mrok/ziti/api.py

@@ -397,7 +397,7 @@ class ZitiManagementAPI(BaseZitiAPI):
     async def search_config_type(self, id_or_name: str) -> dict[str, Any] | None:
         return await self.search_by_id_or_name("/config-types", id_or_name)
 
-    async def delete_config_type(self, config_type_id: str) -> dict[str, Any] | None:
+    async def delete_config_type(self, config_type_id: str) -> None:
         return await self.delete("/config-types", config_type_id)
 
     async def get_identity(self, identity_id: str) -> dict[str, Any]:

{mrok-0.2.1 → mrok-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mrok"
-version = "0.2.1"
+version = "0.2.3"
 description = "MPT Extensions OpenZiti Orchestrator"
 readme = { file = "README.md", content-type = "text/markdown" }
 authors = [

{mrok-0.2.1 → mrok-0.2.3}/tests/controller/test_extensions.py

@@ -305,6 +305,7 @@ async def test_register_instance(mocker: MockerFixture, api_client: AsyncClient)
         "extension": {"id": "EXT-1234-5678"},
         "instance": {"id": "INS-1234-5678-0001"},
         "name": "ins-1234-5678-0001.ext-1234-5678",
+        "status": "offline",
         "tags": {
             MROK_VERSION_TAG_NAME: "0.0.0.dev0",
             MROK_SERVICE_TAG_NAME: "ext-1234-5678",
@@ -321,11 +322,13 @@ async def test_register_instance(mocker: MockerFixture, api_client: AsyncClient)
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("status", ["online", "offline"])
 async def test_get_instance(
     mocker: MockerFixture,
     settings_factory: SettingsFactory,
     api_client: AsyncClient,
     httpx_mock: HTTPXMock,
+    status: str,
 ):
     mocker.patch(
         "mrok.controller.routes.extensions.fetch_extension_or_404",
@@ -349,6 +352,7 @@ async def test_get_instance(
                         MROK_VERSION_TAG_NAME: "0.0.0.dev0",
                         MROK_SERVICE_TAG_NAME: "ext-1234-5678",
                     },
+                    "hasEdgeRouterConnection": status == "online",
                 }
             ],
         },
@@ -361,6 +365,7 @@ async def test_get_instance(
         "extension": {"id": "EXT-1234-5678"},
         "instance": {"id": "INS-1234-5678-0001"},
         "name": "ins-1234-5678-0001.ext-1234-5678",
+        "status": status,
         "tags": {
             MROK_VERSION_TAG_NAME: "0.0.0.dev0",
             MROK_SERVICE_TAG_NAME: "ext-1234-5678",
@@ -369,11 +374,13 @@ async def test_get_instance(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("status", ["online", "offline"])
 async def test_get_instance_by_instance_id(
     mocker: MockerFixture,
     settings_factory: SettingsFactory,
     api_client: AsyncClient,
     httpx_mock: HTTPXMock,
+    status: str,
 ):
     mocker.patch(
         "mrok.controller.routes.extensions.fetch_extension_or_404",
@@ -390,6 +397,7 @@ async def test_get_instance_by_instance_id(
                 {
                     "id": "ins1",
                     "name": "ins-1234-5678-0001.ext-1234-5678",
+                    "hasEdgeRouterConnection": status == "online",
                     "tags": {
                         MROK_VERSION_TAG_NAME: "0.0.0.dev0",
                         MROK_SERVICE_TAG_NAME: "ext-1234-5678",
@@ -406,6 +414,7 @@ async def test_get_instance_by_instance_id(
         "extension": {"id": "EXT-1234-5678"},
         "instance": {"id": "INS-1234-5678-0001"},
         "name": "ins-1234-5678-0001.ext-1234-5678",
+        "status": status,
         "tags": {
             MROK_VERSION_TAG_NAME: "0.0.0.dev0",
             MROK_SERVICE_TAG_NAME: "ext-1234-5678",
@@ -487,3 +496,54 @@ async def test_delete_instance_extension_not_found(
 
     response = await api_client.delete("/extensions/EXT-1234-5678/instances/INS-1234-5678-0001")
     assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("status", "expected_instance"),
+    [("online", "ins1.svc"), ("offline", "ins2.svc")],
+)
+async def test_get_extension_with_instances(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+    status: str,
+    expected_instance: str,
+):
+    settings = settings_factory()
+    query = quote(
+        f'(id="EXT-1234-5678" or name="ext-1234-5678") and tags.{MROK_VERSION_TAG_NAME} != null'
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "svc1",
+                    "name": "ext-1234-5678",
+                    "tags": {MROK_VERSION_TAG_NAME: "0.0.0.dev0"},
+                }
+            ],
+        },
+    )
+
+    query = quote(f'tags.{MROK_SERVICE_TAG_NAME} = "ext-1234-5678"')
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}&limit=5&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 2, "limit": 5, "offset": 0}},
+            "data": [
+                {"id": "ins1", "name": "ins1.svc", "hasEdgeRouterConnection": True},
+                {"id": "ins2", "name": "ins2.svc", "hasEdgeRouterConnection": False},
+            ],
+        },
+    )
+
+    response = await api_client.get(f"/extensions/EXT-1234-5678?with_instances={status}")
+    assert response.status_code == 200
+    ext = response.json()
+    assert len(ext["instances"]) == 1
+    assert ext["instances"][0]["name"] == expected_instance

{mrok-0.2.1 → mrok-0.2.3}/tests/controller/test_instances.py

@@ -17,7 +17,7 @@ async def test_list_instances(
     settings = settings_factory()
     httpx_mock.add_response(
         method="GET",
-        url=f"{settings.ziti.api.management}/edge/management/v1/identities?&limit=10&offset=0",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter=tags.mrok-identity-type%3D%22instance%22&limit=10&offset=0",
         json={
             "meta": {"pagination": {"totalCount": 15, "limit": 10, "offset": 0}},
             "data": [{"id": f"ins{i}", "name": "ins.svc"} for i in range(10)],
@@ -25,7 +25,7 @@ async def test_list_instances(
     )
     httpx_mock.add_response(
         method="GET",
-        url=f"{settings.ziti.api.management}/edge/management/v1/identities?&limit=10&offset=10",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter=tags.mrok-identity-type%3D%22instance%22&limit=10&offset=10",
         json={
             "meta": {"pagination": {"totalCount": 15, "limit": 10, "offset": 10}},
             "data": [{"id": f"ins{i}", "name": "ins.svc"} for i in range(11, 16)],
@@ -49,10 +49,12 @@ async def test_list_instances(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("status", ["online", "offline"])
 async def test_get_instance(
     settings_factory: SettingsFactory,
     api_client: AsyncClient,
     httpx_mock: HTTPXMock,
+    status: str,
 ):
     settings = settings_factory()
     query = quote(
@@ -68,6 +70,7 @@ async def test_get_instance(
                 {
                     "id": "ins1",
                     "name": "ins-1234-1234-0001.ext-1234-1234",
+                    "hasEdgeRouterConnection": status == "online",
                     "tags": {
                         MROK_VERSION_TAG_NAME: "0.0.0.dev0",
                         MROK_SERVICE_TAG_NAME: "ext-1234-1234",
@@ -85,6 +88,7 @@ async def test_get_instance(
         "extension": {"id": "EXT-1234-1234"},
         "instance": {"id": "INS-1234-1234-0001"},
         "name": "ins-1234-1234-0001.ext-1234-1234",
+        "status": status,
         "tags": {
             MROK_VERSION_TAG_NAME: "0.0.0.dev0",
             MROK_SERVICE_TAG_NAME: "ext-1234-1234",
@@ -93,10 +97,12 @@ async def test_get_instance(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("status", ["online", "offline"])
 async def test_get_instance_by_instance_id(
     settings_factory: SettingsFactory,
     api_client: AsyncClient,
     httpx_mock: HTTPXMock,
+    status: str,
 ):
     settings = settings_factory()
     query = quote(f'(id="ins1" or name="ins1") and tags.{MROK_VERSION_TAG_NAME} != null')
@@ -109,6 +115,7 @@ async def test_get_instance_by_instance_id(
                 {
                     "id": "ins1",
                     "name": "ins-1234-1234-0001.ext-1234-1234",
+                    "hasEdgeRouterConnection": status == "online",
                     "tags": {
                         MROK_VERSION_TAG_NAME: "0.0.0.dev0",
                         MROK_SERVICE_TAG_NAME: "ext-1234-1234",
@@ -125,6 +132,7 @@ async def test_get_instance_by_instance_id(
         "extension": {"id": "EXT-1234-1234"},
         "instance": {"id": "INS-1234-1234-0001"},
         "name": "ins-1234-1234-0001.ext-1234-1234",
+        "status": status,
         "tags": {
             MROK_VERSION_TAG_NAME: "0.0.0.dev0",
             MROK_SERVICE_TAG_NAME: "ext-1234-1234",

{mrok-0.2.1 → mrok-0.2.3}/tests/http/test_master.py

@@ -1,4 +1,6 @@
 import signal
+import threading
+import time
 from collections.abc import Generator
 from pathlib import Path
 
@@ -42,7 +44,7 @@ def test_start(mocker: MockerFixture):
     start_fn = mocker.MagicMock()
     master = Master(start_fn, 3, False)
     master.start()
-    assert master.worker_processes == processes
+    assert master.worker_processes == {0: processes[0], 1: processes[1], 2: processes[2]}
     for i in range(3):
         assert mocked_start_process.mock_calls[i].args == (start_fn, "function", (), None)
 
@@ -51,7 +53,7 @@ def test_stop(mocker: MockerFixture):
     master = Master(mocker.MagicMock(), 3, False)
     p1 = mocker.MagicMock()
     p2 = mocker.MagicMock()
-    master.worker_processes = [p1, p2]
+    master.worker_processes = {0: p1, 2: p2}
     master.stop()
     p1.stop.assert_called_once_with(sigint_timeout=5, sigkill_timeout=1)
     p2.stop.assert_called_once_with(sigint_timeout=5, sigkill_timeout=1)
@@ -84,17 +86,20 @@ def test_next(mocker: MockerFixture):
 
 def test_run(mocker: MockerFixture):
     mocked_start = mocker.patch.object(Master, "start")
+    mocked_monitor_fn = mocker.patch.object(Master, "monitor_workers")
     master = Master(mocker.MagicMock(), 3, False)
     mocked_stop_event = mocker.MagicMock()
     master.stop_event = mocked_stop_event
     master.run()
     mocked_start.assert_called_once()
     mocked_stop_event.wait.assert_called_once()
+    mocked_monitor_fn.assert_called_once()
 
 
 def test_run_with_reload(mocker: MockerFixture):
     mocker.patch.object(Master, "start")
     mocked_restart = mocker.patch.object(Master, "restart")
+    mocked_monitor_fn = mocker.patch.object(Master, "monitor_workers")
 
     def watcher() -> Generator:
         yield {(Change.modified, "/file1.py")}
@@ -105,3 +110,57 @@ def test_run_with_reload(mocker: MockerFixture):
     master.run()
 
     mocked_restart.assert_called_once()
+    mocked_monitor_fn.assert_called_once()
+
+
+def test_monitor_workers_restarts_dead_process(mocker: MockerFixture):
+    mocker.patch("mrok.http.master.MONITOR_THREAD_CHECK_DELAY", 0.1)
+
+    mock_start_process = mocker.patch("mrok.http.master.start_process")
+    master = Master(mocker.MagicMock(), 3, False)
+
+    dead_process = mocker.Mock()
+    dead_process.is_alive.return_value = False
+    dead_process.pid = 12345
+
+    alive_process = mocker.Mock()
+    alive_process.is_alive.return_value = True
+    alive_process.pid = 12346
+
+    new_process = mocker.Mock()
+    new_process.pid = 12347
+
+    master.worker_processes = {0: dead_process, 1: alive_process}
+
+    mock_start_process.return_value = new_process
+
+    monitor_thread = threading.Thread(target=master.monitor_workers)
+    monitor_thread.start()
+    time.sleep(0.1)
+    master.stop_event.set()
+    monitor_thread.join()
+
+    dead_process.stop.assert_called_once_with(sigint_timeout=1, sigkill_timeout=1)
+    mock_start_process.assert_called_once_with(master.start_fn, "function", (), None)
+    assert master.worker_processes[0] == new_process
+    assert master.worker_processes[1] == alive_process
+
+
+def test_monitor_workers_handles_is_alive_exception(mocker: MockerFixture):
+    mocker.patch("mrok.http.master.MONITOR_THREAD_ERROR_DELAY", 0.1)
+    mock_logger = mocker.patch("mrok.http.master.logger.error")
+    master = Master(mocker.MagicMock(), 3, False)
+
+    problematic_process = mocker.Mock()
+    problematic_process.is_alive.side_effect = Exception("Test exception")
+
+    master.worker_processes = {0: problematic_process}
+
+    monitor_thread = threading.Thread(target=master.monitor_workers)
+    monitor_thread.start()
+
+    time.sleep(0.1)
+    master.stop_event.set()
+    monitor_thread.join()
+
+    assert mock_logger.mock_calls[0].args[0] == "Error in worker monitoring: Test exception"

mrok-0.2.1/mrok/http/master.py

@@ -1,90 +0,0 @@
-import logging
-import os
-import signal
-import threading
-from collections.abc import Callable
-from pathlib import Path
-
-from watchfiles import watch
-from watchfiles.filters import PythonFilter
-from watchfiles.run import CombinedProcess, start_process
-
-logger = logging.getLogger("mrok.agent")
-
-
-def print_path(path):
-    try:
-        return f'"{path.relative_to(Path.cwd())}"'
-    except ValueError:
-        return f'"{path}"'
-
-
-class Master:
-    def __init__(
-        self,
-        start_fn: Callable,
-        workers: int,
-        reload: bool,
-    ):
-        self.start_fn = start_fn
-        self.workers = workers
-        self.reload = reload
-        self.worker_processes: list[CombinedProcess] = []
-        self.stop_event = threading.Event()
-        self.watch_filter = PythonFilter(ignore_paths=None)
-        self.watcher = watch(
-            Path.cwd(),
-            watch_filter=self.watch_filter,
-            stop_event=self.stop_event,
-            yield_on_timeout=True,
-        )
-        self.setup_signals_handler()
-
-    def setup_signals_handler(self):
-        for sig in (signal.SIGINT, signal.SIGTERM):
-            signal.signal(sig, self.handle_signal)
-
-    def handle_signal(self, *args, **kwargs):
-        self.stop_event.set()
-
-    def start(self):
-        for _ in range(self.workers):
-            p = start_process(
-                self.start_fn,
-                "function",
-                (),
-                None,
-            )
-            logger.info(f"Worker [{p.pid}] started")
-            self.worker_processes.append(p)
-
-    def stop(self):
-        for process in self.worker_processes:
-            process.stop(sigint_timeout=5, sigkill_timeout=1)
-        self.worker_processes = []
-
-    def restart(self):
-        self.stop()
-        self.start()
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        changes = next(self.watcher)
-        if changes:
-            return list({Path(change[1]) for change in changes})
-        return None
-
-    def run(self):
-        self.start()
-        logger.info(f"Master process started: {os.getpid()}")
-        if self.reload:
-            for files_changed in self:
-                if files_changed:
-                    logger.warning(
-                        f"{', '.join(map(print_path, files_changed))} changed, reloading...",
-                    )
-                    self.restart()
-        else:
-            self.stop_event.wait()