4571974294

Build # 4571974294

Build Type

push

github

Committed by luca

Commit Message

run-vcpkg@v11: leverage BinaryCaching with GH Action's cache.

Run Details

180 of 308 branches covered (58.44%)

Branch coverage included in aggregate %.

33 of 38 new or added lines in 2 files covered. (86.84%)

17 existing lines in 2 files now uncovered.

352 of 432 relevant lines covered (81.48%)

5.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.64

/src/vcpkg-utils.ts

// Copyright (c) 2020-2021-2022-2023 Luca Cappa
// Released under the term specified in file LICENSE.txt
// SPDX short identifier: MIT

import * as path from 'path'
import * as fs from 'fs'
import * as runvcpkglib from '@lukka/run-vcpkg-lib'
import * as baselib from '@lukka/base-lib'
import * as baseutillib from '@lukka/base-util-lib'
import * as cache from '@actions/cache'
import * as fastglob from "fast-glob"
import { doNotCacheInput } from './vcpkg-action'

export class Utils {

  public static isExactKeyMatch(key: string, cacheKey?: string): boolean {
    if (cacheKey)
      return cacheKey.localeCompare(key, undefined, { sensitivity: "accent" }) === 0;
    else
      return false;
  }

  /**
   * Retrieve the commit id of the Git repository at vcpkgDirectory.
   * Returns [undefined, undefined] when the provided path is not the root of a Git repository.
   * @static
   * @param {baseutillib.BaseUtilLib} baseUtils
   * @param {string} vcpkgDirectory
   * @returns {(Promise<[string | undefined, boolean | undefined]>)}
   * @memberof Utils
   */
  public static async getVcpkgCommitId(baseUtils: baseutillib.BaseUtilLib, vcpkgDirectory: string): Promise<[string | undefined, boolean | undefined]> {
    baseUtils.baseLib.debug(`getVcpkgCommitId()<<`);
    let id = undefined;
    let isSubmodule = undefined;
    const workspaceDir = process.env.GITHUB_WORKSPACE ?? "";
    if (workspaceDir) {
      let fullVcpkgPath = "";
      baseUtils.baseLib.debug(`inputVcpkgPath=${vcpkgDirectory}`);
      if (path.isAbsolute(vcpkgDirectory))
        fullVcpkgPath = path.normalize(path.resolve(vcpkgDirectory));
      else
        fullVcpkgPath = path.normalize(path.resolve(path.join(workspaceDir, vcpkgDirectory)));
      baseUtils.baseLib.debug(`fullVcpkgPath='${fullVcpkgPath}'`);
      const relPath = fullVcpkgPath.replace(workspaceDir, '');
      baseUtils.baseLib.debug(`relPath='${relPath}'`);
      const submodulePath = path.join(workspaceDir, ".git/modules", relPath, "HEAD")
      baseUtils.baseLib.debug(`submodulePath='${submodulePath}'`);
      // Check whether it is a submodule.
      if (fs.existsSync(submodulePath)) {
        id = fs.readFileSync(submodulePath).toString();
        baseUtils.baseLib.debug(`commitId='${id}'`);
        isSubmodule = true;
      } else if (fs.existsSync(path.join(fullVcpkgPath, ".git"))) {
        id = await runvcpkglib.VcpkgRunner.getCommitId(baseUtils, fullVcpkgPath);
        isSubmodule = false;
      }
      id = id?.trim();
    }
    baseUtils.baseLib.debug(`getVcpkgCommitId()>> -> [id=${id}, isSubmodule=${isSubmodule}]`);
    return [id, isSubmodule];
  }

