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

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

huangrunheng 3 лет назад
Родитель
Сommit
7cf4ad416d

+ 26 - 14
module/server/main_manager.py

@@ -2,28 +2,30 @@
 # @author runhey
 # 主进程的管理
 # github https://github.com/runhey
+import asyncio
+from asyncio.tasks import Task
 from multiprocessing import Queue, Pipe
 from threading import Thread
 
 from module.logger import logger
 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
 
+
 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  # 数据推送线程
 
     def __init__(self) -> None:
         super().__init__()
+        self.script_process: dict[str: ScriptProcess] = {}  # 脚本进程
         self._all_script_files = self.all_script_files()
         for script_name in self._all_script_files:
             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):
         if self.config_cache is None:
@@ -43,11 +45,21 @@ class MainManager(ConfigManager):
         self._all_script_files = self.all_script_files()
         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
 import multiprocessing
-# from multiprocessing import Process, Queue
+from asyncio import QueueEmpty, CancelledError, sleep
 from enum import Enum
 
 from module.logger import logger
@@ -11,10 +11,10 @@ from module.logger import logger
 from module.server.script_websocket import ScriptWSManager
 
 class ScriptState(int, Enum):
-    INACTIVE = 1
-    RUNNING = 2
-    WARNING = 3
-    UPDATING = 4
+    INACTIVE = 0
+    RUNNING = 1
+    WARNING = 2
+    UPDATING = 3
 
 class ScriptProcess(ScriptWSManager):
 
@@ -24,8 +24,9 @@ class ScriptProcess(ScriptWSManager):
         self.log_pipe_out, self.log_pipe_in = multiprocessing.Pipe(False)
         self.state_queue = multiprocessing.Queue()
         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,
                                                 daemon=True)
 
@@ -41,6 +42,7 @@ class ScriptProcess(ScriptWSManager):
             self.stop()
         self._process.start()
         self.state = ScriptState.RUNNING
+        self.state_queue.put({"state": self.state})
 
     def stop(self):
         if self._process is None:
@@ -51,52 +53,111 @@ class ScriptProcess(ScriptWSManager):
             return
         self._process.terminate()
         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:
-            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:
-            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:
             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)
         except Exception as e:
             logger.exception(f'Start log error')
             logger.error(f'Error: {e}')
             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__':

+ 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]
     await script_process.connect(websocket)
     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()})
 
     try:
         while True:
             # 初次进入,广播state schedule
             data = await websocket.receive_text()
-            if data == 'get_sate':
+            if data == 'get_state':
                 await script_process.broadcast_state({"state":script_process.state})
             elif data == 'get_schedule':
                 mm.ensure_config_cache(script_name)
+                mm.config_cache.update_scheduler()
                 await script_process.broadcast_state({"schedule":mm.config_cache.get_schedule_data()})
             elif data == 'start':
                 script_process.start()
@@ -155,6 +158,7 @@ async def websocket_endpoint(websocket: WebSocket, script_name: str):
                 script_process.stop()
 
     except WebSocketDisconnect:
+        logger.warning(f'[{script_name}] websocket disconnect')
         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
     def validate(cls, value):
-        print(f' Time validate: {value} type: {type(value)}')
+        # print(f' Time validate: {value} type: {type(value)}')
         if isinstance(value, str):
             hour, minute, second = map(int, value.split(":"))
             return cls(hour, minute, second)