HomeResultsReader.java

package tfb.status.service;

import static com.google.common.collect.ImmutableSet.toImmutableSet;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Comparator.comparing;
import static java.util.Comparator.reverseOrder;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.base.Joiner;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
import com.google.errorprone.annotations.Immutable;
import com.google.errorprone.annotations.concurrent.GuardedBy;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.FileTime;
import java.text.NumberFormat;
import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
import javax.annotation.Nullable;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import tfb.status.util.ZipFiles;
import tfb.status.view.HomePageView.ResultsGitView;
import tfb.status.view.HomePageView.ResultsJsonView;
import tfb.status.view.HomePageView.ResultsView;
import tfb.status.view.HomePageView.ResultsZipView;
import tfb.status.view.HomePageView.ResultsZipView.Failure;
import tfb.status.view.Results;

/**
 * Loads previously-uploaded results for display on the home page.
 */
@Singleton
public final class HomeResultsReader {
  private final FileStore fileStore;
  private final ObjectMapper objectMapper;
  private final Clock clock;
  private final Logger logger = LoggerFactory.getLogger(getClass());

  private final LoadingCache<ViewCacheKey, ResultsJsonView> jsonCache =
      Caffeine.newBuilder()
              .maximumSize(VIEW_CACHE_MAX_SIZE)
              .build(key -> viewJsonFile(key.file));

  private final LoadingCache<ViewCacheKey, ResultsZipView> zipCache =
      Caffeine.newBuilder()
              .maximumSize(VIEW_CACHE_MAX_SIZE)
              .build(key -> viewZipFile(key.file));

  // This number should be greater than the total number of results files we'll
  // ever have on disk at once.
  private static final int VIEW_CACHE_MAX_SIZE = 10_000;

  @GuardedBy("this") @Nullable private ScheduledThreadPoolExecutor purgeScheduler;
  @GuardedBy("this") @Nullable private ScheduledFuture<?> purgeTask;

  @Inject
  public HomeResultsReader(FileStore fileStore,
                           ObjectMapper objectMapper,
                           Clock clock) {

    this.fileStore = Objects.requireNonNull(fileStore);
    this.objectMapper = Objects.requireNonNull(objectMapper);
    this.clock = Objects.requireNonNull(clock);
  }

  /**
   * Initializes resources used by this service.
   */
  @PostConstruct
  public synchronized void start() {
    purgeScheduler = new ScheduledThreadPoolExecutor(1);
    purgeScheduler.setRemoveOnCancelPolicy(true);
    purgeScheduler.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
    purgeScheduler.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);

