@ohos-ports/nx 19.8.4-beta.0

package/src/tasks-runner/task-env.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvVariablesForBatchProcess = getEnvVariablesForBatchProcess;
+exports.getTaskSpecificEnv = getTaskSpecificEnv;
+exports.getEnvVariablesForTask = getEnvVariablesForTask;
+exports.loadAndExpandDotEnvFile = loadAndExpandDotEnvFile;
+exports.unloadDotEnvFile = unloadDotEnvFile;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("../utils/workspace-root");
+const node_path_1 = require("node:path");
+function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
+    return {
+        // User Process Env Variables override Dotenv Variables
+        ...process.env,
+        // Nx Env Variables overrides everything
+        ...getNxEnvVariablesForForkedProcess(process.env.FORCE_COLOR === undefined ? 'true' : process.env.FORCE_COLOR, skipNxCache, captureStderr),
+    };
+}
+function getTaskSpecificEnv(task) {
+    // Unload any dot env files at the root of the workspace that were loaded on init of Nx.
+    const taskEnv = unloadDotEnvFiles({ ...process.env });
+    return process.env.NX_LOAD_DOT_ENV_FILES === 'true'
+        ? loadDotEnvFilesForTask(task, taskEnv)
+        : // If not loading dot env files, ensure env vars created by system are still loaded
+            taskEnv;
+}
+function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const res = {
+        // Start With Dotenv Variables
+        ...taskSpecificEnv,
+        // Nx Env Variables overrides everything
+        ...getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
+    };
+    // we have to delete it because if we invoke Nx from within Nx, we need to reset those values
+    if (!outputPath) {
+        delete res.NX_TERMINAL_OUTPUT_PATH;
+        delete res.NX_STREAM_OUTPUT;
+        delete res.NX_PREFIX_OUTPUT;
+    }
+    // we don't reset NX_BASE or NX_HEAD because those are set by the user and should be preserved
+    delete res.NX_SET_CLI;
+    return res;
+}
+function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const env = {
+        FORCE_COLOR: forceColor,
+        NX_WORKSPACE_ROOT: workspace_root_1.workspaceRoot,
+        NX_SKIP_NX_CACHE: skipNxCache ? 'true' : undefined,
+    };
+    if (outputPath) {
+        env.NX_TERMINAL_OUTPUT_PATH = outputPath;
+        if (captureStderr) {
+            env.NX_TERMINAL_CAPTURE_STDERR = 'true';
+        }
+        if (streamOutput) {
+            env.NX_STREAM_OUTPUT = 'true';
+        }
+    }
+    return env;
+}
+function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const env = {
+        NX_TASK_TARGET_PROJECT: task.target.project,
+        NX_TASK_TARGET_TARGET: task.target.target,
+        NX_TASK_TARGET_CONFIGURATION: task.target.configuration ?? undefined,
+        NX_TASK_HASH: task.hash,
+        // used when Nx is invoked via Lerna
+        LERNA_PACKAGE_NAME: task.target.project,
+    };
+    // TODO: remove this once we have a reasonable way to configure it
+    if (task.target.target === 'test') {
+        env.NX_TERMINAL_CAPTURE_STDERR = 'true';
+    }
+    return {
+        ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
+        ...env,
+    };
+}
+/**
+ * This function loads a .env file and expands the variables in it.
+ * @param filename the .env file to load
+ * @param environmentVariables the object to load environment variables into
+ * @param override whether to override existing environment variables
+ */
+function loadAndExpandDotEnvFile(filename, environmentVariables, override = false) {
+    const myEnv = (0, dotenv_1.config)({
+        path: filename,
+        processEnv: environmentVariables,
+        override,
+    });
+    return (0, dotenv_expand_1.expand)({
+        ...myEnv,
+        processEnv: environmentVariables,
+    });
+}
+/**
+ * This function unloads a .env file and removes the variables in it from the environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+function unloadDotEnvFile(filename, environmentVariables, override = false) {
+    const parsedDotEnvFile = {};
+    loadAndExpandDotEnvFile(filename, parsedDotEnvFile, override);
+    Object.keys(parsedDotEnvFile).forEach((envVarKey) => {
+        if (environmentVariables[envVarKey] === parsedDotEnvFile[envVarKey]) {
+            delete environmentVariables[envVarKey];
+        }
+    });
+}
+function getEnvFilesForTask(task) {
+    // Collect dot env files that may pertain to a task
+    return [
+        // Load DotEnv Files for a configuration in the project root
+        ...(task.target.configuration
+            ? [
+                `${task.projectRoot}/.env.${task.target.target}.${task.target.configuration}.local`,
+                `${task.projectRoot}/.env.${task.target.target}.${task.target.configuration}`,
+                `${task.projectRoot}/.env.${task.target.configuration}.local`,
+                `${task.projectRoot}/.env.${task.target.configuration}`,
+                `${task.projectRoot}/.${task.target.target}.${task.target.configuration}.local.env`,
+                `${task.projectRoot}/.${task.target.target}.${task.target.configuration}.env`,
+                `${task.projectRoot}/.${task.target.configuration}.local.env`,
+                `${task.projectRoot}/.${task.target.configuration}.env`,
+            ]
+            : []),
+        // Load DotEnv Files for a target in the project root
+        `${task.projectRoot}/.env.${task.target.target}.local`,
+        `${task.projectRoot}/.env.${task.target.target}`,
+        `${task.projectRoot}/.${task.target.target}.local.env`,
+        `${task.projectRoot}/.${task.target.target}.env`,
+        `${task.projectRoot}/.env.local`,
+        `${task.projectRoot}/.local.env`,
+        `${task.projectRoot}/.env`,
+        // Load DotEnv Files for a configuration in the workspace root
+        ...(task.target.configuration
+            ? [
+                `.env.${task.target.target}.${task.target.configuration}.local`,
+                `.env.${task.target.target}.${task.target.configuration}`,
+                `.env.${task.target.configuration}.local`,
+                `.env.${task.target.configuration}`,
+                `.${task.target.target}.${task.target.configuration}.local.env`,
+                `.${task.target.target}.${task.target.configuration}.env`,
+                `.${task.target.configuration}.local.env`,
+                `.${task.target.configuration}.env`,
+            ]
+            : []),
+        // Load DotEnv Files for a target in the workspace root
+        `.env.${task.target.target}.local`,
+        `.env.${task.target.target}`,
+        `.${task.target.target}.local.env`,
+        `.${task.target.target}.env`,
+        // Load base DotEnv Files at workspace root
+        `.local.env`,
+        `.env.local`,
+        `.env`,
+    ];
+}
+function loadDotEnvFilesForTask(task, environmentVariables) {
+    const dotEnvFiles = getEnvFilesForTask(task);
+    for (const file of dotEnvFiles) {
+        loadAndExpandDotEnvFile((0, node_path_1.join)(workspace_root_1.workspaceRoot, file), environmentVariables);
+    }
+    return environmentVariables;
+}
+function unloadDotEnvFiles(environmentVariables) {
+    for (const file of ['.env', '.local.env', '.env.local']) {
+        unloadDotEnvFile((0, node_path_1.join)(workspace_root_1.workspaceRoot, file), environmentVariables);
+    }
+    return environmentVariables;
+}

package/src/tasks-runner/task-graph-utils.d.ts

@@ -0,0 +1,10 @@
+import { ProjectGraph } from '../config/project-graph';
+import { TaskGraph } from '../config/task-graph';
+export declare function findCycle(graph: {
+    dependencies: Record<string, string[]>;
+}): string[] | null;
+export declare function makeAcyclic(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}): void;
+export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;

package/src/tasks-runner/task-graph-utils.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCycle = findCycle;
+exports.makeAcyclic = makeAcyclic;
+exports.validateNoAtomizedTasks = validateNoAtomizedTasks;
+const output_1 = require("../utils/output");
+function _findCycle(graph, id, visited, path) {
+    if (visited[id])
+        return null;
+    visited[id] = true;
+    for (const d of graph.dependencies[id]) {
+        if (path.includes(d))
+            return [...path, d];
+        const cycle = _findCycle(graph, d, visited, [...path, d]);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+function findCycle(graph) {
+    const visited = {};
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        const cycle = _findCycle(graph, t, visited, [t]);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+function _makeAcyclic(graph, id, visited, path) {
+    if (visited[id])
+        return;
+    visited[id] = true;
+    const deps = graph.dependencies[id];
+    for (const d of [...deps]) {
+        if (path.includes(d)) {
+            deps.splice(deps.indexOf(d), 1);
+        }
+        else {
+            _makeAcyclic(graph, d, visited, [...path, d]);
+        }
+    }
+    return null;
+}
+function makeAcyclic(graph) {
+    const visited = {};
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        _makeAcyclic(graph, t, visited, [t]);
+    }
+    graph.roots = Object.keys(graph.dependencies).filter((t) => graph.dependencies[t].length === 0);
+}
+function validateNoAtomizedTasks(taskGraph, projectGraph) {
+    const getNonAtomizedTargetForTask = (task) => projectGraph.nodes[task.target.project]?.data?.targets?.[task.target.target]
+        ?.metadata?.nonAtomizedTarget;
+    const atomizedRootTasks = Object.values(taskGraph.tasks).filter((task) => getNonAtomizedTargetForTask(task) !== undefined);
+    if (atomizedRootTasks.length === 0) {
+        return;
+    }
+    const nonAtomizedTasks = atomizedRootTasks
+        .map((t) => `"${getNonAtomizedTargetForTask(t)}"`)
+        .filter((item, index, arr) => arr.indexOf(item) === index);
+    const moreInfoLines = [
+        `Please enable Nx Cloud or use the slower ${nonAtomizedTasks.join(',')} task${nonAtomizedTasks.length > 1 ? 's' : ''}.`,
+        'Learn more at https://nx.dev/ci/features/split-e2e-tasks#nx-cloud-is-required-to-run-atomized-tasks',
+    ];
+    if (atomizedRootTasks.length === 1) {
+        output_1.output.error({
+            title: `The ${atomizedRootTasks[0].id} task should only be run with Nx Cloud.`,
+            bodyLines: [...moreInfoLines],
+        });
+    }
+    else {
+        output_1.output.error({
+            title: `The following tasks should only be run with Nx Cloud:`,
+            bodyLines: [
+                ...atomizedRootTasks.map((task) => `  - ${task.id}`),
+                '',
+                ...moreInfoLines,
+            ],
+        });
+    }
+    process.exit(1);
+}

package/src/tasks-runner/task-orchestrator.d.ts

@@ -0,0 +1,53 @@
+import { TaskHasher } from '../hasher/task-hasher';
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { TaskStatus } from './tasks-runner';
+import { ProjectGraph } from '../config/project-graph';
+import { TaskGraph } from '../config/task-graph';
+import { DaemonClient } from '../daemon/client/client';
+import { NxJsonConfiguration } from '../config/nx-json';
+export declare class TaskOrchestrator {
+    private readonly hasher;
+    private readonly initiatingProject;
+    private readonly projectGraph;
+    private readonly taskGraph;
+    private readonly nxJson;
+    private readonly options;
+    private readonly bail;
+    private readonly daemon;
+    private readonly outputStyle;
+    private taskDetails;
+    private cache;
+    private forkedProcessTaskRunner;
+    private tasksSchedule;
+    private batchEnv;
+    private reverseTaskDeps;
+    private processedTasks;
+    private processedBatches;
+    private completedTasks;
+    private waitingForTasks;
+    private groups;
+    private bailed;
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    run(): Promise<{
+        [id: string]: TaskStatus;
+    }>;
+    private executeNextBatchOfTasksUsingTaskSchedule;
+    private processScheduledTask;
+    private processScheduledBatch;
+    private processAllScheduledTasks;
+    private applyCachedResults;
+    private applyCachedResult;
+    private applyFromCacheOrRunBatch;
+    private runBatch;
+    private applyFromCacheOrRunTask;
+    private runTaskInForkedProcess;
+    private preRunSteps;
+    private postRunSteps;
+    private complete;
+    private pipeOutputCapture;
+    private shouldCacheTaskResult;
+    private closeGroup;
+    private openGroup;
+    private shouldCopyOutputsFromCache;
+    private recordOutputsHash;
+}