milo/frontend/resultui/src/context/build_state.ts - infra/luci/luci-go - Git at Google

 // Copyright 2020 The LUCI Authors.
 //
 // 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 { autorun, computed, observable } from 'mobx';
 import { fromPromise, IPromiseBasedObservable } from 'mobx-utils';

 import { getGitilesRepoURL, renderBuildBugTemplate } from '../libs/build_utils';
 import { createContextLink } from '../libs/context';
 import * as iter from '../libs/iter_utils';
 import { unwrapObservable } from '../libs/utils';
 import { BuildExt } from '../models/build_ext';
 import {
   Build,
   BUILD_FIELD_MASK,
   BuilderID,
   BuilderItem,
   GetBuildRequest,
   GitilesCommit,
   SEARCH_BUILD_FIELD_MASK,
 } from '../services/buildbucket';
 import { Project, QueryBlamelistRequest, QueryBlamelistResponse } from '../services/milo_internal';
 import { getInvIdFromBuildId, getInvIdFromBuildNum } from '../services/resultdb';
 import { AppState } from './app_state';

 /**
  * Records state of a build.
  */
 export class BuildState {
   @observable.ref builderIdParam?: BuilderID;
   @observable.ref buildNumOrIdParam?: string;

   /**
    * Indicates whether a computed invocation ID should be used.
    * Computed invocation ID may not work on older builds.
    */
   @observable.ref useComputedInvId = true;

   @computed get builderId() {
     return this.builderIdParam || this.build?.builder;
   }

   /**
    * buildNum is defined when this.buildNumOrId is defined and doesn't start
    * with 'b'.
    */
   @computed get buildNum() {
     return this.buildNumOrIdParam?.startsWith('b') === false ? Number(this.buildNumOrIdParam) : null;
   }

   /**
    * buildId is defined when this.buildNumOrId is defined and starts with 'b',
    * or we have a matching cached build ID in appState.
    */
   @computed get buildId() {
     const cached =
       this.builderIdParam && this.buildNum !== null
         ? this.appState.getBuildId(this.builderIdParam, this.buildNum)
         : null;
     return cached || (this.buildNumOrIdParam?.startsWith('b') ? this.buildNumOrIdParam.slice(1) : null);
   }

   @computed private get invocationId$(): IPromiseBasedObservable<string> {
     if (!this.useComputedInvId) {
       if (this.build === null) {
         return fromPromise(Promise.race([]));
       }
       const invIdFromBuild = this.build.infra?.resultdb?.invocation?.slice('invocations/'.length) || '';
       return fromPromise(Promise.resolve(invIdFromBuild));
     } else if (this.buildId) {
       // Favor ID over builder + number to ensure cache hit when the build page
       // is redirected from a short build link to a long build link.
       return fromPromise(Promise.resolve(getInvIdFromBuildId(this.buildId)));
     } else if (this.builderIdParam && this.buildNum) {
       return fromPromise(getInvIdFromBuildNum(this.builderIdParam, this.buildNum));
     } else {
       return fromPromise(Promise.race([]));
     }
   }

   @computed get invocationId() {
     return unwrapObservable(this.invocationId$, null);
   }

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

   constructor(private appState: AppState) {
     this.disposers.push(
       autorun(() => {
         if (!this.build) {
           return;
         }

         // If the associated gitiles commit is in the blamelist pins, select it.
         // Otherwise, select the first blamelist pin.
         const buildInputCommitRepo = this.build.associatedGitilesCommit
           ? getGitilesRepoURL(this.build.associatedGitilesCommit)
           : null;
         let selectedBlamelistPinIndex =
           this.build.blamelistPins.findIndex((pin) => getGitilesRepoURL(pin) === buildInputCommitRepo) || 0;
         if (selectedBlamelistPinIndex === -1) {
           selectedBlamelistPinIndex = 0;
         }
         this.selectedBlamelistPinIndex = selectedBlamelistPinIndex;
       })
     );
   }

   @observable.ref private isDisposed = false;

   /**
    * Perform cleanup.
    * Must be called before the object is GCed.
    */
   dispose() {
     this.isDisposed = true;

     // Evaluates @computed({keepAlive: true}) properties after this.isDisposed
     // is set to true so they no longer subscribes to any external observable.
     this.build$;
     this.relatedBuilds$;
     this.queryBlamelistResIterFns;
     this.permittedActions$;
     this.projectCfg$;

     this.disposers.reverse().forEach((disposer) => disposer());
     this.disposers = [];
   }

   private buildQueryTime = this.appState.timestamp;
   @computed({ keepAlive: true })
   private get build$(): IPromiseBasedObservable<BuildExt> {
     if (
       this.isDisposed ||
       !this.appState.buildsService ||
       (!this.buildId && (!this.builderIdParam || !this.buildNum))
     ) {
       // Returns a promise that never resolves when the dependencies aren't
       // ready.
       return fromPromise(Promise.race([]));
     }

     // If we use a simple boolean property here,
     // 1. the boolean property cannot be an observable because we don't want to
     // update observables in a computed property, and
     // 2. we still need an observable (like this.timestamp) to trigger the
     // update, and
     // 3. this.refresh() will need to reset the boolean properties of all
     // time-sensitive computed value.
     //
     // If we record the query time instead, no other code will need to read
     // or update the query time.
     const cacheOpt = {
       acceptCache: this.buildQueryTime >= this.appState.timestamp,
     };
     this.buildQueryTime = this.appState.timestamp;

     // Favor ID over builder + number to ensure cache hit when the build page is
     // redirected from a short build link to a long build link.
     const req: GetBuildRequest = this.buildId
       ? { id: this.buildId, fields: BUILD_FIELD_MASK }
       : { builder: this.builderIdParam, buildNumber: this.buildNum!, fields: BUILD_FIELD_MASK };

     return fromPromise(this.appState.buildsService.getBuild(req, cacheOpt).then((b) => new BuildExt(b)));
   }

   @computed
   get build(): BuildExt | null {
     return unwrapObservable(this.build$, null);
   }

   @computed({ keepAlive: true })
   private get relatedBuilds$(): IPromiseBasedObservable<readonly BuildExt[]> {
     if (this.isDisposed || !this.build) {
       return fromPromise(Promise.race([]));
     }

     const buildsPromises = this.build.buildSets
       // Remove the commit/git/ buildsets because we know they're redundant with
       // the commit/gitiles/ buildsets, and we don't need to ask Buildbucket
       // twice.
       .filter((b) => !b.startsWith('commit/git/'))
       .map((b) =>
         this.appState
           .buildsService!.searchBuilds({
             predicate: { tags: [{ key: 'buildset', value: b }] },
             fields: SEARCH_BUILD_FIELD_MASK,
             pageSize: 1000,
           })
           .then((res) => res.builds)
       );

     return fromPromise(
       Promise.all(buildsPromises).then((buildArrays) => {
         const buildMap = new Map<string, Build>();
         for (const builds of buildArrays) {
           for (const build of builds) {
             // Filter out duplicate builds by overwriting them.
             buildMap.set(build.id, build);
           }
         }
         return [...buildMap.values()]
           .sort((b1, b2) => (b1.id.length === b2.id.length ? b1.id.localeCompare(b2.id) : b1.id.length - b2.id.length))
           .map((b) => new BuildExt(b));
       })
     );
   }

   @computed
   get relatedBuilds(): readonly BuildExt[] | null {
     return unwrapObservable(this.relatedBuilds$, null);
   }

   @observable.ref selectedBlamelistPinIndex = 0;

   private getQueryBlamelistResIterFn(gitilesCommit: GitilesCommit, multiProjectSupport = false) {
     if (!this.appState.milo || !this.build) {
       // eslint-disable-next-line require-yield
       return async function* () {
         await Promise.race([]);
       };
     }
     let req: QueryBlamelistRequest = {
       gitilesCommit,
       builder: this.build.builder,
       multiProjectSupport,
     };
     const milo = this.appState.milo;
     async function* streamBlamelist() {
       let res: QueryBlamelistResponse;
       do {
         res = await milo.queryBlamelist(req);
         req = { ...req, pageToken: res.nextPageToken };
         yield res;
       } while (res.nextPageToken);
     }
     return iter.teeAsync(streamBlamelist());
   }

   @computed
   private get gitilesCommitRepo() {
     if (!this.build?.associatedGitilesCommit) {
       return null;
     }
     return getGitilesRepoURL(this.build.associatedGitilesCommit);
   }

   @computed({ keepAlive: true })
   get queryBlamelistResIterFns() {
     if (this.isDisposed || !this.build) {
       return [];
     }

     return this.build.blamelistPins.map((pin) => {
       const pinRepo = getGitilesRepoURL(pin);
       return this.getQueryBlamelistResIterFn(pin, pinRepo !== this.gitilesCommitRepo);
     });
   }

   @computed({ keepAlive: true })
   private get builder$() {
     // We should not merge this with the if statement below because no other
     // observables should be accessed when this.isDisposed is set to true.
     if (this.isDisposed) {
       return fromPromise(Promise.race([]));
     }

     if (!this.appState.buildersService || !this.builderId) {
       return fromPromise(Promise.race([]));
     }
     return fromPromise(this.appState.buildersService.getBuilder({ id: this.builderId }));
   }

   @computed
   get builder(): BuilderItem | null {
     return unwrapObservable(this.builder$, null);
   }

   @computed private get bucketResourceId() {
     if (!this.builderId) {
       return null;
     }
     return `luci.${this.builderId.project}.${this.builderId.bucket}`;
   }

   @computed({ keepAlive: true })
   private get permittedActions$() {
     if (this.isDisposed || !this.appState.accessService || !this.bucketResourceId) {
       // Returns a promise that never resolves when the dependencies aren't
       // ready.
       return fromPromise(Promise.race([]));
     }

     // Establish a dependency on the timestamp.
     this.appState.timestamp;

     return fromPromise(
       this.appState.accessService?.permittedActions({
         resourceKind: 'bucket',
         resourceIds: [this.bucketResourceId],
       })
     );
   }

   @computed
   get permittedActions(): Set<string> {
     const permittedActionRes = unwrapObservable(this.permittedActions$, null);
     return new Set(permittedActionRes?.permitted[this.bucketResourceId!].actions || []);
   }

   @computed({ keepAlive: true })
   private get projectCfg$() {
     if (this.isDisposed || !this.appState.milo || !this.builderId?.project) {
       // Returns a promise that never resolves when the dependencies aren't
       // ready.
       return fromPromise(Promise.race([]));
     }

     // Establishes a dependency on the timestamp.
     this.appState.timestamp;

     return fromPromise(
       this.appState.milo.getProjectCfg({
         project: this.builderId.project,
       })
     );
   }

   @computed
   private get projectCfg(): Project | null {
     return unwrapObservable(this.projectCfg$, null);
   }

   @computed
   get customBugLink(): string | null {
     const bugTemplate = this.projectCfg?.buildBugTemplate;
     if (!bugTemplate?.monorailProject || !this.build) {
       return null;
     }
     const components = bugTemplate.components?.join(',');
     const searchParam = new URLSearchParams({
       summary: renderBuildBugTemplate(bugTemplate.summary || '', this.build),
       description: renderBuildBugTemplate(bugTemplate.description || '', this.build),
       ...(components ? { components } : {}),
     });
     return `https://bugs.chromium.org/p/${bugTemplate.monorailProject}/issues/entry?${searchParam}`;
   }
 }

 export const [provideBuildState, consumeBuildState] = createContextLink<BuildState>();
	// Copyright 2020 The LUCI Authors.
	//
	// 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 { autorun, computed, observable } from 'mobx';
	import { fromPromise, IPromiseBasedObservable } from 'mobx-utils';

	import { getGitilesRepoURL, renderBuildBugTemplate } from '../libs/build_utils';
	import { createContextLink } from '../libs/context';
	import * as iter from '../libs/iter_utils';
	import { unwrapObservable } from '../libs/utils';
	import { BuildExt } from '../models/build_ext';
	import {
	Build,
	BUILD_FIELD_MASK,
	BuilderID,
	BuilderItem,
	GetBuildRequest,
	GitilesCommit,
	SEARCH_BUILD_FIELD_MASK,
	} from '../services/buildbucket';
	import { Project, QueryBlamelistRequest, QueryBlamelistResponse } from '../services/milo_internal';
	import { getInvIdFromBuildId, getInvIdFromBuildNum } from '../services/resultdb';
	import { AppState } from './app_state';

	/**
	* Records state of a build.
	*/
	export class BuildState {
	@observable.ref builderIdParam?: BuilderID;
	@observable.ref buildNumOrIdParam?: string;

	/**
	* Indicates whether a computed invocation ID should be used.
	* Computed invocation ID may not work on older builds.
	*/
	@observable.ref useComputedInvId = true;

	@computed get builderId() {
	return this.builderIdParam \|\| this.build?.builder;
	}

	/**
	* buildNum is defined when this.buildNumOrId is defined and doesn't start
	* with 'b'.
	*/
	@computed get buildNum() {
	return this.buildNumOrIdParam?.startsWith('b') === false ? Number(this.buildNumOrIdParam) : null;
	}

	/**
	* buildId is defined when this.buildNumOrId is defined and starts with 'b',
	* or we have a matching cached build ID in appState.
	*/
	@computed get buildId() {
	const cached =
	this.builderIdParam && this.buildNum !== null
	? this.appState.getBuildId(this.builderIdParam, this.buildNum)
	: null;
	return cached \|\| (this.buildNumOrIdParam?.startsWith('b') ? this.buildNumOrIdParam.slice(1) : null);
	}

	@computed private get invocationId$(): IPromiseBasedObservable<string> {
	if (!this.useComputedInvId) {
	if (this.build === null) {
	return fromPromise(Promise.race([]));
	}
	const invIdFromBuild = this.build.infra?.resultdb?.invocation?.slice('invocations/'.length) \|\| '';
	return fromPromise(Promise.resolve(invIdFromBuild));
	} else if (this.buildId) {
	// Favor ID over builder + number to ensure cache hit when the build page
	// is redirected from a short build link to a long build link.
	return fromPromise(Promise.resolve(getInvIdFromBuildId(this.buildId)));
	} else if (this.builderIdParam && this.buildNum) {
	return fromPromise(getInvIdFromBuildNum(this.builderIdParam, this.buildNum));
	} else {
	return fromPromise(Promise.race([]));
	}
	}

	@computed get invocationId() {
	return unwrapObservable(this.invocationId$, null);
	}

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

	constructor(private appState: AppState) {
	this.disposers.push(
	autorun(() => {
	if (!this.build) {
	return;
	}

	// If the associated gitiles commit is in the blamelist pins, select it.
	// Otherwise, select the first blamelist pin.
	const buildInputCommitRepo = this.build.associatedGitilesCommit
	? getGitilesRepoURL(this.build.associatedGitilesCommit)
	: null;
	let selectedBlamelistPinIndex =
	this.build.blamelistPins.findIndex((pin) => getGitilesRepoURL(pin) === buildInputCommitRepo) \|\| 0;
	if (selectedBlamelistPinIndex === -1) {
	selectedBlamelistPinIndex = 0;
	}
	this.selectedBlamelistPinIndex = selectedBlamelistPinIndex;
	})
	);
	}

	@observable.ref private isDisposed = false;

	/**
	* Perform cleanup.
	* Must be called before the object is GCed.
	*/
	dispose() {
	this.isDisposed = true;

	// Evaluates @computed({keepAlive: true}) properties after this.isDisposed
	// is set to true so they no longer subscribes to any external observable.
	this.build$;
	this.relatedBuilds$;
	this.queryBlamelistResIterFns;
	this.permittedActions$;
	this.projectCfg$;

	this.disposers.reverse().forEach((disposer) => disposer());
	this.disposers = [];
	}

	private buildQueryTime = this.appState.timestamp;
	@computed({ keepAlive: true })
	private get build$(): IPromiseBasedObservable<BuildExt> {
	if (
	this.isDisposed \|\|
	!this.appState.buildsService \|\|
	(!this.buildId && (!this.builderIdParam \|\| !this.buildNum))
	) {
	// Returns a promise that never resolves when the dependencies aren't
	// ready.
	return fromPromise(Promise.race([]));
	}

	// If we use a simple boolean property here,
	// 1. the boolean property cannot be an observable because we don't want to
	// update observables in a computed property, and
	// 2. we still need an observable (like this.timestamp) to trigger the
	// update, and
	// 3. this.refresh() will need to reset the boolean properties of all
	// time-sensitive computed value.
	//
	// If we record the query time instead, no other code will need to read
	// or update the query time.
	const cacheOpt = {
	acceptCache: this.buildQueryTime >= this.appState.timestamp,
	};
	this.buildQueryTime = this.appState.timestamp;

	// Favor ID over builder + number to ensure cache hit when the build page is
	// redirected from a short build link to a long build link.
	const req: GetBuildRequest = this.buildId
	? { id: this.buildId, fields: BUILD_FIELD_MASK }
	: { builder: this.builderIdParam, buildNumber: this.buildNum!, fields: BUILD_FIELD_MASK };

	return fromPromise(this.appState.buildsService.getBuild(req, cacheOpt).then((b) => new BuildExt(b)));
	}

	@computed
	get build(): BuildExt \| null {
	return unwrapObservable(this.build$, null);
	}

	@computed({ keepAlive: true })
	private get relatedBuilds$(): IPromiseBasedObservable<readonly BuildExt[]> {
	if (this.isDisposed \|\| !this.build) {
	return fromPromise(Promise.race([]));
	}

	const buildsPromises = this.build.buildSets
	// Remove the commit/git/ buildsets because we know they're redundant with
	// the commit/gitiles/ buildsets, and we don't need to ask Buildbucket
	// twice.
	.filter((b) => !b.startsWith('commit/git/'))
	.map((b) =>
	this.appState
	.buildsService!.searchBuilds({
	predicate: { tags: [{ key: 'buildset', value: b }] },
	fields: SEARCH_BUILD_FIELD_MASK,
	pageSize: 1000,
	})
	.then((res) => res.builds)
	);

	return fromPromise(
	Promise.all(buildsPromises).then((buildArrays) => {
	const buildMap = new Map<string, Build>();
	for (const builds of buildArrays) {
	for (const build of builds) {
	// Filter out duplicate builds by overwriting them.
	buildMap.set(build.id, build);
	}
	}
	return [...buildMap.values()]
	.sort((b1, b2) => (b1.id.length === b2.id.length ? b1.id.localeCompare(b2.id) : b1.id.length - b2.id.length))
	.map((b) => new BuildExt(b));
	})
	);
	}

	@computed
	get relatedBuilds(): readonly BuildExt[] \| null {
	return unwrapObservable(this.relatedBuilds$, null);
	}

	@observable.ref selectedBlamelistPinIndex = 0;

	private getQueryBlamelistResIterFn(gitilesCommit: GitilesCommit, multiProjectSupport = false) {
	if (!this.appState.milo \|\| !this.build) {
	// eslint-disable-next-line require-yield
	return async function* () {
	await Promise.race([]);
	};
	}
	let req: QueryBlamelistRequest = {
	gitilesCommit,
	builder: this.build.builder,
	multiProjectSupport,
	};
	const milo = this.appState.milo;
	async function* streamBlamelist() {
	let res: QueryBlamelistResponse;
	do {
	res = await milo.queryBlamelist(req);
	req = { ...req, pageToken: res.nextPageToken };
	yield res;
	} while (res.nextPageToken);
	}
	return iter.teeAsync(streamBlamelist());
	}

	@computed
	private get gitilesCommitRepo() {
	if (!this.build?.associatedGitilesCommit) {
	return null;
	}
	return getGitilesRepoURL(this.build.associatedGitilesCommit);
	}

	@computed({ keepAlive: true })
	get queryBlamelistResIterFns() {
	if (this.isDisposed \|\| !this.build) {
	return [];
	}

	return this.build.blamelistPins.map((pin) => {
	const pinRepo = getGitilesRepoURL(pin);
	return this.getQueryBlamelistResIterFn(pin, pinRepo !== this.gitilesCommitRepo);
	});
	}

	@computed({ keepAlive: true })
	private get builder$() {
	// We should not merge this with the if statement below because no other
	// observables should be accessed when this.isDisposed is set to true.
	if (this.isDisposed) {
	return fromPromise(Promise.race([]));
	}

	if (!this.appState.buildersService \|\| !this.builderId) {
	return fromPromise(Promise.race([]));
	}
	return fromPromise(this.appState.buildersService.getBuilder({ id: this.builderId }));
	}

	@computed
	get builder(): BuilderItem \| null {
	return unwrapObservable(this.builder$, null);
	}

	@computed private get bucketResourceId() {
	if (!this.builderId) {
	return null;
	}
	return `luci.${this.builderId.project}.${this.builderId.bucket}`;
	}

	@computed({ keepAlive: true })
	private get permittedActions$() {
	if (this.isDisposed \|\| !this.appState.accessService \|\| !this.bucketResourceId) {
	// Returns a promise that never resolves when the dependencies aren't
	// ready.
	return fromPromise(Promise.race([]));
	}

	// Establish a dependency on the timestamp.
	this.appState.timestamp;

	return fromPromise(
	this.appState.accessService?.permittedActions({
	resourceKind: 'bucket',
	resourceIds: [this.bucketResourceId],
	})
	);
	}

	@computed
	get permittedActions(): Set<string> {
	const permittedActionRes = unwrapObservable(this.permittedActions$, null);
	return new Set(permittedActionRes?.permitted[this.bucketResourceId!].actions \|\| []);
	}

	@computed({ keepAlive: true })
	private get projectCfg$() {
	if (this.isDisposed \|\| !this.appState.milo \|\| !this.builderId?.project) {
	// Returns a promise that never resolves when the dependencies aren't
	// ready.
	return fromPromise(Promise.race([]));
	}

	// Establishes a dependency on the timestamp.
	this.appState.timestamp;

	return fromPromise(
	this.appState.milo.getProjectCfg({
	project: this.builderId.project,
	})
	);
	}

	@computed
	private get projectCfg(): Project \| null {
	return unwrapObservable(this.projectCfg$, null);
	}

	@computed
	get customBugLink(): string \| null {
	const bugTemplate = this.projectCfg?.buildBugTemplate;
	if (!bugTemplate?.monorailProject \|\| !this.build) {
	return null;
	}
	const components = bugTemplate.components?.join(',');
	const searchParam = new URLSearchParams({
	summary: renderBuildBugTemplate(bugTemplate.summary \|\| '', this.build),
	description: renderBuildBugTemplate(bugTemplate.description \|\| '', this.build),
	...(components ? { components } : {}),
	});
	return `https://bugs.chromium.org/p/${bugTemplate.monorailProject}/issues/entry?${searchParam}`;
	}
	}

	export const [provideBuildState, consumeBuildState] = createContextLink<BuildState>();