github/codeql-action
1
0
Fork 0
mirror of https://github.com/github/codeql-action.git synced 2026-10-21 02:01:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move start-proxy status report handling into its own file

Browse Source
This commit is contained in:
Michael B. Gale
2026-10-13 18:59:11 +01:00
parent eb94de7c5c
commit aa80ca0686
5 changed files with 305 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
lib/entry-points.js generated
View File

@@ -187524,11 +187524,72 @@ var core25 = __toESM(require_core());
// src/start-proxy.ts
var path27 = __toESM(require("path"));
var core24 = __toESM(require_core());
var toolcache4 = __toESM(require_tool_cache());
// src/start-proxy/validation.ts
// src/start-proxy/status-report.ts
var core23 = __toESM(require_core());
async function sendSuccessStatusReport(startedAt, config, registry_types, logger2) {
const statusReportBase = await createStatusReportBase(
"start-proxy" /* StartProxy */,
"success",
startedAt,
config,
await checkDiskUsage(logger2),
logger2
);
if (statusReportBase !== void 0) {
const statusReport = {
...statusReportBase,
registry_types: registry_types.join(",")
};
await sendStatusReport(statusReport);
}
}
function getStartProxyErrorMessage(errorType) {
switch (errorType) {
case 0 /* DownloadFailed */:
return "Failed to download proxy archive.";
case 1 /* ExtractionFailed */:
return "Failed to extract proxy archive.";
case 2 /* CacheFailed */:
return "Failed to add proxy to toolcache";
}
}
var StartProxyError = class extends Error {
errorType;
constructor(errorType) {
super();
this.errorType = errorType;
}
};
function getSafeErrorMessage(error3) {
if (error3 instanceof StartProxyError) {
return getStartProxyErrorMessage(error3.errorType);
}
return `Error from start-proxy Action omitted (${error3.constructor.name}).`;
}
async function sendFailedStatusReport(logger2, startedAt, language, unwrappedError) {
const error3 = wrapError(unwrappedError);
core23.setFailed(`start-proxy action failed: ${error3.message}`);
const statusReportMessage = getSafeErrorMessage(error3);
const errorStatusReportBase = await createStatusReportBase(
"start-proxy" /* StartProxy */,
getActionsStatus(error3),
startedAt,
{
languages: language === void 0 ? void 0 : [language]
},
await checkDiskUsage(logger2),
logger2,
statusReportMessage
);
if (errorStatusReportBase !== void 0) {
await sendStatusReport(errorStatusReportBase);
}
}
// src/start-proxy/validation.ts
var core24 = __toESM(require_core());
function cloneCredential(schema, obj) {
const result = {};
for (const key of Object.keys(schema)) {
@@ -187547,14 +187608,14 @@ function getAuthConfig(config) {
}
if (isToken(config)) {
if (isDefined2(config.token)) {
core23.setSecret(config.token);
core24.setSecret(config.token);
}
return cloneCredential(tokenSchema, config);
} else {
let username = void 0;
let password = void 0;
if ("password" in config && isString(config.password)) {
core23.setSecret(config.password);
core24.setSecret(config.password);
password = config.password;
}
if ("username" in config && isString(config.username)) {
@@ -187568,65 +187629,6 @@ function getAuthConfig(config) {
}
// src/start-proxy.ts
function getStartProxyErrorMessage(errorType) {
switch (errorType) {
case 0 /* DownloadFailed */:
return "Failed to download proxy archive.";
case 1 /* ExtractionFailed */:
return "Failed to extract proxy archive.";
case 2 /* CacheFailed */:
return "Failed to add proxy to toolcache";
}
}
var StartProxyError = class extends Error {
errorType;
constructor(errorType) {
super();
this.errorType = errorType;
}
};
async function sendSuccessStatusReport(startedAt, config, registry_types, logger2) {
const statusReportBase = await createStatusReportBase(
"start-proxy" /* StartProxy */,
"success",
startedAt,
config,
await checkDiskUsage(logger2),
logger2
);
if (statusReportBase !== void 0) {
const statusReport = {
...statusReportBase,
registry_types: registry_types.join(",")
};
await sendStatusReport(statusReport);
}
}
function getSafeErrorMessage(error3) {
if (error3 instanceof StartProxyError) {
return getStartProxyErrorMessage(error3.errorType);
}
return `Error from start-proxy Action omitted (${error3.constructor.name}).`;
}
async function sendFailedStatusReport(logger2, startedAt, language, unwrappedError) {
const error3 = wrapError(unwrappedError);
core24.setFailed(`start-proxy action failed: ${error3.message}`);
const statusReportMessage = getSafeErrorMessage(error3);
const errorStatusReportBase = await createStatusReportBase(
"start-proxy" /* StartProxy */,
getActionsStatus(error3),
startedAt,
{
languages: language === void 0 ? void 0 : [language]
},
await checkDiskUsage(logger2),
logger2,
statusReportMessage
);
if (errorStatusReportBase !== void 0) {
await sendStatusReport(errorStatusReportBase);
}
}
var UPDATEJOB_PROXY = "update-job-proxy";
var UPDATEJOB_PROXY_VERSION = "v2.0.20250624110901";
var UPDATEJOB_PROXY_URL_PREFIX = "https://github.com/github/codeql-action/releases/download/codeql-bundle-v2.22.0/";

88
src/start-proxy.test.ts
View File

@@ -1,6 +1,5 @@
import * as filepath from "path";
import * as core from "@actions/core";
import * as toolcache from "@actions/tool-cache";
import test, { ExecutionContext } from "ava";
import sinon from "sinon";
@@ -15,7 +14,6 @@ import { BuiltInLanguage } from "./languages";
import { getRunnerLogger, Logger } from "./logging";
import { BundlePlatform, getBundlePlatform } from "./platform";
import * as startProxyExports from "./start-proxy";
import * as statusReport from "./status-report";
import {
assertNotLogged,
checkExpectedLogMessages,
@@ -27,94 +25,10 @@ import {
setupTests,
withRecordingLoggerAsync,
} from "./testing-utils";
import {
ConfigurationError,
GitHubVariant,
GitHubVersion,
withTmpDir,
} from "./util";
import { GitHubVariant, GitHubVersion, withTmpDir } from "./util";
setupTests(test);
const sendFailedStatusReportTest = makeMacro({
exec: async (
t: ExecutionContext<unknown>,
err: Error,
expectedMessage: string,
expectedStatus: statusReport.ActionStatus = "failure",
) => {
const now = new Date();
// Override core.setFailed to avoid it setting the program's exit code
sinon.stub(core, "setFailed").returns();
const createStatusReportBase = sinon.stub(
statusReport,
"createStatusReportBase",
);
createStatusReportBase.resolves(undefined);
await withRecordingLoggerAsync(async (logger) => {
await startProxyExports.sendFailedStatusReport(
logger,
now,
undefined,
err,
);
// Check that the stub has been called exactly once, with the expected arguments,
// but not with the message from the error.
sinon.assert.calledOnceWithExactly(
createStatusReportBase,
statusReport.ActionName.StartProxy,
expectedStatus,
now,
sinon.match.any,
sinon.match.any,
sinon.match.any,
expectedMessage,
);
t.false(
createStatusReportBase.calledWith(
statusReport.ActionName.StartProxy,
expectedStatus,
now,
sinon.match.any,
sinon.match.any,
sinon.match.any,
sinon.match((msg: string) => msg.includes(err.message)),
),
"createStatusReportBase was called with the error message",
);
});
},
title: (providedTitle = "") => `sendFailedStatusReport - ${providedTitle}`,
});
sendFailedStatusReportTest.serial(
"reports generic error message for non-StartProxyError error",
new Error("Something went wrong today"),
"Error from start-proxy Action omitted (Error).",
);
sendFailedStatusReportTest.serial(
"reports generic error message for non-StartProxyError error with safe error message",
new Error(
startProxyExports.getStartProxyErrorMessage(
startProxyExports.StartProxyErrorType.DownloadFailed,
),
),
"Error from start-proxy Action omitted (Error).",
);
sendFailedStatusReportTest.serial(
"reports generic error message for ConfigurationError error",
new ConfigurationError("Something went wrong today"),
"Error from start-proxy Action omitted (ConfigurationError).",
"user-error",
);
const toEncodedJSON = (data: any) =>
Buffer.from(JSON.stringify(data)).toString("base64");

142
src/start-proxy.ts
View File

@@ -1,6 +1,5 @@
import * as path from "path";
import * as core from "@actions/core";
import * as toolcache from "@actions/tool-cache";
import { ActionState } from "./action-common";
@@ -11,7 +10,6 @@ import {
getGitHubVersion,
} from "./api-client";
import * as artifactScanner from "./artifact-scanner";
import { Config } from "./config-utils";
import * as defaults from "./defaults.json";
import {
CodeQLDefaultVersionInfo,
@@ -22,6 +20,10 @@ import * as json from "./json";
import { BuiltInLanguage } from "./languages";
import { Logger } from "./logging";
import { BundlePlatform, getBundlePlatform } from "./platform";
import {
StartProxyError,
StartProxyErrorType,
} from "./start-proxy/status-report";
import {
Address,
Registry,
@@ -32,144 +34,10 @@ import {
RawCredential,
} from "./start-proxy/types";
import { getAuthConfig } from "./start-proxy/validation";
import {
ActionName,
createStatusReportBase,
getActionsStatus,
sendStatusReport,
StatusReportBase,
} from "./status-report";
import * as util from "./util";
import { ConfigurationError, getErrorMessage, isDefined } from "./util";
export * from "./start-proxy/types";
/**
* Enumerates specific error types for which we have corresponding error messages that
* are safe to include in status reports.
*/
export enum StartProxyErrorType {
DownloadFailed,
ExtractionFailed,
CacheFailed,
}
/**
* @returns The error message corresponding to the error type.
*/
export function getStartProxyErrorMessage(
errorType: StartProxyErrorType,
): string {
switch (errorType) {
case StartProxyErrorType.DownloadFailed:
return "Failed to download proxy archive.";
case StartProxyErrorType.ExtractionFailed:
return "Failed to extract proxy archive.";
case StartProxyErrorType.CacheFailed:
return "Failed to add proxy to toolcache";
}
}
/**
* We want to avoid accidentally leaking secrets that may be contained in exception
* messages in the `start-proxy` action. Consequently, we don't report the messages
* of arbitrary exceptions. This type of error ensures that the message is one from
* `StartProxyErrorType` and therefore safe to include in a status report.
*/
export class StartProxyError extends Error {
public readonly errorType: StartProxyErrorType;
constructor(errorType: StartProxyErrorType) {
super();
this.errorType = errorType;
}
}
/**
* Sends a status report for the `start-proxy` action indicating a successful outcome.
*
* @param startedAt When the action was started.
* @param config The configuration used.
* @param registry_types The types of registries that are configured.
* @param logger The logger to use.
*/
export async function sendSuccessStatusReport(
startedAt: Date,
config: Partial<Config>,
registry_types: string[],
logger: Logger,
) {
const statusReportBase = await createStatusReportBase(
ActionName.StartProxy,
"success",
startedAt,
config,
await util.checkDiskUsage(logger),
logger,
);
if (statusReportBase !== undefined) {
const statusReport: StatusReportBase = {
...statusReportBase,
registry_types: registry_types.join(","),
};
await sendStatusReport(statusReport);
}
}
/**
* Returns an error message for `error` that can safely be reported in a status report,
* i.e. that does not contain sensitive information.
*
* @param error The error for which to get an error message.
*/
export function getSafeErrorMessage(error: Error): string {
// If the error is a `StartProxyError`, resolve the error type to the corresponding
// error message.
if (error instanceof StartProxyError) {
return getStartProxyErrorMessage(error.errorType);
}
// Otherwise, omit the actual error message.
return `Error from start-proxy Action omitted (${error.constructor.name}).`;
}
/**
* Sends a status report for the `start-proxy` action indicating a failure.
*
* @param logger The logger to use.
* @param startedAt When the action was started.
* @param language The language provided as input, if any.
* @param unwrappedError The exception that was thrown.
*/
export async function sendFailedStatusReport(
logger: Logger,
startedAt: Date,
language: BuiltInLanguage | undefined,
unwrappedError: unknown,
) {
const error = util.wrapError(unwrappedError);
core.setFailed(`start-proxy action failed: ${error.message}`);
// To avoid the possibility of leaking sensitive information into the telemetry,
// we don't include arbitrary error messages. Instead, `getSafeErrorMessage` will
// return a generic message that includes the type of the error, unless it can decide
// that the message is safe to include.
const statusReportMessage = getSafeErrorMessage(error);
const errorStatusReportBase = await createStatusReportBase(
ActionName.StartProxy,
getActionsStatus(error),
startedAt,
{
languages: language === undefined ? undefined : [language],
},
await util.checkDiskUsage(logger),
logger,
statusReportMessage,
);
if (errorStatusReportBase !== undefined) {
await sendStatusReport(errorStatusReportBase);
}
}
export * from "./start-proxy/status-report";
export const UPDATEJOB_PROXY = "update-job-proxy";
export const UPDATEJOB_PROXY_VERSION = "v2.0.20250624110901";

94
src/start-proxy/status-report.test.ts Normal file
View File

@@ -0,0 +1,94 @@
import * as core from "@actions/core";
import test, { ExecutionContext } from "ava";
import sinon from "sinon";
import * as statusReport from "../status-report";
import {
makeMacro,
setupTests,
withRecordingLoggerAsync,
} from "../testing-utils";
import { ConfigurationError } from "../util";
import * as startProxyExports from "./status-report";
setupTests(test);
const sendFailedStatusReportTest = makeMacro({
exec: async (
t: ExecutionContext<unknown>,
err: Error,
expectedMessage: string,
expectedStatus: statusReport.ActionStatus = "failure",
) => {
const now = new Date();
// Override core.setFailed to avoid it setting the program's exit code
sinon.stub(core, "setFailed").returns();
const createStatusReportBase = sinon.stub(
statusReport,
"createStatusReportBase",
);
createStatusReportBase.resolves(undefined);
await withRecordingLoggerAsync(async (logger) => {
await startProxyExports.sendFailedStatusReport(
logger,
now,
undefined,
err,
);
// Check that the stub has been called exactly once, with the expected arguments,
// but not with the message from the error.
sinon.assert.calledOnceWithExactly(
createStatusReportBase,
statusReport.ActionName.StartProxy,
expectedStatus,
now,
sinon.match.any,
sinon.match.any,
sinon.match.any,
expectedMessage,
);
t.false(
createStatusReportBase.calledWith(
statusReport.ActionName.StartProxy,
expectedStatus,
now,
sinon.match.any,
sinon.match.any,
sinon.match.any,
sinon.match((msg: string) => msg.includes(err.message)),
),
"createStatusReportBase was called with the error message",
);
});
},
title: (providedTitle = "") => `sendFailedStatusReport - ${providedTitle}`,
});
sendFailedStatusReportTest.serial(
"reports generic error message for non-StartProxyError error",
new Error("Something went wrong today"),
"Error from start-proxy Action omitted (Error).",
);
sendFailedStatusReportTest.serial(
"reports generic error message for non-StartProxyError error with safe error message",
new Error(
startProxyExports.getStartProxyErrorMessage(
startProxyExports.StartProxyErrorType.DownloadFailed,
),
),
"Error from start-proxy Action omitted (Error).",
);
sendFailedStatusReportTest.serial(
"reports generic error message for ConfigurationError error",
new ConfigurationError("Something went wrong today"),
"Error from start-proxy Action omitted (ConfigurationError).",
"user-error",
);

140
src/start-proxy/status-report.ts Normal file
View File

@@ -0,0 +1,140 @@
import * as core from "@actions/core";
import type { Config } from "../config-utils";
import type { BuiltInLanguage } from "../languages";
import type { Logger } from "../logging";
import {
ActionName,
createStatusReportBase,
getActionsStatus,
sendStatusReport,
type StatusReportBase,
} from "../status-report";
import * as util from "../util";
/**
* Sends a status report for the `start-proxy` action indicating a successful outcome.
*
* @param startedAt When the action was started.
* @param config The configuration used.
* @param registry_types The types of registries that are configured.
* @param logger The logger to use.
*/
export async function sendSuccessStatusReport(
startedAt: Date,
config: Partial<Config>,
registry_types: string[],
logger: Logger,
) {
const statusReportBase = await createStatusReportBase(
ActionName.StartProxy,
"success",
startedAt,
config,
await util.checkDiskUsage(logger),
logger,
);
if (statusReportBase !== undefined) {
const statusReport: StatusReportBase = {
...statusReportBase,
registry_types: registry_types.join(","),
};
await sendStatusReport(statusReport);
}
}
/**
* Enumerates specific error types for which we have corresponding error messages that
* are safe to include in status reports.
*/
export enum StartProxyErrorType {
DownloadFailed,
ExtractionFailed,
CacheFailed,
}
/**
* @returns The error message corresponding to the error type.
*/
export function getStartProxyErrorMessage(
errorType: StartProxyErrorType,
): string {
switch (errorType) {
case StartProxyErrorType.DownloadFailed:
return "Failed to download proxy archive.";
case StartProxyErrorType.ExtractionFailed:
return "Failed to extract proxy archive.";
case StartProxyErrorType.CacheFailed:
return "Failed to add proxy to toolcache";
}
}
/**
* We want to avoid accidentally leaking secrets that may be contained in exception
* messages in the `start-proxy` action. Consequently, we don't report the messages
* of arbitrary exceptions. This type of error ensures that the message is one from
* `StartProxyErrorType` and therefore safe to include in a status report.
*/
export class StartProxyError extends Error {
public readonly errorType: StartProxyErrorType;
constructor(errorType: StartProxyErrorType) {
super();
this.errorType = errorType;
}
}
/**
* Returns an error message for `error` that can safely be reported in a status report,
* i.e. that does not contain sensitive information.
*
* @param error The error for which to get an error message.
*/
export function getSafeErrorMessage(error: Error): string {
// If the error is a `StartProxyError`, resolve the error type to the corresponding
// error message.
if (error instanceof StartProxyError) {
return getStartProxyErrorMessage(error.errorType);
}
// Otherwise, omit the actual error message.
return `Error from start-proxy Action omitted (${error.constructor.name}).`;
}
/**
* Sends a status report for the `start-proxy` action indicating a failure.
*
* @param logger The logger to use.
* @param startedAt When the action was started.
* @param language The language provided as input, if any.
* @param unwrappedError The exception that was thrown.
*/
export async function sendFailedStatusReport(
logger: Logger,
startedAt: Date,
language: BuiltInLanguage | undefined,
unwrappedError: unknown,
) {
const error = util.wrapError(unwrappedError);
core.setFailed(`start-proxy action failed: ${error.message}`);
// To avoid the possibility of leaking sensitive information into the telemetry,
// we don't include arbitrary error messages. Instead, `getSafeErrorMessage` will
// return a generic message that includes the type of the error, unless it can decide
// that the message is safe to include.
const statusReportMessage = getSafeErrorMessage(error);
const errorStatusReportBase = await createStatusReportBase(
ActionName.StartProxy,
getActionsStatus(error),
startedAt,
{
languages: language === undefined ? undefined : [language],
},
await util.checkDiskUsage(logger),
logger,
statusReportMessage,
);
if (errorStatusReportBase !== undefined) {
await sendStatusReport(errorStatusReportBase);
}
}