@h-ai/scheduler 1.0.0-beta.17 → 1.0.0-beta.19
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/dist/index.d.ts +2 -1
- package/dist/index.js +800 -199
- 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 = [];
|
|
@@ -348,7 +438,19 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
348
438
|
created = await this.db.sql.execute(
|
|
349
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)
|
|
350
440
|
VALUES (?, ?, ?, ?, ?, ${clock} + ?, 0, ?, ?, ?, ?, ?, ${clock}, ${clock})${conflictClause}`,
|
|
351
|
-
[
|
|
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
|
+
]
|
|
352
454
|
);
|
|
353
455
|
} catch (cause) {
|
|
354
456
|
return failed(cause);
|
|
@@ -359,12 +461,22 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
359
461
|
if (!existing.success)
|
|
360
462
|
return existing;
|
|
361
463
|
if (!existing.data) {
|
|
362
|
-
const active = await this.findAll({
|
|
464
|
+
const active = await this.findAll({
|
|
465
|
+
where: "active_task = ?",
|
|
466
|
+
params: [task.id],
|
|
467
|
+
limit: 1
|
|
468
|
+
});
|
|
363
469
|
return active.success && active.data.length > 0 ? ok(null) : failed(created.success ? void 0 : created.error);
|
|
364
470
|
}
|
|
365
471
|
const row = existing.data;
|
|
366
|
-
if (created.success && created.data.changes === 1 || [
|
|
472
|
+
if (created.success && created.data.changes === 1 || [
|
|
473
|
+
"success",
|
|
474
|
+
"failed",
|
|
475
|
+
"interrupted",
|
|
476
|
+
"discarded"
|
|
477
|
+
].includes(row.status)) {
|
|
367
478
|
return ok(row);
|
|
479
|
+
}
|
|
368
480
|
if (row.status === "unknown")
|
|
369
481
|
return ok(null);
|
|
370
482
|
if (row.status === "running" && (!row.idempotent || row.attemptCount >= row.maxAttempts)) {
|
|
@@ -378,7 +490,15 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
378
490
|
const recovered = await this.db.sql.execute(
|
|
379
491
|
`UPDATE ${TABLE} SET status = ?, owner = ?, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
|
|
380
492
|
WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${clock} AND status IN (?, ?)`,
|
|
381
|
-
[
|
|
493
|
+
[
|
|
494
|
+
"claimed",
|
|
495
|
+
owner,
|
|
496
|
+
leaseMs,
|
|
497
|
+
id,
|
|
498
|
+
row.owner,
|
|
499
|
+
"claimed",
|
|
500
|
+
"running"
|
|
501
|
+
]
|
|
382
502
|
);
|
|
383
503
|
if (!recovered.success)
|
|
384
504
|
return failed(recovered.error);
|
|
@@ -390,7 +510,14 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
390
510
|
const result = await this.db.sql.execute(
|
|
391
511
|
`UPDATE ${TABLE} SET status = ?, attempt_count = attempt_count + 1, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
|
|
392
512
|
WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?) AND attempt_count < max_attempts`,
|
|
393
|
-
[
|
|
513
|
+
[
|
|
514
|
+
"running",
|
|
515
|
+
leaseMs,
|
|
516
|
+
row.occurrenceId,
|
|
517
|
+
row.owner,
|
|
518
|
+
"claimed",
|
|
519
|
+
"running"
|
|
520
|
+
]
|
|
394
521
|
);
|
|
395
522
|
if (!result.success || result.data.changes !== 1)
|
|
396
523
|
return failed(result.success ? void 0 : result.error);
|
|
@@ -403,7 +530,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
403
530
|
const clock = this.databaseClock();
|
|
404
531
|
const result = await this.db.sql.execute(
|
|
405
532
|
`UPDATE ${TABLE} SET leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
|
|
406
|
-
[
|
|
533
|
+
[
|
|
534
|
+
leaseMs,
|
|
535
|
+
row.occurrenceId,
|
|
536
|
+
row.owner,
|
|
537
|
+
"claimed",
|
|
538
|
+
"running"
|
|
539
|
+
]
|
|
407
540
|
);
|
|
408
541
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
409
542
|
}
|
|
@@ -413,7 +546,17 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
413
546
|
const result = await this.db.sql.execute(
|
|
414
547
|
`UPDATE ${TABLE} SET status = ?, active_task = ?, owner = NULL, leased_until = 0, log_json = ?, logs_json = ?, log_persistence = ?, updated_at = ${this.nextUpdatedAt()}
|
|
415
548
|
WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
|
|
416
|
-
[
|
|
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
|
+
]
|
|
417
560
|
);
|
|
418
561
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
419
562
|
}
|
|
@@ -421,7 +564,12 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
421
564
|
async resolve(id, status, expectedUpdatedAt) {
|
|
422
565
|
const result = await this.db.sql.execute(
|
|
423
566
|
`UPDATE ${TABLE} SET status = ?, active_task = NULL, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND status = ? AND updated_at = ?`,
|
|
424
|
-
[
|
|
567
|
+
[
|
|
568
|
+
status,
|
|
569
|
+
id,
|
|
570
|
+
"unknown",
|
|
571
|
+
expectedUpdatedAt
|
|
572
|
+
]
|
|
425
573
|
);
|
|
426
574
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
427
575
|
}
|
|
@@ -434,18 +582,102 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
434
582
|
table: SCHEDULER_LOG_TABLE,
|
|
435
583
|
idColumn: "id",
|
|
436
584
|
fields: [
|
|
437
|
-
{
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
{
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
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
|
+
}
|
|
449
681
|
]
|
|
450
682
|
});
|
|
451
683
|
}
|
|
@@ -454,7 +686,10 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
454
686
|
* @example `const saved = await repository.saveLog(log); if (!saved.success) return saved`
|
|
455
687
|
*/
|
|
456
688
|
async saveLog(log) {
|
|
457
|
-
const payload = {
|
|
689
|
+
const payload = {
|
|
690
|
+
...log,
|
|
691
|
+
persistence: { status: "persisted" }
|
|
692
|
+
};
|
|
458
693
|
try {
|
|
459
694
|
const created = await this.create({
|
|
460
695
|
id: log.id,
|
|
@@ -521,20 +756,27 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
521
756
|
if (!pageResult.success) {
|
|
522
757
|
return err(
|
|
523
758
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
524
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
759
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
760
|
+
params: { error: pageResult.error.message }
|
|
761
|
+
}),
|
|
525
762
|
pageResult.error
|
|
526
763
|
);
|
|
527
764
|
}
|
|
528
765
|
return ok({
|
|
529
766
|
...pageResult.data,
|
|
530
|
-
items: pageResult.data.items.map((row) => ({
|
|
767
|
+
items: pageResult.data.items.map((row) => ({
|
|
768
|
+
...row.payload,
|
|
769
|
+
persistence: { status: "persisted" }
|
|
770
|
+
}))
|
|
531
771
|
});
|
|
532
772
|
} catch (error) {
|
|
533
773
|
logger.error("Failed to query execution logs", { error });
|
|
534
774
|
return err(
|
|
535
775
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
536
776
|
schedulerM("scheduler_dbSaveFailed", {
|
|
537
|
-
params: {
|
|
777
|
+
params: {
|
|
778
|
+
error: error instanceof Error ? error.message : String(error)
|
|
779
|
+
}
|
|
538
780
|
}),
|
|
539
781
|
error
|
|
540
782
|
);
|
|
@@ -554,7 +796,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
554
796
|
if (!retentionResult.success) {
|
|
555
797
|
return err(
|
|
556
798
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
557
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
799
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
800
|
+
params: { error: retentionResult.error.message }
|
|
801
|
+
}),
|
|
558
802
|
retentionResult.error
|
|
559
803
|
);
|
|
560
804
|
}
|
|
@@ -575,7 +819,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
575
819
|
if (!maxLogsResult.success) {
|
|
576
820
|
return err(
|
|
577
821
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
578
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
822
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
823
|
+
params: { error: maxLogsResult.error.message }
|
|
824
|
+
}),
|
|
579
825
|
maxLogsResult.error
|
|
580
826
|
);
|
|
581
827
|
}
|
|
@@ -586,7 +832,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
586
832
|
return err(
|
|
587
833
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
588
834
|
schedulerM("scheduler_dbSaveFailed", {
|
|
589
|
-
params: {
|
|
835
|
+
params: {
|
|
836
|
+
error: error instanceof Error ? error.message : String(error)
|
|
837
|
+
}
|
|
590
838
|
}),
|
|
591
839
|
error
|
|
592
840
|
);
|
|
@@ -603,7 +851,13 @@ var TaskRetryPolicySchema = z.object({
|
|
|
603
851
|
var ApiTaskConfigSchema = z.object({
|
|
604
852
|
kind: z.literal("api"),
|
|
605
853
|
url: z.string().min(1),
|
|
606
|
-
method: z.enum([
|
|
854
|
+
method: z.enum([
|
|
855
|
+
"GET",
|
|
856
|
+
"POST",
|
|
857
|
+
"PUT",
|
|
858
|
+
"DELETE",
|
|
859
|
+
"PATCH"
|
|
860
|
+
]).optional(),
|
|
607
861
|
headers: z.record(z.string(), z.string()).optional(),
|
|
608
862
|
body: z.unknown().optional(),
|
|
609
863
|
timeout: z.number().int().positive().optional(),
|
|
@@ -621,20 +875,118 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
621
875
|
table: SCHEDULER_TASK_TABLE,
|
|
622
876
|
idColumn: "id",
|
|
623
877
|
fields: [
|
|
624
|
-
{
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
{
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
|
|
636
|
-
|
|
637
|
-
|
|
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
|
+
}
|
|
638
990
|
]
|
|
639
991
|
});
|
|
640
992
|
}
|
|
@@ -658,7 +1010,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
658
1010
|
logger2.error("Failed to save task definition", { taskId: task.id, error: createResult.error.message });
|
|
659
1011
|
return err(
|
|
660
1012
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
661
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1013
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1014
|
+
params: { error: createResult.error.message }
|
|
1015
|
+
}),
|
|
662
1016
|
createResult.error
|
|
663
1017
|
);
|
|
664
1018
|
}
|
|
@@ -668,7 +1022,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
668
1022
|
return err(
|
|
669
1023
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
670
1024
|
schedulerM("scheduler_dbSaveFailed", {
|
|
671
|
-
params: {
|
|
1025
|
+
params: {
|
|
1026
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1027
|
+
}
|
|
672
1028
|
}),
|
|
673
1029
|
error
|
|
674
1030
|
);
|
|
@@ -676,11 +1032,17 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
676
1032
|
}
|
|
677
1033
|
async updateTask(taskId, updates) {
|
|
678
1034
|
try {
|
|
679
|
-
const rows = await this.findAll({
|
|
1035
|
+
const rows = await this.findAll({
|
|
1036
|
+
where: "task_id = ?",
|
|
1037
|
+
params: [taskId],
|
|
1038
|
+
limit: 1
|
|
1039
|
+
});
|
|
680
1040
|
if (!rows.success) {
|
|
681
1041
|
return err(
|
|
682
1042
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
683
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1043
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1044
|
+
params: { error: rows.error.message }
|
|
1045
|
+
}),
|
|
684
1046
|
rows.error
|
|
685
1047
|
);
|
|
686
1048
|
}
|
|
@@ -715,7 +1077,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
715
1077
|
logger2.error("Failed to update task definition", { taskId, error: updateResult.error.message });
|
|
716
1078
|
return err(
|
|
717
1079
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
718
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1080
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1081
|
+
params: { error: updateResult.error.message }
|
|
1082
|
+
}),
|
|
719
1083
|
updateResult.error
|
|
720
1084
|
);
|
|
721
1085
|
}
|
|
@@ -725,7 +1089,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
725
1089
|
return err(
|
|
726
1090
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
727
1091
|
schedulerM("scheduler_dbSaveFailed", {
|
|
728
|
-
params: {
|
|
1092
|
+
params: {
|
|
1093
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1094
|
+
}
|
|
729
1095
|
}),
|
|
730
1096
|
error
|
|
731
1097
|
);
|
|
@@ -735,13 +1101,35 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
735
1101
|
async deleteTask(taskId, expected) {
|
|
736
1102
|
try {
|
|
737
1103
|
if (expected) {
|
|
738
|
-
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
|
+
];
|
|
739
1114
|
const postgres = this.db.config?.type === "postgresql";
|
|
740
1115
|
const enabled = expected.enabled !== false;
|
|
741
1116
|
const deleteAfterRun = expected.deleteAfterRun === true;
|
|
742
|
-
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
|
+
];
|
|
743
1127
|
const jsonValue = this.db.config?.type === "mysql" ? "CAST(? AS JSON)" : this.db.config?.type === "postgresql" ? "CAST(? AS JSONB)" : "?";
|
|
744
|
-
const jsonFields = [
|
|
1128
|
+
const jsonFields = [
|
|
1129
|
+
["retry", expected.retry],
|
|
1130
|
+
["params", expected.params ?? {}],
|
|
1131
|
+
["handler", expected.handler]
|
|
1132
|
+
];
|
|
745
1133
|
for (const [column, value] of jsonFields) {
|
|
746
1134
|
if (value === void 0 || value === null) {
|
|
747
1135
|
conditions.push(`(${column} IS NULL OR ${column} = ${jsonValue})`);
|
|
@@ -754,11 +1142,17 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
754
1142
|
const deleted = await this.db.sql.execute(`DELETE FROM ${SCHEDULER_TASK_TABLE} WHERE ${conditions.join(" AND ")}`, params);
|
|
755
1143
|
return deleted.success ? ok(deleted.data.changes > 0) : deleted;
|
|
756
1144
|
}
|
|
757
|
-
const rows = await this.findAll({
|
|
1145
|
+
const rows = await this.findAll({
|
|
1146
|
+
where: "task_id = ?",
|
|
1147
|
+
params: [taskId],
|
|
1148
|
+
limit: 1
|
|
1149
|
+
});
|
|
758
1150
|
if (!rows.success) {
|
|
759
1151
|
return err(
|
|
760
1152
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
761
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1153
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1154
|
+
params: { error: rows.error.message }
|
|
1155
|
+
}),
|
|
762
1156
|
rows.error
|
|
763
1157
|
);
|
|
764
1158
|
}
|
|
@@ -769,7 +1163,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
769
1163
|
logger2.error("Failed to delete task definition", { taskId, error: deleteResult.error.message });
|
|
770
1164
|
return err(
|
|
771
1165
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
772
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1166
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1167
|
+
params: { error: deleteResult.error.message }
|
|
1168
|
+
}),
|
|
773
1169
|
deleteResult.error
|
|
774
1170
|
);
|
|
775
1171
|
}
|
|
@@ -779,7 +1175,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
779
1175
|
return err(
|
|
780
1176
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
781
1177
|
schedulerM("scheduler_dbSaveFailed", {
|
|
782
|
-
params: {
|
|
1178
|
+
params: {
|
|
1179
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1180
|
+
}
|
|
783
1181
|
}),
|
|
784
1182
|
error
|
|
785
1183
|
);
|
|
@@ -791,7 +1189,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
791
1189
|
if (!rows.success) {
|
|
792
1190
|
return err(
|
|
793
1191
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
794
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1192
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1193
|
+
params: { error: rows.error.message }
|
|
1194
|
+
}),
|
|
795
1195
|
rows.error
|
|
796
1196
|
);
|
|
797
1197
|
}
|
|
@@ -799,15 +1199,21 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
799
1199
|
for (const row of rows.data) {
|
|
800
1200
|
const paramsResult = TaskParamsSchema.safeParse(row.params ?? {});
|
|
801
1201
|
if (!paramsResult.success) {
|
|
802
|
-
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
|
+
}));
|
|
803
1205
|
}
|
|
804
1206
|
const handlerResult = row.handler == null ? { success: true, data: void 0 } : TaskHandlerConfigSchema.safeParse(row.handler);
|
|
805
1207
|
if (!handlerResult.success) {
|
|
806
|
-
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
|
+
}));
|
|
807
1211
|
}
|
|
808
1212
|
const retryResult = row.retry == null ? { success: true, data: void 0 } : TaskRetryPolicySchema.safeParse(row.retry);
|
|
809
1213
|
if (!retryResult.success) {
|
|
810
|
-
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
|
+
}));
|
|
811
1217
|
}
|
|
812
1218
|
tasks.push({
|
|
813
1219
|
id: row.taskId,
|
|
@@ -829,7 +1235,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
829
1235
|
return err(
|
|
830
1236
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
831
1237
|
schedulerM("scheduler_dbSaveFailed", {
|
|
832
|
-
params: {
|
|
1238
|
+
params: {
|
|
1239
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1240
|
+
}
|
|
833
1241
|
}),
|
|
834
1242
|
error
|
|
835
1243
|
);
|
|
@@ -843,7 +1251,9 @@ function parseCronExpression(expression, timezone) {
|
|
|
843
1251
|
} catch {
|
|
844
1252
|
return err(
|
|
845
1253
|
HaiSchedulerError.INVALID_CRON,
|
|
846
|
-
schedulerM("scheduler_invalidCron", {
|
|
1254
|
+
schedulerM("scheduler_invalidCron", {
|
|
1255
|
+
params: { expression }
|
|
1256
|
+
})
|
|
847
1257
|
);
|
|
848
1258
|
}
|
|
849
1259
|
}
|
|
@@ -922,7 +1332,9 @@ function validateRetryPolicy(taskId, retry) {
|
|
|
922
1332
|
if (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1 || retry.maxAttempts > 100) {
|
|
923
1333
|
return err(
|
|
924
1334
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
925
|
-
schedulerM("scheduler_invalidRetryConfig", {
|
|
1335
|
+
schedulerM("scheduler_invalidRetryConfig", {
|
|
1336
|
+
params: { taskId }
|
|
1337
|
+
})
|
|
926
1338
|
);
|
|
927
1339
|
}
|
|
928
1340
|
if (retry.backoffMs !== void 0) {
|
|
@@ -930,13 +1342,17 @@ function validateRetryPolicy(taskId, retry) {
|
|
|
930
1342
|
if (hasInvalidBackoff) {
|
|
931
1343
|
return err(
|
|
932
1344
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
933
|
-
schedulerM("scheduler_invalidRetryConfig", {
|
|
1345
|
+
schedulerM("scheduler_invalidRetryConfig", {
|
|
1346
|
+
params: { taskId }
|
|
1347
|
+
})
|
|
934
1348
|
);
|
|
935
1349
|
}
|
|
936
1350
|
}
|
|
937
1351
|
return ok({
|
|
938
1352
|
maxAttempts: retry.maxAttempts,
|
|
939
|
-
...retry.backoffMs ? {
|
|
1353
|
+
...retry.backoffMs ? {
|
|
1354
|
+
backoffMs: [...retry.backoffMs]
|
|
1355
|
+
} : {}
|
|
940
1356
|
});
|
|
941
1357
|
}
|
|
942
1358
|
async function loadPersistedTasks(taskRepo2) {
|
|
@@ -959,7 +1375,10 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
|
|
|
959
1375
|
});
|
|
960
1376
|
let loadResult;
|
|
961
1377
|
try {
|
|
962
|
-
loadResult = await Promise.race([
|
|
1378
|
+
loadResult = await Promise.race([
|
|
1379
|
+
taskRepo2.loadTasks(),
|
|
1380
|
+
cancelled
|
|
1381
|
+
]);
|
|
963
1382
|
} finally {
|
|
964
1383
|
signal.removeEventListener("abort", cancel);
|
|
965
1384
|
}
|
|
@@ -974,8 +1393,11 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
|
|
|
974
1393
|
for (const task of loadResult.data) {
|
|
975
1394
|
if (!task.id)
|
|
976
1395
|
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_taskIdEmpty"));
|
|
977
|
-
if (nextTasks.has(task.id))
|
|
978
|
-
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
|
+
}
|
|
979
1401
|
const cronResult = parseCronExpression(task.cron, task.timezone);
|
|
980
1402
|
if (!cronResult.success)
|
|
981
1403
|
return cronResult;
|
|
@@ -1014,7 +1436,9 @@ async function registerTask(task, taskRepo2) {
|
|
|
1014
1436
|
}
|
|
1015
1437
|
async function registerTaskDefinition(task, taskRepo2) {
|
|
1016
1438
|
if (task.handler && !TaskHandlerConfigSchema.safeParse(task.handler).success || task.idempotent !== void 0 && typeof task.idempotent !== "boolean") {
|
|
1017
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1439
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1440
|
+
params: { taskId: task.id }
|
|
1441
|
+
}));
|
|
1018
1442
|
}
|
|
1019
1443
|
if (!task.id) {
|
|
1020
1444
|
return err(
|
|
@@ -1025,7 +1449,9 @@ async function registerTaskDefinition(task, taskRepo2) {
|
|
|
1025
1449
|
if (hasTask(task.id)) {
|
|
1026
1450
|
return err(
|
|
1027
1451
|
HaiSchedulerError.TASK_ALREADY_EXISTS,
|
|
1028
|
-
schedulerM("scheduler_taskAlreadyExists", {
|
|
1452
|
+
schedulerM("scheduler_taskAlreadyExists", {
|
|
1453
|
+
params: { taskId: task.id }
|
|
1454
|
+
})
|
|
1029
1455
|
);
|
|
1030
1456
|
}
|
|
1031
1457
|
const cronResult = parseCronExpression(task.cron, task.timezone);
|
|
@@ -1050,7 +1476,9 @@ async function registerTaskDefinition(task, taskRepo2) {
|
|
|
1050
1476
|
logger3.warn("Failed to persist task definition", { taskId: task.id, error: saveResult.error.message });
|
|
1051
1477
|
return err(
|
|
1052
1478
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1053
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1479
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1480
|
+
params: { error: saveResult.error.message }
|
|
1481
|
+
}),
|
|
1054
1482
|
saveResult.error
|
|
1055
1483
|
);
|
|
1056
1484
|
}
|
|
@@ -1074,7 +1502,9 @@ async function unregisterTaskDefinition(taskId, taskRepo2, expected) {
|
|
|
1074
1502
|
if (!hasTask(taskId)) {
|
|
1075
1503
|
return err(
|
|
1076
1504
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
1077
|
-
schedulerM("scheduler_taskNotFound", {
|
|
1505
|
+
schedulerM("scheduler_taskNotFound", {
|
|
1506
|
+
params: { taskId }
|
|
1507
|
+
})
|
|
1078
1508
|
);
|
|
1079
1509
|
}
|
|
1080
1510
|
if (taskRepo2) {
|
|
@@ -1083,7 +1513,9 @@ async function unregisterTaskDefinition(taskId, taskRepo2, expected) {
|
|
|
1083
1513
|
logger3.warn("Failed to delete persisted task definition", { taskId, error: deleteResult.error.message });
|
|
1084
1514
|
return err(
|
|
1085
1515
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1086
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1516
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1517
|
+
params: { error: deleteResult.error.message }
|
|
1518
|
+
}),
|
|
1087
1519
|
deleteResult.error
|
|
1088
1520
|
);
|
|
1089
1521
|
}
|
|
@@ -1110,7 +1542,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1110
1542
|
if (!existingTask) {
|
|
1111
1543
|
return err(
|
|
1112
1544
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
1113
|
-
schedulerM("scheduler_taskNotFound", {
|
|
1545
|
+
schedulerM("scheduler_taskNotFound", {
|
|
1546
|
+
params: { taskId }
|
|
1547
|
+
})
|
|
1114
1548
|
);
|
|
1115
1549
|
}
|
|
1116
1550
|
let updatedCron = getCron(taskId);
|
|
@@ -1140,7 +1574,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1140
1574
|
...updates.retry !== void 0 ? { retry: normalizedRetry } : {}
|
|
1141
1575
|
};
|
|
1142
1576
|
if (updates.handler && !TaskHandlerConfigSchema.safeParse(updates.handler).success || updates.idempotent !== void 0 && typeof updates.idempotent !== "boolean") {
|
|
1143
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1577
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1578
|
+
params: { taskId }
|
|
1579
|
+
}));
|
|
1144
1580
|
}
|
|
1145
1581
|
const updatedTask = {
|
|
1146
1582
|
...existingTask,
|
|
@@ -1161,7 +1597,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1161
1597
|
logger3.warn("Failed to update persisted task definition", { taskId, error: updateResult.error.message });
|
|
1162
1598
|
return err(
|
|
1163
1599
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1164
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1600
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1601
|
+
params: { error: updateResult.error.message }
|
|
1602
|
+
}),
|
|
1165
1603
|
updateResult.error
|
|
1166
1604
|
);
|
|
1167
1605
|
}
|
|
@@ -1214,7 +1652,9 @@ function compileJsTaskHandler(config) {
|
|
|
1214
1652
|
signal?.removeEventListener("abort", aborted);
|
|
1215
1653
|
void worker.terminate().then(() => error ? reject(error) : resolve(result), reject);
|
|
1216
1654
|
}
|
|
1217
|
-
timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
|
|
1655
|
+
timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
|
|
1656
|
+
params: { timeout }
|
|
1657
|
+
}))), timeout);
|
|
1218
1658
|
signal?.addEventListener("abort", aborted, { once: true });
|
|
1219
1659
|
worker.once("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
|
|
1220
1660
|
worker.once("exit", (code) => finish(new Error(`JS worker exited before returning a result (${code})`)));
|
|
@@ -1232,84 +1672,115 @@ function compileJsTaskHandler(config) {
|
|
|
1232
1672
|
return err(
|
|
1233
1673
|
HaiSchedulerError.JS_COMPILE_FAILED,
|
|
1234
1674
|
schedulerM("scheduler_jsCompileFailed", {
|
|
1235
|
-
params: {
|
|
1675
|
+
params: {
|
|
1676
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1677
|
+
}
|
|
1236
1678
|
}),
|
|
1237
1679
|
error
|
|
1238
1680
|
);
|
|
1239
1681
|
}
|
|
1240
1682
|
}
|
|
1241
1683
|
function migrateScheduler(options = {}) {
|
|
1242
|
-
const steps = [
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
version: 2,
|
|
1254
|
-
name: "execution-history-snapshots",
|
|
1255
|
-
async needed(sql) {
|
|
1256
|
-
const columns = await schemaColumns(reldb, "hai_scheduler_logs", sql);
|
|
1257
|
-
if (!columns.success)
|
|
1258
|
-
return columns;
|
|
1259
|
-
if (columns.data.length && !columns.data.includes("payload"))
|
|
1260
|
-
return ok(true);
|
|
1261
|
-
const archive = await schemaColumns(reldb, "hai_scheduler_logs_alpha65", sql);
|
|
1262
|
-
if (!archive.success)
|
|
1263
|
-
return archive;
|
|
1264
|
-
if (!archive.data.length)
|
|
1265
|
-
return ok(false);
|
|
1266
|
-
if (!columns.data.length)
|
|
1267
|
-
return ok(true);
|
|
1268
|
-
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)";
|
|
1269
|
-
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`);
|
|
1270
|
-
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
|
+
}
|
|
1271
1695
|
},
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
|
|
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);
|
|
1278
1706
|
if (!archive.success)
|
|
1279
1707
|
return archive;
|
|
1280
|
-
if (archive.data.length)
|
|
1281
|
-
return
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
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);
|
|
1306
1779
|
}
|
|
1307
|
-
if (rows.data.length < 100)
|
|
1308
|
-
return ok(void 0);
|
|
1309
1780
|
}
|
|
1310
1781
|
}
|
|
1311
|
-
|
|
1312
|
-
return migrateSchema(
|
|
1782
|
+
];
|
|
1783
|
+
return reldb.migrateSchema("scheduler", steps, options);
|
|
1313
1784
|
}
|
|
1314
1785
|
|
|
1315
1786
|
// src/scheduler-cancellation.ts
|
|
@@ -1412,7 +1883,9 @@ async function executeJsTask(task, context, signal = new AbortController().signa
|
|
|
1412
1883
|
if (!handler || handler.kind !== "js") {
|
|
1413
1884
|
return err(
|
|
1414
1885
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1415
|
-
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1886
|
+
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1887
|
+
params: { taskId: task.id }
|
|
1888
|
+
})
|
|
1416
1889
|
);
|
|
1417
1890
|
}
|
|
1418
1891
|
const compileResult = compileJsTaskHandler(handler);
|
|
@@ -1426,7 +1899,9 @@ async function executeJsTask(task, context, signal = new AbortController().signa
|
|
|
1426
1899
|
logger4.error("JS task execution failed", { taskId: task.id, error: message });
|
|
1427
1900
|
return err(
|
|
1428
1901
|
HaiSchedulerError.JS_EXECUTION_FAILED,
|
|
1429
|
-
schedulerM("scheduler_jsExecutionFailed", {
|
|
1902
|
+
schedulerM("scheduler_jsExecutionFailed", {
|
|
1903
|
+
params: { error: message }
|
|
1904
|
+
}),
|
|
1430
1905
|
error
|
|
1431
1906
|
);
|
|
1432
1907
|
}
|
|
@@ -1436,12 +1911,17 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1436
1911
|
if (!handler || handler.kind !== "api") {
|
|
1437
1912
|
return err(
|
|
1438
1913
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1439
|
-
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1914
|
+
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1915
|
+
params: { taskId: task.id }
|
|
1916
|
+
})
|
|
1440
1917
|
);
|
|
1441
1918
|
}
|
|
1442
1919
|
const { url, method = "GET", headers, body, timeout = 3e4, maxResponseBytes = 1024 * 1024 } = handler;
|
|
1443
|
-
if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)
|
|
1444
|
-
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
|
+
}
|
|
1445
1925
|
const controller = new AbortController();
|
|
1446
1926
|
const timer = setTimeout(() => controller.abort(), timeout);
|
|
1447
1927
|
try {
|
|
@@ -1458,7 +1938,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1458
1938
|
method,
|
|
1459
1939
|
headers: requestHeaders,
|
|
1460
1940
|
signal: AbortSignal.any([signal, controller.signal]),
|
|
1461
|
-
...body !== void 0 ? {
|
|
1941
|
+
...body !== void 0 ? {
|
|
1942
|
+
body: JSON.stringify(body)
|
|
1943
|
+
} : {}
|
|
1462
1944
|
});
|
|
1463
1945
|
let receivedBytes = 0;
|
|
1464
1946
|
let responseText = "";
|
|
@@ -1473,7 +1955,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1473
1955
|
receivedBytes += chunk.value.byteLength;
|
|
1474
1956
|
if (receivedBytes > maxResponseBytes) {
|
|
1475
1957
|
controller.abort();
|
|
1476
|
-
return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
|
|
1958
|
+
return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
|
|
1959
|
+
params: { maxResponseBytes }
|
|
1960
|
+
}));
|
|
1477
1961
|
}
|
|
1478
1962
|
responseText += decoder.decode(chunk.value, { stream: true });
|
|
1479
1963
|
}
|
|
@@ -1498,10 +1982,16 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1498
1982
|
return ok(responseText || null);
|
|
1499
1983
|
} catch (error) {
|
|
1500
1984
|
const message = error instanceof Error ? error.message : String(error);
|
|
1501
|
-
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
|
+
});
|
|
1502
1990
|
return err(
|
|
1503
1991
|
HaiSchedulerError.API_EXECUTION_FAILED,
|
|
1504
|
-
schedulerM("scheduler_apiExecutionFailed", {
|
|
1992
|
+
schedulerM("scheduler_apiExecutionFailed", {
|
|
1993
|
+
params: { error: message }
|
|
1994
|
+
}),
|
|
1505
1995
|
error
|
|
1506
1996
|
);
|
|
1507
1997
|
} finally {
|
|
@@ -1512,7 +2002,9 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
|
|
|
1512
2002
|
if (!hooks.onTaskExecute) {
|
|
1513
2003
|
return err(
|
|
1514
2004
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1515
|
-
schedulerM("scheduler_taskHandlerMissing", {
|
|
2005
|
+
schedulerM("scheduler_taskHandlerMissing", {
|
|
2006
|
+
params: { taskId: task.id }
|
|
2007
|
+
})
|
|
1516
2008
|
);
|
|
1517
2009
|
}
|
|
1518
2010
|
const executeEvent = {
|
|
@@ -1530,7 +2022,9 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
|
|
|
1530
2022
|
logger4.error("Task execute hook failed", { taskId: task.id, error: message });
|
|
1531
2023
|
return err(
|
|
1532
2024
|
HaiSchedulerError.HOOK_EXECUTION_FAILED,
|
|
1533
|
-
schedulerM("scheduler_hookExecutionFailed", {
|
|
2025
|
+
schedulerM("scheduler_hookExecutionFailed", {
|
|
2026
|
+
params: { error: message }
|
|
2027
|
+
}),
|
|
1534
2028
|
error
|
|
1535
2029
|
);
|
|
1536
2030
|
}
|
|
@@ -1539,7 +2033,13 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
|
|
|
1539
2033
|
const startedAt = Date.now();
|
|
1540
2034
|
const taskType = resolveTaskType(task, hooks);
|
|
1541
2035
|
const context = createTaskContext(task, trigger, execution);
|
|
1542
|
-
await notifyTaskStart(hooks, {
|
|
2036
|
+
await notifyTaskStart(hooks, {
|
|
2037
|
+
task,
|
|
2038
|
+
trigger,
|
|
2039
|
+
startedAt,
|
|
2040
|
+
signal,
|
|
2041
|
+
context
|
|
2042
|
+
});
|
|
1543
2043
|
let executionResult;
|
|
1544
2044
|
let shouldNotifyInterrupted = false;
|
|
1545
2045
|
if (signal.aborted) {
|
|
@@ -1580,8 +2080,17 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
|
|
|
1580
2080
|
context
|
|
1581
2081
|
});
|
|
1582
2082
|
}
|
|
1583
|
-
if (status !== "interrupted" && !signal.aborted)
|
|
1584
|
-
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
|
+
}
|
|
1585
2094
|
return log;
|
|
1586
2095
|
}
|
|
1587
2096
|
|
|
@@ -1611,13 +2120,24 @@ var publishedLogSchema = z.object({
|
|
|
1611
2120
|
taskType: z.enum(["api", "js", "hook"]),
|
|
1612
2121
|
triggerType: z.enum(["manual", "scheduled"]),
|
|
1613
2122
|
triggerSource: z.string().nullable(),
|
|
1614
|
-
status: z.enum([
|
|
2123
|
+
status: z.enum([
|
|
2124
|
+
"success",
|
|
2125
|
+
"failed",
|
|
2126
|
+
"interrupted",
|
|
2127
|
+
"unknown"
|
|
2128
|
+
]),
|
|
1615
2129
|
result: z.string().nullable(),
|
|
1616
2130
|
error: z.string().nullable(),
|
|
1617
2131
|
startedAt: z.number().safe(),
|
|
1618
2132
|
finishedAt: z.number().safe(),
|
|
1619
2133
|
duration: z.number().safe(),
|
|
1620
|
-
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
|
+
})
|
|
1621
2141
|
});
|
|
1622
2142
|
function repairExecutionLogs(id) {
|
|
1623
2143
|
const operation = projectExecutionLogs(id);
|
|
@@ -1694,7 +2214,9 @@ async function drainRunner() {
|
|
|
1694
2214
|
stopTimer();
|
|
1695
2215
|
for (const controller of activeRuns.values())
|
|
1696
2216
|
controller.abort(new Error(schedulerM("scheduler_closing")));
|
|
1697
|
-
await Promise.allSettled([
|
|
2217
|
+
await Promise.allSettled([
|
|
2218
|
+
...activeRuns.keys()
|
|
2219
|
+
]);
|
|
1698
2220
|
await Promise.allSettled([...activeRepairs]);
|
|
1699
2221
|
}
|
|
1700
2222
|
async function tick() {
|
|
@@ -1772,20 +2294,35 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1772
2294
|
const leaseMs = currentLeaseMs;
|
|
1773
2295
|
const occurrenceId = recovery?.occurrenceId ?? executionId(task.id, trigger.type, minute === void 0 ? options?.idempotencyKey ?? randomUUID() : String(minute));
|
|
1774
2296
|
const interrupted = async (reason, observationOnly = false) => {
|
|
1775
|
-
const log = {
|
|
2297
|
+
const log = {
|
|
2298
|
+
...await interruptTask(task, trigger, reason, {}, controller.signal),
|
|
2299
|
+
occurrenceId
|
|
2300
|
+
};
|
|
1776
2301
|
if (observationOnly && logRepository) {
|
|
1777
2302
|
const saved = await logRepository.saveLog(log);
|
|
1778
|
-
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
|
+
};
|
|
1779
2310
|
}
|
|
1780
2311
|
return log;
|
|
1781
2312
|
};
|
|
1782
2313
|
if (!executionRepo2)
|
|
1783
2314
|
return interrupted(schedulerM("scheduler_executionStateFailed"), true);
|
|
1784
|
-
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);
|
|
1785
2319
|
if (!claimed.success)
|
|
1786
2320
|
return interrupted(claimed.error.message, true);
|
|
1787
|
-
if (!claimed.data)
|
|
1788
|
-
return interrupted(schedulerM("scheduler_taskRunning", {
|
|
2321
|
+
if (!claimed.data) {
|
|
2322
|
+
return interrupted(schedulerM("scheduler_taskRunning", {
|
|
2323
|
+
params: { taskId: task.id }
|
|
2324
|
+
}), true);
|
|
2325
|
+
}
|
|
1789
2326
|
const row = claimed.data;
|
|
1790
2327
|
if (!["claimed", "running"].includes(row.status)) {
|
|
1791
2328
|
if (minute === void 0) {
|
|
@@ -1806,12 +2343,19 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1806
2343
|
duration: row.updatedAt - row.createdAt
|
|
1807
2344
|
};
|
|
1808
2345
|
const status = row.status === "discarded" ? "interrupted" : row.status;
|
|
1809
|
-
return {
|
|
2346
|
+
return {
|
|
2347
|
+
...log,
|
|
2348
|
+
status,
|
|
2349
|
+
error: status === "success" ? null : log.error,
|
|
2350
|
+
occurrenceId
|
|
2351
|
+
};
|
|
1810
2352
|
} catch {
|
|
1811
2353
|
return interrupted(schedulerM("scheduler_executionStateFailed"));
|
|
1812
2354
|
}
|
|
1813
2355
|
}
|
|
1814
|
-
return interrupted(schedulerM("scheduler_occurrenceHandled", {
|
|
2356
|
+
return interrupted(schedulerM("scheduler_occurrenceHandled", {
|
|
2357
|
+
params: { taskId: task.id }
|
|
2358
|
+
}), true);
|
|
1815
2359
|
}
|
|
1816
2360
|
runningTasks.add(task.id);
|
|
1817
2361
|
let timer;
|
|
@@ -1850,14 +2394,21 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1850
2394
|
} catch {
|
|
1851
2395
|
}
|
|
1852
2396
|
if (!refreshed.success || !latest || latest.enabled === false || !unchanged) {
|
|
1853
|
-
log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
|
|
2397
|
+
log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
|
|
2398
|
+
params: { taskId: task.id }
|
|
2399
|
+
}));
|
|
1854
2400
|
if (row.attemptCount > 0)
|
|
1855
2401
|
log.status = "unknown";
|
|
1856
2402
|
break;
|
|
1857
2403
|
}
|
|
1858
2404
|
task = latest;
|
|
1859
2405
|
if (!task.handler && !hooks.onTaskExecute) {
|
|
1860
|
-
log = {
|
|
2406
|
+
log = {
|
|
2407
|
+
...await interruptTask(task, trigger, schedulerM("scheduler_taskHandlerMissing", {
|
|
2408
|
+
params: { taskId: task.id }
|
|
2409
|
+
}), hooks, controller.signal),
|
|
2410
|
+
occurrenceId
|
|
2411
|
+
};
|
|
1861
2412
|
break;
|
|
1862
2413
|
}
|
|
1863
2414
|
const begun = await executionRepo2.begin(row, leaseMs);
|
|
@@ -1865,7 +2416,12 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1865
2416
|
lost = true;
|
|
1866
2417
|
break;
|
|
1867
2418
|
}
|
|
1868
|
-
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
|
+
});
|
|
1869
2425
|
log.occurrenceId = occurrenceId;
|
|
1870
2426
|
attempts.push(log);
|
|
1871
2427
|
if (log.status !== "failed" || !row.idempotent || row.attemptCount >= row.maxAttempts)
|
|
@@ -1877,21 +2433,51 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1877
2433
|
if (!log)
|
|
1878
2434
|
log = await interrupted(schedulerM("scheduler_executionStateFailed"));
|
|
1879
2435
|
if (lost) {
|
|
1880
|
-
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
|
+
};
|
|
1881
2450
|
}
|
|
1882
|
-
if (controller.signal.aborted && row.attemptCount > 0)
|
|
1883
|
-
log = { ...log, status: "unknown", error: schedulerM("scheduler_executionUnknown") };
|
|
1884
2451
|
const currentAttempt = attempts.findIndex((attempt) => attempt.id === log.id);
|
|
1885
2452
|
if (currentAttempt >= 0)
|
|
1886
2453
|
attempts[currentAttempt] = log;
|
|
1887
2454
|
else
|
|
1888
2455
|
attempts.push(log);
|
|
1889
|
-
const published = attempts.map((attempt) => ({
|
|
1890
|
-
|
|
1891
|
-
|
|
1892
|
-
|
|
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
|
+
}
|
|
1893
2473
|
const projected = await repairExecutionLogs(occurrenceId);
|
|
1894
|
-
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
|
+
};
|
|
1895
2481
|
if (!projected.success)
|
|
1896
2482
|
logger5.warn("Execution completed with pending log persistence", { taskId: task.id, occurrenceId, errorCode: projected.error.code });
|
|
1897
2483
|
if (task.deleteAfterRun && log.status === "success") {
|
|
@@ -1926,7 +2512,10 @@ var taskRepo = null;
|
|
|
1926
2512
|
var logRepo = null;
|
|
1927
2513
|
var executionRepo = null;
|
|
1928
2514
|
var executionIdSchema = z.string().regex(/^[a-f\d]{64}$/);
|
|
1929
|
-
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
|
+
});
|
|
1930
2519
|
var notInitialized = core.module.createNotInitializedKit(
|
|
1931
2520
|
HaiSchedulerError.NOT_INITIALIZED,
|
|
1932
2521
|
() => schedulerM("scheduler_notInitialized")
|
|
@@ -2010,7 +2599,9 @@ var scheduler = {
|
|
|
2010
2599
|
logger6.warn("Scheduler init already in progress, skipping concurrent call");
|
|
2011
2600
|
return err(
|
|
2012
2601
|
HaiSchedulerError.INIT_FAILED,
|
|
2013
|
-
schedulerM("scheduler_initFailed", {
|
|
2602
|
+
schedulerM("scheduler_initFailed", {
|
|
2603
|
+
params: { error: "Concurrent initialization detected" }
|
|
2604
|
+
})
|
|
2014
2605
|
);
|
|
2015
2606
|
}
|
|
2016
2607
|
initInProgress = true;
|
|
@@ -2028,7 +2619,9 @@ var scheduler = {
|
|
|
2028
2619
|
logger6.error("Scheduler config validation failed", { error: parseResult.error.message });
|
|
2029
2620
|
return err(
|
|
2030
2621
|
HaiSchedulerError.CONFIG_ERROR,
|
|
2031
|
-
schedulerM("scheduler_configError", {
|
|
2622
|
+
schedulerM("scheduler_configError", {
|
|
2623
|
+
params: { error: parseResult.error.message }
|
|
2624
|
+
}),
|
|
2032
2625
|
parseResult.error
|
|
2033
2626
|
);
|
|
2034
2627
|
}
|
|
@@ -2053,7 +2646,9 @@ var scheduler = {
|
|
|
2053
2646
|
return err(
|
|
2054
2647
|
HaiSchedulerError.INIT_FAILED,
|
|
2055
2648
|
schedulerM("scheduler_initFailed", {
|
|
2056
|
-
params: {
|
|
2649
|
+
params: {
|
|
2650
|
+
error: error instanceof Error ? error.message : String(error)
|
|
2651
|
+
}
|
|
2057
2652
|
}),
|
|
2058
2653
|
error
|
|
2059
2654
|
);
|
|
@@ -2089,8 +2684,12 @@ var scheduler = {
|
|
|
2089
2684
|
if (!currentConfig)
|
|
2090
2685
|
return notInitialized.result();
|
|
2091
2686
|
const updateResult = await updateRegisteredTask(taskId, updates, taskRepo);
|
|
2092
|
-
if (updateResult.success)
|
|
2093
|
-
logger6.info("Task updated", {
|
|
2687
|
+
if (updateResult.success) {
|
|
2688
|
+
logger6.info("Task updated", {
|
|
2689
|
+
taskId,
|
|
2690
|
+
updates: Object.keys(updates)
|
|
2691
|
+
});
|
|
2692
|
+
}
|
|
2094
2693
|
return updateResult;
|
|
2095
2694
|
},
|
|
2096
2695
|
start() {
|
|
@@ -2135,7 +2734,9 @@ var scheduler = {
|
|
|
2135
2734
|
if (!task) {
|
|
2136
2735
|
return err(
|
|
2137
2736
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
2138
|
-
schedulerM("scheduler_taskNotFound", {
|
|
2737
|
+
schedulerM("scheduler_taskNotFound", {
|
|
2738
|
+
params: { taskId }
|
|
2739
|
+
})
|
|
2139
2740
|
);
|
|
2140
2741
|
}
|
|
2141
2742
|
const log = await runTask(task, void 0, normalizeTriggerInput(parsed.data), parsed.data);
|