4586898739

Build Type

push

github

Committed by Luca

Commit Message

- doNotCache default's is true - add vcpkg to PATH - code fix ups

Run Details

180 of 308 branches covered (58.44%)

Branch coverage included in aggregate %.

55 of 60 new or added lines in 2 files covered. (91.67%)

9 existing lines in 2 files now uncovered.

366 of 446 relevant lines covered (82.06%)

5.27 hits per line

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

77.36

/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(baseUtilLib: baseutillib.BaseUtilLib, keys: baseutillib.KeySet,
    hitCacheKey: string | null, cachedPaths: string[]): Promise<void> {
    const baseLib = baseUtilLib.baseLib;
    baseLib.debug(`saveCache(keys:${JSON.stringify(keys)},hitCacheKey:${hitCacheKey},cachedPaths:${cachedPaths})<<`)
    try {
      await baseUtilLib.wrapOp('Save vcpkg into the GitHub Action cache (only the tool, not the built packages which are saved by vcpkg`s Binary Caching on GitHub Action`s cache).',
        async () => {

          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'
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
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()<<`);	16✔
34	let id = undefined;	16✔
35	let isSubmodule = undefined;	16✔
36	const workspaceDir = process.env.GITHUB_WORKSPACE ?? "";	16✔
37	if (workspaceDir) {	16✔
38	let fullVcpkgPath = "";	14✔
39	baseUtils.baseLib.debug(`inputVcpkgPath=${vcpkgDirectory}`);	14✔
40	if (path.isAbsolute(vcpkgDirectory))	14!
41	fullVcpkgPath = path.normalize(path.resolve(vcpkgDirectory));	14✔
42	else
43	fullVcpkgPath = path.normalize(path.resolve(path.join(workspaceDir, vcpkgDirectory)));	×
44	baseUtils.baseLib.debug(`fullVcpkgPath='${fullVcpkgPath}'`);	14✔
45	const relPath = fullVcpkgPath.replace(workspaceDir, '');	14✔
46	baseUtils.baseLib.debug(`relPath='${relPath}'`);	14✔
47	const submodulePath = path.join(workspaceDir, ".git/modules", relPath, "HEAD")	14✔
48	baseUtils.baseLib.debug(`submodulePath='${submodulePath}'`);	14✔
49	// Check whether it is a submodule.
50	if (fs.existsSync(submodulePath)) {	14✔
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"))) {	12✔
55	id = await runvcpkglib.VcpkgRunner.getCommitId(baseUtils, fullVcpkgPath);	4✔
56	isSubmodule = false;	4✔
57	}
58	id = id?.trim();	14✔
59	}
60	baseUtils.baseLib.debug(`getVcpkgCommitId()>> -> [id=${id}, isSubmodule=${isSubmodule}]`);	16✔
61	return [id, isSubmodule];	16✔
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✔
73	} else if (vcpkgJsonPath.length > 1) {	×
74	baseUtil.baseLib.warning(`The file ${runvcpkglib.VCPKG_JSON} was found multiple times with glob expression '${vcpkgJsonGlob}'.`);	×
75	} else {
76	baseUtil.baseLib.warning(`The file ${runvcpkglib.VCPKG_JSON} was not found with glob expression '${vcpkgJsonGlob}'.`);	×
77	}
78	}
79	catch (err) {
80	if (err instanceof Error) {	×
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()<<`);	16✔
94	const cacheKeySegments: string[] = [];	16✔
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}`;	16!
98	firstSegment += process.env['ImageVersion'] \|\| "";	16!
99
100	const [commitId, isSubmodule] = await Utils.getVcpkgCommitId(baseUtilLib, vcpkgDirectory);	16✔
101	if (commitId) {	16✔
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) {	8✔
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.`);	6✔
116	}
117
118	cacheKeySegments.push(firstSegment);	16✔
119
120	const keyset: baseutillib.KeySet = baseutillib.createKeySet(cacheKeySegments);	16✔
121	baseUtilLib.baseLib.debug(`computeCacheKeys()>>`);	16✔
122	return keyset;	16✔
123	}
124
125	public static async saveCache(baseUtilLib: baseutillib.BaseUtilLib, keys: baseutillib.KeySet,
126	hitCacheKey: string \| null, cachedPaths: string[]): Promise<void> {
127	const baseLib = baseUtilLib.baseLib;	8✔
128	baseLib.debug(`saveCache(keys:${JSON.stringify(keys)},hitCacheKey:${hitCacheKey},cachedPaths:${cachedPaths})<<`)	8✔
129	try {	8✔
130	await baseUtilLib.wrapOp('Save vcpkg into the GitHub Action cache (only the tool, not the built packages which are saved by vcpkg`s Binary Caching on GitHub Action`s cache).',	8✔
131	async () => {	8✔
132
133	if (hitCacheKey && Utils.isExactKeyMatch(keys.primary, hitCacheKey)) {	8✔
134	baseLib.info(`Saving cache is skipped, because cache hit occurred on the cache key '${keys.primary}'.`);	2✔
135	} else {
136	baseLib.info(`Saving a new cache entry, because primary key was missed or a fallback restore key was hit.`);	6✔
137	const pathsToCache: string[] = cachedPaths;	6✔
138	baseLib.info(`Caching paths: '${pathsToCache}'`);	6✔
139
140	try {	6✔
141	baseLib.info(`Saving cache with primary key '${keys.primary}' ...`);	6✔
142	await cache.saveCache(pathsToCache, keys.primary);	6✔
143	}
144	catch (error) {
145	if (error instanceof Error) {	2!
146	if (error.name === cache.ValidationError.name) {	2!
NEW 147	throw error;	×
148	} else if (error.name === cache.ReserveCacheError.name) {	2!
NEW 149	baseLib.info(error.message);	×
150	} else {
151	baseLib.warning(error.message);	2✔
152	}
153	}
154	}
155	}
156	});
157	} catch (err) {
158	baseLib.warning("vcpkg-utils.saveCache() failed!");	×
159	if (err instanceof Error) {	×
160	baseLib.warning(err.name);	×
161	baseLib.warning(err.message);	×
162	if (err?.stack) {	×
163	baseLib.warning(err.stack);	×
164	}
165	}
166	}
167
168	baseLib.debug(`saveCache()>>`)	8✔
169	}
170
171	public static getAllCachedPaths(baseLib: baselib.BaseLib, vcpkgRootDir: string): string[] {
172	baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<<`);	16✔
173	let pathsToCache: string[] = runvcpkglib.getOrdinaryCachedPaths(vcpkgRootDir);	16✔
174
175	// Remove empty entries.
176	pathsToCache = pathsToCache.map(s => s.trim()).filter(Boolean);	16✔
177
178	// Remove duplicates.
179	const ps = [...new Set(pathsToCache)];	16✔
180
181	baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<< -> '${JSON.stringify(ps)}'`);	16✔
182	return ps;	16✔
183	}
184	}

lukka / run-vcpkg / 4586898739

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