diff --git a/README.md b/README.md index 0aa69d4..6c1f063 100644 --- a/README.md +++ b/README.md @@ -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前后端分离交流群 diff --git a/docs/rental/history-service.md b/docs/rental/history-service.md index 77507a1..2b599fe 100644 --- a/docs/rental/history-service.md +++ b/docs/rental/history-service.md @@ -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以及真实订单端到端验收;本次未执行数据库迁移或任何链上广播。 diff --git a/docs/rental/implementation.md b/docs/rental/implementation.md index eb97291..a4d41df 100644 --- a/docs/rental/implementation.md +++ b/docs/rental/implementation.md @@ -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`,服务必须基于该实际区块状态返回: diff --git a/docs/rental/schema-design.md b/docs/rental/schema-design.md index b0e35d6..53c0f4b 100644 --- a/docs/rental/schema-design.md +++ b/docs/rental/schema-design.md @@ -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表结构。待确认缓冲不用于直接结算,确认并核对哈希后提升至证据表。 | 表 | 作用 | | --- | --- | diff --git a/ruoyi-admin/src/main/resources/application-rental.yml b/ruoyi-admin/src/main/resources/application-rental.yml index a10bbad..6d14218 100644 --- a/ruoyi-admin/src/main/resources/application-rental.yml +++ b/ruoyi-admin/src/main/resources/application-rental.yml @@ -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:} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java index c85cdff..59a792a 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java @@ -118,29 +118,21 @@ public class RentalChain { } public Map 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 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 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; } diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryDiagnostics.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryDiagnostics.java new file mode 100644 index 0000000..ed098a3 --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryDiagnostics.java @@ -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 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); + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryDispatcher.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryDispatcher.java new file mode 100644 index 0000000..547143f --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryDispatcher.java @@ -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 tasks; + private final ObjectProvider socket; + private final Set 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 tasks, ObjectProvider 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(); + } + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryEvents.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryEvents.java new file mode 100644 index 0000000..2cb7773 --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalDeliveryEvents.java @@ -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(); + } + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryArchive.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryArchive.java new file mode 100644 index 0000000..613d1dc --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryArchive.java @@ -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 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(); + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCleaner.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCleaner.java new file mode 100644 index 0000000..7d3bc92 --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCleaner.java @@ -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 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 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 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 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> 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> blocks = store.rows("SELECT b.* FROM rent_history_block b" + + " WHERE b.network=? AND b.block_height> anchors = store.rows("SELECT * FROM rent_history_anchor" + + " WHERE network=? AND block_height> 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 row : events) { + store.execute("DELETE FROM rent_history_event WHERE network=? AND tx_id=?", network, row.get("tx_id")); + } + for (Map row : blocks) { + store.execute("DELETE FROM rent_history_block WHERE network=? AND block_height=?", network, row.get("block_height")); + } + for (Map 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 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> 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> relations = new LinkedHashMap<>(); + for (Map 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 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> pairs = new ArrayList<>(relations.values()); + for (int offset = 0; offset < pairs.size(); offset += 100) { + List> 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 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> found = store.rows(sql.toString(), args.toArray()); + if (found.size() != selected.size()) { + log.warn("受保护地址对缺少基线,停止本网络清理 network={}", network); + return 0; + } + for (Map 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 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; + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCollector.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCollector.java index 25a34c0..fb5e53e 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCollector.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryCollector.java @@ -44,24 +44,31 @@ 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) { - executor.scheduleWithFixedDelay(() -> { + 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 diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryGuard.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryGuard.java new file mode 100644 index 0000000..96ba06e --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryGuard.java @@ -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 lock(RentalStore store, String network) { + require(TransactionSynchronizationManager.isActualTransactionActive(), "历史保护锁必须在事务内获取"); + Map 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; + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryService.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryService.java index 7bc8659..4bca138 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryService.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalHistoryService.java @@ -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 pendingSnapshots = new java.util.concurrent.ConcurrentHashMap<>(); + /** 同一进程每网络最多一个采样;不同网络和事件扫描互不阻塞。 */ + private final java.util.Set 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 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 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 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 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 rows = response.path("delegatedResource"); - require(rows.isMissingNode() || 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); - } + for (boolean locked : new boolean[] {false, true}) { + 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(response.size() == 0 || rows.isArray(), "确认关系响应结构错误"); + for (JsonNode row : rows) { + String field = "ENERGY".equals(type) + ? "frozen_balance_for_energy" : "frozen_balance_for_bandwidth"; + 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 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 healthy = store.one("SELECT created_at AS sampled_at FROM rent_history_sample" + + " WHERE network=? ORDER BY block_height DESC LIMIT 1", network); + Map 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 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 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 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 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 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 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 cursor = store.one( "SELECT * FROM rent_history_cursor WHERE network=?", network); Map 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 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 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 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> 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 target = block(network, height); + if (target == null) { + return "BLOCK_NOT_ARCHIVED"; + } + if (target.get("parameters_at") == null) { + return "PARAMETERS_MISSING"; + } + Map anchor = store.one("SELECT block_height FROM rent_history_anchor WHERE network=?" + + " AND owner_address=? AND receiver_address=? AND resource_type=? AND block_height> 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; } } } diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalOrders.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalOrders.java index 4a8ef04..f30e216 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalOrders.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalOrders.java @@ -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); diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalQueries.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalQueries.java index 166c407..c9fc2da 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalQueries.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalQueries.java @@ -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 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 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", "历史履约核验未通过,未保存完整诊断,请核对原交易证据、资源数量及核验时间"); + } } diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalSocket.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalSocket.java index b2a7688..e2bff9d 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalSocket.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalSocket.java @@ -291,90 +291,104 @@ 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()) { - try { - if (c.node == 0) { - if (System.currentTimeMillis() - c.opened > 5000) { - c.socket.close(CloseStatus.POLICY_VIOLATION); - } - continue; - } - if (System.currentTimeMillis() - c.pong > 45000) { - c.socket.close(CloseStatus.SESSION_NOT_RELIABLE); - continue; - } - Map node = store.get("node", c.node, false); - if (number(node, "session_epoch") != c.epoch - || "REVOKED".equals(text(node, "status"))) { - c.socket.close(CloseStatus.POLICY_VIOLATION); - continue; - } - // 快速扫描订单不等于快速发心跳;距离最近PONG至少15秒才主动探活。 - if (c.ping == null && System.currentTimeMillis() - c.pong >= 15000) { - send(c, "PING", map()); - } - if (!c.ready) { - continue; - } - for (Map task : - store.rows( - "SELECT * FROM rent_task WHERE node_id=? AND status IN" - + " ('PENDING','ACCEPTED','UNKNOWN','BROADCASTED') AND" - + " (last_sent_at IS NULL OR last_sent_at credential = - store.get("credential", number(task, "credential_id"), false); - if ("REVOKED".equals(text(credential, "status"))) { - continue; - } - // PAUSED仍核对历史原任务,但不推送尚未接受的首次任务去执行。 - if (!"ACTIVE".equals(text(node, "status")) - && "PENDING".equals(text(task, "status"))) { - continue; - } - send( - c, - "TASK_PUSH", - map( - "task_no", - text(task, "task_no"), - "delivery_message_id", - text(task, "delivery_message_id"), - "api_key", - text(credential, "api_key"), - "intent", - json.writeValueAsString( - new TreeMap<>( - json.readValue( - text(task, "intent"), Map.class))), - "signature", - text(task, "signature"), - "timestamp", - time(task.get("signed_at")).toEpochMilli(), - "nonce", - text(task, "nonce"))); - LOG.info("租赁任务已推送 taskId={} taskNo={} orderId={} nodeId={} deliveryCount={} taskAgeMs={}", - task.get("id"), text(task, "task_no"), task.get("order_id"), - c.node, number(task, "delivery_count") + 1, - System.currentTimeMillis() - time(task.get("created_at")).toEpochMilli()); - store.execute( - "UPDATE rent_task SET" - + " delivery_count=delivery_count+1,last_sent_at=?,delivery_session_epoch=?,version=version+1,updated_at=?" - + " WHERE id=?", - now(), - c.epoch, - now(), - task.get("id")); - } - } catch (Exception ex) { - LOG.warn("租赁任务推送或连接检查失败 nodeId={} diagnostic={}", - c.node, RentalDiagnostics.describe(ex)); + if (nodeId != 0 && c.node != nodeId) { + continue; + } + // 即时推送与补偿扫描串行处理同一连接的选择、发送及投递计数。 + synchronized (c) { try { - c.socket.close(CloseStatus.SERVER_ERROR); - } catch (Exception ignored) { - /* 关闭后由epoch保护离线更新。 */ + if (c.node == 0) { + if (System.currentTimeMillis() - c.opened > 5000) { + c.socket.close(CloseStatus.POLICY_VIOLATION); + } + continue; + } + if (System.currentTimeMillis() - c.pong > 45000) { + c.socket.close(CloseStatus.SESSION_NOT_RELIABLE); + continue; + } + Map node = store.get("node", c.node, false); + if (number(node, "session_epoch") != c.epoch + || "REVOKED".equals(text(node, "status"))) { + c.socket.close(CloseStatus.POLICY_VIOLATION); + continue; + } + // 快速扫描订单不等于快速发心跳;距离最近PONG至少15秒才主动探活。 + if (c.ping == null && System.currentTimeMillis() - c.pong >= 15000) { + send(c, "PING", map()); + } + if (!c.ready) { + continue; + } + for (Map task : + store.rows( + "SELECT * FROM rent_task WHERE node_id=? AND status IN" + + " ('PENDING','ACCEPTED','UNKNOWN','BROADCASTED') AND" + + " (last_sent_at IS NULL OR last_sent_at credential = + store.get("credential", number(task, "credential_id"), false); + if ("REVOKED".equals(text(credential, "status"))) { + continue; + } + // PAUSED仍核对历史原任务,但不推送尚未接受的首次任务去执行。 + if (!"ACTIVE".equals(text(node, "status")) + && "PENDING".equals(text(task, "status"))) { + continue; + } + send( + c, + "TASK_PUSH", + map( + "task_no", + text(task, "task_no"), + "delivery_message_id", + text(task, "delivery_message_id"), + "api_key", + text(credential, "api_key"), + "intent", + json.writeValueAsString( + new TreeMap<>( + json.readValue( + text(task, "intent"), Map.class))), + "signature", + text(task, "signature"), + "timestamp", + time(task.get("signed_at")).toEpochMilli(), + "nonce", + text(task, "nonce"))); + LOG.info("租赁任务已推送 taskId={} taskNo={} orderId={} nodeId={} deliveryCount={} taskAgeMs={}", + task.get("id"), text(task, "task_no"), task.get("order_id"), + c.node, number(task, "delivery_count") + 1, + System.currentTimeMillis() - time(task.get("created_at")).toEpochMilli()); + store.execute( + "UPDATE rent_task SET" + + " delivery_count=delivery_count+1,last_sent_at=?,delivery_session_epoch=?,version=version+1,updated_at=?" + + " WHERE id=?", + now(), + c.epoch, + now(), + task.get("id")); + } + } catch (Exception ex) { + LOG.warn("租赁任务推送或连接检查失败 nodeId={} diagnostic={}", + c.node, RentalDiagnostics.describe(ex)); + try { + c.socket.close(CloseStatus.SERVER_ERROR); + } catch (Exception ignored) { + /* 关闭后由epoch保护离线更新。 */ + } } } } diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalTasks.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalTasks.java index bc32394..bcdd0c6 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalTasks.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalTasks.java @@ -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 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( diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWorkers.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWorkers.java index 1a7b85a..142c598 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWorkers.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWorkers.java @@ -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 row : waiting) { dispatchCursor = number(row, "id"); try { - tasks.dispatch(dispatchCursor); + if (deliveryDispatcher == null) { + tasks.dispatch(dispatchCursor); + } else { + deliveryDispatcher.dispatch(dispatchCursor); + } } catch (Exception ex) { LOG.warn("租赁订单调度待重试 orderId={} diagnostic={}", dispatchCursor, RentalDiagnostics.describe(ex)); } diff --git a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalBusinessTest.java b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalBusinessTest.java index 298a36d..715acc9 100644 --- a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalBusinessTest.java +++ b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalBusinessTest.java @@ -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 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 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 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 oldAccount = new LinkedHashMap<>(store.get("account", payer, false)); + Map order = create("CLEANUP-PRESERVE-FUNDS"); + Map 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 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 order = store.get("order", id, false); assertEquals("MANUAL_REVIEW", text(order, "status")); assertEquals("HELD", text(order, "fund_status")); + Map 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> 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 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)); diff --git a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryCleanupTest.java b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryCleanupTest.java new file mode 100644 index 0000000..74b47af --- /dev/null +++ b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryCleanupTest.java @@ -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 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 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 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 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 cleaning = pool.submit(() -> slow.clean("NILE")); + assertTrue(archiving.await(5, TimeUnit.SECONDS)); + Future> proof = pool.submit(() -> history.proof("NILE", hash(1001), 101, OWNER, RECEIVER, "ENERGY")); + Future 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(); + } + } +} diff --git a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryTest.java b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryTest.java index 7144aeb..38e4462 100644 --- a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryTest.java +++ b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalHistoryTest.java @@ -25,20 +25,25 @@ public class RentalHistoryTest { private final ObjectMapper json = new ObjectMapper(); private final Map 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 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 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 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); diff --git a/sql/rent_history_cleanup_upgrade.sql b/sql/rent_history_cleanup_upgrade.sql new file mode 100644 index 0000000..ed06755 --- /dev/null +++ b/sql/rent_history_cleanup_upgrade.sql @@ -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; diff --git a/sql/rent_history_init.sql b/sql/rent_history_init.sql index d909b5c..127a0a4 100644 --- a/sql/rent_history_init.sql +++ b/sql/rent_history_init.sql @@ -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='派单前稳定确认状态的地址对基线';