update to 2.2.5 version again

add transaction for SpinLock.php add getAllCQ() for CQ.php fix CQ bug update docs
update to 2.2.5 version
2026-07-03 23:05:37 +08:00 · 2021-02-20 16:57:19 +08:00 · 2021-02-15 15:15:26 +08:00 · 2021-02-09 17:09:26 +08:00 · 2021-02-09 17:09:09 +08:00 · 2021-02-09 11:12:29 +08:00
68 changed files with 1567 additions and 304 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ composer.lock
 /bin/.phpunit.result.cache
 /resources/zhamao.service
 .phpunit.result.cache
+.daemon_pid
--- a/README.md
+++ b/README.md
@@ -6,21 +6,19 @@
 [![作者QQ](https://img.shields.io/badge/作者QQ-627577391-orange.svg)]()
 [![zhamao License](https://img.shields.io/hexpm/l/plug.svg?maxAge=2592000)](https://github.com/zhamao-robot/zhamao-framework/blob/master/LICENSE)
 [![Latest Stable Version](http://img.shields.io/packagist/v/zhamao/framework.svg)](https://packagist.org/packages/zhamao/framework)
-[![Banner](https://img.shields.io/badge/CQHTTP-v11-black)]()
+[![Banner](https://img.shields.io/badge/OneBot-v11-black)]()

-[![stupid counter](https://img.shields.io/github/search/zhamao-robot/zhamao-framework/stupid.svg)](https://github.com/zhamao-robot/zhamao-framework/search?q=stupid)
-[![TODO counter](https://img.shields.io/github/search/zhamao-robot/zhamao-framework/TODO.svg)](https://github.com/zhamao-robot/zhamao-framework/search?q=TODO)
+[![注解数量](https://img.shields.io/github/search/zhamao-robot/zhamao-framework/AnnotationBase.svg)](https://github.com/zhamao-robot/zhamao-framework/search?q=AnnotationBase)
+[![TODO 数量](https://img.shields.io/github/search/zhamao-robot/zhamao-framework/TODO.svg)](https://github.com/zhamao-robot/zhamao-framework/search?q=TODO)

 </div>

 ## 开发者注意
-**开发者 QQ 群：670821194**
+开发者 QQ 群：**670821194**

-**当前 v2 版本已正式发布，此 master 分支为 2.0 版本，如需查看 v1 版本，请移步 `v1-legacy` 分支！**
+当前 v2 版本已正式发布，此 master 分支为 2.0 版本，如需查看 v1 版本，请移步 `v1-legacy` 分支！

-**2.0 版本如果有问题请第一时间加群反馈！**
-
-有关 3.0 版本的最新情况，请看这里：[Issue #22](https://github.com/zhamao-robot/zhamao-framework/issues/22)
+2.0 版本如果有问题请第一时间加群反馈！

 ## 简介
 炸毛框架使用 PHP 编写，采用 Swoole 扩展为基础，主要面向 API 服务，聊天机器人（OneBot 兼容的 QQ 机器人对接），包含 Websocket、HTTP 等监听和请求库，用户代码采用模块化处理，使用注解可以方便地编写各类功能。
@@ -53,16 +51,15 @@ public function index() {
 自行构建文档：`mkdocs build -d distribute`

 ## 特点
- 支持多账号
+- 原生为多账号设计，支持多个机器人负载均衡
 - 使用 Swoole 多工作进程机制和协程加持，尽可能简单的情况下提升了性能
 - 灵活的注解事件绑定机制
- 支持下断点调试（Psysh）
 - 易用的上下文，模块内随处可用
- 采用模块化编写，可单独拆装功能
- 常驻内存，全局缓存变量随处使用
+- 采用模块化编写，可自由搭配其他 composer 组件
+- 常驻内存，全局缓存变量随处使用，提供多种缓存方案
 - 自带 MySQL、Redis 等数据库连接池等数据库连接方案
- 自带 HTTP 服务器、WebSocket 服务器可复用，可以构建属于自己的 HTTP API 接口
- 静态文件服务器
+- 本身为 HTTP 服务器、WebSocket 服务器，可以构建属于自己的 HTTP API 接口
+- 静态文件服务器，可将前端合并到一起

 ## 从 v1 升级
 炸毛框架 v2 相对 v1 版本改动了不少内容，其中包括框架底层机制、注解事件分发、调试、命名空间等变化，详情可查看上方文档。
@@ -70,11 +67,13 @@ public function index() {
 如果旧版框架使用过程中无问题且对新功能暂无需求，可以继续使用 v1 版本，后续也将维护安全类更新和修复致命 bug。

 ## 贡献和捐赠
-如果你在使用过程中发现任何问题，可以提交 Issue 或自行 Fork 后修改并提交 Pull Request。目前项目仅一人维护，耗费精力较大，所以非常欢迎对框架的贡献。
+如果你在使用过程中发现任何问题，可以提交 Issue 或自行 Fork 后修改并提交 Pull Request。
+
+目前项目仅一人维护，耗费精力较大，所以非常欢迎对框架的贡献。

 本项目为作者闲暇时间开发，如果觉得好用，不妨进行捐助～你的捐助会让我更加有动力完善插件，感谢你的支持！

-我们会将捐赠的资金用于本项目驱动的炸毛机器人和框架文档的服务器开销上。
+我们会将捐赠的资金用于本项目驱动的炸毛机器人和框架文档的服务器开销上。[捐赠列表](https://github.com/zhamao-robot/thanks)

 ### 支付宝
 ![支付宝二维码](/resources/images/alipay_img.jpg)
@@ -94,4 +93,6 @@ public function index() {

 **注意**：在你使用 mirai 等 `AGPL-3.0` 协议的机器人软件与框架连接时，使用本框架需要将你编写或修改的部分使用 `AGPL-3.0` 协议重新分发。

+在贡献代码时，请保管好自己的全局配置文件中的敏感信息，请勿将带有个人信息的配置文件上传 GitHub 等网站。
+
 ![star](https://starchart.cc/zhamao-robot/zhamao-framework.svg)
--- a/composer.json
+++ b/composer.json
@@ -3,7 +3,7 @@
    "description": "High performance QQ robot and web server development framework",
    "minimum-stability": "stable",
    "license": "Apache-2.0",
-    "version": "2.1.6",
+    "version": "2.2.5",
    "extra": {
        "exclude_annotate": [
            "src/ZM"
@@ -37,7 +37,8 @@
        "zhamao/config": "^1.0",
        "zhamao/request": "*@dev",
        "symfony/routing": "^5.1",
-        "symfony/polyfill-php80": "^1.20"
+        "symfony/polyfill-php80": "^1.20",
+        "ext-posix": "*"
    },
    "suggest": {
        "ext-ctype": "*",
@@ -52,6 +53,7 @@
        ]
    },
    "require-dev": {
-        "swoole/ide-helper": "@dev"
+        "swoole/ide-helper": "@dev",
+        "phpunit/phpunit": "^9.5"
    }
-}
+}
--- a/config/global.php
+++ b/config/global.php
@@ -36,13 +36,19 @@ $config['swoole'] = [

 /** 轻量字符串缓存，默认开启 */
 $config['light_cache'] = [
-    'size' => 1024,                     //最多允许储存的条数（需要2的倍数）
-    'max_strlen' => 16384,               //单行字符串最大长度（需要2的倍数）
+    'size' => 512,                     //最多允许储存的条数（需要2的倍数）
+    'max_strlen' => 32768,               //单行字符串最大长度（需要2的倍数）
    'hash_conflict_proportion' => 0.6,   //Hash冲突率（越大越好，但是需要的内存更多）
    'persistence_path' => $config['zm_data'].'_cache.json',
    'auto_save_interval' => 900
 ];

+/** 大容量跨进程变量存储（2.2.0可用） */
+$config["worker_cache"] = [
+    "worker" => 0,
+    "transaction_timeout" => 30000
+];
+
 /** MySQL数据库连接信息，host留空则启动时不创建sql连接池 */
 $config['sql_config'] = [
    'sql_host' => '',
@@ -72,7 +78,7 @@ $config["access_token"] = '';

 /** HTTP服务器固定请求头的返回 */
 $config['http_header'] = [
-    'X-Powered-By' => 'zhamao-framework',
+    'Server' => 'zhamao-framework',
    'Content-Type' => 'text/html; charset=utf-8'
 ];

--- a/docs/advanced/custom-start.md
+++ b/docs/advanced/custom-start.md
@@ -91,6 +91,18 @@ bin/start server # 通过源码模式启动框架
 - `--watch`：监控 `src/` 目录下的文件变化，有变化则自动重新载入代码。开启监控需要安装 PHP 扩展：inotify。使用 pecl 就可以安装：`pecl install inotify`。
 - `--env`：设置运行环境，设置运行环境后将优先加载指定环境的配置文件，支持 `--env=production`，`--env=staging`，`--env=development`，见 [基本配置](/guide/basic-config/#_2)。

+## 守护进程操作命令
+
+守护进程在 2.2.0 版本开始，可以使用命令行快速操作，如重启、停止、查看状态等。
+
+注意，这里的守护进程操作命令是指 **使用 `--daemon` 方式启动的框架**，如使用 Docker、screen、tmux 等方式挂后台跑则此命令不可用！
+
+```bash
+vendor/bin/start daemon:status # 查看守护进程的状态
+vendor/bin/start daemon:reload # 重载框架
+vendor/bin/start daemon:stop # 停止运行守护进程的框架
+```
+
 ## 独立启动其他组件

 框架默认不止启动框架的 `server` 命令，还有 `init` 命令和 `simple-http-server` 命令。`init` 命令在上方 Composer 依赖模式中提到过，就是初始化各个文件的。
--- a/docs/advanced/example/admin.md
+++ b/docs/advanced/example/admin.md
@@ -0,0 +1,231 @@
+# 编写管理员专属功能
+
+众所周知，如果大家使用炸毛框架来开发聊天机器人的话，会比较方便。但是有些地方你一定会感觉还是欠缺了点，比如下面这样，你想编写一个只能由机器人管理员，也就是你自己，才能触发的功能：
+
+```php
+/**
+ * @CQCommand(match="禁言",message_type="group")
+ */
+public function banSomeone() {
+    $r1 = ctx()->getNextArg("请输入禁言的人或at他");
+    $r2 = ctx()->getFullArg("请输入禁言的时间（秒）");
+    $cq = CQ::getCQ($r1);
+    if ($cq !== null) {
+        if ($cq["type"] != "at") return "请at或者输入正确的QQ号！";
+        $r1 = $cq["params"]["qq"];
+    }
+    // 群内禁言用户
+    ctx()->getRobot()->setGroupBan(ctx()->getGroupId(), $r1, $r2);
+    return "禁言成功！";
+}
+```
+
+这时候，如果只是自己有绝对的权利，可以将自己的 QQ 号写死在注解 `@CQCommand` 中，并限定 `user_id`（假设我的 QQ 号码为 123456）：
+
+```php
+/**
+ * @CQCommand(match="禁言",message_type="group",user_id=123456)
+ */
+```
+
+但是，随着时间的推移，你的机器人伙伴群可能越来越大，这个命令可能不止需要绝对的你来使用，你还要将机器人的部分权利下发给更多的伙伴，怎么办呢？注解里面只能写死的。
+
+答案很简单，这时候我们就需要用到框架提供的中间件（Middleware）。中间件说白了就是在事件执行前、后、过程中抛出的异常对其进行阻断和插入代码，比如我们上方在触发禁言这个注解事件前首先要判断执行这个命令的是不是钦定的管理员。
+
+## 第一步：定义中间件
+
+首先，我们需要定义一个中间件。在框架默认提供的脚手架中，包含了一个叫 `TimerMiddleware.php` 的示例中间件，这个示例中间件的目的是非常简单的，就是判断这个注解事件运行了多长时间。假设你有一个机器人功能，这个功能下的代码需要执行很长时间，可以使用这一注解轻松将事件执行的时间打印到终端上。
+
+关于中间件的有关说明，见 [中间件](/event/middleware)。
+
+下面我们假设你已经阅读过中间件注解的文档了，我们着手编写一个判断指令执行者是否是指定的管理员 QQ 的中间件。为了省事和让大家方便地复现，我先在脚手架下的目录 `src/Module/Middleware/` 下新建 PHP 类文件 `AdminMiddleware.php`（和 `TimerMiddleware.php` 在同一个目录）。
+
+```php
+<?php
+
+namespace Module\Middleware;
+
+use ZM\Annotation\Http\HandleBefore;
+use ZM\Annotation\Http\MiddlewareClass;
+use ZM\Exception\ZMException;
+use ZM\Http\MiddlewareInterface;
+use ZM\Store\LightCache;
+
+/**
+ * Class AdminMiddleware
+ * 示例中间件：用于动态管理一些管理员指令的中间件
+ * @package Module\Middleware
+ * @MiddlewareClass("admin")
+ */
+class AdminMiddleware implements MiddlewareInterface
+{
+    /**
+     * @HandleBefore()
+     * @return bool
+     * @throws ZMException
+     */
+    public function onBefore(): bool {
+        $r = ctx()->getUserId(); // 从上下文获取发消息的用户 QQ
+        $admin_list = LightCache::get("admin_list") ?? []; // 从轻量缓存获取管理员列表
+        return in_array($r, $admin_list); // 返回这个 QQ 是否在管理员列表中
+    }
+}
+```
+
+其中，`@MiddlewareClass("admin")` 的意思是，定义这个类为名字叫 `admin` 的中间件，同时，所有中间件的类**必须**带上 `implements MiddlewareInterface`，统一接口形式。
+
+`@HandleBefore()` 代表的是，这个类下的这个函数（onBefore）被标注为这个中间件的 `onBefore` 事件，也就是说，如果有别的注解事件插入了这个 `admin` 中间件，那么执行对应注解事件前都要执行一下 `@HandleBefore` 所绑定的这个函数。而这个绑定的函数只能返回 `bool` 类型的值哦！
+
+## 第二步：使用中间件
+
+使用中间件很简单，在需要阻断的注解事件绑定的函数上再加一个注解就好了！我们以上方的禁言例子说明：
+
+```php
+/**
+ * @Middleware("admin")
+ * @CQCommand(match="禁言",message_type="group")
+ */
+```
+
+<chat-box>
+^ 假设我是管理员
+) 禁言 1234567 600
+( 禁言成功！
+^ 假设我不在管理员名单里
+) 禁言 1234567 900
+^ 机器人没有回复，因为中间件返回了 false，不继续执行
+</chat-box>
+
+而这时候有朋友又要问了，如果我有一系列管理员命令，假设都在一个叫 `AdminFunc.php` 的模块类里，我是不是还得一个一个地给注解事件写 `@Middleware("admin")` 呢？当然不需要！如果你这个类所有的注解事件都是机器人的聊天事件（`@CQCommand`，`@CQMessage`）的话，可以直接给类注解这个中间件，效果等同于给每一个函数写一次中间件注解。
+
+```php
+<?php
+
+namespace Module\Example;
+
+use ZM\Annotation\Http\Middleware;
+
+/**
+ * Class AdminFunc
+ * @package Module\Example
+ * @Middleware("admin")
+ */
+class AdminFunc
+{ 
+    // ...这里是你的一堆注解事件的函数
+}
+```
+
+## 第三步：补全代码
+
+上面我们讲到了，中间件里面使用了 `LightCache` 轻量缓存来储存临时的管理员列表，那么我们将这部分的代码完善吧！
+
+=== "src/Module/Example/AdminFunc.php"
+
+	```php
+	<?php
+
+    namespace Module\Example;
+
+    use ZM\Annotation\CQ\CQCommand;
+    use ZM\Annotation\Http\Middleware;
+    use ZM\API\CQ;
+
+    /**
+     * Class AdminFunc
+     * @package Module\Example
+     * @Middleware("admin")
+     */
+    class AdminFunc
+    {
+        /**
+         * @CQCommand(match="禁言",message_type="group")
+         */
+        public function banSomeone() {
+            $r1 = ctx()->getNextArg("请输入禁言的人或at他");
+            $r2 = ctx()->getFullArg("请输入禁言的时间（秒）");
+            $cq = CQ::getCQ($r1);
+            if ($cq !== null) {
+                if ($cq["type"] != "at") return "请at或者输入正确的QQ号！";
+                $r1 = $cq["params"]["qq"];
+            }
+            // 群内禁言用户
+            ctx()->getRobot()->setGroupBan(ctx()->getGroupId(), $r1, $r2);
+            return "禁言成功！";
+        }
+
+        /**
+         * @CQCommand(match="解除禁言",message_type="group")
+         */
+        public function unbanSomeone() {
+            $r1 = ctx()->getNextArg("请输入禁言的人或at他");
+            $cq = CQ::getCQ($r1);
+            if ($cq !== null) {
+                if ($cq["type"] != "at") return "请at或者输入正确的QQ号！";
+                $r1 = $cq["params"]["qq"];
+            }
+            // 群内禁言用户
+            ctx()->getRobot()->setGroupBan(ctx()->getGroupId(), $r1, 0);
+            return "解除禁言成功！";
+        }
+    }
+    ```
+
+=== "src/Module/Example/AdminManager.php"
+
+	```php
+	<?php
+
+    namespace Module\Example;
+
+    use ZM\Annotation\CQ\CQCommand;
+    use ZM\Annotation\Http\Middleware;
+    use ZM\Annotation\Swoole\OnStart;
+    use ZM\Store\LightCache;
+    use ZM\Store\Lock\SpinLock;
+
+    class AdminManager
+    {
+        /**
+         * @OnStart()
+         */
+        public function onStart() {
+            if (!LightCache::isset("admin_list")) { //一次性代码，首次执行才会执行if
+                LightCache::set("admin_list", [ // 框架启动时初始化管理员列表
+                    "123456",
+                    "234567"
+                ], -2); // 这里用 -2 的原因是将这一列表持久化保存，避免关闭框架后丢失
+            }
+        }
+
+        /**
+         * @CQCommand(match="添加管理员")
+         * @Middleware("admin")
+         */
+        public function addAdmin() { //只有管理员才能添加管理员
+            $qq = ctx()->getNextArg("请输入要添加管理员的QQ(qq号码，不可at）");
+            SpinLock::lock("admin_list");        //如果是多进程模式的话需要加锁
+            $ls = LightCache::get("admin_list");
+            if (!in_array($qq, $ls)) $ls[] = $qq;
+            LightCache::set("admin_list", $ls, -2);
+            SpinLock::unlock("admin_list");      //如果是多进程模式的话需要加锁
+            return "成功添加 $qq 到管理员列表！";
+        }
+    }
+	```
+	
+<chat-box>
+^ 现在我是 123456
+) 禁言 13579 60
+( 禁言成功！
+) 解除禁言 13579
+( 解除禁言成功！
+) 添加管理员 98765
+( 成功添加 98765 到管理员列表！
+^ 现在我是98765
+) 禁言 13579
+( 请输入禁言的时间（秒）
+) 120
+( 禁言成功！
+</chat-box>
+
--- a/docs/advanced/multi-process.md
+++ b/docs/advanced/multi-process.md
@@ -0,0 +1,70 @@
+# 框架多进程
+
+首先对于多进程概念，对于传统 PHP 程序员可能比较陌生，唯一接触到的地方可能就是 php-fpm 等一些方式处理时间长的请求时开进程去执行。关于多进程，我觉得廖雪峰的 Python 多进程这段讲的不错：
+
+> Unix/Linux 操作系统提供了一个`fork()`系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是`fork()`调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。
+
+这里面的重点在于，多进程的创建，是父进程的复制，然后两个进程接下来运行的代码和存的内容就分道扬镳了。
+
+PHP 也是如此，框架的多进程又是怎么一回事呢？为什么要采用多进程呢？
+
+## 作用
+
+使用过框架的你一定知道，框架是以命令行方式运行 PHP 的，而命令行方式运行 PHP，就代表要常驻内存，就像 Python、Node.js 一样。而默认情况下，比如 Python 的 Flask 为单线程单进程模式，也就是说同时只能处理一个 Web 请求。但大部分情况下，比如 Node.js，提供的都是异步 I/O，这也就是说明它在 Web 处理请求上，可同时承接的 I/O 密集型请求会更多一些，这样在对一般的 Web 应用中 I/O 密集型场景非常有用，而且往往只需要单进程也可以承载上万的并发请求。
+
+在炸毛框架中，因为框架基于 Swoole 构建，所以天然支持协程，而协程就是针对 I/O 操作进行一个调度，类似异步的 Node.js，所以针对项目中存在太多的 SQL 语句执行、文件读写的话，炸毛框架直接上手，无需做任何修改，也可以达到很好的性能。
+
+**但是**，CPU 密集型的应用怎么办呢？假设我的 Web 应用有大量的排序、md5 运算怎么办呢？这样的阻塞，假设是一个超级大的 for 循环或者是要执行很长时间的 while 循环，CPU 一直在被占用。多进程就是针对 CPU 密集型的应用说 yes 的一个方案。
+
+![Untitled Diagram (1)](../assets/img/single-process.png)
+
+我们假设现在有 3 个请求同时访问，也就是说上面的流程需要执行 3 遍。而如果我们只有一个进程的话，最后一个请求需要等待的时间为 `2*3+5*3=21` 秒，非常耗时。
+
+而如果有两个进程处理 3 个请求，则最后一个完成的请求就缩短了，`2+5+2+5=14` 秒。
+
+![Untitled Diagram (2)](../assets/img/Untitled Diagram (2).png)
+
+所以如果要充分利用你的服务器或者个人电脑的多核 CPU 资源，就要设置多个进程来处理。一个进程只能在一个 CPU 上运行，而设置了多进程后，就可以让多核 CPU 充分运行多个进程，所以我们给框架设置多进程的推荐数值为等同于 CPU 的核心数。
+
+## 为什么不是多线程
+
+因为众所周知，PHP 对线程的支持比较不好，而 ZTS 版本的 PHP 又会影响传统的 Web 端 PHP 的性能，再加上 Linux 对线程的切换效率和多进程切换的效率差不多，多线程容易造成数据读写不安全等问题，故 Swoole 使用的是多进程模型。
+
+## 框架进程模型
+
+![Untitled Diagram (3)](../assets/img/Untitled Diagram (3).png)
+
+上图中，横向的时间片可以理解为并行执行，这些操作在多个 CPU 内可能同时在执行。
+
+## 进程间隔离
+
+众所周知，进程是程序在操作系统中的一个边界，和自己有关的一切变量、内容和代码都在自己的进程内，不同进程之间如果不使用管道等方式，是不可以互相访问的。而加上开始描述的，创建子进程是一个复制自身的过程，所以也就会有如下图的情况：
+
+![Untitled Diagram (4)](../assets/img/Untitled Diagram (4).png)
+
+我们以静态类为例，设置一个进程中的全局变量。这里就会出现，同一个静态变量在多个进程中完全不同的值的结果。此后，我们将会在 Worker 进程中执行用户的代码，如果设置 Worker 数量仅为 1 的话，那么就简单许多了，你还是可以使用全局变量或静态类来存储你想要的内容而不用担心这种多个进程变量隔离的情况（因为用户的 Web 请求处理的代码只会在一个 Worker 进程中执行）。如果像上图一样设置了多个 Worker，则用户过来的比如 HTTP 请求就有可能出现在不同的 Worker 进程中，给全局变量设值就一定会造成不同步的问题。这时我们就不可以使用全局变量做数据同步（注意，我说的是数据同步）。
+
+## 跨进程同步
+
+跨进程同步方案中，框架给出了很多种解决方案。
+
+- MySQL 数据库
+- Redis
+- LightCache 轻量缓存（共享内存）
+- WorkerCache 大缓存
+- ZMAtomic 跨进程原子计数器
+
+下面的表格我将列出下方的特点和各自的优缺点：
+
+| 类型        | 用途                                                | 优点                                              | 缺点                                                         |
+| ----------- | --------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------ |
+| MySQL       | 大型的传统的关系式数据都可以用数据库，你懂的        | 就是数据库的优点                                  | 和数据库不在同一台服务器的话网络延迟会较大，数据获取效率不高 |
+| Redis       | 传统的 key-value 数据库                             | 数据无同步等问题，性能高                          | 有网络通信延迟                                               |
+| LightCache  | 框架封装的跨进程的 key-value 存储模型               | 性能强悍，无 I/O 和网络通信                       | 需要提前分配最大内存大小，最大单个值长度大小，不灵活         |
+| WorkerCache | 框架封装的基于进程的 key-value 存储模型，类似 Redis | 无需提前分配最大内存大小，受限于 PHP memory_limit | 见 WorkerCache 的说明                                        |
+
+!!! note "WorkerCache 的说明"
+	对于 WorkerCache 来说，其实是比较特殊的进程间通信。具体来说就是，WorkerCache 的原理就是将变量指定的存到一个进程中，如果是本进程读写的话直接相当于改一下全局变量，如果是其他进程读写的话，则依靠进程间通信。
+	
+	所以缺点也显而易见，如果使用过程中不是命中了 WorkerCache 存储所在的进程的话，则一直会使用进程间通信，影响一定的效率。
+
--- a/docs/assets/face_id.html
+++ b/docs/assets/face_id.html
--- a/docs/assets/img/Untitled
+++ b/docs/assets/img/Untitled
--- a/docs/assets/img/Untitled
+++ b/docs/assets/img/Untitled
--- a/docs/assets/img/Untitled
+++ b/docs/assets/img/Untitled
--- a/docs/assets/img/single-process.png
+++ b/docs/assets/img/single-process.png
--- a/docs/component/cqcode.md
+++ b/docs/component/cqcode.md
@@ -82,15 +82,20 @@ class Hello {

 CQ 码字符反转义。

+定义：`CQ::encode($msg, $is_content = false)`
+
+当 `$is_content` 为 true 时，会将 `&#44;` 转义为 `,`。
+
 | 反转义前 | 反转义后 |
 | -------- | -------- |
 | `&amp;`  | `&`      |
 | `&#91;`  | `[`      |
 | `&#93;`  | `]`      |
+| `&#44;`  | `,`      |

 ```php
-$str = CQ::decode("&#91;我只是一条普通的文本&#93;");
-// 转换为 "[我只是一条普通的文本]"
+$str = CQ::decode("&#91;CQ:at,qq=我只是一条普通的文本&#93;");
+// 转换为 "[CQ:at,qq=我只是一条普通的文本]"
 ```

 ### CQ::encode()
@@ -102,6 +107,14 @@ $str = CQ::encode("[CQ:我只是一条普通的文本]");
 // $str: "&#91;CQ:我只是一条普通的文本&#93;"
 ```

+定义：`CQ::encode($msg, $is_content = false)`
+
+当 `$is_content` 为 true 时，会将 `,` 转义为 `&#44;`。
+
+### CQ::escape()
+
+同 `CQ::encode()`。
+
 ### CQ::removeCQ()

 去除字符串中所有的 CQ 码。
@@ -111,6 +124,48 @@ $str = CQ::removeCQ("[CQ:at,qq=all]这是带表情的全体消息[CQ:face,id=8]"
 // $str: "这是带表情的全体消息"
 ```

+### CQ::getCQ()
+
+解析 CQ 码。
+
+- 参数：`getCQ($msg);`：要解析出 CQ 码的消息。
+- 返回：`数组 | null`，见下表
+
+| 键名   | 说明                                                         |
+| ------ | ------------------------------------------------------------ |
+| type   | CQ码类型，比如 `[CQ:at]` 中的 `at`                           |
+| params | 参数列表，比如 `[CQ:image,file=123.jpg,url=http://a.com/a.jpg]`，params 为  `["file" => "123","url" => "http://a.com/a.jpg"]` |
+| start  | 此 CQ 码在字符串中的起始位置                                 |
+| end    | 此 CQ 码在字符串中的结束位置                                 |
+
+### CQ::getAllCQ()
+
+解析 CQ 码，和 `getCQ()` 的区别是，这个会将字符串中的所有 CQ 码都解析出来，并以同样上方解析出来的数组格式返回。
+
+```php
+CQ::getAllCQ("[CQ:at,qq=123]你好啊[CQ:at,qq=456]");
+/*
+[
+  [
+    "type" => "at",
+    "params" => [
+      "qq" => "123",
+    ],
+    "start" => 0,
+    "end" => 13,
+  ],
+  [
+    "type" => "at",
+    "params" => [
+      "qq" => "456",
+    ],
+    "start" => 17,
+    "end" => 30,
+  ],
+]
+*/
+```
+
 ## CQ 码列表

 ### CQ::face() - 发送 QQ 表情
@@ -119,7 +174,7 @@ $str = CQ::removeCQ("[CQ:at,qq=all]这是带表情的全体消息[CQ:face,id=8]"

 定义：`CQ::face($id)`

-参数：`$id` 为 QQ 表情对应的 ID 号，一些常见的表情 ID 对应的表情样式见 [炸毛框架 1.x 版本文档](https://docs-v1.zhamao.xin/face_list.html)。
+参数：`$id` 为 QQ 表情对应的 ID 号，一些常见的表情 ID 对应的表情样式见 [QQ 对应表情ID表](/assets/face_id.html)。

 ```php
 /**
@@ -449,11 +504,31 @@ public function xmlTest() {

 发送 QQ 兼容的 JSON 多媒体消息。

-定义：`CQ::json($data)`
+定义：`CQ::json($data, $resid = 0)`

 参数同上，内含 JSON 字符串即可。

+其中 `$resid` 是面向 go-cqhttp 扩展的参数，默认不填为 0，走小程序通道，填了走富文本通道发送。
+
 !!! tip "提示"

 	因为某些众所周知的原因，XML 和 JSON 的返回不提供实例，有兴趣的可以自行研究如何编写，文档不含任何相关教程。

+### CQ::_custom() - 扩展自定义 CQ 码
+
+用于兼容各类含有被支持的扩展 CQ 码，比如 go-cqhttp 的 `[CQ:gift]` 礼物类型。
+
+定义：`CQ::_custom(string $type_name, array $params)`
+
+| 参数名      | 说明                                                |
+| ----------- | --------------------------------------------------- |
+| `type_name` | CQ 码类型，如 `music`，`at`                         |
+| `params`    | 发送的 CQ 码中的参数数组，例如 `["qq" => "123456"]` |
+
+下面是一个例子：
+
+```php
+CQ::_custom("at",["qq" => "123456","qwe" => "asd"]);
+// 返回：[CQ:at,qq=123456,qwe=asd]
+```
+
--- a/docs/component/light-cache.md
+++ b/docs/component/light-cache.md
@@ -224,3 +224,97 @@ public function test() {

 解决这一问题，就需要用到锁。这种情况下，我们首先考虑的是自旋锁，框架也因此内置了一个方便使用的自旋锁组件。详见下一章：自旋锁。

+## 如何临时缓存大变量
+
+由于 LightCache 需要提前声明最大大小，所以在某些情况下，比如第三方 API 接口结果临时缓存，可能不太适合使用，这时对于 2.x 版本的多进程炸毛框架是一个新的问题。
+
+解决方案有三种：
+
+- 将 `global.php` 中的 `swoole.worker_num` 调整为 `1` 即可，所有除所有主 handler 事件的用户类外其他类均可使用如 `Hello::$store` 类似的静态变量全局存取
+- 使用 WorkerCache（需要 2.2.0 以上版本）
+- 使用 Redis（需要安装 `redis` 扩展）
+
+以上，WorkerCache 是为了弥补 LightCache 的不足而诞生的，以下就是 WorkerCache 的具体内容。
+
+### WorkerCache 跨进程大缓存
+
+WorkerCache 和 LightCache 几乎完全不同，WorkerCache 存储的方式说白了就是 PHP 的静态变量，不过框架支持使用封装好的进程间通信进行跨进程读取。但由于需要设置一个存储变量的进程，所以配置文件必须先指定要将数据存到哪个 Worker/TaskWorker 进程中。关于框架内多进程的说明，请见 [进阶 - 多进程 Hack](/advanced/multi-process/)。
+
+定义：`ZM\Store\WorkerCache`。
+
+#### 配置
+
+见 [基本配置](/guide/basic-config/)。
+
+#### WorkerCache::get()
+
+定义：`get($key)`。
+
+`$key` 为指定要获取的键值对的值，如果不存在则返回 null。
+
+#### WorkerCache::set()
+
+定义：`set($key, $value, $async = false)`。
+
+设置变量，你懂的。
+
+注意，`$value` 可以是被无损 `json_encode` 和 `json_decode` 的变量，闭包（Closure）、资源（resource）等类型不支持存储。
+
+`$async` 默认为 false，当为 true 时候，不会返回是否成功设置与否，否则会协程等待是否目标进程存储成功。
+
+#### WorkerCache::unset()
+
+定义：`unset($key, $async = false)` 
+
+删除键对应的值。`$async` 的意义同上。
+
+#### WorkerCache::add()
+
+定义：`add($key, int $value, $async = false)`
+
+给 int 类型的值加一，如果值不存在，则默认为 0 且加上目标的 `$value`。
+
+#### WorkerCache::sub()
+
+定义：`sub($key, int $value, $async = false)`
+
+给 int 类型的值减一，如果值不存在，则默认为 0 且减去目标的 `$value`。
+
+```php
+<?php
+namespace Module\Example;
+
+use ZM\Store\WorkerCache;
+use ZM\Annotation\CQ\CQCommand;
+
+class Hello {
+    /**
+     * @CQCommand("set_store")
+     */
+    public function setStorage() {
+        $arg1 = ctx()->getNextArg("请输入要设置的内容名称");
+        $arg2 = ctx()->getFullArg("请输入要设置的内容");
+        WorkerCache::set($arg1, $arg2);
+        return "成功！";
+    }
+    
+    /**
+     * @CQCommand("get_store")
+     */
+    public function getStorage() {
+        $arg1 = ctx()->getFullArg("请输入要获取的内容名称");
+        $data = WorkerCache::get($arg1);
+        return $data ?? "内容不存在！";
+    }
+}
+```
+
+<chat-box>
+) set_store hello world
+( 成功！
+) get_store hello
+( world
+) get_store foo
+( 内容不存在！
+</chat-box>
+
--- a/docs/event/framework-annotations.md
+++ b/docs/event/framework-annotations.md
@@ -116,6 +116,44 @@

 `$conn`: [ConnectionObject](/advanced/connect-ws-client/) 类型，返回一个当前 WS 连接的连接对象。

+## OnPipeMessageEvent()
+
+当有 其他 Worker 进程通信发来指令，激活响应。（2.2.0 版本可用）
+
+### 属性
+
+| 类型       | 值                                                      |
+| ---------- | ------------------------------------------------------- |
+| 名称       | `@OnPipeMessageEvent`                                   |
+| 触发前提   | 当有 WebSocket 连接接入框架后发送过来消息，触发注解事件 |
+| 命名空间   | `ZM\Annotation\Swoole\OnPipeMessageEvent`               |
+| 适用位置   | 方法                                                    |
+| 返回值处理 | 无                                                      |
+
+### 参数
+
+| 参数名称 | 参数范围 | 用途         | 默认 |
+| -------- | -------- | ------------ | ---- |
+| action   | `string` | 限定动作名称 |      |
+
+### 用法
+
+```java
+@OnPipeMessageEvent("foo")
+@OnPipeMessageEvent(action="bar")
+```
+
+### 事件绑定参数
+
+`$data`: 数组，内容如下：
+
+```php
+[
+    "action" => "你的上面的名称",
+    ... //其他自己发送时随便定义，带什么都行
+]
+```
+
 ## OnSwooleEvent()

 绑定 Swoole 所相关的事件，例如 WebSocket 接入、收到 WS 消息、关闭 WS 连接，HTTP 请求到达等。这个是旧的统一的 Swoole 事件分发注解。**请尽量使用上面几个新的注解**。
@@ -208,7 +246,7 @@
 ```php
 <?php
 namespace Module\Example;
-use ZM\Annotation\Swoole\OnSwooleEvent;
+use ZM\Annotation\Swoole\OnOpenEvent;
 use ZM\ConnectionManager\ConnectionObject;
 use ZM\Console\Console;
 class Hello {
--- a/docs/event/middleware.md
+++ b/docs/event/middleware.md
@@ -163,5 +163,5 @@ public function onThrowing(?Exception $e) {

 这里的 `@HandleException` 中的参数为要捕获的类名，注意这里面的类名的命名空间需要写全称，不能上面 use 再使用，否则会无法找到异常类。

-`context()` 为获取当前协程空间绑定的 `request` 和 `response` 对象。
+`ctx()` 为获取当前协程空间绑定的 `request` 和 `response` 对象。

--- a/docs/event/robot-annotations.md
+++ b/docs/event/robot-annotations.md
@@ -11,10 +11,25 @@ QQ 机器人事件是指 CQHTTP 插件发来的 Event 事件，被框架处理
 事件是用户需要从 OneBot 被动接收的数据，有以下几个大类：

 - [消息事件](#cqmessage)，包括私聊消息、群消息等，被 [`@CQCommand`](#cqcommand)，`@CQMessage` 注解处理。
+
 - [通知事件](#cqnotice)，包括群成员变动、好友变动等，被 `@CQNotice` 注解事件处理。
+
 - [请求事件](#cqrequest)，包括加群请求、加好友请求等，被 `@CQRequest` 注解事件处理。
+
 - [元事件](#cqmetaevent)，包括 OneBot 生命周期、心跳等，被 `@CQMetaEvent` 注解事件处理。

+## 注解事件参照表
+
+| 注解名称                                                | 类所在命名全称               | 作用                                                         |
+| ------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------ |
+| [`@CQBefore`](/event/robot-annotations/#cqbefore)       | `\ZM\Annotation\CQBefore`    | OneBot 各类事件前触发的，可当作事件过滤器使用                |
+| [`@CQAfter`](/event/robot-annotations/#cqafter)         | `\ZM\Annotation\CQAfter`     | OneBot 各类事件后触发的                                      |
+| [`@CQMessage`](/event/robot-annotations/#cqmessage)     | `\ZM\Annotation\CQMessage`   | OneBot 中消息类事件的触发（机器人消息）事件                  |
+| [`@CQCommand`](/event/robot-annotations/#cqcommand)     | `\ZM\Annotation\CQCommand`   | OneBot 中消息类事件的触发（机器人消息）事件，但是被封装为指令型的，无需自己切割命令式 |
+| [`@CQNotice`](/event/robot-annotations/#cqnotice)       | `\ZM\Annotation\CQNotice`    | OneBot 中通知类事件的触发（机器人消息）事件                  |
+| [`@CQRequest`](/event/robot-annotations/#cqrequest)     | `\ZM\Annotation\CQRequest`   | OneBot 中请求类事件的触发（机器人消息）事件，一般带有请求信息，可联动相关响应的 API 完成功能编写 |
+| [`@CQMetaEvent`](/event/robot-annotations/#cqmetaevent) | `\ZM\Annotation\CQMetaEvent` | OneBot 中涉及 OneBot 实现本身的一些和机器人事件无关的元事件，比如 WS 连接的心跳包 |
+
 ## CQMessage()

 QQ 收到消息后触发的事件对应注解。
--- a/docs/guide/basic-config.md
+++ b/docs/guide/basic-config.md
@@ -20,6 +20,7 @@
 | `crash_dir`                  | 存放崩溃和运行日志的目录                         | `zm_data` 下的 `crash/`      |
 | `swoole`                     | 对应 Swoole server 中 set 的参数，参考Swoole文档 | 见子表 `swoole`              |
 | `light_cache`                | 轻量内置 key-value 缓存                          | 见字表 `light_cache`         |
+| `worker_cache`               | 跨进程变量级缓存                                 | 见子表 `worker_cache`        |
 | `sql_config`                 | MySQL 数据库连接信息                             | 见子表 `sql_config`          |
 | `redis_config`               | Redis 连接信息                                   | 见子表 `redis_config`        |
 | `access_token`               | OneBot 客户端连接约定的token，留空则无           | 空                           |
@@ -82,6 +83,12 @@
 | `document_root`  | 静态文件的根目录       | `{WORKING_DIR}/resources/html` |
 | `document_index` | 默认索引的文件名列表   | `["index.html"]`               |

+### 子表 worker_cache
+
+| 配置名称 | 说明                        | 默认值 |
+| -------- | --------------------------- | ------ |
+| `worker` | 跨进程缓存的存储工作进程 id | 0      |
+
 ## 多环境下的配置文件

 炸毛框架的配置文件模块支持不同环境下的配置文件，主要结构为 `global.{环境}.php`。在一般情况下，炸毛框架默认从教程引导方式根据指令 `vendor/bin/start server` 启动的框架是不带环境控制的。这章将讲述如何根据不同的环境（production / development / staging）来编写配置文件。
--- a/docs/guide/quickstart-robot.md
+++ b/docs/guide/quickstart-robot.md
@@ -224,5 +224,14 @@ public function repeat() {

 这样，一个简易的复读机就做好了！回到 QQ 机器人聊天，向机器人发送 `echo 你好啊`，它会回复你 `你好啊`。

+<chat-box>
+) echo 你好啊
+( 你好啊
+) echo
+( 请输入你要回复的内容
+) 哦豁，完蛋
+( 哦豁，完蛋
+</chat-box>
+
 > 如果你只回复 `echo` 的话，它会先和你进入一个会话状态，并问你 `请输入你要回复的内容`，这时你再次说一些内容例如 `哦豁`，会回复你 `哦豁`。效果和直接输入 `echo 哦豁` 是一致的，这是炸毛框架内的一个封装好的命令参数对话询问功能。有关参数询问功能，请看后面的进阶模块。

--- a/docs/index.md
+++ b/docs/index.md
@@ -4,6 +4,11 @@

 > 如果是从 v1.x 版本升级到 v2.x，[点我看升级指南](/advanced/to-v2/)。

+!!! tip "提示"
+	
+	编写文档需要较大精力，你也可以参与到本文档的建设中来，比如找错字，增加或更正内容，每页文档可直接点击右上方铅笔图标直接跳转至 GitHub 进行编辑，编辑后自动 Fork 并生成 Pull Request，以此来贡献此文档！
+
+
 炸毛框架使用 PHP 编写，采用 Swoole 扩展为基础，主要面向 API 服务，聊天机器人（CQHTTP 对接），包含 websocket、http 等监听和请求库，用户代码采用模块化处理，使用注解可以方便地编写各类功能。

 框架主要用途为 HTTP 服务器，机器人搭建框架。尤其对于 QQ 机器人消息处理较为方便和全面，提供了众多会话机制和内部调用机制，可以以各种方式设计你自己的模块。
@@ -33,7 +38,7 @@ public function index() {

 首先，你需要了解你需要知道哪些事情才能开始着手使用框架：

-1. Linux 命令行基础
+1. Linux 命令行（会跑 Linux 程序）
 2. php 7.2+ 开发环境
 3. HTTP 协议（可选）
 4. OneBot 机器人聊天接口标准（可选）
--- a/docs/javascripts/config.js
+++ b/docs/javascripts/config.js
@@ -42,7 +42,7 @@ function setCookie(name, value) {
    var Days = 30;
    var exp = new Date();
    exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000);
-    document.cookie = name + "=" + escape(value) + ";expires=" + exp.toGMTString();
+    document.cookie = name + "=" + escape(value) + ";expires=" + exp.toGMTString() + ";path=/";
 }

 s_theme=getCookie("_theme");
--- a/docs/update/v2.md
+++ b/docs/update/v2.md
@@ -1,5 +1,48 @@
 # 更新日志（v2 版本）

+## v2.2.4
+
+> 更新事件：2021.2.7
+
+- 修复：终端交互导致的 ssh 断掉后 CPU 占用过高的问题
+- 修复：WorkerCache 在缺少配置文件下工作异常的问题
+- 新增：全局函数：`zm_atomic()`
+
+## v2.2.3
+
+> 更新时间：2021.1.30
+
+- 修复：waitMessage() 在 v2.2.2 版本中不可用的 bug
+- 修复：access_token 无效的问题
+
+## v2.2.2
+
+> 更新时间：2021.1.29
+
+- 修复：模块文件错误时避免循环报错
+- 优化：代码结构
+- 修复：在不同进程时调用机器人 API 无法返回且报错的 bug
+- **修复：机器人无法连接的问题（2.1.6 ~ 2.2.1 受影响）**
+
+## v2.2.1
+
+> 更新时间：2021.1.29
+
+- 修复：配置文件兼容性问题
+
+## v2.2.0
+
+> 更新时间：2021.1.29
+
+- 新增：`@OnPipeMessageEvent` 注解
+- 新增：进程管理器
+- 新增：`--daemon` 守护进程化后查看状态以及一系列操作的命令行
+- 新增：WorkerCache
+- 修复：路由问题
+- 修复：`http_header` 配置项不生效的 bug
+- 优化：框架内部所有异常全部基于 `ZMException`
+- 优化：SingletonTrait 支持扩展
+
 ## v2.1.6

 > 更新时间：2021.1.18
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -10,8 +10,8 @@ theme:
  favicon: assets/favicon.png
  language: zh
  palette:
-    primary: blue
-    accent: blue
+    primary: red
+    accent: red
  features:
    - navigation.tabs
 extra_javascript:
@@ -34,7 +34,7 @@ extra:
  version:
    method: mike

-copyright: 'Copyright &copy; 2019 - 2020 CrazyBot Team&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="tx-switch">
+copyright: 'Copyright &copy; 2019 - 2021 CrazyBot Team&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="tx-switch">
                 <button data-md-color-scheme="default"><code>默认模式</code></button>
                 <button data-md-color-scheme="slate"><code>暗黑模式</code></button>
               </span>
@@ -94,6 +94,9 @@ nav:
      - 从 v1 升级: advanced/to-v2.md
      - 内部类文件手册: advanced/inside-class.md
      - 接入 WebSocket 客户端: advanced/connect-ws-client.md
+      - 框架多进程: advanced/multi-process.md
+      - 开发实战教程:
+          - 编写管理员才能触发的功能: advanced/example/admin.md
  - FAQ: FAQ.md
  - 更新日志:
      - 更新日志（v2）: update/v2.md
--- a/src/Custom/Command/CustomCommand.php
+++ b/src/Custom/Command/CustomCommand.php
@@ -1,31 +0,0 @@
-<?php
-
-
-namespace Custom\Command;
-
-
-use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Input\InputInterface;
-use Symfony\Component\Console\Output\OutputInterface;
-
-class CustomCommand extends Command
-{
-    // the name of the command (the part after "bin/console")
-    protected static $defaultName = 'custom';
-
-    protected function configure() {
-        $this->setDescription("custom description | 自定义命令的描述字段");
-        $this->addOption("failure", null, null, "以错误码为1返回结果");
-        // ...
-    }
-
-    protected function execute(InputInterface $input, OutputInterface $output) {
-        if ($input->getOption("failure")) {
-            $output->writeln("<error>Hello error! I am wrong message.</error>");
-            return Command::FAILURE;
-        } else {
-            $output->writeln("<comment>Hello world! I am successful message.</comment>");
-            return Command::SUCCESS;
-        }
-    }
-}
--- a/src/Custom/global_function.php
+++ b/src/Custom/global_function.php
@@ -1,4 +1,4 @@
-<?php #plain
+<?php /** @noinspection PhpFullyQualifiedNameUsageInspection */ #plain

 //这里写你的全局函数
 function pgo(callable $func, $name = "default") {
--- a/src/Module/Example/Hello.php
+++ b/src/Module/Example/Hello.php
@@ -89,7 +89,7 @@ class Hello
     * @return string
     */
    public function paramGet($param) {
-        return "Your name: {$param["name"]}";
+        return "Hello, ".$param["name"];
    }

    /**
--- a/src/ZM/API/CQ.php
+++ b/src/ZM/API/CQ.php
@@ -45,11 +45,11 @@ class CQ
     */
    public static function image($file, $cache = true, $flash = false, $proxy = true, $timeout = -1) {
        return
-            "[CQ:image,file=" . $file .
+            "[CQ:image,file=" . self::encode($file, true) .
            (!$cache ? ",cache=0" : "") .
            ($flash ? ",type=flash" : "") .
            (!$proxy ? ",proxy=false" : "") .
-            ($timeout != -1 ? (",timeout=" . $timeout) : "") .
+            ($timeout != -1 ? (",timeout=" . intval($timeout)) : "") .
            "]";
    }

@@ -64,11 +64,11 @@ class CQ
     */
    public static function record($file, $magic = false, $cache = true, $proxy = true, $timeout = -1) {
        return
-            "[CQ:record,file=" . $file .
+            "[CQ:record,file=" . self::encode($file, true) .
            (!$cache ? ",cache=0" : "") .
            ($magic ? ",magic=1" : "") .
            (!$proxy ? ",proxy=false" : "") .
-            ($timeout != -1 ? (",timeout=" . $timeout) : "") .
+            ($timeout != -1 ? (",timeout=" . intval($timeout)) : "") .
            "]";
    }

@@ -82,10 +82,10 @@ class CQ
     */
    public static function video($file, $cache = true, $proxy = true, $timeout = -1) {
        return
-            "[CQ:video,file=" . $file .
+            "[CQ:video,file=" . self::encode($file, true) .
            (!$cache ? ",cache=0" : "") .
            (!$proxy ? ",proxy=false" : "") .
-            ($timeout != -1 ? (",timeout=" . $timeout) : "") .
+            ($timeout != -1 ? (",timeout=" . intval($timeout)) : "") .
            "]";
    }

@@ -121,7 +121,7 @@ class CQ
     * @return string
     */
    public static function poke($type, $id, $name = "") {
-        return "[CQ:poke,type=$type,id=$id" . ($name != "" ? ",name=$name" : "") . "]";
+        return "[CQ:poke,type=$type,id=$id" . ($name != "" ? (",name=".self::encode($name, true)) : "") . "]";
    }

    /**
@@ -130,7 +130,7 @@ class CQ
     * @return string
     */
    public static function anonymous($ignore = 1) {
-        return "[CQ:anonymous".($ignore != 1 ? ",ignore=0" : "")."]";
+        return "[CQ:anonymous" . ($ignore != 1 ? ",ignore=0" : "") . "]";
    }

    /**
@@ -143,10 +143,10 @@ class CQ
     */
    public static function share($url, $title, $content = null, $image = null) {
        if ($content === null) $c = "";
-        else $c = ",content=" . $content;
+        else $c = ",content=" . self::encode($content, true);
        if ($image === null) $i = "";
-        else $i = ",image=" . $image;
-        return "[CQ:share,url=" . $url . ",title=" . $title . $c . $i . "]";
+        else $i = ",image=" . self::encode($image, true);
+        return "[CQ:share,url=" . self::encode($url, true) . ",title=" . self::encode($title, true) . $c . $i . "]";
    }

    /**
@@ -159,8 +159,21 @@ class CQ
        return "[CQ:contact,type=$type,id=$id]";
    }

+    /**
+     * 发送位置
+     * @param $lat
+     * @param $lon
+     * @param string $title
+     * @param string $content
+     * @return string
+     */
    public static function location($lat, $lon, $title = "", $content = "") {
-
+        return "[CQ:location" .
+            ",lat=".self::encode($lat, true) .
+            ",lon=".self::encode($lon, true).
+            ($title != "" ? (",title=".self::encode($title, true)) : "") .
+            ($content != "" ? (",content=".self::encode($content, true)) : "") .
+            "]";
    }

    /**
@@ -193,10 +206,13 @@ class CQ
                    return " ";
                }
                if ($content === null) $c = "";
-                else $c = ",content=" . $content;
+                else $c = ",content=" . self::encode($content, true);
                if ($image === null) $i = "";
-                else $i = ",image=" . $image;
-                return "[CQ:music,type=custom,url=" . $id_or_url . ",audio=" . $audio . ",title=" . $title . $c . $i . "]";
+                else $i = ",image=" . self::encode($image, true);
+                return "[CQ:music,type=custom,url=" .
+                    self::encode($id_or_url, true) .
+                    ",audio=" . self::encode($audio, true) . ",title=" . self::encode($title, true) . $c . $i .
+                    "]";
            default:
                Console::warning("传入的music type($type)错误！");
                return " ";
@@ -208,19 +224,36 @@ class CQ
    }

    public static function node($user_id, $nickname, $content) {
-        return "[CQ:node,user_id=$user_id,nickname=$nickname,content=".self::escape($content)."]";
+        return "[CQ:node,user_id=$user_id,nickname=".self::encode($nickname, true).",content=" . self::encode($content, true) . "]";
+    }
+
+    public static function xml($data) {
+        return "[CQ:xml,data=" . self::encode($data, true) . "]";
+    }
+
+    public static function json($data, $resid = 0) {
+        return "[CQ:json,data=" . self::encode($data, true) . ",resid=" . intval($resid) . "]";
+    }
+
+    public static function _custom(string $type_name, $params) {
+        $code = "[CQ:" . $type_name;
+        foreach ($params as $k => $v) {
+            $code .= "," . $k . "=" . self::escape($v, true);
+        }
+        $code .= "]";
+        return $code;
    }

    /**
     * 反转义字符串中的CQ码敏感符号
-     * @param $str
+     * @param $msg
+     * @param bool $is_content
     * @return mixed
     */
-    public static function decode($str) {
-        $str = str_replace("&amp;", "&", $str);
-        $str = str_replace("&#91;", "[", $str);
-        $str = str_replace("&#93;", "]", $str);
-        return $str;
+    public static function decode($msg, $is_content = false) {
+        $msg = str_replace(["&amp;", "&#91;", "&#93;"], ["&", "[", "]"], $msg);
+        if ($is_content) $msg = str_replace("&#44;", ",", $msg);
+        return $msg;
    }

    public static function replace($str) {
@@ -230,42 +263,97 @@ class CQ
    }

    /**
-     * 转义CQ码
+     * 转义CQ码的特殊字符，同encode
     * @param $msg
+     * @param bool $is_content
     * @return mixed
     */
-    public static function escape($msg) {
-        $msg = str_replace("&", "&amp;", $msg);
-        $msg = str_replace("[", "&#91;", $msg);
-        $msg = str_replace("]", "&#93;", $msg);
+    public static function escape($msg, $is_content = false) {
+        $msg = str_replace(["&", "[", "]"], ["&amp;", "&#91;", "&#93;"], $msg);
+        if ($is_content) $msg = str_replace(",", "&#44;", $msg);
        return $msg;
    }

-    public static function encode($str) {
-        return self::escape($str);
+    /**
+     * 转义CQ码的特殊字符
+     * @param $msg
+     * @param false $is_content
+     * @return mixed
+     */
+    public static function encode($msg, $is_content = false) {
+        $msg = str_replace(["&", "[", "]"], ["&amp;", "&#91;", "&#93;"], $msg);
+        if ($is_content) $msg = str_replace(",", "&#44;", $msg);
+        return $msg;
    }

+    /**
+     * 移除消息中所有的CQ码并返回移除CQ码后的消息
+     * @param $msg
+     * @return string
+     */
    public static function removeCQ($msg) {
-        while (($cq = self::getCQ($msg)) !== null) {
-            $msg = str_replace(mb_substr($msg, $cq["start"], $cq["end"] - $cq["start"] + 1), "", $msg);
+        $final = "";
+        $last_end = 0;
+        foreach(self::getAllCQ($msg) as $k => $v) {
+            $final .= mb_substr($msg, $last_end, $v["start"] - $last_end);
+            $last_end = $v["end"] + 1;
        }
-        return $msg;
+        $final .= mb_substr($msg, $last_end);
+        return $final;
    }

+    /**
+     * 获取消息中第一个CQ码
+     * @param $msg
+     * @return array|null
+     */
    public static function getCQ($msg) {
-        if (($start = mb_strpos($msg, '[')) === false) return null;
-        if (($end = mb_strpos($msg, ']')) === false) return null;
-        $msg = mb_substr($msg, $start + 1, $end - $start - 1);
-        if (mb_substr($msg, 0, 3) != "CQ:") return null;
-        $msg = mb_substr($msg, 3);
-        $msg2 = explode(",", $msg);
-        $type = array_shift($msg2);
-        $array = [];
-        foreach ($msg2 as $k => $v) {
-            $ss = explode("=", $v);
-            $sk = array_shift($ss);
-            $array[$sk] = implode("=", $ss);
+        if (($head = mb_strpos($msg, "[CQ:")) !== false) {
+            $key_offset = mb_substr($msg, $head);
+            $close = mb_strpos($key_offset, "]");
+            if ($close === false) return null;
+            $content = mb_substr($msg, $head + 4, $close + $head - mb_strlen($msg));
+            $exp = explode(",", $content);
+            $cq["type"] = array_shift($exp);
+            foreach ($exp as $k => $v) {
+                $ss = explode("=", $v);
+                $sk = array_shift($ss);
+                $cq["params"][$sk] = self::decode(implode("=", $ss), true);
+            }
+            $cq["start"] = $head;
+            $cq["end"] = $close + $head;
+            return $cq;
+        } else {
+            return null;
        }
-        return ["type" => $type, "params" => $array, "start" => $start, "end" => $end];
+    }
+
+    /**
+     * 获取消息中所有的CQ码
+     * @param $msg
+     * @return array
+     */
+    public static function getAllCQ($msg) {
+        $cqs = [];
+        $offset = 0;
+        while (($head = mb_strpos(($submsg = mb_substr($msg, $offset)), "[CQ:")) !== false) {
+            $key_offset = mb_substr($submsg, $head);
+            $tmpmsg = mb_strpos($key_offset, "]");
+            if ($tmpmsg === false) break; // 没闭合，不算CQ码
+            $content = mb_substr($submsg, $head + 4, $tmpmsg + $head - mb_strlen($submsg));
+            $exp = explode(",", $content);
+            $cq = [];
+            $cq["type"] = array_shift($exp);
+            foreach ($exp as $k => $v) {
+                $ss = explode("=", $v);
+                $sk = array_shift($ss);
+                $cq["params"][$sk] = self::decode(implode("=", $ss), true);
+            }
+            $cq["start"] = $offset + $head;
+            $cq["end"] = $offset + $tmpmsg + $head;
+            $offset += $tmpmsg + 1;
+            $cqs[] = $cq;
+        }
+        return $cqs;
    }
 }
--- a/src/ZM/API/CQAPI.php
+++ b/src/ZM/API/CQAPI.php
@@ -3,17 +3,16 @@

 namespace ZM\API;

-use Co;
-use ZM\ConnectionManager\ConnectionObject;
 use ZM\Console\Console;
 use ZM\Store\LightCacheInside;
 use ZM\Store\Lock\SpinLock;
 use ZM\Store\ZMAtomic;
+use ZM\Utils\CoMessage;

 trait CQAPI
 {
    /**
-     * @param ConnectionObject $connection
+     * @param $connection
     * @param $reply
     * @param |null $function
     * @return bool|array
@@ -35,21 +34,20 @@ trait CQAPI
        $r[$api_id] = [
            "data" => $reply,
            "time" => microtime(true),
-            "self_id" => $connection->getOption("connect_id")
+            "self_id" => $connection->getOption("connect_id"),
+            "echo" => $api_id
        ];
-        if ($function === true) $r[$api_id]["coroutine"] = Co::getuid();
        LightCacheInside::set("wait_api", "wait_api", $r);
        SpinLock::unlock("wait_api");
        if (server()->push($connection->getFd(), json_encode($reply))) {
            if ($function === true) {
-                Co::suspend();
+                return CoMessage::yieldByWS($r[$api_id], ["echo"], 60);
+            } else {
                SpinLock::lock("wait_api");
                $r = LightCacheInside::get("wait_api", "wait_api");
-                $data = $r[$api_id];
                unset($r[$api_id]);
                LightCacheInside::set("wait_api", "wait_api", $r);
                SpinLock::unlock("wait_api");
-                return isset($data['result']) ? $data['result'] : null;
            }
            return true;
        } else {
--- a/src/ZM/API/ZMRobot.php
+++ b/src/ZM/API/ZMRobot.php
@@ -59,7 +59,7 @@ class ZMRobot
    public static function getAllRobot() {
        $r = ManagerGM::getAllByName('qq');
        $obj = [];
-        foreach($r as $v) {
+        foreach ($r as $v) {
            $obj[] = new ZMRobot($v);
        }
        return $obj;
@@ -228,9 +228,9 @@ class ZMRobot
    /**
     * 群组单人禁言
     * @link https://github.com/howmanybots/onebot/blob/master/v11/specs/api/public.md#set_group_ban-%E7%BE%A4%E7%BB%84%E5%8D%95%E4%BA%BA%E7%A6%81%E8%A8%80
-     * @param int $group_id
-     * @param int $user_id
-     * @param int $duration
+     * @param $group_id
+     * @param $user_id
+     * @param $duration
     * @return array|bool|null
     */
    public function setGroupBan($group_id, $user_id, $duration = 1800) {
--- a/src/ZM/Annotation/AnnotationParser.php
+++ b/src/ZM/Annotation/AnnotationParser.php
@@ -9,11 +9,10 @@ use ZM\Console\Console;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionMethod;
-use ZM\Annotation\Http\{HandleAfter, HandleBefore, Controller, HandleException, Middleware, MiddlewareClass, RequestMapping};
+use ZM\Annotation\Http\{HandleAfter, HandleBefore, HandleException, Middleware, MiddlewareClass, RequestMapping};
 use ZM\Annotation\Interfaces\Level;
 use ZM\Annotation\Module\Closed;
 use ZM\Http\RouteManager;
-use ZM\Utils\DataProvider;

 class AnnotationParser
 {
@@ -48,7 +47,7 @@ class AnnotationParser
     */
    public function registerMods() {
        foreach ($this->path_list as $path) {
-            Console::debug("parsing annotation in ".$path[0]);
+            Console::debug("parsing annotation in " . $path[0]);
            $all_class = getAllClasses($path[0], $path[1]);
            $this->reader = new AnnotationReader();
            foreach ($all_class as $v) {
@@ -91,6 +90,7 @@ class AnnotationParser
                    if ($vs instanceof ErgodicAnnotation) {
                        foreach (($this->annotation_map[$v]["methods"] ?? []) as $method) {
                            $copy = clone $vs;
+                            /** @noinspection PhpUndefinedFieldInspection */
                            $copy->method = $method->getName();
                            $this->annotation_map[$v]["methods_annotations"][$method->getName()][] = $copy;
                        }
--- a/src/ZM/Annotation/CQ/CQMessage.php
+++ b/src/ZM/Annotation/CQ/CQMessage.php
@@ -3,7 +3,6 @@

 namespace ZM\Annotation\CQ;

-use Doctrine\Common\Annotations\Annotation\Required;
 use Doctrine\Common\Annotations\Annotation\Target;
 use ZM\Annotation\AnnotationBase;
 use ZM\Annotation\Interfaces\Level;
--- a/src/ZM/Annotation/Http/HandleAfter.php
+++ b/src/ZM/Annotation/Http/HandleAfter.php
@@ -4,7 +4,6 @@
 namespace ZM\Annotation\Http;


-use Doctrine\Common\Annotations\Annotation\Required;
 use Doctrine\Common\Annotations\Annotation\Target;
 use ZM\Annotation\AnnotationBase;

--- a/src/ZM/Annotation/Swoole/OnCloseEvent.php
+++ b/src/ZM/Annotation/Swoole/OnCloseEvent.php
@@ -5,7 +5,6 @@ namespace ZM\Annotation\Swoole;


 use Doctrine\Common\Annotations\Annotation\Target;
-use ZM\Annotation\Interfaces\Rule;

 /**
 * @Annotation
--- a/src/ZM/Annotation/Swoole/OnPipeMessageEvent.php
+++ b/src/ZM/Annotation/Swoole/OnPipeMessageEvent.php
@@ -0,0 +1,24 @@
+<?php
+
+
+namespace ZM\Annotation\Swoole;
+
+
+use Doctrine\Common\Annotations\Annotation\Required;
+use Doctrine\Common\Annotations\Annotation\Target;
+use ZM\Annotation\AnnotationBase;
+
+/**
+ * Class OnPipeMessageEvent
+ * @package ZM\Annotation\Swoole
+ * @Annotation
+ * @Target("METHOD")
+ */
+class OnPipeMessageEvent extends AnnotationBase
+{
+    /**
+     * @var string
+     * @Required()
+     */
+    public $action;
+}
--- a/src/ZM/Command/BuildCommand.php
+++ b/src/ZM/Command/BuildCommand.php
@@ -31,7 +31,7 @@ class BuildCommand extends Command
        $target_dir = $input->getOption("target") ?? (__DIR__ . '/../../../resources/');
        if (mb_strpos($target_dir, "../")) $target_dir = realpath($target_dir);
        if ($target_dir === false) {
-            $output->writeln(TermColor::color8(31) . "Error: No such file or directory (".__DIR__ . '/../../../resources/'.")" . TermColor::RESET);
+            $output->writeln(TermColor::color8(31) . "Error: No such file or directory (" . __DIR__ . '/../../../resources/' . ")" . TermColor::RESET);
            return Command::FAILURE;
        }
        $output->writeln("Target: " . $target_dir . " , Version: " . ($version = json_decode(file_get_contents(__DIR__ . "/../../../composer.json"), true)["version"]));
@@ -51,7 +51,7 @@ class BuildCommand extends Command
        return Command::SUCCESS;
    }

-    private function build ($target_dir, $filename) {
+    private function build($target_dir, $filename) {
        @unlink($target_dir . $filename);
        $phar = new Phar($target_dir . $filename);
        $phar->startBuffering();
--- a/src/ZM/Command/DaemonCommand.php
+++ b/src/ZM/Command/DaemonCommand.php
@@ -0,0 +1,31 @@
+<?php
+
+
+namespace ZM\Command;
+
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use ZM\Utils\DataProvider;
+
+abstract class DaemonCommand extends Command
+{
+    protected $daemon_file = null;
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $pid_path = DataProvider::getWorkingDir() . "/.daemon_pid";
+        if (!file_exists($pid_path)) {
+            $output->writeln("<comment>没有检测到正在运行的守护进程！</comment>");
+            die();
+        }
+        $file = json_decode(file_get_contents($pid_path), true);
+        if ($file === null || posix_getsid(intval($file["pid"])) === false) {
+            $output->writeln("<comment>未检测到正在运行的守护进程！</comment>");
+            unlink($pid_path);
+            die();
+        }
+        $this->daemon_file = $file;
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/DaemonReloadCommand.php
+++ b/src/ZM/Command/DaemonReloadCommand.php
@@ -0,0 +1,24 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class DaemonReloadCommand extends DaemonCommand
+{
+    protected static $defaultName = 'daemon:reload';
+
+    protected function configure() {
+        $this->setDescription("重载守护进程下的用户代码（仅限--daemon模式可用）");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        parent::execute($input, $output);
+        system("kill -USR1 " . intval($this->daemon_file["pid"]));
+        $output->writeln("<info>成功重载！</info>");
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/DaemonStatusCommand.php
+++ b/src/ZM/Command/DaemonStatusCommand.php
@@ -0,0 +1,30 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class DaemonStatusCommand extends DaemonCommand
+{
+    protected static $defaultName = 'daemon:status';
+
+    protected function configure() {
+        $this->setDescription("查看守护进程框架的运行状态（仅限--daemon模式可用）");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        parent::execute($input, $output);
+        $output->writeln("<info>框架运行中，pid：" . $this->daemon_file["pid"] . "</info>");
+        $output->writeln("<comment>----- 以下是stdout内容 -----</comment>");
+        $stdout = file_get_contents($this->daemon_file["stdout"]);
+        $stdout = explode("\n", $stdout);
+        for ($i = 10; $i > 0; --$i) {
+            if (isset($stdout[count($stdout) - $i]))
+                echo $stdout[count($stdout) - $i] . PHP_EOL;
+        }
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/DaemonStopCommand.php
+++ b/src/ZM/Command/DaemonStopCommand.php
@@ -0,0 +1,26 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use ZM\Utils\DataProvider;
+
+class DaemonStopCommand extends DaemonCommand
+{
+    protected static $defaultName = 'daemon:stop';
+
+    protected function configure() {
+        $this->setDescription("停止守护进程下运行的框架（仅限--daemon模式可用）");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        parent::execute($input, $output);
+        system("kill -TERM " . intval($this->daemon_file["pid"]));
+        unlink(DataProvider::getWorkingDir() . "/.daemon_pid");
+        $output->writeln("<info>成功停止！</info>");
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/PureHttpCommand.php
+++ b/src/ZM/Command/PureHttpCommand.php
@@ -36,8 +36,8 @@ class PureHttpCommand extends Command

    protected function execute(InputInterface $input, OutputInterface $output) {
        $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>");
+        if (realpath($input->getArgument('dir') ?? '.') === false) {
+            $output->writeln("<error>Directory error(" . ($input->getArgument('dir') ?? '.') . "): no such file or directory.</error>");
            return self::FAILURE;
        }
        $global = ZMConfig::get("global");
@@ -60,15 +60,15 @@ class PureHttpCommand extends Command
                    "document_root" => realpath($input->getArgument('dir') ?? '.'),
                    "document_index" => $index
                ]);
-            echo "\r".Coroutine::stats()["coroutine_peak_num"];
+            echo "\r" . Coroutine::stats()["coroutine_peak_num"];
        });
        $server->on("start", function ($server) {
            Process::signal(SIGINT, function () use ($server) {
                Console::warning("Server interrupted by keyboard.");
                for ($i = 0; $i < 32; ++$i) {
                    $num = ZMAtomic::$atomics["request"][$i]->get();
-                    if($num != 0)
-                    echo "[$i]: ".$num."\n";
+                    if ($num != 0)
+                        echo "[$i]: " . $num . "\n";
                }
                $server->shutdown();
                $server->stop();
--- a/src/ZM/Command/RunServerCommand.php
+++ b/src/ZM/Command/RunServerCommand.php
@@ -11,7 +11,6 @@ use ZM\Framework;

 class RunServerCommand extends Command
 {
-    // the name of the command (the part after "bin/console")
    protected static $defaultName = 'server';

    protected function configure() {
@@ -31,27 +30,17 @@ class RunServerCommand extends Command
        ]);
        $this->setDescription("Run zhamao-framework | 启动框架");
        $this->setHelp("直接运行可以启动");
-
-        // ...
    }

    protected function execute(InputInterface $input, OutputInterface $output) {
-        if(($opt = $input->getOption("env")) !== null) {
-            if(!in_array($opt, ["production", "staging", "development", ""])) {
+        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>");
                return Command::FAILURE;
            }
        }
-        // ... put here the code to run in your command
-        // this method must return an integer number with the "exit status code"
-        // of the command. You can also use these constants to make code more readable
+        if (LOAD_MODE == 0) echo "* This is repository mode.\n";
        (new Framework($input->getOptions()))->start();
-        // return this if there was no problem running the command
-        // (it's equivalent to returning int(0))
        return Command::SUCCESS;
-
-        // or return this if some error happened during the execution
-        // (it's equivalent to returning int(1))
-        // return Command::FAILURE;
    }
 }
--- a/src/ZM/ConsoleApplication.php
+++ b/src/ZM/ConsoleApplication.php
@@ -5,6 +5,9 @@ namespace ZM;


 use Exception;
+use ZM\Command\DaemonReloadCommand;
+use ZM\Command\DaemonStatusCommand;
+use ZM\Command\DaemonStopCommand;
 use ZM\Command\InitCommand;
 use ZM\Command\PureHttpCommand;
 use ZM\Command\RunServerCommand;
@@ -40,7 +43,6 @@ class ConsoleApplication extends Application
             * @noinspection RedundantSuppression
             */
            require_once WORKING_DIR . "/vendor/autoload.php";
-            echo "* This is repository mode.\n";
            $composer = json_decode(file_get_contents(DataProvider::getWorkingDir() . "/composer.json"), true);
            if (!isset($composer["autoload"]["psr-4"]["Module\\"])) {
                echo "框架源码模式需要在autoload文件中添加Module目录为自动加载，是否添加？[Y/n] ";
@@ -64,6 +66,9 @@ class ConsoleApplication extends Application
        }

        $this->addCommands([
+            new DaemonStatusCommand(),
+            new DaemonReloadCommand(),
+            new DaemonStopCommand(),
            new RunServerCommand(), //运行主服务的指令控制器
            new InitCommand(), //初始化用的，用于项目初始化和phar初始化
            new PureHttpCommand() //纯HTTP服务器指令
--- a/src/ZM/Context/Context.php
+++ b/src/ZM/Context/Context.php
@@ -145,7 +145,7 @@ class Context implements ContextInterface
        if ($prompt != "") $this->reply($prompt);

        try {
-            $r = CoMessage::yieldByWS($this->getData(), ["user_id", "self_id", "message_type", onebot_target_id_name($this->getMessageType())]);
+            $r = CoMessage::yieldByWS($this->getData(), ["user_id", "self_id", "message_type", onebot_target_id_name($this->getMessageType())], $timeout);
        } catch (Exception $e) {
            $r = false;
        }
--- a/src/ZM/DB/DB.php
+++ b/src/ZM/DB/DB.php
@@ -31,7 +31,6 @@ class DB

    /**
     * @param $table_name
-     * @param bool $enable_cache
     * @return Table
     * @throws DbException
     */
@@ -39,7 +38,7 @@ class DB
        if (Table::getTableInstance($table_name) === null) {
            if (in_array($table_name, self::$table_list))
                return new Table($table_name);
-            elseif(SqlPoolStorage::$sql_pool !== null){
+            elseif (SqlPoolStorage::$sql_pool !== null) {
                throw new DbException("Table " . $table_name . " not exist in database.");
            } else {
                throw new DbException("Database connection not exist or connect failed. Please check sql configuration");
@@ -85,7 +84,7 @@ class DB
     * @throws DbException
     */
    public static function rawQuery(string $line, $params = [], $fetch_mode = ZM_DEFAULT_FETCH_MODE) {
-        Console::debug("MySQL: ".$line." | ". implode(", ", $params));
+        Console::debug("MySQL: " . $line . " | " . implode(", ", $params));
        try {
            $conn = SqlPoolStorage::$sql_pool->get();
            if ($conn === false) {
@@ -95,6 +94,7 @@ class DB
            $ps = $conn->prepare($line);
            if ($ps === false) {
                SqlPoolStorage::$sql_pool->put(null);
+                /** @noinspection PhpUndefinedFieldInspection */
                throw new DbException("SQL语句查询错误，" . $line . "，错误信息：" . $conn->error);
            } else {
                if (!($ps instanceof PDOStatement) && !($ps instanceof PDOStatementProxy)) {
@@ -115,7 +115,7 @@ class DB
                return $ps->fetchAll($fetch_mode);
            }
        } catch (DbException $e) {
-            if(mb_strpos($e->getMessage(), "has gone away") !== false) {
+            if (mb_strpos($e->getMessage(), "has gone away") !== false) {
                zm_sleep(0.2);
                Console::warning("Gone away of MySQL! retrying!");
                return self::rawQuery($line, $params);
@@ -123,7 +123,7 @@ class DB
            Console::warning($e->getMessage());
            throw $e;
        } catch (PDOException $e) {
-            if(mb_strpos($e->getMessage(), "has gone away") !== false) {
+            if (mb_strpos($e->getMessage(), "has gone away") !== false) {
                zm_sleep(0.2);
                Console::warning("Gone away of MySQL! retrying!");
                return self::rawQuery($line, $params);
--- a/src/ZM/DB/InsertBody.php
+++ b/src/ZM/DB/InsertBody.php
@@ -28,6 +28,6 @@ class InsertBody
     * @throws DbException
     */
    public function save() {
-        DB::rawQuery('INSERT INTO ' . $this->table->getTableName() . ' VALUES ('.implode(',', array_fill(0, count($this->row), '?')).')', $this->row);
+        DB::rawQuery('INSERT INTO ' . $this->table->getTableName() . ' VALUES (' . implode(',', array_fill(0, count($this->row), '?')) . ')', $this->row);
    }
 }
--- a/src/ZM/DB/Table.php
+++ b/src/ZM/DB/Table.php
@@ -4,7 +4,6 @@
 namespace ZM\DB;


-
 class Table
 {
    private $table_name;
@@ -28,7 +27,7 @@ class Table
        return new SelectBody($this, $what == [] ? ["*"] : $what);
    }

-    public function where($column, $operation_or_value, $value = null){
+    public function where($column, $operation_or_value, $value = null) {
        return (new SelectBody($this, ["*"]))->where($column, $operation_or_value, $value);
    }

@@ -47,7 +46,7 @@ class Table
        return new DeleteBody($this);
    }

-    public function statement($line){
+    public function statement() {
        $this->cache = [];
        //TODO: 无返回的statement语句
    }
--- a/src/ZM/DB/UpdateBody.php
+++ b/src/ZM/DB/UpdateBody.php
@@ -18,6 +18,7 @@ class UpdateBody
     * @var array
     */
    private $set_value;
+
    /**
     * UpdateBody constructor.
     * @param Table $table
@@ -31,19 +32,19 @@ class UpdateBody
    /**
     * @throws DbException
     */
-    public function save(){
+    public function save() {
        $arr = [];
        $msg = [];
-        foreach($this->set_value as $k => $v) {
-            $msg []= $k .' = ?';
-            $arr[]=$v;
+        foreach ($this->set_value as $k => $v) {
+            $msg [] = $k . ' = ?';
+            $arr[] = $v;
        }
-        if(($msg ?? []) == []) throw new DbException('update value sets can not be empty!');
-        $line = 'UPDATE '.$this->table->getTableName().' SET '.implode(', ', $msg);
-        if($this->where_thing != []) {
+        if (($msg ?? []) == []) throw new DbException('update value sets can not be empty!');
+        $line = 'UPDATE ' . $this->table->getTableName() . ' SET ' . implode(', ', $msg);
+        if ($this->where_thing != []) {
            list($sql, $param) = $this->getWhereSQL();
            $arr = array_merge($arr, $param);
-            $line .= ' WHERE '.$sql;
+            $line .= ' WHERE ' . $sql;
        }
        return DB::rawQuery($line, $arr);
    }
--- a/src/ZM/DB/WhereBody.php
+++ b/src/ZM/DB/WhereBody.php
@@ -15,17 +15,17 @@ trait WhereBody
        return $this;
    }

-    protected function getWhereSQL(){
+    protected function getWhereSQL() {
        $param = [];
        $msg = '';
-        foreach($this->where_thing as $k => $v) {
-            foreach($v as $ks => $vs) {
-                if($param != []) {
-                    $msg .= ' AND '.$ks ." $k ?";
+        foreach ($this->where_thing as $k => $v) {
+            foreach ($v as $ks => $vs) {
+                if ($param != []) {
+                    $msg .= ' AND ' . $ks . " $k ?";
                } else {
                    $msg .= "$ks $k ?";
                }
-                $param []=$vs;
+                $param [] = $vs;
            }
        }
        if ($msg == '') $msg = 1;
--- a/src/ZM/Event/EventDispatcher.php
+++ b/src/ZM/Event/EventDispatcher.php
@@ -87,27 +87,23 @@ class EventDispatcher
    /**
     * @param mixed ...$params
     * @throws Exception
-     * @throws InterruptException
     */
    public function dispatchEvents(...$params) {
        try {
            foreach ((EventManager::$events[$this->class] ?? []) as $v) {
                $this->dispatchEvent($v, $this->rule, ...$params);
                if ($this->log) Console::verbose("[事件分发{$this->eid}] 单一对象 " . $v->class . "::" . $v->method . " 分发结束。");
-                if($this->status == self::STATUS_BEFORE_FAILED || $this->status == self::STATUS_RULE_FAILED) continue;
+                if ($this->status == self::STATUS_BEFORE_FAILED || $this->status == self::STATUS_RULE_FAILED) continue;
                if (is_callable($this->return_func) && $this->status === self::STATUS_NORMAL) {
                    if ($this->log) Console::verbose("[事件分发{$this->eid}] 单一对象 " . $v->class . "::" . $v->method . " 正在执行返回值处理函数 ...");
                    ($this->return_func)($this->store);
                }
            }
-            if($this->status === self::STATUS_RULE_FAILED) $this->status = self::STATUS_NORMAL;
+            if ($this->status === self::STATUS_RULE_FAILED) $this->status = self::STATUS_NORMAL;
        } catch (InterruptException $e) {
            $this->store = $e->return_var;
            $this->status = self::STATUS_INTERRUPTED;
-        } catch (Exception $e) {
-            $this->status = self::STATUS_EXCEPTION;
-            throw $e;
-        } catch (Error $e) {
+        } catch (Exception | Error $e) {
            $this->status = self::STATUS_EXCEPTION;
            throw $e;
        }
@@ -117,9 +113,9 @@ class EventDispatcher
     * @param mixed $v
     * @param null $rule_func
     * @param mixed ...$params
-     * @throws AnnotationException
-     * @throws InterruptException
     * @return bool
+     * @throws InterruptException
+     * @throws AnnotationException
     */
    public function dispatchEvent($v, $rule_func = null, ...$params) {
        $q_c = $v->class;
--- a/src/ZM/Event/EventManager.php
+++ b/src/ZM/Event/EventManager.php
@@ -9,8 +9,11 @@ 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;
+use ZM\Store\LightCache;
 use ZM\Store\ZMAtomic;

 class EventManager
@@ -59,5 +62,11 @@ class EventManager
                }
            });
        }
+        $conf = ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if (server()->worker_id == $conf["worker"]) {
+            zm_timer_tick(ZMConfig::get("global", "light_cache")["auto_save_interval"] * 1000, function () {
+                LightCache::savePersistence();
+            });
+        }
    }
 }
--- a/src/ZM/Event/ServerEventHandler.php
+++ b/src/ZM/Event/ServerEventHandler.php
@@ -1,4 +1,6 @@
-<?php /** @noinspection PhpComposerExtensionStubsInspection */
+<?php /** @noinspection PhpUnreachableStatementInspection */
+
+/** @noinspection PhpComposerExtensionStubsInspection */


 namespace ZM\Event;
@@ -14,12 +16,12 @@ use Swoole\Database\PDOConfig;
 use Swoole\Database\PDOPool;
 use Swoole\Event;
 use Swoole\Process;
-use Swoole\Timer;
 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;
@@ -39,9 +41,11 @@ 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\Store\ZMBuf;
 use ZM\Utils\DataProvider;
 use ZM\Utils\HttpUtil;
@@ -59,7 +63,12 @@ class ServerEventHandler
        if ($terminal_id !== null) {
            ZMBuf::$terminal = $r = STDIN;
            Event::add($r, function () use ($r) {
-                $var = trim(fgets($r));
+                $fget = fgets($r);
+                if ($fget === false) {
+                    Event::del($r);
+                    return;
+                }
+                $var = trim($fget);
                try {
                    Terminal::executeCommand($var, $r);
                } catch (Exception $e) {
@@ -71,11 +80,18 @@ class ServerEventHandler
        }
        Process::signal(SIGINT, function () use ($r) {
            echo "\r";
-            Console::warning("Server interrupted by keyboard on Master.");
+            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.");
@@ -84,11 +100,11 @@ class ServerEventHandler
                $this->addWatcher(DataProvider::getWorkingDir() . "/src", $fd);
                Event::add($fd, function () use ($fd) {
                    $r = inotify_read($fd);
-                    var_dump($r);
+                    dump($r);
                    ZMUtil::reload();
                });
            } else {
-                Console::warning("You have not loaded inotify extension.");
+                Console::warning("You have not loaded \"inotify\" extension, please install first.");
            }
        }
    }
@@ -106,6 +122,9 @@ class ServerEventHandler
     * @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 已停止");
    }

@@ -228,7 +247,7 @@ class ServerEventHandler
                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');
-                ZMUtil::stop();
+                posix_kill($server->master_pid, SIGINT);
            }
        } else {
            // 这里是TaskWorker初始化的内容部分
@@ -245,7 +264,7 @@ class ServerEventHandler
                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');
-                ZMUtil::stop();
+                posix_kill($server->master_pid, SIGINT);
            }
        }
    }
@@ -258,11 +277,12 @@ class ServerEventHandler
    public function onMessage($server, Frame $frame) {

        Console::debug("Calling Swoole \"message\" from fd=" . $frame->fd . ": " . TermColor::ITALIC . $frame->data . TermColor::RESET);
-        unset(Context::$context[\Swoole\Coroutine::getCid()]);
+        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() . ";");
        });

@@ -303,6 +323,9 @@ class ServerEventHandler
     */
    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]);
@@ -387,6 +410,14 @@ class ServerEventHandler
        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"] ?? $request->get["token"] ?? "")[1] ?? "";
+        if (($a = ZMConfig::get("global", "access_token")) != "") {
+            if ($access_token !== $a) {
+                $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);
@@ -477,9 +508,10 @@ class ServerEventHandler

    /**
     * @SwooleHandler("pipeMessage")
-     * @param $server
+     * @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);
@@ -490,28 +522,80 @@ class ServerEventHandler
                $obj = $data["data"];
                Co::resume($obj["coroutine"]);
                break;
-            case "stop":
-                Console::verbose('正在清理 #' . $server->worker_id . ' 的计时器');
-                Timer::clearAll();
+            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 "terminate":
-                $server->stop();
+            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 'echo':
-                Console::success('接收到来自 #' . $src_worker_id . ' 的消息');
+            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 'send':
-                $server->sendMessage(json_encode(["action" => "echo"]), $data["target"]);
+            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:
-                echo $data . PHP_EOL;
+                $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() {
+    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;
    }

    /**
--- a/src/ZM/Framework.php
+++ b/src/ZM/Framework.php
@@ -94,7 +94,7 @@ class Framework
                "version" => ZM_VERSION,
                "config" => $args["env"] === null ? 'global.php' : $args["env"]
            ];
-            if(APP_VERSION !== "unknown") $out["app_version"] = APP_VERSION;
+            if (APP_VERSION !== "unknown") $out["app_version"] = APP_VERSION;
            if (isset(ZMConfig::get("global", "swoole")["task_worker_num"])) {
                $out["task_worker_num"] = ZMConfig::get("global", "swoole")["task_worker_num"];
            }
@@ -250,6 +250,7 @@ class Framework
                case 'daemon':
                    if ($y) {
                        $this->server_set["daemonize"] = 1;
+                        Console::$theme = "no-color";
                        Console::log("已启用守护进程，输出重定向到 " . $this->server_set["log_file"]);
                        $terminal_id = null;
                    }
--- a/src/ZM/Http/Response.php
+++ b/src/ZM/Http/Response.php
@@ -4,8 +4,6 @@
 namespace ZM\Http;


-use ZM\Console\Console;
-
 class Response
 {

@@ -162,7 +160,7 @@ class Response
     * @return mixed
     */
    public function end($content = null) {
-        if(!$this->is_end) {
+        if (!$this->is_end) {
            $this->is_end = true;
            return $this->response->end($content);
        } else {
--- a/src/ZM/Http/RouteManager.php
+++ b/src/ZM/Http/RouteManager.php
@@ -8,6 +8,7 @@ use Symfony\Component\Routing\Route;
 use Symfony\Component\Routing\RouteCollection;
 use ZM\Annotation\Http\Controller;
 use ZM\Annotation\Http\RequestMapping;
+use ZM\Console\Console;

 class RouteManager
 {
@@ -15,7 +16,7 @@ class RouteManager
    public static $routes = null;

    public static function importRouteByAnnotation(RequestMapping $vss, $method, $class, $methods_annotations) {
-        if(self::$routes === null) self::$routes = new RouteCollection();
+        if (self::$routes === null) self::$routes = new RouteCollection();

        // 拿到所属方法的类上面有没有控制器的注解
        $prefix = '';
@@ -25,8 +26,9 @@ class RouteManager
                break;
            }
        }
-
-        $route_name = $prefix."/".$vss->route;
+        $tail = trim($vss->route, "/");
+        $route_name = $prefix . ($tail === "" ? "" : "/") . $tail;
+        Console::debug("添加路由：" . $route_name);
        $route = new Route($route_name, ['_class' => $class, '_method' => $method]);
        $route->setMethods($vss->request_method);

--- a/src/ZM/Http/StaticFileHandler.php
+++ b/src/ZM/Http/StaticFileHandler.php
@@ -13,14 +13,14 @@ class StaticFileHandler
    public function __construct($filename, $path) {
        $full_path = realpath($path . "/" . $filename);
        $response = ctx()->getResponse();
-        Console::debug("Full path: ".$full_path);
+        Console::debug("Full path: " . $full_path);
        if ($full_path !== false) {
            if (strpos($full_path, $path) !== 0) {
                $response->status(403);
                $response->end("403 Forbidden");
                return true;
            } else {
-                if(is_file($full_path)) {
+                if (is_file($full_path)) {
                    $exp = strtolower(pathinfo($full_path)['extension'] ?? "unknown");
                    $response->setHeader("Content-Type", ZMConfig::get("file_header")[$exp] ?? "application/octet-stream");
                    $response->end(file_get_contents($full_path));
--- a/src/ZM/Module/QQBot.php
+++ b/src/ZM/Module/QQBot.php
@@ -3,7 +3,7 @@

 namespace ZM\Module;

-use Swoole\Coroutine;
+use Exception;
 use ZM\Annotation\CQ\CQAPIResponse;
 use ZM\Annotation\CQ\CQBefore;
 use ZM\Annotation\CQ\CQCommand;
@@ -14,8 +14,6 @@ use ZM\Annotation\CQ\CQRequest;
 use ZM\Event\EventDispatcher;
 use ZM\Exception\InterruptException;
 use ZM\Exception\WaitTimeoutException;
-use ZM\Store\LightCacheInside;
-use ZM\Store\Lock\SpinLock;
 use ZM\Utils\CoMessage;

 /**
@@ -26,27 +24,27 @@ class QQBot
 {
    /**
     * @throws InterruptException
+     * @throws Exception
     */
    public function handle() {
        try {
            $data = json_decode(context()->getFrame()->data, true);
+            set_coroutine_params(["data" => $data]);
            if (isset($data["post_type"])) {
                //echo TermColor::ITALIC.json_encode($data, 128|256).TermColor::RESET.PHP_EOL;
-                set_coroutine_params(["data" => $data]);
                ctx()->setCache("level", 0);
                //Console::debug("Calling CQ Event from fd=" . ctx()->getConnection()->getFd());
                if ($data["post_type"] != "meta_event") {
                    $r = $this->dispatchBeforeEvents($data); // before在这里执行，元事件不执行before为减少不必要的调试日志
                    if ($r->store === "block") EventDispatcher::interrupt();
                }
-                if (CoMessage::resumeByWS()) {
-                    EventDispatcher::interrupt();
-                }
                //Console::warning("最上数据包：".json_encode($data));
-                $this->dispatchEvents($data);
-            } else {
-                $this->dispatchAPIResponse($data);
            }
+            if (isset($data["echo"]) || isset($data["post_type"])) {
+                if (CoMessage::resumeByWS()) EventDispatcher::interrupt();
+            }
+            if (isset($data["post_type"])) $this->dispatchEvents($data);
+            else $this->dispatchAPIResponse($data);
        } /** @noinspection PhpRedundantCatchClauseInspection */ catch (WaitTimeoutException $e) {
            $e->module->finalReply($e->getMessage());
        }
@@ -55,7 +53,7 @@ class QQBot
    /**
     * @param $data
     * @return EventDispatcher
-     * @throws InterruptException
+     * @throws Exception
     */
    public function dispatchBeforeEvents($data) {
        $before = new EventDispatcher(CQBefore::class);
@@ -177,45 +175,16 @@ class QQBot
        }
    }

+    /**
+     * @param $req
+     * @throws Exception
+     */
    private function dispatchAPIResponse($req) {
-        $status = $req["status"];
-        $retcode = $req["retcode"];
-        $data = $req["data"];
-        if (isset($req["echo"]) && is_numeric($req["echo"])) {
-            $r = LightCacheInside::get("wait_api", "wait_api");
-            if (isset($r[$req["echo"]])) {
-                $origin = $r[$req["echo"]];
-                $self_id = $origin["self_id"];
-                $response = [
-                    "status" => $status,
-                    "retcode" => $retcode,
-                    "data" => $data,
-                    "self_id" => $self_id,
-                    "echo" => $req["echo"]
-                ];
-                set_coroutine_params(["cq_response" => $response]);
-                $dispatcher = new EventDispatcher(CQAPIResponse::class);
-                $dispatcher->setRuleFunction(function (CQAPIResponse $response) {
-                    return $response->retcode == ctx()->getCQResponse()["retcode"];
-                });
-                $dispatcher->dispatchEvents($response);
-
-                $origin_ctx = ctx()->copy();
-                set_coroutine_params($origin_ctx);
-                if (($origin["coroutine"] ?? false) !== false) {
-                    SpinLock::lock("wait_api");
-                    $r = LightCacheInside::get("wait_api", "wait_api");
-                    $r[$req["echo"]]["result"] = $response;
-                    LightCacheInside::set("wait_api", "wait_api", $r);
-                    SpinLock::unlock("wait_api");
-                    Coroutine::resume($origin['coroutine']);
-                }
-                SpinLock::lock("wait_api");
-                $r = LightCacheInside::get("wait_api", "wait_api");
-                unset($r[$req["echo"]]);
-                LightCacheInside::set("wait_api", "wait_api", $r);
-                SpinLock::unlock("wait_api");
-            }
-        }
+        set_coroutine_params(["cq_response" => $req]);
+        $dispatcher = new EventDispatcher(CQAPIResponse::class);
+        $dispatcher->setRuleFunction(function (CQAPIResponse $response) {
+            return $response->retcode == ctx()->getCQResponse()["retcode"];
+        });
+        $dispatcher->dispatchEvents($req);
    }
 }
--- a/src/ZM/Store/LightCache.php
+++ b/src/ZM/Store/LightCache.php
@@ -6,7 +6,11 @@ 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;

 class LightCache
 {
@@ -19,6 +23,11 @@ class LightCache

    public static $last_error = '';

+    /**
+     * @param $config
+     * @return bool|mixed
+     * @throws Exception
+     */
    public static function init($config) {
        self::$config = $config;
        self::$kv_table = new Table($config["size"], $config["hash_conflict_proportion"]);
@@ -50,11 +59,11 @@ class LightCache

    /**
     * @param string $key
-     * @return null|string
-     * @throws Exception
+     * @return null|mixed
+     * @throws ZMException
     */
    public static function get(string $key) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
        self::checkExpire($key);
        $r = self::$kv_table->get($key);
        return $r === false ? null : self::parseGet($r);
@@ -63,10 +72,10 @@ class LightCache
    /**
     * @param string $key
     * @return mixed|null
-     * @throws Exception
+     * @throws ZMException
     */
    public static function getExpire(string $key) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache");
+        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 - time();
@@ -77,10 +86,10 @@ class LightCache
     * @param string|array|int $value
     * @param int $expire
     * @return mixed
-     * @throws Exception
+     * @throws ZMException
     */
    public static function set(string $key, $value, int $expire = -1) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
        if (is_array($value)) {
            $value = json_encode($value, JSON_UNESCAPED_UNICODE);
            if (strlen($value) >= self::$config["max_strlen"]) return false;
@@ -93,7 +102,7 @@ class LightCache
            $data_type = "bool";
            $value = json_encode($value);
        } else {
-            throw new Exception("Only can set string, array and int");
+            throw new ZMException("Only can set string, array and int");
        }
        try {
            return self::$kv_table->set($key, [
@@ -110,10 +119,10 @@ class LightCache
     * @param string $key
     * @param $value
     * @return bool|mixed
-     * @throws Exception
+     * @throws ZMException
     */
    public static function update(string $key, $value) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache.");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache.");
        if (is_array($value)) {
            $value = json_encode($value, JSON_UNESCAPED_UNICODE);
            if (strlen($value) >= self::$config["max_strlen"]) return false;
@@ -123,7 +132,7 @@ class LightCache
        } elseif (is_int($value)) {
            $data_type = "int";
        } else {
-            throw new Exception("Only can set string, array and int");
+            throw new ZMException("Only can set string, array and int");
        }
        try {
            if (self::$kv_table->get($key) === false) return false;
@@ -169,7 +178,16 @@ class LightCache
        return $r;
    }

-    public static function savePersistence() {
+    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();
+        }
+
+        if($only_worker) return;
+
        if (self::$kv_table === null) return;
        $r = [];
        foreach (self::$kv_table as $k => $v) {
@@ -178,11 +196,13 @@ class LightCache
                $r[$k] = self::parseGet($v);
            }
        }
-        if(self::$config["persistence_path"] == "") return;
+        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\"!");
        }
+
+
    }

    private static function checkExpire($key) {
--- a/src/ZM/Store/LightCacheInside.php
+++ b/src/ZM/Store/LightCacheInside.php
@@ -23,9 +23,10 @@ class LightCacheInside
        $result = self::$kv_table["wait_api"]->create() && self::$kv_table["connect"]->create();
        if ($result === false) {
            self::$last_error = '系统内存不足，申请失败';
-            return $result;
+            return false;
+        } else {
+            return true;
        }
-        return $result;
    }

    /**
--- a/src/ZM/Store/Lock/SpinLock.php
+++ b/src/ZM/Store/Lock/SpinLock.php
@@ -15,18 +15,16 @@ class SpinLock

    private static $delay = 1;

-    public static function init($key_cnt, $delay = 1)
-    {
+    public static function init($key_cnt, $delay = 1) {
        self::$kv_lock = new Table($key_cnt, 0.7);
        self::$delay = $delay;
        self::$kv_lock->column('lock_num', Table::TYPE_INT, 8);
        return self::$kv_lock->create();
    }

-    public static function lock(string $key)
-    {
+    public static function lock(string $key) {
        while (($r = self::$kv_lock->incr($key, 'lock_num')) > 1) { //此资源已经被锁上了
-            if(Coroutine::getCid() != -1) System::sleep(self::$delay / 1000);
+            if (Coroutine::getCid() != -1) System::sleep(self::$delay / 1000);
            else usleep(self::$delay * 1000);
        }
    }
@@ -41,4 +39,10 @@ class SpinLock
    public static function unlock(string $key) {
        return self::$kv_lock->set($key, ['lock_num' => 0]);
    }
+
+    public static function transaction(string $key, callable $function) {
+        SpinLock::lock($key);
+        $function();
+        SpinLock::unlock($key);
+    }
 }
--- a/src/ZM/Store/Redis/ZMRedis.php
+++ b/src/ZM/Store/Redis/ZMRedis.php
@@ -16,7 +16,7 @@ class ZMRedis
     * @throws NotInitializedException
     */
    public static function call(callable $callable) {
-        if(ZMRedisPool::$pool === null) throw new NotInitializedException("Redis pool is not initialized.");
+        if (ZMRedisPool::$pool === null) throw new NotInitializedException("Redis pool is not initialized.");
        $r = ZMRedisPool::$pool->get();
        $result = $callable($r);
        if (isset($r->wasted)) ZMRedisPool::$pool->put(null);
@@ -29,7 +29,7 @@ class ZMRedis
     * @throws NotInitializedException
     */
    public function __construct() {
-        if(ZMRedisPool::$pool === null) throw new NotInitializedException("Redis pool is not initialized.");
+        if (ZMRedisPool::$pool === null) throw new NotInitializedException("Redis pool is not initialized.");
        $this->conn = ZMRedisPool::$pool->get();
    }

--- a/src/ZM/Store/Redis/ZMRedisPool.php
+++ b/src/ZM/Store/Redis/ZMRedisPool.php
@@ -24,13 +24,13 @@ class ZMRedisPool
        );
        try {
            $r = self::$pool->get()->ping('123');
-            if(strpos(strtolower($r), "123") !== false) {
+            if (strpos(strtolower($r), "123") !== false) {
                Console::debug("成功连接redis连接池！");
            } else {
                var_dump($r);
            }
        } catch (RedisException $e) {
-            Console::error("Redis init failed! ".$e->getMessage());
+            Console::error("Redis init failed! " . $e->getMessage());
            self::$pool = null;
        }
    }
--- a/src/ZM/Store/WorkerCache.php
+++ b/src/ZM/Store/WorkerCache.php
@@ -0,0 +1,96 @@
+<?php
+
+
+namespace ZM\Store;
+
+
+use ZM\Config\ZMConfig;
+
+class WorkerCache
+{
+    public static $config = null;
+
+    public static $store = [];
+
+    public static $transfer = [];
+
+    public static function get($key) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            return self::$store[$key] ?? null;
+        } else {
+            $action = ["action" => "getWorkerCache", "key" => $key, "cid" => zm_cid()];
+            server()->sendMessage(json_encode($action, JSON_UNESCAPED_UNICODE), $config["worker"]);
+            zm_yield();
+            $p = self::$transfer[zm_cid()] ?? null;
+            unset(self::$transfer[zm_cid()]);
+            return $p;
+        }
+    }
+
+    public static function set($key, $value, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            self::$store[$key] = $value;
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncSetWorkerCache" : "setWorkerCache", "key" => $key, "value" => $value, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+
+    public static function hasKey($key, $subkey) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            return isset(self::$store[$key][$subkey]);
+        } else {
+            $action = ["hasKeyWorkerCache", "key" => $key, "subkey" => $subkey, "cid" => zm_cid()];
+            return self::processRemote($action, false, $config);
+        }
+    }
+
+    private static function processRemote($action, $async, $config) {
+        $ss = server()->sendMessage(json_encode($action, JSON_UNESCAPED_UNICODE), $config["worker"]);
+        if (!$ss) return false;
+        if ($async) return true;
+        zm_yield();
+        $p = self::$transfer[zm_cid()] ?? null;
+        unset(self::$transfer[zm_cid()]);
+        return $p;
+    }
+
+    public static function unset($key, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            unset(self::$store[$key]);
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncUnsetWorkerCache" : "unsetWorkerCache", "key" => $key, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+
+    public static function add($key, int $value, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            if (!isset(self::$store[$key])) self::$store[$key] = 0;
+            self::$store[$key] += $value;
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncAddWorkerCache" : "addWorkerCache", "key" => $key, "value" => $value, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+
+    public static function sub($key, int $value, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            if (!isset(self::$store[$key])) self::$store[$key] = 0;
+            self::$store[$key] -= $value;
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncSubWorkerCache" : "subWorkerCache", "key" => $key, "value" => $value, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+}
--- a/src/ZM/Utils/CoMessage.php
+++ b/src/ZM/Utils/CoMessage.php
@@ -16,7 +16,7 @@ class CoMessage
     * @param array $hang
     * @param array $compare
     * @param int $timeout
-     * @return bool
+     * @return mixed
     * @throws Exception
     */
    public static function yieldByWS(array $hang, array $compare, $timeout = 600) {
@@ -55,20 +55,21 @@ class CoMessage
        SpinLock::lock("wait_api");
        $all = LightCacheInside::get("wait_api", "wait_api") ?? [];
        foreach ($all as $k => $v) {
-            if(!isset($v["compare"])) continue;
+            if (!isset($v["compare"])) continue;
            foreach ($v["compare"] as $vs) {
-                if ($v[$vs] != ($dat[$vs] ?? null)) {
+                if (!isset($v[$vs], $dat[$vs])) continue 2;
+                if ($v[$vs] != $dat[$vs]) {
                    continue 2;
                }
            }
            $last = $k;
        }
-        if($last !== null) {
+        if ($last !== null) {
            $all[$last]["result"] = $dat;
            LightCacheInside::set("wait_api", "wait_api", $all);
            SpinLock::unlock("wait_api");
            if ($all[$last]["worker_id"] != server()->worker_id) {
-                ZMUtil::sendActionToWorker($all[$k]["worker_id"], "resume_ws_message", $all[$last]);
+                ZMUtil::sendActionToWorker($all[$last]["worker_id"], "resume_ws_message", $all[$last]);
            } else {
                Co::resume($all[$last]["coroutine"]);
            }
--- a/src/ZM/Utils/DataProvider.php
+++ b/src/ZM/Utils/DataProvider.php
@@ -5,6 +5,7 @@ namespace ZM\Utils;


 use ZM\Config\ZMConfig;
+use ZM\Console\Console;

 class DataProvider
 {
@@ -15,7 +16,7 @@ class DataProvider
    }

    public static function getWorkingDir() {
-        if(LOAD_MODE == 0) return WORKING_DIR;
+        if (LOAD_MODE == 0) return WORKING_DIR;
        elseif (LOAD_MODE == 1) return LOAD_MODE_COMPOSER_PATH;
        elseif (LOAD_MODE == 2) return realpath('.');
        return null;
@@ -28,4 +29,29 @@ class DataProvider
    public static function getDataFolder() {
        return ZM_DATA;
    }
+
+    public static function saveToJson($filename, $file_array) {
+        $path = ZMConfig::get("global", "config_dir");
+        $r = explode("/", $filename);
+        if(count($r) == 2) {
+            $path = $path . $r[0]."/";
+            if(!is_dir($path)) mkdir($path);
+            $name = $r[1];
+        } elseif (count($r) != 1) {
+            Console::warning("存储失败，文件名只能有一级目录");
+            return false;
+        } else {
+            $name = $r[0];
+        }
+        return file_put_contents($path.$name.".json", json_encode($file_array, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+    }
+
+    public static function loadFromJson($filename) {
+        $path = ZMConfig::get("global", "config_dir");
+        if(file_exists($path.$filename.".json")) {
+            return json_decode(file_get_contents($path.$filename.".json"), true);
+        } else {
+            return null;
+        }
+    }
 }
--- a/src/ZM/Utils/ProcessManager.php
+++ b/src/ZM/Utils/ProcessManager.php
@@ -0,0 +1,17 @@
+<?php
+
+
+namespace ZM\Utils;
+
+
+class ProcessManager
+{
+    public static function runOnTask($param, $timeout = 0.5, $dst_worker_id = -1) {
+        return server()->taskwait([
+            "action" => "runMethod",
+            "class" => $param["class"],
+            "method" => $param["method"],
+            "params" => $param["params"]
+        ], $timeout, $dst_worker_id);
+    }
+}
--- a/src/ZM/Utils/SingletonTrait.php
+++ b/src/ZM/Utils/SingletonTrait.php
@@ -11,6 +11,8 @@ trait SingletonTrait
     */
    private static $instance;

+    protected static $cached = [];
+
    /**
     * @return self
     */
--- a/src/ZM/global_functions.php
+++ b/src/ZM/global_functions.php
@@ -24,6 +24,7 @@ function phar_classloader($p) {
        return;
    }
    try {
+        /** @noinspection PhpIncludeInspection */
        require_once $filepath;
    } catch (Exception $e) {
        echo "Error when finding class: " . $p . PHP_EOL;
@@ -75,7 +76,7 @@ function unicode_decode($str) {
 /**
 * 获取模块文件夹下的每个类文件的类名称
 * @param $dir
- * @param string $indoor_name
+ * @param $indoor_name
 * @return array
 */
 function getAllClasses($dir, $indoor_name) {
@@ -88,13 +89,14 @@ function getAllClasses($dir, $indoor_name) {
        //echo "At " . $indoor_name . PHP_EOL;
        if (is_dir($dir . $v)) $classes = array_merge($classes, getAllClasses($dir . $v . "/", $indoor_name . "\\" . $v));
        elseif (mb_substr($v, -4) == ".php") {
-            if(substr(file_get_contents($dir.$v), 6, 6) == "#plain") continue;
-            $composer = json_decode(file_get_contents(DataProvider::getWorkingDir()."/composer.json"), true);
-            foreach($composer["autoload"]["files"] as $fi) {
-                if(realpath(DataProvider::getWorkingDir()."/".$fi) == realpath($dir.$v)) {
+            if (substr(file_get_contents($dir . $v), 6, 6) == "#plain") continue;
+            $composer = json_decode(file_get_contents(DataProvider::getWorkingDir() . "/composer.json"), true);
+            foreach ($composer["autoload"]["files"] as $fi) {
+                if (realpath(DataProvider::getWorkingDir() . "/" . $fi) == realpath($dir . $v)) {
                    continue 2;
                }
            }
+            if ($v == "global_function.php") continue;
            $class_name = $indoor_name . "\\" . mb_substr($v, 0, -4);
            $classes [] = $class_name;
        }
@@ -265,10 +267,14 @@ function zm_timer_after($ms, callable $callable) {
 }

 function zm_timer_tick($ms, callable $callable) {
-    go(function () use ($ms, $callable) {
-        Console::debug("Adding extra timer tick of " . $ms . " ms");
-        Swoole\Timer::tick($ms, $callable);
-    });
+    if (zm_cid() === -1) {
+        return go(function () use ($ms, $callable) {
+            Console::debug("Adding extra timer tick of " . $ms . " ms");
+            Swoole\Timer::tick($ms, $callable);
+        });
+    } else {
+        return Swoole\Timer::tick($ms, $callable);
+    }
 }

 function zm_data_hash($v) {
@@ -308,3 +314,7 @@ function getAllFdByConnectType(string $type = 'default'): array {
    }
    return $fds;
 }
+
+function zm_atomic($name) {
+    return \ZM\Store\ZMAtomic::get($name);
+}
--- a/test/usage_test.php
+++ b/test/usage_test.php
@@ -0,0 +1,10 @@
+<?php
+
+use ZM\Exception\ZMException;
+use ZM\Store\LightCache;
+
+LightCache::getMemoryUsage();
+try {
+    LightCache::getExpire('1');
+} catch (ZMException $e) {
+}
Author	SHA1	Message	Date
jerry	9ace85e604	update to 2.2.5 version again add transaction for SpinLock.php add getAllCQ() for CQ.php fix CQ bug update docs	2021-02-20 16:57:19 +08:00
jerry	f677b0e132	update to 2.2.5 version add saveToJson and loadFromJson function for DataProvider.php fix @OnSave annotation not working adjust swoole timer tick add hasKey() for WorkerCache.php	2021-02-15 15:15:26 +08:00
jerry	f137f044d0	Merge remote-tracking branch 'origin/master'	2021-02-09 17:09:26 +08:00
jerry	77c12db31a	reformat code	2021-02-09 17:09:09 +08:00
Whale	b670cb29fe	Update README.md	2021-02-09 11:12:29 +08:00
Whale	95d7bb071d	Update README.md	2021-02-09 10:54:59 +08:00
Whale	eadb4c1dee	Update README.md	2021-02-09 10:54:05 +08:00
Whale	6672a6c852	Update README.md	2021-02-09 10:53:52 +08:00
Whale	094feddda4	Update README.md	2021-02-09 10:53:15 +08:00
Whale	f86eddb298	Update README.md	2021-02-09 10:48:05 +08:00
Whale	a93b4917cd	Update README.md	2021-02-09 10:47:40 +08:00
jerry	0f9767aa16	update docs	2021-02-07 11:48:55 +08:00
jerry	0c9f246690	update to 2.2.4 version update docs fix broken ssh caused cpu overloading fix WorkerCache bug when no global config add global function zm_atomic	2021-02-07 11:46:42 +08:00
jerry	517d258d61	update to 2.2.3 version, I am tired fix access_token not working fix waitMessage() not working in v2.2.2	2021-01-30 00:06:42 +08:00
jerry	61e3818563	update to 2.2.2 version finally clean redundant code fix API reply in @OnTick for multi-process fix loop error reporting	2021-01-29 23:34:34 +08:00
jerry	776ec98a3e	fix waitMessage timeout bug	2021-01-29 22:32:29 +08:00
jerry	f3e844bb0a	update to 2.2.2 version fix QQBot error clean code	2021-01-29 22:27:10 +08:00
jerry	a55cd4ed05	update docs	2021-01-29 21:37:02 +08:00
jerry	8a985620f9	update to 2.2.1 version fix a compatibility bug	2021-01-29 21:36:14 +08:00
jerry	484ddf9dfa	update Hello.php update docs	2021-01-29 21:30:19 +08:00
jerry	b611b4aad6	add DaemonCommand for daemon players adjust http_header available	2021-01-29 20:47:00 +08:00
jerry	b9f973c718	add unset for WorkerCache.php	2021-01-20 18:43:22 +08:00
jerry	cd6c971547	update Singleton	2021-01-20 16:45:50 +08:00
jerry	c68083484a	update to 2.2.0 version add OnPipeMessageEvent.php add ProcessManager.php add WorkerCache component fix route bug correct Exception to ZMException	2021-01-20 16:11:04 +08:00