enqueueAll method

  1. @override
Future<List<RegenerationJob>> enqueueAll(
  1. List<RegenerationJobRequest> requests, {
  2. DateTime? now,
})
override

Implementation

@override
Future<List<RegenerationJob>> enqueueAll(
  List<RegenerationJobRequest> requests, {
  DateTime? now,
}) async => _locked(() async {
  if (requests.isEmpty) return const [];
  final state = await _syncState();
  final createdTime = (now ?? DateTime.now()).toUtc();
  final results = <RegenerationJob>[];
  final jobsToWrite = <RegenerationJob>[];
  final journalBatchEntries = <Map<String, Object?>>[];

  for (final req in requests) {
    _validateId(req.siteId, 'siteId');
    _validateId(req.tenantId, 'tenantId');
    _validateId(req.routeId, 'routeId');
    _validateId(req.idempotencyKey, 'idempotencyKey');
    final normalized = _normalizeQueuePath(req.path);
    if (req.tags.any(
      (tag) =>
          tag.trim().isEmpty || tag.length > 200 || tag.contains('\u0000'),
    )) {
      throw const FormatException('Invalid job dependency tag.');
    }
    if (req.maxAttempts < 1 || req.maxAttempts > 20) {
      throw ArgumentError('maxAttempts must be between 1 and 20.');
    }

    final composite = '${req.siteId}|${req.tenantId}|${req.idempotencyKey}';
    final existingId = state.idempotency[composite];
    if (existingId != null) {
      final existing = await _tryRead(existingId);
      if (existing != null &&
          existing.status != RegenerationJobStatus.cancelled) {
        results.add(existing);
        continue;
      }
    }

    final id =
        '${createdTime.microsecondsSinceEpoch}_${pid}_${_queueNonce()}';
    final seq = ++state.lastSeq;
    final job = RegenerationJob(
      id: id,
      siteId: req.siteId,
      tenantId: req.tenantId,
      path: normalized,
      routeId: req.routeId,
      tags: List.unmodifiable(req.tags.toSet().toList()..sort()),
      idempotencyKey: req.idempotencyKey,
      sourceVersion: req.sourceVersion,
      status: RegenerationJobStatus.queued,
      attempts: 0,
      maxAttempts: req.maxAttempts,
      createdAt: createdTime,
      availableAt: createdTime,
      sequence: seq,
    );

    jobsToWrite.add(job);
    state.idempotency[composite] = id;
    state.pending.add(id);
    results.add(job);
    journalBatchEntries.add({'id': id, 'composite': composite});
  }

  // Write new job files concurrently in bounded chunks
  for (var i = 0; i < jobsToWrite.length; i += 64) {
    final chunk = jobsToWrite.skip(i).take(64);
    await Future.wait(chunk.map(_save));
  }

  if (journalBatchEntries.isNotEmpty) {
    await _appendJournal({
      'seq': ++state.lastSeq,
      'op': 'enqueue_batch',
      'jobs': journalBatchEntries,
    });
  }

  if (state.lastSeq % 1000 == 0) {
    await _checkpointInternal();
  }

  return results;
});