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