@h-ai/scheduler 1.0.0-beta.2 → 1.0.0-beta.20
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.en.md +94 -39
- package/README.ja.md +93 -38
- package/README.md +93 -38
- package/dist/index.d.ts +2 -1
- package/dist/index.js +805 -200
- package/dist/index.js.map +1 -1
- package/dist/scheduler-js-worker.d.ts +6 -1
- package/dist/scheduler-js-worker.js +4 -1
- package/dist/scheduler-js-worker.js.map +1 -1
- package/package.json +10 -10
package/dist/index.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { z } from 'zod';
|
|
2
2
|
import { core, ok, err, HaiCommonError } from '@h-ai/core';
|
|
3
|
-
import {
|
|
3
|
+
import { reldb, BaseReldbCrudRepository } from '@h-ai/reldb';
|
|
4
4
|
import { randomUUID, createHash } from 'crypto';
|
|
5
5
|
import { isDeepStrictEqual } from 'util';
|
|
6
6
|
import { Cron } from 'croner';
|
|
@@ -176,7 +176,15 @@ function executionId(taskId, type, key) {
|
|
|
176
176
|
return createHash("sha256").update(JSON.stringify([taskId, type, key])).digest("hex");
|
|
177
177
|
}
|
|
178
178
|
function executionEntry(row) {
|
|
179
|
-
return {
|
|
179
|
+
return {
|
|
180
|
+
occurrenceId: row.occurrenceId,
|
|
181
|
+
taskId: row.taskId,
|
|
182
|
+
status: row.status,
|
|
183
|
+
sequence: row.sequence,
|
|
184
|
+
attemptCount: row.attemptCount,
|
|
185
|
+
updatedAt: row.updatedAt,
|
|
186
|
+
logPersistence: row.logPersistence
|
|
187
|
+
};
|
|
180
188
|
}
|
|
181
189
|
function failed(cause) {
|
|
182
190
|
return err(HaiSchedulerError.DB_SAVE_FAILED, schedulerM("scheduler_executionStateFailed"), cause);
|
|
@@ -188,22 +196,58 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
188
196
|
idColumn: "sequence",
|
|
189
197
|
idField: "sequence",
|
|
190
198
|
fields: [
|
|
191
|
-
{
|
|
199
|
+
{
|
|
200
|
+
fieldName: "sequence",
|
|
201
|
+
columnName: "sequence",
|
|
202
|
+
def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
|
|
203
|
+
select: true,
|
|
204
|
+
create: false,
|
|
205
|
+
update: false
|
|
206
|
+
},
|
|
192
207
|
...[
|
|
193
|
-
[
|
|
208
|
+
[
|
|
209
|
+
"occurrenceId",
|
|
210
|
+
"occurrence_id",
|
|
211
|
+
true,
|
|
212
|
+
true
|
|
213
|
+
],
|
|
194
214
|
["taskId", "task_id", true, false],
|
|
195
|
-
[
|
|
215
|
+
[
|
|
216
|
+
"activeTask",
|
|
217
|
+
"active_task",
|
|
218
|
+
false,
|
|
219
|
+
true
|
|
220
|
+
],
|
|
196
221
|
["status", "status", true, false],
|
|
197
222
|
["owner", "owner", false, false],
|
|
198
223
|
["snapshot", "snapshot", true, false],
|
|
199
|
-
[
|
|
224
|
+
[
|
|
225
|
+
"triggerJson",
|
|
226
|
+
"trigger_json",
|
|
227
|
+
true,
|
|
228
|
+
false
|
|
229
|
+
],
|
|
200
230
|
["logJson", "log_json", false, false],
|
|
201
231
|
["logsJson", "logs_json", false, false],
|
|
202
|
-
[
|
|
232
|
+
[
|
|
233
|
+
"logPersistence",
|
|
234
|
+
"log_persistence",
|
|
235
|
+
true,
|
|
236
|
+
false
|
|
237
|
+
]
|
|
203
238
|
].map(([fieldName, columnName, notNull, unique]) => ({
|
|
204
239
|
fieldName: String(fieldName),
|
|
205
240
|
columnName: String(columnName),
|
|
206
|
-
def: {
|
|
241
|
+
def: {
|
|
242
|
+
type: [
|
|
243
|
+
"snapshot",
|
|
244
|
+
"triggerJson",
|
|
245
|
+
"logJson",
|
|
246
|
+
"logsJson"
|
|
247
|
+
].includes(String(fieldName)) ? "JSON" : "TEXT",
|
|
248
|
+
notNull: Boolean(notNull),
|
|
249
|
+
unique: Boolean(unique)
|
|
250
|
+
},
|
|
207
251
|
select: true,
|
|
208
252
|
create: true,
|
|
209
253
|
update: true
|
|
@@ -222,7 +266,14 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
222
266
|
create: true,
|
|
223
267
|
update: true
|
|
224
268
|
})),
|
|
225
|
-
{
|
|
269
|
+
{
|
|
270
|
+
fieldName: "idempotent",
|
|
271
|
+
columnName: "idempotent",
|
|
272
|
+
def: { type: "BOOLEAN", notNull: true },
|
|
273
|
+
select: true,
|
|
274
|
+
create: true,
|
|
275
|
+
update: true
|
|
276
|
+
}
|
|
226
277
|
]
|
|
227
278
|
});
|
|
228
279
|
}
|
|
@@ -260,11 +311,23 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
260
311
|
/** 读取统一校验 BIGINT,不能把 PG 字符串时间或舍入的序号用于 owner 判断。 */
|
|
261
312
|
normalize(row) {
|
|
262
313
|
const value = { ...row };
|
|
263
|
-
for (const field of [
|
|
314
|
+
for (const field of [
|
|
315
|
+
"snapshot",
|
|
316
|
+
"triggerJson",
|
|
317
|
+
"logJson",
|
|
318
|
+
"logsJson"
|
|
319
|
+
]) {
|
|
264
320
|
if (row[field] !== void 0 && row[field] !== null && typeof row[field] !== "string")
|
|
265
321
|
value[field] = JSON.stringify(row[field]);
|
|
266
322
|
}
|
|
267
|
-
for (const field of [
|
|
323
|
+
for (const field of [
|
|
324
|
+
"sequence",
|
|
325
|
+
"leasedUntil",
|
|
326
|
+
"attemptCount",
|
|
327
|
+
"maxAttempts",
|
|
328
|
+
"updatedAt",
|
|
329
|
+
"createdAt"
|
|
330
|
+
]) {
|
|
268
331
|
const number = Number(row[field]);
|
|
269
332
|
if (!Number.isSafeInteger(number) || number < 0)
|
|
270
333
|
return failed();
|
|
@@ -274,7 +337,11 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
274
337
|
}
|
|
275
338
|
/** 按稳定回执读取。@example await repository.byOccurrence(id) */
|
|
276
339
|
async byOccurrence(id) {
|
|
277
|
-
const rows = await this.findAll({
|
|
340
|
+
const rows = await this.findAll({
|
|
341
|
+
where: "occurrence_id = ?",
|
|
342
|
+
params: [id],
|
|
343
|
+
limit: 1
|
|
344
|
+
});
|
|
278
345
|
if (!rows.success)
|
|
279
346
|
return failed(rows.error);
|
|
280
347
|
return rows.data[0] ? this.normalize(rows.data[0]) : ok(null);
|
|
@@ -288,7 +355,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
288
355
|
const result = await this.db.sql.execute(
|
|
289
356
|
`UPDATE ${TABLE} SET status = ?, owner = NULL, leased_until = 0, updated_at = ${this.nextUpdatedAt()}
|
|
290
357
|
WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${this.databaseClock()} AND status IN (?, ?)`,
|
|
291
|
-
[
|
|
358
|
+
[
|
|
359
|
+
"unknown",
|
|
360
|
+
row.occurrenceId,
|
|
361
|
+
row.owner,
|
|
362
|
+
"claimed",
|
|
363
|
+
"running"
|
|
364
|
+
]
|
|
292
365
|
);
|
|
293
366
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
294
367
|
}
|
|
@@ -311,7 +384,18 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
311
384
|
const result = await this.db.sql.execute(
|
|
312
385
|
`UPDATE ${TABLE} SET log_persistence = ?, log_json = ?, updated_at = ${this.nextUpdatedAt()}
|
|
313
386
|
WHERE occurrence_id = ? AND updated_at = ? AND log_persistence = ? AND status NOT IN (?, ?)`,
|
|
314
|
-
[
|
|
387
|
+
[
|
|
388
|
+
"persisted",
|
|
389
|
+
JSON.stringify({
|
|
390
|
+
...log,
|
|
391
|
+
persistence: { status: "persisted" }
|
|
392
|
+
}),
|
|
393
|
+
row.occurrenceId,
|
|
394
|
+
row.updatedAt,
|
|
395
|
+
"pending",
|
|
396
|
+
"claimed",
|
|
397
|
+
"running"
|
|
398
|
+
]
|
|
315
399
|
);
|
|
316
400
|
if (result.success && result.data.changes === 1)
|
|
317
401
|
return ok(void 0);
|
|
@@ -319,7 +403,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
319
403
|
return current.success && current.data?.logPersistence === "persisted" && current.data.logsJson === row.logsJson ? ok(void 0) : failed();
|
|
320
404
|
}
|
|
321
405
|
async rows(where, params, limit, offset) {
|
|
322
|
-
const result = await this.findAll({
|
|
406
|
+
const result = await this.findAll({
|
|
407
|
+
where,
|
|
408
|
+
params,
|
|
409
|
+
limit,
|
|
410
|
+
offset,
|
|
411
|
+
orderBy: "sequence ASC"
|
|
412
|
+
});
|
|
323
413
|
if (!result.success)
|
|
324
414
|
return failed(result.error);
|
|
325
415
|
const rows = [];
|
|
@@ -341,26 +431,52 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
341
431
|
return failed(ready.error);
|
|
342
432
|
const clock = this.databaseClock();
|
|
343
433
|
const owner = `${nodeId}:${randomUUID()}`;
|
|
434
|
+
const postgres = this.db.config?.type === "postgresql";
|
|
435
|
+
const conflictClause = postgres ? " ON CONFLICT DO NOTHING" : "";
|
|
344
436
|
let created;
|
|
345
437
|
try {
|
|
346
438
|
created = await this.db.sql.execute(
|
|
347
439
|
`INSERT INTO ${TABLE} (occurrence_id, task_id, active_task, status, owner, leased_until, attempt_count, max_attempts, idempotent, snapshot, trigger_json, log_persistence, updated_at, created_at)
|
|
348
|
-
VALUES (?, ?, ?, ?, ?, ${clock} + ?, 0, ?, ?, ?, ?, ?, ${clock}, ${clock})`,
|
|
349
|
-
[
|
|
440
|
+
VALUES (?, ?, ?, ?, ?, ${clock} + ?, 0, ?, ?, ?, ?, ?, ${clock}, ${clock})${conflictClause}`,
|
|
441
|
+
[
|
|
442
|
+
id,
|
|
443
|
+
task.id,
|
|
444
|
+
task.id,
|
|
445
|
+
"claimed",
|
|
446
|
+
owner,
|
|
447
|
+
leaseMs,
|
|
448
|
+
task.retry?.maxAttempts ?? 1,
|
|
449
|
+
postgres ? task.idempotent === true : Number(task.idempotent === true),
|
|
450
|
+
JSON.stringify(task),
|
|
451
|
+
JSON.stringify(trigger),
|
|
452
|
+
"unconfirmed"
|
|
453
|
+
]
|
|
350
454
|
);
|
|
351
455
|
} catch (cause) {
|
|
352
456
|
return failed(cause);
|
|
353
457
|
}
|
|
458
|
+
if (postgres && !created.success)
|
|
459
|
+
return failed(created.error);
|
|
354
460
|
const existing = await this.byOccurrence(id);
|
|
355
461
|
if (!existing.success)
|
|
356
462
|
return existing;
|
|
357
463
|
if (!existing.data) {
|
|
358
|
-
const active = await this.findAll({
|
|
464
|
+
const active = await this.findAll({
|
|
465
|
+
where: "active_task = ?",
|
|
466
|
+
params: [task.id],
|
|
467
|
+
limit: 1
|
|
468
|
+
});
|
|
359
469
|
return active.success && active.data.length > 0 ? ok(null) : failed(created.success ? void 0 : created.error);
|
|
360
470
|
}
|
|
361
471
|
const row = existing.data;
|
|
362
|
-
if (created.success
|
|
472
|
+
if (created.success && created.data.changes === 1 || [
|
|
473
|
+
"success",
|
|
474
|
+
"failed",
|
|
475
|
+
"interrupted",
|
|
476
|
+
"discarded"
|
|
477
|
+
].includes(row.status)) {
|
|
363
478
|
return ok(row);
|
|
479
|
+
}
|
|
364
480
|
if (row.status === "unknown")
|
|
365
481
|
return ok(null);
|
|
366
482
|
if (row.status === "running" && (!row.idempotent || row.attemptCount >= row.maxAttempts)) {
|
|
@@ -374,7 +490,15 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
374
490
|
const recovered = await this.db.sql.execute(
|
|
375
491
|
`UPDATE ${TABLE} SET status = ?, owner = ?, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
|
|
376
492
|
WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${clock} AND status IN (?, ?)`,
|
|
377
|
-
[
|
|
493
|
+
[
|
|
494
|
+
"claimed",
|
|
495
|
+
owner,
|
|
496
|
+
leaseMs,
|
|
497
|
+
id,
|
|
498
|
+
row.owner,
|
|
499
|
+
"claimed",
|
|
500
|
+
"running"
|
|
501
|
+
]
|
|
378
502
|
);
|
|
379
503
|
if (!recovered.success)
|
|
380
504
|
return failed(recovered.error);
|
|
@@ -386,7 +510,14 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
386
510
|
const result = await this.db.sql.execute(
|
|
387
511
|
`UPDATE ${TABLE} SET status = ?, attempt_count = attempt_count + 1, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
|
|
388
512
|
WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?) AND attempt_count < max_attempts`,
|
|
389
|
-
[
|
|
513
|
+
[
|
|
514
|
+
"running",
|
|
515
|
+
leaseMs,
|
|
516
|
+
row.occurrenceId,
|
|
517
|
+
row.owner,
|
|
518
|
+
"claimed",
|
|
519
|
+
"running"
|
|
520
|
+
]
|
|
390
521
|
);
|
|
391
522
|
if (!result.success || result.data.changes !== 1)
|
|
392
523
|
return failed(result.success ? void 0 : result.error);
|
|
@@ -399,7 +530,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
399
530
|
const clock = this.databaseClock();
|
|
400
531
|
const result = await this.db.sql.execute(
|
|
401
532
|
`UPDATE ${TABLE} SET leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
|
|
402
|
-
[
|
|
533
|
+
[
|
|
534
|
+
leaseMs,
|
|
535
|
+
row.occurrenceId,
|
|
536
|
+
row.owner,
|
|
537
|
+
"claimed",
|
|
538
|
+
"running"
|
|
539
|
+
]
|
|
403
540
|
);
|
|
404
541
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
405
542
|
}
|
|
@@ -409,7 +546,17 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
409
546
|
const result = await this.db.sql.execute(
|
|
410
547
|
`UPDATE ${TABLE} SET status = ?, active_task = ?, owner = NULL, leased_until = 0, log_json = ?, logs_json = ?, log_persistence = ?, updated_at = ${this.nextUpdatedAt()}
|
|
411
548
|
WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
|
|
412
|
-
[
|
|
549
|
+
[
|
|
550
|
+
log.status,
|
|
551
|
+
log.status === "unknown" ? row.taskId : null,
|
|
552
|
+
JSON.stringify(log),
|
|
553
|
+
JSON.stringify(logs),
|
|
554
|
+
"pending",
|
|
555
|
+
row.occurrenceId,
|
|
556
|
+
row.owner,
|
|
557
|
+
"claimed",
|
|
558
|
+
"running"
|
|
559
|
+
]
|
|
413
560
|
);
|
|
414
561
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
415
562
|
}
|
|
@@ -417,7 +564,12 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
417
564
|
async resolve(id, status, expectedUpdatedAt) {
|
|
418
565
|
const result = await this.db.sql.execute(
|
|
419
566
|
`UPDATE ${TABLE} SET status = ?, active_task = NULL, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND status = ? AND updated_at = ?`,
|
|
420
|
-
[
|
|
567
|
+
[
|
|
568
|
+
status,
|
|
569
|
+
id,
|
|
570
|
+
"unknown",
|
|
571
|
+
expectedUpdatedAt
|
|
572
|
+
]
|
|
421
573
|
);
|
|
422
574
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
423
575
|
}
|
|
@@ -430,18 +582,102 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
430
582
|
table: SCHEDULER_LOG_TABLE,
|
|
431
583
|
idColumn: "id",
|
|
432
584
|
fields: [
|
|
433
|
-
{
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
{
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
585
|
+
{
|
|
586
|
+
fieldName: "id",
|
|
587
|
+
columnName: "id",
|
|
588
|
+
def: { type: "TEXT", primaryKey: true },
|
|
589
|
+
select: true,
|
|
590
|
+
create: true,
|
|
591
|
+
update: false
|
|
592
|
+
},
|
|
593
|
+
{
|
|
594
|
+
fieldName: "occurrenceId",
|
|
595
|
+
columnName: "occurrence_id",
|
|
596
|
+
def: { type: "TEXT" },
|
|
597
|
+
select: true,
|
|
598
|
+
create: true,
|
|
599
|
+
update: false
|
|
600
|
+
},
|
|
601
|
+
{
|
|
602
|
+
fieldName: "taskId",
|
|
603
|
+
columnName: "task_id",
|
|
604
|
+
def: { type: "TEXT", notNull: true },
|
|
605
|
+
select: true,
|
|
606
|
+
create: true,
|
|
607
|
+
update: false
|
|
608
|
+
},
|
|
609
|
+
{
|
|
610
|
+
fieldName: "taskName",
|
|
611
|
+
columnName: "task_name",
|
|
612
|
+
def: { type: "TEXT", notNull: true },
|
|
613
|
+
select: true,
|
|
614
|
+
create: true,
|
|
615
|
+
update: false
|
|
616
|
+
},
|
|
617
|
+
{
|
|
618
|
+
fieldName: "taskType",
|
|
619
|
+
columnName: "task_type",
|
|
620
|
+
def: { type: "TEXT", notNull: true },
|
|
621
|
+
select: true,
|
|
622
|
+
create: true,
|
|
623
|
+
update: false
|
|
624
|
+
},
|
|
625
|
+
{
|
|
626
|
+
fieldName: "triggerType",
|
|
627
|
+
columnName: "trigger_type",
|
|
628
|
+
def: { type: "TEXT", notNull: true },
|
|
629
|
+
select: true,
|
|
630
|
+
create: true,
|
|
631
|
+
update: false
|
|
632
|
+
},
|
|
633
|
+
{
|
|
634
|
+
fieldName: "triggerSource",
|
|
635
|
+
columnName: "trigger_source",
|
|
636
|
+
def: { type: "TEXT" },
|
|
637
|
+
select: true,
|
|
638
|
+
create: true,
|
|
639
|
+
update: false
|
|
640
|
+
},
|
|
641
|
+
{
|
|
642
|
+
fieldName: "status",
|
|
643
|
+
columnName: "status",
|
|
644
|
+
def: { type: "TEXT", notNull: true },
|
|
645
|
+
select: true,
|
|
646
|
+
create: true,
|
|
647
|
+
update: false
|
|
648
|
+
},
|
|
649
|
+
{
|
|
650
|
+
fieldName: "payload",
|
|
651
|
+
columnName: "payload",
|
|
652
|
+
def: { type: "JSON", notNull: true },
|
|
653
|
+
select: true,
|
|
654
|
+
create: true,
|
|
655
|
+
update: false
|
|
656
|
+
},
|
|
657
|
+
{
|
|
658
|
+
fieldName: "startedAt",
|
|
659
|
+
columnName: "started_at",
|
|
660
|
+
def: { type: "BIGINT", notNull: true },
|
|
661
|
+
select: true,
|
|
662
|
+
create: true,
|
|
663
|
+
update: false
|
|
664
|
+
},
|
|
665
|
+
{
|
|
666
|
+
fieldName: "finishedAt",
|
|
667
|
+
columnName: "finished_at",
|
|
668
|
+
def: { type: "BIGINT", notNull: true },
|
|
669
|
+
select: true,
|
|
670
|
+
create: true,
|
|
671
|
+
update: false
|
|
672
|
+
},
|
|
673
|
+
{
|
|
674
|
+
fieldName: "duration",
|
|
675
|
+
columnName: "duration",
|
|
676
|
+
def: { type: "INTEGER", notNull: true },
|
|
677
|
+
select: true,
|
|
678
|
+
create: true,
|
|
679
|
+
update: false
|
|
680
|
+
}
|
|
445
681
|
]
|
|
446
682
|
});
|
|
447
683
|
}
|
|
@@ -450,7 +686,10 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
450
686
|
* @example `const saved = await repository.saveLog(log); if (!saved.success) return saved`
|
|
451
687
|
*/
|
|
452
688
|
async saveLog(log) {
|
|
453
|
-
const payload = {
|
|
689
|
+
const payload = {
|
|
690
|
+
...log,
|
|
691
|
+
persistence: { status: "persisted" }
|
|
692
|
+
};
|
|
454
693
|
try {
|
|
455
694
|
const created = await this.create({
|
|
456
695
|
id: log.id,
|
|
@@ -517,20 +756,27 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
517
756
|
if (!pageResult.success) {
|
|
518
757
|
return err(
|
|
519
758
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
520
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
759
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
760
|
+
params: { error: pageResult.error.message }
|
|
761
|
+
}),
|
|
521
762
|
pageResult.error
|
|
522
763
|
);
|
|
523
764
|
}
|
|
524
765
|
return ok({
|
|
525
766
|
...pageResult.data,
|
|
526
|
-
items: pageResult.data.items.map((row) => ({
|
|
767
|
+
items: pageResult.data.items.map((row) => ({
|
|
768
|
+
...row.payload,
|
|
769
|
+
persistence: { status: "persisted" }
|
|
770
|
+
}))
|
|
527
771
|
});
|
|
528
772
|
} catch (error) {
|
|
529
773
|
logger.error("Failed to query execution logs", { error });
|
|
530
774
|
return err(
|
|
531
775
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
532
776
|
schedulerM("scheduler_dbSaveFailed", {
|
|
533
|
-
params: {
|
|
777
|
+
params: {
|
|
778
|
+
error: error instanceof Error ? error.message : String(error)
|
|
779
|
+
}
|
|
534
780
|
}),
|
|
535
781
|
error
|
|
536
782
|
);
|
|
@@ -550,7 +796,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
550
796
|
if (!retentionResult.success) {
|
|
551
797
|
return err(
|
|
552
798
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
553
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
799
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
800
|
+
params: { error: retentionResult.error.message }
|
|
801
|
+
}),
|
|
554
802
|
retentionResult.error
|
|
555
803
|
);
|
|
556
804
|
}
|
|
@@ -571,7 +819,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
571
819
|
if (!maxLogsResult.success) {
|
|
572
820
|
return err(
|
|
573
821
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
574
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
822
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
823
|
+
params: { error: maxLogsResult.error.message }
|
|
824
|
+
}),
|
|
575
825
|
maxLogsResult.error
|
|
576
826
|
);
|
|
577
827
|
}
|
|
@@ -582,7 +832,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
582
832
|
return err(
|
|
583
833
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
584
834
|
schedulerM("scheduler_dbSaveFailed", {
|
|
585
|
-
params: {
|
|
835
|
+
params: {
|
|
836
|
+
error: error instanceof Error ? error.message : String(error)
|
|
837
|
+
}
|
|
586
838
|
}),
|
|
587
839
|
error
|
|
588
840
|
);
|
|
@@ -599,7 +851,13 @@ var TaskRetryPolicySchema = z.object({
|
|
|
599
851
|
var ApiTaskConfigSchema = z.object({
|
|
600
852
|
kind: z.literal("api"),
|
|
601
853
|
url: z.string().min(1),
|
|
602
|
-
method: z.enum([
|
|
854
|
+
method: z.enum([
|
|
855
|
+
"GET",
|
|
856
|
+
"POST",
|
|
857
|
+
"PUT",
|
|
858
|
+
"DELETE",
|
|
859
|
+
"PATCH"
|
|
860
|
+
]).optional(),
|
|
603
861
|
headers: z.record(z.string(), z.string()).optional(),
|
|
604
862
|
body: z.unknown().optional(),
|
|
605
863
|
timeout: z.number().int().positive().optional(),
|
|
@@ -617,20 +875,118 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
617
875
|
table: SCHEDULER_TASK_TABLE,
|
|
618
876
|
idColumn: "id",
|
|
619
877
|
fields: [
|
|
620
|
-
{
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
{
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
878
|
+
{
|
|
879
|
+
fieldName: "id",
|
|
880
|
+
columnName: "id",
|
|
881
|
+
def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
|
|
882
|
+
select: true,
|
|
883
|
+
create: false,
|
|
884
|
+
update: false
|
|
885
|
+
},
|
|
886
|
+
{
|
|
887
|
+
fieldName: "taskId",
|
|
888
|
+
columnName: "task_id",
|
|
889
|
+
def: { type: "TEXT", notNull: true, unique: true },
|
|
890
|
+
select: true,
|
|
891
|
+
create: true,
|
|
892
|
+
update: false
|
|
893
|
+
},
|
|
894
|
+
{
|
|
895
|
+
fieldName: "taskName",
|
|
896
|
+
columnName: "task_name",
|
|
897
|
+
def: { type: "TEXT", notNull: true },
|
|
898
|
+
select: true,
|
|
899
|
+
create: true,
|
|
900
|
+
update: true
|
|
901
|
+
},
|
|
902
|
+
{
|
|
903
|
+
fieldName: "description",
|
|
904
|
+
columnName: "description",
|
|
905
|
+
def: { type: "TEXT" },
|
|
906
|
+
select: true,
|
|
907
|
+
create: true,
|
|
908
|
+
update: true
|
|
909
|
+
},
|
|
910
|
+
{
|
|
911
|
+
fieldName: "cron",
|
|
912
|
+
columnName: "cron",
|
|
913
|
+
def: { type: "TEXT", notNull: true },
|
|
914
|
+
select: true,
|
|
915
|
+
create: true,
|
|
916
|
+
update: true
|
|
917
|
+
},
|
|
918
|
+
{
|
|
919
|
+
fieldName: "timezone",
|
|
920
|
+
columnName: "timezone",
|
|
921
|
+
def: { type: "TEXT" },
|
|
922
|
+
select: true,
|
|
923
|
+
create: true,
|
|
924
|
+
update: true
|
|
925
|
+
},
|
|
926
|
+
{
|
|
927
|
+
fieldName: "enabled",
|
|
928
|
+
columnName: "enabled",
|
|
929
|
+
def: { type: "BOOLEAN", notNull: true, defaultValue: true },
|
|
930
|
+
select: true,
|
|
931
|
+
create: true,
|
|
932
|
+
update: true
|
|
933
|
+
},
|
|
934
|
+
{
|
|
935
|
+
fieldName: "idempotent",
|
|
936
|
+
columnName: "idempotent",
|
|
937
|
+
def: { type: "BOOLEAN", notNull: true, defaultValue: false },
|
|
938
|
+
select: true,
|
|
939
|
+
create: true,
|
|
940
|
+
update: true
|
|
941
|
+
},
|
|
942
|
+
{
|
|
943
|
+
fieldName: "deleteAfterRun",
|
|
944
|
+
columnName: "delete_after_run",
|
|
945
|
+
def: { type: "BOOLEAN", notNull: true, defaultValue: false },
|
|
946
|
+
select: true,
|
|
947
|
+
create: true,
|
|
948
|
+
update: true
|
|
949
|
+
},
|
|
950
|
+
{
|
|
951
|
+
fieldName: "retry",
|
|
952
|
+
columnName: "retry",
|
|
953
|
+
def: { type: "JSON" },
|
|
954
|
+
select: true,
|
|
955
|
+
create: true,
|
|
956
|
+
update: true
|
|
957
|
+
},
|
|
958
|
+
{
|
|
959
|
+
fieldName: "params",
|
|
960
|
+
columnName: "params",
|
|
961
|
+
def: { type: "JSON" },
|
|
962
|
+
select: true,
|
|
963
|
+
create: true,
|
|
964
|
+
update: true
|
|
965
|
+
},
|
|
966
|
+
{
|
|
967
|
+
fieldName: "handler",
|
|
968
|
+
columnName: "handler",
|
|
969
|
+
def: { type: "JSON" },
|
|
970
|
+
select: true,
|
|
971
|
+
create: true,
|
|
972
|
+
update: true
|
|
973
|
+
},
|
|
974
|
+
{
|
|
975
|
+
fieldName: "createdAt",
|
|
976
|
+
columnName: "created_at",
|
|
977
|
+
def: { type: "TIMESTAMP" },
|
|
978
|
+
select: true,
|
|
979
|
+
create: true,
|
|
980
|
+
update: false
|
|
981
|
+
},
|
|
982
|
+
{
|
|
983
|
+
fieldName: "updatedAt",
|
|
984
|
+
columnName: "updated_at",
|
|
985
|
+
def: { type: "TIMESTAMP" },
|
|
986
|
+
select: true,
|
|
987
|
+
create: false,
|
|
988
|
+
update: true
|
|
989
|
+
}
|
|
634
990
|
]
|
|
635
991
|
});
|
|
636
992
|
}
|
|
@@ -654,7 +1010,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
654
1010
|
logger2.error("Failed to save task definition", { taskId: task.id, error: createResult.error.message });
|
|
655
1011
|
return err(
|
|
656
1012
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
657
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1013
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1014
|
+
params: { error: createResult.error.message }
|
|
1015
|
+
}),
|
|
658
1016
|
createResult.error
|
|
659
1017
|
);
|
|
660
1018
|
}
|
|
@@ -664,7 +1022,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
664
1022
|
return err(
|
|
665
1023
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
666
1024
|
schedulerM("scheduler_dbSaveFailed", {
|
|
667
|
-
params: {
|
|
1025
|
+
params: {
|
|
1026
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1027
|
+
}
|
|
668
1028
|
}),
|
|
669
1029
|
error
|
|
670
1030
|
);
|
|
@@ -672,11 +1032,17 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
672
1032
|
}
|
|
673
1033
|
async updateTask(taskId, updates) {
|
|
674
1034
|
try {
|
|
675
|
-
const rows = await this.findAll({
|
|
1035
|
+
const rows = await this.findAll({
|
|
1036
|
+
where: "task_id = ?",
|
|
1037
|
+
params: [taskId],
|
|
1038
|
+
limit: 1
|
|
1039
|
+
});
|
|
676
1040
|
if (!rows.success) {
|
|
677
1041
|
return err(
|
|
678
1042
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
679
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1043
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1044
|
+
params: { error: rows.error.message }
|
|
1045
|
+
}),
|
|
680
1046
|
rows.error
|
|
681
1047
|
);
|
|
682
1048
|
}
|
|
@@ -711,7 +1077,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
711
1077
|
logger2.error("Failed to update task definition", { taskId, error: updateResult.error.message });
|
|
712
1078
|
return err(
|
|
713
1079
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
714
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1080
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1081
|
+
params: { error: updateResult.error.message }
|
|
1082
|
+
}),
|
|
715
1083
|
updateResult.error
|
|
716
1084
|
);
|
|
717
1085
|
}
|
|
@@ -721,7 +1089,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
721
1089
|
return err(
|
|
722
1090
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
723
1091
|
schedulerM("scheduler_dbSaveFailed", {
|
|
724
|
-
params: {
|
|
1092
|
+
params: {
|
|
1093
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1094
|
+
}
|
|
725
1095
|
}),
|
|
726
1096
|
error
|
|
727
1097
|
);
|
|
@@ -731,13 +1101,35 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
731
1101
|
async deleteTask(taskId, expected) {
|
|
732
1102
|
try {
|
|
733
1103
|
if (expected) {
|
|
734
|
-
const conditions = [
|
|
1104
|
+
const conditions = [
|
|
1105
|
+
"task_id = ?",
|
|
1106
|
+
"task_name = ?",
|
|
1107
|
+
"cron = ?",
|
|
1108
|
+
"COALESCE(timezone, '') = ?",
|
|
1109
|
+
"COALESCE(description, '') = ?",
|
|
1110
|
+
"enabled = ?",
|
|
1111
|
+
"delete_after_run = ?",
|
|
1112
|
+
"idempotent = ?"
|
|
1113
|
+
];
|
|
735
1114
|
const postgres = this.db.config?.type === "postgresql";
|
|
736
1115
|
const enabled = expected.enabled !== false;
|
|
737
1116
|
const deleteAfterRun = expected.deleteAfterRun === true;
|
|
738
|
-
const params = [
|
|
1117
|
+
const params = [
|
|
1118
|
+
taskId,
|
|
1119
|
+
expected.name,
|
|
1120
|
+
expected.cron,
|
|
1121
|
+
expected.timezone ?? "",
|
|
1122
|
+
expected.description ?? "",
|
|
1123
|
+
postgres ? enabled : Number(enabled),
|
|
1124
|
+
postgres ? deleteAfterRun : Number(deleteAfterRun),
|
|
1125
|
+
postgres ? expected.idempotent === true : Number(expected.idempotent === true)
|
|
1126
|
+
];
|
|
739
1127
|
const jsonValue = this.db.config?.type === "mysql" ? "CAST(? AS JSON)" : this.db.config?.type === "postgresql" ? "CAST(? AS JSONB)" : "?";
|
|
740
|
-
const jsonFields = [
|
|
1128
|
+
const jsonFields = [
|
|
1129
|
+
["retry", expected.retry],
|
|
1130
|
+
["params", expected.params ?? {}],
|
|
1131
|
+
["handler", expected.handler]
|
|
1132
|
+
];
|
|
741
1133
|
for (const [column, value] of jsonFields) {
|
|
742
1134
|
if (value === void 0 || value === null) {
|
|
743
1135
|
conditions.push(`(${column} IS NULL OR ${column} = ${jsonValue})`);
|
|
@@ -750,11 +1142,17 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
750
1142
|
const deleted = await this.db.sql.execute(`DELETE FROM ${SCHEDULER_TASK_TABLE} WHERE ${conditions.join(" AND ")}`, params);
|
|
751
1143
|
return deleted.success ? ok(deleted.data.changes > 0) : deleted;
|
|
752
1144
|
}
|
|
753
|
-
const rows = await this.findAll({
|
|
1145
|
+
const rows = await this.findAll({
|
|
1146
|
+
where: "task_id = ?",
|
|
1147
|
+
params: [taskId],
|
|
1148
|
+
limit: 1
|
|
1149
|
+
});
|
|
754
1150
|
if (!rows.success) {
|
|
755
1151
|
return err(
|
|
756
1152
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
757
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1153
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1154
|
+
params: { error: rows.error.message }
|
|
1155
|
+
}),
|
|
758
1156
|
rows.error
|
|
759
1157
|
);
|
|
760
1158
|
}
|
|
@@ -765,7 +1163,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
765
1163
|
logger2.error("Failed to delete task definition", { taskId, error: deleteResult.error.message });
|
|
766
1164
|
return err(
|
|
767
1165
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
768
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1166
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1167
|
+
params: { error: deleteResult.error.message }
|
|
1168
|
+
}),
|
|
769
1169
|
deleteResult.error
|
|
770
1170
|
);
|
|
771
1171
|
}
|
|
@@ -775,7 +1175,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
775
1175
|
return err(
|
|
776
1176
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
777
1177
|
schedulerM("scheduler_dbSaveFailed", {
|
|
778
|
-
params: {
|
|
1178
|
+
params: {
|
|
1179
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1180
|
+
}
|
|
779
1181
|
}),
|
|
780
1182
|
error
|
|
781
1183
|
);
|
|
@@ -787,7 +1189,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
787
1189
|
if (!rows.success) {
|
|
788
1190
|
return err(
|
|
789
1191
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
790
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1192
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1193
|
+
params: { error: rows.error.message }
|
|
1194
|
+
}),
|
|
791
1195
|
rows.error
|
|
792
1196
|
);
|
|
793
1197
|
}
|
|
@@ -795,15 +1199,21 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
795
1199
|
for (const row of rows.data) {
|
|
796
1200
|
const paramsResult = TaskParamsSchema.safeParse(row.params ?? {});
|
|
797
1201
|
if (!paramsResult.success) {
|
|
798
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1202
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1203
|
+
params: { taskId: row.taskId, error: paramsResult.error.message }
|
|
1204
|
+
}));
|
|
799
1205
|
}
|
|
800
1206
|
const handlerResult = row.handler == null ? { success: true, data: void 0 } : TaskHandlerConfigSchema.safeParse(row.handler);
|
|
801
1207
|
if (!handlerResult.success) {
|
|
802
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1208
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1209
|
+
params: { taskId: row.taskId, error: handlerResult.error.message }
|
|
1210
|
+
}));
|
|
803
1211
|
}
|
|
804
1212
|
const retryResult = row.retry == null ? { success: true, data: void 0 } : TaskRetryPolicySchema.safeParse(row.retry);
|
|
805
1213
|
if (!retryResult.success) {
|
|
806
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1214
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1215
|
+
params: { taskId: row.taskId, error: retryResult.error.message }
|
|
1216
|
+
}));
|
|
807
1217
|
}
|
|
808
1218
|
tasks.push({
|
|
809
1219
|
id: row.taskId,
|
|
@@ -825,7 +1235,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
825
1235
|
return err(
|
|
826
1236
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
827
1237
|
schedulerM("scheduler_dbSaveFailed", {
|
|
828
|
-
params: {
|
|
1238
|
+
params: {
|
|
1239
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1240
|
+
}
|
|
829
1241
|
}),
|
|
830
1242
|
error
|
|
831
1243
|
);
|
|
@@ -839,7 +1251,9 @@ function parseCronExpression(expression, timezone) {
|
|
|
839
1251
|
} catch {
|
|
840
1252
|
return err(
|
|
841
1253
|
HaiSchedulerError.INVALID_CRON,
|
|
842
|
-
schedulerM("scheduler_invalidCron", {
|
|
1254
|
+
schedulerM("scheduler_invalidCron", {
|
|
1255
|
+
params: { expression }
|
|
1256
|
+
})
|
|
843
1257
|
);
|
|
844
1258
|
}
|
|
845
1259
|
}
|
|
@@ -918,7 +1332,9 @@ function validateRetryPolicy(taskId, retry) {
|
|
|
918
1332
|
if (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1 || retry.maxAttempts > 100) {
|
|
919
1333
|
return err(
|
|
920
1334
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
921
|
-
schedulerM("scheduler_invalidRetryConfig", {
|
|
1335
|
+
schedulerM("scheduler_invalidRetryConfig", {
|
|
1336
|
+
params: { taskId }
|
|
1337
|
+
})
|
|
922
1338
|
);
|
|
923
1339
|
}
|
|
924
1340
|
if (retry.backoffMs !== void 0) {
|
|
@@ -926,13 +1342,17 @@ function validateRetryPolicy(taskId, retry) {
|
|
|
926
1342
|
if (hasInvalidBackoff) {
|
|
927
1343
|
return err(
|
|
928
1344
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
929
|
-
schedulerM("scheduler_invalidRetryConfig", {
|
|
1345
|
+
schedulerM("scheduler_invalidRetryConfig", {
|
|
1346
|
+
params: { taskId }
|
|
1347
|
+
})
|
|
930
1348
|
);
|
|
931
1349
|
}
|
|
932
1350
|
}
|
|
933
1351
|
return ok({
|
|
934
1352
|
maxAttempts: retry.maxAttempts,
|
|
935
|
-
...retry.backoffMs ? {
|
|
1353
|
+
...retry.backoffMs ? {
|
|
1354
|
+
backoffMs: [...retry.backoffMs]
|
|
1355
|
+
} : {}
|
|
936
1356
|
});
|
|
937
1357
|
}
|
|
938
1358
|
async function loadPersistedTasks(taskRepo2) {
|
|
@@ -955,7 +1375,10 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
|
|
|
955
1375
|
});
|
|
956
1376
|
let loadResult;
|
|
957
1377
|
try {
|
|
958
|
-
loadResult = await Promise.race([
|
|
1378
|
+
loadResult = await Promise.race([
|
|
1379
|
+
taskRepo2.loadTasks(),
|
|
1380
|
+
cancelled
|
|
1381
|
+
]);
|
|
959
1382
|
} finally {
|
|
960
1383
|
signal.removeEventListener("abort", cancel);
|
|
961
1384
|
}
|
|
@@ -970,8 +1393,11 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
|
|
|
970
1393
|
for (const task of loadResult.data) {
|
|
971
1394
|
if (!task.id)
|
|
972
1395
|
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_taskIdEmpty"));
|
|
973
|
-
if (nextTasks.has(task.id))
|
|
974
|
-
return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", {
|
|
1396
|
+
if (nextTasks.has(task.id)) {
|
|
1397
|
+
return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", {
|
|
1398
|
+
params: { taskId: task.id }
|
|
1399
|
+
}));
|
|
1400
|
+
}
|
|
975
1401
|
const cronResult = parseCronExpression(task.cron, task.timezone);
|
|
976
1402
|
if (!cronResult.success)
|
|
977
1403
|
return cronResult;
|
|
@@ -1010,7 +1436,9 @@ async function registerTask(task, taskRepo2) {
|
|
|
1010
1436
|
}
|
|
1011
1437
|
async function registerTaskDefinition(task, taskRepo2) {
|
|
1012
1438
|
if (task.handler && !TaskHandlerConfigSchema.safeParse(task.handler).success || task.idempotent !== void 0 && typeof task.idempotent !== "boolean") {
|
|
1013
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1439
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1440
|
+
params: { taskId: task.id }
|
|
1441
|
+
}));
|
|
1014
1442
|
}
|
|
1015
1443
|
if (!task.id) {
|
|
1016
1444
|
return err(
|
|
@@ -1021,7 +1449,9 @@ async function registerTaskDefinition(task, taskRepo2) {
|
|
|
1021
1449
|
if (hasTask(task.id)) {
|
|
1022
1450
|
return err(
|
|
1023
1451
|
HaiSchedulerError.TASK_ALREADY_EXISTS,
|
|
1024
|
-
schedulerM("scheduler_taskAlreadyExists", {
|
|
1452
|
+
schedulerM("scheduler_taskAlreadyExists", {
|
|
1453
|
+
params: { taskId: task.id }
|
|
1454
|
+
})
|
|
1025
1455
|
);
|
|
1026
1456
|
}
|
|
1027
1457
|
const cronResult = parseCronExpression(task.cron, task.timezone);
|
|
@@ -1046,7 +1476,9 @@ async function registerTaskDefinition(task, taskRepo2) {
|
|
|
1046
1476
|
logger3.warn("Failed to persist task definition", { taskId: task.id, error: saveResult.error.message });
|
|
1047
1477
|
return err(
|
|
1048
1478
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1049
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1479
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1480
|
+
params: { error: saveResult.error.message }
|
|
1481
|
+
}),
|
|
1050
1482
|
saveResult.error
|
|
1051
1483
|
);
|
|
1052
1484
|
}
|
|
@@ -1070,7 +1502,9 @@ async function unregisterTaskDefinition(taskId, taskRepo2, expected) {
|
|
|
1070
1502
|
if (!hasTask(taskId)) {
|
|
1071
1503
|
return err(
|
|
1072
1504
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
1073
|
-
schedulerM("scheduler_taskNotFound", {
|
|
1505
|
+
schedulerM("scheduler_taskNotFound", {
|
|
1506
|
+
params: { taskId }
|
|
1507
|
+
})
|
|
1074
1508
|
);
|
|
1075
1509
|
}
|
|
1076
1510
|
if (taskRepo2) {
|
|
@@ -1079,7 +1513,9 @@ async function unregisterTaskDefinition(taskId, taskRepo2, expected) {
|
|
|
1079
1513
|
logger3.warn("Failed to delete persisted task definition", { taskId, error: deleteResult.error.message });
|
|
1080
1514
|
return err(
|
|
1081
1515
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1082
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1516
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1517
|
+
params: { error: deleteResult.error.message }
|
|
1518
|
+
}),
|
|
1083
1519
|
deleteResult.error
|
|
1084
1520
|
);
|
|
1085
1521
|
}
|
|
@@ -1106,7 +1542,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1106
1542
|
if (!existingTask) {
|
|
1107
1543
|
return err(
|
|
1108
1544
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
1109
|
-
schedulerM("scheduler_taskNotFound", {
|
|
1545
|
+
schedulerM("scheduler_taskNotFound", {
|
|
1546
|
+
params: { taskId }
|
|
1547
|
+
})
|
|
1110
1548
|
);
|
|
1111
1549
|
}
|
|
1112
1550
|
let updatedCron = getCron(taskId);
|
|
@@ -1136,7 +1574,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1136
1574
|
...updates.retry !== void 0 ? { retry: normalizedRetry } : {}
|
|
1137
1575
|
};
|
|
1138
1576
|
if (updates.handler && !TaskHandlerConfigSchema.safeParse(updates.handler).success || updates.idempotent !== void 0 && typeof updates.idempotent !== "boolean") {
|
|
1139
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1577
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1578
|
+
params: { taskId }
|
|
1579
|
+
}));
|
|
1140
1580
|
}
|
|
1141
1581
|
const updatedTask = {
|
|
1142
1582
|
...existingTask,
|
|
@@ -1157,7 +1597,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1157
1597
|
logger3.warn("Failed to update persisted task definition", { taskId, error: updateResult.error.message });
|
|
1158
1598
|
return err(
|
|
1159
1599
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1160
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1600
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1601
|
+
params: { error: updateResult.error.message }
|
|
1602
|
+
}),
|
|
1161
1603
|
updateResult.error
|
|
1162
1604
|
);
|
|
1163
1605
|
}
|
|
@@ -1210,7 +1652,9 @@ function compileJsTaskHandler(config) {
|
|
|
1210
1652
|
signal?.removeEventListener("abort", aborted);
|
|
1211
1653
|
void worker.terminate().then(() => error ? reject(error) : resolve(result), reject);
|
|
1212
1654
|
}
|
|
1213
|
-
timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
|
|
1655
|
+
timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
|
|
1656
|
+
params: { timeout }
|
|
1657
|
+
}))), timeout);
|
|
1214
1658
|
signal?.addEventListener("abort", aborted, { once: true });
|
|
1215
1659
|
worker.once("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
|
|
1216
1660
|
worker.once("exit", (code) => finish(new Error(`JS worker exited before returning a result (${code})`)));
|
|
@@ -1228,84 +1672,115 @@ function compileJsTaskHandler(config) {
|
|
|
1228
1672
|
return err(
|
|
1229
1673
|
HaiSchedulerError.JS_COMPILE_FAILED,
|
|
1230
1674
|
schedulerM("scheduler_jsCompileFailed", {
|
|
1231
|
-
params: {
|
|
1675
|
+
params: {
|
|
1676
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1677
|
+
}
|
|
1232
1678
|
}),
|
|
1233
1679
|
error
|
|
1234
1680
|
);
|
|
1235
1681
|
}
|
|
1236
1682
|
}
|
|
1237
1683
|
function migrateScheduler(options = {}) {
|
|
1238
|
-
const steps = [
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1242
|
-
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
version: 2,
|
|
1250
|
-
name: "execution-history-snapshots",
|
|
1251
|
-
async needed(sql) {
|
|
1252
|
-
const columns = await schemaColumns(reldb, "hai_scheduler_logs", sql);
|
|
1253
|
-
if (!columns.success)
|
|
1254
|
-
return columns;
|
|
1255
|
-
if (columns.data.length && !columns.data.includes("payload"))
|
|
1256
|
-
return ok(true);
|
|
1257
|
-
const archive = await schemaColumns(reldb, "hai_scheduler_logs_alpha65", sql);
|
|
1258
|
-
if (!archive.success)
|
|
1259
|
-
return archive;
|
|
1260
|
-
if (!archive.data.length)
|
|
1261
|
-
return ok(false);
|
|
1262
|
-
if (!columns.data.length)
|
|
1263
|
-
return ok(true);
|
|
1264
|
-
const identity = reldb.config?.type === "mysql" ? "CAST(n.id AS BINARY)=CAST(CONCAT('legacy:',CAST(a.id AS CHAR)) AS BINARY)" : "n.id='legacy:' || CAST(a.id AS TEXT)";
|
|
1265
|
-
const missing = await sql.get(`SELECT id FROM hai_scheduler_logs_alpha65 a WHERE NOT EXISTS (SELECT 1 FROM hai_scheduler_logs n WHERE ${identity}) LIMIT 1`);
|
|
1266
|
-
return missing.success ? ok(Boolean(missing.data)) : missing;
|
|
1684
|
+
const steps = [
|
|
1685
|
+
{
|
|
1686
|
+
version: 1,
|
|
1687
|
+
name: "explicit-task-idempotency",
|
|
1688
|
+
async needed(sql) {
|
|
1689
|
+
const columns = await reldb.schemaColumns("hai_scheduler_tasks", sql);
|
|
1690
|
+
return columns.success ? ok(columns.data.length > 0 && !columns.data.includes("idempotent")) : columns;
|
|
1691
|
+
},
|
|
1692
|
+
async apply(sql) {
|
|
1693
|
+
return sql.execute("ALTER TABLE hai_scheduler_tasks ADD COLUMN idempotent BOOLEAN NOT NULL DEFAULT FALSE");
|
|
1694
|
+
}
|
|
1267
1695
|
},
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
|
|
1272
|
-
|
|
1273
|
-
|
|
1696
|
+
{
|
|
1697
|
+
version: 2,
|
|
1698
|
+
name: "execution-history-snapshots",
|
|
1699
|
+
async needed(sql) {
|
|
1700
|
+
const columns = await reldb.schemaColumns("hai_scheduler_logs", sql);
|
|
1701
|
+
if (!columns.success)
|
|
1702
|
+
return columns;
|
|
1703
|
+
if (columns.data.length && !columns.data.includes("payload"))
|
|
1704
|
+
return ok(true);
|
|
1705
|
+
const archive = await reldb.schemaColumns("hai_scheduler_logs_alpha65", sql);
|
|
1274
1706
|
if (!archive.success)
|
|
1275
1707
|
return archive;
|
|
1276
|
-
if (archive.data.length)
|
|
1277
|
-
return
|
|
1278
|
-
|
|
1279
|
-
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1708
|
+
if (!archive.data.length)
|
|
1709
|
+
return ok(false);
|
|
1710
|
+
if (!columns.data.length)
|
|
1711
|
+
return ok(true);
|
|
1712
|
+
const identity = reldb.config?.type === "mysql" ? "CAST(n.id AS BINARY)=CAST(CONCAT('legacy:',CAST(a.id AS CHAR)) AS BINARY)" : "n.id='legacy:' || CAST(a.id AS TEXT)";
|
|
1713
|
+
const missing = await sql.get(`SELECT id FROM hai_scheduler_logs_alpha65 a WHERE NOT EXISTS (SELECT 1 FROM hai_scheduler_logs n WHERE ${identity}) LIMIT 1`);
|
|
1714
|
+
return missing.success ? ok(Boolean(missing.data)) : missing;
|
|
1715
|
+
},
|
|
1716
|
+
async apply(sql) {
|
|
1717
|
+
const columns = await reldb.schemaColumns("hai_scheduler_logs", sql);
|
|
1718
|
+
if (!columns.success)
|
|
1719
|
+
return columns;
|
|
1720
|
+
if (columns.data.length && !columns.data.includes("payload")) {
|
|
1721
|
+
const archive = await reldb.schemaColumns("hai_scheduler_logs_alpha65", sql);
|
|
1722
|
+
if (!archive.success)
|
|
1723
|
+
return archive;
|
|
1724
|
+
if (archive.data.length)
|
|
1725
|
+
return err(HaiCommonError.INIT_FAILED, "Scheduler archive already exists");
|
|
1726
|
+
const renamed = await sql.execute("ALTER TABLE hai_scheduler_logs RENAME TO hai_scheduler_logs_alpha65");
|
|
1727
|
+
if (!renamed.success)
|
|
1728
|
+
return renamed;
|
|
1729
|
+
}
|
|
1730
|
+
const text = reldb.config?.type === "mysql" ? "VARCHAR(255)" : "TEXT";
|
|
1731
|
+
const json = reldb.config?.type === "postgresql" ? "JSONB" : reldb.config?.type === "mysql" ? "JSON" : "TEXT";
|
|
1732
|
+
const created = await sql.execute(`CREATE TABLE IF NOT EXISTS hai_scheduler_logs (id ${text} NOT NULL,occurrence_id ${text},task_id ${text} NOT NULL,task_name ${text} NOT NULL,task_type ${text} NOT NULL,trigger_type ${text} NOT NULL,trigger_source ${text},status ${text} NOT NULL,payload ${json} NOT NULL,started_at BIGINT NOT NULL,finished_at BIGINT NOT NULL,duration INTEGER NOT NULL,CONSTRAINT pk_hai_scheduler_log_v2 PRIMARY KEY(id))`);
|
|
1733
|
+
if (!created.success)
|
|
1734
|
+
return created;
|
|
1735
|
+
for (let offset = 0; ; offset += 100) {
|
|
1736
|
+
const rows = await sql.query(`SELECT CAST(id AS ${reldb.config?.type === "mysql" ? "CHAR" : "TEXT"}) AS id,task_id,task_name,task_type,trigger_type,trigger_source,status,result,error,started_at,finished_at,duration FROM hai_scheduler_logs_alpha65 ORDER BY id LIMIT 100 OFFSET ?`, [offset]);
|
|
1737
|
+
if (!rows.success)
|
|
1738
|
+
return rows;
|
|
1739
|
+
for (const row of rows.data) {
|
|
1740
|
+
const id = `legacy:${row.id}`;
|
|
1741
|
+
const existing = await sql.get("SELECT id FROM hai_scheduler_logs WHERE id=?", [id]);
|
|
1742
|
+
if (!existing.success)
|
|
1743
|
+
return existing;
|
|
1744
|
+
if (existing.data)
|
|
1745
|
+
continue;
|
|
1746
|
+
const payload = {
|
|
1747
|
+
id,
|
|
1748
|
+
taskId: row.task_id,
|
|
1749
|
+
taskName: row.task_name,
|
|
1750
|
+
taskType: row.task_type,
|
|
1751
|
+
triggerType: row.trigger_type,
|
|
1752
|
+
triggerSource: row.trigger_source,
|
|
1753
|
+
status: row.status,
|
|
1754
|
+
result: row.result,
|
|
1755
|
+
error: row.error,
|
|
1756
|
+
startedAt: Number(row.started_at),
|
|
1757
|
+
finishedAt: Number(row.finished_at),
|
|
1758
|
+
duration: Number(row.duration),
|
|
1759
|
+
persistence: { status: "persisted" }
|
|
1760
|
+
};
|
|
1761
|
+
const copied = await sql.execute("INSERT INTO hai_scheduler_logs(id,task_id,task_name,task_type,trigger_type,trigger_source,status,payload,started_at,finished_at,duration) VALUES(?,?,?,?,?,?,?,?,?,?,?)", [
|
|
1762
|
+
id,
|
|
1763
|
+
row.task_id,
|
|
1764
|
+
row.task_name,
|
|
1765
|
+
row.task_type,
|
|
1766
|
+
row.trigger_type,
|
|
1767
|
+
row.trigger_source,
|
|
1768
|
+
row.status,
|
|
1769
|
+
JSON.stringify(payload),
|
|
1770
|
+
row.started_at,
|
|
1771
|
+
row.finished_at,
|
|
1772
|
+
row.duration
|
|
1773
|
+
]);
|
|
1774
|
+
if (!copied.success)
|
|
1775
|
+
return copied;
|
|
1776
|
+
}
|
|
1777
|
+
if (rows.data.length < 100)
|
|
1778
|
+
return ok(void 0);
|
|
1302
1779
|
}
|
|
1303
|
-
if (rows.data.length < 100)
|
|
1304
|
-
return ok(void 0);
|
|
1305
1780
|
}
|
|
1306
1781
|
}
|
|
1307
|
-
|
|
1308
|
-
return migrateSchema(
|
|
1782
|
+
];
|
|
1783
|
+
return reldb.migrateSchema("scheduler", steps, options);
|
|
1309
1784
|
}
|
|
1310
1785
|
|
|
1311
1786
|
// src/scheduler-cancellation.ts
|
|
@@ -1408,7 +1883,9 @@ async function executeJsTask(task, context, signal = new AbortController().signa
|
|
|
1408
1883
|
if (!handler || handler.kind !== "js") {
|
|
1409
1884
|
return err(
|
|
1410
1885
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1411
|
-
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1886
|
+
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1887
|
+
params: { taskId: task.id }
|
|
1888
|
+
})
|
|
1412
1889
|
);
|
|
1413
1890
|
}
|
|
1414
1891
|
const compileResult = compileJsTaskHandler(handler);
|
|
@@ -1422,7 +1899,9 @@ async function executeJsTask(task, context, signal = new AbortController().signa
|
|
|
1422
1899
|
logger4.error("JS task execution failed", { taskId: task.id, error: message });
|
|
1423
1900
|
return err(
|
|
1424
1901
|
HaiSchedulerError.JS_EXECUTION_FAILED,
|
|
1425
|
-
schedulerM("scheduler_jsExecutionFailed", {
|
|
1902
|
+
schedulerM("scheduler_jsExecutionFailed", {
|
|
1903
|
+
params: { error: message }
|
|
1904
|
+
}),
|
|
1426
1905
|
error
|
|
1427
1906
|
);
|
|
1428
1907
|
}
|
|
@@ -1432,12 +1911,17 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1432
1911
|
if (!handler || handler.kind !== "api") {
|
|
1433
1912
|
return err(
|
|
1434
1913
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1435
|
-
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1914
|
+
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1915
|
+
params: { taskId: task.id }
|
|
1916
|
+
})
|
|
1436
1917
|
);
|
|
1437
1918
|
}
|
|
1438
1919
|
const { url, method = "GET", headers, body, timeout = 3e4, maxResponseBytes = 1024 * 1024 } = handler;
|
|
1439
|
-
if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)
|
|
1440
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1920
|
+
if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0) {
|
|
1921
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1922
|
+
params: { taskId: task.id }
|
|
1923
|
+
}));
|
|
1924
|
+
}
|
|
1441
1925
|
const controller = new AbortController();
|
|
1442
1926
|
const timer = setTimeout(() => controller.abort(), timeout);
|
|
1443
1927
|
try {
|
|
@@ -1454,7 +1938,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1454
1938
|
method,
|
|
1455
1939
|
headers: requestHeaders,
|
|
1456
1940
|
signal: AbortSignal.any([signal, controller.signal]),
|
|
1457
|
-
...body !== void 0 ? {
|
|
1941
|
+
...body !== void 0 ? {
|
|
1942
|
+
body: JSON.stringify(body)
|
|
1943
|
+
} : {}
|
|
1458
1944
|
});
|
|
1459
1945
|
let receivedBytes = 0;
|
|
1460
1946
|
let responseText = "";
|
|
@@ -1469,7 +1955,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1469
1955
|
receivedBytes += chunk.value.byteLength;
|
|
1470
1956
|
if (receivedBytes > maxResponseBytes) {
|
|
1471
1957
|
controller.abort();
|
|
1472
|
-
return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
|
|
1958
|
+
return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
|
|
1959
|
+
params: { maxResponseBytes }
|
|
1960
|
+
}));
|
|
1473
1961
|
}
|
|
1474
1962
|
responseText += decoder.decode(chunk.value, { stream: true });
|
|
1475
1963
|
}
|
|
@@ -1494,10 +1982,16 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1494
1982
|
return ok(responseText || null);
|
|
1495
1983
|
} catch (error) {
|
|
1496
1984
|
const message = error instanceof Error ? error.message : String(error);
|
|
1497
|
-
logger4.error("API task execution failed", {
|
|
1985
|
+
logger4.error("API task execution failed", {
|
|
1986
|
+
taskId: context.taskId,
|
|
1987
|
+
error: message,
|
|
1988
|
+
url: core.sanitize.sanitizeUrl(url)
|
|
1989
|
+
});
|
|
1498
1990
|
return err(
|
|
1499
1991
|
HaiSchedulerError.API_EXECUTION_FAILED,
|
|
1500
|
-
schedulerM("scheduler_apiExecutionFailed", {
|
|
1992
|
+
schedulerM("scheduler_apiExecutionFailed", {
|
|
1993
|
+
params: { error: message }
|
|
1994
|
+
}),
|
|
1501
1995
|
error
|
|
1502
1996
|
);
|
|
1503
1997
|
} finally {
|
|
@@ -1508,7 +2002,9 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
|
|
|
1508
2002
|
if (!hooks.onTaskExecute) {
|
|
1509
2003
|
return err(
|
|
1510
2004
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1511
|
-
schedulerM("scheduler_taskHandlerMissing", {
|
|
2005
|
+
schedulerM("scheduler_taskHandlerMissing", {
|
|
2006
|
+
params: { taskId: task.id }
|
|
2007
|
+
})
|
|
1512
2008
|
);
|
|
1513
2009
|
}
|
|
1514
2010
|
const executeEvent = {
|
|
@@ -1526,7 +2022,9 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
|
|
|
1526
2022
|
logger4.error("Task execute hook failed", { taskId: task.id, error: message });
|
|
1527
2023
|
return err(
|
|
1528
2024
|
HaiSchedulerError.HOOK_EXECUTION_FAILED,
|
|
1529
|
-
schedulerM("scheduler_hookExecutionFailed", {
|
|
2025
|
+
schedulerM("scheduler_hookExecutionFailed", {
|
|
2026
|
+
params: { error: message }
|
|
2027
|
+
}),
|
|
1530
2028
|
error
|
|
1531
2029
|
);
|
|
1532
2030
|
}
|
|
@@ -1535,7 +2033,13 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
|
|
|
1535
2033
|
const startedAt = Date.now();
|
|
1536
2034
|
const taskType = resolveTaskType(task, hooks);
|
|
1537
2035
|
const context = createTaskContext(task, trigger, execution);
|
|
1538
|
-
await notifyTaskStart(hooks, {
|
|
2036
|
+
await notifyTaskStart(hooks, {
|
|
2037
|
+
task,
|
|
2038
|
+
trigger,
|
|
2039
|
+
startedAt,
|
|
2040
|
+
signal,
|
|
2041
|
+
context
|
|
2042
|
+
});
|
|
1539
2043
|
let executionResult;
|
|
1540
2044
|
let shouldNotifyInterrupted = false;
|
|
1541
2045
|
if (signal.aborted) {
|
|
@@ -1576,8 +2080,17 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
|
|
|
1576
2080
|
context
|
|
1577
2081
|
});
|
|
1578
2082
|
}
|
|
1579
|
-
if (status !== "interrupted" && !signal.aborted)
|
|
1580
|
-
await notifyTaskFinish(hooks, {
|
|
2083
|
+
if (status !== "interrupted" && !signal.aborted) {
|
|
2084
|
+
await notifyTaskFinish(hooks, {
|
|
2085
|
+
task,
|
|
2086
|
+
trigger,
|
|
2087
|
+
startedAt,
|
|
2088
|
+
finishedAt,
|
|
2089
|
+
log,
|
|
2090
|
+
signal,
|
|
2091
|
+
context
|
|
2092
|
+
});
|
|
2093
|
+
}
|
|
1581
2094
|
return log;
|
|
1582
2095
|
}
|
|
1583
2096
|
|
|
@@ -1607,13 +2120,24 @@ var publishedLogSchema = z.object({
|
|
|
1607
2120
|
taskType: z.enum(["api", "js", "hook"]),
|
|
1608
2121
|
triggerType: z.enum(["manual", "scheduled"]),
|
|
1609
2122
|
triggerSource: z.string().nullable(),
|
|
1610
|
-
status: z.enum([
|
|
2123
|
+
status: z.enum([
|
|
2124
|
+
"success",
|
|
2125
|
+
"failed",
|
|
2126
|
+
"interrupted",
|
|
2127
|
+
"unknown"
|
|
2128
|
+
]),
|
|
1611
2129
|
result: z.string().nullable(),
|
|
1612
2130
|
error: z.string().nullable(),
|
|
1613
2131
|
startedAt: z.number().safe(),
|
|
1614
2132
|
finishedAt: z.number().safe(),
|
|
1615
2133
|
duration: z.number().safe(),
|
|
1616
|
-
persistence: z.object({
|
|
2134
|
+
persistence: z.object({
|
|
2135
|
+
status: z.enum(["pending", "persisted", "unconfirmed"]),
|
|
2136
|
+
error: z.object({
|
|
2137
|
+
code: z.string(),
|
|
2138
|
+
message: z.string()
|
|
2139
|
+
}).optional()
|
|
2140
|
+
})
|
|
1617
2141
|
});
|
|
1618
2142
|
function repairExecutionLogs(id) {
|
|
1619
2143
|
const operation = projectExecutionLogs(id);
|
|
@@ -1690,7 +2214,9 @@ async function drainRunner() {
|
|
|
1690
2214
|
stopTimer();
|
|
1691
2215
|
for (const controller of activeRuns.values())
|
|
1692
2216
|
controller.abort(new Error(schedulerM("scheduler_closing")));
|
|
1693
|
-
await Promise.allSettled([
|
|
2217
|
+
await Promise.allSettled([
|
|
2218
|
+
...activeRuns.keys()
|
|
2219
|
+
]);
|
|
1694
2220
|
await Promise.allSettled([...activeRepairs]);
|
|
1695
2221
|
}
|
|
1696
2222
|
async function tick() {
|
|
@@ -1768,20 +2294,35 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1768
2294
|
const leaseMs = currentLeaseMs;
|
|
1769
2295
|
const occurrenceId = recovery?.occurrenceId ?? executionId(task.id, trigger.type, minute === void 0 ? options?.idempotencyKey ?? randomUUID() : String(minute));
|
|
1770
2296
|
const interrupted = async (reason, observationOnly = false) => {
|
|
1771
|
-
const log = {
|
|
2297
|
+
const log = {
|
|
2298
|
+
...await interruptTask(task, trigger, reason, {}, controller.signal),
|
|
2299
|
+
occurrenceId
|
|
2300
|
+
};
|
|
1772
2301
|
if (observationOnly && logRepository) {
|
|
1773
2302
|
const saved = await logRepository.saveLog(log);
|
|
1774
|
-
log.persistence = saved.success ? { status: "persisted" } : {
|
|
2303
|
+
log.persistence = saved.success ? { status: "persisted" } : {
|
|
2304
|
+
status: "unconfirmed",
|
|
2305
|
+
error: {
|
|
2306
|
+
code: String(saved.error.code),
|
|
2307
|
+
message: saved.error.message
|
|
2308
|
+
}
|
|
2309
|
+
};
|
|
1775
2310
|
}
|
|
1776
2311
|
return log;
|
|
1777
2312
|
};
|
|
1778
2313
|
if (!executionRepo2)
|
|
1779
2314
|
return interrupted(schedulerM("scheduler_executionStateFailed"), true);
|
|
1780
|
-
const claimed = await executionRepo2.claim(task, occurrenceId, {
|
|
2315
|
+
const claimed = await executionRepo2.claim(task, occurrenceId, {
|
|
2316
|
+
...trigger,
|
|
2317
|
+
...minute !== void 0 ? { minute } : {}
|
|
2318
|
+
}, currentNodeId, leaseMs);
|
|
1781
2319
|
if (!claimed.success)
|
|
1782
2320
|
return interrupted(claimed.error.message, true);
|
|
1783
|
-
if (!claimed.data)
|
|
1784
|
-
return interrupted(schedulerM("scheduler_taskRunning", {
|
|
2321
|
+
if (!claimed.data) {
|
|
2322
|
+
return interrupted(schedulerM("scheduler_taskRunning", {
|
|
2323
|
+
params: { taskId: task.id }
|
|
2324
|
+
}), true);
|
|
2325
|
+
}
|
|
1785
2326
|
const row = claimed.data;
|
|
1786
2327
|
if (!["claimed", "running"].includes(row.status)) {
|
|
1787
2328
|
if (minute === void 0) {
|
|
@@ -1802,12 +2343,19 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1802
2343
|
duration: row.updatedAt - row.createdAt
|
|
1803
2344
|
};
|
|
1804
2345
|
const status = row.status === "discarded" ? "interrupted" : row.status;
|
|
1805
|
-
return {
|
|
2346
|
+
return {
|
|
2347
|
+
...log,
|
|
2348
|
+
status,
|
|
2349
|
+
error: status === "success" ? null : log.error,
|
|
2350
|
+
occurrenceId
|
|
2351
|
+
};
|
|
1806
2352
|
} catch {
|
|
1807
2353
|
return interrupted(schedulerM("scheduler_executionStateFailed"));
|
|
1808
2354
|
}
|
|
1809
2355
|
}
|
|
1810
|
-
return interrupted(schedulerM("scheduler_occurrenceHandled", {
|
|
2356
|
+
return interrupted(schedulerM("scheduler_occurrenceHandled", {
|
|
2357
|
+
params: { taskId: task.id }
|
|
2358
|
+
}), true);
|
|
1811
2359
|
}
|
|
1812
2360
|
runningTasks.add(task.id);
|
|
1813
2361
|
let timer;
|
|
@@ -1846,14 +2394,21 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1846
2394
|
} catch {
|
|
1847
2395
|
}
|
|
1848
2396
|
if (!refreshed.success || !latest || latest.enabled === false || !unchanged) {
|
|
1849
|
-
log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
|
|
2397
|
+
log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
|
|
2398
|
+
params: { taskId: task.id }
|
|
2399
|
+
}));
|
|
1850
2400
|
if (row.attemptCount > 0)
|
|
1851
2401
|
log.status = "unknown";
|
|
1852
2402
|
break;
|
|
1853
2403
|
}
|
|
1854
2404
|
task = latest;
|
|
1855
2405
|
if (!task.handler && !hooks.onTaskExecute) {
|
|
1856
|
-
log = {
|
|
2406
|
+
log = {
|
|
2407
|
+
...await interruptTask(task, trigger, schedulerM("scheduler_taskHandlerMissing", {
|
|
2408
|
+
params: { taskId: task.id }
|
|
2409
|
+
}), hooks, controller.signal),
|
|
2410
|
+
occurrenceId
|
|
2411
|
+
};
|
|
1857
2412
|
break;
|
|
1858
2413
|
}
|
|
1859
2414
|
const begun = await executionRepo2.begin(row, leaseMs);
|
|
@@ -1861,7 +2416,12 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1861
2416
|
lost = true;
|
|
1862
2417
|
break;
|
|
1863
2418
|
}
|
|
1864
|
-
log = await executeTask(task, trigger, hooks, controller.signal, {
|
|
2419
|
+
log = await executeTask(task, trigger, hooks, controller.signal, {
|
|
2420
|
+
occurrenceId,
|
|
2421
|
+
executionToken: row.owner,
|
|
2422
|
+
sequence: row.sequence,
|
|
2423
|
+
attempt: row.attemptCount
|
|
2424
|
+
});
|
|
1865
2425
|
log.occurrenceId = occurrenceId;
|
|
1866
2426
|
attempts.push(log);
|
|
1867
2427
|
if (log.status !== "failed" || !row.idempotent || row.attemptCount >= row.maxAttempts)
|
|
@@ -1873,21 +2433,51 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1873
2433
|
if (!log)
|
|
1874
2434
|
log = await interrupted(schedulerM("scheduler_executionStateFailed"));
|
|
1875
2435
|
if (lost) {
|
|
1876
|
-
return {
|
|
2436
|
+
return {
|
|
2437
|
+
...log,
|
|
2438
|
+
status: "unknown",
|
|
2439
|
+
persistence: { status: "unconfirmed" },
|
|
2440
|
+
error: schedulerM("scheduler_executionUnknown"),
|
|
2441
|
+
occurrenceId
|
|
2442
|
+
};
|
|
2443
|
+
}
|
|
2444
|
+
if (controller.signal.aborted && row.attemptCount > 0) {
|
|
2445
|
+
log = {
|
|
2446
|
+
...log,
|
|
2447
|
+
status: "unknown",
|
|
2448
|
+
error: schedulerM("scheduler_executionUnknown")
|
|
2449
|
+
};
|
|
1877
2450
|
}
|
|
1878
|
-
if (controller.signal.aborted && row.attemptCount > 0)
|
|
1879
|
-
log = { ...log, status: "unknown", error: schedulerM("scheduler_executionUnknown") };
|
|
1880
2451
|
const currentAttempt = attempts.findIndex((attempt) => attempt.id === log.id);
|
|
1881
2452
|
if (currentAttempt >= 0)
|
|
1882
2453
|
attempts[currentAttempt] = log;
|
|
1883
2454
|
else
|
|
1884
2455
|
attempts.push(log);
|
|
1885
|
-
const published = attempts.map((attempt) => ({
|
|
1886
|
-
|
|
1887
|
-
|
|
1888
|
-
|
|
2456
|
+
const published = attempts.map((attempt) => ({
|
|
2457
|
+
...attempt,
|
|
2458
|
+
persistence: { status: "pending" }
|
|
2459
|
+
}));
|
|
2460
|
+
const finished = await executionRepo2.finish(row, {
|
|
2461
|
+
...log,
|
|
2462
|
+
persistence: { status: "pending" }
|
|
2463
|
+
}, published);
|
|
2464
|
+
if (!finished.success) {
|
|
2465
|
+
return {
|
|
2466
|
+
...log,
|
|
2467
|
+
status: "unknown",
|
|
2468
|
+
persistence: { status: "unconfirmed" },
|
|
2469
|
+
error: finished.error.message,
|
|
2470
|
+
occurrenceId
|
|
2471
|
+
};
|
|
2472
|
+
}
|
|
1889
2473
|
const projected = await repairExecutionLogs(occurrenceId);
|
|
1890
|
-
log.persistence = projected.success ? { status: "persisted" } : {
|
|
2474
|
+
log.persistence = projected.success ? { status: "persisted" } : {
|
|
2475
|
+
status: "pending",
|
|
2476
|
+
error: {
|
|
2477
|
+
code: String(projected.error.code),
|
|
2478
|
+
message: projected.error.message
|
|
2479
|
+
}
|
|
2480
|
+
};
|
|
1891
2481
|
if (!projected.success)
|
|
1892
2482
|
logger5.warn("Execution completed with pending log persistence", { taskId: task.id, occurrenceId, errorCode: projected.error.code });
|
|
1893
2483
|
if (task.deleteAfterRun && log.status === "success") {
|
|
@@ -1922,7 +2512,10 @@ var taskRepo = null;
|
|
|
1922
2512
|
var logRepo = null;
|
|
1923
2513
|
var executionRepo = null;
|
|
1924
2514
|
var executionIdSchema = z.string().regex(/^[a-f\d]{64}$/);
|
|
1925
|
-
var executionListSchema = z.object({
|
|
2515
|
+
var executionListSchema = z.object({
|
|
2516
|
+
limit: z.number().int().min(1).max(100).default(50),
|
|
2517
|
+
offset: z.number().int().min(0).max(1e6).default(0)
|
|
2518
|
+
});
|
|
1926
2519
|
var notInitialized = core.module.createNotInitializedKit(
|
|
1927
2520
|
HaiSchedulerError.NOT_INITIALIZED,
|
|
1928
2521
|
() => schedulerM("scheduler_notInitialized")
|
|
@@ -2006,7 +2599,9 @@ var scheduler = {
|
|
|
2006
2599
|
logger6.warn("Scheduler init already in progress, skipping concurrent call");
|
|
2007
2600
|
return err(
|
|
2008
2601
|
HaiSchedulerError.INIT_FAILED,
|
|
2009
|
-
schedulerM("scheduler_initFailed", {
|
|
2602
|
+
schedulerM("scheduler_initFailed", {
|
|
2603
|
+
params: { error: "Concurrent initialization detected" }
|
|
2604
|
+
})
|
|
2010
2605
|
);
|
|
2011
2606
|
}
|
|
2012
2607
|
initInProgress = true;
|
|
@@ -2024,7 +2619,9 @@ var scheduler = {
|
|
|
2024
2619
|
logger6.error("Scheduler config validation failed", { error: parseResult.error.message });
|
|
2025
2620
|
return err(
|
|
2026
2621
|
HaiSchedulerError.CONFIG_ERROR,
|
|
2027
|
-
schedulerM("scheduler_configError", {
|
|
2622
|
+
schedulerM("scheduler_configError", {
|
|
2623
|
+
params: { error: parseResult.error.message }
|
|
2624
|
+
}),
|
|
2028
2625
|
parseResult.error
|
|
2029
2626
|
);
|
|
2030
2627
|
}
|
|
@@ -2049,7 +2646,9 @@ var scheduler = {
|
|
|
2049
2646
|
return err(
|
|
2050
2647
|
HaiSchedulerError.INIT_FAILED,
|
|
2051
2648
|
schedulerM("scheduler_initFailed", {
|
|
2052
|
-
params: {
|
|
2649
|
+
params: {
|
|
2650
|
+
error: error instanceof Error ? error.message : String(error)
|
|
2651
|
+
}
|
|
2053
2652
|
}),
|
|
2054
2653
|
error
|
|
2055
2654
|
);
|
|
@@ -2085,8 +2684,12 @@ var scheduler = {
|
|
|
2085
2684
|
if (!currentConfig)
|
|
2086
2685
|
return notInitialized.result();
|
|
2087
2686
|
const updateResult = await updateRegisteredTask(taskId, updates, taskRepo);
|
|
2088
|
-
if (updateResult.success)
|
|
2089
|
-
logger6.info("Task updated", {
|
|
2687
|
+
if (updateResult.success) {
|
|
2688
|
+
logger6.info("Task updated", {
|
|
2689
|
+
taskId,
|
|
2690
|
+
updates: Object.keys(updates)
|
|
2691
|
+
});
|
|
2692
|
+
}
|
|
2090
2693
|
return updateResult;
|
|
2091
2694
|
},
|
|
2092
2695
|
start() {
|
|
@@ -2131,7 +2734,9 @@ var scheduler = {
|
|
|
2131
2734
|
if (!task) {
|
|
2132
2735
|
return err(
|
|
2133
2736
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
2134
|
-
schedulerM("scheduler_taskNotFound", {
|
|
2737
|
+
schedulerM("scheduler_taskNotFound", {
|
|
2738
|
+
params: { taskId }
|
|
2739
|
+
})
|
|
2135
2740
|
);
|
|
2136
2741
|
}
|
|
2137
2742
|
const log = await runTask(task, void 0, normalizeTriggerInput(parsed.data), parsed.data);
|