Просмотр исходного кода

feat(flutter): Push state and schedule data to client

huangrunheng 3 лет назад
Родитель
Сommit
7cf4ad416d
4 измененных файлов с 135 добавлено и 57 удалено
  1. 26 14
      module/server/main_manager.py
  2. 102 41
      module/server/script_process.py
  3. 6 1
      module/server/script_router.py
  4. 1 1
      tasks/Component/config_base.py

+ 26 - 14
module/server/main_manager.py

@@ -2,28 +2,30 @@
 # @author runhey
 # @author runhey
 # 主进程的管理
 # 主进程的管理
 # github https://github.com/runhey
 # github https://github.com/runhey
+import asyncio
+from asyncio.tasks import Task
 from multiprocessing import Queue, Pipe
 from multiprocessing import Queue, Pipe
 from threading import Thread
 from threading import Thread
 
 
 from module.logger import logger
 from module.logger import logger
 from module.config.config import Config
 from module.config.config import Config
-from module.server.script_process import ScriptProcess
+from module.server.script_process import ScriptProcess, ScriptState
 from module.server.config_manager import ConfigManager
 from module.server.config_manager import ConfigManager
 
 
+
 class MainManager(ConfigManager):
 class MainManager(ConfigManager):
-    config_cache :Config = None  # 缓存当前切换的配置
-    script_process :dict[str: ScriptProcess] = None  # 脚本进程
+    config_cache: Config = None  # 缓存当前切换的配置
+    script_process: dict[str: ScriptProcess] = None  # 脚本进程
     push_data_thread: Thread = None  # 数据推送线程
     push_data_thread: Thread = None  # 数据推送线程
 
 
     def __init__(self) -> None:
     def __init__(self) -> None:
         super().__init__()
         super().__init__()
+        self.script_process: dict[str: ScriptProcess] = {}  # 脚本进程
         self._all_script_files = self.all_script_files()
         self._all_script_files = self.all_script_files()
         for script_name in self._all_script_files:
         for script_name in self._all_script_files:
             self.script_process[script_name] = ScriptProcess(script_name)
             self.script_process[script_name] = ScriptProcess(script_name)
-        self.push_data_thread = Thread(target=self.push_data)
-
-
-
+        self.push_data_thread = Thread(target=lambda : asyncio.run(self.push_data_handle()), daemon=True)
+        self.push_data_thread.start()
 
 
     def ensure_config_cache(self, config_name):
     def ensure_config_cache(self, config_name):
         if self.config_cache is None:
         if self.config_cache is None:
@@ -43,11 +45,21 @@ class MainManager(ConfigManager):
         self._all_script_files = self.all_script_files()
         self._all_script_files = self.all_script_files()
         self.script_process[file_name] = ScriptProcess(file_name)
         self.script_process[file_name] = ScriptProcess(file_name)
 
 
-
-    def push_data_handle(self):
-
-        pass
-
-
-
+    async def push_data_handle(self):
+        tasks : dict[str, Task] = {}
+        from asyncio import sleep
+        while 1:
+            await sleep(5)
+            # logger.info(asyncio.all_tasks())
+            for name, script_p in self.script_process.items():
+                # 遍历所有的
+                # 如果 这个进程未激活 跳过
+                # 如果 已经存在了 对应的协程 跳过
+                # 如果这个进程异常/运行中 那这个协程也应该存在
+                # logger.info(f'检测脚本的process: {name}')
+                if script_p.state == ScriptState.INACTIVE:
+                    continue
+                coroutine_state_name = f'coroutine_state_{name}'
+                if coroutine_state_name not in tasks:
+                    tasks[coroutine_state_name] = asyncio.create_task(script_p.coroutine_broadcast_state(), name=coroutine_state_name)
 
 

+ 102 - 41
module/server/script_process.py

@@ -3,7 +3,7 @@
 # 脚本进程
 # 脚本进程
 # github https://github.com/runhey
 # github https://github.com/runhey
 import multiprocessing
 import multiprocessing
-# from multiprocessing import Process, Queue
+from asyncio import QueueEmpty, CancelledError, sleep
 from enum import Enum
 from enum import Enum
 
 
 from module.logger import logger
 from module.logger import logger
@@ -11,10 +11,10 @@ from module.logger import logger
 from module.server.script_websocket import ScriptWSManager
 from module.server.script_websocket import ScriptWSManager
 
 
 class ScriptState(int, Enum):
 class ScriptState(int, Enum):