  public static async getVcpkgJsonPath(baseUtil: baseutillib.BaseUtilLib, vcpkgJsonGlob: string,
    vcpkgJsonIgnores: string[]): Promise<string | null> {
    baseUtil.baseLib.debug(`getVcpkgJsonPath(${vcpkgJsonGlob})<<`);
    let ret: string | null = null;
    try {
      const vcpkgJsonPath = await fastglob(vcpkgJsonGlob, { ignore: vcpkgJsonIgnores });
      if (vcpkgJsonPath?.length === 1) {
        baseUtil.baseLib.info(`Found ${runvcpkglib.VCPKG_JSON} at '${vcpkgJsonPath[0]}'.`);
        ret = vcpkgJsonPath[0];
      } else if (vcpkgJsonPath.length > 1) {
        baseUtil.baseLib.warning(`The file ${runvcpkglib.VCPKG_JSON} was found multiple times with glob expression '${vcpkgJsonGlob}'.`);
      } else {
        baseUtil.baseLib.warning(`The file ${runvcpkglib.VCPKG_JSON} was not found with glob expression '${vcpkgJsonGlob}'.`);
      }
    }
    catch (err) {
      if (err instanceof Error) {
        baseUtil.baseLib.warning(err.message);
      }
    }

    baseUtil.baseLib.debug(`getVcpkgJsonPath()>>`);
    return ret;
  }

  public static async computeCacheKeys(
    baseUtilLib: baseutillib.BaseUtilLib,
    vcpkgDirectory: string,
    userProvidedCommitId: string | null): Promise<baseutillib.KeySet> {
    baseUtilLib.baseLib.debug(`computeCacheKeys()<<`);
    const cacheKeySegments: string[] = [];

    // Add to the first segment of the key the values of env vars ImageOS and ImageVersion if available.
    let firstSegment = `runnerOS=${process.env['ImageOS'] ? process.env['ImageOS'] : process.platform}`;
    firstSegment += process.env['ImageVersion'] || "";

    const [commitId, isSubmodule] = await Utils.getVcpkgCommitId(baseUtilLib, vcpkgDirectory);
    if (commitId) {
      firstSegment += `-vcpkgGitCommit=${commitId}`;
      if (isSubmodule) {
        baseUtilLib.baseLib.info(`Adding vcpkg submodule Git commit id '${commitId}' to cache key`);
        if (userProvidedCommitId) {
          baseUtilLib.baseLib.warning(`The provided Git commit id is disregarded: '${userProvidedCommitId}'. Please remove it from the inputs.`);
        }
      } else {
        baseUtilLib.baseLib.info(`vcpkg identified at Git commit id '${commitId}', adding it to the cache's key.`);
      }
    } else if (userProvidedCommitId) {
      firstSegment += `-vcpkgGitCommit=${userProvidedCommitId}`;
      baseUtilLib.baseLib.info(`Adding user provided vcpkg's Git commit id '${userProvidedCommitId}' to cache key.`);
    } else {
      baseUtilLib.baseLib.info(`No vcpkg's commit id was provided, does not contribute to the cache's key.`);
    }

    cacheKeySegments.push(firstSegment);

    const keyset: baseutillib.KeySet = baseutillib.createKeySet(cacheKeySegments);
    baseUtilLib.baseLib.debug(`computeCacheKeys()>>`);
    return keyset;
  }

  public static async saveCache(baseLib: baselib.BaseLib, doNotCache: boolean, keys: baseutillib.KeySet,
    hitCacheKey: string | null, cachedPaths: string[]): Promise<void> {
    baseLib.debug(`saveCache(doNotCache:${doNotCache},keys:${JSON.stringify(keys)},hitCacheKey:${hitCacheKey},cachedPaths:${cachedPaths})<<`)
    try {
      if (doNotCache) {
        baseLib.info(`Skipping saving cache as caching is disabled (${doNotCacheInput}: ${doNotCache}).`);
      } else {
        if (hitCacheKey && Utils.isExactKeyMatch(keys.primary, hitCacheKey)) {
          baseLib.info(`Saving cache is skipped, because cache hit occurred on the cache key '${keys.primary}'.`);
        } else {
          baseLib.info(`Saving a new cache entry, because primary key was missed or a fallback restore key was hit.`);
          const pathsToCache: string[] = cachedPaths;
          baseLib.info(`Caching paths: '${pathsToCache}'`);

          try {
            baseLib.info(`Saving cache with primary key '${keys.primary}' ...`);
            await cache.saveCache(pathsToCache, keys.primary);
          }
          catch (error) {
            if (error instanceof Error) {
              if (error.name === cache.ValidationError.name) {
                throw error;
              } else if (error.name === cache.ReserveCacheError.name) {
                baseLib.info(error.message);
              } else {
                baseLib.warning(error.message);
              }
            }
          }
        }
      }
    } catch (err) {
      baseLib.warning("vcpkg-utils.saveCache() failed!");
      if (err instanceof Error) {
        baseLib.warning(err.name);
        baseLib.warning(err.message);
        if (err?.stack) {
          baseLib.warning(err.stack);
        }
      }
    }

    baseLib.debug(`saveCache()>>`)
  }

