update docs

add config: swoole.max_wait_time (default 5)
add constant MAIN_WORKER
add getExpireTS() for LightCache
fix savePersistence() bug
add zm_go() to prevent errors

.entry.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-if [ ! -d "/app/zhamao-framework/bin" ]; then
-	cp -r /app/zhamao-framework-bak/* /app/zhamao-framework/
-fi
-php /app/zhamao-framework/bin/start

.gitignore

@@ -11,4 +11,5 @@ composer.lock
 /resources/zhamao.service
 .phpunit.result.cache
 .daemon_pid
-/runtime/
+/runtime/
+/tmp/

Dockerfile

@@ -1,3 +0,0 @@
-FROM zmbot/swoole:latest
-
-# TODO: auto-setup entrypoint

README.md

@@ -69,7 +69,7 @@ public function index() {
 ## 下载源码
 框架源码可直接克隆本仓库进行编辑，如果你在国内，访问 GitHub 和 clone 仓库比较慢，可以将 `github.com` 替换为 `fgit.zhamao.me` 进行加速。
 
-例如：`git clone https://fgit.zhamao.me/zhamao-robot/zhamao-framework.git`。
+例如：`git clone https://fgit.zhamao.me/zhamao-robot/zhamao-framework.git --depth 1`。
 
 ## 贡献和捐赠
 如果你在使用过程中发现任何问题，可以提交 Issue 或自行 Fork 后修改并提交 Pull Request。

SECURITY.md

@@ -1,14 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 2.0     | :white_check_mark: |
-| 1.6.x   | :white_check_mark: |
-| 1.1.x   | :x:                |
-| 1.0.x   | :x:                |
-
-## Reporting a Vulnerability
-
-If you find a bug which is safety related, you should post a new issue named **Security Issue**, and I will check it as soon as possible.

bin/phpunit-swoole

@@ -1,5 +1,5 @@
 #!/usr/bin/env php
-<?php
+/** @noinspection ALL */<?php
 /**
  * Copyright: Swlib
  * Author: Twosee <twose@qq.com>
@@ -52,6 +52,7 @@ if (!defined('PHPUNIT_COMPOSER_INSTALL')) {
         }
     }
 }
+/** @noinspection PhpIncludeInspection */
 require PHPUNIT_COMPOSER_INSTALL;
 $starttime = microtime(true);
 go(function (){

bin/systemd

@@ -1,31 +0,0 @@
-#!/usr/bin/env php
-<?php /** @since 1.2 */
-switch ($argv[1] ?? '') {
-    case '--generate':
-    case '':
-        generate($argv);
-        break;
-    case '--help':
-    case '-h':
-    default:
-        echo "\nUsage: " . $argv[0] . " [OPTION]\n";
-        echo "\nzhamao-framework systemd generator.";
-        echo "\n\n  -h, --help\t\tShow this help menu";
-        echo "\n  --generate\tGenerate a systemd service file\n\n";
-        break;
-}
-
-function generate($argv) {
-    $s = "[Unit]\nDescription=zhamao-framework Daemon\nAfter=rc-local.service\n\n[Service]\nType=simple";
-    $s .= "\nUser=" . exec("whoami");
-    $s .= "\nGroup=" . exec("groups | awk '{print $1}'");
-    $s .= "\nWorkingDirectory=" . getcwd();
-    if ($argv[0] == "systemd" && !file_exists(getcwd() . '/systemd'))
-        $s .= "\nExecStart=" . getcwd() . "/vendor/bin/start server";
-    else
-        $s .= "\nExecStart=" . getcwd() . "/bin/start server";
-    $s .= "\nRestart=always\n\n[Install]\nWantedBy=multi-user.target\n";
-    @mkdir(getcwd() . "/resources/");
-    file_put_contents(getcwd() . "/resources/zhamao.service", $s);
-    echo "File successfully generated. Path: " . getcwd() . "/resources/zhamao.service\n";
-}

composer.json

@@ -29,14 +29,15 @@
         "symfony/polyfill-mbstring": "^1.20",
         "symfony/console": "^5.1",
         "symfony/routing": "^5.1",
-        "zhamao/connection-manager": "*@dev",
-        "zhamao/console": "^1.0",
+        "zhamao/console": "^1.0.10",
         "zhamao/config": "^1.0",
-        "zhamao/request": "*@dev"
+        "zhamao/request": "^1.1",
+        "zhamao/connection-manager": "^1.0"
     },
     "suggest": {
-        "ext-ctype": "*",
-        "ext-mbstring": "*"
+        "ext-ctype": "Use C/C++ extension instead of polyfill will be more efficient",
+        "ext-mbstring": "Use C/C++ extension instead of polyfill will be more efficient",
+        "league/climate": "Display columns and status in terminal"
     },
     "autoload": {
         "psr-4": {

config/global.php

@@ -1,7 +1,6 @@
 <?php
 /** @noinspection PhpFullyQualifiedNameUsageInspection */
 /** @noinspection PhpComposerExtensionStubsInspection */
-global $config;
 
 /** bind host */
 $config['host'] = '0.0.0.0';
@@ -30,6 +29,7 @@ $config['swoole'] = [
     //'worker_num' => swoole_cpu_num(), //如果你只有一个 OneBot 实例连接到框架并且代码没有复杂的CPU密集计算，则可把这里改为1使用全局变量
     'dispatch_mode' => 2, //包分配原则，见 https://wiki.swoole.com/#/server/setting?id=dispatch_mode
     'max_coroutine' => 300000,
+    'max_wait_time' => 5
     //'task_worker_num' => 4,
     //'task_enable_coroutine' => true
 ];
@@ -39,7 +39,7 @@ $config['light_cache'] = [
     'size' => 512,                     //最多允许储存的条数（需要2的倍数）
     'max_strlen' => 32768,               //单行字符串最大长度（需要2的倍数）
     'hash_conflict_proportion' => 0.6,   //Hash冲突率（越大越好，但是需要的内存更多）
-    'persistence_path' => $config['zm_data'].'_cache.json',
+    'persistence_path' => $config['zm_data'] . '_cache.json',
     'auto_save_interval' => 900
 ];
 
@@ -109,15 +109,22 @@ $config['static_file_server'] = [
 
 /** 注册 Swoole Server 事件注解的类列表 */
 $config['server_event_handler_class'] = [
-    \ZM\Event\ServerEventHandler::class,
+    // 这里添加例如 \ZM\Event\ServerEventHandler::class 这样的启动注解类
 ];
 
-/** 服务器启用的外部第三方和内部插件 */
-$config['modules'] = [
-    'onebot' => [
-        'status' => true,
-        'single_bot_mode' => false
-    ], // QQ机器人事件解析器，如果取消此项则默认为 true 开启状态，否则你手动填写 false 才会关闭
+/** 机器人解析模块，关闭后无法使用如CQCommand等注解(上面的modules即将废弃) */
+$config['onebot'] = [
+    'status' => true,
+    'single_bot_mode' => false,
+    'message_level' => 99999
+];
+
+/** 一个远程简易终端，使用nc直接连接即可，但是不建议开放host为0.0.0.0(远程连接) */
+$config['remote_terminal'] = [
+    'status' => false,
+    'host' => '127.0.0.1',
+    'port' => 20002,
+    'token' => ''
 ];
 
 return $config;

docs/FAQ.md

@@ -1,3 +1,54 @@
 # FAQ
 
-这里会写一些常见的疑难解答。
+这里会写一些常见的疑难解答。
+
+## 启动时报错 Address already in use
+
+1. 检查是否开启了两次框架，每个端口只能开启一个框架。
+2. 如果是之前已经在 20001 端口或者你设置了别的应用同样占用此端口，更换配置文件 `global.php` 中的 port 即可。
+3. 如果是之前框架成功启动，但是使用 Ctrl+C 停止后再次启动导致的报错，请根据下面的步骤来检查是否存在僵尸进程。
+
+- 如果系统内装有 `htop`，可以直接在 `htop` 中开启 Tree 模式并使用 filter 过滤 php，检查残留的框架进程。
+- 如果系统没有 `htop`，使用 `ps aux | grep vendor/bin/start | grep -v grep` 如果存在进程，请使用以下命令尝试杀掉：
+  
+```bash
+# 如果确定框架的数据都已保存且没有需要保存的缓存数据，直接杀掉 SIGKILL 即可，输入下面这条
+ps aux | grep vendor/bin/start | grep -v grep | awk '{print $2}' | xargs kill -9
+
+# 如果不确定框架是不是还继续运行，想尝试正常关闭（走一遍储存保存数据的事件），使用下面这条
+# 首先使用 'ps aux | grep vendor/bin/start | grep -v grep' 找到进程中第二列最小的pid
+# 然后使用下面的这条命令，假设最小的pid是23643
+kill -INT 23643
+# 如果使用 ps aux 看不到框架相关进程，证明关闭成功，否则需要使用第一条强行杀死
+```
+
+## 出现 deadlock 字样
+
+一般情况下，如果误操作框架可能会报如下图的错误：
+
+```
+===================================================================
+ [FATAL ERROR]: all coroutines (count: 1) are asleep - deadlock!
+===================================================================
+
+ [Coroutine-1]
+--------------------------------------------------------------------
+#0  Swoole\Coroutine\System::sleep() called at [/Users/jerry/project/git-project/zhamao-framework/src/ZM/global_functions.php:232]
+#1  zm_sleep() called at [/Users/jerry/project/git-project/zhamao-framework/src/Module/Example/Hello.php:38]
+#2  Module\Example\Hello->onStart() called at [/Users/jerry/project/git-project/zhamao-framework/src/ZM/Event/EventDispatcher.php:205]
+#3  ZM\Event\EventDispatcher->dispatchEvent() called at [/Users/jerry/project/git-project/zhamao-framework/src/ZM/Event/EventDispatcher.php:89]
+#4  ZM\Event\EventDispatcher->dispatchEvents() called at [/Users/jerry/project/git-project/zhamao-framework/src/ZM/Event/SwooleEvent/OnWorkerStart.php:130]
+#5  ZM\Event\SwooleEvent\OnWorkerStart->onCall() called at [/Users/jerry/project/git-project/zhamao-framework/src/ZM/Framework.php:336]
+```
+
+这种错误的出现原因一般是因为协程未结束而 Worker 进程提前退出导致的，这个错误也可手动造成（在任意 Worker 进程内的位置使用 `zm_yield()` 且不使用 `zm_resume()` 恢复，期间使用 reload 或 stop 重启或停止框架就会报错）。
+
+还有一种情况是数据库、文件读取或下载上传还没有传送结束，时间已经超时，在关闭或重启框架时不得不强行切断协程的运行。这种情况建议根据下方的打印输出栈进行插错，建议将协程运行时间长的过程缩短或调长 `swoole` 配置项下面的 `max_wait_time` 时间（秒），2.4.3 版本起此参数默认为 5 秒。
+
+## 使用 LightCache 关闭时无法正常保存持久化
+
+LightCache 因为是跨内存使用的，所以每次重启和关闭框架时，都只会让其中一个进程去保存。因为在 2.4.2 版本开始，持久化的逻辑发生了更改，不再支持 `expire = -2` 进行设置持久化（因为那样会很容易让开发者写错），仅支持使用 `LightCache::addPersistence($key)` 这样的方式进行设置持久化，所以在 2.4.2 版本以后，请使用此方法进行持久化设置，保证数据不丢失。
+
+此外，2.4.2 版本起，不再支持用户手动调用 `savePersistence()` 方法，普通用户不可手动调用此方法，否则会导致数据出错。
+
+## 

docs/advanced/custom-start.md

@@ -86,15 +86,19 @@ bin/start server # 通过源码模式启动框架
 - `--log-{mode}`：设置 log 等级。支持 `--log-debug`，`--log-verbose`，`--log-info`，`--log-warning`，`--log-error`。
 - `--log-theme`：设置终端信息的主题。这个选项适用于多种终端信息显示的兼容，例如白色终端和不支持颜色的终端。详见 [Console - 主题设置](/component/console/#_2)。
 - `--disable-coroutine`：关闭一键协程化。
+- `--remote-terminal`：开启 nc 远程终端，配置文件使用全局中的 `remote_terminal` 项。也可以在全局配置中常开启（status 设置为 true）。
 - `--daemon`：以守护进程方式运行框架，此参数将直接在输出 motd 后将进程挂到 init 下运行，后台常驻。
-- `--watch`：监控 `src/` 目录下的文件变化，有变化则自动重新载入代码。开启监控需要安装 PHP 扩展：inotify。使用 pecl 就可以安装：`pecl install inotify`。
+- `--watch`：监控 `src/` 目录下的文件变化，有变化则自动重新载入代码。开启监控需要安装 PHP 扩展：inotify。使用 pecl 就可以安装：`pecl install inotify`。（注：不支持 WSL 和 macOS）
 - `--env`：设置运行环境，设置运行环境后将优先加载指定环境的配置文件，支持 `--env=production`，`--env=staging`，`--env=development`，见 [基本配置](/guide/basic-config/#_2)。
+- `--worker-num`：指定运行的工作进程数量（并不是越多越好，框架默认为 CPU 核心数），例如 `--worker-num=8`。
+- `--task-worker-num`：启用 TaskWorker 进程并指定数量。
+- `--show-php-ver`：在启动时显示 Swoole 和 PHP 的版本。
 
 ## 守护进程操作命令
 
 守护进程在 2.2.0 版本开始，可以使用命令行快速操作，如重启、停止、查看状态等。
 
-注意，这里的守护进程操作命令是指 **使用 `--daemon` 方式启动的框架**，如使用 Docker、screen、tmux 等方式挂后台跑则此命令不可用！
+注意，这里的守护进程操作命令是指 **使用 `--daemon` 方式启动的框架**，如使用 Docker、screen、tmux、systemd 等方式挂后台跑则此命令不可用！
 
 ```bash
 vendor/bin/start daemon:status # 查看守护进程的状态
@@ -115,4 +119,16 @@ vendor/bin/start simple-http-server your-web-dir/ --host=0.0.0.0 --port=8080
 ```
 
 -  `your-web-dir` 是必填的参数。
-- `--host` 和 `--port` 是可选参数，如果不填，则默认使用 `global.php` 配置文件中的配置。
+- `--host` 和 `--port` 是可选参数，如果不填，则默认使用 `global.php` 配置文件中的配置。
+
+### 检查配置是否更新
+
+默认情况下（非源码模式），你可以使用命令 `vendor/bin/start check:config` 来检查你的配置文件是否需要更新部分段落。
+
+### systemd 配置文件生成器
+
+框架支持生成 systemd 配置文件 `zhamao.service`，生成后将文件放入 `/etc/systemd/system` 后输入 `systemctl enable zhamao.service` 即可。
+
+命令：`vendor/bin/start systemd:generate`
+
+注意，systemd 启动的守护进程模式和使用参数 `--daemon` 不一样，请勿同时混用，直接使用上述命令生成的配置文件即可正常使用！

docs/advanced/framework-structure.md

@@ -2,5 +2,5 @@
 
 ## 框架运行总结构图
 
-![](../assets/img/framework-structure.png)
+![](https://static.zhamao.me/images/docs/a23d8a952cf9c88d395888d220605a4f.png)
 

docs/advanced/inside-class.md

@@ -27,3 +27,44 @@
 TODO：先放一放。
 ```
 
+## ZM\Entity\MatchObject
+
+此类是调用方法 `MessageUtil::matchCommand()` 返回的对象体，含有匹配成功与否和匹配到的注解相关的信息。
+
+### 属性
+
+- `$match`：`bool` 类型，返回匹配是否成功
+- `$object`：`CQCommand` 注解类，如果匹配成功则返回对应的 `@CQCommand` 信息
+- `match`：`array` 类型，如果匹配成功则返回匹配到的参数
+
+```php
+// 假设我有一个注解事件 @CQCommand(match="你好")，绑定的函数是 \Module\Example\Hello 下的 hello123()
+
+$obj = MessageUtil::matchCommand("你好 我叫顺溜 我今年二十八", ctx()->getData());
+/* 以下是返回信息，仅供参考
+$obj->match ==> true
+$obj->object ==> \ZM\Annotation\CQ\CQCommand: (
+	match: "你好",
+    pattern: "",
+    regex: "",
+    start_with: "",
+    end_with: "",
+    keyword: "",
+    alias: [],
+    message_type: "",
+    user_id: 0,
+    group_id: 0,
+    discuss_id: 0,
+    level: 20,
+    method: "hello123",
+    class: \Module\Example\Hello::class
+)
+$obj->match ==> [
+	"我叫顺溜",
+	"我今年二十八"
+]
+*/
+```
+
+
+

docs/advanced/multi-process.md

@@ -16,13 +16,13 @@ PHP 也是如此，框架的多进程又是怎么一回事呢？为什么要采
 
 **但是**，CPU 密集型的应用怎么办呢？假设我的 Web 应用有大量的排序、md5 运算怎么办呢？这样的阻塞，假设是一个超级大的 for 循环或者是要执行很长时间的 while 循环，CPU 一直在被占用。多进程就是针对 CPU 密集型的应用说 yes 的一个方案。
 
-![Untitled Diagram (1)](../assets/img/single-process.png)
+![diagram](https://static.zhamao.me/images/docs/06c17ab473f17ab10523a938cdbd8760.png)
 
 我们假设现在有 3 个请求同时访问，也就是说上面的流程需要执行 3 遍。而如果我们只有一个进程的话，最后一个请求需要等待的时间为 `2*3+5*3=21` 秒，非常耗时。
 
 而如果有两个进程处理 3 个请求，则最后一个完成的请求就缩短了，`2+5+2+5=14` 秒。
 
-![Untitled Diagram (2)](../assets/img/Untitled Diagram (2).png)
+![diagram](https://static.zhamao.me/images/docs/dbb4e32e1c77f96162d10e41f25befa4.png)
 
 所以如果要充分利用你的服务器或者个人电脑的多核 CPU 资源，就要设置多个进程来处理。一个进程只能在一个 CPU 上运行，而设置了多进程后，就可以让多核 CPU 充分运行多个进程，所以我们给框架设置多进程的推荐数值为等同于 CPU 的核心数。
 
@@ -32,7 +32,7 @@ PHP 也是如此，框架的多进程又是怎么一回事呢？为什么要采
 
 ## 框架进程模型
 
-![Untitled Diagram (3)](../assets/img/Untitled Diagram (3).png)
+![diagram](https://static.zhamao.me/images/docs/46a34feb0195d6ea12da7b80750c9e71.png)
 
 上图中，横向的时间片可以理解为并行执行，这些操作在多个 CPU 内可能同时在执行。
 
@@ -40,7 +40,7 @@ PHP 也是如此，框架的多进程又是怎么一回事呢？为什么要采
 
 众所周知，进程是程序在操作系统中的一个边界，和自己有关的一切变量、内容和代码都在自己的进程内，不同进程之间如果不使用管道等方式，是不可以互相访问的。而加上开始描述的，创建子进程是一个复制自身的过程，所以也就会有如下图的情况：
 
-![Untitled Diagram (4)](../assets/img/Untitled Diagram (4).png)
+![diagram](https://static.zhamao.me/images/docs/8b43e2179a63c8d91a508d7cefcd3226.png)
 
 我们以静态类为例，设置一个进程中的全局变量。这里就会出现，同一个静态变量在多个进程中完全不同的值的结果。此后，我们将会在 Worker 进程中执行用户的代码，如果设置 Worker 数量仅为 1 的话，那么就简单许多了，你还是可以使用全局变量或静态类来存储你想要的内容而不用担心这种多个进程变量隔离的情况（因为用户的 Web 请求处理的代码只会在一个 Worker 进程中执行）。如果像上图一样设置了多个 Worker，则用户过来的比如 HTTP 请求就有可能出现在不同的 Worker 进程中，给全局变量设值就一定会造成不同步的问题。这时我们就不可以使用全局变量做数据同步（注意，我说的是数据同步）。
 

docs/advanced/task-worker.md

@@ -0,0 +1,4 @@
+# 使用 TaskWorker 进程处理密集运算
+
+> 新开个坑，有时间补上。（__填坑标记__）
+

docs/component/cqcode.md

@@ -128,8 +128,9 @@ $str = CQ::removeCQ("[CQ:at,qq=all]这是带表情的全体消息[CQ:face,id=8]"
 
 解析 CQ 码。
 
-- 参数：`getCQ($msg);`：要解析出 CQ 码的消息。
-- 返回：`数组 | null`，见下表
+- 定义：`getCQ($msg, $is_object = false)`
+- 参数 `$is_object` 为 true 时，返回一个 `\ZM\Entity\CQObject` 对象，此对象的属性和下表相同。（2.3.0+ 版本可用）
+- 返回：`数组 | CQObject | null`，见下表。
 
 | 键名   | 说明                                                         |
 | ------ | ------------------------------------------------------------ |
@@ -140,6 +141,10 @@ $str = CQ::removeCQ("[CQ:at,qq=all]这是带表情的全体消息[CQ:face,id=8]"
 
 ### CQ::getAllCQ()
 
+定义：`CQ::getAllCQ($msg, $is_object = false)`
+
+参数 `$is_object` 为 true 时，返回一个 `\ZM\Entity\CQObject[]` 对象数组，此对象的属性和上面的表格内相同。（2.3.0+ 版本可用）
+
 解析 CQ 码，和 `getCQ()` 的区别是，这个会将字符串中的所有 CQ 码都解析出来，并以同样上方解析出来的数组格式返回。
 
 ```php

docs/component/global-functions.md

@@ -134,10 +134,6 @@ set_coroutine_params(["data" => [
 
 别名：`context()`，获取当前协程的上下文，见 [上下文](/component/context/)。
 
-## zm_debug()
-
-同 `Console::debug($msg)`。
-
 ## zm_sleep()
 
 协程版 `sleep()` 函数。
@@ -255,4 +251,62 @@ bot()->sendPrivateMsg(123456, "你好啊！！");
 
 定义：`getAllFdByConnectType(string $type = 'default'): array`
 
-当 `$type` 为 `qq` 时，则返回所有 OneBot 机器人接入的 WebSocket 连接号。
+当 `$type` 为 `qq` 时，则返回所有 OneBot 机器人接入的 WebSocket 连接号。
+
+## zm_dump()
+
+更漂亮地输出变量值，可替代 `var_dump()`。
+
+```php
+class Pass {
+    public $foo = 123;
+    public $bar = ["a", "b"];
+}
+$pass = new Pass();
+$pass->obj = true;
+zm_dump($pass);
+```
+
+![](https://static.zhamao.me/images/docs/ba026ca11332b1a4ad68a549165230e6.png)
+
+## zm_config()
+
+> v2.4.0 起可用。
+
+同 `ZMConfig::get()`。
+
+定义：`zm_config($name, $key = null)`。
+
+有关 ZMConfig 模块的说明，见 [指南 - 基本配置](/guide/basic-config/)。
+
+```php
+zm_config("global"); //等同于 ZMConfig::get("global");
+zm_config("global", "swoole"); //等同于 ZMConfig::get("global", "swoole");
+```
+
+## zm_info()
+
+> v2.4.0 起可用。（下面的 log 类也一样）
+
+同 `Console::info($msg)`。
+
+## zm_debug()
+
+同 `Console::debug($msg)`。
+
+## zm_warning()
+
+同 `Console::warning($msg)`。
+
+## zm_success()
+
+同 `Console::success($msg)`。
+
+## zm_error()
+
+同 `Console::error($msg)`。
+
+## zm_verbose()
+
+同 `Console::verbose($msg)`。
+

docs/component/light-cache.md

@@ -57,7 +57,9 @@ $config['light_cache'] = [
 
 `$value` 可存入 `bool`、`string`、`int`、`array` 等可被 `json_encode()` 的变量，闭包函数和对象不可存入。
 
-`$expire` 是 `int`，超时时间（秒）。如果设定了大于 0 的值，则表明是在 `$expire` 秒后自动删除。如果为 -1 则什么都不做，如果框架使用了 `stop` 或 Ctrl+C 或意外退出时数据会丢失。如果为 -2，则会将此数据持久化保存，保存在上方配置文件指定的 json 文件中，待关闭后再次启动框架会自动加载回来，不会丢失。
+`$expire` 是 `int`，超时时间（秒）。如果设定了大于 0 的值，则表明是在 `$expire` 秒后自动删除（框架中途停止不受影响）。如果为 -1 则什么都不做。框架停止后自动被清除。
+
+**注意：如果前面使用了 set() ，后面再次使用 set() 会重置 expire 过期时间为 -1（-1 是框架运行时不过期，关闭框架删除的状态），如果只需要更新值，请使用 update()。**
 
 ```php
 // use ZM\Store\LightCache;
@@ -88,6 +90,14 @@ public function storeAfterRemove() {
 ( 内容不存在！
 </chat-box>
 
+### LightCache::update()
+
+更新值而不更新状态。如果键值对不存在，则返回 false。
+
+定义：`LightCache::update(string $key, $value)`
+
+参数同 `set()`，可参考。
+
 ### LightCache::get()
 
 获取内容。
@@ -106,6 +116,20 @@ zm_sleep(10);
 dump(LightCache::getExpire("test")); // 返回 10
 ```
 
+### LightCache::getExpireTS()
+
+获取存储项要过期的时间戳。
+
+定义：`LightCache::getExpireTS(string $key)`
+
+```php
+$s = LightCache::set("test", "hello", 20); //假设这条代码执行时时间戳是 1616838482
+zm_sleep(10);
+dump(LightCache::getExpire("test")); // 返回 1616838502
+zm_sleep(10);
+dump(LightCache::getExpire("test")); // 返回 null
+```
+
 ### LightCache::getMemoryUsage()
 
 获取轻量缓存使用的总空间大小（字节）
@@ -157,25 +181,34 @@ dump(LightCache::getAll());
 */
 ```
 
-### LightCache::savePersistence()
+### LightCache::addPersistence()
 
-立刻保存所有被标记为持久化的缓存项到磁盘。
+添加持久化存储的键。
 
-!!! note "提示"
+用法：`LightCache::addPersistence($key)`。
 
-	在一般情况下，框架定时执行此方法来保存，在停止框架、reload 框架和 Ctrl+C 停止框架的时候，均会执行保存。
+注：只需调用一次即可，无需多次重复调用，也不需要设置 expire 为 -2 了。（2.4.2 起可用此方法）。
+
+详见下方 **持久化**。
+
+### LightCache::removePersistence()
+
+删除持久化的键。
+
+用法：`LightCache::removePersistence($key)`。
+
+注：只需调用一次即可，无需多次重复调用，也不需要设置 expire 为非 -2 了。（2.4.2 起可用此方法）。
 
 ### 持久化
 
-将 `set()` 的 expire 设置为 -2 即可。
+使用 `LightCache::addPersistence($key)` 添加对应需要持久化的键名即可。
 
 ```php
 /**
- * @CQCommand("store")
+ * @OnStart()
  */
-public function store() {
-    LightCache::set("msg_time", time(), -2);
-    return "OK!";
+public function onStart() {
+    LightCache::addPersistence("msg_time");
 }
 /**
  * @CQCommand("getStore")
@@ -187,11 +220,11 @@ public function getStore() {
 
 <chat-box>
 ^ 我在 2021-01-05 15:21:00 发送这条消息
-) store
-( OK!
+) getStore
+( 2021-01-05 15:20:00
 ^ 这时我用 Ctrl+C 停止框架，过一会儿再启动
 ) getStore
-( 存储时间：2021-01-05 15:21:00
+( 存储时间：2021-01-05 15:20:00
 </chat-box>
 
 ### 数据加锁

docs/component/message-util.md

@@ -0,0 +1,89 @@
+# MessageUtil 消息处理工具类
+
+类定义：`\ZM\Utils\MessageUtil`
+
+> 2.3.0 版本起可用。
+
+这里放置一些机器人聊天消息处理的便捷静态方法，例如下载图片等。
+
+## 方法
+
+### downloadCQImage()
+
+下载用户消息中所带的所有图片，并返回文件路径。
+
+定义：`downloadCQImage($msg, $path = null)`
+
+参数 `$msg` 为带图片的用户消息，例如 `你好啊！\n[CQ:image,file=a.jpg,url=https://zhamao.xin/file/hello.jpg]`
+
+参数 `$path` 为图片下载的路径，如果不填（默认 null）则指定为 `zm_data/images/` 目录，且不存在会自动创建。
+
+```php
+$r = MessageUtil::downloadCQImage("你好啊！\n[CQ:image,file=a.jpg,url=https://zhamao.xin/file/hello.jpg]");
+/*
+$r == [
+    "/path-to/zhamao-framework/zm_data/images/a.jpg"
+];
+*/
+```
+
+如果返回的是空数组 `[ ]`，则表明消息中没有图片。如果返回的是 `false`，则表明其中至少一张下载失败或路径有误。
+
+### containsImage()
+
+检查消息中是否含有图片。
+
+定义：`containsImage($msg)`
+
+返回：`bool`，你懂的，true 就是有，false 就没有。
+
+```php
+MessageUtil::containsImage("[CQ:image,file=a.jpg,url=http://xxx]"); // true
+MessageUtil::containsImage("[CQ:face,id=140] 咦，这是一条带表情的消息"); // false
+```
+
+### getImageCQFromLocal()
+
+通过文件路径获取图片的发送 CQ 码。
+
+定义：`getImageCQFromLocal($file, $type = 0)`
+
+参数 `$file` 为图片的绝对路径。
+
+返回：图片的 CQ 码，如 `[CQ:image,file=xxxxx]`
+
+参数 `$type`：
+
+- `0`：以 base64 的方式发送图片，返回结果如 `[CQ:image,file=base64://xxxxxx]`
+- `1`：以 `file://` 本地文件的方式发送图片，返回结果如 `[CQ:image,file=file:///path-to/images/a.jpg]`
+- `2`：返回图片的 http:// CQ 码（默认为 /images/ 路径就是文件对应所在的目录），如 `[CQ:image,file=http://127.0.0.1:20001/images/a.jpg]`
+
+### splitCommand()
+
+切割用户消息为数组形式（`@CQCommand` 就是使用此方式切割的）
+
+定义：`splitCommand($msg): array`
+
+返回：数组，切分后的。
+
+!!! tip "为什么不直接使用 explode 呢"
+
+	因为 `explode()` 只会简单粗暴的切割字符串，假设用户输入的消息中两个词中间有多个空格，则会有空的词出现。例如 `你好     我是一个长空格`。此函数会将多个空格当作一个空格来对待。
+
+```php
+MessageUtil::splitCommand("你好 我是傻瓜\n我是傻瓜二号"); // ["你好","我是傻瓜","我是傻瓜二号"]
+MessageUtil::splitCommand("我有   三个空格"); // ["我有","三个空格"]
+```
+
+### matchCommand()
+
+匹配一条消息到 `@CQCommand` 规则的注解事件，返回要执行的类和函数位置。
+
+定义：`matchCommand($msg, $obj)`
+
+参数 `$msg` 为消息内容。
+
+参数 `$obj` 为事件的对象，可使用 `ctx()->getData()` 获取原先的事件体（仅限 OneBot 消息类型事件中使用）
+
+返回：`\ZM\Entity\MatchObject` 对象，含有匹配成功与否，匹配到的注解对象，匹配到的分割词等，见 []
+

docs/component/remote-terminal.md

@@ -0,0 +1,37 @@
+# 远程终端
+框架在 2.3 版本时删除了本地终端（就是框架启动后可以在终端输入一些参数），因为框架的多进程模式会导致终端输入错乱，所以暂时取消掉了。
+
+而远程终端应运而生，为的是弥补这一功能。与之前不同的是，远程终端使用 nc 连接，无需任何其他组件和客户端，而且功能更丰富，支持自定义命令。
+
+## 启用
+有两种开启方式：
+
+- 永久开启：全局配置文件中找到 `remote_terminal` 的 `status`，改为 true，启动框架即可。
+- 临时开启：启动框架时加上参数 `--remote-terminal`。例如：`vendor/bin/start server --remote-terminal`。
+
+## 配置
+在一般情况下，框架为了安全，直接按照默认配置，会监听 `127.0.0.1:20002` 端口，不可以远程访问，只能使用本机的 nc 连接，效果如下：
+
+本地主机：
+![img.png](https://static.zhamao.me/images/docs/3432551c08b34ca10aaf19f3f82aedeb.png)
+
+从别的主机：
+![img.png](https://static.zhamao.me/images/docs/6f35f2745d66c7e186da75b6f09248c2.png)
+
+如果将 `host` 改为 `0.0.0.0` 或对应监听地址，即可指向性访问。
+
+但是，如果你又想远程连接，又想保证安全，那么可以设置一个 token 参数，来保证连接时需要输入 token 才能使用远程终端。
+假设我们的 token 是 `iAMTokEn`：
+![img.png](https://static.zhamao.me/images/docs/e502af4c0fd9359615548303cacb70dd.png
+)
+
+## 使用
+默认情况下，使用 `nc` 命令即可。
+```bash
+nc <your-host> <your-port> -vvv
+# nc 127.0.0.1 20002 -vvv
+```
+
+输入 help 即可查看内置的常用指令：
+![img.png](https://static.zhamao.me/images/docs/7b74aa2b487c86482097ec7692c66e08.png
+)

docs/component/route-manager.md

@@ -0,0 +1,54 @@
+# HTTP 路由管理
+
+HTTP 路由管理器用作管理炸毛框架内 `@RequestMapping` 和静态目录的路由操作的，可在运行过程中编写添加路由。
+
+类定义：`\ZM\Http\RouteManager`
+
+> 2.3.0 版本起可用。
+
+!!! warning "注意"
+
+	因为炸毛框架的路由实现是不基于跨进程的共享内存的，所以每次使用这里面的工具函数都需要单独在所有 Worker 进程中执行一次，最好的办法就是在启动框架时执行（`@OnStart(-1)` 即可，代表此注解事件将在每个工作进程中都被执行一次）。
+
+## 方法
+
+### importRouteByAnnotation()
+
+通过注解类导入路由。（注：此方法一般为框架内部使用）
+
+定义：`importRouteByAnnotation(RequestMapping $vss, $method, $class, $methods_annotations)`
+
+参数 `$vss`：RequestMapping 注解类，类中定义 `route` 和 `request_method` 即可。
+
+参数 `$method, $class`：执行的目标注解事件函数位置，比如 `$class = \Module\Example\Hello::class`，`$method = 'hitokoto'`。
+
+参数 `$methods_annotations`：需要绑定的 Controller 注解类数组，一般数组内建议只带有一个 Controller，如 `[$controller]`。
+
+### addStaticFileRoute()
+
+添加一个单目录（此目录下无子目录，只有文件）并绑定为一个路由。
+
+定义：`addStaticFileRoute($route, $path)`
+
+参数 `$route`：绑定的目标路由，如 `/images/`。
+
+参数 `$path`：绑定的文件目录位置，如 `/root/zhamao-framework-starter/zm_data/images/`。
+
+```php
+/**
+ * @OnStart(-1)
+ */
+public function onStart() {
+    RouteManager::addStaticFileRoute("/images/", DataProvider::getDataFolder()."images/");
+}
+```
+
+## 属性
+
+### RouteManager::$routes
+
+此为存放路由树的变量，请谨慎操作。
+
+定义：`\Symfony\Component\Routing\RouteCollection | null`
+
+炸毛框架使用了 Symfony 框架的 route 组件，有关详情请查阅 [文档](https://symfony.com/doc/current/routing.html)。

docs/component/task-worker.md

@@ -0,0 +1,26 @@
+# TaskManager 工作进程管理
+
+此类管理的是 TaskWorker 相关工作。有关使用 TaskWorker 的教程，见 [进阶 - 使用 TaskWorker 进程处理密集运算](/advanced/task-worker)
+
+类定义：`\ZM\Utils\TaskManager`
+
+使用 TaskWorker 需要先在 `global.php` 配置文件中开启！
+
+## 方法
+
+### runTask()
+
+在 TaskWorker 运行任务。
+
+定义：`runTask($task_name, $timeout = -1, ...$params)`
+
+参数 `$task_name`：对应 `@OnTask` 注解绑定的任务函数。
+
+参数 `$timeout`：等待任务函数最长运行的时间（秒），如果超过此时间将返回 false。
+
+参数 `剩余`：将变量传入 TaskWorker 进程，除 Closure，资源类型外，可序列化的变量均可。
+
+```php
+TaskManager::runTask("heavy_task", 100, "param1", "param2");
+```
+

docs/component/zmutil.md

@@ -21,3 +21,47 @@ class ASD{
 ZMUtil::getModInstance(ASD::class)->test = 5;
 ```
 
+## ZMUtil::getReloadableFiles()
+
+返回可通过热重启（reload）来重新加载的 php 文件列表。
+
+以下是示例模块下的例子（直接拉取最新的框架源码并运行框架后获取的）。
+
+```php
+array:31 [
+  94 => "src/ZM/Context/Context.php"
+  95 => "src/ZM/Context/ContextInterface.php"
+  96 => "src/ZM/Annotation/AnnotationParser.php"
+  97 => "src/Custom/Annotation/Example.php"
+  98 => "src/ZM/Annotation/Interfaces/CustomAnnotation.php"
+  99 => "src/Module/Example/Hello.php"
+  100 => "src/ZM/Annotation/Swoole/OnStart.php"
+  101 => "src/ZM/Annotation/CQ/CQCommand.php"
+  102 => "src/ZM/Annotation/Interfaces/Level.php"
+  103 => "src/ZM/Annotation/Command/TerminalCommand.php"
+  104 => "src/ZM/Annotation/Http/RequestMapping.php"
+  105 => "src/ZM/Annotation/Http/RequestMethod.php"
+  106 => "src/ZM/Annotation/Http/Middleware.php"
+  107 => "src/ZM/Annotation/Interfaces/ErgodicAnnotation.php"
+  108 => "src/ZM/Annotation/Swoole/OnOpenEvent.php"
+  109 => "src/ZM/Annotation/Swoole/OnSwooleEventBase.php"
+  110 => "src/ZM/Annotation/Interfaces/Rule.php"
+  111 => "src/ZM/Annotation/Swoole/OnCloseEvent.php"
+  112 => "src/ZM/Annotation/Swoole/OnRequestEvent.php"
+  113 => "src/ZM/Http/RouteManager.php"
+  114 => "vendor/symfony/routing/RouteCollection.php"
+  115 => "vendor/symfony/routing/Route.php"
+  116 => "src/Module/Middleware/TimerMiddleware.php"
+  117 => "src/ZM/Http/MiddlewareInterface.php"
+  118 => "src/ZM/Annotation/Http/MiddlewareClass.php"
+  119 => "src/ZM/Annotation/Http/HandleBefore.php"
+  120 => "src/ZM/Annotation/Http/HandleAfter.php"
+  121 => "src/ZM/Annotation/Http/HandleException.php"
+  122 => "src/ZM/Event/EventManager.php"
+  123 => "src/ZM/Annotation/Swoole/OnSwooleEvent.php"
+  124 => "src/ZM/Event/EventDispatcher.php"
+]
+```
+
+> 为什么不能重载所有文件？因为框架是多进程模型，而重载相当于只重新启动了一次 Worker 进程，Manager 和 Master 进程未重启，所以被 Manager、Master 进程已经加载的 PHP 文件无法使用 reload 命令重新加载。详见 [进阶 - 进程间隔离](/advanced/multi-process/#_5)。
+

docs/event/event-dispatcher.md

@@ -102,15 +102,15 @@ class Test {
 
 在炸毛框架内部，一个完整的事件流程和中间件的关系如下图：
 
-![Untitled Diagram](../assets/img/diagram3.dbb4e32e.png)
+![Untitled Diagram](https://static.zhamao.me/images/docs/dbb4e32e1c77f96162d10e41f25befa4.png)
 
 对于同一事件的优先级和响应顺序，优先级的关系如下图：
 
-![Untitled Diagram](../assets/img/Untitled Diagram.png)
+![diagram](https://static.zhamao.me/images/docs/fa52005b7ca891053617a77541c7e785.png)
 
 对于事件内单个事件被调用的单个函数下如果存在多个中间件，中间件模型和事件的关系如下图：
 
-![Untitled Diagram-2](../assets/img/diagram4.16ce39ca.png)
+![Untitled Diagram-2](https://static.zhamao.me/images/docs/16ce39caad472d03d7786e6ffb0c55bf.png)
 
 ## 实战例子
 

docs/event/framework-annotations.md

@@ -221,6 +221,27 @@
 | tick_ms   | `int`，**必填**，间隔的毫秒数，例如 1 秒间隔为 `1000`，范围大于 0，小于 86400000。 |                          |      |
 | worker_id | `int`，要在哪个 Worker 进程上执行，默认为 0，范围是 0～{你设定的 Worker 数量-1}，如果是 -1 的话，则会在所有 Worker 进程上触发。 | 限定只执行的 Worker 进程 |      |
 
+## OnTask()
+
+定义一个在工作进程中运行的任务函数。详情见 [进阶 - 使用 TaskWorker 进程处理密集运算](/advanced/task-worker)。
+
+### 属性
+
+| 类型       | 值                            |
+| ---------- | ----------------------------- |
+| 名称       | `@OnTask`                     |
+| 触发前提   | 在框架加载后激活              |
+| 命名空间   | `ZM\Annotation\Swoole\OnTask` |
+| 适用位置   | 方法                          |
+| 返回值处理 | 有，返回 Worker 进程的结果    |
+
+### 注解参数
+
+| 参数名称  | 参数范围                                                     | 用途         | 默认 |
+| --------- | ------------------------------------------------------------ | ------------ | ---- |
+| task_name | `string`，**必填**，任务函数的名称，不建议重复。             |              |      |
+| rule      | 设置触发前提，PHP 代码，返回 bool 值即可，参考 OnRequestEvent | 限定是否执行 | 空   |
+
 ## OnSetup()
 
 在框架加载前执行的代码。此部分代码是在主进程执行的，不可在此事件中使用任何协程相关的功能。
@@ -241,6 +262,27 @@
 
 无。
 
+## TerminalCommand()
+
+添加一个远程终端的自定义命令。（2.4.0 版本起可用）
+
+### 属性
+
+| 类型       | 值                                      |
+| ---------- | --------------------------------------- |
+| 名称       | `@TerminalCommand`                      |
+| 触发前提   | 连接到远程终端可触发                    |
+| 命名空间   | `ZM\Annotation\Command\TerminalCommand` |
+| 适用位置   | 方法                                    |
+| 返回值处理 | 无                                      |
+
+### 注解参数
+
+| 参数名称    | 参数范围                       | 默认 |
+| ----------- | ------------------------------ | ---- |
+| command     | `string`，**必填**，命令字符串 |      |
+| description | `string`，要显示的帮助文本     | 空   |
+
 ## 示例1（机器人连接框架后输出信息）
 
 ```php
@@ -385,3 +427,6 @@ public function onCrawl() {
 }
 ```
 
+## 示例6（创建一个远程终端命令并调试框架）
+
+> 开个坑，以后填。（__填坑标记__）

docs/guide/basic-config.md

@@ -18,6 +18,7 @@
 | `zm_data`                    | 框架的配置文件、日志文件等文件目录                           | `./` 下的 `zm_data/`         |
 | `debug_mode`                 | 框架是否启动 debug 模式                                      | false                        |
 | `crash_dir`                  | 存放崩溃和运行日志的目录                                     | `zm_data` 下的 `crash/`      |
+| `config_dir`                 | 存放 saveToJson() 方法保存的数据的目录                       | `zm_data` 下的 `config/`     |
 | `swoole`                     | 对应 Swoole server 中 set 的参数，参考Swoole文档             | 见子表 `swoole`              |
 | `light_cache`                | 轻量内置 key-value 缓存                                      | 见字表 `light_cache`         |
 | `worker_cache`               | 跨进程变量级缓存                                             | 见子表 `worker_cache`        |
@@ -28,20 +29,23 @@
 | `http_default_code_page`     | HTTP服务器在指定状态码下回复的默认页面                       | 见配置文件                   |
 | `init_atomics`               | 框架启动时初始化的原子计数器列表                             | 见配置文件                   |
 | `info_level`                 | 终端日志显示等级（0-4）                                      | 2                            |
-| `context_class`              | 上下文所定义的类，待上下文完善后见对应文档                   | `\ZM\Context\Context::class` |
+| `context_class`              | 上下文所定义的类，见对应上下文说明文档                       | `\ZM\Context\Context::class` |
 | `static_file_server`         | 静态文件服务器配置项                                         | 见子表 `static_file_server`  |
-| `server_event_handler_class` | 注册 Swoole Server 事件注解的类列表                          | 见配置文件                   |
-| `command_register_class`     | 注册自定义命令行选项指令的类                                 | 见配置文件                   |
-| `modules`                    | 服务器启用的外部第三方和内部插件                             | `['onebot' => true]`         |
+| `server_event_handler_class` | 注册 Swoole Server 事件注解的类列表，在 Swoole 服务器启动前就被加载 | 空                           |
+| `onebot`                     | OneBot 协议相关配置                                          | 见子表 `onebot`              |
+| `remote_terminal`            | 远程终端相关配置                                             | 见子表 `remote_terminal`     |
 
 ### 子表 **swoole**
 
-| 配置名称        | 说明                                                         | 默认值                              |
-| --------------- | ------------------------------------------------------------ | ----------------------------------- |
-| `log_file`      | Swoole 的日志文件                                            | `crash_dir` 下的 `swoole_error.log` |
-| `worker_num`    | Worker 工作进程数                                            | 运行框架的主机 CPU 核心数           |
-| `dispatch_mode` | 数据包分发策略，见 [文档](https://wiki.swoole.com/#/server/setting?id=dispatch_mode) | 2                                   |
-| `max_coroutine` | 最大协程并发数                                               | 300000                              |
+| 配置名称                | 说明                                                         | 默认值                              |
+| ----------------------- | ------------------------------------------------------------ | ----------------------------------- |
+| `log_file`              | Swoole 的日志文件                                            | `crash_dir` 下的 `swoole_error.log` |
+| `worker_num`            | Worker 工作进程数                                            | 运行框架的主机 CPU 核心数           |
+| `dispatch_mode`         | 数据包分发策略，见 [文档](https://wiki.swoole.com/#/server/setting?id=dispatch_mode) | 2                                   |
+| `max_coroutine`         | 最大协程并发数                                               | 300000                              |
+| `max_wait_time`         | 退出进程时等待协程恢复的最长时间（秒）                       | 5（2.4.3 版本后默认值）             |
+| `task_worker_num`       | TaskWorker 工作进程数                                        | 默认不开启（此参数被注释）          |
+| `task_enable_coroutine` | TaskWorker 工作进程启用协程                                  | 默认不开启（此参数被注释）或 `bool` |
 
 ### 子表 **light_cache**
 
@@ -89,6 +93,23 @@
 | `document_root`  | 静态文件的根目录       | `{WORKING_DIR}/resources/html` |
 | `document_index` | 默认索引的文件名列表   | `["index.html"]`               |
 
+### 子表 onebot
+
+| 配置名称          | 说明                                                         | 默认值 |
+| ----------------- | ------------------------------------------------------------ | ------ |
+| `status`          | 是否开启 OneBot 标准机器人解析功能                           | true   |
+| `single_bot_mode` | 是否开启单机器人模式                                         | false  |
+| `message_level`   | 机器人的 WebSocket 事件在 Swoole 原生事件 `@OnMessageEvent` 中的等级（越高说明越被优先处理） | 99999  |
+
+### 子表 remote_terminal
+
+| 配置名称 | 说明                                                         | 默认值      |
+| -------- | ------------------------------------------------------------ | ----------- |
+| `status` | 是否开启远程终端功能，见 [组件 - 远程终端](/component/remote-terminal) | false       |
+| `host`   | 远程终端监听地址，为安全起见，默认值只允许本地回环地址（127.0.0.1） | `127.0.0.1` |
+| `port`   | 远程终端监听的 TCP 端口                                      | 20002       |
+| `token`  | 远程终端连接的令牌（如果为空（""）则不验证）                 | ""          |
+
 ## 多环境下的配置文件
 
 炸毛框架的配置文件模块支持不同环境下的配置文件，主要结构为 `global.{环境}.php`。在一般情况下，炸毛框架默认从教程引导方式根据指令 `vendor/bin/start server` 启动的框架是不带环境控制的。这章将讲述如何根据不同的环境（development / staging / production）来编写配置文件。

docs/update/config.md

@@ -0,0 +1,25 @@
+# 配置文件变更记录
+
+这里将会记录各个主版本的框架升级后，涉及 `global.php` 的更新日志，你可以根据这里描述的内容与你的旧配置文件进行合并。
+
+## v2.4.0 (build 400)
+- 调整 `$config['modules']['onebot']` 配置项到 `$config['onebot']`，旧版本的此段会向下兼容，建议更新，
+- 新增 `$config['remote_terminal']` 远程终端的配置项，新增此段即可。
+
+更新部分：
+```php
+/** 机器人解析模块，关闭后无法使用如CQCommand等注解(上面的modules即将废弃) */
+$config['onebot'] = [
+    'status' => true,
+    'single_bot_mode' => false,
+    'message_level' => 99999
+];
+
+/** 一个远程简易终端，使用nc直接连接即可，但是不建议开放host为0.0.0.0(远程连接) */
+$config['remote_terminal'] = [
+    'status' => false,
+    'host' => '127.0.0.1',
+    'port' => 20002,
+    'token' => ''
+];
+```

docs/update/v2.md

@@ -1,5 +1,107 @@
 # 更新日志（v2 版本）
 
+## v2.4.3 (build 403)
+
+> 更新时间：2021.3.29
+
+- 新增：swoole 设置配置新增 `max_wait_time` 项，设置等待进程关闭流程最大时间（秒）
+- 新增：常量 `MAIN_WORKER`，值等同于 `worker_cache` 项中的 `worker` 参数（WorkerCache 所在的进程）
+- 新增：`LightCache` 新增 `getExpireTS()` 方法，用于返回项目过期的时间戳
+- 修复：`savePersistence()` 的部分丢失数据的 bug
+- 新增：全局方法 `zm_go()`
+- 修复：2.4.2 版本下的刷屏报错
+- 优化：Ctrl+C 响应机制，启用异步 重启/关闭 措施，防止残留僵尸进程和丢失数据
+
+## v2.4.2 (build 402)
+
+> 更新时间：2021.3.27
+
+- 更改：`WORKING_DIR` 常量的含义
+- 修复：未指定 `--remote-terminal` 参数时还依旧开启远程终端的 bug
+- 删除：`phar_classloader()` 全局方法
+- 更改：持久化存储 LightCache 的逻辑，修复一个愚蠢的容易造成误用的方式
+- 新增：LightCache 方法 `addPersistence()` 和 `removePersistence()`
+- 新增：框架启动短指令 `./zhamao` 或 `php zhamao`
+
+## v2.4.1 (build 401)
+
+> 更新时间：2021.3.25
+
+- 修复：开启框架时导致的报错
+
+## v2.4.0（build 400）
+
+> 更新时间：2021.3.25
+
+- 新增：检查全局配置文件的命令
+- 新增：全局配置文件更新记录
+- 依赖变更：**Swoole 最低版本需要 4.5.0**
+- 优化：reload 和 stop 命令重载和停止框架的逻辑
+- 新增：`$_running_annotation` 变量，可在注解事件中的类使用
+- 新增：远程终端（Remote Terminal），弥补原来删掉的本地终端，通过 nc 命令连接即可
+- 新增：启动参数 `--worker-num`，`--task-worker-num`，`--remote-terminal`
+- 更新：全局配置文件结构
+- 新增：Swoole 计时器报错处理
+- 新增：全局方法（`zm_dump()`，`zm_error()`，`zm_warning()`，`zm_info()`，`zm_success()`，`zm_verbose()`，`zm_debug()`，`zm_config()`）
+- 新增：示例模块的图灵机器人和 at 机器人的处理函数
+- 新增：MessageUtil 工具类新增 `isAtMe(), splitCommand(), matchCommand()` 方法
+- 新增：ProcessManager 进程管理类新增 `workerAction(), sendActionToWorker(), resumeAllWorkerCoroutines()` 方法
+- 优化：CQCommand 的匹配逻辑
+- 新增：支持添加自定义远程终端指令的 `@TerminalCommand` 注解
+- 新增：图灵机器人 API 封装函数
+- 新增：ZMUtil 工具杂项类 `getReloadableFiles()` 函数
+- 新增：`vendor/bin/start systemd:generate` 生成 systemd 配置文件的功能
+- 新增：`vendor/bin/start check:config` 检查配置文件更新的命令
+- 新增：`vendor/bin/start init` 新增 `--force` 参数，覆盖现有文件重新生成
+- 新增：MessageUtil 新增方法：`addShortCommand()`，用于快速添加静态文本问答回复的
+
+以下是需要**手动更新**或**更换新写法**的部分：
+
+- 配置文件 `global.php` 中的 `modules` 字段展开，内置模块的配置一律平铺到外面。详见 [更新日志 - 配置文件变更](/update/config)。
+
+以下是默认机器人直接连接产生的变更：
+
+- 2.4.0 新增了默认回复其他人 at 的消息，如果不需要，请将 `Hello.php` 中的 `changeAt()` 和 `turingAPI()` 方法删除。
+
+## v2.3.5 (build 398)
+
+> 更新时间：2021.3.23
+
+- 修复：MySQL 数据库查询导致的一系列问题
+- 修复：内存泄露问题
+
+> 2.3.2-2.3.4 版本由于操作失误导致代码不完整，请直接使用 2.3.5 即可。
+
+## v2.3.1
+
+> 更新时间：2021.3.18
+
+- 规范代码，修复一个小报错的 bug
+
+## v2.3.0
+
+> 更新时间：2021.3.16
+
+- 新增：MessageUtil 消息处理工具类
+- 新增：TaskManager，封装了 TaskWorker 进程的应用
+- 新增：CQObject，使用 `CQ::getCQ()` 可获取对象形式的 CQ 码解析结果
+- 新增：`@OnTask` 注解，绑定任务函数
+- 新增：RouteManager 路由管理类，可快速添加路由
+- 修复：`ZM_DATA` 和 `DataProvider::getDataFolder()` 返回 false 的问题
+- 优化：关闭显示停止框架后多余的输出信息
+
+注：本次升级建议升级后合并全局配置文件，有一些新加的内容。
+
+## v2.2.11
+
+> 更新时间：2021.3.13
+
+- 新增：内部 ID 版本号（ZM_VERSION_ID）
+- 优化：启动时 log 的等级
+- 移除：终端输入命令
+- 修复：纯 HTTP 服务器的启动 bug
+- 新增：`zm_timer` 的报错处理，防止服务器直接崩掉
+
 ## v2.2.10
 
 > 更新时间：2021.3.8

mkdocs.yml

@@ -72,9 +72,12 @@ nav:
       - 事件分发器: event/event-dispatcher.md
   - 框架组件:
       - 框架组件: component/index.md
-      - 机器人 API: component/robot-api.md
-      - CQ 码（多媒体消息）: component/cqcode.md
       - 上下文: component/context.md
+      - 聊天机器人组件:
+          - 机器人 API: component/robot-api.md
+          - CQ 码（多媒体消息）: component/cqcode.md
+          - 机器人消息处理: component/message-util.md
+          - Token 验证: component/access-token.md
       - 存储:
           - LightCache 轻量缓存: component/light-cache.md
           - MySQL 数据库: component/mysql.md
@@ -82,13 +85,16 @@ nav:
           - ZMAtomic 原子计数器: component/atomics.md
           - SpinLock 自旋锁: component/spin-lock.md
           - 文件管理: component/data-provider.md
+      - HTTP 服务器工具类:
+          - HTTP 和 WebSocket 客户端: component/zmrequest.md
+          - HTTP 路由管理: component/route-manager.md
       - 协程池: component/coroutine-pool.md
       - 单例类: component/singleton-trait.md
       - ZMUtil 杂项: component/zmutil.md
       - 全局方法: component/global-functions.md
-      - HTTP 和 WebSocket 客户端: component/zmrequest.md
       - Console 终端: component/console.md
-      - Token 验证: component/access-token.md
+      - TaskWorker 管理: component/task-worker.md
+      - 远程终端: component/remote-terminal.md
   - 进阶开发:
       - 进阶开发: advanced/index.md
       - 框架剖析: advanced/framework-structure.md
@@ -97,10 +103,12 @@ nav:
       - 内部类文件手册: advanced/inside-class.md
       - 接入 WebSocket 客户端: advanced/connect-ws-client.md
       - 框架多进程: advanced/multi-process.md
+      - TaskWorker 提高并发: advanced/task-worker.md
       - 开发实战教程:
           - 编写管理员才能触发的功能: advanced/example/admin.md
   - FAQ: FAQ.md
   - 更新日志:
       - 更新日志（v2）: update/v2.md
       - 更新日志（v1）: update/v1.md
+      - 配置文件更新日志: update/config.md
   - <u>炸毛框架 v1</u>: https://docs-v1.zhamao.xin/

src/Custom/global_function.php

@@ -1,6 +1,11 @@
 <?php /** @noinspection PhpFullyQualifiedNameUsageInspection */ #plain
 
 //这里写你的全局函数
+/**
+ * @param callable $func
+ * @param string $name
+ * @noinspection PhpUnused
+ */
 function pgo(callable $func, $name = "default") {
     \ZM\Utils\CoroutinePool::go($func, $name);
 }

src/Module/Example/Hello.php

@@ -1,17 +1,24 @@
-<?php
+<?php /** @noinspection PhpMissingReturnTypeInspection */
 
 namespace Module\Example;
 
+use ZM\Annotation\CQ\CQBefore;
+use ZM\Annotation\CQ\CQMessage;
 use ZM\Annotation\Http\Middleware;
 use ZM\Annotation\Swoole\OnCloseEvent;
 use ZM\Annotation\Swoole\OnOpenEvent;
 use ZM\Annotation\Swoole\OnRequestEvent;
+use ZM\API\CQ;
+use ZM\API\TuringAPI;
 use ZM\ConnectionManager\ConnectionObject;
 use ZM\Console\Console;
 use ZM\Annotation\CQ\CQCommand;
 use ZM\Annotation\Http\RequestMapping;
 use ZM\Event\EventDispatcher;
+use ZM\Exception\InterruptException;
+use ZM\Module\QQBot;
 use ZM\Requests\ZMRequest;
+use ZM\Utils\MessageUtil;
 use ZM\Utils\ZMUtil;
 
 /**
@@ -21,6 +28,14 @@ use ZM\Utils\ZMUtil;
  */
 class Hello
 {
+    /*
+     * 默认的图片监听路由对应目录，如需要使用可取消下面的注释，把上面的 /* 换成 /**
+     * @OnStart(-1)
+     */
+    //public function onStart() {
+    //    \ZM\Http\RouteManager::addStaticFileRoute("/images/", \ZM\Utils\DataProvider::getWorkingDir()."/zm_data/images/");
+    //}
+
     /**
      * 使用命令 .reload 发给机器人远程重载，注意将 user_id 换成你自己的 QQ
      * @CQCommand(".reload",user_id=627577391)
@@ -58,6 +73,42 @@ class Hello
         return $obj["hitokoto"] . "\n----「" . $obj["from"] . "」";
     }
 
+    /**
+     * 图灵机器人的内置实现，在tuling123.com申请一个apikey填入下方变量即可。
+     * @CQCommand(start_with="机器人",end_with="机器人",message_type="group")
+     * @CQMessage(message_type="private",level=1)
+     */
+    public function turingAPI() {
+        $user_id = ctx()->getUserId();
+        $api = ""; // 请在这里填入你的图灵机器人的apikey
+        if ($api === "") return false; //如果没有填入apikey则此功能关闭
+        if (($this->_running_annotation ?? null) instanceof CQCommand) {
+            $msg = ctx()->getFullArg("我在！有什么事吗？");
+        } else {
+            $msg = ctx()->getMessage();
+        }
+        ctx()->setMessage($msg);
+        if (MessageUtil::matchCommand($msg, ctx()->getData())->status === false) {
+            return TuringAPI::getTuringMsg($msg, $user_id, $api);
+        } else {
+            QQBot::getInstance()->handle(ctx()->getData(), ctx()->getCache("level") + 1);
+            return true;
+        }
+    }
+
+    /**
+     * 响应at机器人的消息
+     * @CQBefore("message")
+     */
+    public function changeAt() {
+        if (MessageUtil::isAtMe(ctx()->getMessage(), ctx()->getRobotId())) {
+            $msg = str_replace(CQ::at(ctx()->getRobotId()), "", ctx()->getMessage());
+            ctx()->setMessage("机器人" . $msg);
+            Console::info(ctx()->getMessage());
+        }
+        return true;
+    }
+
     /**
      * 一个简单随机数的功能demo
      * 问法1：随机数 1 20
@@ -126,6 +177,7 @@ class Hello
     /**
      * 阻止 Chrome 自动请求 /favicon.ico 导致的多条请求并发和干扰
      * @OnRequestEvent(rule="ctx()->getRequest()->server['request_uri'] == '/favicon.ico'",level=200)
+     * @throws InterruptException
      */
     public function onRequest() {
         EventDispatcher::interrupt();

src/Module/Middleware/TimerMiddleware.php

@@ -24,7 +24,7 @@ class TimerMiddleware implements MiddlewareInterface
      * @HandleBefore()
      * @return bool
      */
-    public function onBefore() {
+    public function onBefore(): bool {
         $this->starttime = microtime(true);
         return true;
     }

src/ZM/API/CQ.php

@@ -1,10 +1,13 @@
-<?php
+<?php /** @noinspection PhpUnused */
+
+/** @noinspection PhpMissingReturnTypeInspection */
 
 
 namespace ZM\API;
 
 
 use ZM\Console\Console;
+use ZM\Entity\CQObject;
 
 class CQ
 {
@@ -305,9 +308,10 @@ class CQ
     /**
      * 获取消息中第一个CQ码
      * @param $msg
-     * @return array|null
+     * @param bool $is_object
+     * @return array|CQObject|null
      */
-    public static function getCQ($msg) {
+    public static function getCQ($msg, $is_object = false) {
         if (($head = mb_strpos($msg, "[CQ:")) !== false) {
             $key_offset = mb_substr($msg, $head);
             $close = mb_strpos($key_offset, "]");
@@ -322,7 +326,7 @@ class CQ
             }
             $cq["start"] = $head;
             $cq["end"] = $close + $head;
-            return $cq;
+            return !$is_object ? $cq : CQObject::fromArray($cq);
         } else {
             return null;
         }
@@ -331,9 +335,10 @@ class CQ
     /**
      * 获取消息中所有的CQ码
      * @param $msg
-     * @return array
+     * @param bool $is_object
+     * @return array|CQObject[]
      */
-    public static function getAllCQ($msg) {
+    public static function getAllCQ($msg, $is_object = false) {
         $cqs = [];
         $offset = 0;
         while (($head = mb_strpos(($submsg = mb_substr($msg, $offset)), "[CQ:")) !== false) {
@@ -352,7 +357,7 @@ class CQ
             $cq["start"] = $offset + $head;
             $cq["end"] = $offset + $tmpmsg + $head;
             $offset += $tmpmsg + 1;
-            $cqs[] = $cq;
+            $cqs[] = (!$is_object ? $cq : CQObject::fromArray($cq));
         }
         return $cqs;
     }

src/ZM/API/CQAPI.php

@@ -29,25 +29,15 @@ trait CQAPI
     public function processWebsocketAPI($connection, $reply, $function = false) {
         $api_id = ZMAtomic::get("wait_msg_id")->add(1);
         $reply["echo"] = $api_id;
-        SpinLock::lock("wait_api");
-        $r = LightCacheInside::get("wait_api", "wait_api");
-        $r[$api_id] = [
-            "data" => $reply,
-            "time" => microtime(true),
-            "self_id" => $connection->getOption("connect_id"),
-            "echo" => $api_id
-        ];
-        LightCacheInside::set("wait_api", "wait_api", $r);
-        SpinLock::unlock("wait_api");
         if (server()->push($connection->getFd(), json_encode($reply))) {
             if ($function === true) {
-                return CoMessage::yieldByWS($r[$api_id], ["echo"], 60);
-            } else {
-                SpinLock::lock("wait_api");
-                $r = LightCacheInside::get("wait_api", "wait_api");
-                unset($r[$api_id]);
-                LightCacheInside::set("wait_api", "wait_api", $r);
-                SpinLock::unlock("wait_api");
+                $obj = [
+                    "data" => $reply,
+                    "time" => microtime(true),
+                    "self_id" => $connection->getOption("connect_id"),
+                    "echo" => $api_id
+                ];
+                return CoMessage::yieldByWS($obj, ["echo"], 60);
             }
             return true;
         } else {
@@ -75,10 +65,11 @@ trait CQAPI
      * @return bool
      * @noinspection PhpUnusedParameterInspection
      */
-    public function processHttpAPI($connection, $reply, $function = null) {
+    public function processHttpAPI($connection, $reply, $function = null): bool {
         return false;
     }
 
+    /** @noinspection PhpMissingReturnTypeInspection */
     public function __call($name, $arguments) {
         return false;
     }

src/ZM/API/TuringAPI.php

@@ -0,0 +1,118 @@
+<?php
+
+
+namespace ZM\API;
+
+
+use Swoole\Coroutine\Http\Client;
+use ZM\Console\Console;
+
+class TuringAPI
+{
+    /**
+     * 请求图灵API，返回图灵的消息
+     * @param $msg
+     * @param $user_id
+     * @param $api
+     * @return string
+     */
+    public static function getTuringMsg($msg, $user_id, $api) {
+        $origin = $msg;
+        if (($cq = CQ::getCQ($msg)) !== null) {//如有CQ码则去除
+            if ($cq["type"] == "image") {
+                $url = $cq["params"]["url"];
+                $msg = str_replace(mb_substr($msg, $cq["start"], $cq["end"] - $cq["start"] + 1), "", $msg);
+            }
+            $msg = trim($msg);
+        }
+        //构建将要发送的json包给图灵
+        $content = [
+            "reqType" => 0,
+            "userInfo" => [
+                "apiKey" => $api,
+                "userId" => $user_id
+            ]
+        ];
+        if ($msg != "") {
+            $content["perception"]["inputText"]["text"] = $msg;
+        }
+        $msg = trim($msg);
+        if (mb_strlen($msg) < 1 && !isset($url)) return "请说出你想说的话";
+        if (isset($url)) {
+            $content["perception"]["inputImage"]["url"] = $url;
+            $content["reqType"] = 1;
+        }
+        if (!isset($content["perception"])) return "请说出你想说的话";
+        $client = new Client("openapi.tuling123.com", 80);
+        $client->setHeaders(["Content-type" => "application/json"]);
+        $client->post("/openapi/api/v2", json_encode($content, JSON_UNESCAPED_UNICODE));
+        $api_return = json_decode($client->body, true);
+        if (!isset($api_return["intent"]["code"])) return "XD 哎呀，我脑子突然短路了，请稍后再问我吧！";
+        $status = self::getResultStatus($api_return);
+        if ($status !== true) {
+            if ($status == "err:输入文本内容超长(上限150)") return "你的话太多了！！！";
+            if ($api_return["intent"]["code"] == 4003) {
+                return "哎呀，我刚才有点走神了，可能忘记你说什么了，可以重说一遍吗";
+            }
+            Console::error("图灵机器人发送错误！\n错误原始内容：" . $origin . "\n来自：" . $user_id . "\n错误信息：" . $status);
+            //echo json_encode($r, 128|256);
+            return "哎呀，我刚才有点走神了，要不一会儿换一种问题试试？";
+        }
+        $result = $api_return["results"];
+        //Console::info(Console::setColor(json_encode($result, 128 | 256), "green"));
+        $final = "";
+        foreach ($result as $k => $v) {
+            switch ($v["resultType"]) {
+                case "url":
+                    $final .= "\n" . $v["values"]["url"];
+                    break;
+                case "text":
+                    $final .= "\n" . $v["values"]["text"];
+                    break;
+                case "image":
+                    $final .= "\n" . CQ::image($v["values"]["image"]);
+                    break;
+            }
+        }
+        return trim($final);
+    }
+
+    public static function getResultStatus($r) {
+        switch ($r["intent"]["code"]) {
+            case 5000:
+                return "err:无解析结果";
+            case 4000:
+            case 6000:
+                return "err:暂不支持该功能";
+            case 4001:
+                return "err:加密方式错误";
+            case 4005:
+            case 4002:
+                return "err:无功能权限";
+            case 4003:
+                return "err:该apikey没有可用请求次数";
+            case 4007:
+                return "err:apikey不合法";
+            case 4100:
+                return "err:userid获取失败";
+            case 4200:
+                return "err:上传格式错误";
+            case 4300:
+                return "err:批量操作超过限制";
+            case 4400:
+                return "err:没有上传合法userid";
+            case 4500:
+                return "err:userid申请个数超过限制";
+            case 4600:
+                return "err:输入内容为空";
+            case 4602:
+                return "err:输入文本内容超长(上限150)";
+            case 7002:
+                return "err:上传信息失败";
+            case 8008:
+                return "err:服务器错误";
+            default:
+                return true;
+        }
+    }
+}

src/ZM/API/ZMRobot.php

@@ -1,4 +1,6 @@
-<?php /** @noinspection PhpUnused */
+<?php /** @noinspection PhpMissingReturnTypeInspection */
+
+/** @noinspection PhpUnused */
 
 
 namespace ZM\API;

src/ZM/Annotation/AnnotationBase.php

@@ -12,7 +12,7 @@ abstract class AnnotationBase
 
     public $class;
 
-    public function __toString() {
+    public function __toString(): string {
         $str = __CLASS__ . ": ";
         foreach ($this as $k => $v) {
             $str .= "\n\t" . $k . " => ";

src/ZM/Annotation/AnnotationParser.php

@@ -125,10 +125,7 @@ class AnnotationParser
         Console::debug("解析注解完毕！");
     }
 
-    /**
-     * @return array
-     */
-    public function generateAnnotationEvents() {
+    public function generateAnnotationEvents(): array {
         $o = [];
         foreach ($this->annotation_map as $module => $obj) {
             foreach (($obj["class_annotations"] ?? []) as $class_annotation) {
@@ -151,17 +148,17 @@ class AnnotationParser
     /**
      * @return array
      */
-    public function getMiddlewares() { return $this->middlewares; }
+    public function getMiddlewares(): array { return $this->middlewares; }
 
     /**
      * @return array
      */
-    public function getMiddlewareMap() { return $this->middleware_map; }
+    public function getMiddlewareMap(): array { return $this->middleware_map; }
 
     /**
      * @return array
      */
-    public function getReqMapping() { return $this->req_mapping; }
+    public function getReqMapping(): array { return $this->req_mapping; }
 
     /**
      * @param $path
@@ -171,7 +168,7 @@ class AnnotationParser
 
     //private function below
 
-    private function registerMiddleware(MiddlewareClass $vs, ReflectionClass $reflection_class) {
+    private function registerMiddleware(MiddlewareClass $vs, ReflectionClass $reflection_class): array {
         $result = [
             "class" => "\\" . $reflection_class->getName(),
             "name" => $vs->name

src/ZM/Annotation/CQ/CQAfter.php

@@ -26,7 +26,7 @@ class CQAfter extends AnnotationBase implements Level
     /**
      * @return mixed
      */
-    public function getLevel() {
+    public function getLevel(): int {
         return $this->level;
     }
 

src/ZM/Annotation/CQ/CQBefore.php

@@ -28,7 +28,7 @@ class CQBefore extends AnnotationBase implements Level
     /**
      * @return mixed
      */
-    public function getLevel() {
+    public function getLevel(): int {
         return $this->level;
     }
 

src/ZM/Annotation/CQ/CQMessage.php

@@ -32,7 +32,7 @@ class CQMessage extends AnnotationBase implements Level
     /** @var int */
     public $level = 20;
 
-    public function getLevel() { return $this->level; }
+    public function getLevel(): int { return $this->level; }
 
     public function setLevel(int $level) {
         $this->level = $level;

src/ZM/Annotation/CQ/CQMetaEvent.php

@@ -27,7 +27,7 @@ class CQMetaEvent extends AnnotationBase implements Level
     /**
      * @return mixed
      */
-    public function getLevel() { return $this->level; }
+    public function getLevel(): int { return $this->level; }
 
     /**
      * @param int $level

src/ZM/Annotation/Command/TerminalCommand.php

@@ -0,0 +1,30 @@
+<?php
+
+
+namespace ZM\Annotation\Command;
+
+use Doctrine\Common\Annotations\Annotation\Required;
+use Doctrine\Common\Annotations\Annotation\Target;
+use ZM\Annotation\AnnotationBase;
+
+/**
+ * Class TerminalCommand
+ * @package ZM\Annotation\Command
+ * @Annotation
+ * @Target("METHOD")
+ */
+class TerminalCommand extends AnnotationBase
+{
+    /**
+     * @var string
+     * @Required()
+     */
+    public $command;
+
+    public $alias = '';
+
+    /**
+     * @var string
+     */
+    public $description = "";
+}

src/ZM/Annotation/Swoole/OnTask.php

@@ -0,0 +1,36 @@
+<?php
+
+
+namespace ZM\Annotation\Swoole;
+
+use Doctrine\Common\Annotations\Annotation\Required;
+use Doctrine\Common\Annotations\Annotation\Target;
+use ZM\Annotation\AnnotationBase;
+use ZM\Annotation\Interfaces\Rule;
+
+/**
+ * Class OnTask
+ * @package ZM\Annotation\Swoole
+ * @Annotation
+ * @Target("METHOD")
+ */
+class OnTask extends AnnotationBase implements Rule
+{
+    /**
+     * @var string
+     * @Required()
+     */
+    public $task_name;
+
+    /**
+     * @var string
+     */
+    public $rule = "";
+
+    /**
+     * @return mixed
+     */
+    public function getRule(): string {
+        return $this->rule;
+    }
+}

src/ZM/Annotation/Swoole/OnTaskEvent.php

@@ -0,0 +1,16 @@
+<?php
+
+
+namespace ZM\Annotation\Swoole;
+
+use Doctrine\Common\Annotations\Annotation\Target;
+
+/**
+ * Class OnTaskEvent
+ * @package ZM\Annotation\Swoole
+ * @Annotation
+ * @Target("METHOD")
+ */
+class OnTaskEvent extends OnSwooleEventBase
+{
+}

src/ZM/Annotation/Swoole/SwooleHandler.php

@@ -12,7 +12,7 @@ use ZM\Annotation\AnnotationBase;
  * Class SwooleHandler
  * @package ZM\Annotation\Swoole
  * @Annotation
- * @Target("METHOD")
+ * @Target("ALL")
  */
 class SwooleHandler extends AnnotationBase
 {

src/ZM/Command/BuildCommand.php

@@ -26,7 +26,7 @@ class BuildCommand extends Command
         // ...
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         $this->output = $output;
         $target_dir = $input->getOption("target") ?? (__DIR__ . '/../../../resources/');
         if (mb_strpos($target_dir, "../")) $target_dir = realpath($target_dir);

src/ZM/Command/CheckConfigCommand.php

@@ -0,0 +1,60 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class CheckConfigCommand extends Command
+{
+    protected static $defaultName = 'check:config';
+
+    private $need_update = false;
+
+    protected function configure() {
+        $this->setDescription("检查配置文件是否和框架当前版本有更新");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        if (LOAD_MODE !== 1) {
+            $output->writeln("<error>仅限在Composer依赖模式中使用此命令！</error>");
+            return Command::FAILURE;
+        }
+        $current_cfg = getcwd() . "/config/";
+        $remote_cfg = include_once FRAMEWORK_ROOT_DIR . "/config/global.php";
+        if (file_exists($current_cfg . "global.php")) {
+            $this->check($remote_cfg, "global.php", $output);
+        }
+        if (file_exists($current_cfg . "global.development.php")) {
+            $this->check($remote_cfg, "global.development.php", $output);
+        }
+        if (file_exists($current_cfg . "global.staging.php")) {
+            $this->check($remote_cfg, "global.staging.php", $output);
+        }
+        if (file_exists($current_cfg . "global.production.php")) {
+            $this->check($remote_cfg, "global.production.php", $output);
+        }
+        if ($this->need_update === true) {
+            $output->writeln("<comment>有配置文件需要更新，详情见文档 `https://framework.zhamao.xin/update/config.md`</comment>");
+        } else {
+            $output->writeln("<info>配置文件暂无更新！</info>");
+        }
+
+        return Command::SUCCESS;
+    }
+
+    /**
+     * @noinspection PhpIncludeInspection
+     */
+    private function check($remote, $local, OutputInterface $out) {
+        $local_file = include_once getcwd() . "/config/".$local;
+        foreach($remote as $k => $v) {
+            if (!isset($local_file[$k])) {
+                $out->writeln("<comment>配置文件 ".$local . " 需要更新！(当前配置文件缺少 `$k` 字段配置)</comment>");
+                $this->need_update = true;
+            }
+        }
+    }
+}

src/ZM/Command/DaemonCommand.php

@@ -13,7 +13,7 @@ abstract class DaemonCommand extends Command
 {
     protected $daemon_file = null;
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         $pid_path = DataProvider::getWorkingDir() . "/.daemon_pid";
         if (!file_exists($pid_path)) {
             $output->writeln("<comment>没有检测到正在运行的守护进程！</comment>");

src/ZM/Command/DaemonReloadCommand.php

@@ -15,7 +15,7 @@ class DaemonReloadCommand extends DaemonCommand
         $this->setDescription("重载守护进程下的用户代码（仅限--daemon模式可用）");
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         parent::execute($input, $output);
         system("kill -USR1 " . intval($this->daemon_file["pid"]));
         $output->writeln("<info>成功重载！</info>");

src/ZM/Command/DaemonStatusCommand.php

@@ -15,7 +15,7 @@ class DaemonStatusCommand extends DaemonCommand
         $this->setDescription("查看守护进程框架的运行状态（仅限--daemon模式可用）");
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         parent::execute($input, $output);
         $output->writeln("<info>框架运行中，pid：" . $this->daemon_file["pid"] . "</info>");
         $output->writeln("<comment>----- 以下是stdout内容 -----</comment>");

src/ZM/Command/DaemonStopCommand.php

@@ -16,9 +16,9 @@ class DaemonStopCommand extends DaemonCommand
         $this->setDescription("停止守护进程下运行的框架（仅限--daemon模式可用）");
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         parent::execute($input, $output);
-        system("kill -TERM " . intval($this->daemon_file["pid"]));
+        system("kill -INT " . intval($this->daemon_file["pid"]));
         unlink(DataProvider::getWorkingDir() . "/.daemon_pid");
         $output->writeln("<info>成功停止！</info>");
         return Command::SUCCESS;

src/ZM/Command/InitCommand.php

@@ -6,6 +6,7 @@ namespace ZM\Command;
 use Phar;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 
 class InitCommand extends Command
@@ -26,16 +27,20 @@ class InitCommand extends Command
 
     protected function configure() {
         $this->setDescription("Initialize framework starter | 初始化框架运行的基础文件");
+        $this->setDefinition([
+            new InputOption("force", "F", null, "强制重制，覆盖现有文件")
+        ]);
         $this->setHelp("此命令将会解压以下文件到项目的根目录：\n" . implode("\n", $this->getExtractFiles()));
         // ...
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         if (LOAD_MODE === 1) { // 从composer依赖而来的项目模式，最基本的需要初始化的模式
             $output->writeln("<comment>Initializing files</comment>");
-            $base_path = LOAD_MODE_COMPOSER_PATH;
+            $base_path = WORKING_DIR;
+            $args = $input->getOption("force");
             foreach ($this->extract_files as $file) {
-                if (!file_exists($base_path . $file)) {
+                if (!file_exists($base_path . $file) || $args) {
                     $info = pathinfo($file);
                     @mkdir($base_path . $info["dirname"], 0777, true);
                     echo "Copying " . $file . PHP_EOL;
@@ -45,6 +50,12 @@ class InitCommand extends Command
                     echo "Skipping " . $file . " , file exists." . PHP_EOL;
                 }
             }
+            echo "Copying ./zhamao\n";
+            file_put_contents(
+                $base_path."/zhamao",
+                "#!/usr/bin/env php\n<?php require_once \"vendor/autoload.php\";(new ZM\ConsoleApplication(\"zhamao-framework\"))->initEnv()->run();"
+            );
+            chmod($base_path."/zhamao", 0755);
             $autoload = [
                 "psr-4" => [
                     "Module\\" => "src/Module",
@@ -67,8 +78,8 @@ class InitCommand extends Command
                     }
                 }
                 file_put_contents($base_path . "/composer.json", json_encode($composer, 64 | 128 | 256));
-                $output->writeln("<info>Executing composer update command</info>");
-                exec("composer update");
+                $output->writeln("<info>Executing composer command: `composer dump-autoload`</info>");
+                exec("composer dump-autoload");
                 echo PHP_EOL;
             } else {
                 echo("Error occurred. Please check your updates.\n");
@@ -96,7 +107,7 @@ class InitCommand extends Command
         return Command::FAILURE;
     }
 
-    private function getExtractFiles() {
+    private function getExtractFiles(): array {
         return $this->extract_files;
     }
 }

src/ZM/Command/PureHttpCommand.php

@@ -5,7 +5,6 @@ namespace ZM\Command;
 
 
 use Swoole\Atomic;
-use Swoole\Coroutine;
 use Swoole\Http\Request;
 use Swoole\Http\Response;
 use Swoole\Http\Server;
@@ -36,7 +35,7 @@ class PureHttpCommand extends Command
         // ...
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         $tty_width = explode(" ", trim(exec("stty size")))[1];
         if (realpath($input->getArgument('dir') ?? '.') === false) {
             $output->writeln("<error>Directory error(" . ($input->getArgument('dir') ?? '.') . "): no such file or directory.</error>");

src/ZM/Command/RunServerCommand.php

@@ -23,8 +23,11 @@ class RunServerCommand extends Command
             new InputOption("log-error", null, null, "调整消息等级到error (log-level=0)"),
             new InputOption("log-theme", null, InputOption::VALUE_REQUIRED, "改变终端的主题配色"),
             new InputOption("disable-console-input", null, null, "禁止终端输入内容 (废弃)"),
+            new InputOption("remote-terminal", null, null, "启用远程终端，配置使用global.php中的"),
             new InputOption("disable-coroutine", null, null, "关闭协程Hook"),
             new InputOption("daemon", null, null, "以守护进程的方式运行框架"),
+            new InputOption("worker-num", null, InputOption::VALUE_REQUIRED, "启动框架时运行的 Worker 进程数量"),
+            new InputOption("task-worker-num", null, InputOption::VALUE_REQUIRED, "启动框架时运行的 TaskWorker 进程数量"),
             new InputOption("watch", null, null, "监听 src/ 目录的文件变化并热更新"),
             new InputOption("show-php-ver", null, null, "启动时显示PHP和Swoole版本"),
             new InputOption("env", null, InputOption::VALUE_REQUIRED, "设置环境类型 (production, development, staging)"),
@@ -33,7 +36,7 @@ class RunServerCommand extends Command
         $this->setHelp("直接运行可以启动");
     }
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output): int {
         if (($opt = $input->getOption("env")) !== null) {
             if (!in_array($opt, ["production", "staging", "development", ""])) {
                 $output->writeln("<error> \"--env\" option only accept production, development, staging and [empty] ! </error>");

src/ZM/Command/SystemdCommand.php

@@ -13,8 +13,30 @@ class SystemdCommand extends Command
     // the name of the command (the part after "bin/console")
     protected static $defaultName = 'systemd:generate';
 
-    protected function execute(InputInterface $input, OutputInterface $output) {
-        //TODO: 写一个生成systemd配置的功能，给2.0
+    protected function configure() {
+        $this->setDescription("生成框架的 systemd 配置文件");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $path = $this->generate();
+        $output->writeln("<info>成功生成 systemd 文件，位置：".$path."</info>");
+        $output->writeln("<info>有关如何使用 systemd 配置文件，请访问 `https://github.com/zhamao-robot/zhamao-framework/issues/36`</info>");
         return Command::SUCCESS;
     }
+
+    private function generate() {
+        $s = "[Unit]\nDescription=zhamao-framework Daemon\nAfter=rc-local.service\n\n[Service]\nType=simple";
+        $s .= "\nUser=" . exec("whoami");
+        $s .= "\nGroup=" . exec("groups | awk '{print $1}'");
+        $s .= "\nWorkingDirectory=" . getcwd();
+        if (LOAD_MODE == 1) {
+            $s .= "\nExecStart=" . getcwd() . "/vendor/bin/start server";
+        } else {
+            $s .= "\nExecStart=" . getcwd() . "/bin/start server";
+        }
+        $s .= "\nRestart=always\n\n[Install]\nWantedBy=multi-user.target\n";
+        @mkdir(getcwd() . "/resources/");
+        file_put_contents(getcwd() . "/resources/zhamao.service", $s);
+        return getcwd() . "/resources/zhamao.service";
+    }
 }

src/ZM/ConsoleApplication.php

@@ -5,6 +5,7 @@ namespace ZM;
 
 
 use Exception;
+use ZM\Command\CheckConfigCommand;
 use ZM\Command\DaemonReloadCommand;
 use ZM\Command\DaemonStatusCommand;
 use ZM\Command\DaemonStopCommand;
@@ -14,12 +15,12 @@ use ZM\Command\RunServerCommand;
 use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
-use ZM\Utils\DataProvider;
+use ZM\Command\SystemdCommand;
 
 class ConsoleApplication extends Application
 {
-    const VERSION_ID = 384;
-    const VERSION = "2.2.11";
+    const VERSION_ID = 403;
+    const VERSION = "2.4.3";
 
     public function __construct(string $name = 'UNKNOWN') {
         define("ZM_VERSION_ID", self::VERSION_ID);
@@ -27,35 +28,24 @@ class ConsoleApplication extends Application
         parent::__construct($name, ZM_VERSION);
     }
 
-    public function initEnv() {
+    public function initEnv($with_default_cmd = ""): ConsoleApplication {
         $this->selfCheck();
 
-        if (!is_dir(__DIR__ . '/../../vendor')) {
-            define("LOAD_MODE", 1); // composer项目模式
-            define("LOAD_MODE_COMPOSER_PATH", getcwd());
-        } else  {
-            define("LOAD_MODE", 0); // 源码模式
-        }
-
-        //if (LOAD_MODE === 0) $this->add(new BuildCommand()); //只有在git源码模式才能使用打包指令
-        if (LOAD_MODE === 0) define("WORKING_DIR", getcwd());
-        elseif (LOAD_MODE == 1) define("WORKING_DIR", realpath(__DIR__ . "/../../"));
-        if (file_exists(DataProvider::getWorkingDir() . "/vendor/autoload.php")) {
-            /** @noinspection PhpIncludeInspection */
-            require_once DataProvider::getWorkingDir() . "/vendor/autoload.php";
-        }
+        define("WORKING_DIR", getcwd());
+        define("LOAD_MODE", is_dir(WORKING_DIR . "/src/ZM") ? 0 : 1);
+        define("FRAMEWORK_ROOT_DIR", realpath(__DIR__ . "/../../"));
         if (LOAD_MODE == 0) {
-            $composer = json_decode(file_get_contents(DataProvider::getWorkingDir() . "/composer.json"), true);
+            $composer = json_decode(file_get_contents(WORKING_DIR . "/composer.json"), true);
             if (!isset($composer["autoload"]["psr-4"]["Module\\"])) {
                 echo "框架源码模式需要在autoload文件中添加Module目录为自动加载，是否添加？[Y/n] ";
                 $r = strtolower(trim(fgets(STDIN)));
                 if ($r === "" || $r === "y") {
                     $composer["autoload"]["psr-4"]["Module\\"] = "src/Module";
                     $composer["autoload"]["psr-4"]["Custom\\"] = "src/Custom";
-                    $r = file_put_contents(DataProvider::getWorkingDir() . "/composer.json", json_encode($composer, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+                    $r = file_put_contents(WORKING_DIR . "/composer.json", json_encode($composer, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
                     if ($r !== false) {
-                        echo "成功添加！请重新进行 composer update ！\n";
-                        exit(1);
+                        echo "成功添加！请运行 composer dump-autoload ！\n";
+                        exit(0);
                     } else {
                         echo "添加失败！请按任意键继续！";
                         fgets(STDIN);
@@ -73,15 +63,15 @@ class ConsoleApplication extends Application
             new DaemonStopCommand(),
             new RunServerCommand(), //运行主服务的指令控制器
             new InitCommand(), //初始化用的，用于项目初始化和phar初始化
-            new PureHttpCommand() //纯HTTP服务器指令
+            new PureHttpCommand(), //纯HTTP服务器指令
+            new SystemdCommand()
         ]);
-        /*
-        $command_register = ZMConfig::get("global", "command_register_class") ?? [];
-        foreach ($command_register as $v) {
-            $obj = new $v();
-            if (!($obj instanceof Command)) throw new TypeError("Command register class must be extended by Symfony\\Component\\Console\\Command\\Command");
-            $this->add($obj);
-        }*/
+        if (LOAD_MODE === 1) {
+            $this->add(new CheckConfigCommand());
+        }
+        if (!empty($with_default_cmd)) {
+            $this->setDefaultCommand($with_default_cmd);
+        }
         return $this;
     }
 
@@ -90,7 +80,7 @@ class ConsoleApplication extends Application
      * @param OutputInterface|null $output
      * @return int
      */
-    public function run(InputInterface $input = null, OutputInterface $output = null) {
+    public function run(InputInterface $input = null, OutputInterface $output = null): int {
         try {
             return parent::run($input, $output);
         } catch (Exception $e) {
@@ -98,9 +88,9 @@ class ConsoleApplication extends Application
         }
     }
 
-    private function selfCheck() {
+    private function selfCheck(): bool {
         if (!extension_loaded("swoole")) die("Can not find swoole extension.\nSee: https://github.com/zhamao-robot/zhamao-framework/issues/19\n");
-        if (version_compare(SWOOLE_VERSION, "4.4.13") == -1) die("You must install swoole version >= 4.4.13 !");
+        if (version_compare(SWOOLE_VERSION, "4.5.0") == -1) die("You must install swoole version >= 4.5.0 !");
         if (version_compare(PHP_VERSION, "7.2") == -1) die("PHP >= 7.2 required.");
         return true;
     }

src/ZM/Context/Context.php

@@ -8,11 +8,12 @@ use Co;
 use Exception;
 use Swoole\Http\Request;
 use Swoole\WebSocket\Frame;
-use swoole_server;
+use Swoole\WebSocket\Server;
 use ZM\ConnectionManager\ConnectionObject;
 use ZM\ConnectionManager\ManagerGM;
 use ZM\Console\Console;
 use ZM\Event\EventDispatcher;
+use ZM\Exception\InterruptException;
 use ZM\Exception\InvalidArgumentException;
 use ZM\Exception\WaitTimeoutException;
 use ZM\Http\Response;
@@ -27,19 +28,19 @@ class Context implements ContextInterface
     public function __construct($cid) { $this->cid = $cid; }
 
     /**
-     * @return swoole_server|null
+     * @return Server
      */
-    public function getServer() { return self::$context[$this->cid]["server"] ?? server(); }
+    public function getServer(): ?Server { return self::$context[$this->cid]["server"] ?? server(); }
 
     /**
      * @return Frame|null
      */
-    public function getFrame() { return self::$context[$this->cid]["frame"] ?? null; }
+    public function getFrame(): ?Frame { return self::$context[$this->cid]["frame"] ?? null; }
 
-    public function getFd() { return self::$context[$this->cid]["fd"] ?? $this->getFrame()->fd ?? null; }
+    public function getFd(): ?int { return self::$context[$this->cid]["fd"] ?? $this->getFrame()->fd ?? null; }
 
     /**
-     * @return array|null
+     * @return mixed
      */
     public function getData() { return self::$context[$this->cid]["data"] ?? null; }
 
@@ -48,25 +49,25 @@ class Context implements ContextInterface
     /**
      * @return Request|null
      */
-    public function getRequest() { return self::$context[$this->cid]["request"] ?? null; }
+    public function getRequest(): ?Request { return self::$context[$this->cid]["request"] ?? null; }
 
     /**
      * @return Response|null
      */
-    public function getResponse() { return self::$context[$this->cid]["response"] ?? null; }
+    public function getResponse(): ?Response { return self::$context[$this->cid]["response"] ?? null; }
 
-    /** @return ConnectionObject|null */
+    /** @return ConnectionObject|null|Response */
     public function getConnection() { return ManagerGM::get($this->getFd()); }
 
     /**
      * @return int|null
      */
-    public function getCid() { return $this->cid; }
+    public function getCid(): ?int { return $this->cid; }
 
     /**
      * @return ZMRobot|null
      */
-    public function getRobot() {
+    public function getRobot(): ?ZMRobot {
         $conn = ManagerGM::get($this->getFrame()->fd);
         return $conn instanceof ConnectionObject ? new ZMRobot($conn) : null;
     }
@@ -87,7 +88,7 @@ class Context implements ContextInterface
 
     public function setDiscussId($id) { self::$context[$this->cid]["data"]["discuss_id"] = $id; }
 
-    public function getMessageType() { return $this->getData()["message_type"] ?? null; }
+    public function getMessageType(): ?string { return $this->getData()["message_type"] ?? null; }
 
     public function setMessageType($type) { self::$context[$this->cid]["data"]["message_type"] = $type; }
 
@@ -104,6 +105,7 @@ class Context implements ContextInterface
      * @param $msg
      * @param bool $yield
      * @return mixed
+     * @noinspection PhpMissingReturnTypeInspection
      */
     public function reply($msg, $yield = false) {
         $data = $this->getData();
@@ -131,6 +133,12 @@ class Context implements ContextInterface
         }
     }
 
+    /**
+     * @param $msg
+     * @param false $yield
+     * @return mixed|void
+     * @throws InterruptException
+     */
     public function finalReply($msg, $yield = false) {
         self::$context[$this->cid]["cache"]["block_continue"] = true;
         if ($msg != "") $this->reply($msg, $yield);
@@ -144,6 +152,7 @@ class Context implements ContextInterface
      * @return string
      * @throws InvalidArgumentException
      * @throws WaitTimeoutException
+     * @noinspection PhpMissingReturnTypeInspection
      */
     public function waitMessage($prompt = "", $timeout = 600, $timeout_prompt = "") {
         if (!isset($this->getData()["user_id"], $this->getData()["message"], $this->getData()["self_id"]))
@@ -207,7 +216,7 @@ class Context implements ContextInterface
      * @throws WaitTimeoutException
      */
     public function getArgs($mode, $prompt_msg) {
-        $arg = ctx()->getCache("match");
+        $arg = ctx()->getCache("match") ?? [];
         switch ($mode) {
             case ZM_MATCH_ALL:
                 $p = $arg;
@@ -258,6 +267,7 @@ class Context implements ContextInterface
      */
     public function getNumArg($prompt_msg = "") { return $this->getArgs(ZM_MATCH_NUMBER, $prompt_msg); }
 
+    /** @noinspection PhpMissingReturnTypeInspection */
     public function cloneFromParent() {
         set_coroutine_params(self::$context[Co::getPcid()] ?? self::$context[$this->cid]);
         return context();

src/ZM/Context/ContextInterface.php

@@ -1,4 +1,4 @@
-<?php
+<?php /** @noinspection PhpMissingReturnTypeInspection */
 
 
 namespace ZM\Context;

src/ZM/DB/DB.php

@@ -1,4 +1,6 @@
-<?php /** @noinspection PhpComposerExtensionStubsInspection */
+<?php /** @noinspection PhpUnused */
+
+/** @noinspection PhpComposerExtensionStubsInspection */
 
 
 namespace ZM\DB;
@@ -34,7 +36,7 @@ class DB
      * @return Table
      * @throws DbException
      */
-    public static function table($table_name) {
+    public static function table($table_name): Table {
         if (Table::getTableInstance($table_name) === null) {
             if (in_array($table_name, self::$table_list))
                 return new Table($table_name);
@@ -60,7 +62,7 @@ class DB
      * @return bool
      * @throws DbException
      */
-    public static function unprepared($line) {
+    public static function unprepared($line): bool {
         try {
             $conn = SqlPoolStorage::$sql_pool->get();
             if ($conn === false) {
@@ -134,7 +136,7 @@ class DB
         }
     }
 
-    public static function isTableExists($table) {
+    public static function isTableExists($table): bool {
         return in_array($table, self::$table_list);
     }
 }

src/ZM/DB/SelectBody.php

@@ -32,7 +32,7 @@ class SelectBody
     /**
      * @throws DbException
      */
-    public function count() {
+    public function count(): int {
         $this->select_thing = ["count(*)"];
         $str = $this->queryPrepare();
         $this->result = DB::rawQuery($str[0], $str[1]);
@@ -81,7 +81,7 @@ class SelectBody
 
     public function getResult() { return $this->result; }
 
-    public function equals(SelectBody $body) {
+    public function equals(SelectBody $body): bool {
         if ($this->select_thing != $body->getSelectThing()) return false;
         elseif ($this->where_thing == $body->getWhereThing()) return false;
         else return true;
@@ -95,9 +95,9 @@ class SelectBody
     /**
      * @return array
      */
-    public function getWhereThing() { return $this->where_thing; }
+    public function getWhereThing(): array { return $this->where_thing; }
 
-    private function queryPrepare() {
+    private function queryPrepare(): array {
         $msg = "SELECT " . implode(", ", $this->select_thing) . " FROM " . $this->table->getTableName();
         $sql = $this->table->paintWhereSQL($this->where_thing['='] ?? [], '=');
         if ($sql[0] != '') {

src/ZM/DB/Table.php

@@ -1,4 +1,6 @@
-<?php
+<?php /** @noinspection PhpUnused */
+
+/** @noinspection PhpMissingReturnTypeInspection */
 
 
 namespace ZM\DB;
@@ -59,7 +61,7 @@ class Table
             if ($msg == "") {
                 $msg .= $k . " $operator ? ";
             } else {
-                $msg .= "AND " . $k . " $operator ?";
+                $msg .= " AND " . $k . " $operator ?";
             }
             $param[] = $v;
         }

src/ZM/DB/WhereBody.php

@@ -1,4 +1,4 @@
-<?php
+<?php /** @noinspection PhpMissingReturnTypeInspection */
 
 
 namespace ZM\DB;

src/ZM/Entity/CQObject.php

@@ -0,0 +1,26 @@
+<?php
+
+
+namespace ZM\Entity;
+
+
+class CQObject
+{
+    public $type;
+    public $params;
+    public $start;
+    public $end;
+
+    public function __construct($type = "", $params = [], $start = 0, $end = 0) {
+        if ($type !== "") {
+            $this->type = $type;
+            $this->params = $params;
+            $this->start = $start;
+            $this->end = $end;
+        }
+    }
+
+    public static function fromArray($arr): CQObject {
+        return new CQObject($arr["type"], $arr["params"] ?? [], $arr["start"], $arr["end"]);
+    }
+}

src/ZM/Entity/MatchResult.php

@@ -0,0 +1,17 @@
+<?php
+
+
+namespace ZM\Entity;
+
+
+use ZM\Annotation\CQ\CQCommand;
+
+class MatchResult
+{
+    /** @var bool */
+    public $status = false;
+    /** @var CQCommand|null */
+    public $object = null;
+    /** @var array */
+    public $match = [];
+}

src/ZM/Event/EventDispatcher.php

@@ -1,4 +1,4 @@
-<?php
+<?php /** @noinspection PhpUnused */
 
 
 namespace ZM\Event;
@@ -9,7 +9,6 @@ use Error;
 use Exception;
 use ZM\Console\Console;
 use ZM\Exception\InterruptException;
-use ZM\Exception\ZMException;
 use ZM\Store\LightCacheInside;
 use ZM\Store\Lock\SpinLock;
 use ZM\Store\ZMAtomic;
@@ -32,7 +31,7 @@ class EventDispatcher
     /** @var bool */
     private $log = false;
     /** @var int */
-    private $eid = 0;
+    private $eid;
     /** @var int */
     public $status = self::STATUS_NORMAL;
     /** @var mixed */
@@ -64,22 +63,18 @@ class EventDispatcher
 
     public function __construct(string $class = '') {
         $this->class = $class;
-        try {
-            $this->eid = ZMAtomic::get("_event_id")->add(1);
-            $list = LightCacheInside::get("wait_api", "event_trace");
-        } catch (ZMException $e) {
-            $list = [];
-        }
+        $this->eid = ZMAtomic::get("_event_id")->add(1);
+        $list = LightCacheInside::get("wait_api", "event_trace");
         if (isset($list[$class])) $this->log = true;
         if ($this->log) Console::verbose("[事件分发{$this->eid}] 开始分发事件: " . $class);
     }
 
-    public function setRuleFunction(callable $rule = null) {
+    public function setRuleFunction(callable $rule = null): EventDispatcher {
         $this->rule = $rule;
         return $this;
     }
 
-    public function setReturnFunction(callable $return_func) {
+    public function setReturnFunction(callable $return_func): EventDispatcher {
         $this->return_func = $return_func;
         return $this;
     }
@@ -100,6 +95,7 @@ class EventDispatcher
                 }
             }
             if ($this->status === self::STATUS_RULE_FAILED) $this->status = self::STATUS_NORMAL;
+            //TODO:没有过滤before的false，可能会导致一些问题，先观望一下
         } catch (InterruptException $e) {
             $this->store = $e->return_var;
             $this->status = self::STATUS_INTERRUPTED;
@@ -116,10 +112,22 @@ class EventDispatcher
      * @return bool
      * @throws InterruptException
      * @throws AnnotationException
+     * @noinspection PhpMissingReturnTypeInspection
      */
     public function dispatchEvent($v, $rule_func = null, ...$params) {
         $q_c = $v->class;
         $q_f = $v->method;
+        if ($q_c === "" && ($q_f instanceof \Closure)) {
+            if ($this->log) Console::verbose("[事件分发{$this->eid}] 闭包函数的事件触发过程！");
+            if ($rule_func !== null && !$rule_func($v)) {
+                if ($this->log) Console::verbose("[事件分发{$this->eid}] 闭包函数下的 ruleFunc 判断为 false, 拒绝执行此方法。");
+                $this->status = self::STATUS_RULE_FAILED;
+                return false;
+            }
+            $this->store = $q_f(...$params);
+            $this->status = self::STATUS_NORMAL;
+            return true;
+        }
         if ($this->log) Console::verbose("[事件分发{$this->eid}] 正在判断 " . $q_c . "::" . $q_f . " 方法下的 ruleFunc ...");
         if ($rule_func !== null && !$rule_func($v)) {
             if ($this->log) Console::verbose("[事件分发{$this->eid}] " . $q_c . "::" . $q_f . " 方法下的 ruleFunc 判断为 false, 拒绝执行此方法。");
@@ -155,6 +163,7 @@ class EventDispatcher
             if ($before_result) {
                 try {
                     $q_o = ZMUtil::getModInstance($q_c);
+                    $q_o->_running_annotation = $v;
                     if ($this->log) Console::verbose("[事件分发{$this->eid}] 正在执行方法 " . $q_c . "::" . $q_f . " ...");
                     $this->store = $q_o->$q_f(...$params);
                 } catch (Exception $e) {
@@ -191,6 +200,7 @@ class EventDispatcher
             return false;
         } else {
             $q_o = ZMUtil::getModInstance($q_c);
+            $q_o->_running_annotation = $v;
             if ($this->log) Console::verbose("[事件分发{$this->eid}] 正在执行方法 " . $q_c . "::" . $q_f . " ...");
             $this->store = $q_o->$q_f(...$params);
             $this->status = self::STATUS_NORMAL;

src/ZM/Event/EventManager.php

@@ -9,7 +9,6 @@ use Exception;
 use Swoole\Timer;
 use ZM\Annotation\AnnotationBase;
 use ZM\Annotation\AnnotationParser;
-use ZM\Annotation\Swoole\OnSave;
 use ZM\Annotation\Swoole\OnTick;
 use ZM\Config\ZMConfig;
 use ZM\Console\Console;
@@ -37,6 +36,7 @@ class EventManager
 
     /**
      * 注册所有计时器给每个进程
+     * @throws Exception
      */
     public static function registerTimerTick() {
         $dispatcher = new EventDispatcher(OnTick::class);

src/ZM/Event/ServerEventHandler.php

@@ -1,691 +0,0 @@
-<?php /** @noinspection PhpUnreachableStatementInspection */
-
-/** @noinspection PhpComposerExtensionStubsInspection */
-
-
-namespace ZM\Event;
-
-
-use Closure;
-use Co;
-use Error;
-use Exception;
-use PDO;
-use ReflectionException;
-use Swoole\Coroutine;
-use Swoole\Database\PDOConfig;
-use Swoole\Database\PDOPool;
-use Swoole\Event;
-use Swoole\Process;
-use ZM\Annotation\AnnotationParser;
-use ZM\Annotation\Http\RequestMapping;
-use ZM\Annotation\Swoole\OnCloseEvent;
-use ZM\Annotation\Swoole\OnMessageEvent;
-use ZM\Annotation\Swoole\OnOpenEvent;
-use ZM\Annotation\Swoole\OnPipeMessageEvent;
-use ZM\Annotation\Swoole\OnRequestEvent;
-use ZM\Annotation\Swoole\OnStart;
-use ZM\Annotation\Swoole\OnSwooleEvent;
-use ZM\Config\ZMConfig;
-use ZM\ConnectionManager\ManagerGM;
-use ZM\Console\Console;
-use Swoole\Http\Request;
-use Swoole\Server;
-use Swoole\WebSocket\Frame;
-use ZM\Annotation\Swoole\SwooleHandler;
-use ZM\Console\TermColor;
-use ZM\Context\Context;
-use ZM\Context\ContextInterface;
-use ZM\DB\DB;
-use ZM\Exception\DbException;
-use ZM\Exception\InterruptException;
-use ZM\Framework;
-use ZM\Http\Response;
-use ZM\Module\QQBot;
-use ZM\Store\LightCache;
-use ZM\Store\LightCacheInside;
-use ZM\Store\MySQL\SqlPoolStorage;
-use ZM\Store\Redis\ZMRedisPool;
-use ZM\Store\WorkerCache;
-use ZM\Utils\DataProvider;
-use ZM\Utils\HttpUtil;
-use ZM\Utils\ZMUtil;
-
-class ServerEventHandler
-{
-    /**
-     * @SwooleHandler("start")
-     */
-    public function onStart() {
-        //global $terminal_id;
-        $r = null;
-        /*if ($terminal_id !== null) {
-            ZMBuf::$terminal = $r = STDIN;
-            Event::add($r, function () use ($r) {
-                $fget = fgets($r);
-                if ($fget === false) {
-                    Event::del($r);
-                    return;
-                }
-                $var = trim($fget);
-                try {
-                    Terminal::executeCommand($var, $r);
-                } catch (Exception $e) {
-                    Console::error("Uncaught exception " . get_class($e) . ": " . $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")");
-                } catch (Error $e) {
-                    Console::error("Uncaught error " . get_class($e) . ": " . $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")");
-                }
-            });
-        }*/
-        Process::signal(SIGINT, function () use ($r) {
-            if (zm_atomic("_int_is_reload")->get() === 1) {
-                zm_atomic("_int_is_reload")->set(0);
-                ZMUtil::reload();
-            } else {
-                echo "\r";
-                Console::warning("Server interrupted(SIGINT) on Master.");
-                if ((Framework::$server->inotify ?? null) !== null)
-                    /** @noinspection PhpUndefinedFieldInspection */ Event::del(Framework::$server->inotify);
-                ZMUtil::stop();
-            }
-        });
-        if (Framework::$argv["daemon"]) {
-            $daemon_data = json_encode([
-                "pid" => \server()->master_pid,
-                "stdout" => ZMConfig::get("global")["swoole"]["log_file"]
-            ], 128 | 256);
-            file_put_contents(DataProvider::getWorkingDir() . "/.daemon_pid", $daemon_data);
-        }
-        if (Framework::$argv["watch"]) {
-            if (extension_loaded('inotify')) {
-                Console::warning("Enabled File watcher, do not use in production.");
-                /** @noinspection PhpUndefinedFieldInspection */
-                Framework::$server->inotify = $fd = inotify_init();
-                $this->addWatcher(DataProvider::getWorkingDir() . "/src", $fd);
-                Event::add($fd, function () use ($fd) {
-                    $r = inotify_read($fd);
-                    dump($r);
-                    ZMUtil::reload();
-                });
-            } else {
-                Console::warning("You have not loaded \"inotify\" extension, please install first.");
-            }
-        }
-    }
-
-    /**
-     * @SwooleHandler("shutdown")
-     */
-    public function onShutdown() {
-        Console::debug("正在关闭 Master 进程，pid=" . posix_getpid());
-    }
-
-    /**
-     * @SwooleHandler("WorkerStop")
-     * @param $server
-     * @param $worker_id
-     */
-    public function onWorkerStop(Server $server, $worker_id) {
-        if ($worker_id == (ZMConfig::get("worker_cache")["worker"] ?? 0)) {
-            LightCache::savePersistence();
-        }
-        Console::debug(($server->taskworker ? "Task" : "") . "Worker #$worker_id 已停止");
-    }
-
-    /**
-     * @SwooleHandler("WorkerStart")
-     * @param Server $server
-     * @param $worker_id
-     */
-    public function onWorkerStart(Server $server, $worker_id) {
-        //if (ZMBuf::atomic("stop_signal")->get() != 0) return;
-        Process::signal(SIGINT, function () use ($worker_id, $server) {
-            Console::debug("正在关闭 " . ($server->taskworker ? "Task" : "") . "Worker 进程 " . Console::setColor("#" . \server()->worker_id, "gold") . TermColor::frontColor256(59) . ", pid=" . posix_getpid());
-            server()->stop($worker_id);
-        });
-        unset(Context::$context[Coroutine::getCid()]);
-        if ($server->taskworker === false) {
-            try {
-                register_shutdown_function(function () use ($server) {
-                    $error = error_get_last();
-                    if ($error["type"] != 0) {
-                        Console::error("Internal fatal error: " . $error["message"] . " at " . $error["file"] . "({$error["line"]})");
-                    }
-                    //DataProvider::saveBuffer();
-                    /** @var Server $server */
-                    if (server() === null) $server->shutdown();
-                    else server()->shutdown();
-                });
-
-                Console::verbose("Worker #{$server->worker_id} 启动中");
-                Framework::$server = $server;
-                //ZMBuf::resetCache(); //清空变量缓存
-                //ZMBuf::set("wait_start", []); //添加队列，在workerStart运行完成前先让其他协程等待执行
-                foreach ($server->connections as $v) {
-                    $server->close($v);
-                }
-
-
-                // 这里执行的是只需要执行一遍的代码，比如终端监听器和键盘监听器
-                /*if ($server->worker_id === 0) {
-                    global $terminal_id;
-                    if ($terminal_id !== null)
-                        go(function () {
-                            while (true) {
-                                $r = server()->process->exportSocket();
-                                $result = $r->recv();
-                                try {
-                                    if (!Terminal::executeCommand($result)) {
-                                        //if ($result == "stop" || $result == "reload" || $result == "r") {
-                                        //echo "Stopped.\n";
-                                        break;
-                                    }
-                                } catch (Exception $e) {
-                                    Console::error($e->getMessage());
-                                } catch (Error $e) {
-                                    Console::error($e->getMessage());
-                                }
-                            }
-                        });
-                }*/
-                //TODO: 单独抽出来MySQL和Redis连接池
-                if (ZMConfig::get("global", "sql_config")["sql_host"] != "") {
-                    if (SqlPoolStorage::$sql_pool !== null) {
-                        SqlPoolStorage::$sql_pool->close();
-                        SqlPoolStorage::$sql_pool = null;
-                    }
-                    Console::info("新建SQL连接池中");
-                    ob_start();
-                    phpinfo();
-                    $str = ob_get_clean();
-                    $str = explode("\n", $str);
-                    foreach ($str as $k => $v) {
-                        $v = trim($v);
-                        if ($v == "") continue;
-                        if (mb_strpos($v, "API Extensions") === false) continue;
-                        if (mb_strpos($v, "pdo_mysql") === false) {
-                            throw new DbException("未安装 mysqlnd php-mysql扩展。");
-                        }
-                    }
-                    $sql = ZMConfig::get("global", "sql_config");
-                    SqlPoolStorage::$sql_pool = new PDOPool((new PDOConfig())
-                        ->withHost($sql["sql_host"])
-                        ->withPort($sql["sql_port"])
-                        // ->withUnixSocket('/tmp/mysql.sock')
-                        ->withDbName($sql["sql_database"])
-                        ->withCharset('utf8mb4')
-                        ->withUsername($sql["sql_username"])
-                        ->withPassword($sql["sql_password"])
-                        ->withOptions($sql["sql_options"] ?? [PDO::ATTR_STRINGIFY_FETCHES => false])
-                    );
-                    DB::initTableList();
-                }
-
-                // 开箱即用的Redis
-                $redis = ZMConfig::get("global", "redis_config");
-                if ($redis !== null && $redis["host"] != "") {
-                    if (!extension_loaded("redis")) Console::error("Can not find redis extension.\n");
-                    else ZMRedisPool::init($redis);
-                }
-
-                $this->loadAnnotations(); //加载composer资源、phar外置包、注解解析注册等
-
-                //echo json_encode(debug_backtrace(), 128|256);
-
-                EventManager::registerTimerTick(); //启动计时器
-                //ZMBuf::unsetCache("wait_start");
-                set_coroutine_params(["server" => $server, "worker_id" => $worker_id]);
-                $dispatcher = new EventDispatcher(OnStart::class);
-                $dispatcher->setRuleFunction(function ($v) {
-                    return server()->worker_id === $v->worker_id || $v->worker_id === -1;
-                });
-                $dispatcher->dispatchEvents($server, $worker_id);
-                if ($dispatcher->status === EventDispatcher::STATUS_NORMAL) Console::debug("@OnStart 执行完毕");
-                else Console::warning("@OnStart 执行异常！");
-                Console::success("Worker #" . $worker_id . " 已启动");
-            } catch (Exception $e) {
-                Console::error("Worker加载出错！停止服务！");
-                Console::error($e->getMessage() . "\n" . $e->getTraceAsString());
-                ZMUtil::stop();
-                return;
-            } catch (Error $e) {
-                Console::error("PHP Error: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine());
-                Console::error("Maybe it caused by your own code if in your own Module directory.");
-                Console::log($e->getTraceAsString(), 'gray');
-                posix_kill($server->master_pid, SIGINT);
-            }
-        } else {
-            // 这里是TaskWorker初始化的内容部分
-            try {
-                Framework::$server = $server;
-                $this->loadAnnotations();
-                Console::debug("TaskWorker #" . $server->worker_id . " 已启动");
-            } catch (Exception $e) {
-                Console::error("Worker加载出错！停止服务！");
-                Console::error($e->getMessage() . "\n" . $e->getTraceAsString());
-                ZMUtil::stop();
-                return;
-            } catch (Error $e) {
-                Console::error("PHP Error: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine());
-                Console::error("Maybe it caused by your own code if in your own Module directory.");
-                Console::log($e->getTraceAsString(), 'gray');
-                posix_kill($server->master_pid, SIGINT);
-            }
-        }
-    }
-
-    /**
-     * @SwooleHandler("message")
-     * @param $server
-     * @param Frame $frame
-     */
-    public function onMessage($server, Frame $frame) {
-
-        Console::debug("Calling Swoole \"message\" from fd=" . $frame->fd . ": " . TermColor::ITALIC . $frame->data . TermColor::RESET);
-        unset(Context::$context[Coroutine::getCid()]);
-        $conn = ManagerGM::get($frame->fd);
-        set_coroutine_params(["server" => $server, "frame" => $frame, "connection" => $conn]);
-        $dispatcher1 = new EventDispatcher(OnMessageEvent::class);
-        $dispatcher1->setRuleFunction(function ($v) {
-            /** @noinspection PhpUnreachableStatementInspection */
-            return ctx()->getConnection()->getName() == $v->connect_type && eval("return " . $v->getRule() . ";");
-        });
-
-
-        $dispatcher = new EventDispatcher(OnSwooleEvent::class);
-        $dispatcher->setRuleFunction(function ($v) {
-            if ($v->getRule() == '') {
-                return strtolower($v->type) == 'message';
-            } else {
-                /** @noinspection PhpUnreachableStatementInspection
-                 * @noinspection RedundantSuppression
-                 */
-                if (strtolower($v->type) == 'message' && eval("return " . $v->getRule() . ";")) return true;
-                else return false;
-            }
-        });
-        try {
-            //$starttime = microtime(true);
-            $dispatcher1->dispatchEvents($conn);
-            $dispatcher->dispatchEvents($conn);
-            //Console::success("Used ".round((microtime(true) - $starttime) * 1000, 3)." ms!");
-        } catch (Exception $e) {
-            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-            Console::error("Uncaught exception " . get_class($e) . " when calling \"message\": " . $error_msg);
-            Console::trace();
-        } catch (Error $e) {
-            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-            Console::error("Uncaught " . get_class($e) . " when calling \"message\": " . $error_msg);
-            Console::trace();
-        }
-
-    }
-
-    /**
-     * @SwooleHandler("request")
-     * @param $request
-     * @param $response
-     */
-    public function onRequest(?Request $request, ?\Swoole\Http\Response $response) {
-        $response = new Response($response);
-        foreach (ZMConfig::get("global")["http_header"] as $k => $v) {
-            $response->setHeader($k, $v);
-        }
-        unset(Context::$context[Co::getCid()]);
-        Console::debug("Calling Swoole \"request\" event from fd=" . $request->fd);
-        set_coroutine_params(["request" => $request, "response" => $response]);
-
-        $dis1 = new EventDispatcher(OnRequestEvent::class);
-        $dis1->setRuleFunction(function ($v) {
-            return eval("return " . $v->getRule() . ";") ? true : false;
-        });
-
-        $dis = new EventDispatcher(OnSwooleEvent::class);
-        $dis->setRuleFunction(function ($v) {
-            if ($v->getRule() == '') {
-                return strtolower($v->type) == 'request';
-            } else {
-                /** @noinspection PhpUnreachableStatementInspection */
-                if (strtolower($v->type) == 'request' && eval("return " . $v->getRule() . ";")) return true;
-                else return false;
-            }
-        });
-
-        try {
-            $dis1->dispatchEvents($request, $response);
-            $dis->dispatchEvents($request, $response);
-            if ($dis->status === EventDispatcher::STATUS_NORMAL && $dis1->status === EventDispatcher::STATUS_NORMAL) {
-                $result = HttpUtil::parseUri($request, $response, $request->server["request_uri"], $node, $params);
-                if ($result === true) {
-                    ctx()->setCache("params", $params);
-                    $dispatcher = new EventDispatcher(RequestMapping::class);
-                    $div = new RequestMapping();
-                    $div->route = $node["route"];
-                    $div->params = $params;
-                    $div->method = $node["method"];
-                    $div->request_method = $node["request_method"];
-                    $div->class = $node["class"];
-                    //Console::success("正在执行路由：".$node["method"]);
-                    $dispatcher->dispatchEvent($div, null, $params, $request, $response);
-                    if (is_string($dispatcher->store) && !$response->isEnd()) $response->end($dispatcher->store);
-                }
-            }
-            if (!$response->isEnd()) {
-                //Console::warning('返回了404');
-                HttpUtil::responseCodePage($response, 404);
-            }
-        } catch (InterruptException $e) {
-            // do nothing
-        } catch (Exception $e) {
-            $response->status(500);
-            Console::info($request->server["remote_addr"] . ":" . $request->server["remote_port"] .
-                " [" . $response->getStatusCode() . "] " . $request->server["request_uri"]
-            );
-            if (!$response->isEnd()) {
-                if (ZMConfig::get("global", "debug_mode"))
-                    $response->end("Internal server exception: " . $e->getMessage());
-                else
-                    $response->end("Internal server error.");
-            }
-            Console::error("Internal server exception (500), caused by " . get_class($e) . ": " . $e->getMessage());
-            Console::log($e->getTraceAsString(), "gray");
-        } catch (Error $e) {
-            $response->status(500);
-            Console::info($request->server["remote_addr"] . ":" . $request->server["remote_port"] .
-                " [" . $response->getStatusCode() . "] " . $request->server["request_uri"]
-            );
-            if (!$response->isEnd()) {
-                $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-                if (ZMConfig::get("global", "debug_mode"))
-                    $response->end("Internal server error: " . $error_msg);
-                else
-                    $response->end("Internal server error.");
-            }
-            Console::error("Internal server error (500), caused by " . get_class($e) . ": " . $e->getMessage());
-            Console::log($e->getTraceAsString(), "gray");
-        }
-    }
-
-    /**
-     * @SwooleHandler("open")
-     * @param $server
-     * @param Request $request
-     */
-    public function onOpen($server, Request $request) {
-        Console::debug("Calling Swoole \"open\" event from fd=" . $request->fd);
-        unset(Context::$context[Co::getCid()]);
-        $type = strtolower($request->header["x-client-role"] ?? $request->get["type"] ?? "");
-        $access_token = explode(" ", $request->header["authorization"] ?? "")[1] ?? $request->get["token"] ?? "";
-        $token = ZMConfig::get("global", "access_token");
-        if ($token instanceof Closure) {
-            if (!$token($access_token)) {
-                $server->close($request->fd);
-                Console::warning("Unauthorized access_token: " . $access_token);
-                return;
-            }
-        } elseif (is_string($token)) {
-            if ($access_token !== $token && $token !== "") {
-                $server->close($request->fd);
-                Console::warning("Unauthorized access_token: " . $access_token);
-                return;
-            }
-        }
-        $type_conn = ManagerGM::getTypeClassName($type);
-        ManagerGM::pushConnect($request->fd, $type_conn);
-        $conn = ManagerGM::get($request->fd);
-        set_coroutine_params(["server" => $server, "request" => $request, "connection" => $conn, "fd" => $request->fd]);
-        $conn->setOption("connect_id", strval($request->header["x-self-id"] ?? ""));
-
-        $dispatcher1 = new EventDispatcher(OnOpenEvent::class);
-        $dispatcher1->setRuleFunction(function ($v) {
-            return ctx()->getConnection()->getName() == $v->connect_type && eval("return " . $v->getRule() . ";");
-        });
-
-        $dispatcher = new EventDispatcher(OnSwooleEvent::class);
-        $dispatcher->setRuleFunction(function ($v) {
-            if ($v->getRule() == '') {
-                return strtolower($v->type) == 'open';
-            } else {
-                /** @noinspection PhpUnreachableStatementInspection */
-                if (strtolower($v->type) == 'open' && eval("return " . $v->getRule() . ";")) return true;
-                else return false;
-            }
-        });
-        try {
-            if ($conn->getName() === 'qq' && ZMConfig::get("global", "modules")["onebot"]["status"] === true) {
-                if (ZMConfig::get("global", "modules")["onebot"]["single_bot_mode"]) {
-                    LightCacheInside::set("connect", "conn_fd", $request->fd);
-                }
-            }
-            $dispatcher1->dispatchEvents($conn);
-            $dispatcher->dispatchEvents($conn);
-        } catch (Exception $e) {
-            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-            Console::error("Uncaught exception " . get_class($e) . " when calling \"open\": " . $error_msg);
-            Console::trace();
-        } catch (Error $e) {
-            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-            Console::error("Uncaught " . get_class($e) . " when calling \"open\": " . $error_msg);
-            Console::trace();
-        }
-        //EventHandler::callSwooleEvent("open", $server, $request);
-    }
-
-    /**
-     * @SwooleHandler("close")
-     * @param $server
-     * @param $fd
-     */
-    public function onClose($server, $fd) {
-        unset(Context::$context[Co::getCid()]);
-        $conn = ManagerGM::get($fd);
-        if ($conn === null) return;
-        Console::debug("Calling Swoole \"close\" event from fd=" . $fd);
-        set_coroutine_params(["server" => $server, "connection" => $conn, "fd" => $fd]);
-
-        $dispatcher1 = new EventDispatcher(OnCloseEvent::class);
-        $dispatcher1->setRuleFunction(function ($v) {
-            return $v->connect_type == ctx()->getConnection()->getName() && eval("return " . $v->getRule() . ";");
-        });
-
-        $dispatcher = new EventDispatcher(OnSwooleEvent::class);
-        $dispatcher->setRuleFunction(function ($v) {
-            if ($v->getRule() == '') {
-                return strtolower($v->type) == 'close';
-            } else {
-                /** @noinspection PhpUnreachableStatementInspection */
-                if (strtolower($v->type) == 'close' && eval("return " . $v->getRule() . ";")) return true;
-                else return false;
-            }
-        });
-        try {
-            if ($conn->getName() === 'qq' && ZMConfig::get("global", "modules")["onebot"]["status"] === true) {
-                if (ZMConfig::get("global", "modules")["onebot"]["single_bot_mode"]) {
-                    LightCacheInside::set("connect", "conn_fd", -1);
-                }
-            }
-            $dispatcher1->dispatchEvents($conn);
-            $dispatcher->dispatchEvents($conn);
-        } catch (Exception $e) {
-            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-            Console::error("Uncaught exception " . get_class($e) . " when calling \"close\": " . $error_msg);
-            Console::trace();
-        } catch (Error $e) {
-            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
-            Console::error("Uncaught " . get_class($e) . " when calling \"close\": " . $error_msg);
-            Console::trace();
-        }
-        ManagerGM::popConnect($fd);
-    }
-
-    /**
-     * @SwooleHandler("pipeMessage")
-     * @param Server $server
-     * @param $src_worker_id
-     * @param $data
-     * @throws Exception
-     */
-    public function onPipeMessage(Server $server, $src_worker_id, $data) {
-        //var_dump($data, $server->worker_id);
-        //unset(Context::$context[Co::getCid()]);
-        $data = json_decode($data, true);
-        switch ($data["action"] ?? '') {
-            case "resume_ws_message":
-                $obj = $data["data"];
-                Co::resume($obj["coroutine"]);
-                break;
-            case "getWorkerCache":
-                $r = WorkerCache::get($data["key"]);
-                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
-                $server->sendMessage(json_encode($action, 256), $src_worker_id);
-                break;
-            case "setWorkerCache":
-                $r = WorkerCache::set($data["key"], $data["value"]);
-                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
-                $server->sendMessage(json_encode($action, 256), $src_worker_id);
-                break;
-            case "unsetWorkerCache":
-                $r = WorkerCache::unset($data["key"]);
-                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
-                $server->sendMessage(json_encode($action, 256), $src_worker_id);
-                break;
-            case "hasKeyWorkerCache":
-                $r = WorkerCache::hasKey($data["key"], $data["subkey"]);
-                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
-                $server->sendMessage(json_encode($action, 256), $src_worker_id);
-                break;
-            case "asyncAddWorkerCache":
-                WorkerCache::add($data["key"], $data["value"], true);
-                break;
-            case "asyncSubWorkerCache":
-                WorkerCache::sub($data["key"], $data["value"], true);
-                break;
-            case "asyncSetWorkerCache":
-                WorkerCache::set($data["key"], $data["value"], true);
-                break;
-            case "asyncUnsetWorkerCache":
-                WorkerCache::unset($data["key"], true);
-                break;
-            case "addWorkerCache":
-                $r = WorkerCache::add($data["key"], $data["value"]);
-                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
-                $server->sendMessage(json_encode($action, 256), $src_worker_id);
-                break;
-            case "subWorkerCache":
-                $r = WorkerCache::sub($data["key"], $data["value"]);
-                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
-                $server->sendMessage(json_encode($action, 256), $src_worker_id);
-                break;
-            case "returnWorkerCache":
-                WorkerCache::$transfer[$data["cid"]] = $data["value"];
-                zm_resume($data["cid"]);
-                break;
-            default:
-                $dispatcher = new EventDispatcher(OnPipeMessageEvent::class);
-                $dispatcher->setRuleFunction(function (OnPipeMessageEvent $v) use ($data) {
-                    return $v->action == $data["action"];
-                });
-                $dispatcher->dispatchEvents($data);
-                break;
-        }
-    }
-
-    /**
-     * @SwooleHandler("task")
-     * @param Server|null $server
-     * @param Server\Task $task
-     * @return mixed
-     * @noinspection PhpUnusedParameterInspection
-     */
-    public function onTask(?Server $server, Server\Task $task) {
-        $data = $task->data;
-        switch ($data["action"]) {
-            case "runMethod":
-                $c = $data["class"];
-                $ss = new $c();
-                $method = $data["method"];
-                $ps = $data["params"];
-                $task->finish($ss->$method(...$ps));
-        }
-        return null;
-    }
-
-    /**
-     * @throws ReflectionException
-     * @throws Exception
-     */
-    private function loadAnnotations() {
-        //加载phar包
-        /*Console::debug("加载外部phar包中");
-        $dir = DataProvider::getWorkingDir() . "/resources/package/";
-        if (version_compare(SWOOLE_VERSION, "4.4.0", ">=")) Timer::clearAll();
-        if (is_dir($dir)) {
-            $list = scandir($dir);
-            unset($list[0], $list[1]);
-            foreach ($list as $v) {
-                if (is_dir($dir . $v)) continue;
-                if (pathinfo($dir . $v, 4) == "phar") {
-                    Console::debug("加载Phar: " . $dir . $v . " 中");
-                    require_once($dir . $v);
-                }
-            }
-        }*/
-
-        //加载各个模块的注解类，以及反射
-        Console::debug("检索Module中");
-        $parser = new AnnotationParser();
-        $path = DataProvider::getWorkingDir() . "/src/";
-        $dir = scandir($path);
-        unset($dir[0], $dir[1]);
-        $composer = json_decode(file_get_contents(DataProvider::getWorkingDir() . "/composer.json"), true);
-        foreach ($dir as $v) {
-            if (is_dir($path . "/" . $v) && isset($composer["autoload"]["psr-4"][$v . "\\"]) && !in_array($composer["autoload"]["psr-4"][$v . "\\"], $composer["extra"]["exclude_annotate"] ?? [])) {
-                if (\server()->worker_id == 0)
-                    Console::verbose("Add " . $v . " to register path");
-                $parser->addRegisterPath(DataProvider::getWorkingDir() . "/src/" . $v . "/", $v);
-            }
-        }
-        $parser->registerMods();
-        EventManager::loadEventByParser($parser); //加载事件
-
-        //加载自定义的全局函数
-        Console::debug("加载自定义上下文中...");
-        $context_class = ZMConfig::get("global", "context_class");
-        if (!is_a($context_class, ContextInterface::class, true)) {
-            throw new Exception("Context class must implemented from ContextInterface!");
-        }
-
-        //加载插件
-        $plugins = ZMConfig::get("global", "modules") ?? [];
-        if (!isset($plugins["onebot"])) $plugins["onebot"] = ["status" => true, "single_bot_mode" => false, "message_level" => 99999];
-
-        if ($plugins["onebot"]) {
-            $obj = new OnSwooleEvent();
-            $obj->class = QQBot::class;
-            $obj->method = 'handle';
-            $obj->type = 'message';
-            $obj->level = $plugins["onebot"]["message_level"] ?? 99999;
-            $obj->rule = 'connectIsQQ()';
-            EventManager::addEvent(OnSwooleEvent::class, $obj);
-            if ($plugins["onebot"]["single_bot_mode"]) {
-                LightCacheInside::set("connect", "conn_fd", -1);
-            } else {
-                LightCacheInside::set("connect", "conn_fd", -2);
-            }
-        }
-
-        //TODO: 编写加载外部插件的方式
-    }
-
-    private function addWatcher($maindir, $fd) {
-        $dir = scandir($maindir);
-        unset($dir[0], $dir[1]);
-        foreach ($dir as $subdir) {
-            if (is_dir($maindir . "/" . $subdir)) {
-                Console::debug("添加监听目录：" . $maindir . "/" . $subdir);
-                inotify_add_watch($fd, $maindir . "/" . $subdir, IN_ATTRIB | IN_ISDIR);
-                $this->addWatcher($maindir . "/" . $subdir, $fd);
-            }
-        }
-    }
-}

src/ZM/Event/SwooleEvent.php

@@ -0,0 +1,9 @@
+<?php
+
+
+namespace ZM\Event;
+
+
+interface SwooleEvent
+{
+}

src/ZM/Event/SwooleEvent/OnBeforeReload.php

@@ -0,0 +1,26 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Process;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Console\Console;
+use ZM\Event\SwooleEvent;
+
+/**
+ * Class OnBeforeReload
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("BeforeReload")
+ */
+class OnBeforeReload implements SwooleEvent
+{
+    public function onCall() {
+        Console::info(Console::setColor("Reloading server...", "gold"));
+        for ($i = 0; $i < ZM_WORKER_NUM; ++$i) {
+            Process::kill(zm_atomic("_#worker_".$i)->get(), SIGUSR1);
+        }
+        usleep(800 * 1000);
+    }
+}

src/ZM/Event/SwooleEvent/OnClose.php

@@ -0,0 +1,73 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Co;
+use Error;
+use Exception;
+use ZM\Annotation\Swoole\OnCloseEvent;
+use ZM\Annotation\Swoole\OnSwooleEvent;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Config\ZMConfig;
+use ZM\ConnectionManager\ManagerGM;
+use ZM\Console\Console;
+use ZM\Context\Context;
+use ZM\Event\EventDispatcher;
+use ZM\Event\SwooleEvent;
+use ZM\Store\LightCacheInside;
+
+/**
+ * Class OnClose
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("close")
+ */
+class OnClose implements SwooleEvent
+{
+    /** @noinspection PhpUnreachableStatementInspection */
+    public function onCall($server, $fd) {
+        unset(Context::$context[Co::getCid()]);
+        $conn = ManagerGM::get($fd);
+        if ($conn === null) return;
+        Console::debug("Calling Swoole \"close\" event from fd=" . $fd);
+        set_coroutine_params(["server" => $server, "connection" => $conn, "fd" => $fd]);
+
+        $dispatcher1 = new EventDispatcher(OnCloseEvent::class);
+        $dispatcher1->setRuleFunction(function ($v) {
+            return $v->connect_type == ctx()->getConnection()->getName() && eval("return " . $v->getRule() . ";");
+        });
+
+        $dispatcher = new EventDispatcher(OnSwooleEvent::class);
+        $dispatcher->setRuleFunction(function ($v) {
+            if ($v->getRule() == '') {
+                return strtolower($v->type) == 'close';
+            } else {
+                /** @noinspection PhpUnreachableStatementInspection */
+                if (strtolower($v->type) == 'close' && eval("return " . $v->getRule() . ";")) return true;
+                else return false;
+            }
+        });
+        try {
+            $obb_onebot = ZMConfig::get("global", "onebot") ??
+                ZMConfig::get("global", "modules")["onebot"] ??
+                ["status" => true, "single_bot_mode" => false, "message_level" => 99999];
+            if ($conn->getName() === 'qq' && $obb_onebot["status"] === true) {
+                if ($obb_onebot["single_bot_mode"]) {
+                    LightCacheInside::set("connect", "conn_fd", -1);
+                }
+            }
+            $dispatcher1->dispatchEvents($conn);
+            $dispatcher->dispatchEvents($conn);
+        } catch (Exception $e) {
+            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+            Console::error("Uncaught exception " . get_class($e) . " when calling \"close\": " . $error_msg);
+            Console::trace();
+        } catch (Error $e) {
+            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+            Console::error("Uncaught " . get_class($e) . " when calling \"close\": " . $error_msg);
+            Console::trace();
+        }
+        ManagerGM::popConnect($fd);
+    }
+}

src/ZM/Event/SwooleEvent/OnManagerStart.php

@@ -0,0 +1,27 @@
+<?php /** @noinspection PhpUnusedParameterInspection */
+
+/** @noinspection PhpComposerExtensionStubsInspection */
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Server;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Console\Console;
+use ZM\Event\SwooleEvent;
+
+/**
+ * Class OnManagerStart
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("ManagerStart")
+ */
+class OnManagerStart implements SwooleEvent
+{
+    public function onCall(Server $server) {
+        pcntl_signal(SIGINT, function () {
+            Console::verbose("Interrupted in manager!");
+        });
+        Console::verbose("进程 Manager 已启动");
+    }
+}

src/ZM/Event/SwooleEvent/OnMessage.php

@@ -0,0 +1,68 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Error;
+use Exception;
+use Swoole\Coroutine;
+use Swoole\WebSocket\Frame;
+use ZM\Annotation\Swoole\OnMessageEvent;
+use ZM\Annotation\Swoole\OnSwooleEvent;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\ConnectionManager\ManagerGM;
+use ZM\Console\Console;
+use ZM\Console\TermColor;
+use ZM\Context\Context;
+use ZM\Event\EventDispatcher;
+use ZM\Event\SwooleEvent;
+
+/**
+ * Class OnMessage
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("message")
+ */
+class OnMessage implements SwooleEvent
+{
+    public function onCall($server, Frame $frame) {
+        Console::debug("Calling Swoole \"message\" from fd=" . $frame->fd . ": " . TermColor::ITALIC . $frame->data . TermColor::RESET);
+        unset(Context::$context[Coroutine::getCid()]);
+        $conn = ManagerGM::get($frame->fd);
+        set_coroutine_params(["server" => $server, "frame" => $frame, "connection" => $conn]);
+        $dispatcher1 = new EventDispatcher(OnMessageEvent::class);
+        $dispatcher1->setRuleFunction(function ($v) {
+            /** @noinspection PhpUnreachableStatementInspection */
+            return ctx()->getConnection()->getName() == $v->connect_type && eval("return " . $v->getRule() . ";");
+        });
+
+
+        $dispatcher = new EventDispatcher(OnSwooleEvent::class);
+        $dispatcher->setRuleFunction(function ($v) {
+            if ($v->getRule() == '') {
+                return strtolower($v->type) == 'message';
+            } else {
+                /** @noinspection PhpUnreachableStatementInspection
+                 * @noinspection RedundantSuppression
+                 */
+                if (strtolower($v->type) == 'message' && eval("return " . $v->getRule() . ";")) return true;
+                else return false;
+            }
+        });
+        try {
+            //$starttime = microtime(true);
+            $dispatcher1->dispatchEvents($conn);
+            $dispatcher->dispatchEvents($conn);
+            //Console::success("Used ".round((microtime(true) - $starttime) * 1000, 3)." ms!");
+        } catch (Exception $e) {
+            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+            Console::error("Uncaught exception " . get_class($e) . " when calling \"message\": " . $error_msg);
+            Console::trace();
+        } catch (Error $e) {
+            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+            Console::error("Uncaught " . get_class($e) . " when calling \"message\": " . $error_msg);
+            Console::trace();
+        }
+
+    }
+}

src/ZM/Event/SwooleEvent/OnOpen.php

@@ -0,0 +1,92 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Closure;
+use Co;
+use Error;
+use Exception;
+use Swoole\Http\Request;
+use ZM\Annotation\Swoole\OnOpenEvent;
+use ZM\Annotation\Swoole\OnSwooleEvent;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Config\ZMConfig;
+use ZM\ConnectionManager\ManagerGM;
+use ZM\Console\Console;
+use ZM\Context\Context;
+use ZM\Event\EventDispatcher;
+use ZM\Event\SwooleEvent;
+use ZM\Store\LightCacheInside;
+
+/**
+ * Class OnOpen
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("open")
+ */
+class OnOpen implements SwooleEvent
+{
+    /** @noinspection PhpUnreachableStatementInspection */
+    public function onCall($server, Request $request) {
+        Console::debug("Calling Swoole \"open\" event from fd=" . $request->fd);
+        unset(Context::$context[Co::getCid()]);
+        $type = strtolower($request->header["x-client-role"] ?? $request->get["type"] ?? "");
+        $access_token = explode(" ", $request->header["authorization"] ?? "")[1] ?? $request->get["token"] ?? "";
+        $token = ZMConfig::get("global", "access_token");
+        if ($token instanceof Closure) {
+            if (!$token($access_token)) {
+                $server->close($request->fd);
+                Console::warning("Unauthorized access_token: " . $access_token);
+                return;
+            }
+        } elseif (is_string($token)) {
+            if ($access_token !== $token && $token !== "") {
+                $server->close($request->fd);
+                Console::warning("Unauthorized access_token: " . $access_token);
+                return;
+            }
+        }
+        $type_conn = ManagerGM::getTypeClassName($type);
+        ManagerGM::pushConnect($request->fd, $type_conn);
+        $conn = ManagerGM::get($request->fd);
+        set_coroutine_params(["server" => $server, "request" => $request, "connection" => $conn, "fd" => $request->fd]);
+        $conn->setOption("connect_id", strval($request->header["x-self-id"] ?? ""));
+
+        $dispatcher1 = new EventDispatcher(OnOpenEvent::class);
+        $dispatcher1->setRuleFunction(function ($v) {
+            return ctx()->getConnection()->getName() == $v->connect_type && eval("return " . $v->getRule() . ";");
+        });
+
+        $dispatcher = new EventDispatcher(OnSwooleEvent::class);
+        $dispatcher->setRuleFunction(function ($v) {
+            if ($v->getRule() == '') {
+                return strtolower($v->type) == 'open';
+            } else {
+                if (strtolower($v->type) == 'open' && eval("return " . $v->getRule() . ";")) return true;
+                else return false;
+            }
+        });
+        try {
+            $obb_onebot = ZMConfig::get("global", "onebot") ??
+                ZMConfig::get("global", "modules")["onebot"] ??
+                ["status" => true, "single_bot_mode" => false, "message_level" => 99999];
+            $onebot_status = $obb_onebot["status"];
+            if ($conn->getName() === 'qq' && $onebot_status === true) {
+                if ($obb_onebot["single_bot_mode"]) {
+                    LightCacheInside::set("connect", "conn_fd", $request->fd);
+                }
+            }
+            $dispatcher1->dispatchEvents($conn);
+            $dispatcher->dispatchEvents($conn);
+        } catch (Exception $e) {
+            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+            Console::error("Uncaught exception " . get_class($e) . " when calling \"open\": " . $error_msg);
+            Console::trace();
+        } catch (Error $e) {
+            $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+            Console::error("Uncaught " . get_class($e) . " when calling \"open\": " . $error_msg);
+            Console::trace();
+        }
+    }
+}

src/ZM/Event/SwooleEvent/OnPipeMessage.php

@@ -0,0 +1,23 @@
+<?php /** @noinspection PhpUnusedParameterInspection */
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Server;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Event\SwooleEvent;
+use ZM\Utils\ProcessManager;
+
+/**
+ * Class OnPipeMessage
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("PipeMessage")
+ */
+class OnPipeMessage implements SwooleEvent
+{
+    public function onCall(Server $server, $src_worker_id, $data) {
+        $data = json_decode($data, true);
+        ProcessManager::workerAction($src_worker_id, $data);
+    }
+}

src/ZM/Event/SwooleEvent/OnRequest.php

@@ -0,0 +1,111 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Co;
+use Error;
+use Exception;
+use Swoole\Http\Request;
+use ZM\Annotation\Http\RequestMapping;
+use ZM\Annotation\Swoole\OnRequestEvent;
+use ZM\Annotation\Swoole\OnSwooleEvent;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Config\ZMConfig;
+use ZM\Console\Console;
+use ZM\Context\Context;
+use ZM\Event\EventDispatcher;
+use ZM\Event\SwooleEvent;
+use ZM\Exception\InterruptException;
+use ZM\Http\Response;
+use ZM\Utils\HttpUtil;
+
+/**
+ * Class OnRequest
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("request")
+ */
+class OnRequest implements SwooleEvent
+{
+    public function onCall(?Request $request, ?\Swoole\Http\Response $response) {
+        $response = new Response($response);
+        foreach (ZMConfig::get("global")["http_header"] as $k => $v) {
+            $response->setHeader($k, $v);
+        }
+        unset(Context::$context[Co::getCid()]);
+        Console::debug("Calling Swoole \"request\" event from fd=" . $request->fd);
+        set_coroutine_params(["request" => $request, "response" => $response]);
+
+        $dis1 = new EventDispatcher(OnRequestEvent::class);
+        $dis1->setRuleFunction(function ($v) {
+            /** @noinspection PhpUnreachableStatementInspection */
+            return eval("return " . $v->getRule() . ";") ? true : false;
+        });
+
+        $dis = new EventDispatcher(OnSwooleEvent::class);
+        $dis->setRuleFunction(function ($v) {
+            if ($v->getRule() == '') {
+                return strtolower($v->type) == 'request';
+            } else {
+                /** @noinspection PhpUnreachableStatementInspection */
+                if (strtolower($v->type) == 'request' && eval("return " . $v->getRule() . ";")) return true;
+                else return false;
+            }
+        });
+
+        try {
+            $dis1->dispatchEvents($request, $response);
+            $dis->dispatchEvents($request, $response);
+            if ($dis->status === EventDispatcher::STATUS_NORMAL && $dis1->status === EventDispatcher::STATUS_NORMAL) {
+                $result = HttpUtil::parseUri($request, $response, $request->server["request_uri"], $node, $params);
+                if ($result === true) {
+                    ctx()->setCache("params", $params);
+                    $dispatcher = new EventDispatcher(RequestMapping::class);
+                    $div = new RequestMapping();
+                    $div->route = $node["route"];
+                    $div->params = $params;
+                    $div->method = $node["method"];
+                    $div->request_method = $node["request_method"];
+                    $div->class = $node["class"];
+                    //Console::success("正在执行路由：".$node["method"]);
+                    $dispatcher->dispatchEvent($div, null, $params, $request, $response);
+                    if (is_string($dispatcher->store) && !$response->isEnd()) $response->end($dispatcher->store);
+                }
+            }
+            if (!$response->isEnd()) {
+                //Console::warning('返回了404');
+                HttpUtil::responseCodePage($response, 404);
+            }
+        } catch (InterruptException $e) {
+            // do nothing
+        } catch (Exception $e) {
+            $response->status(500);
+            Console::info($request->server["remote_addr"] . ":" . $request->server["remote_port"] .
+                " [" . $response->getStatusCode() . "] " . $request->server["request_uri"]
+            );
+            if (!$response->isEnd()) {
+                if (ZMConfig::get("global", "debug_mode"))
+                    $response->end("Internal server exception: " . $e->getMessage());
+                else
+                    $response->end("Internal server error.");
+            }
+            Console::error("Internal server exception (500), caused by " . get_class($e) . ": " . $e->getMessage());
+            Console::log($e->getTraceAsString(), "gray");
+        } catch (Error $e) {
+            $response->status(500);
+            Console::info($request->server["remote_addr"] . ":" . $request->server["remote_port"] .
+                " [" . $response->getStatusCode() . "] " . $request->server["request_uri"]
+            );
+            if (!$response->isEnd()) {
+                $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+                if (ZMConfig::get("global", "debug_mode"))
+                    $response->end("Internal server error: " . $error_msg);
+                else
+                    $response->end("Internal server error.");
+            }
+            Console::error("Internal server error (500), caused by " . get_class($e) . ": " . $e->getMessage());
+            Console::log($e->getTraceAsString(), "gray");
+        }
+    }
+}

src/ZM/Event/SwooleEvent/OnShutdown.php

@@ -0,0 +1,22 @@
+<?php /** @noinspection PhpUnusedParameterInspection */
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Server;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Console\Console;
+use ZM\Event\SwooleEvent;
+
+/**
+ * Class OnShutdown
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("shutdown")
+ */
+class OnShutdown implements SwooleEvent
+{
+    public function onCall(Server $server) {
+        Console::verbose("正在关闭 Master 进程，pid=" . posix_getpid());
+    }
+}

src/ZM/Event/SwooleEvent/OnStart.php

@@ -0,0 +1,74 @@
+<?php /** @noinspection PhpComposerExtensionStubsInspection */
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Event;
+use Swoole\Process;
+use Swoole\Server;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Config\ZMConfig;
+use ZM\Console\Console;
+use ZM\Event\SwooleEvent;
+use ZM\Framework;
+use ZM\Utils\DataProvider;
+use ZM\Utils\ZMUtil;
+
+/**
+ * Class OnStart
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("start")
+ */
+class OnStart implements SwooleEvent
+{
+    public function onCall(Server $server) {
+        $r = null;
+        Process::signal(SIGINT, function () use ($r, $server) {
+            if (zm_atomic("_int_is_reload")->get() === 1) {
+                zm_atomic("_int_is_reload")->set(0);
+                $server->reload();
+            } else {
+                echo "\r";
+                Console::warning("Server interrupted(SIGINT) on Master.");
+                if ((Framework::$server->inotify ?? null) !== null)
+                    /** @noinspection PhpUndefinedFieldInspection */ Event::del(Framework::$server->inotify);
+                Process::kill($server->master_pid, SIGTERM);
+            }
+        });
+        if (Framework::$argv["daemon"]) {
+            $daemon_data = json_encode([
+                "pid" => $server->master_pid,
+                "stdout" => ZMConfig::get("global")["swoole"]["log_file"]
+            ], 128 | 256);
+            file_put_contents(DataProvider::getWorkingDir() . "/.daemon_pid", $daemon_data);
+        }
+        if (Framework::$argv["watch"]) {
+            if (extension_loaded('inotify')) {
+                Console::warning("Enabled File watcher, do not use in production.");
+                /** @noinspection PhpUndefinedFieldInspection */
+                Framework::$server->inotify = $fd = inotify_init();
+                $this->addWatcher(DataProvider::getWorkingDir() . "/src", $fd);
+                Event::add($fd, function () use ($fd) {
+                    $r = inotify_read($fd);
+                    dump($r);
+                    ZMUtil::reload();
+                });
+            } else {
+                Console::warning("You have not loaded \"inotify\" extension, please install first.");
+            }
+        }
+    }
+
+    private function addWatcher($maindir, $fd) {
+        $dir = scandir($maindir);
+        unset($dir[0], $dir[1]);
+        foreach ($dir as $subdir) {
+            if (is_dir($maindir . "/" . $subdir)) {
+                Console::debug("添加监听目录：" . $maindir . "/" . $subdir);
+                inotify_add_watch($fd, $maindir . "/" . $subdir, IN_ATTRIB | IN_ISDIR);
+                $this->addWatcher($maindir . "/" . $subdir, $fd);
+            }
+        }
+    }
+}

src/ZM/Event/SwooleEvent/OnTask.php

@@ -0,0 +1,77 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Error;
+use Exception;
+use Swoole\Server;
+use Swoole\Server\Task;
+use Throwable;
+use ZM\Annotation\Swoole\OnTaskEvent;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Console\Console;
+use ZM\Event\EventDispatcher;
+use ZM\Event\SwooleEvent;
+
+/**
+ * Class OnTask
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("task")
+ */
+class OnTask implements SwooleEvent
+{
+    /**
+     * @noinspection PhpUnreachableStatementInspection
+     * @noinspection PhpUnusedParameterInspection
+     * @param Server|null $server
+     * @param Task $task
+     */
+    public function onCall(?Server $server, Task $task) {
+        if (isset($task->data["task"])) {
+            $dispatcher = new EventDispatcher(\ZM\Annotation\Swoole\OnTask::class);
+            $dispatcher->setRuleFunction(function ($v) use ($task) {
+                /** @var \ZM\Annotation\Swoole\OnTask $v */
+                return $v->task_name == $task->data["task"];
+            });
+            $dispatcher->setReturnFunction(function ($return) {
+                EventDispatcher::interrupt($return);
+            });
+            $params = $task->data["params"];
+            try {
+                $dispatcher->dispatchEvents(...$params);
+            } catch (Throwable $e) {
+                $finish["throw"] = $e;
+            }
+            if ($dispatcher->status === EventDispatcher::STATUS_EXCEPTION) {
+                $finish["result"] = null;
+                $finish["retcode"] = -1;
+            } else {
+                $finish["result"] = $dispatcher->store;
+                $finish["retcode"] = 0;
+            }
+            if (zm_atomic("server_is_stopped")->get() === 1) {
+                return;
+            }
+            $task->finish($finish);
+        } else {
+            try {
+                $dispatcher = new EventDispatcher(OnTaskEvent::class);
+                $dispatcher->setRuleFunction(function ($v) {
+                    /** @var OnTaskEvent $v */
+                    return eval("return " . $v->getRule() . ";");
+                });
+                $dispatcher->dispatchEvents();
+            } catch (Exception $e) {
+                $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+                Console::error("Uncaught exception " . get_class($e) . " when calling \"task\": " . $error_msg);
+                Console::trace();
+            } catch (Error $e) {
+                $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+                Console::error("Uncaught " . get_class($e) . " when calling \"task\": " . $error_msg);
+                Console::trace();
+            }
+        }
+    }
+}

src/ZM/Event/SwooleEvent/OnWorkerExit.php

@@ -0,0 +1,24 @@
+<?php /** @noinspection PhpUnusedParameterInspection */
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Server;
+use Swoole\Timer;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Console\Console;
+use ZM\Event\SwooleEvent;
+
+/**
+ * Class OnWorkerExit
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("WorkerExit")
+ */
+class OnWorkerExit implements SwooleEvent
+{
+    public function onCall(Server $server, $worker_id) {
+        Timer::clearAll();
+        Console::info("正在结束 Worker #".$worker_id."，进程内可能有事务在运行...");
+    }
+}

src/ZM/Event/SwooleEvent/OnWorkerStart.php

@@ -0,0 +1,232 @@
+<?php /** @noinspection PhpComposerExtensionStubsInspection */
+
+
+namespace ZM\Event\SwooleEvent;
+
+use Error;
+use Exception;
+use PDO;
+use ReflectionException;
+use Swoole\Coroutine;
+use Swoole\Database\PDOConfig;
+use Swoole\Database\PDOPool;
+use Swoole\Process;
+use Swoole\Server;
+use Swoole\Timer;
+use ZM\Annotation\AnnotationParser;
+use ZM\Annotation\Swoole\OnStart;
+use ZM\Annotation\Swoole\OnSwooleEvent;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Config\ZMConfig;
+use ZM\Console\Console;
+use ZM\Context\Context;
+use ZM\Context\ContextInterface;
+use ZM\DB\DB;
+use ZM\Event\EventDispatcher;
+use ZM\Event\EventManager;
+use ZM\Event\SwooleEvent;
+use ZM\Exception\DbException;
+use ZM\Framework;
+use ZM\Module\QQBot;
+use ZM\Store\LightCacheInside;
+use ZM\Store\MySQL\SqlPoolStorage;
+use ZM\Store\Redis\ZMRedisPool;
+use ZM\Utils\DataProvider;
+use ZM\Utils\ProcessManager;
+use ZM\Utils\ZMUtil;
+
+/**
+ * Class OnWorkerStart
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("WorkerStart")
+ */
+class OnWorkerStart implements SwooleEvent
+{
+    public function onCall(Server $server, $worker_id) {
+        Process::signal(SIGINT, function () use ($worker_id, $server) {
+
+        });
+        unset(Context::$context[Coroutine::getCid()]);
+        if ($server->taskworker === false) {
+            Process::signal(SIGUSR1, function () use ($worker_id) {
+                Timer::clearAll();
+                ProcessManager::resumeAllWorkerCoroutines();
+            });
+            zm_atomic("_#worker_" . $worker_id)->set($server->worker_pid);
+            if (LightCacheInside::get("wait_api", "wait_api") !== null) {
+                LightCacheInside::unset("wait_api", "wait_api");
+            }
+            try {
+                register_shutdown_function(function () use ($server) {
+                    $error = error_get_last();
+                    if ($error["type"] != 0) {
+                        Console::error("Internal fatal error: " . $error["message"] . " at " . $error["file"] . "({$error["line"]})");
+                    }
+                    //DataProvider::saveBuffer();
+                    /** @var Server $server */
+                    if (server() === null) $server->shutdown();
+                    else server()->shutdown();
+                });
+
+                Console::verbose("Worker #{$server->worker_id} 启动中");
+                Framework::$server = $server;
+                //ZMBuf::resetCache(); //清空变量缓存
+                //ZMBuf::set("wait_start", []); //添加队列，在workerStart运行完成前先让其他协程等待执行
+                foreach ($server->connections as $v) {
+                    $server->close($v);
+                }
+
+                //TODO: 单独抽出来MySQL和Redis连接池
+                if (ZMConfig::get("global", "sql_config")["sql_host"] != "") {
+                    if (SqlPoolStorage::$sql_pool !== null) {
+                        SqlPoolStorage::$sql_pool->close();
+                        SqlPoolStorage::$sql_pool = null;
+                    }
+                    Console::info("新建SQL连接池中");
+                    ob_start();
+                    phpinfo();
+                    $str = ob_get_clean();
+                    $str = explode("\n", $str);
+                    foreach ($str as $k => $v) {
+                        $v = trim($v);
+                        if ($v == "") continue;
+                        if (mb_strpos($v, "API Extensions") === false) continue;
+                        if (mb_strpos($v, "pdo_mysql") === false) {
+                            throw new DbException("未安装 mysqlnd php-mysql扩展。");
+                        }
+                    }
+                    $sql = ZMConfig::get("global", "sql_config");
+                    SqlPoolStorage::$sql_pool = new PDOPool((new PDOConfig())
+                        ->withHost($sql["sql_host"])
+                        ->withPort($sql["sql_port"])
+                        // ->withUnixSocket('/tmp/mysql.sock')
+                        ->withDbName($sql["sql_database"])
+                        ->withCharset('utf8mb4')
+                        ->withUsername($sql["sql_username"])
+                        ->withPassword($sql["sql_password"])
+                        ->withOptions($sql["sql_options"] ?? [PDO::ATTR_STRINGIFY_FETCHES => false])
+                    );
+                    DB::initTableList();
+                }
+
+                // 开箱即用的Redis
+                $redis = ZMConfig::get("global", "redis_config");
+                if ($redis !== null && $redis["host"] != "") {
+                    if (!extension_loaded("redis")) Console::error("Can not find redis extension.\n");
+                    else ZMRedisPool::init($redis);
+                }
+
+                $this->loadAnnotations(); //加载composer资源、phar外置包、注解解析注册等
+
+                //echo json_encode(debug_backtrace(), 128|256);
+
+                EventManager::registerTimerTick(); //启动计时器
+                //ZMBuf::unsetCache("wait_start");
+                set_coroutine_params(["server" => $server, "worker_id" => $worker_id]);
+                $dispatcher = new EventDispatcher(OnStart::class);
+                $dispatcher->setRuleFunction(function ($v) {
+                    return server()->worker_id === $v->worker_id || $v->worker_id === -1;
+                });
+                $dispatcher->dispatchEvents($server, $worker_id);
+                if ($dispatcher->status === EventDispatcher::STATUS_NORMAL) Console::debug("@OnStart 执行完毕");
+                else Console::warning("@OnStart 执行异常！");
+                Console::success("Worker #" . $worker_id . " 已启动");
+            } catch (Exception $e) {
+                Console::error("Worker加载出错！停止服务！");
+                Console::error($e->getMessage() . "\n" . $e->getTraceAsString());
+                Process::kill($server->master_pid, SIGTERM);
+                return;
+            } catch (Error $e) {
+                Console::error("PHP Error: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine());
+                Console::error("Maybe it caused by your own code if in your own Module directory.");
+                Console::log($e->getTraceAsString(), 'gray');
+                Process::kill($server->master_pid, SIGTERM);
+            }
+        } else {
+            // 这里是TaskWorker初始化的内容部分
+            try {
+                Framework::$server = $server;
+                $this->loadAnnotations();
+                Console::success("TaskWorker #" . $server->worker_id . " 已启动");
+            } catch (Exception $e) {
+                Console::error("Worker加载出错！停止服务！");
+                Console::error($e->getMessage() . "\n" . $e->getTraceAsString());
+                Process::kill($server->master_pid, SIGTERM);
+                return;
+            } catch (Error $e) {
+                Console::error("PHP Error: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine());
+                Console::error("Maybe it caused by your own code if in your own Module directory.");
+                Console::log($e->getTraceAsString(), 'gray');
+                Process::kill($server->master_pid, SIGTERM);
+            }
+        }
+    }
+
+    /**
+     * @throws ReflectionException
+     * @throws Exception
+     */
+    private function loadAnnotations() {
+        //加载phar包
+        /*Console::debug("加载外部phar包中");
+        $dir = DataProvider::getWorkingDir() . "/resources/package/";
+        if (version_compare(SWOOLE_VERSION, "4.4.0", ">=")) Timer::clearAll();
+        if (is_dir($dir)) {
+            $list = scandir($dir);
+            unset($list[0], $list[1]);
+            foreach ($list as $v) {
+                if (is_dir($dir . $v)) continue;
+                if (pathinfo($dir . $v, 4) == "phar") {
+                    Console::debug("加载Phar: " . $dir . $v . " 中");
+                    require_once($dir . $v);
+                }
+            }
+        }*/
+
+        //加载各个模块的注解类，以及反射
+        Console::debug("检索Module中");
+        $parser = new AnnotationParser();
+        $path = DataProvider::getWorkingDir() . "/src/";
+        $dir = scandir($path);
+        unset($dir[0], $dir[1]);
+        $composer = json_decode(file_get_contents(DataProvider::getWorkingDir() . "/composer.json"), true);
+        foreach ($dir as $v) {
+            if (is_dir($path . "/" . $v) && isset($composer["autoload"]["psr-4"][$v . "\\"]) && !in_array($composer["autoload"]["psr-4"][$v . "\\"], $composer["extra"]["exclude_annotate"] ?? [])) {
+                if (\server()->worker_id == 0)
+                    Console::verbose("Add " . $v . " to register path");
+                $parser->addRegisterPath(DataProvider::getWorkingDir() . "/src/" . $v . "/", $v);
+            }
+        }
+        $parser->registerMods();
+        EventManager::loadEventByParser($parser); //加载事件
+
+        //加载自定义的全局函数
+        Console::debug("加载自定义上下文中...");
+        $context_class = ZMConfig::get("global", "context_class");
+        if (!is_a($context_class, ContextInterface::class, true)) {
+            throw new Exception("Context class must implemented from ContextInterface!");
+        }
+
+        //加载插件
+        $obb_onebot = ZMConfig::get("global", "onebot") ??
+            ZMConfig::get("global", "modules")["onebot"] ??
+            ["status" => true, "single_bot_mode" => false, "message_level" => 99999];
+
+        if ($obb_onebot["status"]) {
+            $obj = new OnSwooleEvent();
+            $obj->class = QQBot::class;
+            $obj->method = 'handleByEvent';
+            $obj->type = 'message';
+            $obj->level = $obb_onebot["message_level"] ?? 99999;
+            $obj->rule = 'connectIsQQ()';
+            EventManager::addEvent(OnSwooleEvent::class, $obj);
+            if ($obb_onebot["single_bot_mode"]) {
+                LightCacheInside::set("connect", "conn_fd", -1);
+            } else {
+                LightCacheInside::set("connect", "conn_fd", -2);
+            }
+        }
+
+        //TODO: 编写加载外部插件的方式
+    }
+}

src/ZM/Event/SwooleEvent/OnWorkerStop.php

@@ -0,0 +1,27 @@
+<?php
+
+
+namespace ZM\Event\SwooleEvent;
+
+
+use Swoole\Server;
+use ZM\Annotation\Swoole\SwooleHandler;
+use ZM\Config\ZMConfig;
+use ZM\Console\Console;
+use ZM\Event\SwooleEvent;
+use ZM\Store\LightCache;
+
+/**
+ * Class OnWorkerStop
+ * @package ZM\Event\SwooleEvent
+ * @SwooleHandler("WorkerStop")
+ */
+class OnWorkerStop implements SwooleEvent
+{
+    public function onCall(Server $server, $worker_id) {
+        if ($worker_id == (ZMConfig::get("worker_cache")["worker"] ?? 0)) {
+            LightCache::savePersistence();
+        }
+        Console::verbose(($server->taskworker ? "Task" : "") . "Worker #$worker_id 已停止");
+    }
+}

src/ZM/Framework.php

@@ -5,12 +5,13 @@ namespace ZM;
 
 
 use Doctrine\Common\Annotations\AnnotationReader;
+use Error;
 use Exception;
+use Swoole\Server\Port;
 use ZM\Annotation\Swoole\OnSetup;
 use ZM\Config\ZMConfig;
 use ZM\ConnectionManager\ManagerGM;
 use ZM\Console\TermColor;
-use ZM\Event\ServerEventHandler;
 use ZM\Store\LightCache;
 use ZM\Store\LightCacheInside;
 use ZM\Store\Lock\SpinLock;
@@ -23,6 +24,7 @@ use Swoole\Runtime;
 use Swoole\WebSocket\Server;
 use ZM\Annotation\Swoole\SwooleHandler;
 use ZM\Console\Console;
+use ZM\Utils\Terminal;
 use ZM\Utils\ZMUtil;
 
 class Framework
@@ -35,25 +37,30 @@ class Framework
      * @var Server
      */
     public static $server;
+    /**
+     * @var string[]
+     */
+    public static $loaded_files = [];
     /**
      * @var array|bool|mixed|null
      */
     private $server_set;
 
+    /** @noinspection PhpUnusedParameterInspection */
     public function __construct($args = []) {
         $tty_width = $this->getTtyWidth();
 
         self::$argv = $args;
 
-        //定义常量
-        include_once "global_defines.php";
-
         ZMConfig::setDirectory(DataProvider::getWorkingDir() . '/config');
         ZMConfig::setEnv($args["env"] ?? "");
         if (ZMConfig::get("global") === false) {
             die ("Global config load failed: " . ZMConfig::$last_error . "\nPlease init first!\n");
         }
-        ZMAtomic::init();
+
+        //定义常量
+        include_once "global_defines.php";
+
         try {
             $sw = ZMConfig::get("global");
             if (!is_dir($sw["zm_data"])) mkdir($sw["zm_data"]);
@@ -74,7 +81,6 @@ class Framework
             die($e->getMessage());
         }
         try {
-
             Console::init(
                 ZMConfig::get("global", "info_level") ?? 2,
                 self::$server,
@@ -86,18 +92,26 @@ class Framework
             date_default_timezone_set($timezone);
 
             $this->server_set = ZMConfig::get("global", "swoole");
-            $this->parseCliArgs(self::$argv);
+            $this->server_set["log_level"] = SWOOLE_LOG_DEBUG;
+            $add_port = ZMConfig::get("global", "remote_terminal")["status"] ?? false;
 
+            $this->parseCliArgs(self::$argv, $add_port);
+            if (!isset($this->server_set["max_wait_time"])) {
+                $this->server_set["max_wait_time"] = 5;
+            }
+            $worker = $this->server_set["worker_num"] ?? swoole_cpu_num();
+            define("ZM_WORKER_NUM", $worker);
+            ZMAtomic::init();
             // 打印初始信息
             $out["listen"] = ZMConfig::get("global", "host") . ":" . ZMConfig::get("global", "port");
-            if (!isset(ZMConfig::get("global", "swoole")["worker_num"])) $out["worker"] = swoole_cpu_num() . " (auto)";
-            else $out["worker"] = ZMConfig::get("global", "swoole")["worker_num"];
+            if (!isset($this->server_set["worker_num"])) $out["worker"] = swoole_cpu_num() . " (auto)";
+            else $out["worker"] = $this->server_set["worker_num"];
             $out["environment"] = $args["env"] === null ? "default" : $args["env"];
             $out["log_level"] = Console::getLevel();
             $out["version"] = ZM_VERSION . (LOAD_MODE == 0 ? (" (build " . ZM_VERSION_ID . ")") : "");
             if (APP_VERSION !== "unknown") $out["app_version"] = APP_VERSION;
-            if (isset(ZMConfig::get("global", "swoole")["task_worker_num"])) {
-                $out["task_worker"] = ZMConfig::get("global", "swoole")["task_worker_num"];
+            if (isset($this->server_set["task_worker_num"])) {
+                $out["task_worker"] = $this->server_set["task_worker_num"];
             }
             if (ZMConfig::get("global", "sql_config")["sql_host"] !== "") {
                 $conf = ZMConfig::get("global", "sql_config");
@@ -114,12 +128,88 @@ class Framework
                 $out["php_version"] = PHP_VERSION;
                 $out["swoole_version"] = SWOOLE_VERSION;
             }
+            if ($add_port) {
+                $conf = ZMConfig::get("global", "remote_terminal");
+                $out["terminal"] = $conf["host"] . ":" . $conf["port"];
+            }
 
             $out["working_dir"] = DataProvider::getWorkingDir();
             self::printProps($out, $tty_width, $args["log-theme"] === null);
 
             self::$server = new Server(ZMConfig::get("global", "host"), ZMConfig::get("global", "port"));
 
+            if ($add_port) {
+                $conf = ZMConfig::get("global", "remote_terminal") ?? [
+                        'status' => true,
+                        'host' => '127.0.0.1',
+                        'port' => 20002,
+                        'token' => ''
+                    ];
+                $welcome_msg = Console::setColor("Welcome! You can use `help` for usage.", "green");
+                /** @var Port $port */
+                $port = self::$server->listen($conf["host"], $conf["port"], SWOOLE_SOCK_TCP);
+                $port->set([
+                    'open_http_protocol' => false
+                ]);
+                $port->on('connect', function (?\Swoole\Server $serv, $fd) use ($port, $welcome_msg, $conf) {
+                    ManagerGM::pushConnect($fd, "terminal");
+                    $serv->send($fd, file_get_contents(working_dir() . "/config/motd.txt"));
+                    if (!empty($conf["token"])) {
+                        $serv->send($fd, "Please input token: ");
+                    } else {
+                        $serv->send($fd, $welcome_msg . "\n>>> ");
+                    }
+                });
+
+                $port->on('receive', function ($serv, $fd, $reactor_id, $data) use ($welcome_msg, $conf) {
+                    ob_start();
+                    try {
+                        $arr = LightCacheInside::get("light_array", "input_token") ?? [];
+                        if (empty($arr[$fd] ?? '')) {
+                            if ($conf["token"] != '') {
+                                $token = trim($data);
+                                if ($token === $conf["token"]) {
+                                    SpinLock::transaction("input_token", function () use ($fd, $token) {
+                                        $arr = LightCacheInside::get("light_array", "input_token");
+                                        $arr[$fd] = $token;
+                                        LightCacheInside::set("light_array", "input_token", $arr);
+                                    });
+                                    $serv->send($fd, Console::setColor("Auth success!!\n", "green"));
+                                    $serv->send($fd, $welcome_msg . "\n>>> ");
+                                } else {
+                                    $serv->send($fd, Console::setColor("Auth failed!!\n", "red"));
+                                    $serv->close($fd);
+                                }
+                                return;
+                            }
+                        }
+                        if (trim($data) == "exit" || trim($data) == "q") {
+                            $serv->send($fd, Console::setColor("Bye!\n", "blue"));
+                            $serv->close($fd);
+                            return;
+                        }
+                        Terminal::executeCommand(trim($data));
+                    } catch (Exception $e) {
+                        $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+                        Console::error("Uncaught exception " . get_class($e) . " when calling \"open\": " . $error_msg);
+                        Console::trace();
+                    } catch (Error $e) {
+                        $error_msg = $e->getMessage() . " at " . $e->getFile() . "(" . $e->getLine() . ")";
+                        Console::error("Uncaught " . get_class($e) . " when calling \"open\": " . $error_msg);
+                        Console::trace();
+                    }
+
+                    $r = ob_get_clean();
+                    if (!empty($r)) $serv->send($fd, $r);
+                    if (!in_array(trim($data), ['r', 'reload', 'stop'])) $serv->send($fd, ">>> ");
+                });
+
+                $port->on('close', function ($serv, $fd) {
+                    ManagerGM::popConnect($fd);
+                    //echo "Client: Close.\n";
+                });
+            }
+
             self::$server->set($this->server_set);
             Console::setServer(self::$server);
             self::printMotd($tty_width);
@@ -195,7 +285,10 @@ class Framework
     }
 
     public function start() {
+        self::$loaded_files = get_included_files();
         self::$server->start();
+        zm_atomic("server_is_stopped")->set(1);
+        Console::log("zhamao-framework is stopped.");
     }
 
     /**
@@ -204,13 +297,23 @@ class Framework
      * @throws ReflectionException
      */
     private function registerServerEvents() {
-        $all_event_class = ZMConfig::get("global", "server_event_handler_class") ?? [];
-        if (!in_array(ServerEventHandler::class, $all_event_class)) {
-            $all_event_class[] = ServerEventHandler::class;
-        }
         $event_list = [];
+        $reader = new AnnotationReader();
+
+        $all = getAllClasses(FRAMEWORK_ROOT_DIR . "/src/ZM/Event/SwooleEvent/", "ZM\\Event\\SwooleEvent");
+        foreach ($all as $v) {
+            $class = new $v();
+            $reflection_class = new ReflectionClass($class);
+            $anno_class = $reader->getClassAnnotation($reflection_class, SwooleHandler::class);
+            if ($anno_class !== null) { // 类名形式的注解
+                $anno_class->class = $v;
+                $anno_class->method = "onCall";
+                $event_list[strtolower($anno_class->event)] = $anno_class;
+            }
+        }
+
+        $all_event_class = ZMConfig::get("global", "server_event_handler_class") ?? [];
         foreach ($all_event_class as $v) {
-            $reader = new AnnotationReader();
             $reflection_class = new ReflectionClass($v);
             $methods = $reflection_class->getMethods(ReflectionMethod::IS_PUBLIC);
             foreach ($methods as $vs) {
@@ -241,67 +344,80 @@ class Framework
     /**
      * 解析命令行的 $argv 参数们
      * @param $args
-     * @throws Exception
+     * @param $add_port
      */
-    private function parseCliArgs($args) {
+    private function parseCliArgs($args, &$add_port) {
         $coroutine_mode = true;
         global $terminal_id;
         $terminal_id = uuidgen();
         foreach ($args as $x => $y) {
-            switch ($x) {
-                case 'disable-coroutine':
-                    if ($y) {
+            if ($y) {
+                switch ($x) {
+                    case 'worker-num':
+                        if (intval($y) >= 1 && intval($y) <= 1024) {
+                            $this->server_set["worker_num"] = intval($y);
+                        } else {
+                            Console::warning("Invalid worker num! Turn to default value (" . ($this->server_set["worker_num"] ?? swoole_cpu_num()) . ")");
+                        }
+                        break;
+                    case 'task-worker-num':
+                        if (intval($y) >= 1 && intval($y) <= 1024) {
+                            $this->server_set["task_worker_num"] = intval($y);
+                            $this->server_set["task_enable_coroutine"] = true;
+                        } else {
+                            Console::warning("Invalid worker num! Turn to default value (0)");
+                        }
+                        break;
+                    case 'disable-coroutine':
                         $coroutine_mode = false;
-                    }
-                    break;
-                case 'debug-mode':
-                    if ($y || ZMConfig::get("global", "debug_mode")) {
+                        break;
+                    case 'debug-mode':
                         $coroutine_mode = false;
                         $terminal_id = null;
                         Console::warning("You are in debug mode, do not use in production!");
-                    }
-                    break;
-                case 'daemon':
-                    if ($y) {
+                        break;
+                    case 'daemon':
                         $this->server_set["daemonize"] = 1;
                         Console::$theme = "no-color";
                         Console::log("已启用守护进程，输出重定向到 " . $this->server_set["log_file"]);
                         $terminal_id = null;
-                    }
-                    break;
-                case 'disable-console-input':
-                case 'no-interaction':
-                    if ($y) $terminal_id = null;
-                    break;
-                case 'log-error':
-                    if ($y) Console::setLevel(0);
-                    break;
-                case 'log-warning':
-                    if ($y) Console::setLevel(1);
-                    break;
-                case 'log-info':
-                    if ($y) Console::setLevel(2);
-                    break;
-                case 'log-verbose':
-                case 'verbose':
-                    if ($y) Console::setLevel(3);
-                    break;
-                case 'log-debug':
-                    if ($y) Console::setLevel(4);
-                    break;
-                case 'log-theme':
-                    if ($y !== null) {
+                        break;
+                    case 'disable-console-input':
+                    case 'no-interaction':
+                        $terminal_id = null;
+                        break;
+                    case 'log-error':
+                        Console::setLevel(0);
+                        break;
+                    case 'log-warning':
+                        Console::setLevel(1);
+                        break;
+                    case 'log-info':
+                        Console::setLevel(2);
+                        break;
+                    case 'log-verbose':
+                    case 'verbose':
+                        Console::setLevel(3);
+                        break;
+                    case 'log-debug':
+                        Console::setLevel(4);
+                        break;
+                    case 'log-theme':
                         Console::$theme = $y;
-                    }
-                    break;
-                case 'show-php-ver':
-                default:
-                    //Console::info("Calculating ".$x);
-                    //dump($y);
-                    break;
+                        break;
+                    case 'remote-terminal':
+                        $add_port = true;
+                        break;
+                    case 'show-php-ver':
+                    default:
+                        //Console::info("Calculating ".$x);
+                        //dump($y);
+                        break;
+                }
             }
         }
         if ($coroutine_mode) Runtime::enableCoroutine(true, SWOOLE_HOOK_ALL);
+        else Runtime::enableCoroutine(false, SWOOLE_HOOK_ALL);
     }
 
     private static function writeNoDouble($k, $v, &$line_data, &$line_width, &$current_line, $colorful, $max_border) {
@@ -338,7 +454,7 @@ class Framework
                 } else {  // 输出很小，写到前面并分片
                     //Console::info("输出很小，写到前面并分片");
                     $space = intval($max_border / 2) - 2 - strlen($tmp_line);
-                    $line_data[$current_line] .= str_pad("", $space, " ");
+                    $line_data[$current_line] .= str_pad("", $space);
                     $line_data[$current_line] .= "|  "; // 添加分片
                     $line_width[$current_line] -= (strlen($tmp_line) + 3 + $space);
                 }
@@ -390,7 +506,18 @@ class Framework
         echo str_pad("", $max_border, "=") . PHP_EOL;
     }
 
-    public static function getTtyWidth() {
+    public static function getTtyWidth(): string {
         return explode(" ", trim(exec("stty size")))[1];
     }
+
+    public static function loadFrameworkState() {
+        if (!file_exists(DataProvider::getDataFolder() . ".state.json")) return [];
+        $r = json_decode(file_get_contents(DataProvider::getDataFolder() . ".state.json"), true);
+        if ($r === null) $r = [];
+        return $r;
+    }
+
+    public static function saveFrameworkState($data) {
+        return file_put_contents(DataProvider::getDataFolder() . ".state.json", json_encode($data, 64 | 128 | 256));
+    }
 }

src/ZM/Http/Response.php

@@ -1,4 +1,6 @@
-<?php
+<?php /** @noinspection PhpUnused */
+
+/** @noinspection PhpMissingReturnTypeInspection */
 
 
 namespace ZM\Http;

src/ZM/Http/RouteManager.php

@@ -9,6 +9,7 @@ use Symfony\Component\Routing\RouteCollection;
 use ZM\Annotation\Http\Controller;
 use ZM\Annotation\Http\RequestMapping;
 use ZM\Console\Console;
+use ZM\Store\LightCacheInside;
 
 class RouteManager
 {
@@ -34,4 +35,26 @@ class RouteManager
 
         self::$routes->add(md5($route_name), $route);
     }
+
+    public static function addStaticFileRoute($route, $path) {
+        $tail = trim($route, "/");
+        $route_name = ($tail === "" ? "" : "/") . $tail . "/{filename}";
+        Console::debug("添加静态文件路由：" . $route_name);
+        $route = new Route($route_name, ['_class' => RouteManager::class, '_method' => "onStaticRoute"]);
+        //echo $path.PHP_EOL;
+        LightCacheInside::set("static_route", $route->getPath(), $path);
+
+        self::$routes->add(md5($route_name), $route);
+    }
+
+    public function onStaticRoute($params) {
+        $route_path = self::$routes->get($params["_route"])->getPath();
+        if(($path = LightCacheInside::get("static_route", $route_path)) === null) {
+            ctx()->getResponse()->endWithStatus(404);
+            return false;
+        }
+        unset($params["_route"]);
+        $obj = array_shift($params);
+        return new StaticFileHandler($obj, $path);
+    }
 }

src/ZM/Module/QQBot.php

@@ -15,6 +15,8 @@ use ZM\Event\EventDispatcher;
 use ZM\Exception\InterruptException;
 use ZM\Exception\WaitTimeoutException;
 use ZM\Utils\CoMessage;
+use ZM\Utils\MessageUtil;
+use ZM\Utils\SingletonTrait;
 
 /**
  * Class QQBot
@@ -22,20 +24,28 @@ use ZM\Utils\CoMessage;
  */
 class QQBot
 {
+    use SingletonTrait;
+
+    public function handleByEvent() {
+        $data = json_decode(context()->getFrame()->data, true);
+        $this->handle($data);
+    }
+
     /**
+     * @param $data
+     * @param int $level
      * @throws InterruptException
-     * @throws Exception
      */
-    public function handle() {
+    public function handle($data, $level = 0) {
         try {
-            $data = json_decode(context()->getFrame()->data, true);
+            if ($level > 10) return;
             set_coroutine_params(["data" => $data]);
             if (isset($data["post_type"])) {
                 //echo TermColor::ITALIC.json_encode($data, 128|256).TermColor::RESET.PHP_EOL;
-                ctx()->setCache("level", 0);
+                ctx()->setCache("level", $level);
                 //Console::debug("Calling CQ Event from fd=" . ctx()->getConnection()->getFd());
                 if ($data["post_type"] != "meta_event") {
-                    $r = $this->dispatchBeforeEvents($data); // before在这里执行，元事件不执行before为减少不必要的调试日志
+                    $r = $this->dispatchBeforeEvents($data, "pre"); // before在这里执行，元事件不执行before为减少不必要的调试日志
                     if ($r->store === "block") EventDispatcher::interrupt();
                 }
                 //Console::warning("最上数据包：".json_encode($data));
@@ -43,6 +53,10 @@ class QQBot
             if (isset($data["echo"]) || isset($data["post_type"])) {
                 if (CoMessage::resumeByWS()) EventDispatcher::interrupt();
             }
+            if (($data["post_type"] ?? "meta_event") != "meta_event") {
+                $r = $this->dispatchBeforeEvents($data, "post"); // before在这里执行，元事件不执行before为减少不必要的调试日志
+                if ($r->store === "block") EventDispatcher::interrupt();
+            }
             if (isset($data["post_type"])) $this->dispatchEvents($data);
             else $this->dispatchAPIResponse($data);
         } /** @noinspection PhpRedundantCatchClauseInspection */ catch (WaitTimeoutException $e) {
@@ -52,14 +66,21 @@ class QQBot
 
     /**
      * @param $data
+     * @param $time
      * @return EventDispatcher
      * @throws Exception
      */
-    public function dispatchBeforeEvents($data) {
+    public function dispatchBeforeEvents($data, $time): EventDispatcher {
         $before = new EventDispatcher(CQBefore::class);
-        $before->setRuleFunction(function ($v) use ($data) {
-            return $v->cq_event == $data["post_type"];
-        });
+        if ($time === "pre") {
+            $before->setRuleFunction(function($v) use ($data){
+                return $v->level >= 200 && $v->cq_event == $data["post_type"];
+            });
+        } else {
+            $before->setRuleFunction(function($v) use ($data){
+                return $v->level < 200 && $v->cq_event == $data["post_type"];
+            });
+        }
         $before->setReturnFunction(function ($result) {
             if (!$result) EventDispatcher::interrupt("block");
         });
@@ -70,63 +91,25 @@ class QQBot
     /**
      * @param $data
      * @throws InterruptException
+     * @throws Exception
      */
     private function dispatchEvents($data) {
         //Console::warning("最xia数据包：".json_encode($data));
         switch ($data["post_type"]) {
             case "message":
-                $word = explodeMsg(str_replace("\r", "", context()->getMessage()));
-                if (empty($word)) $word = [""];
-                if (count(explode("\n", $word[0])) >= 2) {
-                    $enter = explode("\n", context()->getMessage());
-                    $first = split_explode(" ", array_shift($enter));
-                    $word = array_merge($first, $enter);
-                    foreach ($word as $k => $v) {
-                        $word[$k] = trim($word[$k]);
-                    }
-                }
                 //分发CQCommand事件
                 $dispatcher = new EventDispatcher(CQCommand::class);
-                $dispatcher->setRuleFunction(function (CQCommand $v) use ($word) {
-                    if (array_diff([$v->match, $v->pattern, $v->regex, $v->keyword, $v->end_with, $v->start_with], [""]) == []) return false;
-                    elseif (($v->user_id == 0 || ($v->user_id != 0 && $v->user_id == ctx()->getUserId())) &&
-                        ($v->group_id == 0 || ($v->group_id != 0 && $v->group_id == (ctx()->getGroupId() ?? 0))) &&
-                        ($v->message_type == '' || ($v->message_type != '' && $v->message_type == ctx()->getMessageType()))
-                    ) {
-                        if (($word[0] != "" && $v->match == $word[0]) || in_array($word[0], $v->alias)) {
-                            array_shift($word);
-                            ctx()->setCache("match", $word);
-                            return true;
-                        } elseif ($v->start_with != "" && mb_strpos(ctx()->getMessage(), $v->start_with) === 0) {
-                            ctx()->setCache("match", [mb_substr(ctx()->getMessage(), mb_strlen($v->start_with))]);
-                            return true;
-                        } elseif ($v->end_with != "" && strlen(ctx()->getMessage()) == (strripos(ctx()->getMessage(), $v->end_with) + strlen($v->end_with))) {
-                            ctx()->setCache("match", [substr(ctx()->getMessage(), 0, strripos(ctx()->getMessage(), $v->end_with))]);
-                            return true;
-                        } elseif ($v->keyword != "" && mb_strpos(ctx()->getMessage(), $v->keyword) !== false) {
-                            ctx()->setCache("match", explode($v->keyword, ctx()->getMessage()));
-                            return true;
-                        } elseif ($v->pattern != "") {
-                            $match = matchArgs($v->pattern, ctx()->getMessage());
-                            if ($match !== false) {
-                                ctx()->setCache("match", $match);
-                                return true;
-                            }
-                        } elseif ($v->regex != "") {
-                            if (preg_match("/" . $v->regex . "/u", ctx()->getMessage(), $word2) != 0) {
-                                ctx()->setCache("match", $word2);
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                });
                 $dispatcher->setReturnFunction(function ($result) {
                     if (is_string($result)) ctx()->reply($result);
                     if (ctx()->getCache("has_reply") === true) EventDispatcher::interrupt();
                 });
-                $dispatcher->dispatchEvents();
-                if ($dispatcher->status == EventDispatcher::STATUS_INTERRUPTED) EventDispatcher::interrupt();
+                $s = MessageUtil::matchCommand(ctx()->getMessage(), ctx()->getData());
+                if ($s->status !== false) {
+                    if (!empty($s->match)) ctx()->setCache("match", $s->match);
+                    $dispatcher->dispatchEvent($s->object, null);
+                    if (is_string($dispatcher->store)) ctx()->reply($dispatcher->store);
+                    if (ctx()->getCache("has_reply") === true) EventDispatcher::interrupt();
+                }
 
                 //分发CQMessage事件
                 $msg_dispatcher = new EventDispatcher(CQMessage::class);

src/ZM/Store/LightCache.php

@@ -7,17 +7,16 @@ namespace ZM\Store;
 use Exception;
 use Swoole\Table;
 use ZM\Annotation\Swoole\OnSave;
-use ZM\Config\ZMConfig;
 use ZM\Console\Console;
 use ZM\Event\EventDispatcher;
 use ZM\Exception\ZMException;
+use ZM\Framework;
+use ZM\Utils\ProcessManager;
 
 class LightCache
 {
     /** @var Table|null */
     private static $kv_table = null;
-    /** @var Table|null */
-    private static $kv_lock = null;
 
     private static $config = [];
 
@@ -27,6 +26,7 @@ class LightCache
      * @param $config
      * @return bool|mixed
      * @throws Exception
+     * @noinspection PhpMissingReturnTypeInspection
      */
     public static function init($config) {
         self::$config = $config;
@@ -35,14 +35,13 @@ class LightCache
         self::$kv_table->column("expire", Table::TYPE_INT);
         self::$kv_table->column("data_type", Table::TYPE_STRING, 8);
         $result = self::$kv_table->create();
-        self::$kv_lock = new Table($config["size"], $config["hash_conflict_proportion"]);
-        $result = $result && self::$kv_lock->create();
+        // 加载内容
         if ($result === true && isset($config["persistence_path"])) {
             if (file_exists($config["persistence_path"])) {
                 $r = json_decode(file_get_contents($config["persistence_path"]), true);
                 if ($r === null) $r = [];
                 foreach ($r as $k => $v) {
-                    $write = self::set($k, $v, -2);
+                    $write = self::set($k, $v);
                     Console::verbose("Writing LightCache: " . $k);
                     if ($write === false) {
                         self::$last_error = '可能是由于 Hash 冲突过多导致动态空间无法分配内存';
@@ -53,6 +52,31 @@ class LightCache
         }
         if ($result === false) {
             self::$last_error = '系统内存不足，申请失败';
+        } else {
+            $obj = Framework::loadFrameworkState();
+            foreach(($obj["expiring_light_cache"] ?? []) as $k => $v) {
+                $value = $v["value"];
+                if (is_array($value)) {
+                    $value = json_encode($value, JSON_UNESCAPED_UNICODE);
+                    if (strlen($value) >= self::$config["max_strlen"]) return false;
+                    $data_type = "json";
+                } elseif (is_string($value)) {
+                    $data_type = "";
+                } elseif (is_int($value)) {
+                    $data_type = "int";
+                } elseif (is_bool($value)) {
+                    $data_type = "bool";
+                    $value = json_encode($value);
+                } else {
+                    return false;
+                }
+                $result = self::$kv_table->set($k, [
+                    "value" => $value,
+                    "expire" => $v["expire"],
+                    "data_type" => $data_type
+                ]);
+                if ($result === false) return false;
+            }
         }
         return $result;
     }
@@ -81,12 +105,26 @@ class LightCache
         return $r === false ? null : $r - time();
     }
 
+    /**
+     * @param string $key
+     * @return mixed|null
+     * @throws ZMException
+     * @since 2.4.3
+     */
+    public static function getExpireTS(string $key) {
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
+        self::checkExpire($key);
+        $r = self::$kv_table->get($key, "expire");
+        return $r === false ? null : $r;
+    }
+
     /**
      * @param string $key
      * @param string|array|int $value
      * @param int $expire
      * @return mixed
      * @throws ZMException
+     * @noinspection PhpMissingReturnTypeInspection
      */
     public static function set(string $key, $value, int $expire = -1) {
         if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
@@ -120,6 +158,7 @@ class LightCache
      * @param $value
      * @return bool|mixed
      * @throws ZMException
+     * @noinspection PhpMissingReturnTypeInspection
      */
     public static function update(string $key, $value) {
         if (self::$kv_table === null) throw new ZMException("not initialized LightCache.");
@@ -154,7 +193,7 @@ class LightCache
      * @return bool
      * @throws Exception
      */
-    public static function isset(string $key) {
+    public static function isset(string $key): bool {
         return self::get($key) !== null;
     }
 
@@ -162,7 +201,7 @@ class LightCache
         return self::$kv_table->del($key);
     }
 
-    public static function getAll() {
+    public static function getAll(): array {
         $r = [];
         $del = [];
         foreach (self::$kv_table as $k => $v) {
@@ -178,31 +217,73 @@ class LightCache
         return $r;
     }
 
-    public static function savePersistence($only_worker = false) {
-
-        // 下面将OnSave激活一下
-        if (server()->worker_id == (ZMConfig::get("global", "worker_cache")["worker"] ?? 0)) {
-            $dispatcher = new EventDispatcher(OnSave::class);
-            $dispatcher->dispatchEvents();
+    public static function addPersistence($key) {
+        if (file_exists(self::$config["persistence_path"])) {
+            $r = json_decode(file_get_contents(self::$config["persistence_path"]), true);
+            if ($r === null) $r = [];
+            if (!isset($r[$key])) $r[$key] = null;
+            file_put_contents(self::$config["persistence_path"], json_encode($r, 64 | 128 | 256));
+            return true;
+        } else {
+            return false;
         }
+    }
 
-        if($only_worker) return;
+    public static function removePersistence($key) {
+        if (file_exists(self::$config["persistence_path"])) {
+            $r = json_decode(file_get_contents(self::$config["persistence_path"]), true);
+            if ($r === null) $r = [];
+            if (isset($r[$key])) unset($r[$key]);
+            file_put_contents(self::$config["persistence_path"], json_encode($r, 64 | 128 | 256));
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 这个只能在唯一一个工作进程中执行
+     * @throws Exception
+     */
+    public static function savePersistence() {
+        if (server()->worker_id !== MAIN_WORKER) {
+            ProcessManager::sendActionToWorker(MAIN_WORKER, "save_persistence", []);
+            return;
+        }
+        $dispatcher = new EventDispatcher(OnSave::class);
+        $dispatcher->dispatchEvents();
 
         if (self::$kv_table === null) return;
-        $r = [];
-        foreach (self::$kv_table as $k => $v) {
-            if ($v["expire"] === -2) {
+
+        if (!empty(self::$config["persistence_path"])) {
+            $r = json_decode(file_get_contents(self::$config["persistence_path"]), true);
+            if ($r === null) $r = [];
+            foreach ($r as $k => $v) {
                 Console::verbose("Saving " . $k);
-                $r[$k] = self::parseGet($v);
+                $r[$k] = self::get($k);
+            }
+            file_put_contents(self::$config["persistence_path"], json_encode($r, 64 | 128 | 256));
+        }
+
+        $obj = Framework::loadFrameworkState();
+        $obj["expiring_light_cache"] = [];
+        $del = [];
+        foreach (self::$kv_table as $k => $v) {
+            if ($v["expire"] <= time() && $v["expire"] >= 0) {
+                $del[] = $k;
+                continue;
+            } elseif ($v["expire"] > time()) {
+                $obj["expiring_light_cache"][$k] = [
+                    "expire" => $v["expire"],
+                    "value" => self::parseGet($v)
+                ];
             }
         }
-        if (self::$config["persistence_path"] == "") return;
-        if (file_exists(self::$config["persistence_path"])) {
-            $r = file_put_contents(self::$config["persistence_path"], json_encode($r, 128 | 256));
-            if ($r === false) Console::error("Not saved, please check your \"persistence_path\"!");
+        foreach ($del as $v) {
+            self::unset($v);
         }
-
-
+        Framework::saveFrameworkState($obj);
+        Console::verbose("Saved.");
     }
 
     private static function checkExpire($key) {

src/ZM/Store/LightCacheInside.php

@@ -13,11 +13,15 @@ class LightCacheInside
     /** @var Table[]|null */
     private static $kv_table = [];
 
-    public static $last_error = '';
-
-    public static function init() {
-        self::createTable("wait_api", 3, 65536);    //用于存协程等待的状态内容的
-        self::createTable("connect", 3, 64);        //用于存单机器人模式下的机器人fd的
+    public static function init(): bool {
+        try {
+            self::createTable("wait_api", 3, 65536);
+            self::createTable("connect", 3, 64);        //用于存单机器人模式下的机器人fd的
+            self::createTable("static_route", 64, 256);//用于存储
+            self::createTable("light_array", 8, 512, 0.6);
+        } catch (ZMException $e) {
+            return false;
+        }    //用于存协程等待的状态内容的
         //self::createTable("worker_start", 2, 1024);//用于存启动服务器时的状态的
         return true;
     }
@@ -26,10 +30,8 @@ class LightCacheInside
      * @param string $table
      * @param string $key
      * @return mixed|null
-     * @throws ZMException
      */
     public static function get(string $table, string $key) {
-        if (!isset(self::$kv_table[$table])) throw new ZMException("not initialized LightCache");
         $r = self::$kv_table[$table]->get($key);
         return $r === false ? null : json_decode($r["value"], true);
     }
@@ -39,10 +41,8 @@ class LightCacheInside
      * @param string $key
      * @param string|array|int $value
      * @return mixed
-     * @throws ZMException
      */
-    public static function set(string $table, string $key, $value) {
-        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
+    public static function set(string $table, string $key, $value): bool {
         try {
             return self::$kv_table[$table]->set($key, [
                 "value" => json_encode($value, 256)
@@ -60,10 +60,11 @@ class LightCacheInside
      * @param $name
      * @param $size
      * @param $str_size
+     * @param int $conflict_proportion
      * @throws ZMException
      */
-    private static function createTable($name, $size, $str_size) {
-        self::$kv_table[$name] = new Table($size, 0);
+    private static function createTable($name, $size, $str_size, $conflict_proportion = 0) {
+        self::$kv_table[$name] = new Table($size, $conflict_proportion);
         self::$kv_table[$name]->column("value", Table::TYPE_STRING, $str_size);
         $r = self::$kv_table[$name]->create();
         if ($r === false) throw new ZMException("内存不足，创建静态表失败！");

src/ZM/Store/Lock/SpinLock.php

@@ -1,4 +1,4 @@
-<?php
+<?php /** @noinspection PhpUnused */
 
 
 namespace ZM\Store\Lock;
@@ -7,6 +7,7 @@ namespace ZM\Store\Lock;
 use Swoole\Coroutine;
 use Swoole\Coroutine\System;
 use Swoole\Table;
+use ZM\Console\Console;
 
 class SpinLock
 {
@@ -29,7 +30,7 @@ class SpinLock
         }
     }
 
-    public static function tryLock(string $key) {
+    public static function tryLock(string $key): bool {
         if (($r = self::$kv_lock->incr($key, 'lock_num')) > 1) {
             return false;
         }

src/ZM/Store/Redis/ZMRedis.php

@@ -1,4 +1,6 @@
-<?php /** @noinspection PhpComposerExtensionStubsInspection */
+<?php /** @noinspection PhpUnused */
+
+/** @noinspection PhpComposerExtensionStubsInspection */
 
 
 namespace ZM\Store\Redis;
@@ -36,7 +38,7 @@ class ZMRedis
     /**
      * @return Redis
      */
-    public function get() {
+    public function get(): Redis {
         return $this->conn;
     }