garbageCollect method

Future<GarbageCollectionReport> garbageCollect({
  1. Duration retentionGracePeriod = const Duration(minutes: 15),
  2. int maxRetainedVersions = 10,
})

Collects unreachable objects and cleans old versions while protecting active and rollback versions.

Implementation

Future<GarbageCollectionReport> garbageCollect({
  Duration retentionGracePeriod = const Duration(minutes: 15),
  int maxRetainedVersions = 10,
}) async {
  final watch = Stopwatch()..start();
  final lockFile = File('${root.path}${Platform.pathSeparator}.publish.lock');
  await root.create(recursive: true);
  final lockHandle = await lockFile.open(mode: FileMode.append);
  await lockHandle.lock(FileLock.exclusive);
  try {
    final active = await activeVersion;
    final versionsDir = Directory(
      '${root.path}${Platform.pathSeparator}.versions',
    );
    final allVersions = <Directory>[];
    if (await versionsDir.exists()) {
      await for (final entity in versionsDir.list(followLinks: false)) {
        if (entity is Directory) allVersions.add(entity);
      }
    }
    allVersions.sort((a, b) => b.path.compareTo(a.path));

    final retainedVersions = <String>{};
    if (active != null) retainedVersions.add(active);
    for (final v in allVersions) {
      final vName = v.uri.pathSegments.where((s) => s.isNotEmpty).last;
      if (retainedVersions.length < maxRetainedVersions) {
        retainedVersions.add(vName);
      }
    }

    final reachableHashes = <String>{};
    for (final vName in retainedVersions) {
      final vDir = _versionDir(vName);
      if (await vDir.exists()) {
        final entries = await _loadRouteArtifacts(vDir);
        reachableHashes.addAll(entries.values.map((e) => e.objectHash));
      }
    }

    var reclaimedBytes = 0;
    var deletedObjects = 0;
    final now = DateTime.now();

    if (await _objectsDir.exists()) {
      await for (final entity in _objectsDir.list(followLinks: false)) {
        if (entity is! File || !entity.path.endsWith('.html')) continue;
        final fileName = entity.uri.pathSegments.last;
        final hash = fileName.replaceAll('.html', '');
        if (!reachableHashes.contains(hash)) {
          final stat = await entity.stat();
          if (now.difference(stat.modified) > retentionGracePeriod) {
            reclaimedBytes += stat.size;
            await entity.delete();
            deletedObjects++;
          }
        }
      }
    }

    var deletedVersions = 0;
    for (final v in allVersions) {
      final vName = v.uri.pathSegments.where((s) => s.isNotEmpty).last;
      if (!retainedVersions.contains(vName) && vName != active) {
        await v.delete(recursive: true);
        deletedVersions++;
      }
    }

    return GarbageCollectionReport(
      reclaimedBytes: reclaimedBytes,
      deletedObjects: deletedObjects,
      retainedVersions: retainedVersions.length,
      deletedVersions: deletedVersions,
      duration: watch.elapsed,
    );
  } finally {
    await lockHandle.unlock();
    await lockHandle.close();
  }
}