feat(frontConfig): 前端独立部署域名验证(DNS TXT 校验 + 验证闸门),frontConfig 接口从 setting.warehouse 迁移至独立 service(getInfo/getCert/saveInfo/saveCert/setDomain/getDomain/checkDomain)

This commit is contained in:
liufumingren 2026-09-24 03:26:15 +08:00
parent 05b2d08014
commit 52181c44bd
9 changed files with 2329 additions and 117 deletions

View File

@ -9,6 +9,8 @@
* 管理后台保存后置为待同步,由定时任务同步到 nginx 后回写状态。
* - 证书启用/停用由整行删除或 sync_status 表达;证书到期由 cert_expire_at
* 判断,不单独保留证书 status 列。
* - domain_status 状态机:0-未验证,1-已验证(DNS TXT 校验通过),2-验证失败;
* 未验证/验证失败的域名禁止上传证书与对外公共拉取,管理后台设置域名后回落到 0。
* - domain 唯一索引(uk_domain)为 MySQL 可空列唯一索引:允许多个 NULL,
* 应用层在写入非空 domain 前必须做唯一性校验,不能依赖数据库约束报错。
* - store_id 唯一索引(uk_store_id):每仓一行,由数据库层保证。
@ -43,6 +45,44 @@ module.exports = app => {
allowNull: true,
comment: '仓库自持域名;可空列唯一索引允许多个 NULL,非空值唯一性需应用层校验',
},
domain_status: {
type: TINYINT,
allowNull: false,
defaultValue: 0,
validate: {
isIn: {
args: [[ 0, 1, 2 ]],
msg: '域名验证状态不合法:0-未验证,1-已验证,2-验证失败',
},
},
comment: '域名验证状态:0-未验证,1-已验证,2-验证失败',
},
domain_verify_host: {
type: STRING(255),
allowNull: true,
comment: '待校验 TXT 记录主机名(wmsv-<随机码>.<域名>)',
},
domain_verify_token: {
type: STRING(64),
allowNull: true,
comment: '待校验 TXT 记录值(32 位 hex)',
},
domain_verified_at: {
type: DATE,
allowNull: true,
comment: '域名验证通过时间',
},
domain_verify_attempts: {
type: INTEGER(11),
allowNull: false,
defaultValue: 0,
comment: '域名验证尝试次数',
},
domain_last_error: {
type: STRING(500),
allowNull: true,
comment: '最近一次域名验证失败原因',
},
title: {
type: STRING(100),
allowNull: true,
@ -158,6 +198,10 @@ module.exports = app => {
name: 'idx_sync_status',
fields: [ 'sync_status' ],
},
{
name: 'idx_domain_status',
fields: [ 'domain_status' ],
},
],
});

View File

