@mzzsfy/dsh-cron-board 0.3.0 → 0.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-cron-board",
   "description": "轻量级定时任务看板:环境变量集中管理与定时任务调度,执行体支持本地脚本与 dsh 会话任务",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/api.mjs

@@ -367,6 +367,9 @@ export function createApi({ store, logger, executor, scheduler, periodic, sessio
         const existing = store.jobs.get(params.id)
         if (!existing) throw new Error(MESSAGES.jobNotFound)
         const fields = normalizeJob({ ...existing, ...body })
+        // 编辑保存:请求未显式携带 nextRunAt 即按当前 schedule 重算。
+        // 合并旧任务行会把既有 nextRunAt 当作显式值透传,改期后残留旧触发点导致误执行
+        if (body.nextRunAt === undefined) fields.nextRunAt = nextRunAtOf(fields.schedule)
         const row = await store.jobs.update(params.id, fields)
         sendJson(res, 200, row)
       },

package/src/scheduler.mjs

@@ -11,12 +11,23 @@ export function createScheduler({ store, executor, readTickMs, now = () => Date.
   // 重入闸门:上一 tick 未完成(store 写链排队/慢盘)时跳过本轮,防同一触发点双触发
   let ticking = false
 
-  // 重启孤儿收尾:上次进程遗留的 queued/running 统一标 interrupted,不误标失败
+  // 历史版本编辑残留的自愈:nextRunAt 不在当前 schedule 的触发点上即重算,
+  // 防残留值到点误执行;合法触发点与空值(无未来触发点)不动,保留宽限执行与 misfire 语义
+  function isLegalTrigger(schedule, at) {
+    return nextRunAtOf(schedule, new Date(at - 1000)) === at
+  }
+
+  // 重启恢复:孤儿运行收尾 + 触发点残留自愈
   async function recover() {
     for (const run of [...store.runs.rows]) {
       if (run.status !== 'queued' && run.status !== 'running') continue
       await store.runs.update(run.runId, { status: 'interrupted', endedAt: now(), message: INTERRUPTED_MESSAGE })
     }
+    for (const job of store.jobs.list()) {
+      if (typeof job.nextRunAt !== 'number' || Number.isNaN(job.nextRunAt)) continue
+      if (isLegalTrigger(job.schedule, job.nextRunAt)) continue
+      await store.jobs.update(job.id, { nextRunAt: nextRunAtOf(job.schedule, new Date(now())) })
+    }
   }
 
   async function tick() {

package/test/routes.test.mjs

@@ -12,6 +12,7 @@ import { createStore } from '../src/store.mjs'
 import { createLogger } from '../src/logger.mjs'
 import { createExecutor } from '../src/executor.mjs'
 import { createApi } from '../src/api.mjs'
+import { nextRunAtOf } from '../src/cron.mjs'
 
 async function makeApi(t, overrides = {}) {
   const dir = await mkdtemp(join(tmpdir(), 'cron-board-api-'))
@@ -192,6 +193,38 @@ test('jobs 路由:非法 cron 表达式被拒', async (t) => {
   assert.match(res.payload.error, /cron/)
 })
 
+test('jobs 路由:编辑保存按当前 schedule 重算 nextRunAt', async (t) => {
+  const { api } = await makeApi(t)
+  // Given 任务按工作日 09:55 排期
+  const created = await call(api, 'POST', '/api/cron-board/jobs', {
+    name: '改期', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+  })
+  assert.equal(created.status, 200)
+  const jobId = created.payload.id
+  const before = created.payload.nextRunAt
+  // When 编辑改为每天 09:00(表单契约:请求体不带 nextRunAt)
+  const patched = await call(api, 'PATCH', '/api/cron-board/jobs/' + jobId, { schedule: '0 9 * * *', prompt: 'x' })
+  // Then 触发点随新表达式重算,不残留工作日旧值
+  assert.equal(patched.status, 200)
+  assert.notEqual(patched.payload.nextRunAt, before)
+  assert.equal(patched.payload.nextRunAt, nextRunAtOf('0 9 * * *'))
+})
+
+test('jobs 路由:PATCH 显式 nextRunAt 优先于重算(导入保留原状态契约)', async (t) => {
+  const { api } = await makeApi(t)
+  const created = await call(api, 'POST', '/api/cron-board/jobs', {
+    name: '导入', kind: 'shell', command: 'x', schedule: '* * * * *',
+  })
+  assert.equal(created.status, 200)
+  // When 请求体显式携带 nextRunAt
+  const patched = await call(api, 'PATCH', '/api/cron-board/jobs/' + created.payload.id, {
+    schedule: '0 9 * * *', nextRunAt: 1750000000000,
+  })
+  // Then 显式值落库,不被重算覆盖
+  assert.equal(patched.status, 200)
+  assert.equal(patched.payload.nextRunAt, 1750000000000)
+})
+
 test('jobs 路由:手动运行端到端——RunRecord 产生、日志可读、状态终态', async (t) => {
   // Given shell 任务(node -e 输出标记)
   const { store, api } = await makeApi(t)

package/test/scheduler.test.mjs

@@ -11,6 +11,7 @@ import { createStore } from '../src/store.mjs'
 import { createLogger } from '../src/logger.mjs'
 import { createExecutor } from '../src/executor.mjs'
 import { createScheduler } from '../src/scheduler.mjs'
+import { nextRunAtOf } from '../src/cron.mjs'
 
 const TICK_MS = 30 * 1000
 
@@ -144,6 +145,52 @@ test('scheduler:recover 将遗留 queued/running 孤儿记录标 interrupted', a
   assert.equal(store.runs.get('r-done').status, 'success')
 })
 
+test('scheduler:recover 自愈残留触发点——nextRunAt 非当前表达式触发点即重算', async (t) => {
+  // Given 旧版本编辑残留:工作日任务带着非工作日表达式的触发点(历史 bug 数据)
+  const { store, scheduler } = await makeScheduler(t)
+  const legal = nextRunAtOf('55 9 * * 1-5')
+  const stale = nextRunAtOf('0 9 * * *')
+  const jobStale = await store.jobs.create({
+    name: '残留', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: true, timeoutMs: 1000, nextRunAt: stale,
+  })
+  const jobStaleDisabled = await store.jobs.create({
+    name: '残留禁用', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: false, timeoutMs: 1000, nextRunAt: stale,
+  })
+  const jobLegal = await store.jobs.create({
+    name: '合法', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: true, timeoutMs: 1000, nextRunAt: legal,
+  })
+  const jobNull = await store.jobs.create({
+    name: '空值', kind: 'shell', command: 'x', schedule: '0 0 30 2 *',
+    enabled: true, timeoutMs: 1000, nextRunAt: null,
+  })
+  // When 重启恢复
+  await scheduler.recover()
+  // Then 残留值(启用与禁用)按当前 schedule 重算为合法触发点;合法值与空值不动
+  assert.equal(store.jobs.get(jobStale.id).nextRunAt, legal)
+  assert.equal(store.jobs.get(jobStaleDisabled.id).nextRunAt, legal)
+  assert.equal(store.jobs.get(jobLegal.id).nextRunAt, legal)
+  assert.equal(store.jobs.get(jobNull.id).nextRunAt, null)
+})
+
+test('scheduler:recover 自愈幂等——修复后的数据再次恢复不再改写', async (t) => {
+  const { store, scheduler } = await makeScheduler(t)
+  const legal = nextRunAtOf('55 9 * * 1-5')
+  const job = await store.jobs.create({
+    name: '残留', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: true, timeoutMs: 1000, nextRunAt: nextRunAtOf('0 9 * * *'),
+  })
+  await scheduler.recover()
+  assert.equal(store.jobs.get(job.id).nextRunAt, legal)
+  // When 时钟推进后再次恢复
+  await new Promise((resolve) => setTimeout(resolve, 1100))
+  await scheduler.recover()
+  // Then 已合法的触发点不被重算推迟
+  assert.equal(store.jobs.get(job.id).nextRunAt, legal)
+})
+
 test('scheduler:并发闸门——maxConcurrent=1 时第二个单元排队,首个完成后推进', async (t) => {
   // Given 两个任务同时到期,全局并发 1
   const { store, runner, scheduler, advance } = await makeScheduler(t, { maxConcurrent: 1 })