reload config changes, partial fix for #3

Author: timkpaine

supervisor_pydantic/client/xmlrpc.py

@@ -130,24 +130,29 @@ def _build_rpcurl(self, username: Optional[str], password: Optional[str]) -> str
     def getAllProcessInfo(self) -> List[ProcessInfo]:
         return [ProcessInfo(**_) for _ in self._client.supervisor.getAllProcessInfo()]
 
-    def getState(self):
+    def getState(self) -> SupervisorState:
         return SupervisorState(self._client.supervisor.getState()["statecode"])
 
     # def readLog(self):
     #     return self._client.supervisor.readLog(0, 0)
 
-    def restart(self):
-        return self._client.supervisor.restart()
+    def restart(self) -> SupervisorState:
+        self._client.supervisor.restart()
+        return self.getState()
 
-    def shutdown(self):
-        return self._client.supervisor.shutdown()
+    def shutdown(self) -> SupervisorState:
+        self._client.supervisor.shutdown()
+        return self.getState()
 
     ###################
     # process methods #
     ###################
-    def getProcessInfo(self, name: str):
+    def getProcessInfo(self, name: str) -> ProcessInfo:
         if name not in self._cfg.program:
             raise RuntimeError(f"Unknown process: {name}")
+        return self._getProcessInfoInternal(name)
+
+    def _getProcessInfoInternal(self, name: str) -> ProcessInfo:
         return ProcessInfo(**self._client.supervisor.getProcessInfo(name))
 
     def readProcessLog(self, name: str):
@@ -191,17 +196,32 @@ def stopAllProcesses(self) -> Dict[str, ProcessInfo]:
     def stopProcess(self, name: str) -> ProcessInfo:
         if name not in self._cfg.program:
             raise RuntimeError(f"Unknown process: {name}")
+        return self._stopProcessInternal(name)
+
+    def _stopProcessInternal(self, name: str) -> ProcessInfo:
         try:
             if self._client.supervisor.stopProcess(name):
-                return self.getProcessInfo(name)
+                return self._getProcessInfoInternal(name)
         except Fault as f:
             if f.faultCode == SupervisorMethodResult.NOT_RUNNING.value:
-                return self.getProcessInfo(name)
+                return self._getProcessInfoInternal(name)
             raise f
-        return self.getProcessInfo(name)
-
-    # def reloadConfig(self):
-    #     return self._client.supervisor.reloadConfig()
+        return self._getProcessInfoInternal(name)
+
+    def reloadConfig(self, start_new: bool = False) -> SupervisorState:
+        added, changed, removed = self._client.supervisor.reloadConfig()[0]
+        proc_infos = []
+        for name in removed:
+            proc_infos.append(self._stopProcessInternal(name))
+        for name in changed:
+            self._stopProcessInternal(name)
+            proc_infos.append(self.startProcess(name))
+        # Don't need to start as we'll do this separately
+        for name in added:
+            self._client.supervisor.addProcessGroup(name)
+            if start_new:
+                proc_infos.append(self.startProcess(name))
+        return proc_infos
 
     # def signalAllProcesses(self, signal):
     #     return self._client.supervisor.signalAllProcesses()

supervisor_pydantic/config/convenience.py

@@ -77,6 +77,10 @@ class ConvenienceConfiguration(_BaseCfgModel):
         default="/RPC2",
         description="Path for supervisor XMLRPC HTTP API. Used by the XMLRPC client",
     )
+
+    #########
+    # Other #
+    #########
     command_timeout: int = Field(
         default=30,
         description="Timeout for convenience commands sent to the supervisor, in seconds",

supervisor_pydantic/convenience/commands.py

@@ -103,8 +103,18 @@ def start_supervisor(
     cfg_obj = _load_or_pass(cfg)
     if not _check_same(cfg_obj):
         log.critical("Configs don't match")
+
+        # TODO check if "critical" things are different and restart
+        # supervisor if necessary
+
+        # Otherwise just write and reload
+        cfg_obj._write_self()
+        client = SupervisorRemoteXMLRPCClient(cfg=cfg_obj)
+        client.reloadConfig()
+
     if _check_running(cfg_obj):
         return _raise_or_exit(True, _exit)
+
     cfg_obj.start(daemon=True)
     running = _wait_or_while(until=lambda: cfg_obj.running(), timeout=cfg_obj.convenience.command_timeout)
     if not running:

supervisor_pydantic/tests/client/test_client_e2e.py

@@ -7,23 +7,35 @@
 from supervisor_pydantic.client.xmlrpc import ProcessState
 
 
-def _assert_client_actions(client: SupervisorRemoteXMLRPCClient):
-    assert client.getProcessInfo("test").state == ProcessState.STOPPED
+def _assert_client_actions(client: SupervisorRemoteXMLRPCClient, name: str = "test"):
+    assert client.getProcessInfo(name).state == ProcessState.STOPPED
     sleep(1)
-    assert client.startAllProcesses()["test"].state == ProcessState.RUNNING
+    assert client.startAllProcesses()[name].state == ProcessState.RUNNING
     sleep(1)
-    assert client.getProcessInfo("test").state == ProcessState.EXITED
-    assert client.startProcess("test").state == ProcessState.RUNNING
-    assert client.stopProcess("test").state == ProcessState.STOPPED
-    assert client.startProcess("test").state == ProcessState.RUNNING
-    assert client.stopAllProcesses()["test"].state == ProcessState.STOPPED
+    assert client.getProcessInfo(name).state == ProcessState.EXITED
+    assert client.startProcess(name).state == ProcessState.RUNNING
+    assert client.stopProcess(name).state == ProcessState.STOPPED
+    assert client.startProcess(name).state == ProcessState.RUNNING
+    assert client.stopAllProcesses()[name].state == ProcessState.STOPPED
 
 
 def test_supervisor_client(supervisor_instance: SupervisorConvenienceConfiguration):
     client = SupervisorRemoteXMLRPCClient(supervisor_instance)
     _assert_client_actions(client=client)
 
 
+def test_supervisor_client_changes(supervisor_instance: SupervisorConvenienceConfiguration):
+    client = SupervisorRemoteXMLRPCClient(supervisor_instance)
+    _assert_client_actions(client=client)
+    test_program = supervisor_instance.program.pop("test")
+    supervisor_instance.program["test2"] = test_program
+    supervisor_instance._write_self()
+    client = SupervisorRemoteXMLRPCClient(supervisor_instance)
+    client.reloadConfig()
+    print(supervisor_instance)
+    _assert_client_actions(client=client, name="test2")
+
+
 def test_permissioned_supervisor_client_rejected(permissioned_supervisor_instance: SupervisorConvenienceConfiguration):
     permissioned_supervisor_instance.convenience.username = "bad-username"
     client = SupervisorRemoteXMLRPCClient(permissioned_supervisor_instance)