@ -0,0 +1,183 @@
// app/schedule/domain_verify_scan.js
'use strict';
/**
* 域名验证扫描定时任务。
*
* 按 config.frontConfig.domainVerify.interval 周期性触发(默认 10m),
* 扫描 wms_warehouse_front_config 中「已生成待校验 TXT 记录、且尚未通过验证」的行,
* 逐行解析 DNS TXT 记录并回写 domain_status / domain_verified_at /
* domain_verify_attempts / domain_last_error;只有通过验证的域名才会被公共拉取接口
* 与 nginx server 块生成流程放行。
*
* 并发控制(双保险):
* 1. 进程内重入标志 ctx.app._domainVerifyScanRunning:上一轮未结束时跳过本轮;
* 2. Redis 跨进程互斥锁 SET NX EX:多实例部署时同一轮只有一个实例执行,
* TTL 取 config.frontConfig.domainVerify.lockTtlSeconds(默认 600s);
* Redis 不可用或抛错时降级为「仅进程内防重入」并 WARN,
* 不因缓存故障中断域名验证。
*
* 业务逻辑全部委托 service.systems.frontConfig.verifyPendingDomains(本文件不写 SQL);
* 任务失败只记录错误日志,不向上抛出,避免 schedule 崩溃。
*
* 关闭方式:config.frontConfig.domainVerify.enable = false,此时 schedule
* 标记为 disable,Egg 不注册本任务(进程内不会执行)。
*/
/** @type {string} 跨进程互斥锁 key */
const LOCK_CACHE_KEY = 'schedule:domain_verify_scan:lock';
/** @type {string} 日志前缀 tag */
const LOG_TAG = '[domain_verify_scan]';
/** @type {number} 锁 TTL 兜底值(秒) */
const DEFAULT_LOCK_TTL_SECONDS = 600;
/** @type {string} 扫描间隔兜底值 */
const DEFAULT_INTERVAL = '10m';
/**
* 获取 Redis cache 客户端。
*
* @param {Object} app Egg 应用实例。
* @return {Object|null} Redis 客户端或 null。
*/
function getCacheRedisClient(app) {
if (!app || !app.redis || typeof app.redis.get !== 'function') {
return null;
}
try {
return app.redis.get('cache') || null;
} catch (error) {
return null;
}
}
/**
* 获取跨进程互斥锁(SET NX EX)。
*
* @param {Object} ctx Egg 上下文。
* @param {number} ttlSeconds 锁 TTL(秒)。
* @param {string} lockValue 锁持有者标识(pid + 时间戳)。
* @return {Promise<boolean>} 是否获取成功;Redis 不可用时返回 true(退化为进程内防重入)。
*/
async function acquireLock(ctx, ttlSeconds, lockValue) {
const redis = getCacheRedisClient(ctx.app);
if (!redis || typeof redis.set !== 'function') {
ctx.logger.warn(`${LOG_TAG} Redis 不可用,跨进程互斥降级为进程内防重入`);
return true;
}
try {
const result = await redis.set(LOCK_CACHE_KEY, lockValue, 'EX', ttlSeconds, 'NX');
return result === 'OK';
} catch (error) {
ctx.logger.warn(`${LOG_TAG} 获取互斥锁失败(按未加锁继续): ${error.message}`);
return true;
}
}
/**
* 释放跨进程互斥锁(GET 比对 value 后再 DEL,避免误删他人锁)。
*
* 仍存在极小竞态窗口:本进程 GET 到自己的 value 后、DEL 之前锁恰好 TTL 到期
* 并被其它实例抢到(value 为 pid + 时间戳,重复概率极低),最坏结果是提前释放
* 一次锁,不会造成数据错误(service 层 update 自带 id + domain 防并发守卫),
* 因此接受该窗口而不引入 Lua 脚本。
*
* @param {Object} ctx Egg 上下文。
* @param {string} lockValue 锁持有者标识(与获取时一致)。
* @return {Promise<void>} 无返回值。
*/
async function releaseLock(ctx, lockValue) {
const redis = getCacheRedisClient(ctx.app);
if (!redis || typeof redis.get !== 'function' || typeof redis.del !== 'function') {
// Redis 不可用则跳过释放,等待 TTL 自然过期
return;
}
try {
const current = await redis.get(LOCK_CACHE_KEY);
if (current !== lockValue) {
return;
}
await redis.del(LOCK_CACHE_KEY);
} catch (error) {
ctx.logger.warn(`${LOG_TAG} 释放互斥锁失败(等待 TTL 过期): ${error.message}`);
}
}
/**
* 域名验证扫描定时任务。
*
* @param {Object} app Egg 应用实例。
* @return {Object} 定时任务定义(含 schedule 与 task)。
*/
module.exports = app => {
// 工厂内动态读取配置:interval / lockTtlSeconds / enable 变更后无需改代码
const frontConfig = (app.config && app.config.frontConfig) || {};
const domainVerify = frontConfig.domainVerify || {};
const interval = typeof domainVerify.interval === 'string' && domainVerify.interval
? domainVerify.interval
: DEFAULT_INTERVAL;
const lockTtlSeconds = Number(domainVerify.lockTtlSeconds) > 0
? Math.floor(Number(domainVerify.lockTtlSeconds))
: DEFAULT_LOCK_TTL_SECONDS;
return {
schedule: {
// 固定间隔触发;domainVerify.enable === false 时 disable 为 true,
// Egg 直接不注册本任务(不会进入 task,也不会占用 worker 周期)
interval,
type: 'worker',
immediate: false,
disable: domainVerify.enable === false,
},
/**
* 执行一轮域名验证扫描。
*
* @param {Object} ctx Egg 上下文。
* @return {Promise<void>} 无返回值。
*/
async task(ctx) {
// 进程内防重入:单实例上一轮未结束时不再叠加下一轮
if (ctx.app._domainVerifyScanRunning) {
ctx.logger.info(`${LOG_TAG} 本轮任务跳过,上一轮尚未结束`);
return;
}
const lockValue = `${process.pid}-${Date.now()}`;
const locked = await acquireLock(ctx, lockTtlSeconds, lockValue);
if (!locked) {
ctx.logger.info(`${LOG_TAG} 未获取到跨进程互斥锁,本轮跳过(其它实例正在执行)`);
return;
}
ctx.app._domainVerifyScanRunning = true;
const startedAt = Date.now();
try {
// 业务逻辑一律委托 service,schedule 内不写 SQL
const summary = await ctx.service.systems.frontConfig.verifyPendingDomains({});
ctx.logger.info(
`${LOG_TAG} 本轮完成 scanned=${summary.scanned} verified=${summary.verified}`
+ ` failed=${summary.failed} skipped=${summary.skipped}`
+ ` errors=${summary.errors.length} duration=${Date.now() - startedAt}ms`
);
if (summary.errors.length > 0) {
ctx.logger.warn(`${LOG_TAG} 本轮错误摘要: ${summary.errors.slice(0, 5).join(' | ')}`);
}
} catch (error) {
// service 层已 fail-soft(迁移未执行时返回零统计),此处为最后兜底:
// 只记日志不上抛,避免 schedule 崩溃
ctx.logger.error(`${LOG_TAG} 本轮执行异常: ${error && error.message ? error.message : String(error)}`);
} finally {
ctx.app._domainVerifyScanRunning = false;
await releaseLock(ctx, lockValue);
}
},
};
};