    purgeTask =
        purgeScheduler.scheduleWithFixedDelay(
            /* command= */ () -> {
              try {
                purgeUnreachableCacheKeys();
              } catch (RuntimeException e) {
                // An uncaught exception would de-schedule this task.
                logger.error("Error purging unreachable cache keys", e);
              }
            },
            /* initialDelay= */ 1,
            /* delay= */ 1,
            /* unit= */ TimeUnit.HOURS);
  }

  /**
   * Cleans up resources used by this service.
   */
  @PreDestroy
  public synchronized void stop() {
    ScheduledFuture<?> task = this.purgeTask;
    if (task != null) {
      task.cancel(false);
      this.purgeTask = null;
    }

    ScheduledThreadPoolExecutor scheduler = this.purgeScheduler;
    if (scheduler != null) {
      scheduler.shutdownNow();
      this.purgeScheduler = null;
    }
  }

  /**
   * Returns a view of all the previously-uploaded results, suitable for
   * rendering on the home page.
   *
   * @return a view of the results
   * @throws IOException if an I/O error occurs while reading the results
   */
  public ImmutableList<ResultsView> results() throws IOException {
    var jsonByUuid = new HashMap<String, ResultsJsonView>();
    var jsonWithoutUuid = new ArrayList<ResultsJsonView>();

    viewAllJsonFiles().forEach(
        (ResultsJsonView view) -> {
          if (view.uuid == null)
            jsonWithoutUuid.add(view);

          else
            jsonByUuid.merge(
                view.uuid,
                view,
                (v1, v2) -> {
                  logger.warn(
                      "Ignoring results.json file {}, which has the same "
                          + "uuid ({}) as another results.json file.",
                      view.fileName, view.uuid);
                  return v1;
                });
        });

    var zipByUuid = new HashMap<String, ResultsZipView>();
    var zipWithoutUuid = new ArrayList<ResultsZipView>();

    viewAllZipFiles().forEach(
        (ResultsZipView view) -> {
          if (view.uuid == null)
            zipWithoutUuid.add(view);

          else
            zipByUuid.merge(
                view.uuid,
                view,
                (v1, v2) -> {
                  logger.warn(
                      "Ignoring results.zip file {}, which has the same "
                          + "uuid ({}) as another results.zip file.",
                      view.fileName, view.uuid);
                  return v1;
                });
        });

    var results = new ArrayList<ResultsView>();

    Set<String> uuids = Sets.union(jsonByUuid.keySet(),
                                   zipByUuid.keySet());

    for (String uuid : uuids) {
      ResultsJsonView json = jsonByUuid.get(uuid);
      ResultsZipView zip = zipByUuid.get(uuid);
      results.add(new ResultsView(json, zip));
    }

    for (ResultsJsonView json : jsonWithoutUuid)
      results.add(
          new ResultsView(
              /* json= */ json,
              /* zip= */ null));

    for (ResultsZipView zip : zipWithoutUuid)
      results.add(
          new ResultsView(
              /* json= */ null,
              /* zip= */ zip));

    return ImmutableList.sortedCopyOf(RESULTS_COMPARATOR, results);
  }

  /**
   * Returns a view of the only previously-uploaded results having the given
   * UUID, suitable for rendering on the home page, or {@code null} if there are
   * no results with the given UUID.
   *
   * @param uuid the UUID of the results to be viewed
   * @return a view of the results, or {@code null} if there are no matching
   *         results
   * @throws IOException if an I/O error occurs while reading the results
   */
  @Nullable
  public ResultsView resultsByUuid(String uuid) throws IOException {
    Objects.requireNonNull(uuid);

    ResultsJsonView json =
        viewAllJsonFiles()
            .filter(view -> uuid.equals(view.uuid))
            .findAny()
            .orElse(null);

    ResultsZipView zip =
        viewAllZipFiles()
            .filter(view -> uuid.equals(view.uuid))
            .findAny()
            .orElse(null);

    return (json == null && zip == null)
        ? null
        : new ResultsView(json, zip);
  }

  private Stream<ResultsJsonView> viewAllJsonFiles() throws IOException {
    Stream.Builder<ViewCacheKey> keys = Stream.builder();

    try (DirectoryStream<Path> jsonFiles =
             Files.newDirectoryStream(fileStore.resultsDirectory(), "*.json")) {

      for (Path file : jsonFiles)
        keys.add(new ViewCacheKey(file));
    }

    return keys.build()
               .map(key -> jsonCache.get(key))
               .filter(view -> view != null);
  }

  private Stream<ResultsZipView> viewAllZipFiles() throws IOException {
    Stream.Builder<ViewCacheKey> keys = Stream.builder();

    try (DirectoryStream<Path> zipFiles =
             Files.newDirectoryStream(fileStore.resultsDirectory(), "*.zip")) {

      for (Path file : zipFiles)
        keys.add(new ViewCacheKey(file));
    }

    return keys.build()
               .map(key -> zipCache.get(key))
               .filter(view -> view != null);
  }

  @Nullable
  private ResultsJsonView viewJsonFile(Path jsonFile) {
    Objects.requireNonNull(jsonFile);

    Results results;
    try (InputStream inputStream = Files.newInputStream(jsonFile)) {
      results = objectMapper.readValue(inputStream, Results.class);
    } catch (IOException e) {
      logger.warn("Exception reading json file {}", jsonFile, e);
      return null;
    }

    String uuid = results.uuid;
    String name = results.name;
    String environmentDescription = results.environmentDescription;

    // The "completed" map in the results includes frameworks that won't show up
    // in the "succeeded" or "failed" maps because they had an error before they
    // could execute any of the test types.  For example, this will happen when
    // a rogue process holds onto a common port like 8080 and prevents a lot of
    // frameworks from starting up.
    int frameworksWithCleanSetup = 0;
    int frameworksWithSetupProblems = 0;

    for (String message : results.completed.values()) {
      if (isCompletedTimestamp(message))
        frameworksWithCleanSetup++;
      else
        frameworksWithSetupProblems++;
    }

    int completedFrameworks =
        frameworksWithCleanSetup + frameworksWithSetupProblems;

    int totalFrameworks = results.frameworks.size();
    int successfulTests = results.succeeded.values().size();
    int failedTests = results.failed.values().size();

    for (String testType : Results.TEST_TYPES) {
      for (String framework : results.frameworks) {
        if (results.succeeded.containsEntry(testType, framework)
            && results.requests(testType, framework) == 0) {
          successfulTests--;
          failedTests++;
        }
      }
    }

    LocalDateTime startTime =
        (results.startTime == null)
            ? null
            : epochMillisToDateTime(results.startTime, clock.getZone());

    LocalDateTime completionTime =
        (results.completionTime == null)
            ? null
            : epochMillisToDateTime(results.completionTime, clock.getZone());

    Duration elapsedDuration;
    Duration estimatedRemainingDuration;

    if (startTime == null)
      elapsedDuration = null;

    else {
      LocalDateTime endTime =
          (completionTime == null)
              ? LocalDateTime.now(clock)
              : completionTime;
      elapsedDuration = Duration.between(startTime, endTime);
    }

    if (completionTime != null
        || startTime == null
        || elapsedDuration == null
        || completedFrameworks == 0)
      estimatedRemainingDuration = null;

    else
      estimatedRemainingDuration =
          elapsedDuration.multipliedBy(totalFrameworks)
                         .dividedBy(completedFrameworks)
                         .minus(elapsedDuration);

    //
    // TODO: Avoid using the last modified time of the file on disk, which may
    //       change for reasons completely unrelated to the run itself, and use
    //       something from the results.json file to give us a last modified
    //       time instead.  The datetime strings in the "completed" object are
    //       no good because they are local to the TFB server, and we don't know
    //       that server's time zone.
    //
    FileTime lastUpdatedTime;
    try {
      lastUpdatedTime = Files.getLastModifiedTime(jsonFile);
    } catch (IOException e) {
      logger.warn("Exception reading last modified time of file {}", jsonFile, e);
      return null;
    }

    DateTimeFormatter displayedTimeFormatter =
        DateTimeFormatter.ofPattern(
            "yyyy-MM-dd 'at' h:mm a",
            Locale.ROOT);

    String startTimeString =
        (startTime == null)
            ? null
            : displayedTimeFormatter.format(startTime);

    String completionTimeString =
        (completionTime == null)
            ? null
            : displayedTimeFormatter.format(completionTime);

    String lastUpdatedString =
        lastUpdatedTime.toInstant()
                       .atZone(clock.getZone())
                       .toLocalDateTime()
                       .format(displayedTimeFormatter);

    String elapsedDurationString =
        (elapsedDuration == null)
            ? null
            : formatDuration(elapsedDuration);

    String estimatedRemainingDurationString =
        (estimatedRemainingDuration == null)
            ? null
            : formatDuration(estimatedRemainingDuration);

    Path relativePath = fileStore.resultsDirectory().relativize(jsonFile);
    String fileName = Joiner.on('/').join(relativePath);

    ResultsGitView git;
    if (results.git == null) {
      git = null;
    } else {
      git = new ResultsGitView(
          /* commitId= */ results.git.commitId,
          /* repositoryUrl= */ results.git.repositoryUrl,
          /* branchName= */ results.git.branchName);
    }

    return new ResultsJsonView(
        /* uuid= */ uuid,
        /* git= */ git,
        /* fileName= */ fileName,
        /* name= */ name,
        /* environmentDescription= */ environmentDescription,
        /* startTime= */ startTimeString,
        /* completionTime= */ completionTimeString,
        /* completedFrameworks= */ completedFrameworks,
        /* frameworksWithCleanSetup= */ frameworksWithCleanSetup,
        /* frameworksWithSetupProblems= */ frameworksWithSetupProblems,
        /* totalFrameworks= */ totalFrameworks,
        /* successfulTests= */ successfulTests,
        /* failedTests= */ failedTests,
        /* lastUpdated= */ lastUpdatedString,
        /* elapsedDuration= */ elapsedDurationString,
        /* estimatedRemainingDuration= */ estimatedRemainingDurationString);
  }

  @Nullable
  private ResultsZipView viewZipFile(Path zipFile) {
    Objects.requireNonNull(zipFile);

    Results results;
    try {
      results =
          ZipFiles.readZipEntry(
              /* zipFile= */ zipFile,
              /* entryPath= */ "results.json",
              /* entryReader= */ inputStream ->
                                     objectMapper.readValue(inputStream,
                                                            Results.class));
    } catch (IOException e) {
      logger.warn("Exception reading zip file {}", zipFile, e);
      return null;
    }

    //
    // If the zip doesn't contain a results.json at all, then we have nothing
    // useful to say to users about it, and we want to pretend it doesn't exist.
    //
    if (results == null)
      return null;

    String uuid = results.uuid;
    Path relativePath = fileStore.resultsDirectory().relativize(zipFile);
    String fileName = Joiner.on('/').join(relativePath);

    var failures = new ArrayList<Failure>();

    SetMultimap<String, String> frameworkToFailedTestTypes =
        HashMultimap.create(results.failed.inverse());

    for (String testType : Results.TEST_TYPES) {
      for (String framework : results.frameworks) {
        if (results.succeeded.containsEntry(testType, framework)
            && results.requests(testType, framework) == 0) {
          frameworkToFailedTestTypes.put(framework, testType);
        }
      }
    }

    var frameworksWithSetupIssues = new HashSet<String>();

    results.completed.forEach(
        (String framework, String message) -> {
          if (!isCompletedTimestamp(message)) {
            frameworksWithSetupIssues.add(framework);
          }
        });

    for (String framework : Sets.union(frameworkToFailedTestTypes.keySet(),
                                       frameworksWithSetupIssues)) {

      Set<String> failedTestTypes = frameworkToFailedTestTypes.get(framework);
      boolean hadSetupProblems = frameworksWithSetupIssues.contains(framework);

      failures.add(
          new Failure(
              /* framework= */ framework,
              /* failedTestTypes= */ ImmutableList.sortedCopyOf(failedTestTypes),
              /* hadSetupProblems= */ hadSetupProblems));
    }

    failures.sort(comparing(failure -> failure.framework,
                            String.CASE_INSENSITIVE_ORDER));

    ResultsGitView git;
    if (results.git == null) {

      // We used to collect the git commit id as a separate "commit_id.txt" file.
      String gitCommitId;
      try {
        gitCommitId =
            ZipFiles.readZipEntry(
                /* zipFile= */ zipFile,
                /* entryPath= */ "commit_id.txt",
                /* entryReader= */
                inputStream -> {
                  try (var isr = new InputStreamReader(inputStream, UTF_8);
                       var br = new BufferedReader(isr)) {
                    return br.readLine();
                  }
                });
      } catch (IOException e) {
        logger.warn(
            "Exception reading git commit id from zip file {}",
            zipFile, e);
        gitCommitId = null;
      }

      if (gitCommitId == null) {
        git = null;
      } else {
        git = new ResultsGitView(
            /* commitId= */ gitCommitId,
            /* repositoryUrl= */ null,
            /* branchName= */ null);
      }

    } else {
      git = new ResultsGitView(
          /* commitId= */ results.git.commitId,
          /* repositoryUrl= */ results.git.repositoryUrl,
          /* branchName= */ results.git.branchName);
    }

    return new ResultsZipView(
        /* uuid= */ uuid,
        /* git= */ git,
        /* fileName= */ fileName,
        /* failures= */ ImmutableList.copyOf(failures));
  }

  /**
   * Trims the internal cache, removing entries that are "dead" because they
   * have {@linkplain ViewCacheKey#isUnreachable() unreachable} keys.
   */
  private void purgeUnreachableCacheKeys() {
    purgeUnreachableCacheKeys(jsonCache);
    purgeUnreachableCacheKeys(zipCache);
  }

  private static void purgeUnreachableCacheKeys(Cache<ViewCacheKey, ?> cache) {
    ImmutableSet<ViewCacheKey> unreachableKeys =
        cache.asMap()
             .keySet()
             .stream()
             .filter(key -> key.isUnreachable())
             .collect(toImmutableSet());

    cache.invalidateAll(unreachableKeys);
  }

  @Immutable
  private static final class ViewCacheKey {
    final Path file;

    // When the file is modified, this cache key becomes unreachable.
    final FileTime lastModifiedTime;

    ViewCacheKey(Path file) throws IOException {
      this.file = Objects.requireNonNull(file);
      this.lastModifiedTime = Files.getLastModifiedTime(file);
    }

    @Override
    public boolean equals(@Nullable Object object) {
      if (object == this)
        return true;

      if (!(object instanceof ViewCacheKey))
        return false;

      var that = (ViewCacheKey) object;
      return this.file.equals(that.file)
          && this.lastModifiedTime.equals(that.lastModifiedTime);
    }

    @Override
    public int hashCode() {
      return file.hashCode() ^ lastModifiedTime.hashCode();
    }

    /**
     * Returns {@code true} if the file has been modified since this cache key
     * was created, meaning this cache key is effectively unreachable.
     */
    boolean isUnreachable() {
      try {
        return !lastModifiedTime.equals(Files.getLastModifiedTime(file));
      } catch (IOException ignored) {
        //
        // This would happen if the file is deleted, for example.
        //
        // Since an exception here implies that constructing a new key for this
        // file would also throw an exception, this key is unreachable.
        //
        return true;
      }
    }
  }

  private static LocalDateTime epochMillisToDateTime(long epochMillis,
                                                     ZoneId zone) {
    Objects.requireNonNull(zone);
    Instant instant = Instant.ofEpochMilli(epochMillis);
    return LocalDateTime.ofInstant(instant, zone);
  }

  private static String formatDuration(Duration duration) {
    long seconds = duration.toSeconds();
    long minutes = seconds / 60;
    long hours = minutes / 60;
    seconds %= 60;
    minutes %= 60;

    if (minutes >= 30)
      hours++;

    if (seconds >= 30)
      minutes++;

    if (hours > 0)
      return "~"
          + NumberFormat.getIntegerInstance(Locale.ROOT).format(hours)
          + " hour"
          + ((hours == 1) ? "" : "s");

    if (minutes > 0)
      return "~"
          + NumberFormat.getIntegerInstance(Locale.ROOT).format(minutes)
          + " minute"
          + ((minutes == 1) ? "" : "s");

    return "< 1 minute";
  }

  /**
   * {@code true} if the message looks like a timestamp in the {@link
   * Results#completed} map.
   *
   * @param message a value from the {@link Results#completed} map
   * @return {@code true} if the value is a timestamp, indicating that the
   *         framework started and stopped correctly, or {@code false} if the
   *         message is an error message, indicating that the framework did not
   *         start or stop correctly
   */
  private static boolean isCompletedTimestamp(String message) {
    Objects.requireNonNull(message);
    try {
      LocalDateTime.parse(message, COMPLETED_TIMESTAMP_FORMATTER);
      return true;
    } catch (DateTimeParseException ignored) {
      return false;
    }
  }

  private static final DateTimeFormatter COMPLETED_TIMESTAMP_FORMATTER =
      DateTimeFormatter.ofPattern("yyyyMMddHHmmss", Locale.ROOT);

  /**
   * The ordering of results displayed on the home page.
   */
  //
  // In practice, the results files are named like this:
  //
  //   results.{uploaded_at_date_time}.{json|zip}
  //
  // where {uploaded_at_date_time} is in the format "yyyy-MM-dd-HH-mm-ss-SSS".
  //
  // Therefore, sorting by file name effectively sorts the results by when they
  // were uploaded, and this comparator puts the most recently uploaded results
  // first.
  //
  private static final Comparator<ResultsView> RESULTS_COMPARATOR =
      comparing(
          results -> {
            if (results.json != null)
              return results.json.fileName;

            else if (results.zip != null)
              return results.zip.fileName;

            else
              return "";
          },
          reverseOrder());
}