-    INACTIVE = 1
-    RUNNING = 2
-    WARNING = 3
-    UPDATING = 4
+    INACTIVE = 0
+    RUNNING = 1
+    WARNING = 2
+    UPDATING = 3
 
 
 class ScriptProcess(ScriptWSManager):
 class ScriptProcess(ScriptWSManager):
 
 
@@ -24,8 +24,9 @@ class ScriptProcess(ScriptWSManager):
         self.log_pipe_out, self.log_pipe_in = multiprocessing.Pipe(False)
         self.log_pipe_out, self.log_pipe_in = multiprocessing.Pipe(False)
         self.state_queue = multiprocessing.Queue()
         self.state_queue = multiprocessing.Queue()
         self.state: ScriptState = ScriptState.INACTIVE
         self.state: ScriptState = ScriptState.INACTIVE
-        self._process = multiprocessing.Process(target=self.func,
-                                                args=(self.state_queue, self.log_pipe_in,),
+        self._process = None
+        self._process = multiprocessing.Process(target=func,
+                                                args=(config_name, self.state_queue, self.log_pipe_in,),
                                                 name=self.config_name,
                                                 name=self.config_name,
                                                 daemon=True)
                                                 daemon=True)
 
 
@@ -41,6 +42,7 @@ class ScriptProcess(ScriptWSManager):
             self.stop()
             self.stop()
         self._process.start()
         self._process.start()
         self.state = ScriptState.RUNNING
         self.state = ScriptState.RUNNING
+        self.state_queue.put({"state": self.state})
 
 
     def stop(self):
     def stop(self):
         if self._process is None:
         if self._process is None:
@@ -51,52 +53,111 @@ class ScriptProcess(ScriptWSManager):
             return
             return
         self._process.terminate()
         self._process.terminate()
         self.state = ScriptState.INACTIVE
         self.state = ScriptState.INACTIVE
+        self.state_queue.put({"state": self.state})
+
+
+
+
+    # def func(self):
+    #     # self.start_log(log_pipe_in)
+    #     try:
+    #         from script import Script
+    #         # script = Script(config_name=self.config_name)
+    #         # script.state_queue = state_queue
+    #         # script.loop()
+    #         # 脚本启动
+    #         from time import sleep
+    #         logger.info(f'Script {self.config_name} start')
+    #         sleep(5)
+    #         logger.info(f'Script {self.config_name} end')
+    #         exit(0)
+    #         raise Exception('test')
+    #     except SystemExit as e:
+    #         logger.info(f'Script {self.config_name} exit')
+    #         self.state = ScriptState.WARNING
+    #         self.state_queue.put({"state": self.state})
+    #     except Exception as e:
+    #         logger.exception(f'Run script {self.config_name} error')
+    #         logger.error(f'Error: {e}')
+    #         raise
+
+    # def start_log(self, log_pipe_in) -> None:
+    #     try:
+    #         from module.logger import set_file_logger, set_func_logger
+    #         set_file_logger(name=self.config_name)
+    #         set_func_logger(log_pipe_in.send)
+    #     except Exception as e:
+    #         logger.exception(f'Start log error')
+    #         logger.error(f'Error: {e}')
+    #         raise
 
 
 
 
-
-
-    def func(self, state_queue, log_pipe_in):
-        self.start_log(log_pipe_in)
+    async def broadcast_state_log(self):
         try:
         try:
-            from script import Script
-            script = Script(config_name=self.config_name)
-            script.state_queue = state_queue
-            # script.loop()
-            # 脚本启动
-            from time import sleep
-            logger.info(f'Script {self.config_name} start')
-            sleep(5)
-            logger.info(f'Script {self.config_name} end')
-            exit(0)
-            raise Exception('test')
-        except SystemExit as e:
-            logger.info(f'Script {self.config_name} exit')
-            self.state = ScriptState.WARNING
+            data = self.state_queue.get_nowait()
+            if not data:
+                pass
+            if self.state == ScriptState.INACTIVE:
+                pass
+            await self.broadcast_state(data)
+        except QueueEmpty as e:
+            pass
         except Exception as e:
         except Exception as e:
-            logger.exception(f'Run script {self.config_name} error')
-            logger.error(f'Error: {e}')
-            raise
+            raise e
+
+    async def coroutine_broadcast_state(self):
+        try:
+            while 1:
+                await sleep(0.1)
+                try:
+                    data = self.state_queue.get_nowait()
+                    if not data:
+                        await sleep(0.5)
+                        continue
+                    if self.state == ScriptState.INACTIVE:
+                        logger.warning()
+                        continue
+                    await self.broadcast_state(data)
+                except QueueEmpty as e:
+                    await sleep(0.5)
+                    continue
+                except Exception as e:
+                    raise e
+        except CancelledError as e:
+            logger.warning(f'{self.config_name} state coroutine is cancelled')
+            return
+
 
 
-    def start_log(self, log_pipe_in) -> None:
+def func(config: str, state_queue: multiprocessing.Queue, log_pipe_in) -> None:
+    def start_log() -> None:
         try:
         try:
             from module.logger import set_file_logger, set_func_logger
             from module.logger import set_file_logger, set_func_logger
-            set_file_logger(name=self.config_name)
+            set_file_logger(name=config)
             set_func_logger(log_pipe_in.send)
             set_func_logger(log_pipe_in.send)
         except Exception as e:
         except Exception as e:
             logger.exception(f'Start log error')
             logger.exception(f'Start log error')
             logger.error(f'Error: {e}')
             logger.error(f'Error: {e}')
             raise
             raise
-
-
-    async def broadcast_state_log(self):
-        try:
-            state = self.state_queue.get_nowait()
-            if not state:
-                pass
-            await self.broadcast_state(state)
-        except Exception as e:
-            pass
-
+    start_log()
+    try:
+        from script import Script
+        script = Script(config_name=config)
+        script.state_queue = state_queue
+        script.loop()
+        # 脚本启动
+        # from time import sleep
+        # logger.info(f'Script {self.config_name} start')
+        # sleep(5)
+        # logger.info(f'Script {self.config_name} end')
+        # exit(0)
+        # raise Exception('test')
+    except SystemExit as e:
+        logger.info(f'Script {config} exit')
+        state_queue.put({"state": ScriptState.WARNING})
+    except Exception as e:
+        logger.exception(f'Run script {config} error')
+        logger.error(f'Error: {e}')
+        raise
 
 
 
 
 if __name__ == '__main__':
 if __name__ == '__main__':

+ 6 - 1
module/server/script_router.py

@@ -138,16 +138,19 @@ async def websocket_endpoint(websocket: WebSocket, script_name: str):
     script_process = mm.script_process[script_name]
     script_process = mm.script_process[script_name]
     await script_process.connect(websocket)
     await script_process.connect(websocket)
     await script_process.broadcast_state({"state": script_process.state})
     await script_process.broadcast_state({"state": script_process.state})
+    mm.ensure_config_cache(script_name)
+    mm.config_cache.update_scheduler()
     await script_process.broadcast_state({"schedule": mm.config_cache.get_schedule_data()})
     await script_process.broadcast_state({"schedule": mm.config_cache.get_schedule_data()})
 
 
     try:
     try:
         while True:
         while True:
             # 初次进入,广播state schedule
             # 初次进入,广播state schedule
             data = await websocket.receive_text()
             data = await websocket.receive_text()
-            if data == 'get_sate':
+            if data == 'get_state':
                 await script_process.broadcast_state({"state":script_process.state})
                 await script_process.broadcast_state({"state":script_process.state})
             elif data == 'get_schedule':
             elif data == 'get_schedule':
                 mm.ensure_config_cache(script_name)
                 mm.ensure_config_cache(script_name)
+                mm.config_cache.update_scheduler()
                 await script_process.broadcast_state({"schedule":mm.config_cache.get_schedule_data()})
                 await script_process.broadcast_state({"schedule":mm.config_cache.get_schedule_data()})
             elif data == 'start':
             elif data == 'start':
                 script_process.start()
                 script_process.start()
@@ -155,6 +158,7 @@ async def websocket_endpoint(websocket: WebSocket, script_name: str):
                 script_process.stop()
                 script_process.stop()
 
 
     except WebSocketDisconnect:
     except WebSocketDisconnect:
+        logger.warning(f'[{script_name}] websocket disconnect')
         script_process.disconnect(websocket)
         script_process.disconnect(websocket)
 
 
 
 
@@ -162,3 +166,4 @@ async def websocket_endpoint(websocket: WebSocket, script_name: str):
 
 
 
 
 
 
+

+ 1 - 1
tasks/Component/config_base.py

@@ -66,7 +66,7 @@ class Time(time):
 
 
     @classmethod
     @classmethod
     def validate(cls, value):
     def validate(cls, value):
-        print(f' Time validate: {value} type: {type(value)}')
+        # print(f' Time validate: {value} type: {type(value)}')
         if isinstance(value, str):
         if isinstance(value, str):
             hour, minute, second = map(int, value.split(":"))
             hour, minute, second = map(int, value.split(":"))
             return cls(hour, minute, second)
             return cls(hour, minute, second)