View File

@ -2,22 +2,39 @@
const MainService = require('../main');
/**
* 系统方法层:frontConfig(前端独立部署配置接口包装层)。
*
* 业务实现全部委托 ctx.service.systems.frontConfig:本层只做参数白名单过滤、
* 鉴权出口与统一成功/失败包装。
*/
class FrontConfigMethodsService extends MainService {
constructor(ctx) {
super(ctx);
// 公共按域名拉取前端配置:免登录、免权限、免鉴权(保留系统日志,与 workbench 公共接口口径一致)
// 公共按域名拉取:免登录、免权限、免鉴权(保留系统日志,与 workbench 公共接口口径一致)
// 注意:getByDomain 是唯一免登录接口;域名验证接口(setDomain/getDomain/checkDomain)一律需登录
const _noNeedLogin = 'getByDomain';
const _noNeedRight = 'getByDomain';
const _noNeedLog = '';
const _noNeedAuth = 'getByDomain';
// settings 页配置接口:需登录、免权限、免鉴权(权限由业务层 isWarehouse 判定),不记系统日志
const _noNeedRight = 'getByDomain,getInfo,getCert,saveInfo,saveCert,setDomain,getDomain,checkDomain';
const _noNeedLog = 'getInfo,getCert,saveInfo,saveCert,setDomain,getDomain,checkDomain';
const _noNeedAuth = 'getByDomain,getInfo,getCert,saveInfo,saveCert,setDomain,getDomain,checkDomain';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 获取前端独立部署业务服务(systems/frontConfig)。
*
* @return {Object|null} 业务服务实例;不可用时返回 null。
*/
getFrontConfigService() {
return (this.service && this.service.systems && this.service.systems.frontConfig) || null;
}
/**
* 按域名拉取仓库前端公开配置(公共无鉴权接口)。
*
* 安全红线:响应仅含公开字段(domain/title/logo_url/login_bg_url/favicon_url/theme),
* 不含 cert_path、key_path、sync_status、sync_attempts、last_sync_error 等内部字段。
* 不含 cert_pem/key_pem/cert_path/key_path/sync_status/sync_attempts/last_sync_error 等内部字段。
*
* @param {Object} [data={}] 请求参数。
* @param {string} data.domain 待查询域名(必填,非空)。
@ -27,13 +44,13 @@ class FrontConfigMethodsService extends MainService {
async getByDomain(data = {}) {
const { domain } = data || {};
const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse;
if (!targetService || typeof targetService.getFrontConfigByDomain !== 'function') {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.getByDomain !== 'function') {
return this.fail('获取前端配置失败', { code: 500 });
}
try {
const result = await targetService.getFrontConfigByDomain(domain);
const result = await targetService.getByDomain(domain);
return this.success('获取成功', { ...result, code: 200 });
} catch (error) {
return this.fail(error.message || '获取前端配置失败', {
@ -41,6 +58,209 @@ class FrontConfigMethodsService extends MainService {
});
}
}
/**
* 查询当前仓库前端独立部署品牌配置(settings 页回显,需登录)。
*
* 仅返回品牌与基础字段(warehouse_id/domain/title/logo_url/favicon_url/login_bg_url/theme/updated_at),
* 不含证书/私钥原文与同步状态等内部字段(证书回显走 frontConfig.getCert)。
*
* @return {Promise<Object>} 统一响应结果。
*/
async getInfo() {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.getInfo !== 'function') {
return this.fail('获取前端配置失败', { code: 500 });
}
try {
const result = await targetService.getInfo();
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '获取前端配置失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 查询当前仓库前端独立部署证书配置(settings 页回显,需登录)。
*
* 响应含证书原文(cert_pem)与私钥原文(key_pem,取自 cert_key 列),
* 仅供仓库主体登录后的 settings 页回显,公共无鉴权接口 frontConfig.getByDomain
* 仍只返回公开字段白名单。
*
* @return {Promise<Object>} 统一响应结果。
*/
async getCert() {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.getCert !== 'function') {
return this.fail('获取前端证书配置失败', { code: 500 });
}
try {
const result = await targetService.getCert();
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '获取前端证书配置失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 保存当前仓库前端独立部署品牌配置(upsert,一仓一行,仅品牌字段部分更新,需登录)。
*
* domain 与证书字段不再受理:domain 变更必须走 frontConfig.setDomain(域名验证通过后方可上传证书);
* cert_pem/key_pem/cert_path/key_path/cert_expire_at 一律被白名单过滤忽略。
*
* @param {Object} data 请求参数。
* @param {string} [data.title] 站点标题(≤100 字符,空值清空)。
* @param {string} [data.logo_url] Logo 地址(≤255 字符,空值清空)。
* @param {string} [data.favicon_url] 站点 favicon 图标地址(≤255 字符,空值清空)。
* @param {string} [data.login_bg_url] 登录页背景图地址(≤255 字符,空值清空)。
* @param {Object|string} [data.theme] 主题配置(合法 JSON 对象或 JSON 字符串,空值清空)。
* @return {Promise<Object>} 统一响应结果。
*/
async saveInfo(data = {}) {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.saveInfo !== 'function') {
return this.fail('保存前端配置失败', { code: 500 });
}
try {
const source = data || {};
const params = {};
// domain/cert_path/key_path/cert_pem/key_pem/cert_expire_at 均不受理:
// domain 变更走 setDomain,证书与有效期字段由后端权威维护,前端传值直接忽略
for (const key of [ 'title', 'logo_url', 'favicon_url', 'login_bg_url', 'theme' ]) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
params[key] = source[key];
}
}
const result = await targetService.saveInfo(params);
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '保存前端配置失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 上传当前仓库前端独立部署证书(需登录、仅仓库主体)。
*
* domain 不再受理:域名一律取库内已设置且验证通过的值(前端若仍传 data.domain 一律忽略),
* 未设置域名或域名未通过 TXT 验证时由业务层返回 400。
* 后端自动写入 cert_expire_at(证书 validTo 权威值),证书/私钥内容直接入库(不落盘),
* 保存后清理该域名的公共拉取缓存并返回证书配置输出
* (响应含证书/私钥原文回显,13 字段,口径与 frontConfig.getCert 一致)。
*
* @param {Object} data 请求参数。
* @param {string} data.pem 证书 PEM 文本(必填)。
* @param {string} data.key 私钥 PEM 文本(必填,与证书成对)。
* @return {Promise<Object>} 统一响应结果。
*/
async saveCert(data = {}) {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.saveCert !== 'function') {
return this.fail('上传前端证书失败', { code: 500 });
}
try {
const source = data || {};
const { pem, key } = source;
// data.domain 不再受理:域名只认库内已设置并验证通过的值,前端若仍传 domain 一律忽略
const result = await targetService.saveCert({
pem,
key,
});
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '上传前端证书失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 设置当前仓库前端独立部署域名(需登录、仅仓库主体)。
*
* 设置成功会下发一次性 DNS TXT 校验记录(verify_host/verify_value)与 CNAME 目标(cname);
* 域名发生变更时会同时清空既有证书并重置同步状态(旧证书不覆盖新域名)。
*
* @param {Object} data 请求参数。
* @param {string} data.domain 仓库自持域名(必填,非空,≤100 字符,全局唯一)。
* @return {Promise<Object>} 统一响应结果(code=1);data 含
* warehouse_id/domain/domain_status/verify_host/verify_value/cname/verified_at/attempts/last_error。
*/
async setDomain(data = {}) {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.setDomain !== 'function') {
return this.fail('设置域名失败', { code: 500 });
}
try {
const result = await targetService.setDomain(data || {});
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '设置域名失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 查询当前仓库前端独立部署域名与验证状态(需登录、仅仓库主体)。
*
* 返回待校验的 verify_host/verify_value 与 cname;domain_status=1(已验证)时
* verify_host/verify_value 返回空串(校验令牌已无用途);无记录时返回空值默认。
*
* @return {Promise<Object>} 统一响应结果(code=1);data 含
* warehouse_id/domain/domain_status/verify_host/verify_value/cname/verified_at/attempts/last_error。
*/
async getDomain() {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.getDomain !== 'function') {
return this.fail('获取域名配置失败', { code: 500 });
}
try {
const result = await targetService.getDomain();
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '获取域名配置失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 主动校验当前仓库前端独立部署域名的 DNS TXT 记录(需登录、仅仓库主体)。
*
* 校验结果会回写 domain_status/domain_verified_at/attempts/last_error;
* 响应额外含 verified(本次是否通过)与 resolved_values(本次解析到的 TXT 值,最多 5 条)。
*
* @return {Promise<Object>} 统一响应结果(code=1);未设置域名时 code=400。
*/
async checkDomain() {
const targetService = this.getFrontConfigService();
if (!targetService || typeof targetService.checkDomain !== 'function') {
return this.fail('校验域名失败', { code: 500 });
}
try {
const result = await targetService.checkDomain();
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '校验域名失败', {
code: Number(error.code) || 500,
});
}
}
}
module.exports = FrontConfigMethodsService;

View File

@ -6,9 +6,9 @@ class SettingWarehouseMethodsService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'getSettings,getFieldMeta,saveSettings,getFrontConfig,saveFrontConfig,saveFrontCert,getweChatApp';
const _noNeedRight = 'getSettings,getFieldMeta,saveSettings,getweChatApp';
const _noNeedLog = '*';
const _noNeedAuth = 'getSettings,getFieldMeta,saveSettings,getFrontConfig,saveFrontConfig,saveFrontCert,getweChatApp';
const _noNeedAuth = 'getSettings,getFieldMeta,saveSettings,getweChatApp';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
@ -80,109 +80,6 @@ class SettingWarehouseMethodsService extends MainService {
}
}
/**
* 查询当前仓库前端独立部署配置(settings 页回显)。
*
* 响应含证书原文(cert_pem)与私钥原文(key_pem)回显,
* 仅限登录用户查询其仓库上下文绑定的配置,供仓库主体 settings 页回显;
* 公共无鉴权接口 frontConfig.getByDomain 不经过本出口,仍只返回公开字段白名单。
*
* @return {Promise<Object>} 统一响应结果。
*/
async getFrontConfig() {
const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse;
if (!targetService || typeof targetService.getFrontConfig !== 'function') {
return this.fail('获取仓库前端配置失败', { code: 500 });
}
try {
const result = await targetService.getFrontConfig();
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '获取仓库前端配置失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 保存当前仓库前端独立部署品牌配置(upsert,一仓一行,仅品牌字段部分更新)。
*
* domain 与证书字段不再受理:domain 变更必须走 saveFrontCert 重新校验证书;
* cert_pem/key_pem/cert_path/key_path/cert_expire_at 一律被白名单过滤忽略。
*
* @param {Object} data 请求参数。
* @param {string} [data.title] 站点标题(≤100 字符,空值清空)。
* @param {string} [data.logo_url] Logo 地址(≤255 字符,空值清空)。
* @param {string} [data.favicon_url] 站点 favicon 图标地址(≤255 字符,空值清空)。
* @param {string} [data.login_bg_url] 登录页背景图地址(≤255 字符,空值清空)。
* @param {Object|string} [data.theme] 主题配置(合法 JSON 对象或 JSON 字符串,空值清空)。
* @return {Promise<Object>} 统一响应结果。
*/
async saveFrontConfig(data = {}) {
const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse;
if (!targetService || typeof targetService.saveFrontConfig !== 'function') {
return this.fail('保存仓库前端配置失败', { code: 500 });
}
try {
const source = data || {};
const params = {};
// domain/cert_path/key_path/cert_pem/key_pem/cert_expire_at 均不受理:
// domain 变更走 saveFrontCert,证书与有效期字段由后端权威维护,前端传值直接忽略
for (const key of [ 'title', 'logo_url', 'favicon_url', 'login_bg_url', 'theme' ]) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
params[key] = source[key];
}
}
const result = await targetService.saveFrontConfig(params);
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '保存仓库前端配置失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 上传当前仓库前端独立部署证书(domain + 证书/私钥成对,需登录、仅仓库主体)。
*
* 后端自动写入 cert_expire_at(证书 validTo 权威值),证书/私钥内容直接入库(不落盘),
* 保存后清理新旧 domain 的公共拉取缓存并返回完整配置输出
* (响应含证书/私钥原文回显,口径与 getFrontConfig 一致)。
*
* @param {Object} data 请求参数。
* @param {string} data.domain 仓库自持域名(必填,非空,≤100 字符,全局唯一)。
* @param {string} data.pem 证书 PEM 文本(必填)。
* @param {string} data.key 私钥 PEM 文本(必填,与证书成对)。
* @return {Promise<Object>} 统一响应结果。
*/
async saveFrontCert(data = {}) {
const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse;
if (!targetService || typeof targetService.saveFrontCert !== 'function') {
return this.fail('上传前端证书失败', { code: 500 });
}
try {
const source = data || {};
const { domain, pem, key } = source;
const result = await targetService.saveFrontCert({
domain,
pem,
key,
});
return this.success('ok', result);
} catch (error) {
return this.fail(error.message || '上传前端证书失败', {
code: Number(error.code) || 500,
});
}
}
/**
* 获取当前仓库启用的微信小程序授权配置(wms_wechat_app)。

File diff suppressed because it is too large Load Diff

View File

@ -311,6 +311,17 @@ module.exports = appInfo => {
// 该目录保留供未来定时任务(Egg schedule 或外部 crontab)从库内 cert_pem/cert_key 读取内容后写 nginx 证书目录使用。
config.frontConfig = {
certStagingDir: '/data/wms/cert-staging',
// 前端独立部署:域名验证(DNS TXT 校验)
cname: '', // 用户把域名 CNAME 指向的目标(未验证时返回给前端展示)
domainVerify: {
enable: true, // 是否注册域名验证定时任务
interval: '10m', // 扫描间隔
lockTtlSeconds: 600, // Redis 跨进程锁 TTL(略大于 interval)
batchSize: 50, // 单轮最多处理行数
dohUrl: 'https://doh.pub/dns-query',
timeoutMs: 5000, // 单次 DoH 请求超时
maxAttempts: 20, // 超过后不再自动重试(仍可手动 checkDomain)
},
};
return {

View File

@ -0,0 +1,186 @@
'use strict';
const TABLE_NAME = 'wms_warehouse_front_config';
const DOMAIN_STATUS_COLUMN = 'domain_status';
const DOMAIN_STATUS_INDEX_NAME = 'idx_domain_status';
/**
* Migration: 仓库前端配置表新增域名验证(DNS TXT 校验)相关列与索引。
*
* 背景:
* 前端独立部署需要用户把自持域名解析到平台,必须校验域名归属,避免非自持域名
* 被指向平台(域名误配/抢注、证书误签)。方案为 DNS TXT 校验:后端为每个仓库
* 生成一次性校验主机名(wmsv-<10 位 hex>.<域名>)与校验值(32 位 hex),用户在
* 该子域配置 TXT 记录,后端解析比对通过后置为已验证。未通过验证的域名不得上传
* 证书(frontConfig.saveCert 前置闸门),公共按域名拉取同以 domain_status=1 为闸门。
*
* 新增列:
* - domain_status : 域名验证状态:0-未验证,1-已验证,2-验证失败(NOT NULL,默认 0);
* - domain_verify_host : 待校验 TXT 记录主机名(wmsv-<随机码>.<域名>);
* - domain_verify_token : 待校验 TXT 记录值(32 位 hex);
* - domain_verified_at : 域名验证通过时间;
* - domain_verify_attempts : 验证尝试次数(定时任务自增,超过 maxAttempts 后停止自动重试);
* - domain_last_error : 最近一次验证失败原因(脱敏截断,≤500 字符)。
* 新增索引:
* - idx_domain_status:域名验证定时任务按 domain_status 扫描待验证行的查询索引。
*
* ⚠ 存量数据回填(本次迁移的关键动作):
* 升级前已写入 domain 的行,其域名在线上已生效(nginx 已在按域名提供服务),必须
* 视为「已验证」,否则新加入的 domain_status=1 闸门会在升级瞬间把生产现有域名
* 全部断掉(证书上传被拒、公共拉取被拒)。
* 回填 SQL:UPDATE ... SET domain_status = 1
* WHERE domain IS NOT NULL AND domain <> '' AND domain_status = 0。
* 回填只在本次真正新增 domain_status 列的那一次执行:迁移允许重复执行,若列已存在
* 仍继续回填,会把「升级后新设置但尚未验证」的域名误标为已验证。
* domain_verified_at 保持 NULL:历史生效时间不可考,不写入虚假时间。
*
* Idempotent: 列/索引已存在时跳过;down 逐索引、逐列判存在后删除。
*/
/**
* 判断表是否存在。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {string} tableName 表名。
* @return {Promise<boolean>} 存在返回 true。
*/
async function tableExists(queryInterface, tableName) {
const tables = await queryInterface.showAllTables();
return tables.some(t => (typeof t === 'string' ? t : (t.tableName || t.name)) === tableName);
}
/**
* 判断索引是否存在。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {string} tableName 表名。
* @param {string} indexName 索引名。
* @return {Promise<boolean>} 存在返回 true。
*/
async function indexExists(queryInterface, tableName, indexName) {
const indexes = await queryInterface.showIndex(tableName);
return (indexes || []).some(item => (typeof item === 'string' ? item : item.name) === indexName);
}
module.exports = {
/**
* 执行正向迁移:新增域名验证相关列与索引,并回填存量已生效域名(幂等)。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {import('sequelize')} Sequelize Sequelize 实例。
* @return {Promise<void>} 无返回值。
*/
async up(queryInterface, Sequelize) {
if (!(await tableExists(queryInterface, TABLE_NAME))) {
return;
}
const columns = await queryInterface.describeTable(TABLE_NAME);
const domainStatusAdded = !columns[DOMAIN_STATUS_COLUMN];
if (domainStatusAdded) {
await queryInterface.addColumn(TABLE_NAME, DOMAIN_STATUS_COLUMN, {
type: Sequelize.TINYINT,
allowNull: false,
defaultValue: 0,
comment: '域名验证状态:0-未验证,1-已验证,2-验证失败',
after: 'domain',
});
}
if (!columns.domain_verify_host) {
await queryInterface.addColumn(TABLE_NAME, 'domain_verify_host', {
type: Sequelize.STRING(255),
allowNull: true,
comment: '待校验 TXT 记录主机名(wmsv-<随机码>.<域名>)',
after: 'domain_status',
});
}
if (!columns.domain_verify_token) {
await queryInterface.addColumn(TABLE_NAME, 'domain_verify_token', {
type: Sequelize.STRING(64),
allowNull: true,
comment: '待校验 TXT 记录值(32 位 hex)',
after: 'domain_verify_host',
});
}
if (!columns.domain_verified_at) {
await queryInterface.addColumn(TABLE_NAME, 'domain_verified_at', {
type: Sequelize.DATE,
allowNull: true,
comment: '域名验证通过时间',
after: 'domain_verify_token',
});
}
if (!columns.domain_verify_attempts) {
await queryInterface.addColumn(TABLE_NAME, 'domain_verify_attempts', {
type: Sequelize.INTEGER(11),
allowNull: false,
defaultValue: 0,
comment: '域名验证尝试次数',
after: 'domain_verified_at',
});
}
if (!columns.domain_last_error) {
await queryInterface.addColumn(TABLE_NAME, 'domain_last_error', {
type: Sequelize.STRING(500),
allowNull: true,
comment: '最近一次域名验证失败原因',
after: 'domain_verify_attempts',
});
}
if (!(await indexExists(queryInterface, TABLE_NAME, DOMAIN_STATUS_INDEX_NAME))) {
await queryInterface.addIndex(TABLE_NAME, [ DOMAIN_STATUS_COLUMN ], {
name: DOMAIN_STATUS_INDEX_NAME,
});
}
// 存量回填:升级前已写入 domain 的行在线上已生效,必须视为「已验证」,
// 否则 domain_status=1 闸门会在升级瞬间断掉生产现有域名。
// 仅在本次真正新增该列时执行(重复执行迁移不得把新设置但未验证的域名误标为已验证),
// WHERE 仍带 domain_status = 0 守卫,重复执行同样安全。
if (domainStatusAdded) {
const [ result ] = await queryInterface.sequelize.query(
`UPDATE \`${TABLE_NAME}\`
SET \`domain_status\` = 1
WHERE \`domain\` IS NOT NULL
AND \`domain\` <> ''
AND \`domain_status\` = 0`
);
const affectedRows = Number(result && result.affectedRows !== undefined ? result.affectedRows : result) || 0;
console.log(`[migration] ${TABLE_NAME} 存量域名回填 domain_status=1,影响行数=${affectedRows}`);
}
},
/**
* 回滚迁移:删除域名验证相关索引与列(幂等)。
* 注意:回滚会一并丢弃域名验证状态与校验记录,域名将退回「无验证闸门」状态。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<void>} 无返回值。
*/
async down(queryInterface) {
if (!(await tableExists(queryInterface, TABLE_NAME))) {
return;
}
if (await indexExists(queryInterface, TABLE_NAME, DOMAIN_STATUS_INDEX_NAME)) {
await queryInterface.removeIndex(TABLE_NAME, DOMAIN_STATUS_INDEX_NAME);
}
const columns = await queryInterface.describeTable(TABLE_NAME);
for (const columnName of [
'domain_last_error',
'domain_verify_attempts',
'domain_verified_at',
'domain_verify_token',
'domain_verify_host',
DOMAIN_STATUS_COLUMN,
]) {
if (columns[columnName]) {
await queryInterface.removeColumn(TABLE_NAME, columnName);
}
}
},
};

View File

@ -178,10 +178,21 @@ const seq = new Sequelize(client.database, client.username || client.user, clien
if (exists) {
const [cols] = await seq.query("SELECT column_name AS cn FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'wms_warehouse_front_config'");
console.log("[DB_PROBE] columns: " + cols.map(r => r.cn).join(","));
const hasDomainStatus = cols.some(r => r.cn === "domain_status");
console.log("[DB_PROBE] domain_status column: " + (hasDomainStatus ? "YES" : "NO"));
const [total] = await seq.query("SELECT COUNT(*) AS c FROM wms_warehouse_front_config");
console.log("[DB_PROBE] total rows: " + total[0].c);
const [dist] = await seq.query("SELECT sync_status AS s, COUNT(*) AS c FROM wms_warehouse_front_config GROUP BY sync_status ORDER BY sync_status");
console.log("[DB_PROBE] sync_status distribution: " + (dist.length ? dist.map(r => r.s + "=" + r.c).join(" ") : "(empty)"));
if (hasDomainStatus) {
const [ddist] = await seq.query("SELECT domain_status AS s, COUNT(*) AS c FROM wms_warehouse_front_config GROUP BY domain_status ORDER BY domain_status");
console.log("[DB_PROBE] domain_status distribution: " + (ddist.length ? ddist.map(r => (r.s === null ? "null" : r.s) + "=" + r.c).join(" ") : "(empty)"));
const sumStatus = want => ddist.filter(r => Number(r.s) === want).reduce((n, r) => n + Number(r.c), 0);
console.log("[DB_PROBE] domain_status counts: 0_unverified=" + sumStatus(0) + " 1_verified=" + sumStatus(1) + " 2_failed=" + sumStatus(2));
console.log("[DB_PROBE] gated-out rows (domain_status 0/2, no nginx server block after gate): " + (sumStatus(0) + sumStatus(2)));
} else {
console.log("[DB_PROBE] domain_status distribution: (column missing, migration not applied; cert-sync falls back to no filter)");
}
}
} catch (e) {
console.log("[DB_PROBE] failed: " + e.message);

View File

@ -473,16 +473,43 @@ function nginxBinExists(nginxBin, nginxPrefix) {
}
/**
* 扫描待同步记录(sync_status=0,按 id 升序,limit 条)。
* 探测 wms_warehouse_front_config 是否已有 domain_status 列。
*
* 域名验证闸门依赖该列;脚本部署早于迁移时该列不存在,需降级为不按验证状态过滤,
* 保证脚本可在迁移前先行部署(与 app/service/systems/frontConfig.js 的降级策略一致)。
* @param {import('sequelize').Sequelize} sequelize Sequelize 实例。
* @return {Promise<boolean>} 存在返回 true;探测失败返回 false。
*/
async function hasDomainStatusColumn(sequelize) {
try {
const rows = await sequelize.query(
`SELECT COUNT(*) AS c FROM information_schema.columns
WHERE table_schema = DATABASE() AND table_name = ? AND column_name = 'domain_status'`,
{ replacements: [ TABLE_NAME ], type: Sequelize.QueryTypes.SELECT }
);
return Number(rows && rows[0] && rows[0].c) > 0;
} catch (error) {
console.warn(`[CERT-SYNC] domain_status 列探测失败(按无该列降级): ${sanitizeErrorText(error.message)}`);
return false;
}
}
/**
* 扫描待同步记录(sync_status=0、且域名已验证 domain_status=1,按 id 升序,limit 条)。
*
* 域名验证闸门:未通过验证(domain_status 为 0/2)的域名不生成 nginx server 块;
* filterVerifiedDomain 为 false 时(迁移尚未执行、无 domain_status 列)降级为不过滤。
* @param {import('sequelize').Sequelize} sequelize Sequelize 实例。
* @param {number} limit 单次处理条数上限。
* @param {boolean} [filterVerifiedDomain] 是否只取已验证域名,默认 true。
* @return {Promise<Object[]>} 待同步记录数组。
*/
async function scanPendingRows(sequelize, limit) {
async function scanPendingRows(sequelize, limit, filterVerifiedDomain = true) {
const verifiedFilter = filterVerifiedDomain ? ' AND domain_status = 1' : '';
return sequelize.query(
`SELECT id, store_id, domain, cert_pem, cert_key, cert_expire_at, sync_attempts
FROM ${TABLE_NAME}
WHERE sync_status = 0
WHERE sync_status = 0${verifiedFilter}
ORDER BY id ASC
LIMIT ?`,
{ replacements: [ limit ], type: Sequelize.QueryTypes.SELECT }
@ -917,7 +944,14 @@ async function main() {
}
}
const rows = await scanPendingRows(sequelize, args.limit);
// 域名验证闸门:迁移尚未执行(无 domain_status 列)时降级为不按验证状态过滤,
// 保证脚本可先行部署;迁移执行后自动生效
const domainStatusReady = await hasDomainStatusColumn(sequelize);
if (!domainStatusReady) {
console.warn('[CERT-SYNC] 未检测到 wms_warehouse_front_config.domain_status 列(迁移尚未执行),本轮降级为不按域名验证状态过滤');
}
const rows = await scanPendingRows(sequelize, args.limit, domainStatusReady);
if (!rows || rows.length === 0) {
console.log('[CERT-SYNC] 无待同步记录,静默退出');
return;