Ⓜ️手动从旧梦 81a191f merge

liteyuki/core/__init__.py

@@ -1,3 +1,11 @@
+import multiprocessing
+
 from .spawn_process import *
+from .manager import *
 
+__all__ = [
+        "IS_MAIN_PROCESS"
+]
+
+IS_MAIN_PROCESS = multiprocessing.current_process().name == "MainProcess"
 

liteyuki/core/manager.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2020-2024 LiteyukiStudio. All Rights Reserved 
+
+@Time    : 2024/7/27 上午11:12
+@Author  : snowykami
+@Email   : snowykami@outlook.com
+@File    : manager.py
+@Software: PyCharm
+"""
+import asyncio
+import threading
+from multiprocessing import Process
+from typing import TYPE_CHECKING
+
+from liteyuki.comm import Channel, get_channel, set_channels
+from liteyuki.log import logger
+
+if TYPE_CHECKING:
+    from liteyuki.bot import LiteyukiBot
+
+TIMEOUT = 10
+
+__all__ = ["ProcessManager"]
+
+
+class ProcessManager:
+    """
+    在主进程中被调用
+    """
+
+    def __init__(self, bot: "LiteyukiBot"):
+        self.bot = bot
+        self.targets: dict[str, tuple[callable, tuple, dict]] = {}
+        self.processes: dict[str, Process] = {}
+
+        set_channels(
+            {
+                "nonebot-active": Channel(_id="nonebot-active"),
+                "melobot-active": Channel(_id="melobot-active"),
+                "nonebot-passive": Channel(_id="nonebot-passive"),
+                "melobot-passive": Channel(_id="melobot-passive"),
+            }
+        )
+
+    def start(self, name: str, delay: int = 0):
+        """
+        开启后自动监控进程，并添加到进程字典中
+        Args:
+            name:
+            delay:
+
+        Returns:
+
+        """
+        if name not in self.targets:
+            raise KeyError(f"未有 Process {name} 之存在")
+
+        def _start():
+            should_exit = False
+            while not should_exit:
+                chan_active = get_channel(f"{name}-active")
+                chan_passive = get_channel(f"{name}-passive")
+                process = Process(
+                    target=self.targets[name][0],
+                    args=(chan_active, chan_passive, *self.targets[name][1]),
+                    kwargs=self.targets[name][2],
+                )
+                self.processes[name] = process
+                process.start()
+                while not should_exit:
+                    # 0退出 1重启
+                    data = chan_active.receive()
+                    if data == 1:
+                        logger.info(f"重启 {name} 进程")
+                        asyncio.run(self.bot.lifespan.before_shutdown())
+                        asyncio.run(self.bot.lifespan.before_restart())
+                        self.terminate(name)
+                        break
+
+                    elif data == 0:
+                        logger.info(f"关停 {name} 进程")
+                        asyncio.run(self.bot.lifespan.before_shutdown())
+                        should_exit = True
+                        self.terminate(name)
+                    else:
+                        logger.warning("数据未知，省略：{}".format(data))
+
+        if delay:
+            threading.Timer(delay, _start).start()
+        else:
+            threading.Thread(target=_start).start()
+
+    def add_target(self, name: str, target, *args, **kwargs):
+        self.targets[name] = (target, args, kwargs)
+
+    def join(self):
+        for name, process in self.targets:
+            process.join()
+
+    def terminate(self, name: str):
+        """
+        终止进程并从进程字典中删除
+        Args:
+            name:
+
+        Returns:
+
+        """
+        if name not in self.targets:
+            raise logger.warning(f"未有 Process {name} 之存在")
+        process = self.processes[name]
+        process.terminate()
+        process.join(TIMEOUT)
+        if process.is_alive():
+            process.kill()
+
+    def terminate_all(self):
+        for name in self.targets:
+            self.terminate(name)

liteyuki/core/nb/adapter_manager/__init__.py

@@ -0,0 +1,14 @@
+from . import (
+    satori,
+    onebot
+)
+
+
+def init(config: dict):
+    onebot.init()
+    satori.init(config)
+
+
+def register():
+    onebot.register()
+    satori.register()

liteyuki/core/nb/adapter_manager/onebot.py

@@ -0,0 +1,12 @@
+import nonebot
+from nonebot.adapters.onebot import v11, v12
+
+
+def init():
+    pass
+
+
+def register():
+    driver = nonebot.get_driver()
+    driver.register_adapter(v11.Adapter)
+    driver.register_adapter(v12.Adapter)

liteyuki/core/nb/adapter_manager/satori.py

@@ -0,0 +1,26 @@
+import json
+import os
+
+import nonebot
+from nonebot.adapters import satori
+
+
+def init(config: dict):
+    if config.get("satori", None) is None:
+        nonebot.logger.info("未查见 Satori 的配置文档，将跳过 Satori 初始化")
+        return None
+    satori_config = config.get("satori")
+    if not satori_config.get("enable", False):
+        nonebot.logger.info("未启用 Satori ，将跳过 Satori 初始化")
+        return None
+    if os.getenv("SATORI_CLIENTS", None) is not None:
+        nonebot.logger.info("Satori 客户端已设入环境变量，跳过此步。")
+    os.environ["SATORI_CLIENTS"] = json.dumps(satori_config.get("hosts", []), ensure_ascii=False)
+    config['satori_clients'] = satori_config.get("hosts", [])
+    return
+
+
+def register():
+    if os.getenv("SATORI_CLIENTS", None) is not None:
+        driver = nonebot.get_driver()
+        driver.register_adapter(satori.Adapter)

liteyuki/core/nb/driver_manager/__init__.py

@@ -0,0 +1,6 @@
+from .auto_set_env import auto_set_env
+
+
+def init(config: dict):
+    auto_set_env(config)
+    return

liteyuki/core/nb/driver_manager/auto_set_env.py

@@ -0,0 +1,20 @@
+import os
+
+import dotenv
+import nonebot
+
+from .defines import *
+
+
+def auto_set_env(config: dict):
+    dotenv.load_dotenv(".env")
+    if os.getenv("DRIVER", None) is not None:
+        nonebot.logger.info("Driver 已设入环境变量中，将跳过自动配置环节。")
+        return
+    if config.get("satori", {'enable': False}).get("enable", False):
+        os.environ["DRIVER"] = get_driver_string(ASGI_DRIVER, HTTPX_DRIVER, WEBSOCKETS_DRIVER)
+        nonebot.logger.info("已启用 Satori，将 driver 设为 ASGI+HTTPX+WEBSOCKETS")
+    else:
+        os.environ["DRIVER"] = get_driver_string(ASGI_DRIVER)
+        nonebot.logger.info("已禁用 Satori，将 driver 设为 ASGI")
+    return

liteyuki/core/nb/driver_manager/defines.py

@@ -0,0 +1,17 @@
+ASGI_DRIVER = "~fastapi"
+HTTPX_DRIVER = "~httpx"
+WEBSOCKETS_DRIVER = "~websockets"
+
+
+def get_driver_string(*argv):
+    output_string = ""
+    if ASGI_DRIVER in argv:
+        output_string += ASGI_DRIVER
+    for arg in argv:
+        if arg != ASGI_DRIVER:
+            output_string = f"{output_string}+{arg}"
+    return output_string
+
+
+def get_driver_full_string(*argv):
+    return f"DRIVER={get_driver_string(argv)}"

liteyuki/core/spawn_process.py

@@ -1,37 +1,56 @@
-import threading
-from multiprocessing import get_context, Event
+from typing import Optional, TYPE_CHECKING
 
 import nonebot
-from nonebot import logger
 
-from liteyuki.plugin.load import load_plugins
+from liteyuki.core.nb import adapter_manager, driver_manager
+from liteyuki.comm.channel import set_channel
+
+if TYPE_CHECKING:
+    from liteyuki.comm.channel import Channel
 
 timeout_limit: int = 20
-__all__ = [
-        "ProcessingManager",
-        "nb_run",
-]
+
+"""导出对象，用于主进程与nonebot通信"""
+_channels = {}
 
 
-class ProcessingManager:
-    event: Event = None
+def nb_run(chan_active: "Channel", chan_passive: "Channel", *args, **kwargs):
+    """
+    初始化NoneBot并运行在子进程
+    Args:
 
