mirror of
https://github.com/expo/eas-cli.git
synced 2026-11-15 17:31:46 -10:00
* [eas-build-job] Add hook anchors registry and step stamp fields Signed-off-by: Ash Wu <[email protected]> * [steps] Add hook insertion, after-hook gate, and source function retention Signed-off-by: Ash Wu <[email protected]> * [build-tools] Pass job hooks into the steps parser Signed-off-by: Ash Wu <[email protected]> * address comments Signed-off-by: Ash Wu <[email protected]> --------- Signed-off-by: Ash Wu <[email protected]>
401 lines
13 KiB
TypeScript
401 lines
13 KiB
TypeScript
import assert from 'assert';
|
|
|
|
import { AbstractConfigParser } from './AbstractConfigParser';
|
|
import {
|
|
BuildConfig,
|
|
BuildFunctionConfig,
|
|
BuildFunctionInputs,
|
|
BuildFunctionOutputs,
|
|
BuildStepBareCommandRun,
|
|
BuildStepBareFunctionOrFunctionGroupCall,
|
|
BuildStepCommandRun,
|
|
BuildStepConfig,
|
|
BuildStepFunctionCall,
|
|
BuildStepInputs,
|
|
BuildStepOutputs,
|
|
isBuildStepBareCommandRun,
|
|
isBuildStepBareFunctionOrFunctionGroupCall,
|
|
isBuildStepCommandRun,
|
|
readAndValidateBuildConfigFromPathAsync,
|
|
} from './BuildConfig';
|
|
import { BuildFunction, BuildFunctionById } from './BuildFunction';
|
|
import {
|
|
BuildFunctionGroup,
|
|
BuildFunctionGroupById,
|
|
createBuildFunctionGroupByIdMapping,
|
|
} from './BuildFunctionGroup';
|
|
import { BuildStep } from './BuildStep';
|
|
import { BuildStepGlobalContext } from './BuildStepContext';
|
|
import {
|
|
BuildStepInput,
|
|
BuildStepInputProvider,
|
|
BuildStepInputValueTypeName,
|
|
} from './BuildStepInput';
|
|
import { BuildStepOutput, BuildStepOutputProvider } from './BuildStepOutput';
|
|
import { BuildConfigError } from './errors';
|
|
import { AnchorHooks } from './hooks';
|
|
|
|
export class BuildConfigParser extends AbstractConfigParser {
|
|
private readonly configPath: string;
|
|
constructor(
|
|
ctx: BuildStepGlobalContext,
|
|
{
|
|
configPath,
|
|
externalFunctions,
|
|
externalFunctionGroups,
|
|
}: {
|
|
configPath: string;
|
|
externalFunctions?: BuildFunction[];
|
|
externalFunctionGroups?: BuildFunctionGroup[];
|
|
}
|
|
) {
|
|
super(ctx, {
|
|
externalFunctions,
|
|
externalFunctionGroups,
|
|
});
|
|
|
|
this.configPath = configPath;
|
|
}
|
|
|
|
protected async parseConfigToBuildStepsAndBuildFunctionByIdMappingAsync(): Promise<{
|
|
buildSteps: BuildStep[];
|
|
buildFunctionById: BuildFunctionById;
|
|
hooksByAnchorStep: ReadonlyMap<BuildStep, AnchorHooks>;
|
|
}> {
|
|
const config = await readAndValidateBuildConfigFromPathAsync(this.configPath, {
|
|
externalFunctionIds: this.getExternalFunctionFullIds(),
|
|
externalFunctionGroupsIds: this.getExternalFunctionGroupFullIds(),
|
|
});
|
|
const configBuildFunctions = this.createBuildFunctionsFromConfig(config.functions);
|
|
const buildFunctions = this.mergeBuildFunctionsWithExternal(
|
|
configBuildFunctions,
|
|
this.externalFunctions
|
|
);
|
|
const buildFunctionGroups = createBuildFunctionGroupByIdMapping(
|
|
this.externalFunctionGroups ?? []
|
|
);
|
|
const buildSteps: BuildStep[] = [];
|
|
for (const stepConfig of config.build.steps) {
|
|
buildSteps.push(
|
|
...this.createBuildStepFromConfig(stepConfig, buildFunctions, buildFunctionGroups)
|
|
);
|
|
}
|
|
return {
|
|
buildSteps,
|
|
buildFunctionById: buildFunctions,
|
|
// config.yml builds have no hooks — the payload `hooks` field never
|
|
// reaches this parser.
|
|
hooksByAnchorStep: new Map(),
|
|
};
|
|
}
|
|
|
|
private createBuildStepFromConfig(
|
|
buildStepConfig: BuildStepConfig,
|
|
buildFunctions: BuildFunctionById,
|
|
buildFunctionGroups: BuildFunctionGroupById
|
|
): BuildStep[] {
|
|
if (isBuildStepCommandRun(buildStepConfig)) {
|
|
return [this.createBuildStepFromBuildStepCommandRun(buildStepConfig)];
|
|
} else if (isBuildStepBareCommandRun(buildStepConfig)) {
|
|
return [this.createBuildStepFromBuildStepBareCommandRun(buildStepConfig)];
|
|
} else if (isBuildStepBareFunctionOrFunctionGroupCall(buildStepConfig)) {
|
|
return this.createBuildStepsFromBareBuildStepFunctionOrBareBuildStepFunctionGroupCall(
|
|
buildFunctions,
|
|
buildFunctionGroups,
|
|
buildStepConfig
|
|
);
|
|
} else if (buildStepConfig !== null) {
|
|
return this.createBuildStepsFromBuildStepFunctionOrBuildStepFunctionGroupCall(
|
|
buildFunctions,
|
|
buildFunctionGroups,
|
|
buildStepConfig
|
|
);
|
|
} else {
|
|
throw new BuildConfigError(
|
|
'Invalid build step configuration detected. Build step cannot be empty.'
|
|
);
|
|
}
|
|
}
|
|
|
|
private createBuildStepFromBuildStepCommandRun({ run }: BuildStepCommandRun): BuildStep {
|
|
const {
|
|
id: maybeId,
|
|
inputs: inputsConfig,
|
|
outputs: outputsConfig,
|
|
name,
|
|
workingDirectory,
|
|
shell,
|
|
command,
|
|
env,
|
|
if: ifCondition,
|
|
timeout_minutes,
|
|
__metrics_id,
|
|
} = run;
|
|
const id = BuildStep.getNewId(maybeId);
|
|
const displayName =
|
|
name ??
|
|
maybeId ??
|
|
command
|
|
.split('\n')
|
|
.find(line => line.trim())
|
|
?.trim() ??
|
|
command;
|
|
const inputs =
|
|
inputsConfig && this.createBuildStepInputsFromDefinition(inputsConfig, displayName);
|
|
const outputs =
|
|
outputsConfig && this.createBuildStepOutputsFromDefinition(outputsConfig, displayName);
|
|
const timeoutMs = timeout_minutes !== undefined ? timeout_minutes * 60 * 1000 : undefined;
|
|
return new BuildStep(this.ctx, {
|
|
id,
|
|
displayName,
|
|
inputs,
|
|
outputs,
|
|
workingDirectory,
|
|
shell,
|
|
command,
|
|
env,
|
|
ifCondition,
|
|
timeoutMs,
|
|
__metricsId: __metrics_id,
|
|
});
|
|
}
|
|
|
|
private createBuildStepFromBuildStepBareCommandRun({
|
|
run: command,
|
|
}: BuildStepBareCommandRun): BuildStep {
|
|
const id = BuildStep.getNewId();
|
|
const displayName =
|
|
command
|
|
.split('\n')
|
|
.find(line => line.trim())
|
|
?.trim() ?? command;
|
|
return new BuildStep(this.ctx, {
|
|
id,
|
|
displayName,
|
|
command,
|
|
});
|
|
}
|
|
|
|
private createBuildStepsFromBuildStepFunctionGroupCall(
|
|
buildFunctionGroups: BuildFunctionGroupById,
|
|
buildStepFunctionCall: BuildStepFunctionCall
|
|
): BuildStep[] {
|
|
const functionId = getFunctionIdFromBuildStepFunctionCall(buildStepFunctionCall);
|
|
const buildFunctionGroup = buildFunctionGroups[functionId];
|
|
assert(buildFunctionGroup, `Build function group with id "${functionId}" is not defined.`);
|
|
return buildFunctionGroup.createBuildStepsFromFunctionGroupCall(this.ctx, {
|
|
callInputs: buildStepFunctionCall[functionId].inputs,
|
|
});
|
|
}
|
|
|
|
private createBuildStepsFromBuildStepBareFunctionGroupCall(
|
|
buildFunctionGroups: BuildFunctionGroupById,
|
|
functionGroupId: string
|
|
): BuildStep[] {
|
|
const buildFunctionGroup = buildFunctionGroups[functionGroupId];
|
|
assert(buildFunctionGroup, `Build function group with id "${functionGroupId}" is not defined.`);
|
|
return buildFunctionGroup.createBuildStepsFromFunctionGroupCall(this.ctx);
|
|
}
|
|
|
|
private createBuildStepFromBuildStepBareFunctionCall(
|
|
buildFunctions: BuildFunctionById,
|
|
functionId: BuildStepBareFunctionOrFunctionGroupCall
|
|
): BuildStep {
|
|
const buildFunction = buildFunctions[functionId];
|
|
return buildFunction.createBuildStepFromFunctionCall(this.ctx);
|
|
}
|
|
|
|
private createBuildStepsFromBareBuildStepFunctionOrBareBuildStepFunctionGroupCall(
|
|
buildFunctions: BuildFunctionById,
|
|
buildFunctionGroups: BuildFunctionGroupById,
|
|
functionOrFunctionGroupId: string
|
|
): BuildStep[] {
|
|
const maybeFunctionGroup = buildFunctionGroups[functionOrFunctionGroupId];
|
|
if (maybeFunctionGroup) {
|
|
return this.createBuildStepsFromBuildStepBareFunctionGroupCall(
|
|
buildFunctionGroups,
|
|
functionOrFunctionGroupId
|
|
);
|
|
}
|
|
return [
|
|
this.createBuildStepFromBuildStepBareFunctionCall(buildFunctions, functionOrFunctionGroupId),
|
|
];
|
|
}
|
|
|
|
private createBuildStepsFromBuildStepFunctionOrBuildStepFunctionGroupCall(
|
|
buildFunctions: BuildFunctionById,
|
|
buildFunctionGroups: BuildFunctionGroupById,
|
|
buildStepFunctionCall: BuildStepFunctionCall
|
|
): BuildStep[] {
|
|
const functionId = getFunctionIdFromBuildStepFunctionCall(buildStepFunctionCall);
|
|
|
|
const maybeFunctionGroup = buildFunctionGroups[functionId];
|
|
if (maybeFunctionGroup) {
|
|
return this.createBuildStepsFromBuildStepFunctionGroupCall(
|
|
buildFunctionGroups,
|
|
buildStepFunctionCall
|
|
);
|
|
}
|
|
return [this.createBuildStepFromBuildStepFunctionCall(buildFunctions, buildStepFunctionCall)];
|
|
}
|
|
|
|
private createBuildStepFromBuildStepFunctionCall(
|
|
buildFunctions: BuildFunctionById,
|
|
buildStepFunctionCall: BuildStepFunctionCall
|
|
): BuildStep {
|
|
const functionId = getFunctionIdFromBuildStepFunctionCall(buildStepFunctionCall);
|
|
const buildFunctionCallConfig = buildStepFunctionCall[functionId];
|
|
const buildFunction = buildFunctions[functionId];
|
|
const timeoutMs =
|
|
buildFunctionCallConfig.timeout_minutes !== undefined
|
|
? buildFunctionCallConfig.timeout_minutes * 60 * 1000
|
|
: undefined;
|
|
return buildFunction.createBuildStepFromFunctionCall(this.ctx, {
|
|
id: buildFunctionCallConfig.id,
|
|
name: buildFunctionCallConfig.name,
|
|
callInputs: buildFunctionCallConfig.inputs,
|
|
workingDirectory: buildFunctionCallConfig.workingDirectory,
|
|
shell: buildFunctionCallConfig.shell,
|
|
env: buildFunctionCallConfig.env,
|
|
ifCondition: buildFunctionCallConfig.if,
|
|
timeoutMs,
|
|
});
|
|
}
|
|
|
|
private createBuildFunctionsFromConfig(
|
|
buildFunctionsConfig: BuildConfig['functions']
|
|
): BuildFunctionById {
|
|
if (!buildFunctionsConfig) {
|
|
return {};
|
|
}
|
|
const result: BuildFunctionById = {};
|
|
for (const [functionId, buildFunctionConfig] of Object.entries(buildFunctionsConfig)) {
|
|
const buildFunction = this.createBuildFunctionFromConfig({
|
|
id: functionId,
|
|
...buildFunctionConfig,
|
|
});
|
|
result[buildFunction.getFullId()] = buildFunction;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private createBuildFunctionFromConfig({
|
|
id,
|
|
name,
|
|
inputs: inputsConfig,
|
|
outputs: outputsConfig,
|
|
shell,
|
|
command,
|
|
supportedRuntimePlatforms,
|
|
path: customFunctionModulePath,
|
|
}: BuildFunctionConfig & { id: string }): BuildFunction {
|
|
const inputProviders =
|
|
inputsConfig && this.createBuildStepInputProvidersFromBuildFunctionInputs(inputsConfig);
|
|
const outputProviders =
|
|
outputsConfig && this.createBuildStepOutputProvidersFromBuildFunctionOutputs(outputsConfig);
|
|
return new BuildFunction({
|
|
id,
|
|
name,
|
|
inputProviders,
|
|
outputProviders,
|
|
shell,
|
|
command,
|
|
customFunctionModulePath,
|
|
supportedRuntimePlatforms,
|
|
});
|
|
}
|
|
|
|
private createBuildStepInputsFromDefinition(
|
|
buildStepInputs: BuildStepInputs,
|
|
stepDisplayName: string
|
|
): BuildStepInput[] {
|
|
return Object.entries(buildStepInputs).map(
|
|
([key, value]) =>
|
|
new BuildStepInput(this.ctx, {
|
|
id: key,
|
|
stepDisplayName,
|
|
defaultValue: value,
|
|
required: true,
|
|
allowedValueTypeName:
|
|
typeof value === 'object'
|
|
? BuildStepInputValueTypeName.JSON
|
|
: (typeof value as BuildStepInputValueTypeName),
|
|
})
|
|
);
|
|
}
|
|
|
|
private createBuildStepInputProvidersFromBuildFunctionInputs(
|
|
buildFunctionInputs: BuildFunctionInputs
|
|
): BuildStepInputProvider[] {
|
|
return buildFunctionInputs.map(entry => {
|
|
return typeof entry === 'string'
|
|
? BuildStepInput.createProvider({
|
|
id: entry,
|
|
required: true,
|
|
allowedValueTypeName: BuildStepInputValueTypeName.STRING,
|
|
})
|
|
: BuildStepInput.createProvider({
|
|
id: entry.name,
|
|
required: entry.required ?? true,
|
|
defaultValue: entry.defaultValue,
|
|
allowedValues: entry.allowedValues,
|
|
allowedValueTypeName: entry.allowedValueType,
|
|
});
|
|
});
|
|
}
|
|
|
|
private createBuildStepOutputsFromDefinition(
|
|
buildStepOutputs: BuildStepOutputs,
|
|
stepDisplayName: string
|
|
): BuildStepOutput[] {
|
|
return buildStepOutputs.map(entry =>
|
|
typeof entry === 'string'
|
|
? new BuildStepOutput(this.ctx, { id: entry, stepDisplayName, required: true })
|
|
: new BuildStepOutput(this.ctx, {
|
|
id: entry.name,
|
|
stepDisplayName,
|
|
required: entry.required ?? true,
|
|
})
|
|
);
|
|
}
|
|
|
|
private createBuildStepOutputProvidersFromBuildFunctionOutputs(
|
|
buildFunctionOutputs: BuildFunctionOutputs
|
|
): BuildStepOutputProvider[] {
|
|
return buildFunctionOutputs.map(entry =>
|
|
typeof entry === 'string'
|
|
? BuildStepOutput.createProvider({ id: entry, required: true })
|
|
: BuildStepOutput.createProvider({ id: entry.name, required: entry.required ?? true })
|
|
);
|
|
}
|
|
|
|
private mergeBuildFunctionsWithExternal(
|
|
configFunctions: BuildFunctionById,
|
|
externalFunctions?: BuildFunction[]
|
|
): BuildFunctionById {
|
|
const result: BuildFunctionById = { ...configFunctions };
|
|
if (externalFunctions === undefined) {
|
|
return result;
|
|
}
|
|
for (const buildFunction of externalFunctions) {
|
|
// functions defined in config shadow the external ones
|
|
const fullId = buildFunction.getFullId();
|
|
if (!(fullId in result)) {
|
|
result[fullId] = buildFunction;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
function getFunctionIdFromBuildStepFunctionCall(
|
|
buildStepFunctionCall: BuildStepFunctionCall
|
|
): string {
|
|
const keys = Object.keys(buildStepFunctionCall);
|
|
assert(
|
|
keys.length === 1,
|
|
'There must be at most one function call in the step (enforced by joi).'
|
|
);
|
|
return keys[0];
|
|
}
|