builder/lib/src/tryjob.dart

// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:collection/collection.dart';
import 'package:http/http.dart' as http show Client;
import 'package:pool/pool.dart';

import 'commits_cache.dart';
import 'firestore.dart';
import 'gerrit_change.dart';
import 'result.dart';
import 'status.dart';

class ChangeCounter {
  static const maxReportedSuccesses = 1000;
  static const maxReportedFailures = 1000;

  int changes = 0;
  int passes = 0;
  int failures = 0;
  int unapprovedFailures = 0;
  int newFlakes = 0;
  bool hasTruncatedChanges = false;

  bool get hasTooManyFlakes => newFlakes >= 10;
  bool get hasTooManyPassingChanges => passes > maxReportedSuccesses;
  bool get hasTooManyFailingChanges => failures > maxReportedFailures;

  void count(Map<String, dynamic> change) {
    ++changes;
    change[fMatches] ? ++passes : ++failures;
    if (change[fFlaky] && !change[fPreviousFlaky]) ++newFlakes;
  }

  bool isNotReported(Map<String, dynamic> change) {
    if (change[fMatches] && hasTooManyPassingChanges ||
        !change[fMatches] && hasTooManyFailingChanges) {
      hasTruncatedChanges = true;
      return true;
    }
    return false;
  }

  List<String> report() => [
        if (changes > 0) 'Stored $changes changes',
        if (hasTruncatedChanges) 'Did not store all results. Truncating.',
        if (hasTooManyPassingChanges)
          'Only $maxReportedSuccesses new passes stored',
        if (hasTooManyFailingChanges)
          'Only $maxReportedFailures new failures stored',
        if (unapprovedFailures > 0)
          '$unapprovedFailures unapproved failing tests found',
        if (failures > 0) '$failures failing tests found',
        if (passes > 0) '$passes passing tests found',
        if (newFlakes > 0) '$newFlakes new flaky tests found',
      ];
}

class Tryjob {
  final http.Client httpClient;
  final FirestoreService firestore;
  final CommitsCache commits;
  final counter = ChangeCounter();
  TryBuildInfo info;
  final TestNameLock testNameLock = TestNameLock();
  String baseRevision;
  bool success = true;
  late List<SafeDocument> landedResults;
  Map<String, SafeDocument> lastLandedResultByName = {};
  final String buildbucketID;

  Tryjob(this.info, this.buildbucketID, this.baseRevision, this.commits,
      this.firestore, this.httpClient);

  void log(String string) => firestore.log(string);

  Future<void> update() async {
    await GerritInfo(info.review, info.patchset, firestore, httpClient)
        .update();
  }

  bool isNotLandedResult(Map<String, dynamic> change) {
    return change[fResult] !=
        lastLandedResultByName[change[fName]]?.getString(fResult);
  }

  Future<BuildStatus> process(List<Map<String, dynamic>> results) async {
    await update();
    log('storing ${results.length} change(s)');
    final resultsByConfiguration = groupBy<Map<String, dynamic>, String>(
        results, (result) => result['configuration']);

    for (final configuration in resultsByConfiguration.keys) {
      if (info.previousCommitHash != null) {
        landedResults = await fetchLandedResults(configuration);
        // Map will contain the last result with each name.
        lastLandedResultByName = {
          for (final result in landedResults) result.getString(fName): result
        };
      }
      final changes =
          resultsByConfiguration[configuration]!.where(isNotLandedResult);
      await Pool(30).forEach(changes, guardedStoreChange).drain();
    }

    if (counter.hasTooManyFlakes) {
      success = false;
    }
    await firestore.recordTryBuild(
        info, buildbucketID, success, counter.hasTruncatedChanges);
    final status = BuildStatus()
      ..success = success
      ..truncatedResults = counter.hasTruncatedChanges;
    final report = [
      'Processed ${results.length} results from ${info.builderName} build ${info.buildNumber}',
      'Tryjob on CL ${info.review} patchset ${info.patchset}',
      if (!success) 'Found unapproved new failures',
      ...counter.report(),
      '${firestore.documentsFetched} documents fetched',
      '${firestore.documentsWritten} documents written',
    ];
    log(report.join('\n'));
    return status;
  }

  Future<void> guardedStoreChange(Map<String, dynamic> change) =>
      testNameLock.guardedCall(storeChange, change);

  Future<void> storeChange(Map<String, dynamic> change) async {
    transformChange(change);
    counter.count(change);
    if (counter.isNotReported(change)) return;
    final approved =
        await firestore.storeTryChange(change, info.review, info.patchset);
    if (!approved && isFailure(change)) {
      counter.unapprovedFailures++;
      success = false;
    }
  }

  Future<List<SafeDocument>> fetchLandedResults(String configuration) async {
    final resultsBase = await commits.getCommit(info.previousCommitHash!);
    final rebaseBase = await commits.getCommit(baseRevision);
    if (resultsBase.index > rebaseBase.index) {
      print('Try build is rebased on $baseRevision, which is before '
          'the commit ${info.previousCommitHash} with CI comparison results');
      return [];
    }
    final reviews = [
      for (var index = resultsBase.index + 1;
          index <= rebaseBase.index;
          ++index)
        (await commits.getCommitByIndex(index)).review
    ];
    return [
      for (final landedReview in reviews)
        if (landedReview != null)
          ...await firestore.tryResults(landedReview, configuration)
    ];
  }
}