-    @classmethod
-    def restart(cls, delay: int = 0):
-        """
-        发送终止信号
-        Args:
-            delay: 延迟时间，默认为0，单位秒
-        Returns:
-        """
-        if cls.event is None:
-            raise RuntimeError("ProcessingManager 未初始化。")
-        if delay > 0:
-            threading.Timer(delay, function=cls.event.set).start()
-            return
-        cls.event.set()
+        chan_active:
+        chan_passive:
+        **kwargs:
+
+    Returns:
+
+    """
+    set_channel("nonebot-active", chan_active)
+    set_channel("nonebot-passive", chan_passive)
+    nonebot.init(**kwargs)
+    driver_manager.init(config=kwargs)
+    adapter_manager.init(kwargs)
+    adapter_manager.register()
+    nonebot.load_plugin("src.liteyuki_main")
+    nonebot.run()
 
 
-def nb_run(event, *args, **kwargs):
-    ProcessingManager.event = event
-    nonebot.run(*args, **kwargs)
+def mb_run(chan_active: "Channel", chan_passive: "Channel", *args, **kwargs):
+    """
+    初始化MeloBot并运行在子进程
+    Args:
+        chan_active
+        chan_passive
+        *args:
+        **kwargs:
+
+    Returns:
+
+    """
+    set_channel("melobot-active", chan_active)
+    set_channel("melobot-passive", chan_passive)
+
+    # bot = MeloBot(__name__)
+    # bot.init(AbstractConnector(cd_time=0))
+    # bot.run()