web/code-owners-fetcher.ts

/**
 * @license
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import {ChangeInfo} from '@gerritcodereview/typescript-api/rest-api.js';
import {RestPluginApi} from '@gerritcodereview/typescript-api/rest.js';
import {CodeOwnersApi, FetchedOwner, OwnerStatus} from './code-owners-api.js';
import {FileStatus} from './code-owners-model.js';

/**
 * @enum
 */
export const FetchStatus = {
  /** Fetch hasn't been started */
  NOT_STARTED: 0,
  /**
   * Fetch has been started, but not all files has been finished.
   * Pausing during fetching doesn't change state.
   */
  FETCHING: 1,
  /**
   * All owners has been loaded. resume/pause call doesn't change state.
   */
  FINISHED: 2,
};

/**
 * Fetch owners for files. The class fetches owners in parallel and allows to
 * pause/resume fetch.
 */
class OwnersFetcher {
  private paused = true;

  private fetchedOwners = new Map<string, FetchedOwner>();

  private pausedFilesFetcher: Array<() => void> = [];

  private fetchFilesPromises: Array<Promise<void>> = [];

  /**
   * Creates a fetcher in paused state. Actual fetching starts after resume()
   * is called.
   */
  constructor(
    private readonly codeOwnerApi: CodeOwnersApi,
    private readonly change: ChangeInfo,
    private readonly filesToFetch: Array<string>,
    private readonly ownersLimit: number,
    maxConcurrentRequest: number
  ) {
    for (let i = 0; i < maxConcurrentRequest; i++) {
      this.fetchFilesPromises.push(this.fetchFiles());
    }
  }

  private async fetchFiles() {
    for (;;) {
      const filePath = await this.getNextFilePath();
      if (!filePath) return;
      try {
        this.fetchedOwners.set(filePath, {
          owners: await this.codeOwnerApi.listOwnersForPath(
            this.change,
            filePath,
            this.ownersLimit
          ),
        });
      } catch (error) {
        this.fetchedOwners.set(filePath, {error});
      }
    }
  }

  private async getNextFilePath() {
    if (this.paused) {
      await new Promise<void>(resolve => this.pausedFilesFetcher.push(resolve));
    }
    if (this.filesToFetch.length === 0) return null;
    return this.filesToFetch.splice(0, 1)[0];
  }

  async waitFetchComplete() {
    // Simplified polyfill allSettled
    // TODO: Replace with allSettled once minimal node version is updated.
    await Promise.all(
      this.fetchFilesPromises.map(p =>
        p.then(() => 'succeeded').catch(_reason => 'rejected')
      )
    );
  }

  resume() {
    if (!this.paused) return;
    this.paused = false;
    for (const fetcher of this.pausedFilesFetcher.splice(
      0,
      this.pausedFilesFetcher.length
    )) {
      fetcher();
    }
  }

  pause() {
    this.paused = true;
  }

  getFetchedOwners() {
    return this.fetchedOwners;
  }

  getFiles(): Array<{path: string; info: FetchedOwner}> {
    const result = [];
    for (const [path, info] of this.fetchedOwners.entries()) {
      result.push({path, info});
    }
    return result;
  }
}

export class OwnersProvider {
  private status = FetchStatus.NOT_STARTED;

  private totalFetchCount = 0;

  private codeOwnerApi: CodeOwnersApi;

  private ownersFetcher?: OwnersFetcher;

  constructor(
    restApi: RestPluginApi,
    private readonly change: ChangeInfo,
    private readonly options: {
      maxConcurrentRequests: number;
      ownersLimit: number;
    }
  ) {
    this.codeOwnerApi = new CodeOwnersApi(restApi);
  }

  getStatus() {
    return this.status;
  }

  getProgressString() {
    return !this.ownersFetcher || this.totalFetchCount === 0
      ? 'Loading suggested owners ...'
      : `${this.ownersFetcher.getFetchedOwners().size} out of ` +
          `${this.totalFetchCount} files have returned suggested owners.`;
  }

  getFiles() {
    if (!this.ownersFetcher) return [];
    return this.ownersFetcher.getFiles();
  }

  async fetchSuggestedOwners(codeOwnerStatusMap: Map<string, FileStatus>) {
    if (this.status !== FetchStatus.NOT_STARTED) {
      await this.ownersFetcher!.waitFetchComplete();
      return;
    }
    const filesToFetch = this._getFilesToFetch(codeOwnerStatusMap);
    this.totalFetchCount = filesToFetch.length;
    this.ownersFetcher = new OwnersFetcher(
      this.codeOwnerApi,
      this.change,
      filesToFetch,
      this.options.ownersLimit,
      this.options.maxConcurrentRequests
    );
    this.status = FetchStatus.FETCHING;
    this.ownersFetcher.resume();
    await this.ownersFetcher.waitFetchComplete();
    this.status = FetchStatus.FINISHED;
  }

  _getFilesToFetch(codeOwnerStatusMap: Map<string, FileStatus>) {
    // only fetch those not approved yet
    const filesGroupByStatus = [...codeOwnerStatusMap.entries()].reduce(
      (list, [file, fileInfo]) => {
        if (list[fileInfo.status]) list[fileInfo.status].push(file);
        return list;
      },
      {
        [OwnerStatus.PENDING]: [] as Array<string>,
        [OwnerStatus.INSUFFICIENT_REVIEWERS]: [] as Array<string>,
        [OwnerStatus.APPROVED]: [] as Array<string>,
      }
    );
    // always fetch INSUFFICIENT_REVIEWERS first, then pending and then approved
    return filesGroupByStatus[OwnerStatus.INSUFFICIENT_REVIEWERS]
      .concat(filesGroupByStatus[OwnerStatus.PENDING])
      .concat(filesGroupByStatus[OwnerStatus.APPROVED]);
  }

  pause() {
    if (!this.ownersFetcher) return;
    this.ownersFetcher.pause();
  }

  resume() {
    if (!this.ownersFetcher) return;
    this.ownersFetcher.resume();
  }

  reset() {
    this.totalFetchCount = 0;
    this.ownersFetcher = undefined;
    this.status = FetchStatus.NOT_STARTED;
  }
}