  public static getAllCachedPaths(baseLib: baselib.BaseLib, vcpkgRootDir: string): string[] {
    baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<<`);
    let pathsToCache: string[] = runvcpkglib.getOrdinaryCachedPaths(vcpkgRootDir);

    // Remove empty entries.
    pathsToCache = pathsToCache.map(s => s.trim()).filter(Boolean);

    // Remove duplicates.
    const ps = [...new Set(pathsToCache)];

    baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<< -> '${JSON.stringify(ps)}'`);
    return ps;
  }
}

1	// Copyright (c) 2020-2021-2022-2023 Luca Cappa
2	// Released under the term specified in file LICENSE.txt
3	// SPDX short identifier: MIT
4
5	import * as path from 'path'	2✔
6	import * as fs from 'fs'	2✔
7	import * as runvcpkglib from '@lukka/run-vcpkg-lib'	2✔
8	import * as baselib from '@lukka/base-lib'
9	import * as baseutillib from '@lukka/base-util-lib'	2✔
10	import * as cache from '@actions/cache'	2✔
11	import * as fastglob from "fast-glob"	2✔
12	import { doNotCacheInput } from './vcpkg-action'	2✔
13
14	export class Utils {	2✔
15
16	public static isExactKeyMatch(key: string, cacheKey?: string): boolean {
17	if (cacheKey)	8!
18	return cacheKey.localeCompare(key, undefined, { sensitivity: "accent" }) === 0;	8✔
19	else
UNCOV 20	return false;	×
21	}
22
23	/**
24	* Retrieve the commit id of the Git repository at vcpkgDirectory.
25	* Returns [undefined, undefined] when the provided path is not the root of a Git repository.
26	* @static
27	* @param {baseutillib.BaseUtilLib} baseUtils
28	* @param {string} vcpkgDirectory
29	* @returns {(Promise<[string \| undefined, boolean \| undefined]>)}
30	* @memberof Utils
31	*/
32	public static async getVcpkgCommitId(baseUtils: baseutillib.BaseUtilLib, vcpkgDirectory: string): Promise<[string \| undefined, boolean \| undefined]> {
33	baseUtils.baseLib.debug(`getVcpkgCommitId()<<`);	18✔
34	let id = undefined;	18✔
35	let isSubmodule = undefined;	18✔
36	const workspaceDir = process.env.GITHUB_WORKSPACE ?? "";	18✔
37	if (workspaceDir) {	18✔
38	let fullVcpkgPath = "";	16✔
39	baseUtils.baseLib.debug(`inputVcpkgPath=${vcpkgDirectory}`);	16✔
40	if (path.isAbsolute(vcpkgDirectory))	16!
41	fullVcpkgPath = path.normalize(path.resolve(vcpkgDirectory));	16✔
42	else
UNCOV 43	fullVcpkgPath = path.normalize(path.resolve(path.join(workspaceDir, vcpkgDirectory)));	×
44	baseUtils.baseLib.debug(`fullVcpkgPath='${fullVcpkgPath}'`);	16✔
45	const relPath = fullVcpkgPath.replace(workspaceDir, '');	16✔
46	baseUtils.baseLib.debug(`relPath='${relPath}'`);	16✔
47	const submodulePath = path.join(workspaceDir, ".git/modules", relPath, "HEAD")	16✔
48	baseUtils.baseLib.debug(`submodulePath='${submodulePath}'`);	16✔
49	// Check whether it is a submodule.
50	if (fs.existsSync(submodulePath)) {	16✔
51	id = fs.readFileSync(submodulePath).toString();	2✔
52	baseUtils.baseLib.debug(`commitId='${id}'`);	2✔
53	isSubmodule = true;	2✔
54	} else if (fs.existsSync(path.join(fullVcpkgPath, ".git"))) {	14✔
55	id = await runvcpkglib.VcpkgRunner.getCommitId(baseUtils, fullVcpkgPath);	4✔
56	isSubmodule = false;	4✔
57	}
58	id = id?.trim();	16✔
59	}
60	baseUtils.baseLib.debug(`getVcpkgCommitId()>> -> [id=${id}, isSubmodule=${isSubmodule}]`);	18✔
61	return [id, isSubmodule];	18✔
62	}
63
64	public static async getVcpkgJsonPath(baseUtil: baseutillib.BaseUtilLib, vcpkgJsonGlob: string,
65	vcpkgJsonIgnores: string[]): Promise<string \| null> {
66	baseUtil.baseLib.debug(`getVcpkgJsonPath(${vcpkgJsonGlob})<<`);	10✔
67	let ret: string \| null = null;	10✔
68	try {	10✔
69	const vcpkgJsonPath = await fastglob(vcpkgJsonGlob, { ignore: vcpkgJsonIgnores });	10✔
70	if (vcpkgJsonPath?.length === 1) {	10!
71	baseUtil.baseLib.info(`Found ${runvcpkglib.VCPKG_JSON} at '${vcpkgJsonPath[0]}'.`);	10✔
72	ret = vcpkgJsonPath[0];	10✔
NEW 73	} else if (vcpkgJsonPath.length > 1) {	×
NEW 74	baseUtil.baseLib.warning(`The file ${runvcpkglib.VCPKG_JSON} was found multiple times with glob expression '${vcpkgJsonGlob}'.`);	×
75	} else {
NEW 76	baseUtil.baseLib.warning(`The file ${runvcpkglib.VCPKG_JSON} was not found with glob expression '${vcpkgJsonGlob}'.`);	×
77	}
78	}
79	catch (err) {
UNCOV 80	if (err instanceof Error) {	×
UNCOV 81	baseUtil.baseLib.warning(err.message);	×
82	}
83	}
84
85	baseUtil.baseLib.debug(`getVcpkgJsonPath()>>`);	10✔
86	return ret;	10✔
87	}
88
89	public static async computeCacheKeys(
90	baseUtilLib: baseutillib.BaseUtilLib,
91	vcpkgDirectory: string,
92	userProvidedCommitId: string \| null): Promise<baseutillib.KeySet> {
93	baseUtilLib.baseLib.debug(`computeCacheKeys()<<`);	18✔
94	const cacheKeySegments: string[] = [];	18✔
95
96	// Add to the first segment of the key the values of env vars ImageOS and ImageVersion if available.
97	let firstSegment = `runnerOS=${process.env['ImageOS'] ? process.env['ImageOS'] : process.platform}`;	18!
98	firstSegment += process.env['ImageVersion'] \|\| "";	18!
99
100	const [commitId, isSubmodule] = await Utils.getVcpkgCommitId(baseUtilLib, vcpkgDirectory);	18✔
101	if (commitId) {	18✔
102	firstSegment += `-vcpkgGitCommit=${commitId}`;	8✔
103	if (isSubmodule) {	8✔
104	baseUtilLib.baseLib.info(`Adding vcpkg submodule Git commit id '${commitId}' to cache key`);	4✔
105	if (userProvidedCommitId) {	4✔
106	baseUtilLib.baseLib.warning(`The provided Git commit id is disregarded: '${userProvidedCommitId}'. Please remove it from the inputs.`);	2✔
107	}
108	} else {
109	baseUtilLib.baseLib.info(`vcpkg identified at Git commit id '${commitId}', adding it to the cache's key.`);	4✔
110	}
111	} else if (userProvidedCommitId) {	10✔
112	firstSegment += `-vcpkgGitCommit=${userProvidedCommitId}`;	2✔
113	baseUtilLib.baseLib.info(`Adding user provided vcpkg's Git commit id '${userProvidedCommitId}' to cache key.`);	2✔
114	} else {
115	baseUtilLib.baseLib.info(`No vcpkg's commit id was provided, does not contribute to the cache's key.`);	8✔
116	}
117
118	cacheKeySegments.push(firstSegment);	18✔
119
120	const keyset: baseutillib.KeySet = baseutillib.createKeySet(cacheKeySegments);	18✔
121	baseUtilLib.baseLib.debug(`computeCacheKeys()>>`);	18✔
122	return keyset;	18✔
123	}
124
125	public static async saveCache(baseLib: baselib.BaseLib, doNotCache: boolean, keys: baseutillib.KeySet,
126	hitCacheKey: string \| null, cachedPaths: string[]): Promise<void> {
127	baseLib.debug(`saveCache(doNotCache:${doNotCache},keys:${JSON.stringify(keys)},hitCacheKey:${hitCacheKey},cachedPaths:${cachedPaths})<<`)	10✔
128	try {	10✔
129	if (doNotCache) {	10✔
130	baseLib.info(`Skipping saving cache as caching is disabled (${doNotCacheInput}: ${doNotCache}).`);	2✔
131	} else {
132	if (hitCacheKey && Utils.isExactKeyMatch(keys.primary, hitCacheKey)) {	8✔
133	baseLib.info(`Saving cache is skipped, because cache hit occurred on the cache key '${keys.primary}'.`);	2✔
134	} else {
135	baseLib.info(`Saving a new cache entry, because primary key was missed or a fallback restore key was hit.`);	6✔
136	const pathsToCache: string[] = cachedPaths;	6✔
137	baseLib.info(`Caching paths: '${pathsToCache}'`);	6✔
138
139	try {	6✔
140	baseLib.info(`Saving cache with primary key '${keys.primary}' ...`);	6✔
141	await cache.saveCache(pathsToCache, keys.primary);	6✔
142	}
143	catch (error) {
144	if (error instanceof Error) {	2!
145	if (error.name === cache.ValidationError.name) {	2!
UNCOV 146	throw error;	×
147	} else if (error.name === cache.ReserveCacheError.name) {	2!
UNCOV 148	baseLib.info(error.message);	×
149	} else {
150	baseLib.warning(error.message);	2✔
151	}
152	}
153	}
154	}
155	}
156	} catch (err) {
UNCOV 157	baseLib.warning("vcpkg-utils.saveCache() failed!");	×
UNCOV 158	if (err instanceof Error) {	×
UNCOV 159	baseLib.warning(err.name);	×
UNCOV 160	baseLib.warning(err.message);	×
UNCOV 161	if (err?.stack) {	×
UNCOV 162	baseLib.warning(err.stack);	×
163	}
164	}
165	}
166
167	baseLib.debug(`saveCache()>>`)	10✔
168	}
169
170	public static getAllCachedPaths(baseLib: baselib.BaseLib, vcpkgRootDir: string): string[] {
171	baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<<`);	18✔
172	let pathsToCache: string[] = runvcpkglib.getOrdinaryCachedPaths(vcpkgRootDir);	18✔
173
174	// Remove empty entries.
175	pathsToCache = pathsToCache.map(s => s.trim()).filter(Boolean);	18✔
176
177	// Remove duplicates.
178	const ps = [...new Set(pathsToCache)];	18✔
179
180	baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<< -> '${JSON.stringify(ps)}'`);	18✔
181	return ps;	18✔
182	}
183	}

lukka / run-vcpkg / 4571974294

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous