@h-ai/scheduler 1.0.0-beta.3 → 1.0.0-beta.30
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 -14
- package/dist/index.js +769 -251
- 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
|
-
import { core, ok, err
|
|
3
|
-
import {
|
|
2
|
+
import { core, ok, err } from '@h-ai/core';
|
|
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,10 +266,21 @@ 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
|
}
|
|
280
|
+
/** 等待执行表就绪并验证当前字段定义。 */
|
|
281
|
+
ready() {
|
|
282
|
+
return this.ensureSchema();
|
|
283
|
+
}
|
|
229
284
|
/**
|
|
230
285
|
* 只按已初始化的数据库类型选择存储端毫秒时钟。
|
|
231
286
|
* PostgreSQL/MySQL 使用执行时钟,不能使用固定在事务/语句开始处的时间快照。
|
|
@@ -260,11 +315,23 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
260
315
|
/** 读取统一校验 BIGINT,不能把 PG 字符串时间或舍入的序号用于 owner 判断。 */
|
|
261
316
|
normalize(row) {
|
|
262
317
|
const value = { ...row };
|
|
263
|
-
for (const field of [
|
|
318
|
+
for (const field of [
|
|
319
|
+
"snapshot",
|
|
320
|
+
"triggerJson",
|
|
321
|
+
"logJson",
|
|
322
|
+
"logsJson"
|
|
323
|
+
]) {
|
|
264
324
|
if (row[field] !== void 0 && row[field] !== null && typeof row[field] !== "string")
|
|
265
325
|
value[field] = JSON.stringify(row[field]);
|
|
266
326
|
}
|
|
267
|
-
for (const field of [
|
|
327
|
+
for (const field of [
|
|
328
|
+
"sequence",
|
|
329
|
+
"leasedUntil",
|
|
330
|
+
"attemptCount",
|
|
331
|
+
"maxAttempts",
|
|
332
|
+
"updatedAt",
|
|
333
|
+
"createdAt"
|
|
334
|
+
]) {
|
|
268
335
|
const number = Number(row[field]);
|
|
269
336
|
if (!Number.isSafeInteger(number) || number < 0)
|
|
270
337
|
return failed();
|
|
@@ -274,7 +341,11 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
274
341
|
}
|
|
275
342
|
/** 按稳定回执读取。@example await repository.byOccurrence(id) */
|
|
276
343
|
async byOccurrence(id) {
|
|
277
|
-
const rows = await this.findAll({
|
|
344
|
+
const rows = await this.findAll({
|
|
345
|
+
where: "occurrence_id = ?",
|
|
346
|
+
params: [id],
|
|
347
|
+
limit: 1
|
|
348
|
+
});
|
|
278
349
|
if (!rows.success)
|
|
279
350
|
return failed(rows.error);
|
|
280
351
|
return rows.data[0] ? this.normalize(rows.data[0]) : ok(null);
|
|
@@ -288,7 +359,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
288
359
|
const result = await this.db.sql.execute(
|
|
289
360
|
`UPDATE ${TABLE} SET status = ?, owner = NULL, leased_until = 0, updated_at = ${this.nextUpdatedAt()}
|
|
290
361
|
WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${this.databaseClock()} AND status IN (?, ?)`,
|
|
291
|
-
[
|
|
362
|
+
[
|
|
363
|
+
"unknown",
|
|
364
|
+
row.occurrenceId,
|
|
365
|
+
row.owner,
|
|
366
|
+
"claimed",
|
|
367
|
+
"running"
|
|
368
|
+
]
|
|
292
369
|
);
|
|
293
370
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
294
371
|
}
|
|
@@ -311,7 +388,18 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
311
388
|
const result = await this.db.sql.execute(
|
|
312
389
|
`UPDATE ${TABLE} SET log_persistence = ?, log_json = ?, updated_at = ${this.nextUpdatedAt()}
|
|
313
390
|
WHERE occurrence_id = ? AND updated_at = ? AND log_persistence = ? AND status NOT IN (?, ?)`,
|
|
314
|
-
[
|
|
391
|
+
[
|
|
392
|
+
"persisted",
|
|
393
|
+
JSON.stringify({
|
|
394
|
+
...log,
|
|
395
|
+
persistence: { status: "persisted" }
|
|
396
|
+
}),
|
|
397
|
+
row.occurrenceId,
|
|
398
|
+
row.updatedAt,
|
|
399
|
+
"pending",
|
|
400
|
+
"claimed",
|
|
401
|
+
"running"
|
|
402
|
+
]
|
|
315
403
|
);
|
|
316
404
|
if (result.success && result.data.changes === 1)
|
|
317
405
|
return ok(void 0);
|
|
@@ -319,7 +407,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
319
407
|
return current.success && current.data?.logPersistence === "persisted" && current.data.logsJson === row.logsJson ? ok(void 0) : failed();
|
|
320
408
|
}
|
|
321
409
|
async rows(where, params, limit, offset) {
|
|
322
|
-
const result = await this.findAll({
|
|
410
|
+
const result = await this.findAll({
|
|
411
|
+
where,
|
|
412
|
+
params,
|
|
413
|
+
limit,
|
|
414
|
+
offset,
|
|
415
|
+
orderBy: "sequence ASC"
|
|
416
|
+
});
|
|
323
417
|
if (!result.success)
|
|
324
418
|
return failed(result.error);
|
|
325
419
|
const rows = [];
|
|
@@ -341,26 +435,52 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
341
435
|
return failed(ready.error);
|
|
342
436
|
const clock = this.databaseClock();
|
|
343
437
|
const owner = `${nodeId}:${randomUUID()}`;
|
|
438
|
+
const postgres = this.db.config?.type === "postgresql";
|
|
439
|
+
const conflictClause = postgres ? " ON CONFLICT DO NOTHING" : "";
|
|
344
440
|
let created;
|
|
345
441
|
try {
|
|
346
442
|
created = await this.db.sql.execute(
|
|
347
443
|
`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
|
-
[
|
|
444
|
+
VALUES (?, ?, ?, ?, ?, ${clock} + ?, 0, ?, ?, ?, ?, ?, ${clock}, ${clock})${conflictClause}`,
|
|
445
|
+
[
|
|
446
|
+
id,
|
|
447
|
+
task.id,
|
|
448
|
+
task.id,
|
|
449
|
+
"claimed",
|
|
450
|
+
owner,
|
|
451
|
+
leaseMs,
|
|
452
|
+
task.retry?.maxAttempts ?? 1,
|
|
453
|
+
postgres ? task.idempotent === true : Number(task.idempotent === true),
|
|
454
|
+
JSON.stringify(task),
|
|
455
|
+
JSON.stringify(trigger),
|
|
456
|
+
"unconfirmed"
|
|
457
|
+
]
|
|
350
458
|
);
|
|
351
459
|
} catch (cause) {
|
|
352
460
|
return failed(cause);
|
|
353
461
|
}
|
|
462
|
+
if (postgres && !created.success)
|
|
463
|
+
return failed(created.error);
|
|
354
464
|
const existing = await this.byOccurrence(id);
|
|
355
465
|
if (!existing.success)
|
|
356
466
|
return existing;
|
|
357
467
|
if (!existing.data) {
|
|
358
|
-
const active = await this.findAll({
|
|
468
|
+
const active = await this.findAll({
|
|
469
|
+
where: "active_task = ?",
|
|
470
|
+
params: [task.id],
|
|
471
|
+
limit: 1
|
|
472
|
+
});
|
|
359
473
|
return active.success && active.data.length > 0 ? ok(null) : failed(created.success ? void 0 : created.error);
|
|
360
474
|
}
|
|
361
475
|
const row = existing.data;
|
|
362
|
-
if (created.success
|
|
476
|
+
if (created.success && created.data.changes === 1 || [
|
|
477
|
+
"success",
|
|
478
|
+
"failed",
|
|
479
|
+
"interrupted",
|
|
480
|
+
"discarded"
|
|
481
|
+
].includes(row.status)) {
|
|
363
482
|
return ok(row);
|
|
483
|
+
}
|
|
364
484
|
if (row.status === "unknown")
|
|
365
485
|
return ok(null);
|
|
366
486
|
if (row.status === "running" && (!row.idempotent || row.attemptCount >= row.maxAttempts)) {
|
|
@@ -374,7 +494,15 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
374
494
|
const recovered = await this.db.sql.execute(
|
|
375
495
|
`UPDATE ${TABLE} SET status = ?, owner = ?, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
|
|
376
496
|
WHERE occurrence_id = ? AND owner = ? AND leased_until <= ${clock} AND status IN (?, ?)`,
|
|
377
|
-
[
|
|
497
|
+
[
|
|
498
|
+
"claimed",
|
|
499
|
+
owner,
|
|
500
|
+
leaseMs,
|
|
501
|
+
id,
|
|
502
|
+
row.owner,
|
|
503
|
+
"claimed",
|
|
504
|
+
"running"
|
|
505
|
+
]
|
|
378
506
|
);
|
|
379
507
|
if (!recovered.success)
|
|
380
508
|
return failed(recovered.error);
|
|
@@ -386,7 +514,14 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
386
514
|
const result = await this.db.sql.execute(
|
|
387
515
|
`UPDATE ${TABLE} SET status = ?, attempt_count = attempt_count + 1, leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()}
|
|
388
516
|
WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?) AND attempt_count < max_attempts`,
|
|
389
|
-
[
|
|
517
|
+
[
|
|
518
|
+
"running",
|
|
519
|
+
leaseMs,
|
|
520
|
+
row.occurrenceId,
|
|
521
|
+
row.owner,
|
|
522
|
+
"claimed",
|
|
523
|
+
"running"
|
|
524
|
+
]
|
|
390
525
|
);
|
|
391
526
|
if (!result.success || result.data.changes !== 1)
|
|
392
527
|
return failed(result.success ? void 0 : result.error);
|
|
@@ -399,7 +534,13 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
399
534
|
const clock = this.databaseClock();
|
|
400
535
|
const result = await this.db.sql.execute(
|
|
401
536
|
`UPDATE ${TABLE} SET leased_until = ${clock} + ?, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
|
|
402
|
-
[
|
|
537
|
+
[
|
|
538
|
+
leaseMs,
|
|
539
|
+
row.occurrenceId,
|
|
540
|
+
row.owner,
|
|
541
|
+
"claimed",
|
|
542
|
+
"running"
|
|
543
|
+
]
|
|
403
544
|
);
|
|
404
545
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
405
546
|
}
|
|
@@ -409,7 +550,17 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
409
550
|
const result = await this.db.sql.execute(
|
|
410
551
|
`UPDATE ${TABLE} SET status = ?, active_task = ?, owner = NULL, leased_until = 0, log_json = ?, logs_json = ?, log_persistence = ?, updated_at = ${this.nextUpdatedAt()}
|
|
411
552
|
WHERE occurrence_id = ? AND owner = ? AND leased_until > ${clock} AND status IN (?, ?)`,
|
|
412
|
-
[
|
|
553
|
+
[
|
|
554
|
+
log.status,
|
|
555
|
+
log.status === "unknown" ? row.taskId : null,
|
|
556
|
+
JSON.stringify(log),
|
|
557
|
+
JSON.stringify(logs),
|
|
558
|
+
"pending",
|
|
559
|
+
row.occurrenceId,
|
|
560
|
+
row.owner,
|
|
561
|
+
"claimed",
|
|
562
|
+
"running"
|
|
563
|
+
]
|
|
413
564
|
);
|
|
414
565
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
415
566
|
}
|
|
@@ -417,7 +568,12 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
417
568
|
async resolve(id, status, expectedUpdatedAt) {
|
|
418
569
|
const result = await this.db.sql.execute(
|
|
419
570
|
`UPDATE ${TABLE} SET status = ?, active_task = NULL, updated_at = ${this.nextUpdatedAt()} WHERE occurrence_id = ? AND status = ? AND updated_at = ?`,
|
|
420
|
-
[
|
|
571
|
+
[
|
|
572
|
+
status,
|
|
573
|
+
id,
|
|
574
|
+
"unknown",
|
|
575
|
+
expectedUpdatedAt
|
|
576
|
+
]
|
|
421
577
|
);
|
|
422
578
|
return result.success && result.data.changes === 1 ? ok(void 0) : failed();
|
|
423
579
|
}
|
|
@@ -425,23 +581,110 @@ var SchedulerExecutionRepository = class extends BaseReldbCrudRepository {
|
|
|
425
581
|
var logger = core.logger.child({ module: "scheduler", scope: "log-repository" });
|
|
426
582
|
var SCHEDULER_LOG_TABLE = "hai_scheduler_logs";
|
|
427
583
|
var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
584
|
+
ready() {
|
|
585
|
+
return this.ensureSchema();
|
|
586
|
+
}
|
|
428
587
|
constructor(db) {
|
|
429
588
|
super(db, {
|
|
430
589
|
table: SCHEDULER_LOG_TABLE,
|
|
431
590
|
idColumn: "id",
|
|
432
591
|
fields: [
|
|
433
|
-
{
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
{
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
592
|
+
{
|
|
593
|
+
fieldName: "id",
|
|
594
|
+
columnName: "id",
|
|
595
|
+
def: { type: "TEXT", primaryKey: true },
|
|
596
|
+
select: true,
|
|
597
|
+
create: true,
|
|
598
|
+
update: false
|
|
599
|
+
},
|
|
600
|
+
{
|
|
601
|
+
fieldName: "occurrenceId",
|
|
602
|
+
columnName: "occurrence_id",
|
|
603
|
+
def: { type: "TEXT" },
|
|
604
|
+
select: true,
|
|
605
|
+
create: true,
|
|
606
|
+
update: false
|
|
607
|
+
},
|
|
608
|
+
{
|
|
609
|
+
fieldName: "taskId",
|
|
610
|
+
columnName: "task_id",
|
|
611
|
+
def: { type: "TEXT", notNull: true },
|
|
612
|
+
select: true,
|
|
613
|
+
create: true,
|
|
614
|
+
update: false
|
|
615
|
+
},
|
|
616
|
+
{
|
|
617
|
+
fieldName: "taskName",
|
|
618
|
+
columnName: "task_name",
|
|
619
|
+
def: { type: "TEXT", notNull: true },
|
|
620
|
+
select: true,
|
|
621
|
+
create: true,
|
|
622
|
+
update: false
|
|
623
|
+
},
|
|
624
|
+
{
|
|
625
|
+
fieldName: "taskType",
|
|
626
|
+
columnName: "task_type",
|
|
627
|
+
def: { type: "TEXT", notNull: true },
|
|
628
|
+
select: true,
|
|
629
|
+
create: true,
|
|
630
|
+
update: false
|
|
631
|
+
},
|
|
632
|
+
{
|
|
633
|
+
fieldName: "triggerType",
|
|
634
|
+
columnName: "trigger_type",
|
|
635
|
+
def: { type: "TEXT", notNull: true },
|
|
636
|
+
select: true,
|
|
637
|
+
create: true,
|
|
638
|
+
update: false
|
|
639
|
+
},
|
|
640
|
+
{
|
|
641
|
+
fieldName: "triggerSource",
|
|
642
|
+
columnName: "trigger_source",
|
|
643
|
+
def: { type: "TEXT" },
|
|
644
|
+
select: true,
|
|
645
|
+
create: true,
|
|
646
|
+
update: false
|
|
647
|
+
},
|
|
648
|
+
{
|
|
649
|
+
fieldName: "status",
|
|
650
|
+
columnName: "status",
|
|
651
|
+
def: { type: "TEXT", notNull: true },
|
|
652
|
+
select: true,
|
|
653
|
+
create: true,
|
|
654
|
+
update: false
|
|
655
|
+
},
|
|
656
|
+
{
|
|
657
|
+
fieldName: "payload",
|
|
658
|
+
columnName: "payload",
|
|
659
|
+
def: { type: "JSON", notNull: true },
|
|
660
|
+
select: true,
|
|
661
|
+
create: true,
|
|
662
|
+
update: false
|
|
663
|
+
},
|
|
664
|
+
{
|
|
665
|
+
fieldName: "startedAt",
|
|
666
|
+
columnName: "started_at",
|
|
667
|
+
def: { type: "BIGINT", notNull: true },
|
|
668
|
+
select: true,
|
|
669
|
+
create: true,
|
|
670
|
+
update: false
|
|
671
|
+
},
|
|
672
|
+
{
|
|
673
|
+
fieldName: "finishedAt",
|
|
674
|
+
columnName: "finished_at",
|
|
675
|
+
def: { type: "BIGINT", notNull: true },
|
|
676
|
+
select: true,
|
|
677
|
+
create: true,
|
|
678
|
+
update: false
|
|
679
|
+
},
|
|
680
|
+
{
|
|
681
|
+
fieldName: "duration",
|
|
682
|
+
columnName: "duration",
|
|
683
|
+
def: { type: "INTEGER", notNull: true },
|
|
684
|
+
select: true,
|
|
685
|
+
create: true,
|
|
686
|
+
update: false
|
|
687
|
+
}
|
|
445
688
|
]
|
|
446
689
|
});
|
|
447
690
|
}
|
|
@@ -450,7 +693,10 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
450
693
|
* @example `const saved = await repository.saveLog(log); if (!saved.success) return saved`
|
|
451
694
|
*/
|
|
452
695
|
async saveLog(log) {
|
|
453
|
-
const payload = {
|
|
696
|
+
const payload = {
|
|
697
|
+
...log,
|
|
698
|
+
persistence: { status: "persisted" }
|
|
699
|
+
};
|
|
454
700
|
try {
|
|
455
701
|
const created = await this.create({
|
|
456
702
|
id: log.id,
|
|
@@ -517,20 +763,27 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
517
763
|
if (!pageResult.success) {
|
|
518
764
|
return err(
|
|
519
765
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
520
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
766
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
767
|
+
params: { error: pageResult.error.message }
|
|
768
|
+
}),
|
|
521
769
|
pageResult.error
|
|
522
770
|
);
|
|
523
771
|
}
|
|
524
772
|
return ok({
|
|
525
773
|
...pageResult.data,
|
|
526
|
-
items: pageResult.data.items.map((row) => ({
|
|
774
|
+
items: pageResult.data.items.map((row) => ({
|
|
775
|
+
...row.payload,
|
|
776
|
+
persistence: { status: "persisted" }
|
|
777
|
+
}))
|
|
527
778
|
});
|
|
528
779
|
} catch (error) {
|
|
529
780
|
logger.error("Failed to query execution logs", { error });
|
|
530
781
|
return err(
|
|
531
782
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
532
783
|
schedulerM("scheduler_dbSaveFailed", {
|
|
533
|
-
params: {
|
|
784
|
+
params: {
|
|
785
|
+
error: error instanceof Error ? error.message : String(error)
|
|
786
|
+
}
|
|
534
787
|
}),
|
|
535
788
|
error
|
|
536
789
|
);
|
|
@@ -550,7 +803,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
550
803
|
if (!retentionResult.success) {
|
|
551
804
|
return err(
|
|
552
805
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
553
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
806
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
807
|
+
params: { error: retentionResult.error.message }
|
|
808
|
+
}),
|
|
554
809
|
retentionResult.error
|
|
555
810
|
);
|
|
556
811
|
}
|
|
@@ -571,7 +826,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
571
826
|
if (!maxLogsResult.success) {
|
|
572
827
|
return err(
|
|
573
828
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
574
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
829
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
830
|
+
params: { error: maxLogsResult.error.message }
|
|
831
|
+
}),
|
|
575
832
|
maxLogsResult.error
|
|
576
833
|
);
|
|
577
834
|
}
|
|
@@ -582,7 +839,9 @@ var SchedulerLogRepository = class extends BaseReldbCrudRepository {
|
|
|
582
839
|
return err(
|
|
583
840
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
584
841
|
schedulerM("scheduler_dbSaveFailed", {
|
|
585
|
-
params: {
|
|
842
|
+
params: {
|
|
843
|
+
error: error instanceof Error ? error.message : String(error)
|
|
844
|
+
}
|
|
586
845
|
}),
|
|
587
846
|
error
|
|
588
847
|
);
|
|
@@ -599,7 +858,13 @@ var TaskRetryPolicySchema = z.object({
|
|
|
599
858
|
var ApiTaskConfigSchema = z.object({
|
|
600
859
|
kind: z.literal("api"),
|
|
601
860
|
url: z.string().min(1),
|
|
602
|
-
method: z.enum([
|
|
861
|
+
method: z.enum([
|
|
862
|
+
"GET",
|
|
863
|
+
"POST",
|
|
864
|
+
"PUT",
|
|
865
|
+
"DELETE",
|
|
866
|
+
"PATCH"
|
|
867
|
+
]).optional(),
|
|
603
868
|
headers: z.record(z.string(), z.string()).optional(),
|
|
604
869
|
body: z.unknown().optional(),
|
|
605
870
|
timeout: z.number().int().positive().optional(),
|
|
@@ -612,25 +877,126 @@ var JsTaskConfigSchema = z.object({
|
|
|
612
877
|
});
|
|
613
878
|
var TaskHandlerConfigSchema = z.discriminatedUnion("kind", [ApiTaskConfigSchema, JsTaskConfigSchema]);
|
|
614
879
|
var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
880
|
+
ready() {
|
|
881
|
+
return this.ensureSchema();
|
|
882
|
+
}
|
|
615
883
|
constructor(db) {
|
|
616
884
|
super(db, {
|
|
617
885
|
table: SCHEDULER_TASK_TABLE,
|
|
618
886
|
idColumn: "id",
|
|
619
887
|
fields: [
|
|
620
|
-
{
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
{
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
888
|
+
{
|
|
889
|
+
fieldName: "id",
|
|
890
|
+
columnName: "id",
|
|
891
|
+
def: { type: "INTEGER", primaryKey: true, autoIncrement: true },
|
|
892
|
+
select: true,
|
|
893
|
+
create: false,
|
|
894
|
+
update: false
|
|
895
|
+
},
|
|
896
|
+
{
|
|
897
|
+
fieldName: "taskId",
|
|
898
|
+
columnName: "task_id",
|
|
899
|
+
def: { type: "TEXT", notNull: true, unique: true },
|
|
900
|
+
select: true,
|
|
901
|
+
create: true,
|
|
902
|
+
update: false
|
|
903
|
+
},
|
|
904
|
+
{
|
|
905
|
+
fieldName: "taskName",
|
|
906
|
+
columnName: "task_name",
|
|
907
|
+
def: { type: "TEXT", notNull: true },
|
|
908
|
+
select: true,
|
|
909
|
+
create: true,
|
|
910
|
+
update: true
|
|
911
|
+
},
|
|
912
|
+
{
|
|
913
|
+
fieldName: "description",
|
|
914
|
+
columnName: "description",
|
|
915
|
+
def: { type: "TEXT" },
|
|
916
|
+
select: true,
|
|
917
|
+
create: true,
|
|
918
|
+
update: true
|
|
919
|
+
},
|
|
920
|
+
{
|
|
921
|
+
fieldName: "cron",
|
|
922
|
+
columnName: "cron",
|
|
923
|
+
def: { type: "TEXT", notNull: true },
|
|
924
|
+
select: true,
|
|
925
|
+
create: true,
|
|
926
|
+
update: true
|
|
927
|
+
},
|
|
928
|
+
{
|
|
929
|
+
fieldName: "timezone",
|
|
930
|
+
columnName: "timezone",
|
|
931
|
+
def: { type: "TEXT" },
|
|
932
|
+
select: true,
|
|
933
|
+
create: true,
|
|
934
|
+
update: true
|
|
935
|
+
},
|
|
936
|
+
{
|
|
937
|
+
fieldName: "enabled",
|
|
938
|
+
columnName: "enabled",
|
|
939
|
+
def: { type: "BOOLEAN", notNull: true, defaultValue: true },
|
|
940
|
+
select: true,
|
|
941
|
+
create: true,
|
|
942
|
+
update: true
|
|
943
|
+
},
|
|
944
|
+
{
|
|
945
|
+
fieldName: "idempotent",
|
|
946
|
+
columnName: "idempotent",
|
|
947
|
+
def: { type: "BOOLEAN", notNull: true, defaultValue: false },
|
|
948
|
+
select: true,
|
|
949
|
+
create: true,
|
|
950
|
+
update: true
|
|
951
|
+
},
|
|
952
|
+
{
|
|
953
|
+
fieldName: "deleteAfterRun",
|
|
954
|
+
columnName: "delete_after_run",
|
|
955
|
+
def: { type: "BOOLEAN", notNull: true, defaultValue: false },
|
|
956
|
+
select: true,
|
|
957
|
+
create: true,
|
|
958
|
+
update: true
|
|
959
|
+
},
|
|
960
|
+
{
|
|
961
|
+
fieldName: "retry",
|
|
962
|
+
columnName: "retry",
|
|
963
|
+
def: { type: "JSON" },
|
|
964
|
+
select: true,
|
|
965
|
+
create: true,
|
|
966
|
+
update: true
|
|
967
|
+
},
|
|
968
|
+
{
|
|
969
|
+
fieldName: "params",
|
|
970
|
+
columnName: "params",
|
|
971
|
+
def: { type: "JSON" },
|
|
972
|
+
select: true,
|
|
973
|
+
create: true,
|
|
974
|
+
update: true
|
|
975
|
+
},
|
|
976
|
+
{
|
|
977
|
+
fieldName: "handler",
|
|
978
|
+
columnName: "handler",
|
|
979
|
+
def: { type: "JSON" },
|
|
980
|
+
select: true,
|
|
981
|
+
create: true,
|
|
982
|
+
update: true
|
|
983
|
+
},
|
|
984
|
+
{
|
|
985
|
+
fieldName: "createdAt",
|
|
986
|
+
columnName: "created_at",
|
|
987
|
+
def: { type: "TIMESTAMP" },
|
|
988
|
+
select: true,
|
|
989
|
+
create: true,
|
|
990
|
+
update: false
|
|
991
|
+
},
|
|
992
|
+
{
|
|
993
|
+
fieldName: "updatedAt",
|
|
994
|
+
columnName: "updated_at",
|
|
995
|
+
def: { type: "TIMESTAMP" },
|
|
996
|
+
select: true,
|
|
997
|
+
create: false,
|
|
998
|
+
update: true
|
|
999
|
+
}
|
|
634
1000
|
]
|
|
635
1001
|
});
|
|
636
1002
|
}
|
|
@@ -651,10 +1017,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
651
1017
|
createdAt: /* @__PURE__ */ new Date()
|
|
652
1018
|
});
|
|
653
1019
|
if (!createResult.success) {
|
|
654
|
-
logger2.error("Failed to save task definition", { taskId: task.id, error: createResult.error.
|
|
1020
|
+
logger2.error("Failed to save task definition", { taskId: task.id, errorCode: createResult.error.code, traceId: createResult.error.traceId });
|
|
655
1021
|
return err(
|
|
656
1022
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
657
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1023
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1024
|
+
params: { error: createResult.error.message }
|
|
1025
|
+
}),
|
|
658
1026
|
createResult.error
|
|
659
1027
|
);
|
|
660
1028
|
}
|
|
@@ -664,7 +1032,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
664
1032
|
return err(
|
|
665
1033
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
666
1034
|
schedulerM("scheduler_dbSaveFailed", {
|
|
667
|
-
params: {
|
|
1035
|
+
params: {
|
|
1036
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1037
|
+
}
|
|
668
1038
|
}),
|
|
669
1039
|
error
|
|
670
1040
|
);
|
|
@@ -672,11 +1042,18 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
672
1042
|
}
|
|
673
1043
|
async updateTask(taskId, updates) {
|
|
674
1044
|
try {
|
|
675
|
-
const rows = await this.findAll({
|
|
1045
|
+
const rows = await this.findAll({
|
|
1046
|
+
where: "task_id = ?",
|
|
1047
|
+
params: [taskId],
|
|
1048
|
+
limit: 1
|
|
1049
|
+
});
|
|
676
1050
|
if (!rows.success) {
|
|
1051
|
+
logger2.error("Failed to load task definition for update", { taskId, errorCode: rows.error.code, traceId: rows.error.traceId });
|
|
677
1052
|
return err(
|
|
678
1053
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
679
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1054
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1055
|
+
params: { error: rows.error.message }
|
|
1056
|
+
}),
|
|
680
1057
|
rows.error
|
|
681
1058
|
);
|
|
682
1059
|
}
|
|
@@ -708,10 +1085,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
708
1085
|
return ok(void 0);
|
|
709
1086
|
const updateResult = await this.updateById(rows.data[0].id, data);
|
|
710
1087
|
if (!updateResult.success) {
|
|
711
|
-
logger2.error("Failed to update task definition", { taskId, error: updateResult.error.
|
|
1088
|
+
logger2.error("Failed to update task definition", { taskId, errorCode: updateResult.error.code, traceId: updateResult.error.traceId });
|
|
712
1089
|
return err(
|
|
713
1090
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
714
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1091
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1092
|
+
params: { error: updateResult.error.message }
|
|
1093
|
+
}),
|
|
715
1094
|
updateResult.error
|
|
716
1095
|
);
|
|
717
1096
|
}
|
|
@@ -721,7 +1100,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
721
1100
|
return err(
|
|
722
1101
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
723
1102
|
schedulerM("scheduler_dbSaveFailed", {
|
|
724
|
-
params: {
|
|
1103
|
+
params: {
|
|
1104
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1105
|
+
}
|
|
725
1106
|
}),
|
|
726
1107
|
error
|
|
727
1108
|
);
|
|
@@ -731,13 +1112,35 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
731
1112
|
async deleteTask(taskId, expected) {
|
|
732
1113
|
try {
|
|
733
1114
|
if (expected) {
|
|
734
|
-
const conditions = [
|
|
1115
|
+
const conditions = [
|
|
1116
|
+
"task_id = ?",
|
|
1117
|
+
"task_name = ?",
|
|
1118
|
+
"cron = ?",
|
|
1119
|
+
"COALESCE(timezone, '') = ?",
|
|
1120
|
+
"COALESCE(description, '') = ?",
|
|
1121
|
+
"enabled = ?",
|
|
1122
|
+
"delete_after_run = ?",
|
|
1123
|
+
"idempotent = ?"
|
|
1124
|
+
];
|
|
735
1125
|
const postgres = this.db.config?.type === "postgresql";
|
|
736
1126
|
const enabled = expected.enabled !== false;
|
|
737
1127
|
const deleteAfterRun = expected.deleteAfterRun === true;
|
|
738
|
-
const params = [
|
|
1128
|
+
const params = [
|
|
1129
|
+
taskId,
|
|
1130
|
+
expected.name,
|
|
1131
|
+
expected.cron,
|
|
1132
|
+
expected.timezone ?? "",
|
|
1133
|
+
expected.description ?? "",
|
|
1134
|
+
postgres ? enabled : Number(enabled),
|
|
1135
|
+
postgres ? deleteAfterRun : Number(deleteAfterRun),
|
|
1136
|
+
postgres ? expected.idempotent === true : Number(expected.idempotent === true)
|
|
1137
|
+
];
|
|
739
1138
|
const jsonValue = this.db.config?.type === "mysql" ? "CAST(? AS JSON)" : this.db.config?.type === "postgresql" ? "CAST(? AS JSONB)" : "?";
|
|
740
|
-
const jsonFields = [
|
|
1139
|
+
const jsonFields = [
|
|
1140
|
+
["retry", expected.retry],
|
|
1141
|
+
["params", expected.params ?? {}],
|
|
1142
|
+
["handler", expected.handler]
|
|
1143
|
+
];
|
|
741
1144
|
for (const [column, value] of jsonFields) {
|
|
742
1145
|
if (value === void 0 || value === null) {
|
|
743
1146
|
conditions.push(`(${column} IS NULL OR ${column} = ${jsonValue})`);
|
|
@@ -748,13 +1151,24 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
748
1151
|
}
|
|
749
1152
|
}
|
|
750
1153
|
const deleted = await this.db.sql.execute(`DELETE FROM ${SCHEDULER_TASK_TABLE} WHERE ${conditions.join(" AND ")}`, params);
|
|
751
|
-
|
|
1154
|
+
if (!deleted.success) {
|
|
1155
|
+
logger2.error("Failed to delete task definition", { taskId, errorCode: deleted.error.code, traceId: deleted.error.traceId });
|
|
1156
|
+
return deleted;
|
|
1157
|
+
}
|
|
1158
|
+
return ok(deleted.data.changes > 0);
|
|
752
1159
|
}
|
|
753
|
-
const rows = await this.findAll({
|
|
1160
|
+
const rows = await this.findAll({
|
|
1161
|
+
where: "task_id = ?",
|
|
1162
|
+
params: [taskId],
|
|
1163
|
+
limit: 1
|
|
1164
|
+
});
|
|
754
1165
|
if (!rows.success) {
|
|
1166
|
+
logger2.error("Failed to load task definition for deletion", { taskId, errorCode: rows.error.code, traceId: rows.error.traceId });
|
|
755
1167
|
return err(
|
|
756
1168
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
757
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1169
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1170
|
+
params: { error: rows.error.message }
|
|
1171
|
+
}),
|
|
758
1172
|
rows.error
|
|
759
1173
|
);
|
|
760
1174
|
}
|
|
@@ -762,10 +1176,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
762
1176
|
return ok(false);
|
|
763
1177
|
const deleteResult = await this.deleteById(rows.data[0].id);
|
|
764
1178
|
if (!deleteResult.success) {
|
|
765
|
-
logger2.error("Failed to delete task definition", { taskId, error: deleteResult.error.
|
|
1179
|
+
logger2.error("Failed to delete task definition", { taskId, errorCode: deleteResult.error.code, traceId: deleteResult.error.traceId });
|
|
766
1180
|
return err(
|
|
767
1181
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
768
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1182
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1183
|
+
params: { error: deleteResult.error.message }
|
|
1184
|
+
}),
|
|
769
1185
|
deleteResult.error
|
|
770
1186
|
);
|
|
771
1187
|
}
|
|
@@ -775,7 +1191,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
775
1191
|
return err(
|
|
776
1192
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
777
1193
|
schedulerM("scheduler_dbSaveFailed", {
|
|
778
|
-
params: {
|
|
1194
|
+
params: {
|
|
1195
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1196
|
+
}
|
|
779
1197
|
}),
|
|
780
1198
|
error
|
|
781
1199
|
);
|
|
@@ -785,9 +1203,12 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
785
1203
|
try {
|
|
786
1204
|
const rows = await this.findAll({ orderBy: "id ASC" });
|
|
787
1205
|
if (!rows.success) {
|
|
1206
|
+
logger2.error("Failed to load task definitions", { errorCode: rows.error.code, traceId: rows.error.traceId });
|
|
788
1207
|
return err(
|
|
789
1208
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
790
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1209
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1210
|
+
params: { error: rows.error.message }
|
|
1211
|
+
}),
|
|
791
1212
|
rows.error
|
|
792
1213
|
);
|
|
793
1214
|
}
|
|
@@ -795,15 +1216,21 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
795
1216
|
for (const row of rows.data) {
|
|
796
1217
|
const paramsResult = TaskParamsSchema.safeParse(row.params ?? {});
|
|
797
1218
|
if (!paramsResult.success) {
|
|
798
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1219
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1220
|
+
params: { taskId: row.taskId, error: paramsResult.error.message }
|
|
1221
|
+
}));
|
|
799
1222
|
}
|
|
800
1223
|
const handlerResult = row.handler == null ? { success: true, data: void 0 } : TaskHandlerConfigSchema.safeParse(row.handler);
|
|
801
1224
|
if (!handlerResult.success) {
|
|
802
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1225
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1226
|
+
params: { taskId: row.taskId, error: handlerResult.error.message }
|
|
1227
|
+
}));
|
|
803
1228
|
}
|
|
804
1229
|
const retryResult = row.retry == null ? { success: true, data: void 0 } : TaskRetryPolicySchema.safeParse(row.retry);
|
|
805
1230
|
if (!retryResult.success) {
|
|
806
|
-
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1231
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", {
|
|
1232
|
+
params: { taskId: row.taskId, error: retryResult.error.message }
|
|
1233
|
+
}));
|
|
807
1234
|
}
|
|
808
1235
|
tasks.push({
|
|
809
1236
|
id: row.taskId,
|
|
@@ -825,7 +1252,9 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
|
|
|
825
1252
|
return err(
|
|
826
1253
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
827
1254
|
schedulerM("scheduler_dbSaveFailed", {
|
|
828
|
-
params: {
|
|
1255
|
+
params: {
|
|
1256
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1257
|
+
}
|
|
829
1258
|
}),
|
|
830
1259
|
error
|
|
831
1260
|
);
|
|
@@ -839,13 +1268,14 @@ function parseCronExpression(expression, timezone) {
|
|
|
839
1268
|
} catch {
|
|
840
1269
|
return err(
|
|
841
1270
|
HaiSchedulerError.INVALID_CRON,
|
|
842
|
-
schedulerM("scheduler_invalidCron", {
|
|
1271
|
+
schedulerM("scheduler_invalidCron", {
|
|
1272
|
+
params: { expression }
|
|
1273
|
+
})
|
|
843
1274
|
);
|
|
844
1275
|
}
|
|
845
1276
|
}
|
|
846
1277
|
|
|
847
1278
|
// src/scheduler-functions.ts
|
|
848
|
-
var logger3 = core.logger.child({ module: "scheduler", scope: "functions" });
|
|
849
1279
|
var taskRegistry = /* @__PURE__ */ new Map();
|
|
850
1280
|
var cronCache = /* @__PURE__ */ new Map();
|
|
851
1281
|
var persistedTaskIds = /* @__PURE__ */ new Set();
|
|
@@ -918,7 +1348,9 @@ function validateRetryPolicy(taskId, retry) {
|
|
|
918
1348
|
if (!Number.isInteger(retry.maxAttempts) || retry.maxAttempts < 1 || retry.maxAttempts > 100) {
|
|
919
1349
|
return err(
|
|
920
1350
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
921
|
-
schedulerM("scheduler_invalidRetryConfig", {
|
|
1351
|
+
schedulerM("scheduler_invalidRetryConfig", {
|
|
1352
|
+
params: { taskId }
|
|
1353
|
+
})
|
|
922
1354
|
);
|
|
923
1355
|
}
|
|
924
1356
|
if (retry.backoffMs !== void 0) {
|
|
@@ -926,13 +1358,17 @@ function validateRetryPolicy(taskId, retry) {
|
|
|
926
1358
|
if (hasInvalidBackoff) {
|
|
927
1359
|
return err(
|
|
928
1360
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
929
|
-
schedulerM("scheduler_invalidRetryConfig", {
|
|
1361
|
+
schedulerM("scheduler_invalidRetryConfig", {
|
|
1362
|
+
params: { taskId }
|
|
1363
|
+
})
|
|
930
1364
|
);
|
|
931
1365
|
}
|
|
932
1366
|
}
|
|
933
1367
|
return ok({
|
|
934
1368
|
maxAttempts: retry.maxAttempts,
|
|
935
|
-
...retry.backoffMs ? {
|
|
1369
|
+
...retry.backoffMs ? {
|
|
1370
|
+
backoffMs: [...retry.backoffMs]
|
|
1371
|
+
} : {}
|
|
936
1372
|
});
|
|
937
1373
|
}
|
|
938
1374
|
async function loadPersistedTasks(taskRepo2) {
|
|
@@ -955,7 +1391,10 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
|
|
|
955
1391
|
});
|
|
956
1392
|
let loadResult;
|
|
957
1393
|
try {
|
|
958
|
-
loadResult = await Promise.race([
|
|
1394
|
+
loadResult = await Promise.race([
|
|
1395
|
+
taskRepo2.loadTasks(),
|
|
1396
|
+
cancelled
|
|
1397
|
+
]);
|
|
959
1398
|
} finally {
|
|
960
1399
|
signal.removeEventListener("abort", cancel);
|
|
961
1400
|
}
|
|
@@ -970,8 +1409,11 @@ async function refreshPersistedTasks(taskRepo2, epoch, signal) {
|
|
|
970
1409
|
for (const task of loadResult.data) {
|
|
971
1410
|
if (!task.id)
|
|
972
1411
|
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_taskIdEmpty"));
|
|
973
|
-
if (nextTasks.has(task.id))
|
|
974
|
-
return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", {
|
|
1412
|
+
if (nextTasks.has(task.id)) {
|
|
1413
|
+
return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", {
|
|
1414
|
+
params: { taskId: task.id }
|
|
1415
|
+
}));
|
|
1416
|
+
}
|
|
975
1417
|
const cronResult = parseCronExpression(task.cron, task.timezone);
|
|
976
1418
|
if (!cronResult.success)
|
|
977
1419
|
return cronResult;
|
|
@@ -1010,7 +1452,9 @@ async function registerTask(task, taskRepo2) {
|
|
|
1010
1452
|
}
|
|
1011
1453
|
async function registerTaskDefinition(task, taskRepo2) {
|
|
1012
1454
|
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", {
|
|
1455
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1456
|
+
params: { taskId: task.id }
|
|
1457
|
+
}));
|
|
1014
1458
|
}
|
|
1015
1459
|
if (!task.id) {
|
|
1016
1460
|
return err(
|
|
@@ -1021,7 +1465,9 @@ async function registerTaskDefinition(task, taskRepo2) {
|
|
|
1021
1465
|
if (hasTask(task.id)) {
|
|
1022
1466
|
return err(
|
|
1023
1467
|
HaiSchedulerError.TASK_ALREADY_EXISTS,
|
|
1024
|
-
schedulerM("scheduler_taskAlreadyExists", {
|
|
1468
|
+
schedulerM("scheduler_taskAlreadyExists", {
|
|
1469
|
+
params: { taskId: task.id }
|
|
1470
|
+
})
|
|
1025
1471
|
);
|
|
1026
1472
|
}
|
|
1027
1473
|
const cronResult = parseCronExpression(task.cron, task.timezone);
|
|
@@ -1043,10 +1489,11 @@ async function registerTaskDefinition(task, taskRepo2) {
|
|
|
1043
1489
|
if (taskRepo2) {
|
|
1044
1490
|
const saveResult = await taskRepo2.saveTask(normalizedTask);
|
|
1045
1491
|
if (!saveResult.success) {
|
|
1046
|
-
logger3.warn("Failed to persist task definition", { taskId: task.id, error: saveResult.error.message });
|
|
1047
1492
|
return err(
|
|
1048
1493
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1049
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1494
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1495
|
+
params: { error: saveResult.error.message }
|
|
1496
|
+
}),
|
|
1050
1497
|
saveResult.error
|
|
1051
1498
|
);
|
|
1052
1499
|
}
|
|
@@ -1070,16 +1517,19 @@ async function unregisterTaskDefinition(taskId, taskRepo2, expected) {
|
|
|
1070
1517
|
if (!hasTask(taskId)) {
|
|
1071
1518
|
return err(
|
|
1072
1519
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
1073
|
-
schedulerM("scheduler_taskNotFound", {
|
|
1520
|
+
schedulerM("scheduler_taskNotFound", {
|
|
1521
|
+
params: { taskId }
|
|
1522
|
+
})
|
|
1074
1523
|
);
|
|
1075
1524
|
}
|
|
1076
1525
|
if (taskRepo2) {
|
|
1077
1526
|
const deleteResult = await taskRepo2.deleteTask(taskId, expected);
|
|
1078
1527
|
if (!deleteResult.success) {
|
|
1079
|
-
logger3.warn("Failed to delete persisted task definition", { taskId, error: deleteResult.error.message });
|
|
1080
1528
|
return err(
|
|
1081
1529
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1082
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1530
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1531
|
+
params: { error: deleteResult.error.message }
|
|
1532
|
+
}),
|
|
1083
1533
|
deleteResult.error
|
|
1084
1534
|
);
|
|
1085
1535
|
}
|
|
@@ -1106,7 +1556,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1106
1556
|
if (!existingTask) {
|
|
1107
1557
|
return err(
|
|
1108
1558
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
1109
|
-
schedulerM("scheduler_taskNotFound", {
|
|
1559
|
+
schedulerM("scheduler_taskNotFound", {
|
|
1560
|
+
params: { taskId }
|
|
1561
|
+
})
|
|
1110
1562
|
);
|
|
1111
1563
|
}
|
|
1112
1564
|
let updatedCron = getCron(taskId);
|
|
@@ -1136,7 +1588,9 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1136
1588
|
...updates.retry !== void 0 ? { retry: normalizedRetry } : {}
|
|
1137
1589
|
};
|
|
1138
1590
|
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", {
|
|
1591
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1592
|
+
params: { taskId }
|
|
1593
|
+
}));
|
|
1140
1594
|
}
|
|
1141
1595
|
const updatedTask = {
|
|
1142
1596
|
...existingTask,
|
|
@@ -1154,10 +1608,11 @@ async function updateTaskDefinition(taskId, updates, taskRepo2) {
|
|
|
1154
1608
|
if (taskRepo2) {
|
|
1155
1609
|
const updateResult = await taskRepo2.updateTask(taskId, normalizedUpdates);
|
|
1156
1610
|
if (!updateResult.success) {
|
|
1157
|
-
logger3.warn("Failed to update persisted task definition", { taskId, error: updateResult.error.message });
|
|
1158
1611
|
return err(
|
|
1159
1612
|
HaiSchedulerError.DB_SAVE_FAILED,
|
|
1160
|
-
schedulerM("scheduler_dbSaveFailed", {
|
|
1613
|
+
schedulerM("scheduler_dbSaveFailed", {
|
|
1614
|
+
params: { error: updateResult.error.message }
|
|
1615
|
+
}),
|
|
1161
1616
|
updateResult.error
|
|
1162
1617
|
);
|
|
1163
1618
|
}
|
|
@@ -1210,7 +1665,9 @@ function compileJsTaskHandler(config) {
|
|
|
1210
1665
|
signal?.removeEventListener("abort", aborted);
|
|
1211
1666
|
void worker.terminate().then(() => error ? reject(error) : resolve(result), reject);
|
|
1212
1667
|
}
|
|
1213
|
-
timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
|
|
1668
|
+
timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
|
|
1669
|
+
params: { timeout }
|
|
1670
|
+
}))), timeout);
|
|
1214
1671
|
signal?.addEventListener("abort", aborted, { once: true });
|
|
1215
1672
|
worker.once("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
|
|
1216
1673
|
worker.once("exit", (code) => finish(new Error(`JS worker exited before returning a result (${code})`)));
|
|
@@ -1228,85 +1685,14 @@ function compileJsTaskHandler(config) {
|
|
|
1228
1685
|
return err(
|
|
1229
1686
|
HaiSchedulerError.JS_COMPILE_FAILED,
|
|
1230
1687
|
schedulerM("scheduler_jsCompileFailed", {
|
|
1231
|
-
params: {
|
|
1688
|
+
params: {
|
|
1689
|
+
error: error instanceof Error ? error.message : String(error)
|
|
1690
|
+
}
|
|
1232
1691
|
}),
|
|
1233
1692
|
error
|
|
1234
1693
|
);
|
|
1235
1694
|
}
|
|
1236
1695
|
}
|
|
1237
|
-
function migrateScheduler(options = {}) {
|
|
1238
|
-
const steps = [{
|
|
1239
|
-
version: 1,
|
|
1240
|
-
name: "explicit-task-idempotency",
|
|
1241
|
-
async needed(sql) {
|
|
1242
|
-
const columns = await schemaColumns(reldb, "hai_scheduler_tasks", sql);
|
|
1243
|
-
return columns.success ? ok(columns.data.length > 0 && !columns.data.includes("idempotent")) : columns;
|
|
1244
|
-
},
|
|
1245
|
-
async apply(sql) {
|
|
1246
|
-
return sql.execute("ALTER TABLE hai_scheduler_tasks ADD COLUMN idempotent BOOLEAN NOT NULL DEFAULT FALSE");
|
|
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;
|
|
1267
|
-
},
|
|
1268
|
-
async apply(sql) {
|
|
1269
|
-
const columns = await schemaColumns(reldb, "hai_scheduler_logs", sql);
|
|
1270
|
-
if (!columns.success)
|
|
1271
|
-
return columns;
|
|
1272
|
-
if (columns.data.length && !columns.data.includes("payload")) {
|
|
1273
|
-
const archive = await schemaColumns(reldb, "hai_scheduler_logs_alpha65", sql);
|
|
1274
|
-
if (!archive.success)
|
|
1275
|
-
return archive;
|
|
1276
|
-
if (archive.data.length)
|
|
1277
|
-
return err(HaiCommonError.INIT_FAILED, "Scheduler archive already exists");
|
|
1278
|
-
const renamed = await sql.execute("ALTER TABLE hai_scheduler_logs RENAME TO hai_scheduler_logs_alpha65");
|
|
1279
|
-
if (!renamed.success)
|
|
1280
|
-
return renamed;
|
|
1281
|
-
}
|
|
1282
|
-
const text = reldb.config?.type === "mysql" ? "VARCHAR(255)" : "TEXT";
|
|
1283
|
-
const json = reldb.config?.type === "postgresql" ? "JSONB" : reldb.config?.type === "mysql" ? "JSON" : "TEXT";
|
|
1284
|
-
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))`);
|
|
1285
|
-
if (!created.success)
|
|
1286
|
-
return created;
|
|
1287
|
-
for (let offset = 0; ; offset += 100) {
|
|
1288
|
-
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]);
|
|
1289
|
-
if (!rows.success)
|
|
1290
|
-
return rows;
|
|
1291
|
-
for (const row of rows.data) {
|
|
1292
|
-
const id = `legacy:${row.id}`;
|
|
1293
|
-
const existing = await sql.get("SELECT id FROM hai_scheduler_logs WHERE id=?", [id]);
|
|
1294
|
-
if (!existing.success)
|
|
1295
|
-
return existing;
|
|
1296
|
-
if (existing.data)
|
|
1297
|
-
continue;
|
|
1298
|
-
const payload = { id, taskId: row.task_id, taskName: row.task_name, taskType: row.task_type, triggerType: row.trigger_type, triggerSource: row.trigger_source, status: row.status, result: row.result, error: row.error, startedAt: Number(row.started_at), finishedAt: Number(row.finished_at), duration: Number(row.duration), persistence: { status: "persisted" } };
|
|
1299
|
-
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(?,?,?,?,?,?,?,?,?,?,?)", [id, row.task_id, row.task_name, row.task_type, row.trigger_type, row.trigger_source, row.status, JSON.stringify(payload), row.started_at, row.finished_at, row.duration]);
|
|
1300
|
-
if (!copied.success)
|
|
1301
|
-
return copied;
|
|
1302
|
-
}
|
|
1303
|
-
if (rows.data.length < 100)
|
|
1304
|
-
return ok(void 0);
|
|
1305
|
-
}
|
|
1306
|
-
}
|
|
1307
|
-
}];
|
|
1308
|
-
return migrateSchema(reldb, "scheduler", steps, options);
|
|
1309
|
-
}
|
|
1310
1696
|
|
|
1311
1697
|
// src/scheduler-cancellation.ts
|
|
1312
1698
|
async function waitWithSignal(operation, signal) {
|
|
@@ -1321,7 +1707,7 @@ async function waitWithSignal(operation, signal) {
|
|
|
1321
1707
|
}
|
|
1322
1708
|
|
|
1323
1709
|
// src/scheduler-executor.ts
|
|
1324
|
-
var
|
|
1710
|
+
var logger3 = core.logger.child({ module: "scheduler", scope: "executor" });
|
|
1325
1711
|
function resolveTaskType(task, hooks) {
|
|
1326
1712
|
if (task.handler)
|
|
1327
1713
|
return task.handler.kind;
|
|
@@ -1344,7 +1730,7 @@ async function notifyTaskStart(hooks, event) {
|
|
|
1344
1730
|
try {
|
|
1345
1731
|
await waitWithSignal(() => hooks.onTaskStart(event), event.signal);
|
|
1346
1732
|
} catch (error) {
|
|
1347
|
-
|
|
1733
|
+
logger3.warn("Task start hook failed", { taskId: event.task.id, error });
|
|
1348
1734
|
}
|
|
1349
1735
|
}
|
|
1350
1736
|
async function notifyTaskInterrupted(hooks, event) {
|
|
@@ -1353,7 +1739,7 @@ async function notifyTaskInterrupted(hooks, event) {
|
|
|
1353
1739
|
try {
|
|
1354
1740
|
await waitWithSignal(() => hooks.onTaskInterrupted(event), event.signal);
|
|
1355
1741
|
} catch (error) {
|
|
1356
|
-
|
|
1742
|
+
logger3.warn("Task interrupted hook failed", { taskId: event.task.id, error });
|
|
1357
1743
|
}
|
|
1358
1744
|
}
|
|
1359
1745
|
async function notifyTaskFinish(hooks, event) {
|
|
@@ -1362,7 +1748,7 @@ async function notifyTaskFinish(hooks, event) {
|
|
|
1362
1748
|
try {
|
|
1363
1749
|
await waitWithSignal(() => hooks.onTaskFinish(event), event.signal);
|
|
1364
1750
|
} catch (error) {
|
|
1365
|
-
|
|
1751
|
+
logger3.warn("Task finish hook failed", { taskId: event.task.id, error });
|
|
1366
1752
|
}
|
|
1367
1753
|
}
|
|
1368
1754
|
function createExecutionLog(task, trigger, taskType, status, startedAt, finishedAt, result, error, occurrenceId) {
|
|
@@ -1408,7 +1794,9 @@ async function executeJsTask(task, context, signal = new AbortController().signa
|
|
|
1408
1794
|
if (!handler || handler.kind !== "js") {
|
|
1409
1795
|
return err(
|
|
1410
1796
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1411
|
-
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1797
|
+
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1798
|
+
params: { taskId: task.id }
|
|
1799
|
+
})
|
|
1412
1800
|
);
|
|
1413
1801
|
}
|
|
1414
1802
|
const compileResult = compileJsTaskHandler(handler);
|
|
@@ -1419,10 +1807,12 @@ async function executeJsTask(task, context, signal = new AbortController().signa
|
|
|
1419
1807
|
return ok(result !== void 0 ? JSON.stringify(result) : null);
|
|
1420
1808
|
} catch (error) {
|
|
1421
1809
|
const message = error instanceof Error ? error.message : String(error);
|
|
1422
|
-
|
|
1810
|
+
logger3.error("JS task execution failed", { taskId: task.id, error: message });
|
|
1423
1811
|
return err(
|
|
1424
1812
|
HaiSchedulerError.JS_EXECUTION_FAILED,
|
|
1425
|
-
schedulerM("scheduler_jsExecutionFailed", {
|
|
1813
|
+
schedulerM("scheduler_jsExecutionFailed", {
|
|
1814
|
+
params: { error: message }
|
|
1815
|
+
}),
|
|
1426
1816
|
error
|
|
1427
1817
|
);
|
|
1428
1818
|
}
|
|
@@ -1432,12 +1822,17 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1432
1822
|
if (!handler || handler.kind !== "api") {
|
|
1433
1823
|
return err(
|
|
1434
1824
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1435
|
-
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1825
|
+
schedulerM("scheduler_invalidHandlerConfig", {
|
|
1826
|
+
params: { taskId: task.id }
|
|
1827
|
+
})
|
|
1436
1828
|
);
|
|
1437
1829
|
}
|
|
1438
1830
|
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", {
|
|
1831
|
+
if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0) {
|
|
1832
|
+
return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", {
|
|
1833
|
+
params: { taskId: task.id }
|
|
1834
|
+
}));
|
|
1835
|
+
}
|
|
1441
1836
|
const controller = new AbortController();
|
|
1442
1837
|
const timer = setTimeout(() => controller.abort(), timeout);
|
|
1443
1838
|
try {
|
|
@@ -1454,7 +1849,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1454
1849
|
method,
|
|
1455
1850
|
headers: requestHeaders,
|
|
1456
1851
|
signal: AbortSignal.any([signal, controller.signal]),
|
|
1457
|
-
...body !== void 0 ? {
|
|
1852
|
+
...body !== void 0 ? {
|
|
1853
|
+
body: JSON.stringify(body)
|
|
1854
|
+
} : {}
|
|
1458
1855
|
});
|
|
1459
1856
|
let receivedBytes = 0;
|
|
1460
1857
|
let responseText = "";
|
|
@@ -1469,7 +1866,9 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1469
1866
|
receivedBytes += chunk.value.byteLength;
|
|
1470
1867
|
if (receivedBytes > maxResponseBytes) {
|
|
1471
1868
|
controller.abort();
|
|
1472
|
-
return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
|
|
1869
|
+
return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", {
|
|
1870
|
+
params: { maxResponseBytes }
|
|
1871
|
+
}));
|
|
1473
1872
|
}
|
|
1474
1873
|
responseText += decoder.decode(chunk.value, { stream: true });
|
|
1475
1874
|
}
|
|
@@ -1479,7 +1878,7 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1479
1878
|
}
|
|
1480
1879
|
}
|
|
1481
1880
|
if (!response.ok) {
|
|
1482
|
-
|
|
1881
|
+
logger3.error("API task returned non-OK status", {
|
|
1483
1882
|
taskId: context.taskId,
|
|
1484
1883
|
status: response.status,
|
|
1485
1884
|
url: core.sanitize.sanitizeUrl(url)
|
|
@@ -1494,10 +1893,16 @@ async function executeApiTask(task, context, signal = new AbortController().sign
|
|
|
1494
1893
|
return ok(responseText || null);
|
|
1495
1894
|
} catch (error) {
|
|
1496
1895
|
const message = error instanceof Error ? error.message : String(error);
|
|
1497
|
-
|
|
1896
|
+
logger3.error("API task execution failed", {
|
|
1897
|
+
taskId: context.taskId,
|
|
1898
|
+
error: message,
|
|
1899
|
+
url: core.sanitize.sanitizeUrl(url)
|
|
1900
|
+
});
|
|
1498
1901
|
return err(
|
|
1499
1902
|
HaiSchedulerError.API_EXECUTION_FAILED,
|
|
1500
|
-
schedulerM("scheduler_apiExecutionFailed", {
|
|
1903
|
+
schedulerM("scheduler_apiExecutionFailed", {
|
|
1904
|
+
params: { error: message }
|
|
1905
|
+
}),
|
|
1501
1906
|
error
|
|
1502
1907
|
);
|
|
1503
1908
|
} finally {
|
|
@@ -1508,7 +1913,9 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
|
|
|
1508
1913
|
if (!hooks.onTaskExecute) {
|
|
1509
1914
|
return err(
|
|
1510
1915
|
HaiSchedulerError.EXECUTION_FAILED,
|
|
1511
|
-
schedulerM("scheduler_taskHandlerMissing", {
|
|
1916
|
+
schedulerM("scheduler_taskHandlerMissing", {
|
|
1917
|
+
params: { taskId: task.id }
|
|
1918
|
+
})
|
|
1512
1919
|
);
|
|
1513
1920
|
}
|
|
1514
1921
|
const executeEvent = {
|
|
@@ -1523,10 +1930,12 @@ async function executeHookTask(task, context, hooks, startedAt, signal) {
|
|
|
1523
1930
|
return ok(result !== void 0 ? JSON.stringify(result) : null);
|
|
1524
1931
|
} catch (error) {
|
|
1525
1932
|
const message = error instanceof Error ? error.message : String(error);
|
|
1526
|
-
|
|
1933
|
+
logger3.error("Task execute hook failed", { taskId: task.id, error: message });
|
|
1527
1934
|
return err(
|
|
1528
1935
|
HaiSchedulerError.HOOK_EXECUTION_FAILED,
|
|
1529
|
-
schedulerM("scheduler_hookExecutionFailed", {
|
|
1936
|
+
schedulerM("scheduler_hookExecutionFailed", {
|
|
1937
|
+
params: { error: message }
|
|
1938
|
+
}),
|
|
1530
1939
|
error
|
|
1531
1940
|
);
|
|
1532
1941
|
}
|
|
@@ -1535,7 +1944,13 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
|
|
|
1535
1944
|
const startedAt = Date.now();
|
|
1536
1945
|
const taskType = resolveTaskType(task, hooks);
|
|
1537
1946
|
const context = createTaskContext(task, trigger, execution);
|
|
1538
|
-
await notifyTaskStart(hooks, {
|
|
1947
|
+
await notifyTaskStart(hooks, {
|
|
1948
|
+
task,
|
|
1949
|
+
trigger,
|
|
1950
|
+
startedAt,
|
|
1951
|
+
signal,
|
|
1952
|
+
context
|
|
1953
|
+
});
|
|
1539
1954
|
let executionResult;
|
|
1540
1955
|
let shouldNotifyInterrupted = false;
|
|
1541
1956
|
if (signal.aborted) {
|
|
@@ -1576,13 +1991,22 @@ async function executeTask(task, trigger, hooks, signal = new AbortController().
|
|
|
1576
1991
|
context
|
|
1577
1992
|
});
|
|
1578
1993
|
}
|
|
1579
|
-
if (status !== "interrupted" && !signal.aborted)
|
|
1580
|
-
await notifyTaskFinish(hooks, {
|
|
1994
|
+
if (status !== "interrupted" && !signal.aborted) {
|
|
1995
|
+
await notifyTaskFinish(hooks, {
|
|
1996
|
+
task,
|
|
1997
|
+
trigger,
|
|
1998
|
+
startedAt,
|
|
1999
|
+
finishedAt,
|
|
2000
|
+
log,
|
|
2001
|
+
signal,
|
|
2002
|
+
context
|
|
2003
|
+
});
|
|
2004
|
+
}
|
|
1581
2005
|
return log;
|
|
1582
2006
|
}
|
|
1583
2007
|
|
|
1584
2008
|
// src/scheduler-runner.ts
|
|
1585
|
-
var
|
|
2009
|
+
var logger4 = core.logger.child({ module: "scheduler", scope: "runner" });
|
|
1586
2010
|
var runningTasks = /* @__PURE__ */ new Set();
|
|
1587
2011
|
var activeRuns = /* @__PURE__ */ new Map();
|
|
1588
2012
|
var activeRepairs = /* @__PURE__ */ new Set();
|
|
@@ -1607,13 +2031,24 @@ var publishedLogSchema = z.object({
|
|
|
1607
2031
|
taskType: z.enum(["api", "js", "hook"]),
|
|
1608
2032
|
triggerType: z.enum(["manual", "scheduled"]),
|
|
1609
2033
|
triggerSource: z.string().nullable(),
|
|
1610
|
-
status: z.enum([
|
|
2034
|
+
status: z.enum([
|
|
2035
|
+
"success",
|
|
2036
|
+
"failed",
|
|
2037
|
+
"interrupted",
|
|
2038
|
+
"unknown"
|
|
2039
|
+
]),
|
|
1611
2040
|
result: z.string().nullable(),
|
|
1612
2041
|
error: z.string().nullable(),
|
|
1613
2042
|
startedAt: z.number().safe(),
|
|
1614
2043
|
finishedAt: z.number().safe(),
|
|
1615
2044
|
duration: z.number().safe(),
|
|
1616
|
-
persistence: z.object({
|
|
2045
|
+
persistence: z.object({
|
|
2046
|
+
status: z.enum(["pending", "persisted", "unconfirmed"]),
|
|
2047
|
+
error: z.object({
|
|
2048
|
+
code: z.string(),
|
|
2049
|
+
message: z.string()
|
|
2050
|
+
}).optional()
|
|
2051
|
+
})
|
|
1617
2052
|
});
|
|
1618
2053
|
function repairExecutionLogs(id) {
|
|
1619
2054
|
const operation = projectExecutionLogs(id);
|
|
@@ -1648,7 +2083,7 @@ async function projectExecutionLogs(id) {
|
|
|
1648
2083
|
return err(HaiSchedulerError.LOG_PERSIST_FAILED, schedulerM("scheduler_logPersistFailed"));
|
|
1649
2084
|
const cleanup = await logs.cleanupLogs(cleanupPolicy);
|
|
1650
2085
|
if (!cleanup.success)
|
|
1651
|
-
|
|
2086
|
+
logger4.warn("Execution logs persisted but retention cleanup failed", { occurrenceId: id, errorCode: cleanup.error.code });
|
|
1652
2087
|
return ok(void 0);
|
|
1653
2088
|
} catch {
|
|
1654
2089
|
return err(HaiSchedulerError.LOG_PERSIST_FAILED, schedulerM("scheduler_logPersistFailed"));
|
|
@@ -1690,7 +2125,9 @@ async function drainRunner() {
|
|
|
1690
2125
|
stopTimer();
|
|
1691
2126
|
for (const controller of activeRuns.values())
|
|
1692
2127
|
controller.abort(new Error(schedulerM("scheduler_closing")));
|
|
1693
|
-
await Promise.allSettled([
|
|
2128
|
+
await Promise.allSettled([
|
|
2129
|
+
...activeRuns.keys()
|
|
2130
|
+
]);
|
|
1694
2131
|
await Promise.allSettled([...activeRepairs]);
|
|
1695
2132
|
}
|
|
1696
2133
|
async function tick() {
|
|
@@ -1727,7 +2164,7 @@ async function tick() {
|
|
|
1727
2164
|
return;
|
|
1728
2165
|
continue;
|
|
1729
2166
|
}
|
|
1730
|
-
void runTask(task, trigger.minute, trigger, void 0, row).catch((error) =>
|
|
2167
|
+
void runTask(task, trigger.minute, trigger, void 0, row).catch((error) => logger4.warn("Execution recovery failed", { taskId: task.id, error }));
|
|
1731
2168
|
}
|
|
1732
2169
|
}
|
|
1733
2170
|
}
|
|
@@ -1749,7 +2186,7 @@ function scheduleDueTasks(databaseNow) {
|
|
|
1749
2186
|
continue;
|
|
1750
2187
|
if (!getCron(taskId)?.match(new Date(currentMinute * 6e4)))
|
|
1751
2188
|
continue;
|
|
1752
|
-
void runTask(task, currentMinute, { type: "scheduled", source: null }).catch((error) =>
|
|
2189
|
+
void runTask(task, currentMinute, { type: "scheduled", source: null }).catch((error) => logger4.error("Unhandled task execution error", { taskId, error }));
|
|
1753
2190
|
}
|
|
1754
2191
|
}
|
|
1755
2192
|
function runTask(task, minuteTimestamp, trigger = { type: "manual", source: null }, options, recovery) {
|
|
@@ -1768,20 +2205,35 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1768
2205
|
const leaseMs = currentLeaseMs;
|
|
1769
2206
|
const occurrenceId = recovery?.occurrenceId ?? executionId(task.id, trigger.type, minute === void 0 ? options?.idempotencyKey ?? randomUUID() : String(minute));
|
|
1770
2207
|
const interrupted = async (reason, observationOnly = false) => {
|
|
1771
|
-
const log = {
|
|
2208
|
+
const log = {
|
|
2209
|
+
...await interruptTask(task, trigger, reason, {}, controller.signal),
|
|
2210
|
+
occurrenceId
|
|
2211
|
+
};
|
|
1772
2212
|
if (observationOnly && logRepository) {
|
|
1773
2213
|
const saved = await logRepository.saveLog(log);
|
|
1774
|
-
log.persistence = saved.success ? { status: "persisted" } : {
|
|
2214
|
+
log.persistence = saved.success ? { status: "persisted" } : {
|
|
2215
|
+
status: "unconfirmed",
|
|
2216
|
+
error: {
|
|
2217
|
+
code: String(saved.error.code),
|
|
2218
|
+
message: saved.error.message
|
|
2219
|
+
}
|
|
2220
|
+
};
|
|
1775
2221
|
}
|
|
1776
2222
|
return log;
|
|
1777
2223
|
};
|
|
1778
2224
|
if (!executionRepo2)
|
|
1779
2225
|
return interrupted(schedulerM("scheduler_executionStateFailed"), true);
|
|
1780
|
-
const claimed = await executionRepo2.claim(task, occurrenceId, {
|
|
2226
|
+
const claimed = await executionRepo2.claim(task, occurrenceId, {
|
|
2227
|
+
...trigger,
|
|
2228
|
+
...minute !== void 0 ? { minute } : {}
|
|
2229
|
+
}, currentNodeId, leaseMs);
|
|
1781
2230
|
if (!claimed.success)
|
|
1782
2231
|
return interrupted(claimed.error.message, true);
|
|
1783
|
-
if (!claimed.data)
|
|
1784
|
-
return interrupted(schedulerM("scheduler_taskRunning", {
|
|
2232
|
+
if (!claimed.data) {
|
|
2233
|
+
return interrupted(schedulerM("scheduler_taskRunning", {
|
|
2234
|
+
params: { taskId: task.id }
|
|
2235
|
+
}), true);
|
|
2236
|
+
}
|
|
1785
2237
|
const row = claimed.data;
|
|
1786
2238
|
if (!["claimed", "running"].includes(row.status)) {
|
|
1787
2239
|
if (minute === void 0) {
|
|
@@ -1802,12 +2254,19 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1802
2254
|
duration: row.updatedAt - row.createdAt
|
|
1803
2255
|
};
|
|
1804
2256
|
const status = row.status === "discarded" ? "interrupted" : row.status;
|
|
1805
|
-
return {
|
|
2257
|
+
return {
|
|
2258
|
+
...log,
|
|
2259
|
+
status,
|
|
2260
|
+
error: status === "success" ? null : log.error,
|
|
2261
|
+
occurrenceId
|
|
2262
|
+
};
|
|
1806
2263
|
} catch {
|
|
1807
2264
|
return interrupted(schedulerM("scheduler_executionStateFailed"));
|
|
1808
2265
|
}
|
|
1809
2266
|
}
|
|
1810
|
-
return interrupted(schedulerM("scheduler_occurrenceHandled", {
|
|
2267
|
+
return interrupted(schedulerM("scheduler_occurrenceHandled", {
|
|
2268
|
+
params: { taskId: task.id }
|
|
2269
|
+
}), true);
|
|
1811
2270
|
}
|
|
1812
2271
|
runningTasks.add(task.id);
|
|
1813
2272
|
let timer;
|
|
@@ -1846,14 +2305,21 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1846
2305
|
} catch {
|
|
1847
2306
|
}
|
|
1848
2307
|
if (!refreshed.success || !latest || latest.enabled === false || !unchanged) {
|
|
1849
|
-
log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
|
|
2308
|
+
log = await interrupted(schedulerM("scheduler_taskNoLongerDue", {
|
|
2309
|
+
params: { taskId: task.id }
|
|
2310
|
+
}));
|
|
1850
2311
|
if (row.attemptCount > 0)
|
|
1851
2312
|
log.status = "unknown";
|
|
1852
2313
|
break;
|
|
1853
2314
|
}
|
|
1854
2315
|
task = latest;
|
|
1855
2316
|
if (!task.handler && !hooks.onTaskExecute) {
|
|
1856
|
-
log = {
|
|
2317
|
+
log = {
|
|
2318
|
+
...await interruptTask(task, trigger, schedulerM("scheduler_taskHandlerMissing", {
|
|
2319
|
+
params: { taskId: task.id }
|
|
2320
|
+
}), hooks, controller.signal),
|
|
2321
|
+
occurrenceId
|
|
2322
|
+
};
|
|
1857
2323
|
break;
|
|
1858
2324
|
}
|
|
1859
2325
|
const begun = await executionRepo2.begin(row, leaseMs);
|
|
@@ -1861,7 +2327,12 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1861
2327
|
lost = true;
|
|
1862
2328
|
break;
|
|
1863
2329
|
}
|
|
1864
|
-
log = await executeTask(task, trigger, hooks, controller.signal, {
|
|
2330
|
+
log = await executeTask(task, trigger, hooks, controller.signal, {
|
|
2331
|
+
occurrenceId,
|
|
2332
|
+
executionToken: row.owner,
|
|
2333
|
+
sequence: row.sequence,
|
|
2334
|
+
attempt: row.attemptCount
|
|
2335
|
+
});
|
|
1865
2336
|
log.occurrenceId = occurrenceId;
|
|
1866
2337
|
attempts.push(log);
|
|
1867
2338
|
if (log.status !== "failed" || !row.idempotent || row.attemptCount >= row.maxAttempts)
|
|
@@ -1873,23 +2344,53 @@ async function runTaskExecution(task, minute, trigger, controller, options, reco
|
|
|
1873
2344
|
if (!log)
|
|
1874
2345
|
log = await interrupted(schedulerM("scheduler_executionStateFailed"));
|
|
1875
2346
|
if (lost) {
|
|
1876
|
-
return {
|
|
2347
|
+
return {
|
|
2348
|
+
...log,
|
|
2349
|
+
status: "unknown",
|
|
2350
|
+
persistence: { status: "unconfirmed" },
|
|
2351
|
+
error: schedulerM("scheduler_executionUnknown"),
|
|
2352
|
+
occurrenceId
|
|
2353
|
+
};
|
|
2354
|
+
}
|
|
2355
|
+
if (controller.signal.aborted && row.attemptCount > 0) {
|
|
2356
|
+
log = {
|
|
2357
|
+
...log,
|
|
2358
|
+
status: "unknown",
|
|
2359
|
+
error: schedulerM("scheduler_executionUnknown")
|
|
2360
|
+
};
|
|
1877
2361
|
}
|
|
1878
|
-
if (controller.signal.aborted && row.attemptCount > 0)
|
|
1879
|
-
log = { ...log, status: "unknown", error: schedulerM("scheduler_executionUnknown") };
|
|
1880
2362
|
const currentAttempt = attempts.findIndex((attempt) => attempt.id === log.id);
|
|
1881
2363
|
if (currentAttempt >= 0)
|
|
1882
2364
|
attempts[currentAttempt] = log;
|
|
1883
2365
|
else
|
|
1884
2366
|
attempts.push(log);
|
|
1885
|
-
const published = attempts.map((attempt) => ({
|
|
1886
|
-
|
|
1887
|
-
|
|
1888
|
-
|
|
2367
|
+
const published = attempts.map((attempt) => ({
|
|
2368
|
+
...attempt,
|
|
2369
|
+
persistence: { status: "pending" }
|
|
2370
|
+
}));
|
|
2371
|
+
const finished = await executionRepo2.finish(row, {
|
|
2372
|
+
...log,
|
|
2373
|
+
persistence: { status: "pending" }
|
|
2374
|
+
}, published);
|
|
2375
|
+
if (!finished.success) {
|
|
2376
|
+
return {
|
|
2377
|
+
...log,
|
|
2378
|
+
status: "unknown",
|
|
2379
|
+
persistence: { status: "unconfirmed" },
|
|
2380
|
+
error: finished.error.message,
|
|
2381
|
+
occurrenceId
|
|
2382
|
+
};
|
|
2383
|
+
}
|
|
1889
2384
|
const projected = await repairExecutionLogs(occurrenceId);
|
|
1890
|
-
log.persistence = projected.success ? { status: "persisted" } : {
|
|
2385
|
+
log.persistence = projected.success ? { status: "persisted" } : {
|
|
2386
|
+
status: "pending",
|
|
2387
|
+
error: {
|
|
2388
|
+
code: String(projected.error.code),
|
|
2389
|
+
message: projected.error.message
|
|
2390
|
+
}
|
|
2391
|
+
};
|
|
1891
2392
|
if (!projected.success)
|
|
1892
|
-
|
|
2393
|
+
logger4.warn("Execution completed with pending log persistence", { taskId: task.id, occurrenceId, errorCode: projected.error.code });
|
|
1893
2394
|
if (task.deleteAfterRun && log.status === "success") {
|
|
1894
2395
|
const refreshed = await loadPersistedTasks(repository);
|
|
1895
2396
|
if (refreshed.success && isDeepStrictEqual(getTask(task.id), task))
|
|
@@ -1914,7 +2415,7 @@ function stopTimer() {
|
|
|
1914
2415
|
}
|
|
1915
2416
|
|
|
1916
2417
|
// src/scheduler-main.ts
|
|
1917
|
-
var
|
|
2418
|
+
var logger5 = core.logger.child({ module: "scheduler", scope: "main" });
|
|
1918
2419
|
var currentConfig = null;
|
|
1919
2420
|
var initInProgress = false;
|
|
1920
2421
|
var closeInProgress = null;
|
|
@@ -1922,25 +2423,30 @@ var taskRepo = null;
|
|
|
1922
2423
|
var logRepo = null;
|
|
1923
2424
|
var executionRepo = null;
|
|
1924
2425
|
var executionIdSchema = z.string().regex(/^[a-f\d]{64}$/);
|
|
1925
|
-
var executionListSchema = z.object({
|
|
2426
|
+
var executionListSchema = z.object({
|
|
2427
|
+
limit: z.number().int().min(1).max(100).default(50),
|
|
2428
|
+
offset: z.number().int().min(0).max(1e6).default(0)
|
|
2429
|
+
});
|
|
1926
2430
|
var notInitialized = core.module.createNotInitializedKit(
|
|
1927
2431
|
HaiSchedulerError.NOT_INITIALIZED,
|
|
1928
2432
|
() => schedulerM("scheduler_notInitialized")
|
|
1929
2433
|
);
|
|
1930
2434
|
async function initDatabase(parsed) {
|
|
1931
2435
|
if (!reldb.isInitialized) {
|
|
1932
|
-
|
|
2436
|
+
logger5.error("enableDb is true but @h-ai/reldb is not initialized");
|
|
1933
2437
|
throw new Error(schedulerM("scheduler_reldbNotInitialized"));
|
|
1934
2438
|
}
|
|
1935
|
-
const migration = await migrateScheduler();
|
|
1936
|
-
if (!migration.success)
|
|
1937
|
-
throw migration.error;
|
|
1938
2439
|
taskRepo = new SchedulerTaskRepository(reldb);
|
|
1939
2440
|
logRepo = new SchedulerLogRepository(reldb);
|
|
1940
2441
|
executionRepo = new SchedulerExecutionRepository(reldb);
|
|
1941
|
-
const ready
|
|
1942
|
-
|
|
1943
|
-
|
|
2442
|
+
for (const ready of await Promise.all([
|
|
2443
|
+
taskRepo.ready(),
|
|
2444
|
+
logRepo.ready(),
|
|
2445
|
+
executionRepo.ready()
|
|
2446
|
+
])) {
|
|
2447
|
+
if (!ready.success)
|
|
2448
|
+
throw ready.error;
|
|
2449
|
+
}
|
|
1944
2450
|
setTaskRepository(taskRepo);
|
|
1945
2451
|
setLogRepository(logRepo, {
|
|
1946
2452
|
maxLogs: parsed.maxLogs,
|
|
@@ -1948,7 +2454,7 @@ async function initDatabase(parsed) {
|
|
|
1948
2454
|
});
|
|
1949
2455
|
const nodeId = parsed.nodeId ?? crypto.randomUUID();
|
|
1950
2456
|
configureExecution(executionRepo, nodeId, parsed.leaseMs);
|
|
1951
|
-
|
|
2457
|
+
logger5.info("Shared execution repository configured", { nodeId, leaseMs: parsed.leaseMs });
|
|
1952
2458
|
return { ...parsed, nodeId };
|
|
1953
2459
|
}
|
|
1954
2460
|
function normalizeTriggerInput(options) {
|
|
@@ -2003,10 +2509,12 @@ var scheduler = {
|
|
|
2003
2509
|
},
|
|
2004
2510
|
async init(config) {
|
|
2005
2511
|
if (initInProgress) {
|
|
2006
|
-
|
|
2512
|
+
logger5.warn("Scheduler init already in progress, skipping concurrent call");
|
|
2007
2513
|
return err(
|
|
2008
2514
|
HaiSchedulerError.INIT_FAILED,
|
|
2009
|
-
schedulerM("scheduler_initFailed", {
|
|
2515
|
+
schedulerM("scheduler_initFailed", {
|
|
2516
|
+
params: { error: "Concurrent initialization detected" }
|
|
2517
|
+
})
|
|
2010
2518
|
);
|
|
2011
2519
|
}
|
|
2012
2520
|
initInProgress = true;
|
|
@@ -2014,17 +2522,19 @@ var scheduler = {
|
|
|
2014
2522
|
if (closeInProgress)
|
|
2015
2523
|
await closeInProgress;
|
|
2016
2524
|
if (currentConfig) {
|
|
2017
|
-
|
|
2525
|
+
logger5.warn("Scheduler module is already initialized, reinitializing");
|
|
2018
2526
|
await scheduler.close();
|
|
2019
2527
|
}
|
|
2020
|
-
|
|
2528
|
+
logger5.info("Initializing scheduler module");
|
|
2021
2529
|
const { tasks = [], hooks = {}, ...configOptions } = config ?? {};
|
|
2022
2530
|
const parseResult = SchedulerConfigSchema.safeParse(configOptions);
|
|
2023
2531
|
if (!parseResult.success) {
|
|
2024
|
-
|
|
2532
|
+
logger5.error("Scheduler config validation failed", { error: parseResult.error.message });
|
|
2025
2533
|
return err(
|
|
2026
2534
|
HaiSchedulerError.CONFIG_ERROR,
|
|
2027
|
-
schedulerM("scheduler_configError", {
|
|
2535
|
+
schedulerM("scheduler_configError", {
|
|
2536
|
+
params: { error: parseResult.error.message }
|
|
2537
|
+
}),
|
|
2028
2538
|
parseResult.error
|
|
2029
2539
|
);
|
|
2030
2540
|
}
|
|
@@ -2041,15 +2551,17 @@ var scheduler = {
|
|
|
2041
2551
|
await scheduler.close();
|
|
2042
2552
|
return configResult;
|
|
2043
2553
|
}
|
|
2044
|
-
|
|
2554
|
+
logger5.info("Scheduler module initialized", { enableDb: currentConfig.enableDb, taskCount: getTaskRegistry().size });
|
|
2045
2555
|
return ok(void 0);
|
|
2046
2556
|
} catch (error) {
|
|
2047
|
-
|
|
2557
|
+
logger5.error("Scheduler initialization failed", { error });
|
|
2048
2558
|
await scheduler.close();
|
|
2049
2559
|
return err(
|
|
2050
2560
|
HaiSchedulerError.INIT_FAILED,
|
|
2051
2561
|
schedulerM("scheduler_initFailed", {
|
|
2052
|
-
params: {
|
|
2562
|
+
params: {
|
|
2563
|
+
error: error instanceof Error ? error.message : String(error)
|
|
2564
|
+
}
|
|
2053
2565
|
}),
|
|
2054
2566
|
error
|
|
2055
2567
|
);
|
|
@@ -2069,7 +2581,7 @@ var scheduler = {
|
|
|
2069
2581
|
return notInitialized.result();
|
|
2070
2582
|
const registerResult = await registerTask(task, taskRepo);
|
|
2071
2583
|
if (registerResult.success) {
|
|
2072
|
-
|
|
2584
|
+
logger5.info("Task registered", { taskId: task.id, taskName: task.name, cron: task.cron });
|
|
2073
2585
|
}
|
|
2074
2586
|
return registerResult;
|
|
2075
2587
|
},
|
|
@@ -2078,15 +2590,19 @@ var scheduler = {
|
|
|
2078
2590
|
return notInitialized.result();
|
|
2079
2591
|
const unregisterResult = await unregisterTask(taskId, taskRepo);
|
|
2080
2592
|
if (unregisterResult.success)
|
|
2081
|
-
|
|
2593
|
+
logger5.info("Task unregistered", { taskId });
|
|
2082
2594
|
return unregisterResult;
|
|
2083
2595
|
},
|
|
2084
2596
|
async updateTask(taskId, updates) {
|
|
2085
2597
|
if (!currentConfig)
|
|
2086
2598
|
return notInitialized.result();
|
|
2087
2599
|
const updateResult = await updateRegisteredTask(taskId, updates, taskRepo);
|
|
2088
|
-
if (updateResult.success)
|
|
2089
|
-
|
|
2600
|
+
if (updateResult.success) {
|
|
2601
|
+
logger5.info("Task updated", {
|
|
2602
|
+
taskId,
|
|
2603
|
+
updates: Object.keys(updates)
|
|
2604
|
+
});
|
|
2605
|
+
}
|
|
2090
2606
|
return updateResult;
|
|
2091
2607
|
},
|
|
2092
2608
|
start() {
|
|
@@ -2099,7 +2615,7 @@ var scheduler = {
|
|
|
2099
2615
|
);
|
|
2100
2616
|
}
|
|
2101
2617
|
startTimer(currentConfig.tickInterval);
|
|
2102
|
-
|
|
2618
|
+
logger5.info("Scheduler started", { tickInterval: currentConfig.tickInterval });
|
|
2103
2619
|
return ok(void 0);
|
|
2104
2620
|
},
|
|
2105
2621
|
stop() {
|
|
@@ -2112,7 +2628,7 @@ var scheduler = {
|
|
|
2112
2628
|
);
|
|
2113
2629
|
}
|
|
2114
2630
|
stopTimer();
|
|
2115
|
-
|
|
2631
|
+
logger5.info("Scheduler stopped");
|
|
2116
2632
|
return ok(void 0);
|
|
2117
2633
|
},
|
|
2118
2634
|
async trigger(taskId, options) {
|
|
@@ -2131,7 +2647,9 @@ var scheduler = {
|
|
|
2131
2647
|
if (!task) {
|
|
2132
2648
|
return err(
|
|
2133
2649
|
HaiSchedulerError.TASK_NOT_FOUND,
|
|
2134
|
-
schedulerM("scheduler_taskNotFound", {
|
|
2650
|
+
schedulerM("scheduler_taskNotFound", {
|
|
2651
|
+
params: { taskId }
|
|
2652
|
+
})
|
|
2135
2653
|
);
|
|
2136
2654
|
}
|
|
2137
2655
|
const log = await runTask(task, void 0, normalizeTriggerInput(parsed.data), parsed.data);
|
|
@@ -2172,7 +2690,7 @@ var scheduler = {
|
|
|
2172
2690
|
async close() {
|
|
2173
2691
|
if (closeInProgress)
|
|
2174
2692
|
return closeInProgress;
|
|
2175
|
-
|
|
2693
|
+
logger5.info("Closing scheduler module");
|
|
2176
2694
|
currentConfig = null;
|
|
2177
2695
|
stopTimer();
|
|
2178
2696
|
cancelTaskDefinitionReads();
|
|
@@ -2187,7 +2705,7 @@ var scheduler = {
|
|
|
2187
2705
|
taskRepo = null;
|
|
2188
2706
|
logRepo = null;
|
|
2189
2707
|
executionRepo = null;
|
|
2190
|
-
|
|
2708
|
+
logger5.info("Scheduler module closed");
|
|
2191
2709
|
})();
|
|
2192
2710
|
try {
|
|
2193
2711
|
await closeInProgress;
|
|
@@ -2197,6 +2715,6 @@ var scheduler = {
|
|
|
2197
2715
|
}
|
|
2198
2716
|
};
|
|
2199
2717
|
|
|
2200
|
-
export { ExecutionResolutionSchema, HaiSchedulerError, SchedulerConfigSchema, TriggerTaskSchema,
|
|
2718
|
+
export { ExecutionResolutionSchema, HaiSchedulerError, SchedulerConfigSchema, TriggerTaskSchema, scheduler };
|
|
2201
2719
|
//# sourceMappingURL=index.js.map
|
|
2202
2720
|
//# sourceMappingURL=index.js.map
|