尽量服用,和优化采样区块,交易所在区块的资源参数 获取不需要每次获取有下单租赁订单都获取一遍,应该是全局异步获取是不是就可以,帮我设计合理方案。 和清理逻辑

This commit is contained in:
lu7213 committed 2026-10-31 19:10:27 -04:00
1 parent 13665668ac
commit 1538cd0819
24 files changed
+1805 -141

No files matched your search

+9 -1
View File
@@ -86,7 +86,9 @@ susdt是一套全部开源的快速开发平台,毫无保留给个人及企业
## 租赁历史资源证明
租赁模块已提供与云端同进程运行的历史资源证明采集,部署与4张增量表设计见 [内置历史证明服务](docs/rental/history-service.md),业务运行说明见 [租赁模块](docs/rental/implementation.md)。
租赁模块已提供与云端同进程运行的历史资源证明采集,复用4张证据表及1张待确认缓冲表。全局采样、确认归档与事件扫描独立运行,复用钱包一致性读与地址对基线;订单/任务提交后立即异步派单/推送。升级需重跑幂等脚本 `sql/rent_history_init.sql`,部署与配置见 [内置历史证明服务](docs/rental/history-service.md),业务运行说明见 [租赁模块](docs/rental/implementation.md)。
历史清理默认每日03:15 UTC运行,保留30天并额外保护未闭环订单及最近10000区块,先归档校验再分批删除,业务订单与资金记录不动。已有历史库部署前还需执行 `sql/rent_history_cleanup_upgrade.sql`,并配置持久归档目录 `RENT_HISTORY_ARCHIVE_DIRECTORY`;规则与配置见 [安全清理](docs/rental/history-service.md#7-历史表安全清理)。
## Authenticator 动态码登录
@@ -96,6 +98,12 @@ susdt是一套全部开源的快速开发平台,毫无保留给个人及企业
修改后重启服务端。正常在线、无积压且RPC及时返回时目标约10秒内接单,链上调用、快照过期和积压会额外耗时。
日志`orderAgeMs`表示下单到分配,`taskAgeMs`表示任务创建到推送;Agent另记录签发至接收及预检查耗时。
订单列表新增“未履约原因”及完整说明弹窗,管理员、商户和供应商均仅能查看自身有权限的订单。
委托链上确认但未满足履约条件时,服务端记录`租赁履约未通过`日志,并同事务写入`rent_event`的
`DELIVERY_REVIEW`事件,包含历史证明缺失、已核验数量不足、核验时租期已结束等原因;多个原因同时保留。
使用现有事件表,无需数据库升级。旧订单优先依据已归档交易证据回溯,缺失数据时明确显示无法确认;
不会用当前时间推断历史核验超时,也不会向页面返回完整交易证据或凭证。
保留密码和 Google 账号登录,新增六位动态码登录及个人中心绑定/解绑。部署前执行 `sql/totp_auth.sql` 并配置 `TOTP_ENCRYPTION_KEY`,详见 [部署与使用说明](docs/totp-login.md)。
## susdt前后端分离交流群
+79 -11
View File
@@ -2,7 +2,7 @@
本功能随现有 Java 8 云端服务启动,复用 MySQL 和只读 TRON RPC,不需要另起一个 Java 服务,也不需要供应商运行 TRON 节点。默认关闭;不持有钱包私钥,不签名、不广播、不执行自动出金。
业务16表保持不变,新增4张独立历史表,总计20张租赁相关表。安装脚本为 [rent_history_init.sql](../../sql/rent_history_init.sql),业务基础脚本仍为 [rent_init.sql](../../sql/rent_init.sql)。没有对现有数据库执行这些脚本。
业务16表保持不变,复用4张历史证据表,额外增加1张待确认缓冲表 `rent_history_sample`。新环境执行 [rent_history_init.sql](../../sql/rent_history_init.sql);已有历史库还需执行幂等升级脚本 [rent_history_cleanup_upgrade.sql](../../sql/rent_history_cleanup_upgrade.sql),给游标增加两个独立清理租约字段。业务基础脚本仍为 [rent_init.sql](../../sql/rent_init.sql)。本次没有对现有数据库执行这些脚本。
## 1. 实现范围与可信前提
@@ -15,7 +15,8 @@
| `/walletsolidity/getnowblock` | 获取确认头高度、区块哈希 |
| `/wallet/getnowblock` | FullNode最新头,夹读以绑定实时采样高度 |
| `/wallet/getaccountresource` | 该最新高度的能量/带宽全网额度和权重 |
| `/wallet/getdelegatedresourcev2` | 该最新高度指定地址对的 Stake 2.0 本金 |
| `/wallet/getdelegatedresourcev2` | 当前委托关系检查 |
| `/walletsolidity/getdelegatedresourcev2` | 首次地址对已确认的 Stake 2.0 本金基线,需支持lock=false/true |
| `/walletsolidity/getblockbynum` | 按高度读取确认区块及按序交易、执行回执 |
示例RPC地址仅表示接口来源,不能据此认为公共服务已通过生产验收。不支持某接口、返回参数不完整或限流时,采集会失败,不用空值伪造成功。
@@ -24,15 +25,16 @@
## 2. 业务流程
1. 采集器读取FullNode最新头 H1,读取全网资源参数及所需关系,再次读取最新头 H2。仅高度和哈希一致才绑定该高度。最多尝试3次。不立即写入历史证据;内存保留最多10000份、最长10分钟的未确认采样,每轮继续采集后续高度。确认头到达采样高度后,使用确认区块查询核对原采样哈希,再归档。分叉、超时或重启丢失的采样不补造。
1. 每个网络独立运行参数采样、参数确认、事件扫描三个后台通道。采样读取FullNode最新头 H1、全网资源参数、最新头 H2,高度与哈希都一致才按网络/高度持久化到 `rent_history_sample`,同高度去重,冲突不覆盖。确认通道核对确认区块哈希后提升到 `rent_history_block` 并删除缓冲;分叉采样只丢弃。重启后继续确认已持久化采样,漏采高度不补造。`RentalChain.snapshot` 刷新 `rent_wallet` 时也可提交本次成功夹读的同高度参数,避免重复查询;旧 `rent_wallet` 记录不能充当历史参数。
2. 首次采集从当前确认头开始;已有派单前基线时,从最早基线的下一高度开始。以后从数据库游标下一高度补采确认区块。
3. 每个区块按原交易顺序解析成功的 `DelegateResourceContract` 和 `UnDelegateResourceContract`,保存全网委托/回收事件。相关交易没有完整回执时整个区块不推进。
4. 写入区块事件、标记区块完整和推进游标在同一事务中完成;父哈希不连续、重复高度哈希不同、同高度参数冲突时拒绝覆盖。
5. 平台派单前对候选供应钱包/接收地址/资源类型采集关系基线,同样使用最新头夹读并等待对应区块确认。锁定与非锁定本金合计必须为0,等待确认时订单仍等待派单,后续调度重试,不先发送任务再补证据。原有当前关系检查继续保留。首次启动需要等待确认预热;不要因此关闭确认校验。
5. 派单优先复用地址对已有基线及完整连续事件,重放本金为0后追加检查点,减少后续重放量;游标近期未推进或区块不完整时退回确认节点。首次地址对使用确认头前后夹读 `/walletsolidity/getdelegatedresourcev2`,锁定与非锁定本金合计必须为0,不再等待最新头再确认一轮。不支持该接口、RPC返回错误或头变化时保持等待,不能用最新关系冒充确认基线。原有当前关系检查继续保留;全局参数采样超过默认15秒不新鲜时暂停新派单。
6. 本地 Agent 按原流程执行,云端原有核验继续检查真实交易、owner/receiver、网络、资源类型、非锁定、SUN、回执、确认深度及当前关系。
7. 内置服务查找目标交易之前最近的关系基线,验证从基线到交易区块的所有区块连续且事件完整,按区块高度和交易序号重放本金变化。目标交易必须真实存在于归档,不能用请求的本金代替事件。
8. 从目标区块读取当时保存的额度和权重,返回目标交易前后本金及资源参数。云端以原有精确整数公式换算资源,达标且租期未结束时才扣款、记供应商收入。
9. 完整历史证明进入 `rent_transaction.evidence` JSON,供审计查看;不会把额外证明字段当作交易表的新列写入。
10. 订单事务提交后进入有界异步派单队列,任务事务提交后立即定向推送对应节点。同一订单执行去重,同一连接的即时推送与定时扫描串行,继续复用原投递ID与签名任务。回滚不投递,队列满、重启或临时失败由3秒派单扫描和2秒推送扫描补偿。默认4个工作线程、队列容量200;不在下单HTTP线程执行链上调用。正常在线且RPC及时返回时以约10秒内接单为目标,不承诺在限流、链上故障或队列拥塞下仍满足。
```text
派单前确认基线 B
@@ -54,6 +56,8 @@
## 3. 四张表的具体设计
额外的 `rent_history_sample` 只保存网络、高度、哈希、四个全网参数和原始采样时间,主键为网络/高度。它是耐重启的待确认缓冲,不供履约证明直接读取。确认后写入下述原有证据表,`parameters_at` 保留原始采样时间,不能以较晚的归档时间伪装新鲜采样。
### rent_history_cursor:采集进度和网络租约
| 字段 | 类型 | 功能 |
@@ -63,6 +67,7 @@
| scanned_block_id | VARCHAR(64),可空 | 游标区块哈希,下一块必须引用它 |
| lease_owner | VARCHAR(64),可空 | 本轮采集实例随机令牌 |
| lease_until | DATETIME(3),可空 | 以数据库 UTC 时钟计算的60秒租约 |
| cleanup_owner / cleanup_until | VARCHAR(64) / DATETIME(3),可空 | 清理器独立60秒网络租约,与扫描租约互不覆盖 |
| last_success_at | DATETIME(3),可空 | 最近完整区块成功入库时间 |
| last_error | VARCHAR(255),可空 | 脱敏状态,不保存RPC原始异常或密钥 |
| updated_at | DATETIME(3) | 最近更新UTC时间 |
@@ -155,10 +160,14 @@ RENT_RPC_KEY=按所用RPC要求提供
| rental.history.networks | NILE | 逗号分隔,允许NILE、MAINNET;未启用网络不建立派单基线 |
| rental.history.poll-interval-ms | 1000 | 每网络轮询间隔,允许200至60000毫秒 |
| rental.history.batch-size | 30 | 每轮最多补采区块数,允许1至200 |
| rental.history.parameter-grace-seconds | 120 | 已归档区块参数暂未提升时的重试窗口,0至3600秒;超时仍缺失才走人工核对 |
| rental.history.max-sample-age-seconds | 15 | 派单要求最近全局参数采样新鲜,1至300秒 |
| rental.delivery.workers | 4 | 即时派单/推送线程数,1至32 |
| rental.delivery.queue-capacity | 200 | 有界队列容量,1至10000;满时依靠持久化扫描恢复 |
| rental.history.probe-address | TRON零地址 | 查询全网参数的公开地址 |
| rental.history.nile/mainnet | 空 | 保留外部历史服务兼容;内置开启时不使用 |
每个启用网络有独立守护线程,正常关闭时停止线程。网络间互不阻塞;多实例利用数据库租约避免重复扫描。既有Agent WebSocket单入口限制不因历史采集多实例而改变。
每个启用网络有三个独立守护任务,正常关闭时停止线程。网络间互不阻塞;多实例利用数据库租约避免重复扫描,采样与参数归档通过唯一键、行锁及不可变事实校验幂等合并。既有Agent WebSocket单入口限制不因历史采集多实例而改变。
## 5. 查询接口
@@ -166,7 +175,7 @@ RENT_RPC_KEY=按所用RPC要求提供
### GET /rental/history/status
标准若依AjaxResult,data为每网络采集状态:`network`、`scanned_height`、`scanned_block_id`、`last_success_at`、`last_error`、`last_parameter_height`、`parameter_gap_count`。
标准若依AjaxResult,data为每网络采集状态:`network`、`scanned_height`、`scanned_block_id`、`last_success_at`、`last_error`、`last_parameter_height`、`parameter_gap_count`、`pending_sample_count`、`latest_sample_height`。后两项分别为待确认缓冲数量及最新待确认高度,需结合已归档参数高度判断。
`parameter_gap_count` 为已有完整事件区块中参数为空的区块数,不代表遗漏区块没有交易,也不代表所有订单都会受影响。应监控游标停滞、错误和参数缺口。
@@ -194,7 +203,7 @@ RENT_RPC_KEY=按所用RPC要求提供
| 场景 | 行为 |
| --- | --- |
| 扫描游标尚未到交易高度 | 核验抛出待重试错误,原有后台核验下轮继续 |
| 交易高度没有实时历史参数 | 不出具证明;已确认委托进入原有MANUAL_REVIEW,保留冻结资金 |
| 交易高度暂时没有历史参数 | 在参数等待窗口内保持重试;超时仍缺失则不出具证明,已确认委托进入原有MANUAL_REVIEW,保留冻结资金 |
| 无交易之前的基线 | 不出具证明;不能用交易之后的状态倒造基线 |
| 缺区块、父哈希断裂、目标区块哈希与RPC不符 | 拒绝核验,保留占用和资金,等待运营检查 |
| 同区块同关系在目标交易后继续变化 | 若最终本金不等于目标交易后本金则拒绝证明 |
@@ -205,14 +214,73 @@ RENT_RPC_KEY=按所用RPC要求提供
采集间隔小于出块间隔不保证每个高度都能捕获:节点确认头跳跃、网络慢、RPC限流和采集停机均可能造成参数缺口。生产需要低延迟且有容量保障的RPC,并根据状态接口告警;**本实现不会声称公共RPC轮询等同完整历史归档节点**。需要任意历史补录能力时,应另外建设可回放状态的归档节点/节点侧采集,而不是手工向历史表填当前参数。
历史数据没有自动删除策略。单网络每天约有28800个三秒区块,事件量取决于全网委托交易;应评估磁盘、备份与索引容量,保留覆盖所有在途订单和审计周期的数据,不得随意删除基线和重放区块。状态接口中的缺口统计可能随数据规模增加成本,应控制调用频率。
历史表已提供下述归档后清理策略。单网络每天约有28800个三秒区块,事件量取决于全网委托交易;仍应评估磁盘、备份与索引容量。状态接口中的缺口统计可能随数据规模增加成本,应控制调用频率。
## 7. 代码与测试
## 7. 历史表安全清理
仅在 `rental.enabled=true` 且内置历史服务开启时加载清理器。默认每天 **03:15 UTC** 执行,在线保留 **30天**,每个表每批最多500条,每网络每轮最多200批。订单、任务、链上交易、资金流水、结算、退款、回调和业务事件均不删除、不改状态。
### 升级与配置
旧环境先执行 `sql/rent_history_cleanup_upgrade.sql`,再更新后端JAR及完整lib目录并重启。脚本通过 `information_schema` 判断列和索引是否存在,可重复执行,只增加 `rent_history_cursor.cleanup_owner`、`cleanup_until` 及基线表的 `(network,block_height)` 清理索引。新环境初始化脚本已经包含这些字段和索引。这里未连接实际MySQL执行迁移。
```yaml
rental:
history:
cleanup:
enabled: true
cron: '0 15 3 * * ?' # 固定使用UTC
retention-days: 30
batch-size: 500
max-batches: 200
archive-directory: ./data/rental-history-archive
```
对应环境变量:`RENT_HISTORY_CLEANUP_ENABLED`、`RENT_HISTORY_CLEANUP_CRON`、`RENT_HISTORY_RETENTION_DAYS`、`RENT_HISTORY_CLEANUP_BATCH_SIZE`、`RENT_HISTORY_CLEANUP_MAX_BATCHES`、`RENT_HISTORY_ARCHIVE_DIRECTORY`。保留期允许1至3650天,单表批量1至1000条,批次数1至10000。超过单轮批次数的数据留到下次;积压较大时可调整批次或cron。
归档目录相对于服务进程工作目录解析,必须放在可写、支持同目录原子移动的持久存储上。多实例应使用统一备份的共享目录,或分别持久化并收集所有实例的归档目录;不要使用容器临时层。关闭cleanup开关只停止定时历史清理,原有确认成功/确认分叉的采样处理继续运行。
### 保留边界
每批获取数据库游标行锁并重新计算网络保护水位。默认从 `scanned_height - 10000` 开始保护最近重放窗口,再根据以下任务对应的最早存续基线向前扩大保护范围:
- 订单尚未终结、资金仍冻结、地址对占位未释放、回收未完成或租期未结束。
- 任务结果未知、尚未终结、链上执行占位未释放,或交易尚未明确确认/失败。
- 保留期内更新过的订单、任务或交易,即使已业务闭环,也保留其重放证据供近期核对。
使用任务冻结intent中的owner/receiver定位基线,不依赖后来可能换绑的钱包地址;相同地址对去重,每100个地址对批量查询。受保护任务缺失、intent损坏、基线不存在、网络/资源不匹配或保护任务超过单批100000条时,停止该网络删除并记录日志,不忽略异常继续删。一个长期悬挂订单可能保留整个网络的一段旧数据,这是有意采用的保守策略。
基线及其后的连续区块/事件均保留,不将 `UNKNOWN`、`MANUAL_REVIEW` 当作过期记录。未分配供应钱包的等待订单尚无旧证据依赖;已分配钱包却找不到对应任务的异常在途订单会阻止清理。
### 五张表的行为
| 表 | 清理规则 |
| --- | --- |
| rent_history_event | 仅删除保护水位之前、区块完整且链上时间/区块入库时间/事件入库时间均超过保留期的事件;先归档完整原始行 |
| rent_history_block | 仅删除水位之前且链上时间和入库时间都过期的完整区块;该块必须已无事件、无待确认采样。大区块的事件分批删完后,下批才删区块 |
| rent_history_anchor | 仅删除水位之前且入库已过期的检查点。已保护订单的基线不会删;已超出10000区块可复用窗口且无人依赖的旧地址对基线可退休,下次派单重新读取确认节点建立基线 |
| rent_history_sample | 清理器只处理与已确认归档的哈希及四个参数完全一致的冗余缓冲。未确认或冲突采样不按年龄删,仍由确认通道确认/判定分叉 |
| rent_history_cursor | 永久保留,扫描高度及哈希不重置;清理器仅维护自身租约 |
没有完整事件的区块、有冲突待确认采样的区块、刚补采的老区块都不会被误删。保留期只是最小保留条件,并非保证恰好只留30天。
### 归档、事务与并发
每批归档含格式版本、网络、截止时间、保护水位、游标快照及实际待删的四类完整记录。JSON先写 `.pending` 文件并强制落盘,再原子发布为带SHA-256摘要的唯一 `.json` 文件,重新校验摘要后才执行数据库删除;每批删除同事务提交。归档写入失败、校验失败、租约失效或SQL错误均回滚本批数据库变更;此前已提交的批次不回滚。
写盘后数据库回滚可能留下冗余归档,崩溃也可能留下 `.pending`;它们不是再次执行交易或自动恢复的指令。归档文件不会自动删除,需单独备份并按审计要求管理其保留期。恢复旧证据时应在隔离环境校验文件名中的SHA-256、按表主键去重后审计恢复,不能向历史表补入当前参数。在线证明接口不自动读取归档文件。
清理器有独立数据库租约,多实例仅一个清理器执行同一网络;扫描仍使用原租约。每批清理、证明数据库快照读取、基线写入及参数写入共用网络游标行锁,因此不会读到半删的重放链。所有链上RPC仍在该锁事务外执行;文件归档在受限批次内完成。日志记录网络、水位、各表数量、归档文件名和失败的安全定位摘要,不输出密钥或交易签名。
## 8. 代码与测试
| 文件 | 职责 |
| --- | --- |
| `ruoyi-system/.../rental/RentalHistoryService.java` | 最新状态夹读、暂存等待确认、哈希核对、不可变入库、网络租约、区块解析、关系重放、证明 |
| `ruoyi-system/.../rental/RentalHistoryCollector.java` | 独立后台线程、分网络轮询、关闭 |
| `ruoyi-system/.../rental/RentalHistoryCleaner.java` | 定时清理、独立租约、保护水位、分批删除 |
| `ruoyi-system/.../rental/RentalHistoryGuard.java` | 多实例共用的短事务网络保护锁 |
| `ruoyi-system/.../rental/RentalHistoryArchive.java` | 删除前写盘、原子发布和摘要校验 |
| `ruoyi-system/.../rental/RentalHistoryController.java` | 受保护的状态/证明查询 |
| `RentalChain.java` | 内置/外部证明选择,原链上核验保留 |
| `RentalTasks.java` | 派单前采集基线,完整证明写入evidence JSON |
@@ -221,9 +289,9 @@ RENT_RPC_KEY=按所用RPC要求提供
运行:
```shell
mvn -o -pl ruoyi-system -am test -Dtest=RentalHistoryTest,RentalBusinessTest,RentalRolePermissionTest -Dsurefire.failIfNoSpecifiedTests=false
mvn -o -pl ruoyi-system -am test -Dtest=Rental*Test -Dsurefire.failIfNoSpecifiedTests=false
```
Windows PowerShell需要给含逗号的 `-Dtest=...` 参数加引号。H2不支持MySQL的UTC_TIMESTAMP,测试仅为该时钟函数注册等价UTC实现,不改变生产SQL。
本次JDK8验证:历史服务29项全部通过,云端全回归119项无失败(4项原有外网/手动测试跳过),SQL/文档12项通过,云端package成功;已核对打包lib中的ruoyi-system与本次构建产物一致且包含历史服务类。隔离测试不等同MySQL、固定RPC以及真实NILE端到端验收;本次未执行数据库迁移或任何链上广播。
本次JDK8租赁回归共162项全部通过,包含43项历史服务、23项清理、58项业务状态机测试,以及定价、权限、充值、提现等租赁测试。清理覆盖未知/人工核对/回收/冻结资金保护、近期闭环审计、分批大区块、重复运行、独立租约、归档失败、SQL失败回滚、租约过期、真实归档摘要及并发证明读取;完整业务DDL测试验证账户及流水保持不变。公共NILE确认关系接口先前只读探测返回HTTP200,不等同MySQL、固定RPC以及真实订单端到端验收;本次未执行数据库迁移或任何链上广播。
+3 -1
View File
@@ -141,7 +141,9 @@ TASK_PUSH中保留稳定delivery_message_id、原api_key/intent/timestamp/nonce/
Agent事件先落本地可靠队列,云端同事务以 `NODE:nodeId:eventId` 去重后RESULT_ACK。ACK只说明持久接收,ACCEPTED只说明本地接受,BUILT/BROADCASTED/RESULT只说明执行线索。云端另查交易合约、owner/receiver、网络、资源类型、非锁定、SUN、回执、确认深度和关系,不能凭节点消息扣款。
普通TRON RPC没有任意确认区块的资源历史查询。现已增加与云端同进程部署的内置历史采集/证明服务:执行 `sql/rent_history_init.sql` 增加4张历史表,设置 `RENT_HISTORY_EMBEDDED_ENABLED=true` 和 `RENT_HISTORY_NETWORKS=NILE`。派单前采集确认关系基线,持续归档确认区块和资源参数,交付核验直接调用Java服务;不需要填写 `RENT_NILE_HISTORY` / `RENT_MAINNET_HISTORY`。表设计、接口、配置、采集缺口与部署详见 [内置历史证明服务](history-service.md)。
普通TRON RPC没有任意确认区块的资源历史查询。内置采集/证明与云端同进程部署:执行 `sql/rent_history_init.sql` 创建4张历史证据表及1张待确认缓冲表(升级可重复执行),设置 `RENT_HISTORY_EMBEDDED_ENABLED=true` 和 `RENT_HISTORY_NETWORKS=NILE`。全局参数采样、确认归档与事件扫描异步独立,复用钱包本次一致性夹读及地址对连续事件基线;订单/任务提交后立即异步派单/推送,持久扫描兜底。交付核验直接调用Java服务,不需要填写 `RENT_NILE_HISTORY` / `RENT_MAINNET_HISTORY`。表设计、接口、配置、采集缺口与部署详见 [内置历史证明服务](history-service.md)。
历史清理默认每天03:15 UTC执行,保留30天并保护未闭环订单的连续证据,先归档后分批删除。已有历史库还需执行 `sql/rent_history_cleanup_upgrade.sql`,为游标增加独立清理租约及基线表清理索引;配置持久归档目录后部署,订单与资金表不清理。
外部服务模式继续兼容:内置关闭时,`RENT_NILE_HISTORY` / `RENT_MAINNET_HISTORY` 可以指向运营部署、独立于供应商的可信历史证明服务。后端向 `/rental/resource-proof` POST `network,tx_id,block_height,owner,receiver,resource_type`,服务必须基于该实际区块状态返回:
+1 -1
View File
@@ -34,7 +34,7 @@
## 2. 16张表及职责
以下为业务核心16表。内置历史证明另增加4张只读采集/审计表,独立增量安装,详细字段及协作见 [内置历史服务表设计](history-service.md) 和 [历史DDL](../../sql/rent_history_init.sql)。启用后租赁相关表合计20张,不修改原16表结构。
以下为业务核心16表。内置历史证明复用4张采集/审计证据表,另有1张 `rent_history_sample` 保存待确认参数,独立增量安装,详细字段及协作见 [内置历史服务表设计](history-service.md) 和 [历史DDL](../../sql/rent_history_init.sql)。按该业务核心口径合计21张,不修改原16表结构。待确认缓冲不用于直接结算,确认并核对哈希后提升至证据表。
| 表 | 作用 |
| --- | --- |
@@ -8,6 +8,9 @@ rental:
# 正常在线、无排队且RPC及时返回时,调度+推送等待约0~5秒,目标10秒左右接单。
# 均为上轮执行完成后的等待时间;链上查询耗时不包含在间隔中。修改后重启服务端。
delivery:
# 提交后立即异步派单/推送;以下周期只做持久化补偿扫描。
workers: ${RENT_DELIVERY_WORKERS:4}
queue-capacity: ${RENT_DELIVERY_QUEUE_CAPACITY:200}
dispatch-interval-ms: ${RENT_DELIVERY_DISPATCH_INTERVAL_MS:3000}
push-interval-ms: ${RENT_DELIVERY_PUSH_INTERVAL_MS:2000}
payment:
@@ -47,6 +50,20 @@ rental:
networks: ${RENT_HISTORY_NETWORKS:NILE}
poll-interval-ms: ${RENT_HISTORY_POLL_MS:1000}
batch-size: ${RENT_HISTORY_BATCH_SIZE:30}
# 短暂参数归档落后先重试;超过等待期仍缺证据才进入原人工核对流程。
parameter-grace-seconds: ${RENT_HISTORY_PARAMETER_GRACE_SECONDS:120}
# 参数采样停滞则暂停新资源派单,保留订单等待和原有资金保护。
max-sample-age-seconds: ${RENT_HISTORY_MAX_SAMPLE_AGE_SECONDS:15}
cleanup:
# 已有历史库先执行sql/rent_history_cleanup_upgrade.sql;仅归档清理历史表。
enabled: ${RENT_HISTORY_CLEANUP_ENABLED:true}
# 使用UTC,每天03:15执行;保留期外仍会保护未闭环订单和最近10000个区块。
cron: ${RENT_HISTORY_CLEANUP_CRON:0 15 3 * * ?}
retention-days: ${RENT_HISTORY_RETENTION_DAYS:30}
batch-size: ${RENT_HISTORY_CLEANUP_BATCH_SIZE:500}
max-batches: ${RENT_HISTORY_CLEANUP_MAX_BATCHES:200}
# 必须是可写、支持原子移动的持久目录;归档文件不会自动删除。
archive-directory: ${RENT_HISTORY_ARCHIVE_DIRECTORY:./data/rental-history-archive}
probe-address: ${RENT_HISTORY_PROBE_ADDRESS:T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb}
# 外部历史服务兼容配置;开启embedded-enabled后走Java内部调用,不需要填写这两项。
nile: ${RENT_NILE_HISTORY:}
@@ -118,29 +118,21 @@ public class RentalChain {
}
public Map<String, Object> snapshot(String network, String address) {
long before = block(call(network, "/wallet/getnowblock", map()));
JsonNode beforeBlock = call(network, "/wallet/getnowblock", map());
long before = block(beforeBlock);
JsonNode resources =
call(
network,
"/wallet/getaccountresource",
map("address", address, "visible", true));
long energy =
call(
network,
"/wallet/getcandelegatedmaxsize",
map("owner_address", address, "type", 1, "visible", true))
.path("max_size")
.asLong(-1);
long bandwidth =
call(
network,
"/wallet/getcandelegatedmaxsize",
map("owner_address", address, "type", 0, "visible", true))
.path("max_size")
.asLong(-1);
long after = block(call(network, "/wallet/getnowblock", map()));
long energy = delegatable(network, address, 1);
long bandwidth = delegatable(network, address, 0);
JsonNode afterBlock = call(network, "/wallet/getnowblock", map());
long after = block(afterBlock);
require(
before >= 0 && before == after && energy >= 0 && bandwidth >= 0,
before >= 0 && before == after && energy >= 0 && bandwidth >= 0
&& beforeBlock.path("blockID").asText().matches("[0-9a-fA-F]{64}")
&& beforeBlock.path("blockID").asText().equalsIgnoreCase(afterBlock.path("blockID").asText()),
"快照跨区块或本金查询不完整,请重试");
Map<String, Object> result =
map(
@@ -178,9 +170,30 @@ public class RentalChain {
&& number(result, "total_bandwidth_limit") > 0
&& number(result, "total_bandwidth_weight") > 0,
"全网参数不完整");
if (embeddedHistory && historyService != null) {
// 复用本次夹读,不再为每个订单额外请求全网资源参数;不读取旧rent_wallet快照。
try {
historyService.getObject().offerParameters(network, beforeBlock, afterBlock, resources);
} catch (RuntimeException ex) {
log.warn("钱包全局参数采样未入库 network={},独立采样器将继续重试", network);
}
}
return result;
}
/** protobuf省略零字段的空对象表示0;显式错误和非整数绝不能当作0。 */
private long delegatable(String network, String address, int type) {
JsonNode row = call(network, "/wallet/getcandelegatedmaxsize",
map("owner_address", address, "type", type, "visible", true));
require(row.isObject() && (row.size() == 0 || row.has("max_size"))
&& !row.has("Error") && !row.has("error") && !row.has("code") && !row.has("result"),
"可代理本金查询失败");
JsonNode value = row.path("max_size");
require(value.isMissingNode() || (value.isIntegralNumber() && value.canConvertToLong()
&& value.longValue() >= 0), "可代理本金响应无效");
return value.isMissingNode() ? 0 : value.longValue();
}
public long relation(String network, String owner, String receiver, String resource) {
JsonNode rows =
call(
@@ -278,6 +291,8 @@ public class RentalChain {
Map<String, Object> archived = historyService.getObject().proof(
network, txId, height, owner, receiver, text(task, "resource_type"));
if (archived == null) {
result.put("delivery_evidence_gap", historyService.getObject().missingProofCode(
network, height, owner, receiver, text(task, "resource_type")));
// 参数漏采或缺少派单前基线:保留原有MANUAL_REVIEW路径,绝不降级为当前快照。
return result;
}
@@ -0,0 +1,37 @@
package com.ruoyi.system.rental;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
/** 履约核验说明只使用可信布尔值、精确数量和UTC时间,不接收RPC异常原文。 */
final class RentalDeliveryDiagnostics {
private RentalDeliveryDiagnostics() { }
static String evidenceGap(String code) {
switch (code) {
case "BLOCK_NOT_ARCHIVED": return "目标交易区块尚未归档";
case "PARAMETERS_MISSING": return "目标交易区块缺少当时的全网资源参数,不能用当前参数替代";
case "BASELINE_MISSING": return "缺少委托交易之前已确认的地址对关系基线";
case "HISTORY_INCOMPLETE": return "历史区块或关系证据不完整";
default: return "";
}
}
static String explain(boolean proven, Long verified, long target, Instant expires, Instant checked) {
List<String> reasons = new ArrayList<>();
if (!proven) {
reasons.add("缺少完整历史履约证明,无法确认委托区块的实际资源数量");
} else if (verified == null) {
reasons.add("履约证据未包含已核验资源数量");
} else if (verified < target) {
reasons.add("实际核验资源数量不足:已核验=" + verified + ",订单目标=" + target);
}
if (expires == null || checked == null) {
reasons.add("缺少租期或核验时间,无法确认是否在有效租期内完成核验");
} else if (!expires.isAfter(checked)) {
reasons.add("核验完成时租期已结束:租期截止=" + expires + ",核验时间=" + checked);
}
return String.join(";", reasons);
}
}
@@ -0,0 +1,87 @@
package com.ruoyi.system.rental;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/** 有界异步派单/推送;链上查询不占用下单HTTP线程,队列拥塞由持久化扫描兜底。 */
@Component
@lombok.extern.slf4j.Slf4j
@ConditionalOnProperty(name = "rental.enabled", havingValue = "true")
public class RentalDeliveryDispatcher {
private final ObjectProvider<RentalTasks> tasks;
private final ObjectProvider<RentalSocket> socket;
private final Set<String> running = ConcurrentHashMap.newKeySet();
private ThreadPoolExecutor executor;
@Value("${rental.delivery.workers:4}")
private int workers = 4;
@Value("${rental.delivery.queue-capacity:200}")
private int capacity = 200;
public RentalDeliveryDispatcher(ObjectProvider<RentalTasks> tasks, ObjectProvider<RentalSocket> socket) {
this.tasks = tasks;
this.socket = socket;
}
@PostConstruct
public void start() {
RentalValues.require(workers >= 1 && workers <= 32 && capacity >= 1 && capacity <= 10000,
"即时调度线程/队列配置越界");
AtomicInteger sequence = new AtomicInteger();
executor = new ThreadPoolExecutor(workers, workers, 0, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(capacity), action -> {
Thread thread = new Thread(action, "rental-delivery-" + sequence.incrementAndGet());
thread.setDaemon(true);
return thread;
}, new ThreadPoolExecutor.AbortPolicy());
}
@EventListener
public void receive(RentalDeliveryEvents event) {
enqueue(event.order, event.id);
}
public void dispatch(long orderId) {
enqueue(true, orderId);
}
private void enqueue(boolean order, long id) {
String key = (order ? "O" : "N") + id;
if (!running.add(key)) {
return;
}
try {
executor.execute(() -> {
try {
if (order) {
tasks.getObject().dispatch(id);
} else {
socket.getObject().push(id);
}
} catch (Exception ex) {
log.warn("即时租赁调度待扫描重试 order={} id={} diagnostic={}",
order, id, RentalDiagnostics.describe(ex));
} finally {
running.remove(key);
}
});
} catch (RejectedExecutionException ex) {
running.remove(key);
log.warn("即时租赁调度队列已满,持久化扫描将恢复 order={} id={}", order, id);
}
}
@PreDestroy
public void close() {
if (executor != null) {
executor.shutdownNow();
}
}
}
@@ -0,0 +1,34 @@
package com.ruoyi.system.rental;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/** 提交成功才触发网络工作;回滚不发送,漏送由持久化扫描恢复。 */
final class RentalDeliveryEvents {
final boolean order;
final long id;
RentalDeliveryEvents(boolean order, long id) {
this.order = order;
this.id = id;
}
static void afterCommit(ApplicationEventPublisher publisher, boolean order, long id) {
if (publisher == null) {
return;
}
Runnable publish = () -> publisher.publishEvent(new RentalDeliveryEvents(order, id));
if (TransactionSynchronizationManager.isSynchronizationActive()
&& TransactionSynchronizationManager.isActualTransactionActive()) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
publish.run();
}
});
} else {
publish.run();
}
}
}
@@ -0,0 +1,61 @@
package com.ruoyi.system.rental;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.security.MessageDigest;
import java.util.Map;
import java.util.UUID;
/** 删除前将完整批次写入不可变JSON归档。写盘、原子发布和校验任一步失败都阻止数据库删除。 */
@Component
public class RentalHistoryArchive {
private final ObjectMapper json;
public RentalHistoryArchive(ObjectMapper json) {
this.json = json;
}
public String save(Path directory, Map<String, Object> batch) {
try {
Files.createDirectories(directory);
byte[] data = json.writeValueAsBytes(batch);
String digest = hex(MessageDigest.getInstance("SHA-256").digest(data));
String name = batch.get("network") + "-" + UUID.randomUUID() + "-" + digest + ".json";
Path pending = directory.resolve(name + ".pending");
Path published = directory.resolve(name);
try (FileChannel channel = FileChannel.open(pending, StandardOpenOption.CREATE_NEW,
StandardOpenOption.WRITE)) {
ByteBuffer buffer = ByteBuffer.wrap(data);
while (buffer.hasRemaining()) {
channel.write(buffer);
}
channel.force(true);
}
// 不退化成非原子覆盖;归档目录必须使用支持同目录原子移动的持久文件系统。
Files.move(pending, published, StandardCopyOption.ATOMIC_MOVE);
String actual = hex(MessageDigest.getInstance("SHA-256").digest(Files.readAllBytes(published)));
if (!digest.equals(actual)) {
throw new IOException("history archive checksum mismatch");
}
return name;
} catch (Exception ex) {
// 不暴露配置路径或归档原文。数据库事务回滚后保留已生成文件,允许重试产生冗余归档。
throw new IllegalStateException("历史归档写入或校验失败,本批次不删除", ex);
}
}
private static String hex(byte[] bytes) {
StringBuilder result = new StringBuilder(bytes.length * 2);
for (byte value : bytes) {
result.append(String.format("%02x", value & 255));
}
return result.toString();
}
}
@@ -0,0 +1,278 @@
package com.ruoyi.system.rental;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.PostConstruct;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.LinkedHashSet;
import java.util.LinkedHashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static com.ruoyi.system.rental.RentalValues.*;
/**
* 只清理历史表,不修改订单、任务、交易或资金记录。
* 每网络租约防重入,每批事务锁住网络游标后重新计算保护水位;证明读取、基线写入、参数归档共用该行锁。
* 清理采用保守的网络低水位:一个久悬订单可能保护整个网络的一段旧数据,宁可多留,不能截断证据。
*/
@Component
@lombok.extern.slf4j.Slf4j
@ConditionalOnProperty(name = {"rental.enabled", "rental.history.embedded-enabled"}, havingValue = "true")
public class RentalHistoryCleaner {
private final RentalStore store;
private final ObjectMapper json;
private final RentalHistoryArchive archive;
private final TransactionTemplate transaction;
@Value("${rental.history.cleanup.enabled:true}")
private boolean enabled = true;
@Value("${rental.history.networks:NILE}")
private String networks = "NILE";
@Value("${rental.history.cleanup.retention-days:30}")
private int retentionDays = 30;
@Value("${rental.history.cleanup.batch-size:500}")
private int batchSize = 500;
@Value("${rental.history.cleanup.max-batches:200}")
private int maxBatches = 200;
@Value("${rental.history.cleanup.archive-directory:./data/rental-history-archive}")
private String archiveDirectory = "./data/rental-history-archive";
/** 限制单批保护关系计算的内存和锁持有时间,超量时停止删除并告警,不能忽略剩余任务。 */
private static final int MAX_PROTECTED_TASKS = 100000;
public RentalHistoryCleaner(RentalStore store, ObjectMapper json, RentalHistoryArchive archive,
PlatformTransactionManager manager) {
this.store = store;
this.json = json;
this.archive = archive;
transaction = new TransactionTemplate(manager);
transaction.setTimeout(30);
}
@PostConstruct
public void validate() {
require(retentionDays >= 1 && retentionDays <= 3650, "历史保留天数必须为1到3650");
require(batchSize >= 1 && batchSize <= 1000, "历史清理批量必须为1到1000");
require(maxBatches >= 1 && maxBatches <= 10000, "历史清理批次数必须为1到10000");
require(archiveDirectory != null && !archiveDirectory.trim().isEmpty(), "历史归档目录不能为空");
}
/** UTC低峰定时运行;每批有上限,关闭开关不会影响原本的采样确认和分叉丢弃。 */
@Scheduled(cron = "${rental.history.cleanup.cron:0 15 3 * * ?}", zone = "UTC")
public void scheduled() {
if (!enabled) {
return;
}
Set<String> selected = new LinkedHashSet<>();
for (String value : networks.split(",")) {
selected.add(network(value.trim()));
}
for (String network : selected) {
try {
clean(network);
} catch (Exception ex) {
log.warn("历史清理失败,本批事务已回滚 network={} diagnostic={}",
network, RentalDiagnostics.describe(ex));
}
}
}
public int clean(String network) {
network(network);
validate();
if (!enabled) {
return 0;
}
String lease = id("HC");
Boolean acquired = transaction.execute(status -> {
Map<String, Object> cursor = RentalHistoryGuard.lock(store, network);
return cursor.get("scanned_height") != null && store.execute("UPDATE rent_history_cursor"
+ " SET cleanup_owner=?,cleanup_until=TIMESTAMPADD(SECOND,60,UTC_TIMESTAMP(3))"
+ " WHERE network=? AND (cleanup_until IS NULL OR cleanup_until<UTC_TIMESTAMP(3))",
lease, network) == 1;
});
if (!Boolean.TRUE.equals(acquired)) {
return 0;
}
int total = 0;
LocalDateTime cutoff = now().minusDays(retentionDays);
try {
for (int i = 0; i < maxBatches && !Thread.currentThread().isInterrupted(); i++) {
int removed = transaction.execute(status -> cleanBatch(network, lease, cutoff));
total += removed;
if (removed == 0) {
log.info("历史清理结束 network={} removed={} retentionDays={}", network, total, retentionDays);
return total;
}
}
log.warn("历史清理达到批次上限或被中断,剩余数据留待下次 network={} removed={}", network, total);
return total;
} finally {
store.execute("UPDATE rent_history_cursor SET cleanup_owner=NULL,cleanup_until=NULL"
+ " WHERE network=? AND cleanup_owner=?", network, lease);
}
}
private int cleanBatch(String network, String lease, LocalDateTime cutoff) {
Map<String, Object> cursor = RentalHistoryGuard.lock(store, network);
require(lease.equals(text(cursor, "cleanup_owner")) && validLease(network, lease), "历史清理租约失效");
store.execute("UPDATE rent_history_cursor SET cleanup_until=TIMESTAMPADD(SECOND,60,UTC_TIMESTAMP(3))"
+ " WHERE network=? AND cleanup_owner=?", network, lease);
long floor = protectedFloor(network, number(cursor, "scanned_height"), cutoff);
if (floor <= 0) {
return 0;
}
long cutoffMillis = cutoff.toInstant(java.time.ZoneOffset.UTC).toEpochMilli();
// 同时检查链上时间和入库时间,刚补采的老区块仍有完整保留期。
List<Map<String, Object>> events = store.rows("SELECT e.* FROM rent_history_event e"
+ " JOIN rent_history_block b ON b.network=e.network AND b.block_height=e.block_height"
+ " WHERE e.network=? AND e.block_height<? AND b.block_time<? AND b.created_at<?"
+ " AND e.created_at<? AND b.events_complete=1 ORDER BY e.block_height,e.tx_index LIMIT " + batchSize,
network, floor, cutoffMillis, cutoff, cutoff);
// 有事件的区块在后续批次再删除,单个高交易量区块也不会造成无界归档/删除。
List<Map<String, Object>> blocks = store.rows("SELECT b.* FROM rent_history_block b"
+ " WHERE b.network=? AND b.block_height<? AND b.block_time<? AND b.created_at<?"
+ " AND b.events_complete=1 AND NOT EXISTS (SELECT 1 FROM rent_history_event e"
+ " WHERE e.network=b.network AND e.block_height=b.block_height)"
+ " AND NOT EXISTS (SELECT 1 FROM rent_history_sample s WHERE s.network=b.network"
+ " AND s.block_height=b.block_height) ORDER BY b.block_height LIMIT " + batchSize,
network, floor, cutoffMillis, cutoff);
List<Map<String, Object>> anchors = store.rows("SELECT * FROM rent_history_anchor"
+ " WHERE network=? AND block_height<? AND created_at<? ORDER BY block_height LIMIT " + batchSize,
network, floor, cutoff);
// 缓冲仅删除已存在完全相同确认参数的冗余记录,未确认、冲突或错误采样交给确认通道处理。
List<Map<String, Object>> samples = store.rows("SELECT s.* FROM rent_history_sample s"
+ " JOIN rent_history_block b ON b.network=s.network AND b.block_height=s.block_height"
+ " WHERE s.network=? AND b.parameters_at IS NOT NULL AND b.block_id=s.block_id"
+ " AND b.energy_limit=s.energy_limit AND b.energy_weight=s.energy_weight"
+ " AND b.bandwidth_limit=s.bandwidth_limit AND b.bandwidth_weight=s.bandwidth_weight"
+ " ORDER BY s.block_height LIMIT " + batchSize, network);
int count = events.size() + blocks.size() + anchors.size() + samples.size();
if (count == 0) {
return 0;
}
String file = archive.save(Paths.get(archiveDirectory).toAbsolutePath().normalize(),
map("format", "RENT_HISTORY_ARCHIVE_V1", "network", network, "cutoff", cutoff.toString(),
"protected_from_height", floor, "cursor", cursor,
"events", events, "blocks", blocks, "anchors", anchors, "samples", samples));
require(validLease(network, lease), "归档期间清理租约失效,本批次不删除");
for (Map<String, Object> row : events) {
store.execute("DELETE FROM rent_history_event WHERE network=? AND tx_id=?", network, row.get("tx_id"));
}
for (Map<String, Object> row : blocks) {
store.execute("DELETE FROM rent_history_block WHERE network=? AND block_height=?", network, row.get("block_height"));
}
for (Map<String, Object> row : anchors) {
store.execute("DELETE FROM rent_history_anchor WHERE network=? AND owner_address=?"
+ " AND receiver_address=? AND resource_type=? AND block_height=?", network,
row.get("owner_address"), row.get("receiver_address"), row.get("resource_type"), row.get("block_height"));
}
for (Map<String, Object> row : samples) {
store.execute("DELETE FROM rent_history_sample WHERE network=? AND block_height=? AND block_id=?",
network, row.get("block_height"), row.get("block_id"));
}
log.info("历史清理批次 network={} floor={} events={} blocks={} anchors={} samples={} archive={}",
network, floor, events.size(), blocks.size(), anchors.size(), samples.size(), file);
return count;
}
private boolean validLease(String network, String lease) {
return store.one("SELECT network FROM rent_history_cursor WHERE network=? AND cleanup_owner=?"
+ " AND cleanup_until>UTC_TIMESTAMP(3)", network, lease) != null;
}
/** 订单/任务状态只作为保留条件,绝不由清理器推定失败、释放资源或资金。 */
private long protectedFloor(String network, long scanned, LocalDateTime cutoff) {
long floor = Math.max(0, scanned - RentalHistoryService.MAX_REPLAY_BLOCKS);
List<Map<String, Object>> tasks = store.rows("SELECT t.intent,t.resource_type,o.id AS order_id,"
+ "o.network AS order_network,o.resource_type AS order_resource_type,"
+ "x.block_height FROM rent_task t LEFT JOIN rent_order o ON o.id=t.order_id"
+ " LEFT JOIN rent_transaction x ON x.task_id=t.id WHERE t.network=?"
+ " AND t.resource_type IN ('ENERGY','BANDWIDTH') AND (o.id IS NULL"
+ " OR o.network<>t.network OR o.resource_type<>t.resource_type OR o.status IS NULL"
+ " OR o.fund_status IS NULL OR o.reclaim_status IS NULL OR t.status IS NULL"
+ " OR t.reservation_status IS NULL"
+ " OR o.status NOT IN ('SUCCESS','FAILED','CANCELLED') OR o.fund_status='HELD'"
+ " OR o.relation_slot IS NOT NULL OR o.reclaim_status NOT IN ('DONE','NOT_REQUIRED','NOT_STARTED')"
+ " OR o.service_expires_at>? OR o.updated_at>=? OR t.updated_at>=? OR x.updated_at>=?"
+ " OR t.status NOT IN ('VERIFIED','REJECTED','FAILED') OR t.wallet_execution_slot IS NOT NULL"
+ " OR t.reservation_status='HELD' OR (x.id IS NOT NULL AND x.status NOT IN ('CONFIRMED','FAILED')))"
+ " LIMIT " + (MAX_PROTECTED_TASKS + 1), network, now(), cutoff, cutoff, cutoff);
if (tasks.size() > MAX_PROTECTED_TASKS) {
log.warn("历史保护任务超出单批上限,停止本网络清理 network={}", network);
return 0;
}
Map<String, Map<String, Object>> relations = new LinkedHashMap<>();
for (Map<String, Object> task : tasks) {
if (task.get("order_id") == null || !network.equals(text(task, "order_network"))
|| !text(task, "resource_type").equals(text(task, "order_resource_type"))) {
return 0;
}
try {
// 使用签发时冻结的owner/receiver,禁止用后来换绑的钱包地址定位旧证据。
JsonNode intent = json.readTree(text(task, "intent"));
String owner = RentalHistoryService.addressHex(intent.path("owner").asText());
String receiver = RentalHistoryService.addressHex(intent.path("receiver").asText());
String type = text(task, "resource_type");
String key = owner + ":" + receiver + ":" + type;
Map<String, Object> relation = relations.get(key);
long target = task.get("block_height") == null ? Long.MAX_VALUE : number(task, "block_height");
if (relation == null) {
relations.put(key, map("owner", owner, "receiver", receiver, "type", type, "target", target));
} else {
relation.put("target", Math.min(number(relation, "target"), target));
}
} catch (Exception ex) {
log.warn("受保护任务基线无法定位,停止本网络清理 network={}", network);
return 0;
}
}
// 按地址对去重并批量查基线,避免每个任务一次SQL造成长时间占用保护锁。
List<Map<String, Object>> pairs = new ArrayList<>(relations.values());
for (int offset = 0; offset < pairs.size(); offset += 100) {
List<Map<String, Object>> selected = pairs.subList(offset, Math.min(pairs.size(), offset + 100));
StringBuilder sql = new StringBuilder("SELECT owner_address,receiver_address,resource_type,"
+ "MIN(block_height) AS first_height FROM rent_history_anchor WHERE network=? AND (");
List<Object> args = new ArrayList<>();
args.add(network);
for (int i = 0; i < selected.size(); i++) {
if (i > 0) { sql.append(" OR "); }
sql.append("(owner_address=? AND receiver_address=? AND resource_type=?)");
args.add(selected.get(i).get("owner"));
args.add(selected.get(i).get("receiver"));
args.add(selected.get(i).get("type"));
}
sql.append(") GROUP BY owner_address,receiver_address,resource_type");
List<Map<String, Object>> found = store.rows(sql.toString(), args.toArray());
if (found.size() != selected.size()) {
log.warn("受保护地址对缺少基线,停止本网络清理 network={}", network);
return 0;
}
for (Map<String, Object> anchor : found) {
String key = text(anchor, "owner_address") + ":" + text(anchor, "receiver_address")
+ ":" + text(anchor, "resource_type");
if (number(anchor, "first_height") >= number(relations.get(key), "target")) {
return 0;
}
floor = Math.min(floor, number(anchor, "first_height"));
}
}
// 不完整业务数据也应保守处理,不能因缺任务就跳过已选定供应钱包的在途订单。
Map<String, Object> orphan = store.one("SELECT o.id FROM rent_order o WHERE o.network=?"
+ " AND o.resource_type IN ('ENERGY','BANDWIDTH') AND o.wallet_id IS NOT NULL"
+ " AND (o.status NOT IN ('SUCCESS','FAILED','CANCELLED') OR o.fund_status='HELD'"
+ " OR o.relation_slot IS NOT NULL OR o.reclaim_status NOT IN ('DONE','NOT_REQUIRED','NOT_STARTED'))"
+ " AND NOT EXISTS (SELECT 1 FROM rent_task t WHERE t.order_id=o.id"
+ " AND t.network=o.network AND t.resource_type=o.resource_type) LIMIT 1", network);
return orphan == null ? floor : 0;
}
}
@@ -44,25 +44,32 @@ public class RentalHistoryCollector {
selected.add(RentalValues.network(name.trim()));
}
AtomicInteger sequence = new AtomicInteger();
executor = new ScheduledThreadPoolExecutor(selected.size(), action -> {
executor = new ScheduledThreadPoolExecutor(selected.size() * 3, action -> {
Thread thread = new Thread(action, "rental-history-" + sequence.incrementAndGet());
thread.setDaemon(true);
return thread;
});
executor.setRemoveOnCancelPolicy(true);
for (String network : selected) {
schedule(network, "参数采样", () -> service.sample(network));
schedule(network, "参数确认", () -> service.confirmSamples(network));
schedule(network, "事件扫描", () -> service.collect(network));
}
}
private void schedule(String network, String operation, Runnable action) {
executor.scheduleWithFixedDelay(() -> {
try {
service.collect(network);
action.run();
} catch (RentalHistoryService.PendingConfirmationException ex) {
LOG.debug("租赁历史采样等待区块确认,network={}", network);
} catch (Exception ex) {
// 不记录异常原文,避免RPC配置、认证头或供应商数据进入日志。
LOG.warn("租赁历史采集未完成,network={},请查看受保护的历史状态接口", network);
LOG.warn("租赁历史采集未完成 network={} operation={} diagnostic={}",
network, operation, RentalDiagnostics.describe(ex));
}
}, 0, interval, TimeUnit.MILLISECONDS);
}
}
@PreDestroy
public void close() {
@@ -0,0 +1,26 @@
package com.ruoyi.system.rental;
import java.util.Map;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static com.ruoyi.system.rental.RentalValues.*;
/** 历史读写和清理共用网络游标行锁。只在短数据库事务内持锁,禁止在锁内调用RPC。 */
final class RentalHistoryGuard {
private RentalHistoryGuard() { }
static Map<String, Object> lock(RentalStore store, String network) {
require(TransactionSynchronizationManager.isActualTransactionActive(), "历史保护锁必须在事务内获取");
Map<String, Object> row = store.one("SELECT * FROM rent_history_cursor WHERE network=? FOR UPDATE", network);
if (row == null) {
try {
store.execute("INSERT INTO rent_history_cursor (network,updated_at) VALUES (?,?)", network, now());
} catch (DuplicateKeyException ex) {
// 首次基线、采样确认和扫描可以并发启动;最终必须锁定同一行。
}
row = store.one("SELECT * FROM rent_history_cursor WHERE network=? FOR UPDATE", network);
}
require(row != null, "历史网络保护行缺失");
return row;
}
}
@@ -32,7 +32,7 @@ import java.util.Map;
*/
@Service
public class RentalHistoryService {
private static final int MAX_REPLAY_BLOCKS = 10000;
static final int MAX_REPLAY_BLOCKS = 10000;
private static final String DEFAULT_PROBE = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
private final RentalStore store;
private final RentalChain chain;
@@ -50,8 +50,14 @@ public class RentalHistoryService {
@Value("${rental.confirmations:19}")
private long confirmations = 19;
/** 未确认采样只驻留内存;重启丢弃,禁止回填或使用其他高度参数替代。 */
private final Map<String, Snapshot> pendingSnapshots = new java.util.concurrent.ConcurrentHashMap<>();
/** 同一进程每网络最多一个采样;不同网络和事件扫描互不阻塞。 */
private final java.util.Set<String> sampling = java.util.concurrent.ConcurrentHashMap.newKeySet();
@Value("${rental.history.parameter-grace-seconds:120}")
private long parameterGraceSeconds = 120;
@Value("${rental.history.max-sample-age-seconds:15}")
private long maxSampleAgeSeconds = 15;
/** 确认预热属于正常等待,不作为RPC故障反复输出错误堆栈。 */
public static final class PendingConfirmationException extends IllegalStateException {
@@ -69,6 +75,92 @@ public class RentalHistoryService {
this.transaction = new TransactionTemplate(manager);
}
/** 全局采样按网络/高度去重;钱包刷新可直接提交同一次夹读,绝不从旧钱包快照回填。 */
public void offerParameters(String network, JsonNode before, JsonNode after, JsonNode resources) {
network(network);
if (!Arrays.stream(enabledNetworks.split(",")).anyMatch(value -> network.equals(value.trim()))) {
return;
}
require(height(before) == height(after) && hash(before).equals(hash(after)), "参数采样跨区块");
long[] totals = parameters(resources);
transaction.execute(status -> {
RentalHistoryGuard.lock(store, network);
try {
store.execute("INSERT INTO rent_history_sample (network,block_height,block_id,"
+ "energy_limit,energy_weight,bandwidth_limit,bandwidth_weight,created_at)"
+ " VALUES (?,?,?,?,?,?,?,?)", network, height(before), hash(before),
totals[0], totals[1], totals[2], totals[3], now());
} catch (DuplicateKeyException ex) {
// 同高度重复读允许复用,但不能让不一致的网关响应覆盖已采事实。
}
Map<String, Object> row = store.one("SELECT * FROM rent_history_sample"
+ " WHERE network=? AND block_height=? FOR UPDATE", network, height(before));
require(row != null && hash(before).equals(text(row, "block_id"))
&& number(row, "energy_limit") == totals[0] && number(row, "energy_weight") == totals[1]
&& number(row, "bandwidth_limit") == totals[2] && number(row, "bandwidth_weight") == totals[3],
"同一采样高度状态不一致,请检查RPC后端一致性");
return null;
});
}
/** 不等待确认;独立线程持续采样,不能被订单或补区块的RPC阻塞。 */
public void sample(String network) {
network(network);
if (!sampling.add(network)) {
return;
}
try {
for (int attempt = 0; attempt < 3; attempt++) {
JsonNode before = chain.call(network, "/wallet/getnowblock", map());
Map<String, Object> existing = store.one("SELECT block_id FROM rent_history_sample"
+ " WHERE network=? AND block_height=?", network, height(before));
if (existing != null && hash(before).equals(text(existing, "block_id"))) {
return;
}
JsonNode resources = chain.call(network, "/wallet/getaccountresource",
map("address", probeAddress, "visible", true));
JsonNode after = chain.call(network, "/wallet/getnowblock", map());
if (height(before) == height(after) && hash(before).equals(hash(after))) {
offerParameters(network, before, after, resources);
return;
}
}
throw new IllegalStateException("最新头在采样期间变化,请重试");
} finally {
sampling.remove(network);
}
}
/** 待确认记录持久化跨重启保留;只有确认链同高度同哈希才提升到四张证据表。 */
public void confirmSamples(String network) {
network(network);
long confirmed = height(head(network));
for (Map<String, Object> row : store.rows("SELECT * FROM rent_history_sample WHERE network=?"
+ " AND block_height<=? ORDER BY block_height LIMIT 200", network, confirmed)) {
long sampledHeight = number(row, "block_height");
JsonNode canonical = chain.call(network, "/walletsolidity/getblockbynum",
map("num", sampledHeight, "visible", false));
require(height(canonical) == sampledHeight, "确认采样高度不符");
transaction.execute(status -> {
RentalHistoryGuard.lock(store, network);
Map<String, Object> pending = store.one("SELECT block_id FROM rent_history_sample"
+ " WHERE network=? AND block_height=?", network, sampledHeight);
if (pending == null || !text(row, "block_id").equals(text(pending, "block_id"))) {
return null;
}
if (hash(canonical).equals(text(row, "block_id"))) {
saveParameters(network, new Snapshot(canonical, new long[] {
number(row, "energy_limit"), number(row, "energy_weight"),
number(row, "bandwidth_limit"), number(row, "bandwidth_weight")}, 0, row.get("created_at")));
}
// 分叉采样只能丢弃,禁止把参数改标到确认链的另一个哈希。
store.execute("DELETE FROM rent_history_sample WHERE network=? AND block_height=? AND block_id=?",
network, sampledHeight, text(row, "block_id"));
return null;
});
}
}
/** 仅接受合法TRON地址;库内统一十六进制,避免Base58大小写折叠或多种编码造成漏重放。 */
static String addressHex(String address) {
RentalOrders.address(address);
@@ -106,76 +198,33 @@ public class RentalHistoryService {
}
/**
* 最新头夹读绑定采样高度;采样必须等该高度确认且哈希一致后才能用于历史证明。
* 必须配置同一一致性FullNode(或保证会话一致性的网关),不能混用不同高度后端。
* 确认头夹读绑定地址对基线。参数由全局独立采样,不与地址对或订单重复绑定。
* 必须使用一致性确认节点;未知接口、错误响应或不稳定头均拒绝建基线。
*/
private synchronized Snapshot capture(String network, String owner, String receiver, String type) {
String key = network + ":" + owner + ":" + receiver + ":" + type;
// 有界缓存防止异常地址请求造成无限内存增长;过期快照不再用于新基线。
long oldest = System.currentTimeMillis() - 10 * 60 * 1000L;
pendingSnapshots.entrySet().removeIf(entry -> entry.getValue().sampledAt < oldest);
require(pendingSnapshots.size() < 10000, "待确认资源采样过多,请稍后重试");
private Snapshot capture(String network, String owner, String receiver, String type) {
// 基线与全网参数独立。确认节点夹读成功即可使用,不再等最新头的确认周期。
for (int attempt = 0; attempt < 3; attempt++) {
JsonNode before = chain.call(network, "/wallet/getnowblock", map());
long blockHeight = height(before);
String blockId = hash(before);
long[] totals = parameters(chain.call(network, "/wallet/getaccountresource",
map("address", owner, "visible", true)));
JsonNode before = head(network);
long balance = 0;
if (receiver != null) {
// 锁定和非锁定本金都参与基线,锁定到期解锁不会改变合计本金。
for (boolean locked : new boolean[] {false, true}) {
JsonNode response = chain.call(network, "/wallet/getdelegatedresourcev2",
map("fromAddress", owner, "toAddress", receiver,
"lock", locked, "visible", true));
require(!response.has("Error") && !response.has("error")
&& (!response.has("result") || !response.path("result").isBoolean()
|| response.path("result").asBoolean()), "确认关系查询失败");
JsonNode response = chain.call(network, "/walletsolidity/getdelegatedresourcev2",
map("fromAddress", owner, "toAddress", receiver, "lock", locked, "visible", true));
require(response.isObject() && !response.has("Error") && !response.has("error")
&& !response.has("code") && !response.has("result"), "确认关系查询失败");
JsonNode rows = response.path("delegatedResource");
require(rows.isMissingNode() || rows.isArray(), "确认关系响应结构错误");
require(response.size() == 0 || rows.isArray(), "确认关系响应结构错误");
for (JsonNode row : rows) {
String field = "ENERGY".equals(type)
? "frozen_balance_for_energy" : "frozen_balance_for_bandwidth";
// protobuf省略零字段;有值时必须为精确非负整数。
balance = Math.addExact(balance, row.has(field)
? positive(row.path(field), true) : 0);
balance = Math.addExact(balance, row.has(field) ? positive(row.path(field), true) : 0);
}
}
}
JsonNode after = chain.call(network, "/wallet/getnowblock", map());
if (blockHeight == height(after) && blockId.equals(hash(after))) {
// 每轮继续采样,等待确认期间不能停止采样,否则会漏掉后续交易高度的参数。
String sampleKey = key + ":" + blockHeight;
Snapshot sampled = new Snapshot(before.deepCopy(), totals, balance);
Snapshot original = pendingSnapshots.putIfAbsent(sampleKey, sampled);
if (original != null) {
if (!hash(original.block).equals(blockId)) {
pendingSnapshots.remove(sampleKey);
throw new IllegalStateException("未确认采样区块发生分叉,丢弃并重新采样");
}
require(hash(original.block).equals(blockId)
&& Arrays.equals(original.totals, totals) && original.balance == balance,
"同一采样高度状态不一致,请检查RPC后端一致性");
}
long confirmedHeight = height(head(network));
Map.Entry<String, Snapshot> ready = pendingSnapshots.entrySet().stream()
.filter(entry -> entry.getKey().startsWith(key + ":")
&& height(entry.getValue().block) <= confirmedHeight)
.min(java.util.Comparator.comparingLong(entry -> height(entry.getValue().block)))
.orElse(null);
if (ready == null) {
throw new PendingConfirmationException();
}
Snapshot pending = ready.getValue();
JsonNode canonical = chain.call(network, "/walletsolidity/getblockbynum",
map("num", height(pending.block), "visible", false));
pendingSnapshots.remove(ready.getKey());
require(height(canonical) == height(pending.block)
&& hash(canonical).equals(hash(pending.block)), "资源采样区块发生分叉,丢弃并重新采样");
return pending;
JsonNode after = head(network);
if (height(before) == height(after) && hash(before).equals(hash(after))) {
return new Snapshot(before.deepCopy(), null, balance);
}
}
throw new IllegalStateException("最新头在采样期间变化,请重试,未记录历史证据");
throw new IllegalStateException("确认头在基线读取期间变化,请重试");
}
/** 派单前建立真实基线;非零关系拒绝派单,不用任务声明的0替代链上读取。 */
@@ -186,10 +235,27 @@ public class RentalHistoryService {
resource(type);
String ownerHex = addressHex(owner);
String receiverHex = addressHex(receiver);
require(maxSampleAgeSeconds >= 1 && maxSampleAgeSeconds <= 300, "参数采样新鲜度必须为1到300秒");
// 按主键倒序取最近高度,避免每次派单全表聚合越来越大的历史档案。
Map<String, Object> healthy = store.one("SELECT created_at AS sampled_at FROM rent_history_sample"
+ " WHERE network=? ORDER BY block_height DESC LIMIT 1", network);
Map<String, Object> archived = store.one("SELECT parameters_at AS sampled_at FROM rent_history_block"
+ " WHERE network=? AND parameters_at IS NOT NULL ORDER BY block_height DESC LIMIT 1", network);
long cutoff = System.currentTimeMillis() - maxSampleAgeSeconds * 1000L;
require((healthy != null && RentalValues.time(healthy.get("sampled_at")).toEpochMilli() >= cutoff)
|| (archived != null && RentalValues.time(archived.get("sampled_at")).toEpochMilli() >= cutoff),
"全网资源参数采样尚未就绪或已停滞,暂不派单");
if (Boolean.TRUE.equals(transaction.execute(status -> {
RentalHistoryGuard.lock(store, network);
return reuseAnchor(network, ownerHex, receiverHex, type);
}))) {
return;
}
Snapshot snapshot = capture(network, owner, receiver, type);
require(snapshot.balance == 0, "确认状态存在旧委托,暂不派单");
transaction.execute(status -> {
saveParameters(network, snapshot);
RentalHistoryGuard.lock(store, network);
saveBlock(network, snapshot.block);
Map<String, Object> existing = store.one(
"SELECT * FROM rent_history_anchor WHERE network=? AND owner_address=?"
+ " AND receiver_address=? AND resource_type=? AND block_height=?",
@@ -216,6 +282,59 @@ public class RentalHistoryService {
});
}
/** 仅完整连续且仍在推进的事件档案可复用;不完整时退回确认节点读取真实关系。 */
private boolean reuseAnchor(String network, String owner, String receiver, String type) {
Map<String, Object> cursor = store.one("SELECT * FROM rent_history_cursor WHERE network=?"
+ " AND last_success_at>=?", network, RentalValues.after(-15));
if (cursor == null || cursor.get("scanned_height") == null) {
return false;
}
long end = number(cursor, "scanned_height");
Map<String, Object> anchor = store.one("SELECT * FROM rent_history_anchor WHERE network=?"
+ " AND owner_address=? AND receiver_address=? AND resource_type=? AND block_height<=?"
+ " ORDER BY block_height DESC LIMIT 1", network, owner, receiver, type, end);
if (anchor == null || end - number(anchor, "block_height") > MAX_REPLAY_BLOCKS) {
return false;
}
long expected = number(anchor, "block_height");
String previous = text(anchor, "block_id");
for (Map<String, Object> row : store.rows("SELECT * FROM rent_history_block WHERE network=?"
+ " AND block_height>? AND block_height<=? ORDER BY block_height", network, expected, end)) {
if (number(row, "block_height") != ++expected || number(row, "events_complete") != 1
|| !previous.equals(text(row, "parent_id"))) {
return false;
}
previous = text(row, "block_id");
}
if (expected != end || !previous.equals(text(cursor, "scanned_block_id"))) {
return false;
}
long balance = number(anchor, "balance_sun");
for (Map<String, Object> event : store.rows("SELECT operation,amount_sun FROM rent_history_event"
+ " WHERE network=? AND owner_address=? AND receiver_address=? AND resource_type=?"
+ " AND block_height>? AND block_height<=? ORDER BY block_height,tx_index",
network, owner, receiver, type, number(anchor, "block_height"), end)) {
balance = "DELEGATE".equals(text(event, "operation"))
? Math.addExact(balance, number(event, "amount_sun"))
: Math.subtractExact(balance, number(event, "amount_sun"));
require(balance >= 0, "历史委托本金重放出现负数");
}
require(balance == 0, "确认状态存在旧委托,暂不派单");
// 追加检查点限制未来重放长度,保留原始基线,不覆盖事实。
try {
store.execute("INSERT INTO rent_history_anchor (network,owner_address,receiver_address,"
+ "resource_type,block_height,block_id,balance_sun,created_at) VALUES (?,?,?,?,?,?,0,?)",
network, owner, receiver, type, end, previous, now());
} catch (DuplicateKeyException ex) {
Map<String, Object> existing = store.one("SELECT * FROM rent_history_anchor WHERE network=?"
+ " AND owner_address=? AND receiver_address=? AND resource_type=? AND block_height=?",
network, owner, receiver, type, end);
require(existing != null && number(existing, "balance_sun") == 0
&& previous.equals(text(existing, "block_id")), "历史基线发生冲突");
}
return true;
}
/**
* 每网络一个数据库租约;RPC结束后落库前再次校验租约,过期实例不得推进游标。
* 首次从当前确认头开始,后续只沿父哈希顺序前进。停机后交易可补,参数不能回填。
@@ -236,13 +355,8 @@ public class RentalHistoryService {
return;
}
try {
Snapshot snapshot = capture(network, probeAddress, null, null);
transaction.execute(status -> {
lockLease(network, lease);
saveParameters(network, snapshot);
return null;
});
long confirmed = height(snapshot.block);
// 区块/事件扫描不依赖资源参数是否采到、是否已经提升为确认事实。
long confirmed = height(head(network));
Map<String, Object> cursor = store.one(
"SELECT * FROM rent_history_cursor WHERE network=?", network);
Map<String, Object> firstAnchor = store.one("SELECT MIN(block_height) AS first_height"
@@ -341,7 +455,7 @@ public class RentalHistoryService {
store.execute("UPDATE rent_history_block SET energy_limit=?,energy_weight=?,"
+ "bandwidth_limit=?,bandwidth_weight=?,parameters_at=?"
+ " WHERE network=? AND block_height=?", totals[0], totals[1], totals[2],
totals[3], now(), network, height(snapshot.block));
totals[3], snapshot.sampledAt, network, height(snapshot.block));
} else {
require(number(row, "energy_limit") == totals[0]
&& number(row, "energy_weight") == totals[1]
@@ -397,6 +511,31 @@ public class RentalHistoryService {
String owner, String receiver, String type) {
network(network);
resource(type);
addressHex(owner);
addressHex(receiver);
require(txId != null && txId.matches("[0-9a-fA-F]{64}") && targetHeight >= 0,
"证明交易或高度无效");
Map<String, Object> result = transaction.execute(status -> {
RentalHistoryGuard.lock(store, network);
return buildProof(network, txId, targetHeight, owner, receiver, type);
});
if (result == null) {
return null;
}
// 连续区块/事件在同一保护事务内读成完整证明;RPC在释放行锁之后执行。
require(confirmations > 0 && height(head(network)) - targetHeight + 1 >= confirmations,
"历史证明交易确认深度不足");
JsonNode canonical = chain.call(network, "/walletsolidity/getblockbynum",
map("num", targetHeight, "visible", false));
require(height(canonical) == targetHeight && hash(canonical).equals(text(result, "block_id")),
"历史证明区块与确认链不一致");
return result;
}
private Map<String, Object> buildProof(String network, String txId, long targetHeight,
String owner, String receiver, String type) {
network(network);
resource(type);
require(txId != null && txId.matches("[0-9a-fA-F]{64}") && targetHeight >= 0,
"证明交易或高度无效");
String ownerHex = addressHex(owner);
@@ -405,6 +544,15 @@ public class RentalHistoryService {
require(cursor != null && cursor.get("scanned_height") != null
&& number(cursor, "scanned_height") >= targetHeight, "历史区块正在采集中,请稍后重试");
Map<String, Object> target = block(network, targetHeight);
if (target != null && target.get("parameters_at") == null) {
require(parameterGraceSeconds >= 0 && parameterGraceSeconds <= 3600, "参数等待期必须为0到3600秒");
// 确认与事件扫描线程独立:先到的事件必须留出归档窗口,不能立即判为履约失败。
long age = System.currentTimeMillis() - RentalValues.time(target.get("created_at")).toEpochMilli();
if (age < parameterGraceSeconds * 1000L) {
throw new PendingConfirmationException();
}
// 超过有界窗口仍未提升,即使存在待确认记录也不无限挂起结算。
}
if (target == null || target.get("parameters_at") == null) {
return null;
}
@@ -427,13 +575,6 @@ public class RentalHistoryService {
previous = text(row, "block_id");
}
require(expected == targetHeight, "历史区块覆盖不足");
require(confirmations > 0 && height(head(network)) - targetHeight + 1 >= confirmations,
"历史证明交易确认深度不足");
// 再向配置节点核对目标区块哈希;节点换链/误切网络时不使用旧库证据继续结算。
JsonNode canonical = chain.call(network, "/walletsolidity/getblockbynum",
map("num", targetHeight, "visible", false));
require(height(canonical) == targetHeight && hash(canonical).equals(text(target, "block_id")),
"历史证明区块与确认链不一致");
List<Map<String, Object>> events = store.rows("SELECT * FROM rent_history_event WHERE network=?"
+ " AND owner_address=? AND receiver_address=? AND resource_type=?"
+ " AND block_height>? AND block_height<=? ORDER BY block_height,tx_index",
@@ -464,6 +605,21 @@ public class RentalHistoryService {
return proof;
}
/** proof返回null时细分缺口;只读数据库,返回固定代码,不用当前链上参数补造历史证明。 */
public String missingProofCode(String network, long height, String owner, String receiver, String type) {
Map<String, Object> target = block(network, height);
if (target == null) {
return "BLOCK_NOT_ARCHIVED";
}
if (target.get("parameters_at") == null) {
return "PARAMETERS_MISSING";
}
Map<String, Object> anchor = store.one("SELECT block_height FROM rent_history_anchor WHERE network=?"
+ " AND owner_address=? AND receiver_address=? AND resource_type=? AND block_height<? LIMIT 1",
network, addressHex(owner), addressHex(receiver), type, height);
return anchor == null ? "BASELINE_MISSING" : "HISTORY_INCOMPLETE";
}
/** 仅供运营查看,不返回RPC地址、认证头、私钥或响应原文。 */
public List<Map<String, Object>> status() {
return store.rows("SELECT c.network,c.scanned_height,c.scanned_block_id,c.last_success_at,"
@@ -471,6 +627,8 @@ public class RentalHistoryService {
+ " WHERE b.network=c.network AND b.parameters_at IS NOT NULL) AS last_parameter_height,"
+ "(SELECT COUNT(*) FROM rent_history_block b WHERE b.network=c.network"
+ " AND b.events_complete=1 AND b.parameters_at IS NULL) AS parameter_gap_count"
+ ",(SELECT COUNT(*) FROM rent_history_sample s WHERE s.network=c.network) AS pending_sample_count"
+ ",(SELECT MAX(s.block_height) FROM rent_history_sample s WHERE s.network=c.network) AS latest_sample_height"
+ " FROM rent_history_cursor c ORDER BY c.network");
}
@@ -478,12 +636,17 @@ public class RentalHistoryService {
private final JsonNode block;
private final long[] totals;
private final long balance;
private final long sampledAt = System.currentTimeMillis();
private final Object sampledAt;
private Snapshot(JsonNode block, long[] totals, long balance) {
this(block, totals, balance, now());
}
private Snapshot(JsonNode block, long[] totals, long balance, Object sampledAt) {
this.block = block;
this.totals = totals;
this.balance = balance;
this.sampledAt = sampledAt;
}
}
}
@@ -16,6 +16,8 @@ import java.util.Map;
@Service
@lombok.extern.slf4j.Slf4j
public class RentalOrders {
@org.springframework.beans.factory.annotation.Autowired(required = false)
private org.springframework.context.ApplicationEventPublisher deliveryEvents;
@org.springframework.beans.factory.annotation.Autowired
private RentalOnchain onchain;
private final RentalStore store;
@@ -183,6 +185,7 @@ public class RentalOrders {
order.put("id", id);
funds.hold(order);
store.event("ORDER", id, "CREATE", user, "创建订单并冻结内部USDT");
RentalDeliveryEvents.afterCommit(deliveryEvents, true, id);
return store.get("order", id, false);
}
@@ -237,6 +240,7 @@ public class RentalOrders {
log.info("地址上链分账已锁定 orderId={} platformPercent={} platformFeeUsdt={} supplierNetUsdt={}",
orderId, price.get("supplier_fee_percent"), price.get("supplier_fee_amount"), price.get("supplier_net_amount"));
store.event("ORDER", orderId, "CREATE", user, "地址上链:冻结1TRX折价及固定服务费USDT");
RentalDeliveryEvents.afterCommit(deliveryEvents, true, orderId);
log.info("地址上链订单已冻结 orderId={} userId={} network={} transferSun={} principalUsdt={} serviceFeeUsdt={} totalUsdt={}",
orderId, user, network, RentalOnchain.TRANSFER_SUN, price.get("principal_usdt"),
price.get("service_fee_usdt"), total);
@@ -75,6 +75,15 @@ public class RentalQueries {
// 资金账户列表补充所属用户名;左连接保留关联用户缺失的账户,归属过滤仍使用账户的user_id。
String select = "r.*";
if ("order".equals(type)) {
// 只取归属校验后的订单关联诊断,不向页面暴露整份交易证据或节点配置。
select += ", (SELECT e.reason FROM rent_event e WHERE e.object_type='ORDER'"
+ " AND e.object_id=r.id AND e.action='DELIVERY_REVIEW' ORDER BY e.id DESC LIMIT 1) AS fulfillment_reason"
+ ", (SELECT x.evidence FROM rent_transaction x JOIN rent_task t ON t.id=x.task_id"
+ " WHERE t.order_id=r.id AND t.task_type='DELEGATE' AND x.status='CONFIRMED'"
+ " ORDER BY x.id LIMIT 1) AS review_evidence"
+ ", (SELECT x.confirmed_at FROM rent_transaction x JOIN rent_task t ON t.id=x.task_id"
+ " WHERE t.order_id=r.id AND t.task_type='DELEGATE' AND x.status='CONFIRMED'"
+ " ORDER BY x.id LIMIT 1) AS review_checked_at";
select += ", (SELECT x.tx_id FROM rent_transaction x JOIN rent_task t ON t.id=x.task_id"
+ " WHERE t.order_id=r.id AND t.task_type='TRANSFER_TRX' AND x.status='CONFIRMED'"
+ " ORDER BY x.id LIMIT 1) AS transaction_id";
@@ -93,6 +102,9 @@ public class RentalQueries {
+ ") ORDER BY r.id DESC LIMIT 50 OFFSET ?",
args.toArray());
for (Map<String, Object> row : rows) {
if ("order".equals(type)) {
explainFulfillment(row);
}
row.remove("api_secret");
row.remove("payment_api_key");
row.remove("payment_public_key");
@@ -117,4 +129,40 @@ public class RentalQueries {
}
return rows;
}
/** 老订单尚无诊断事件时,仅用当时已归档的证据回溯;不能用当前时间判断历史租期。 */
private void explainFulfillment(Map<String, Object> row) {
Object evidence = row.remove("review_evidence");
Object checked = row.remove("review_checked_at");
String code = text(row, "error_code");
if ("DELEGATION_CHANGED".equals(code)) {
row.put("fulfillment_reason", "租期内委托关系与原确认本金不一致,可能被外部撤销或追加,需人工核对");
return;
}
if (!"DELIVERY_EVIDENCE_REVIEW".equals(code)) {
row.put("fulfillment_reason", "");
return;
}
if (!text(row, "fulfillment_reason").isEmpty()) {
return;
}
try {
if (evidence != null) {
com.fasterxml.jackson.databind.JsonNode proof = new com.fasterxml.jackson.databind.ObjectMapper()
.readTree(evidence.toString());
com.fasterxml.jackson.databind.JsonNode quantity = proof.path("verified_resource_quantity");
Long verified = quantity.isIntegralNumber() && quantity.canConvertToLong() ? quantity.longValue() : null;
String reason = RentalDeliveryDiagnostics.explain(proof.path("delivery_proven").asBoolean(false),
verified, number(row, "target_resource_quantity"),
row.get("service_expires_at") == null ? null : time(row.get("service_expires_at")),
checked == null ? null : time(checked));
row.put("fulfillment_reason", reason.isEmpty()
? "历史核验未通过,现有归档未记录明确失败项,请核对原任务及订单事件" : reason);
return;
}
} catch (Exception ignored) {
// 不把数据库证据JSON或解析异常原文带到HTTP响应中。
}
row.put("fulfillment_reason", "历史履约核验未通过,未保存完整诊断,请核对原交易证据、资源数量及核验时间");
}
}
@@ -291,7 +291,20 @@ public class RentalSocket extends TextWebSocketHandler {
/** 由有界后台调度调用,同一逻辑任务始终使用相同delivery_message_id和冻结intent。 */
public void tick() {
tick(0);
}
public void push(long nodeId) {
tick(nodeId);
}
private void tick(long nodeId) {
for (Connection c : connections.values()) {
if (nodeId != 0 && c.node != nodeId) {
continue;
}
// 即时推送与补偿扫描串行处理同一连接的选择、发送及投递计数。
synchronized (c) {
try {
if (c.node == 0) {
if (System.currentTimeMillis() - c.opened > 5000) {
@@ -379,6 +392,7 @@ public class RentalSocket extends TextWebSocketHandler {
}
}
}
}
@Override
public void afterConnectionClosed(WebSocketSession socket, CloseStatus status) {
@@ -13,6 +13,8 @@ import java.util.function.Supplier;
@Service
@lombok.extern.slf4j.Slf4j
public class RentalTasks {
@org.springframework.beans.factory.annotation.Autowired(required = false)
private org.springframework.context.ApplicationEventPublisher deliveryEvents;
private final RentalStore store;
private final RentalChain chain;
private final RentalIdentity identity;
@@ -423,6 +425,7 @@ public class RentalTasks {
java.time.LocalDateTime.ofInstant(
Instant.ofEpochMilli(signed), java.time.ZoneOffset.UTC),
taskNo);
RentalDeliveryEvents.afterCommit(deliveryEvents, false, nodeId);
}
public void reclaim(long orderId) {
@@ -634,6 +637,7 @@ public class RentalTasks {
Map<String, Object> fields = new LinkedHashMap<>(proof);
fields.remove("delivery_proven");
fields.remove("history_proof");
fields.remove("delivery_evidence_gap");
fields.put("evidence", orders.encode(proof));
fields.put("confirmed_at", now());
store.update("transaction", number(record, "id"), fields);
@@ -682,11 +686,18 @@ public class RentalTasks {
if (delegate) {
Instant start = time(proof.get("block_time")),
expires = start.plusSeconds(number(order, "duration_seconds"));
boolean delivered =
Boolean.TRUE.equals(proof.get("delivery_proven"))
&& number(proof, "verified_resource_quantity")
>= number(order, "target_resource_quantity")
&& expires.isAfter(Instant.now());
Instant checkedAt = Instant.now();
// 在同一次判断中固定核验时间;记录所有未满足项,避免日志与状态跨租期边界不一致。
String reviewReason = RentalDeliveryDiagnostics.explain(
Boolean.TRUE.equals(proof.get("delivery_proven")),
proof.get("verified_resource_quantity") == null ? null
: number(proof, "verified_resource_quantity"),
number(order, "target_resource_quantity"), expires, checkedAt);
String gap = RentalDeliveryDiagnostics.evidenceGap(text(proof, "delivery_evidence_gap"));
if (!gap.isEmpty() && !Boolean.TRUE.equals(proof.get("delivery_proven"))) {
reviewReason += ";" + gap;
}
boolean delivered = reviewReason.isEmpty();
if (delivered) {
funds.charge(order);
}
@@ -710,6 +721,14 @@ public class RentalTasks {
delivered ? null : "DELIVERY_EVIDENCE_REVIEW"));
if (delivered) {
orders.webhook(order, "SUCCESS", "ORDER:" + orderId + ":SUCCESS");
} else {
// 与人工核对状态同事务保存,查询端无需推测或重新查询链上即可展示当时的原因。
store.event("ORDER", orderId, "DELIVERY_REVIEW", 0, reviewReason);
log.warn("租赁履约未通过 orderId={} taskId={} txId={} historyProven={}"
+ " verifiedQuantity={} targetQuantity={} reason={}",
orderId, taskId, record.get("tx_id"), proof.get("delivery_proven"),
proof.get("verified_resource_quantity"), order.get("target_resource_quantity"),
reviewReason);
}
} else {
store.update(
@@ -26,6 +26,8 @@ public class RentalWorkers {
private long walletCursor;
private long monitoringCursor;
private long dispatchCursor;
@org.springframework.beans.factory.annotation.Autowired(required = false)
private RentalDeliveryDispatcher deliveryDispatcher;
@org.springframework.beans.factory.annotation.Value("${rental.delivery.dispatch-interval-ms:3000}")
private long dispatchIntervalMs = 3000;
@@ -103,7 +105,11 @@ public class RentalWorkers {
for (Map<String, Object> row : waiting) {
dispatchCursor = number(row, "id");
try {
if (deliveryDispatcher == null) {
tasks.dispatch(dispatchCursor);
} else {
deliveryDispatcher.dispatch(dispatchCursor);
}
} catch (Exception ex) {
LOG.warn("租赁订单调度待重试 orderId={} diagnostic={}", dispatchCursor, RentalDiagnostics.describe(ex));
}
@@ -36,6 +36,8 @@ public class RentalBusinessTest {
private long wallet;
private long node;
private boolean proofAvailable = true;
private long verifiedResourceQuantity = 78000;
private long verificationBlockAgeSeconds = 5;
private boolean receiverActivated;
private boolean activationRpcFailed;
private int activationChecks;
@@ -696,7 +698,7 @@ public class RentalBusinessTest {
"block_height",
101,
"block_time",
now().minusSeconds(5),
now().minusSeconds(verificationBlockAgeSeconds),
"after_sun",
"DELEGATE".equals(text(task, "task_type"))
? task.get("delegate_sun")
@@ -706,7 +708,7 @@ public class RentalBusinessTest {
"verified_total_weight",
1000000,
"verified_resource_quantity",
78000,
verifiedResourceQuantity,
"delivery_proven",
proofAvailable);
}
@@ -1141,6 +1143,111 @@ public class RentalBusinessTest {
ADDRESS)));
}
@Test
public void orderAndTaskEventsArePublishedOnlyAfterCommit() throws Exception {
List<RentalDeliveryEvents> events = new ArrayList<>();
org.springframework.context.ApplicationEventPublisher publisher = event -> events.add((RentalDeliveryEvents) event);
injectPublisher(orders, publisher);
injectPublisher(tasks, publisher);
long orderId = tx.execute(status -> {
long id = number(create("AFTER-COMMIT"), "id");
assertTrue(events.isEmpty());
return id;
});
assertEquals(1, events.size());
assertTrue(events.get(0).order);
assertEquals(orderId, events.get(0).id);
tx.execute(status -> {
tasks.dispatch(orderId);
assertEquals(1, events.size());
return null;
});
assertEquals(2, events.size());
assertFalse(events.get(1).order);
assertEquals(node, events.get(1).id);
}
@Test
public void rolledBackOrderDoesNotScheduleDelivery() throws Exception {
List<Object> events = new ArrayList<>();
injectPublisher(orders, events::add);
tx.execute(status -> {
create("ROLLBACK-DELIVERY");
status.setRollbackOnly();
return null;
});
assertTrue(events.isEmpty());
assertNull(store.one("SELECT id FROM rent_order WHERE merchant_order_no='ROLLBACK-DELIVERY'"));
}
@Test
public void committedOrderDispatchesOnIndependentDeliveryWorker() throws Exception {
org.springframework.beans.factory.support.DefaultListableBeanFactory factory =
new org.springframework.beans.factory.support.DefaultListableBeanFactory();
RentalSocket socket = new RentalSocket(store, identity, tasks, json);
factory.registerSingleton("tasks", tasks);
factory.registerSingleton("socket", socket);
RentalDeliveryDispatcher dispatcher = new RentalDeliveryDispatcher(
factory.getBeanProvider(RentalTasks.class), factory.getBeanProvider(RentalSocket.class));
dispatcher.start();
CountDownLatch taskCommitted = new CountDownLatch(1);
java.util.concurrent.atomic.AtomicReference<String> dispatchThread = new java.util.concurrent.atomic.AtomicReference<>();
injectPublisher(orders, event -> dispatcher.receive((RentalDeliveryEvents) event));
injectPublisher(tasks, event -> {
dispatchThread.set(Thread.currentThread().getName());
taskCommitted.countDown();
});
try {
long id = number(create("IMMEDIATE-DISPATCH"), "id");
assertTrue(taskCommitted.await(5, TimeUnit.SECONDS));
assertTrue(dispatchThread.get().startsWith("rental-delivery-"));
assertNotNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id));
} finally {
dispatcher.close();
}
}
private void injectPublisher(Object target, org.springframework.context.ApplicationEventPublisher publisher)
throws Exception {
java.lang.reflect.Field field = target.getClass().getDeclaredField("deliveryEvents");
field.setAccessible(true);
field.set(target, publisher);
}
@Test
public void historyCleanupReadsRealBusinessSchemaAndKeepsFunds() throws Exception {
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String statement : ddl.split(";")) {
if (!statement.trim().isEmpty()) { store.execute(statement); }
}
// 此测试的完整业务DDL来自setup;清理器只能读业务状态,不能改动账户/流水。
store.execute("CREATE ALIAS IF NOT EXISTS UTC_TIMESTAMP FOR \"com.ruoyi.system.rental.RentalHistoryTest.utcTimestamp\"");
Map<String, Object> oldAccount = new LinkedHashMap<>(store.get("account", payer, false));
Map<String, Object> order = create("CLEANUP-PRESERVE-FUNDS");
Map<String, Object> heldAccount = new LinkedHashMap<>(store.get("account", payer, false));
store.execute("INSERT INTO rent_history_cursor (network,scanned_height,scanned_block_id,updated_at)"
+ " VALUES ('NILE',30000,?,?)", String.format("%064x", 30000), now());
store.execute("INSERT INTO rent_history_block (network,block_height,block_id,parent_id,block_time,"
+ "events_complete,created_at) VALUES ('NILE',100,?,?,?,1,?)", String.format("%064x", 100),
String.format("%064x", 99), System.currentTimeMillis() - 45L * 86400000,
now().minusDays(45));
java.nio.file.Path directory = Files.createTempDirectory("rental-history-cleanup-business-");
RentalHistoryCleaner cleaner = new RentalHistoryCleaner(store, json, new RentalHistoryArchive(json), tx.getTransactionManager());
java.lang.reflect.Field archiveDirectory = RentalHistoryCleaner.class.getDeclaredField("archiveDirectory");
archiveDirectory.setAccessible(true);
archiveDirectory.set(cleaner, directory.toString());
assertEquals(1, cleaner.clean("NILE"));
assertEquals(heldAccount, store.get("account", payer, false));
assertEquals("HELD", text(store.get("order", number(order, "id"), false), "fund_status"));
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE order_id=?", order.get("id")).size());
assertTrue(amount(oldAccount, "available_amount").compareTo(amount(heldAccount, "available_amount")) > 0);
// 只删除本测试创建的临时归档文件,不访问部署归档目录。
for (java.io.File file : directory.toFile().listFiles()) { Files.delete(file.toPath()); }
Files.delete(directory);
}
private void expectFailure(Runnable action) {
try {
action.run();
@@ -1296,7 +1403,15 @@ public class RentalBusinessTest {
tasks.dispatch(deliveryOrder);
RentalWorkers workers = new RentalWorkers(store, tasks, socket, identity);
workers.validateDeliveryIntervals();
workers.pushTasks();
ExecutorService competingPushes = Executors.newFixedThreadPool(2);
try {
Future<?> immediate = competingPushes.submit(() -> socket.push(node));
Future<?> periodic = competingPushes.submit(workers::pushTasks);
immediate.get(5, TimeUnit.SECONDS);
periodic.get(5, TimeUnit.SECONDS);
} finally {
competingPushes.shutdownNow();
}
Map<String, Object> delivered = store.one("SELECT * FROM rent_task WHERE order_id=?", deliveryOrder);
assertNotNull(delivered);
assertEquals(1, number(delivered, "delivery_count"));
@@ -1792,6 +1907,16 @@ public class RentalBusinessTest {
Map<String, Object> order = store.get("order", id, false);
assertEquals("MANUAL_REVIEW", text(order, "status"));
assertEquals("HELD", text(order, "fund_status"));
Map<String, Object> diagnostic = store.one("SELECT * FROM rent_event WHERE object_type='ORDER'"
+ " AND object_id=? AND action='DELIVERY_REVIEW'", id);
assertTrue(text(diagnostic, "reason").contains("缺少完整历史履约证明"));
List<Map<String, Object>> visible = new RentalQueries(store).list("order", 10L, 1);
assertEquals(text(diagnostic, "reason"), text(visible.get(0), "fulfillment_reason"));
assertFalse(visible.get(0).containsKey("review_evidence"));
assertTrue(new RentalQueries(store).list("order", 999L, 1).isEmpty());
store.execute("DELETE FROM rent_event WHERE id=?", diagnostic.get("id"));
assertTrue(text(new RentalQueries(store).list("order", 10L, 1).get(0), "fulfillment_reason")
.contains("缺少完整历史履约证明"));
expectFailure(() -> tasks.resolveRecovered(id, 99, "not recovered"));
store.update("order", id, map("next_reclaim_at", after(-1)));
tasks.reclaim(id);
@@ -1815,6 +1940,31 @@ public class RentalBusinessTest {
assertEquals("FAILED", text(store.get("order", id, false), "status"));
}
@Test
public void insufficientQuantityAndExpiredLeaseAreBothRecordedWithoutCharging() {
verifiedResourceQuantity = 1;
verificationBlockAgeSeconds = 100000;
long id = confirmed("INSUFFICIENT-EXPIRED");
Map<String, Object> order = store.get("order", id, false);
assertEquals("MANUAL_REVIEW", text(order, "status"));
assertEquals("HELD", text(order, "fund_status"));
String reason = text(new RentalQueries(store).list("order", null, 1).get(0), "fulfillment_reason");
assertTrue(reason.contains("实际核验资源数量不足"));
assertTrue(reason.contains("核验完成时租期已结束"));
assertFalse(reason.contains("缺少完整历史履约证明"));
}
@Test
public void fulfillmentDiagnosticsRespectBoundaryAndDoNotGuessMissingProofQuantity() {
java.time.Instant expiry = java.time.Instant.parse("2026-10-31T12:00:00Z");
assertEquals("", RentalDeliveryDiagnostics.explain(true, 18L, 18, expiry, expiry.minusMillis(1)));
assertTrue(RentalDeliveryDiagnostics.explain(true, 18L, 18, expiry, expiry).contains("租期已结束"));
assertTrue(RentalDeliveryDiagnostics.explain(false, null, 18, expiry, expiry.minusMillis(1))
.contains("缺少完整历史履约证明"));
assertFalse(RentalDeliveryDiagnostics.explain(false, null, 18, expiry, expiry.minusMillis(1))
.contains("实际核验资源数量不足"));
}
@Test
public void merchantAndSupplierSameAccountNoDoubleLockOrWrongBalance() {
store.update("node", node, map("user_id", 10));
@@ -0,0 +1,440 @@
package com.ruoyi.system.rental;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.h2.jdbcx.JdbcDataSource;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.*;
import static com.ruoyi.system.rental.RentalValues.*;
import static org.junit.Assert.*;
/** 真实历史DDL、H2事务/行锁和临时归档目录;业务表为只读查询所需的受控投影,不接触项目数据库。 */
public class RentalHistoryCleanupTest {
private static final String OWNER = "TMVQGm1qAQYVdetCeGRRkTWYYrLXuHK2HC";
private static final String RECEIVER = "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf";
@Rule public TemporaryFolder temporary = new TemporaryFolder();
private final ObjectMapper json = new ObjectMapper();
private RentalStore store;
private DataSourceTransactionManager manager;
private RentalHistoryCleaner cleaner;
private Path archives;
private LocalDateTime old;
@Before
public void setup() throws Exception {
JdbcDataSource source = new JdbcDataSource();
source.setURL("jdbc:h2:mem:" + UUID.randomUUID()
+ ";MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000");
JdbcTemplate jdbc = new JdbcTemplate(source);
jdbc.execute("CREATE ALIAS UTC_TIMESTAMP FOR \"com.ruoyi.system.rental.RentalHistoryTest.utcTimestamp\"");
store = new RentalStore(jdbc);
manager = new DataSourceTransactionManager(source);
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String statement : ddl.split(";")) {
if (!statement.trim().isEmpty()) { jdbc.execute(statement); }
}
jdbc.execute("CREATE TABLE rent_order (id BIGINT PRIMARY KEY,network VARCHAR(16),resource_type VARCHAR(16),"
+ "status VARCHAR(32),wallet_id BIGINT,fund_status VARCHAR(16),relation_slot INT,"
+ "reclaim_status VARCHAR(24),service_expires_at TIMESTAMP,updated_at TIMESTAMP)");
jdbc.execute("CREATE TABLE rent_task (id BIGINT PRIMARY KEY,order_id BIGINT,network VARCHAR(16),"
+ "resource_type VARCHAR(16),intent LONGTEXT,status VARCHAR(32),wallet_execution_slot INT,"
+ "reservation_status VARCHAR(16),updated_at TIMESTAMP)");
jdbc.execute("CREATE TABLE rent_transaction (id BIGINT PRIMARY KEY,task_id BIGINT,block_height BIGINT,"
+ "status VARCHAR(32),updated_at TIMESTAMP)");
jdbc.execute("CREATE TABLE rent_ledger (id BIGINT PRIMARY KEY,amount DECIMAL(30,6))");
store.execute("INSERT INTO rent_ledger VALUES (1,123.456789)");
archives = temporary.newFolder("archives").toPath();
old = now().minusDays(45);
store.execute("INSERT INTO rent_history_cursor (network,scanned_height,scanned_block_id,updated_at)"
+ " VALUES ('NILE',30000,?,?)", hash(30000), now());
block("NILE", 100, old, old, 1);
block("NILE", 30000, now(), now(), 1);
cleaner = cleaner(new RentalHistoryArchive(json));
}
private RentalHistoryCleaner cleaner(RentalHistoryArchive archive) throws Exception {
RentalHistoryCleaner value = new RentalHistoryCleaner(store, json, archive, manager);
field(value, "archiveDirectory", archives.toString());
return value;
}
private static void field(Object target, String name, Object value) throws Exception {
java.lang.reflect.Field field = target.getClass().getDeclaredField(name);
field.setAccessible(true);
field.set(target, value);
}
private static String hash(long height) { return String.format("%064x", height); }
private void block(String network, long height, LocalDateTime chainTime, LocalDateTime stored, int complete) {
store.execute("INSERT INTO rent_history_block (network,block_height,block_id,parent_id,block_time,"
+ "events_complete,created_at) VALUES (?,?,?,?,?,?,?)", network, height, hash(height),
hash(height - 1), chainTime.toInstant(ZoneOffset.UTC).toEpochMilli(), complete, stored);
}
private void anchor(long height) {
store.execute("INSERT INTO rent_history_anchor VALUES ('NILE',?,?,'ENERGY',?,?,0,?)",
RentalHistoryService.addressHex(OWNER), RentalHistoryService.addressHex(RECEIVER), height, hash(height), old);
}
private void event(long height, long tx, int index) {
store.execute("INSERT INTO rent_history_event VALUES ('NILE',?,?,?,?,?,'ENERGY','DELEGATE',1000000,0,?)",
hash(tx), height, index, RentalHistoryService.addressHex(OWNER),
RentalHistoryService.addressHex(RECEIVER), old);
}
private void task(boolean closed) throws Exception {
store.execute("INSERT INTO rent_order VALUES (1,'NILE','ENERGY',?,1,?,NULL,?, ?,?)",
closed ? "SUCCESS" : "MANUAL_REVIEW", closed ? "CHARGED" : "HELD",
closed ? "DONE" : "MANUAL_REVIEW", old, old);
store.execute("INSERT INTO rent_task VALUES (1,1,'NILE','ENERGY',?,'VERIFIED',NULL,'COMMITTED',?)",
json.writeValueAsString(map("owner", OWNER, "receiver", RECEIVER)), old);
store.execute("INSERT INTO rent_transaction VALUES (1,1,101,'CONFIRMED',?)", old);
}
private long count(String table) { return number(store.one("SELECT COUNT(*) AS n FROM " + table), "n"); }
private void fails(Runnable action) {
try { action.run(); fail("must abort deletion"); }
catch (IllegalStateException | IllegalArgumentException expected) { }
}
@Test
public void expiredFactsAreArchivedBeforeDeletionAndCursorIsKept() throws Exception {
anchor(100);
event(100, 1001, 0);
assertEquals(3, cleaner.clean("NILE"));
assertNull(store.one("SELECT * FROM rent_history_block WHERE block_height=100"));
assertEquals(0, count("rent_history_event"));
assertEquals(0, count("rent_history_anchor"));
assertEquals(30000, number(store.one("SELECT * FROM rent_history_cursor"), "scanned_height"));
assertNull(store.one("SELECT * FROM rent_history_cursor").get("cleanup_owner"));
long archivedEvents = 0, archivedBlocks = 0, archivedAnchors = 0;
for (java.io.File file : archives.toFile().listFiles()) {
byte[] bytes = Files.readAllBytes(file.toPath());
String digest = javax.xml.bind.DatatypeConverter.printHexBinary(
java.security.MessageDigest.getInstance("SHA-256").digest(bytes)).toLowerCase();
assertTrue(file.getName().endsWith(digest + ".json"));
JsonNode data = json.readTree(bytes);
assertEquals("RENT_HISTORY_ARCHIVE_V1", data.path("format").asText());
archivedEvents += data.path("events").size();
archivedBlocks += data.path("blocks").size();
archivedAnchors += data.path("anchors").size();
}
assertEquals(1, archivedEvents);
assertEquals(1, archivedBlocks);
assertEquals(1, archivedAnchors);
assertEquals(0, cleaner.clean("NILE"));
assertEquals(1, count("rent_ledger"));
}
@Test
public void liveManualOrderPinsItsOldBaselineAndEntireReplayRange() throws Exception {
anchor(100);
block("NILE", 101, old, old, 1);
event(101, 1001, 0);
task(false);
assertEquals(0, cleaner.clean("NILE"));
assertEquals(1, count("rent_history_anchor"));
assertEquals(1, count("rent_history_event"));
assertEquals(3, count("rent_history_block"));
assertEquals("HELD", text(store.one("SELECT * FROM rent_order"), "fund_status"));
assertEquals(1, count("rent_task"));
assertEquals(1, count("rent_transaction"));
}
@Test
public void oldClosedOrderDoesNotPreventCleanupButBusinessRecordsRemain() throws Exception {
anchor(100);
task(true);
assertEquals(2, cleaner.clean("NILE"));
assertEquals(1, count("rent_order"));
assertEquals(1, count("rent_task"));
assertEquals(1, count("rent_transaction"));
assertEquals(1, count("rent_ledger"));
}
@Test
public void recentClosedOrderStillKeepsItsAuditEvidence() throws Exception {
anchor(100);
task(true);
store.execute("UPDATE rent_order SET updated_at=?", now());
assertEquals(0, cleaner.clean("NILE"));
assertEquals(1, count("rent_history_anchor"));
}
@Test
public void unknownTransactionWithoutHeightCannotBeTimedOutByCleaner() throws Exception {
anchor(100);
task(true);
store.execute("UPDATE rent_task SET status='UNKNOWN'");
store.execute("UPDATE rent_transaction SET status='UNKNOWN',block_height=NULL");
assertEquals(0, cleaner.clean("NILE"));
assertEquals("UNKNOWN", text(store.one("SELECT * FROM rent_task"), "status"));
}
@Test
public void heldFundsOutstandingRelationAndReclaimEachKeepEvidence() throws Exception {
anchor(100);
task(true);
store.execute("UPDATE rent_order SET fund_status='HELD'");
assertEquals(0, cleaner.clean("NILE"));
store.execute("UPDATE rent_order SET fund_status='CHARGED',relation_slot=1");
assertEquals(0, cleaner.clean("NILE"));
store.execute("UPDATE rent_order SET relation_slot=NULL,reclaim_status='RECOVERING'");
assertEquals(0, cleaner.clean("NILE"));
store.execute("UPDATE rent_order SET reclaim_status='DONE',service_expires_at=?", after(60));
assertEquals(0, cleaner.clean("NILE"));
assertEquals(1, count("rent_history_anchor"));
}
@Test
public void orphanOrMismatchedTaskStopsCleanup() throws Exception {
anchor(100);
task(false);
store.execute("DELETE FROM rent_order");
assertEquals(0, cleaner.clean("NILE"));
store.execute("INSERT INTO rent_order VALUES (1,'MAINNET','ENERGY','MANUAL_REVIEW',1,'HELD',1,'WAITING',?,?)", old, old);
assertEquals(0, cleaner.clean("NILE"));
assertEquals(1, count("rent_history_anchor"));
}
@Test
public void selectedWalletWithoutTaskStopsCleanup() throws Exception {
task(false);
store.execute("DELETE FROM rent_transaction");
store.execute("DELETE FROM rent_task");
assertEquals(0, cleaner.clean("NILE"));
assertEquals(2, count("rent_history_block"));
}
@Test
public void multipleAttemptsReuseOneProtectedPair() throws Exception {
anchor(100);
task(false);
for (int i = 2; i <= 120; i++) {
store.execute("INSERT INTO rent_task SELECT ?,order_id,network,resource_type,intent,'REJECTED',"
+ "NULL,'RELEASED',updated_at FROM rent_task WHERE id=1", i);
}
assertEquals(0, cleaner.clean("NILE"));
assertEquals(120, count("rent_task"));
}
@Test
public void protectedRelationsAreReadAcrossMultipleLookupBatches() throws Exception {
block("NILE", 5, old, old, 1);
block("NILE", 50, old, old, 1);
for (int i = 1; i <= 105; i++) {
byte[] address = new byte[21];
address[0] = 0x41;
address[20] = (byte) i;
String receiver = org.tron.trident.utils.Base58Check.bytesToBase58(address);
long baseline = i == 105 ? 10 : 50 + i;
store.execute("INSERT INTO rent_order VALUES (?,'NILE','ENERGY','MANUAL_REVIEW',1,'HELD',1,'WAITING',?,?)", i, old, old);
store.execute("INSERT INTO rent_task VALUES (?,?,'NILE','ENERGY',?,'VERIFIED',NULL,'COMMITTED',?)",
i, i, json.writeValueAsString(map("owner", OWNER, "receiver", receiver)), old);
store.execute("INSERT INTO rent_history_anchor VALUES ('NILE',?,?,'ENERGY',?,?,0,?)",
RentalHistoryService.addressHex(OWNER), RentalHistoryService.addressHex(receiver), baseline, hash(baseline), old);
}
assertEquals(1, cleaner.clean("NILE"));
assertNotNull(store.one("SELECT * FROM rent_history_block WHERE block_height=50"));
assertEquals(105, count("rent_history_anchor"));
}
@Test
public void missingOrMalformedBaselineStopsDeletion() throws Exception {
task(false);
assertEquals(0, cleaner.clean("NILE"));
anchor(100);
store.execute("UPDATE rent_task SET intent='not-json'");
assertEquals(0, cleaner.clean("NILE"));
assertNotNull(store.one("SELECT * FROM rent_history_block WHERE block_height=100"));
}
@Test
public void replayWindowRecentBackfillAndIncompleteBlocksStay() {
block("NILE", 20001, old, old, 1);
block("NILE", 101, old, now(), 1);
block("NILE", 102, now(), old, 1);
block("NILE", 103, old, old, 0);
assertEquals(1, cleaner.clean("NILE"));
assertEquals(5, count("rent_history_block"));
}
@Test
public void cleanupIsNetworkIsolated() {
block("MAINNET", 99, old, old, 1);
assertEquals(1, cleaner.clean("NILE"));
assertNotNull(store.one("SELECT * FROM rent_history_block WHERE network='MAINNET'"));
}
@Test
public void cleanupLeaseBlocksOtherCleanerAndExpiredLeaseCanBeTakenOver() {
store.execute("UPDATE rent_history_cursor SET cleanup_owner='other',cleanup_until=?", after(60));
assertEquals(0, cleaner.clean("NILE"));
assertEquals(0, archives.toFile().listFiles().length);
store.execute("UPDATE rent_history_cursor SET cleanup_until=?", after(-1));
assertEquals(1, cleaner.clean("NILE"));
}
@Test
public void scannerLeaseIsNotStolenByCleanup() {
store.execute("UPDATE rent_history_cursor SET lease_owner='scanner',lease_until=?", after(60));
assertEquals(1, cleaner.clean("NILE"));
assertEquals("scanner", text(store.one("SELECT * FROM rent_history_cursor"), "lease_owner"));
assertNull(store.one("SELECT * FROM rent_history_cursor").get("cleanup_owner"));
}
@Test
public void archiveFailureRollsBackAndReleasesLease() throws Exception {
RentalHistoryCleaner broken = cleaner(new RentalHistoryArchive(json) {
@Override public String save(Path path, Map<String, Object> batch) {
throw new IllegalStateException("controlled disk failure");
}
});
fails(() -> broken.clean("NILE"));
assertEquals(2, count("rent_history_block"));
assertNull(store.one("SELECT * FROM rent_history_cursor").get("cleanup_owner"));
assertEquals(1, cleaner.clean("NILE"));
}
@Test
public void realUnwritableArchiveLocationPreventsDeletion() throws Exception {
field(cleaner, "archiveDirectory", temporary.newFile("not-a-directory").getAbsolutePath());
fails(() -> cleaner.clean("NILE"));
assertEquals(2, count("rent_history_block"));
assertNull(store.one("SELECT * FROM rent_history_cursor").get("cleanup_owner"));
}
@Test
public void databaseFailureAfterArchiveRollsBackWholeBatch() throws Exception {
block("NILE", 99, old, old, 1);
event(100, 1001, 0);
anchor(100);
RentalStore failing = new RentalStore(new JdbcTemplate(manager.getDataSource())) {
@Override public int execute(String sql, Object... args) {
if (sql.startsWith("DELETE FROM rent_history_block")) {
throw new IllegalStateException("controlled SQL deletion failure");
}
return super.execute(sql, args);
}
};
RentalHistoryCleaner broken = new RentalHistoryCleaner(failing, json, new RentalHistoryArchive(json), manager);
field(broken, "archiveDirectory", archives.toString());
fails(() -> broken.clean("NILE"));
assertEquals(1, count("rent_history_event"));
assertEquals(1, count("rent_history_anchor"));
assertEquals(3, count("rent_history_block"));
assertEquals(1, archives.toFile().listFiles().length);
assertEquals(4, cleaner.clean("NILE"));
}
@Test
public void leaseExpiryDuringArchivePreventsDeletion() throws Exception {
RentalHistoryCleaner expired = cleaner(new RentalHistoryArchive(json) {
@Override public String save(Path path, Map<String, Object> batch) {
String result = super.save(path, batch);
store.execute("UPDATE rent_history_cursor SET cleanup_until=?", after(-1));
return result;
}
});
fails(() -> expired.clean("NILE"));
assertEquals(2, count("rent_history_block"));
assertTrue(archives.toFile().listFiles().length > 0);
}
@Test
public void boundedEventBatchNeverPartiallyDeletesItsBlock() throws Exception {
for (int i = 0; i < 3; i++) { event(100, 1001 + i, i); }
field(cleaner, "batchSize", 1);
field(cleaner, "maxBatches", 1);
assertEquals(1, cleaner.clean("NILE"));
assertEquals(2, count("rent_history_event"));
assertNotNull(store.one("SELECT * FROM rent_history_block WHERE block_height=100"));
field(cleaner, "maxBatches", 10);
assertEquals(3, cleaner.clean("NILE"));
}
@Test
public void pendingAndConflictingSamplesAreNotAgeDeleted() {
store.execute("UPDATE rent_history_block SET energy_limit=10,energy_weight=2,bandwidth_limit=30,"
+ "bandwidth_weight=4,parameters_at=? WHERE block_height=100", old);
store.execute("INSERT INTO rent_history_sample VALUES ('NILE',100,?,10,2,30,4,?)", hash(100), old);
store.execute("INSERT INTO rent_history_sample VALUES ('NILE',40000,?,10,2,30,4,?)", hash(40000), old);
block("NILE", 101, old, old, 1);
store.execute("INSERT INTO rent_history_sample VALUES ('NILE',101,?,10,2,30,4,?)", hash(999), old);
assertEquals(2, cleaner.clean("NILE"));
assertEquals(2, count("rent_history_sample"));
assertNotNull(store.one("SELECT * FROM rent_history_block WHERE block_height=101"));
}
@Test
public void disabledCleanerPerformsNoArchiveOrDeletion() throws Exception {
field(cleaner, "enabled", false);
assertEquals(0, cleaner.clean("NILE"));
assertEquals(2, count("rent_history_block"));
assertEquals(0, archives.toFile().listFiles().length);
}
@Test
public void proofAndSecondCleanerWaitForSameDatabaseGuard() throws Exception {
anchor(100);
block("NILE", 50, old, old, 1);
block("NILE", 101, old, old, 1);
event(101, 1001, 0);
task(false);
store.execute("UPDATE rent_history_block SET energy_limit=60000000,energy_weight=1000000,"
+ "bandwidth_limit=1500000,bandwidth_weight=1000000,parameters_at=? WHERE block_height=101", old);
CountDownLatch archiving = new CountDownLatch(1), release = new CountDownLatch(1);
RentalHistoryCleaner slow = cleaner(new RentalHistoryArchive(json) {
@Override public String save(Path path, Map<String, Object> batch) {
archiving.countDown();
try { assertTrue(release.await(5, TimeUnit.SECONDS)); }
catch (InterruptedException ex) { Thread.currentThread().interrupt(); throw new IllegalStateException(ex); }
return super.save(path, batch);
}
});
RentalChain chain = new RentalChain(json) {
@Override public JsonNode call(String network, String path, Map<String, Object> body) {
assertFalse("RPC must run outside history lock transaction", TransactionSynchronizationManager.isActualTransactionActive());
long height = path.endsWith("getnowblock") ? 30000 : number(body, "num");
return json.valueToTree(map("blockID", hash(height), "block_header",
map("raw_data", map("number", height))));
}
};
RentalHistoryService history = new RentalHistoryService(store, chain, manager);
ExecutorService pool = Executors.newFixedThreadPool(3);
try {
Future<Integer> cleaning = pool.submit(() -> slow.clean("NILE"));
assertTrue(archiving.await(5, TimeUnit.SECONDS));
Future<Map<String, Object>> proof = pool.submit(() -> history.proof("NILE", hash(1001), 101, OWNER, RECEIVER, "ENERGY"));
Future<Integer> competing = pool.submit(() -> cleaner.clean("NILE"));
try { proof.get(100, TimeUnit.MILLISECONDS); fail("proof should wait for cursor lock"); }
catch (TimeoutException expected) { }
release.countDown();
assertEquals(1, cleaning.get(5, TimeUnit.SECONDS).intValue());
assertNotNull(proof.get(5, TimeUnit.SECONDS));
assertEquals(0, competing.get(5, TimeUnit.SECONDS).intValue());
assertEquals(1, archives.toFile().listFiles().length);
} finally {
release.countDown();
pool.shutdownNow();
}
}
}
@@ -25,20 +25,25 @@ public class RentalHistoryTest {
private final ObjectMapper json = new ObjectMapper();
private final Map<Long, JsonNode> blocks = new HashMap<>();
private RentalStore store;
private javax.sql.DataSource storeDataSource;
private RentalHistoryService service;
private RentalChain chain;
private long currentHead;
private long relation;
private long lockedRelation;
private boolean malformedRelation;
private long energyLimit = 60000000;
private int changingHeads;
private boolean invalidParameters;
private boolean rpcFailure;
private JsonNode principalResponse;
private int calls;
private long confirmationLag;
@Before
public void setup() throws Exception {
JdbcDataSource source = new JdbcDataSource();
storeDataSource = source;
source.setURL("jdbc:h2:mem:" + UUID.randomUUID()
+ ";MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000");
JdbcTemplate jdbc = new JdbcTemplate(source);
@@ -73,9 +78,13 @@ public class RentalHistoryTest {
: map("TotalEnergyLimit", energyLimit, "TotalEnergyWeight", 1000000,
"TotalNetLimit", 1500000, "TotalNetWeight", 1000000));
}
if (path.equals("/wallet/getdelegatedresourcev2")) {
return json.valueToTree(Boolean.TRUE.equals(body.get("lock")) ? map()
: map("delegatedResource", Arrays.asList(map("frozen_balance_for_energy", relation))));
if (path.endsWith("getcandelegatedmaxsize")) {
return principalResponse == null ? json.createObjectNode() : principalResponse;
}
if (path.endsWith("/getdelegatedresourcev2")) {
return json.valueToTree(malformedRelation ? map("message", "controlled failure")
: map("delegatedResource", Arrays.asList(map("frozen_balance_for_energy",
Boolean.TRUE.equals(body.get("lock")) ? lockedRelation : relation))));
}
if (path.endsWith("getblockbynum")) {
return block(number(body, "num"));
@@ -102,6 +111,7 @@ public class RentalHistoryTest {
service = new RentalHistoryService(store, rpc, new DataSourceTransactionManager(source));
chain = rpc;
setField(service, "confirmations", 1L);
setField(service, "parameterGraceSeconds", 0L);
currentHead = 100;
}
@@ -142,6 +152,8 @@ public class RentalHistoryTest {
private void collect(long height) {
currentHead = height;
service.sample("NILE");
service.confirmSamples("NILE");
service.collect("NILE");
}
@@ -150,6 +162,7 @@ public class RentalHistoryTest {
}
private void anchor() {
service.sample("NILE");
service.anchor("NILE", OWNER, RECEIVER, "ENERGY");
}
@@ -163,26 +176,26 @@ public class RentalHistoryTest {
}
@Test
public void fullNodeSamplesWaitForConfirmationWithoutRelabelingParameters() {
public void confirmedBaselineDoesNotWaitForFullNodeSamples() {
confirmationLag = 2;
rejects(this::anchor);
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_anchor"), "n"));
anchor();
assertEquals(98, number(store.one("SELECT * FROM rent_history_anchor"), "block_height"));
assertNull(store.one("SELECT * FROM rent_history_block WHERE block_height=98").get("parameters_at"));
service.sample("NILE");
currentHead = 101;
energyLimit = 90000000;
rejects(this::anchor);
service.sample("NILE");
currentHead = 102;
anchor();
Map<String, Object> saved = store.one("SELECT * FROM rent_history_anchor");
assertEquals(100, number(saved, "block_height"));
service.confirmSamples("NILE");
assertEquals(60000000, number(store.one("SELECT * FROM rent_history_block WHERE block_height=100"), "energy_limit"));
}
@Test
public void collectionKeepsSamplingWhileWaitingAndArchivesOriginalHeight() {
confirmationLag = 2;
rejects(() -> collect(100));
collect(100);
energyLimit = 90000000;
rejects(() -> collect(101));
collect(101);
collect(102);
assertEquals(100, number(service.status().get(0), "scanned_height"));
assertEquals(60000000, number(store.one("SELECT * FROM rent_history_block WHERE block_height=100"), "energy_limit"));
@@ -194,11 +207,12 @@ public class RentalHistoryTest {
@Test
public void forkedUnconfirmedSampleCannotBecomeEvidence() {
confirmationLag = 2;
rejects(this::anchor);
service.sample("NILE");
((ObjectNode) block(100)).put("blockID", hash(999));
currentHead = 102;
rejects(this::anchor);
service.confirmSamples("NILE");
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_anchor"), "n"));
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_block"), "n"));
}
@Test
@@ -224,6 +238,7 @@ public class RentalHistoryTest {
transactions(101, event(1001, "DelegateResourceContract", "ENERGY", SUN));
collect(102);
assertNull(proof(1001, 101));
assertEquals("PARAMETERS_MISSING", service.missingProofCode("NILE", 101, OWNER, RECEIVER, "ENERGY"));
assertEquals(1, number(service.status().get(0), "parameter_gap_count"));
}
@@ -233,6 +248,7 @@ public class RentalHistoryTest {
transactions(101, event(1001, "DelegateResourceContract", "ENERGY", SUN));
collect(101);
assertNull(proof(1001, 101));
assertEquals("BASELINE_MISSING", service.missingProofCode("NILE", 101, OWNER, RECEIVER, "ENERGY"));
}
@Test
@@ -297,15 +313,16 @@ public class RentalHistoryTest {
@Test
public void movingConfirmedHeadDoesNotWriteAnAnchor() {
service.sample("NILE");
changingHeads = 6;
rejects(this::anchor);
rejects(() -> service.anchor("NILE", OWNER, RECEIVER, "ENERGY"));
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_anchor"), "n"));
}
@Test
public void invalidParametersCannotBeStored() {
invalidParameters = true;
rejects(this::anchor);
rejects(() -> service.sample("NILE"));
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_block"), "n"));
}
@@ -334,6 +351,7 @@ public class RentalHistoryTest {
@Test
public void bandwidthUsesOwnHistoricalParameters() {
service.sample("NILE");
service.anchor("NILE", OWNER, RECEIVER, "BANDWIDTH");
transactions(101, event(1001, "DelegateResourceContract", "BANDWIDTH", SUN));
collect(101);
@@ -396,7 +414,8 @@ public class RentalHistoryTest {
store.execute("UPDATE rent_history_cursor SET lease_owner='other',"
+ "lease_until=TIMESTAMPADD(SECOND,60,UTC_TIMESTAMP(3)) WHERE network='NILE'");
int before = calls;
collect(101);
currentHead = 101;
service.collect("NILE");
assertEquals(before, calls);
}
@@ -404,7 +423,8 @@ public class RentalHistoryTest {
public void rpcFailureReleasesLeaseAndDoesNotAdvanceCursor() {
collect(100);
rpcFailure = true;
rejects(() -> collect(101));
currentHead = 101;
rejects(() -> service.collect("NILE"));
Map<String, Object> status = store.one("SELECT * FROM rent_history_cursor WHERE network='NILE'");
assertEquals(100, number(status, "scanned_height"));
assertNull(status.get("lease_owner"));
@@ -428,7 +448,122 @@ public class RentalHistoryTest {
assertEquals(0, calls);
}
@Test
public void scannerContinuesWhenResourceSamplingFails() {
collect(100);
invalidParameters = true;
currentHead = 101;
rejects(() -> service.sample("NILE"));
service.collect("NILE");
assertEquals(101, number(service.status().get(0), "scanned_height"));
assertNull(store.one("SELECT * FROM rent_history_block WHERE block_height=101").get("parameters_at"));
}
@Test
public void pendingSamplesSurviveServiceRestart() {
confirmationLag = 2;
service.sample("NILE");
service = new RentalHistoryService(store, chain, transactionManager());
currentHead = 102;
energyLimit = 90000000;
service.confirmSamples("NILE");
assertEquals(60000000, number(store.one("SELECT * FROM rent_history_block WHERE block_height=100"), "energy_limit"));
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_sample"), "n"));
}
private DataSourceTransactionManager transactionManager() {
// 重新创建服务对象模拟进程内存全部丢失,数据库及已采参数保持不变。
return new DataSourceTransactionManager(storeDataSource);
}
@Test
public void baselineReusesContinuousReplayWithoutRelationshipRpc() {
anchor();
collect(100);
transactions(101, event(1001, "DelegateResourceContract", "ENERGY", 1000000));
collect(101);
transactions(102, event(1002, "UnDelegateResourceContract", "ENERGY", 1000000));
collect(102);
int before = calls;
service.anchor("NILE", OWNER, RECEIVER, "ENERGY");
assertEquals(before, calls);
assertNotNull(store.one("SELECT * FROM rent_history_anchor WHERE block_height=102"));
}
@Test
public void baselineReuseRejectsOutstandingDelegation() {
anchor();
collect(100);
transactions(101, event(1001, "DelegateResourceContract", "ENERGY", 1000000));
collect(101);
int before = calls;
rejects(() -> service.anchor("NILE", OWNER, RECEIVER, "ENERGY"));
assertEquals(before, calls);
}
@Test
public void parameterPromotionBacklogIsRetryableWithinGrace() throws Exception {
anchor();
collect(100);
transactions(101, event(1001, "DelegateResourceContract", "ENERGY", SUN));
currentHead = 101;
service.sample("NILE");
service.collect("NILE");
setField(service, "parameterGraceSeconds", 120L);
rejects(() -> proof(1001, 101));
service.confirmSamples("NILE");
assertNotNull(proof(1001, 101));
}
@Test
public void staleOrAbsentGlobalSamplerPreventsNewBaseline() {
rejects(() -> service.anchor("NILE", OWNER, RECEIVER, "ENERGY"));
service.sample("NILE");
store.execute("UPDATE rent_history_sample SET created_at=?", after(-60));
rejects(() -> service.anchor("NILE", OWNER, RECEIVER, "ENERGY"));
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_anchor"), "n"));
}
@Test
public void latePromotionDoesNotMakeOldSamplingAppearFresh() {
service.sample("NILE");
store.execute("UPDATE rent_history_sample SET created_at=?", after(-60));
service.confirmSamples("NILE");
rejects(() -> service.anchor("NILE", OWNER, RECEIVER, "ENERGY"));
}
@Test
public void walletRefreshReusesFreshParametersAndAcceptsProtobufZeroPrincipal() throws Exception {
embeddedMode();
Map<String, Object> snapshot = chain.snapshot("NILE", OWNER);
assertEquals(0, number(snapshot, "bandwidth_delegatable_sun"));
assertEquals(0, number(snapshot, "energy_delegatable_sun"));
assertEquals(1, number(store.one("SELECT COUNT(*) AS n FROM rent_history_sample"), "n"));
assertEquals(100, number(store.one("SELECT * FROM rent_history_sample"), "block_height"));
}
@Test
public void walletPrincipalRpcErrorsCannotBecomeZeroBalance() {
principalResponse = json.valueToTree(map("code", "FAILED", "message", "controlled failure"));
rejects(() -> chain.snapshot("NILE", OWNER));
}
@Test
public void lockedConfirmedPrincipalAlsoPreventsBaseline() {
lockedRelation = 1;
rejects(this::anchor);
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_anchor"), "n"));
}
@Test
public void malformedConfirmedRelationCannotBecomeEmptyBaseline() {
malformedRelation = true;
rejects(this::anchor);
assertEquals(0, number(store.one("SELECT COUNT(*) AS n FROM rent_history_anchor"), "n"));
}
private void embeddedMode() throws Exception {
service.sample("NILE");
org.springframework.beans.factory.support.DefaultListableBeanFactory factory =
new org.springframework.beans.factory.support.DefaultListableBeanFactory();
factory.registerSingleton("history", service);
+29
View File
@@ -0,0 +1,29 @@
-- 已安装历史表的环境先执行本增量脚本,再部署清理器。MySQL 5.7+/8.0,可重复执行。
-- 只增加历史清理租约字段及基线清理索引,不删数据、不修改订单及资金表。
SET @rent_history_cleanup_sql = IF(
EXISTS(SELECT 1 FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=DATABASE()
AND TABLE_NAME='rent_history_cursor' AND COLUMN_NAME='cleanup_owner'),
'SELECT 1',
'ALTER TABLE rent_history_cursor ADD COLUMN cleanup_owner VARCHAR(64) NULL COMMENT ''清理器独立网络租约''');
PREPARE rent_history_cleanup_stmt FROM @rent_history_cleanup_sql;
EXECUTE rent_history_cleanup_stmt;
DEALLOCATE PREPARE rent_history_cleanup_stmt;
-- 按网络/高度分批选择旧检查点,避免清理每批都排序整个地址对基线表。
SET @rent_history_cleanup_sql = IF(
EXISTS(SELECT 1 FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=DATABASE()
AND TABLE_NAME='rent_history_anchor' AND INDEX_NAME='idx_history_anchor_retention'),
'SELECT 1',
'ALTER TABLE rent_history_anchor ADD INDEX idx_history_anchor_retention (network,block_height)');
PREPARE rent_history_cleanup_stmt FROM @rent_history_cleanup_sql;
EXECUTE rent_history_cleanup_stmt;
DEALLOCATE PREPARE rent_history_cleanup_stmt;
SET @rent_history_cleanup_sql = IF(
EXISTS(SELECT 1 FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=DATABASE()
AND TABLE_NAME='rent_history_cursor' AND COLUMN_NAME='cleanup_until'),
'SELECT 1',
'ALTER TABLE rent_history_cursor ADD COLUMN cleanup_until DATETIME(3) NULL COMMENT ''清理租约UTC截止''');
PREPARE rent_history_cleanup_stmt FROM @rent_history_cleanup_sql;
EXECUTE rent_history_cleanup_stmt;
DEALLOCATE PREPARE rent_history_cleanup_stmt;
+18 -2
View File
@@ -1,12 +1,27 @@
-- 租赁历史证明增量安装脚本;MySQL 5.7.8+/8.0。先执行rent_init.sql,再执行本文件。
-- 不删除、不修改既有16张业务表;四表均不保存私钥/API密钥。日期为UTC。
-- 不删除、不修改既有16张业务表;历史证据及待确认缓冲均不保存私钥/API密钥。日期为UTC。
-- 多实例共用network租约;确认区块和基线只追加,冲突必须告警,不覆盖历史事实。
-- 新版本增量升级可重复执行本文件;sample仅为待确认缓冲,不属于可用于结算的证据。
CREATE TABLE IF NOT EXISTS `rent_history_sample` (
`network` VARCHAR(16) NOT NULL,
`block_height` BIGINT NOT NULL,
`block_id` VARCHAR(64) NOT NULL,
`energy_limit` BIGINT NOT NULL,
`energy_weight` BIGINT NOT NULL,
`bandwidth_limit` BIGINT NOT NULL,
`bandwidth_weight` BIGINT NOT NULL,
`created_at` DATETIME(3) NOT NULL,
PRIMARY KEY (`network`,`block_height`)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='全局资源参数待确认缓冲,核对确认链后删除';
CREATE TABLE IF NOT EXISTS `rent_history_cursor` (
`network` VARCHAR(16) NOT NULL COMMENT 'NILE或MAINNET,独立采集游标',
`scanned_height` BIGINT NULL COMMENT '完整持久化交易事件的最后确认高度',
`scanned_block_id` VARCHAR(64) NULL COMMENT '游标对应区块哈希,连续性校验',
`lease_owner` VARCHAR(64) NULL COMMENT '采集实例租约令牌',
`lease_until` DATETIME(3) NULL COMMENT '数据库UTC租约截止',
`cleanup_owner` VARCHAR(64) NULL COMMENT '清理器独立网络租约,不占用区块扫描租约',
`cleanup_until` DATETIME(3) NULL COMMENT '清理租约UTC截止',
`last_success_at` DATETIME(3) NULL COMMENT '最近完整采集成功时间',
`last_error` VARCHAR(255) NULL COMMENT '脱敏运行状态,不记录RPC响应或密钥',
`updated_at` DATETIME(3) NOT NULL COMMENT '最近更新时间',
@@ -56,5 +71,6 @@ CREATE TABLE IF NOT EXISTS `rent_history_anchor` (
`block_id` VARCHAR(64) NOT NULL COMMENT '确认区块哈希',
`balance_sun` BIGINT NOT NULL COMMENT '该地址对Stake2.0锁定与非锁定本金合计SUN',
`created_at` DATETIME(3) NOT NULL COMMENT '采集UTC时间',
PRIMARY KEY (`network`,`owner_address`,`receiver_address`,`resource_type`,`block_height`)
PRIMARY KEY (`network`,`owner_address`,`receiver_address`,`resource_type`,`block_height`),
KEY `idx_history_anchor_retention` (`network`,`block_height`)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='派单前稳定确认状态的地址对基线';