697 lines
33 KiB
TypeScript
697 lines
33 KiB
TypeScript
import * as childProcess from "child_process";
|
|
import * as fs from "fs/promises";
|
|
import * as path from "path";
|
|
import sanitize from "sanitize-filename";
|
|
import { commands, CustomExecution, env, EventEmitter, ExtensionContext, Pseudoterminal, ShellExecution, TaskDefinition, TaskGroup, TaskPanelKind, TaskRevealKind, tasks, TaskScope, TerminalDimensions, Uri, window, workspace, WorkspaceFolder } from "vscode";
|
|
import { ComponentsManager } from "./componentsManager";
|
|
import { ConfigurationManager, Platform, Section } from "./configurationManager";
|
|
import { componentsTreeDataProvider, historyTreeDataProvider } from './extension';
|
|
import { HistoryManager, HistoryStatus } from './historyManager';
|
|
import { SecretManager } from "./secretManager";
|
|
import { SettingsManager } from './settingsManager';
|
|
import { StorageKey, StorageManager } from './storageManager';
|
|
import { Job, Workflow, WorkflowsManager } from "./workflowsManager";
|
|
|
|
export enum Event {
|
|
BranchProtectionRule = 'branch_protection_rule',
|
|
CheckRun = 'check_run',
|
|
CheckSuite = 'check_suite',
|
|
Create = 'create',
|
|
Delete = 'delete',
|
|
Deployment = 'deployment',
|
|
DeploymentStatus = 'deployment_status',
|
|
Discussion = 'discussion',
|
|
DiscussionComment = 'discussion_comment',
|
|
Fork = 'fork',
|
|
Gollum = 'gollum',
|
|
IssueComment = 'issue_comment',
|
|
Issues = 'issues',
|
|
Label = 'label',
|
|
MergeGroup = 'merge_group',
|
|
Milestone = 'milestone',
|
|
PageBuild = 'page_build',
|
|
Public = 'public',
|
|
PullRequest = 'pull_request',
|
|
PullRequestComment = 'pull_request_comment',
|
|
PullRequestReview = 'pull_request_review',
|
|
PullRequestReviewComment = 'pull_request_review_comment',
|
|
PullRequestTarget = 'pull_request_target',
|
|
Push = 'push',
|
|
RegistryPackage = 'registry_package',
|
|
Release = 'release',
|
|
RepositoryDispatch = 'repository_dispatch',
|
|
Schedule = 'schedule',
|
|
Status = 'status',
|
|
Watch = 'watch',
|
|
WorkflowCall = 'workflow_call',
|
|
WorkflowDispatch = 'workflow_dispatch',
|
|
WorkflowRun = 'workflow_run'
|
|
}
|
|
|
|
export enum Option {
|
|
ActionCachePath = "--action-cache-path",
|
|
ActionOfflineMode = "--action-offline-mode",
|
|
Actor = "--actor",
|
|
ArtifactServerAddr = "--artifact-server-addr",
|
|
ArtifactServerPath = "--artifact-server-path",
|
|
ArtifactServerPort = "--artifact-server-port",
|
|
Bind = "--bind",
|
|
BugReport = "--bug-report",
|
|
CacheServerAddr = "--cache-server-addr",
|
|
CacheServerPath = "--cache-server-path",
|
|
CacheServerPort = "--cache-server-port",
|
|
ContainerArchitecture = "--container-architecture",
|
|
ContainerCapAdd = "--container-cap-add",
|
|
ContainerCapDrop = "--container-cap-drop",
|
|
ContainerDaemonSocket = "--container-daemon-socket",
|
|
ContainerOptions = "--container-options",
|
|
DefaultBranch = "--defaultbranch",
|
|
DetectEvent = "--detect-event",
|
|
Directory = "--directory",
|
|
DryRun = "--dryrun",
|
|
Env = "--env",
|
|
EnvFile = "--env-file",
|
|
EventPath = "--eventpath",
|
|
GithubInstance = "--github-instance",
|
|
Graph = "--graph",
|
|
Help = "--help",
|
|
Input = "--input",
|
|
InputFile = "--input-file",
|
|
InsecureSecrets = "--insecure-secrets",
|
|
Job = "--job",
|
|
Json = "--json",
|
|
List = "--list",
|
|
LocalRepository = "--local-repository",
|
|
LogPrefixJobId = "--log-prefix-job-id",
|
|
ManPage = "--man-page",
|
|
Matrix = "--matrix",
|
|
Network = "--network",
|
|
NoCacheServer = "--no-cache-server",
|
|
NoRecurse = "--no-recurse",
|
|
NoSkipCheckout = "--no-skip-checkout",
|
|
Platform = "--platform",
|
|
Privileged = "--privileged",
|
|
Pull = "--pull",
|
|
Quiet = "--quiet",
|
|
Rebuild = "--rebuild",
|
|
RemoteName = "--remote-name",
|
|
ReplaceGheActionTokenWithGithubCom = "--replace-ghe-action-token-with-github-com",
|
|
ReplaceGheActionWithGithubCom = "--replace-ghe-action-with-github-com",
|
|
Reuse = "--reuse",
|
|
Rm = "--rm",
|
|
Secret = "--secret",
|
|
SecretFile = "--secret-file",
|
|
UseGitignore = "--use-gitignore",
|
|
UseNewActionCache = "--use-new-action-cache",
|
|
Userns = "--userns",
|
|
Var = "--var",
|
|
VarFile = "--var-file",
|
|
Verbose = "--verbose",
|
|
Version = "--version",
|
|
Watch = "--watch",
|
|
Workflows = "--workflows",
|
|
}
|
|
|
|
export interface CommandArgs {
|
|
path: string,
|
|
workflow: Workflow,
|
|
options: string[],
|
|
name: string,
|
|
extraHeader: { key: string, value: string }[]
|
|
}
|
|
|
|
export class Act {
|
|
static defaultActCommand: string = 'act';
|
|
static githubCliActCommand: string = 'gh act';
|
|
context: ExtensionContext;
|
|
storageManager: StorageManager;
|
|
secretManager: SecretManager;
|
|
componentsManager: ComponentsManager;
|
|
workflowsManager: WorkflowsManager;
|
|
historyManager: HistoryManager;
|
|
settingsManager: SettingsManager;
|
|
installationCommands: { [packageManager: string]: string };
|
|
prebuiltExecutables: { [architecture: string]: string };
|
|
refreshInterval: NodeJS.Timeout | undefined;
|
|
runningTaskCount: number;
|
|
|
|
constructor(context: ExtensionContext) {
|
|
this.context = context;
|
|
this.storageManager = new StorageManager(context);
|
|
this.secretManager = new SecretManager(context);
|
|
this.componentsManager = new ComponentsManager();
|
|
this.workflowsManager = new WorkflowsManager();
|
|
this.historyManager = new HistoryManager(this.storageManager);
|
|
this.settingsManager = new SettingsManager(this.storageManager, this.secretManager);
|
|
this.runningTaskCount = 0;
|
|
|
|
switch (process.platform) {
|
|
case 'win32':
|
|
this.installationCommands = {
|
|
'Chocolatey': 'choco install act-cli',
|
|
'Winget': 'winget install nektos.act',
|
|
'Scoop': 'scoop install act',
|
|
'GitHub CLI': '(gh auth status || gh auth login) && gh extension install https://github.com/nektos/gh-act'
|
|
};
|
|
|
|
this.prebuiltExecutables = {
|
|
'Windows 64-bit (arm64/aarch64)': 'https://github.com/nektos/act/releases/latest/download/act_Windows_arm64.zip',
|
|
'Windows 64-bit (amd64/x86_64)': 'https://github.com/nektos/act/releases/latest/download/act_Windows_x86_64.zip',
|
|
'Windows 32-bit (armv7)': 'https://github.com/nektos/act/releases/latest/download/act_Windows_armv7.zip',
|
|
'Windows 32-bit (i386/x86)': 'https://github.com/nektos/act/releases/latest/download/act_Windows_i386.zip'
|
|
};
|
|
break;
|
|
case 'darwin':
|
|
this.installationCommands = {
|
|
'Homebrew': 'brew install act',
|
|
'Nix': 'nix run nixpkgs#act',
|
|
'MacPorts': 'sudo port install act',
|
|
'GitHub CLI': '(gh auth status || gh auth login) && gh extension install https://github.com/nektos/gh-act'
|
|
};
|
|
|
|
this.prebuiltExecutables = {
|
|
'macOS 64-bit (Apple Silicon)': 'https://github.com/nektos/act/releases/latest/download/act_Darwin_arm64.tar.gz',
|
|
'macOS 64-bit (Intel)': 'https://github.com/nektos/act/releases/latest/download/act_Darwin_x86_64.tar.gz'
|
|
};
|
|
break;
|
|
case 'linux':
|
|
this.installationCommands = {
|
|
'Homebrew': 'brew install act',
|
|
'Nix': 'nix run nixpkgs#act',
|
|
'Arch': 'pacman -Syu act',
|
|
'AUR': 'yay -Syu act',
|
|
'COPR': 'dnf copr enable goncalossilva/act && dnf install act-cli',
|
|
'GitHub CLI': '(gh auth status || gh auth login) && gh extension install https://github.com/nektos/gh-act'
|
|
};
|
|
|
|
this.prebuiltExecutables = {
|
|
'Linux 64-bit (arm64/aarch64)': 'https://github.com/nektos/act/releases/latest/download/act_Linux_arm64.tar.gz',
|
|
'Linux 64-bit (amd64/x86_64)': 'https://github.com/nektos/act/releases/latest/download/act_Linux_x86_64.tar.gz',
|
|
'Linux 32-bit (armv7)': 'https://github.com/nektos/act/releases/latest/download/act_Linux_armv7.tar.gz',
|
|
'Linux 32-bit (armv6)': 'https://github.com/nektos/act/releases/latest/download/act_Linux_armv6.tar.gz',
|
|
'Linux 32-bit (i386/x86)': 'https://github.com/nektos/act/releases/latest/download/act_Linux_i386.tar.gz',
|
|
};
|
|
break;
|
|
default:
|
|
this.installationCommands = {};
|
|
this.prebuiltExecutables = {};
|
|
}
|
|
|
|
// Setup automatic history view refreshing
|
|
tasks.onDidStartTask(e => {
|
|
const taskDefinition = e.execution.task.definition;
|
|
if (taskDefinition.type === 'GitHub Local Actions') {
|
|
this.runningTaskCount++;
|
|
|
|
if (!this.refreshInterval && this.runningTaskCount >= 0) {
|
|
this.refreshInterval = setInterval(() => {
|
|
historyTreeDataProvider.refresh();
|
|
}, 1000);
|
|
}
|
|
}
|
|
});
|
|
tasks.onDidEndTask(e => {
|
|
const taskDefinition = e.execution.task.definition;
|
|
if (taskDefinition.type === 'GitHub Local Actions') {
|
|
this.runningTaskCount--;
|
|
|
|
if (this.refreshInterval && this.runningTaskCount === 0) {
|
|
clearInterval(this.refreshInterval);
|
|
this.refreshInterval = undefined;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Refresh components view after installation
|
|
tasks.onDidEndTaskProcess(async e => {
|
|
const taskDefinition = e.execution.task.definition;
|
|
if (taskDefinition.type === 'nektos/act installation' && e.exitCode === 0) {
|
|
this.updateActCommand(taskDefinition.ghCliInstall ? Act.githubCliActCommand : Act.defaultActCommand);
|
|
componentsTreeDataProvider.refresh();
|
|
}
|
|
});
|
|
}
|
|
|
|
static getActCommand() {
|
|
return ConfigurationManager.get<string>(Section.actCommand) || Act.defaultActCommand;
|
|
}
|
|
|
|
updateActCommand(newActCommand: string) {
|
|
const actCommand = ConfigurationManager.get(Section.actCommand);
|
|
|
|
if (newActCommand !== actCommand) {
|
|
window.showInformationMessage(`The act command is currently set to "${actCommand}". Once the installation is complete, it is recommended to update this to "${newActCommand}" for this selected installation method.`, 'Proceed', 'Manually Edit').then(async value => {
|
|
if (value === 'Proceed') {
|
|
await ConfigurationManager.set(Section.actCommand, newActCommand);
|
|
componentsTreeDataProvider.refresh();
|
|
} else if (value === 'Manually Edit') {
|
|
await commands.executeCommand('workbench.action.openSettings', ConfigurationManager.getSearchTerm(Section.actCommand));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
async runAllWorkflows(workspaceFolder: WorkspaceFolder) {
|
|
const workflows = await this.workflowsManager.getWorkflows(workspaceFolder);
|
|
if (workflows.length > 0) {
|
|
for (const workflow of workflows) {
|
|
await this.runWorkflow(workspaceFolder, workflow);
|
|
}
|
|
} else {
|
|
window.showErrorMessage('No workflows found.');
|
|
}
|
|
}
|
|
|
|
async runWorkflow(workspaceFolder: WorkspaceFolder, workflow: Workflow) {
|
|
return await this.runCommand({
|
|
path: workspaceFolder.uri.fsPath,
|
|
workflow: workflow,
|
|
options: [
|
|
`${Option.Workflows} ".github/workflows/${path.parse(workflow.uri.fsPath).base}"`
|
|
],
|
|
name: workflow.name,
|
|
extraHeader: [
|
|
{ key: 'Workflow', value: workflow.name }
|
|
]
|
|
});
|
|
}
|
|
|
|
async runJob(workspaceFolder: WorkspaceFolder, workflow: Workflow, job: Job) {
|
|
return await this.runCommand({
|
|
path: workspaceFolder.uri.fsPath,
|
|
workflow: workflow,
|
|
options: [
|
|
`${Option.Workflows} ".github/workflows/${path.parse(workflow.uri.fsPath).base}"`,
|
|
`${Option.Job} "${job.id}"`
|
|
],
|
|
name: `${workflow.name}/${job.name}`,
|
|
extraHeader: [
|
|
{ key: 'Workflow', value: workflow.name },
|
|
{ key: 'Job', value: job.name }
|
|
]
|
|
});
|
|
}
|
|
|
|
async runEvent(workspaceFolder: WorkspaceFolder, event: Event) {
|
|
let eventExists: boolean = false;
|
|
|
|
const workflows = await this.workflowsManager.getWorkflows(workspaceFolder);
|
|
if (workflows.length > 0) {
|
|
for (const workflow of workflows) {
|
|
if (event in workflow.yaml.on) {
|
|
eventExists = true;
|
|
await this.runWorkflow(workspaceFolder, workflow);
|
|
}
|
|
}
|
|
|
|
if (!eventExists) {
|
|
window.showErrorMessage(`No workflows triggered by the ${event} event.`)
|
|
}
|
|
} else {
|
|
window.showErrorMessage('No workflows found.');
|
|
}
|
|
}
|
|
|
|
async runCommand(commandArgs: CommandArgs) {
|
|
// Check if required components are ready
|
|
// const unreadyComponents = await this.componentsManager.getUnreadyComponents();
|
|
// if (unreadyComponents.length > 0) {
|
|
// window.showErrorMessage(`The following required components are not ready: ${unreadyComponents.map(component => component.name).join(', ')}`, 'Fix...').then(async value => {
|
|
// if (value === 'Fix...') {
|
|
// await commands.executeCommand('components.focus');
|
|
// }
|
|
// });
|
|
// return;
|
|
// }
|
|
|
|
// Map to workspace folder
|
|
const workspaceFolder = workspace.getWorkspaceFolder(Uri.file(commandArgs.path));
|
|
if (!workspaceFolder) {
|
|
window.showErrorMessage(`Failed to locate workspace folder for ${commandArgs.path}`);
|
|
return;
|
|
}
|
|
|
|
// Initialize history for workspace
|
|
if (!this.historyManager.workspaceHistory[commandArgs.path]) {
|
|
this.historyManager.workspaceHistory[commandArgs.path] = [];
|
|
await this.storageManager.update(StorageKey.WorkspaceHistory, this.historyManager.workspaceHistory);
|
|
}
|
|
|
|
// Process task count suffix
|
|
const historyIndex = this.historyManager.workspaceHistory[commandArgs.path].length;
|
|
const matchingTasks = this.historyManager.workspaceHistory[commandArgs.path]
|
|
.filter(history => history.name === commandArgs.name)
|
|
.sort((a, b) => b.count - a.count);
|
|
const count = matchingTasks && matchingTasks.length > 0 ? matchingTasks[0].count + 1 : 1;
|
|
|
|
// Process log file and path
|
|
const start = new Date();
|
|
const year = start.getFullYear();
|
|
const month = (start.getMonth() + 1).toString().padStart(2, '0');
|
|
const day = start.getDate().toString().padStart(2, '0');
|
|
const hours = start.getHours().toString().padStart(2, '0');
|
|
const minutes = start.getMinutes().toString().padStart(2, '0');
|
|
const seconds = start.getSeconds().toString().padStart(2, '0');
|
|
const logFileName = sanitize(`${commandArgs.name} #${count} - ${year}${month}${day}_${hours}${minutes}${seconds}.log`, { replacement: '_' });
|
|
const logPath = path.join(this.context.globalStorageUri.fsPath, logFileName);
|
|
|
|
try {
|
|
await workspace.fs.createDirectory(this.context.globalStorageUri);
|
|
} catch (error: any) { }
|
|
|
|
// Build command with settings
|
|
const actCommand = Act.getActCommand();
|
|
const settings = await this.settingsManager.getSettings(workspaceFolder, true);
|
|
|
|
const userOptions: string[] = [
|
|
...settings.secrets.map(secret => `${Option.Secret} ${secret.key}`),
|
|
(settings.secretFiles.length > 0 ? `${Option.SecretFile} "${settings.secretFiles[0].path}"` : `${Option.SecretFile} ""`),
|
|
...settings.variables.map(variable => `${Option.Var} ${variable.key}=${variable.value}`),
|
|
(settings.variableFiles.length > 0 ? `${Option.VarFile} "${settings.variableFiles[0].path}"` : `${Option.VarFile} ""`),
|
|
...settings.inputs.map(input => `${Option.Input} ${input.key}=${input.value}`),
|
|
(settings.inputFiles.length > 0 ? `${Option.InputFile} "${settings.inputFiles[0].path}"` : `${Option.InputFile} ""`),
|
|
...settings.runners.map(runner => `${Option.Platform} ${runner.key}=${runner.value}`),
|
|
(settings.payloadFiles.length > 0 ? `${Option.EventPath} "${settings.payloadFiles[0].path}"` : `${Option.EventPath} ""`),
|
|
...settings.options.map(option => option.path ? `--${option.name} ${option.path}` : `--${option.name}`)
|
|
];
|
|
|
|
const command = `${actCommand} ${Option.Json} ${commandArgs.options.join(' ')} ${userOptions.join(' ')}`;
|
|
const displayCommand = `${actCommand} ${commandArgs.options.join(' ')} ${userOptions.join(' ')}`;
|
|
|
|
// Execute task
|
|
const taskExecution = await tasks.executeTask({
|
|
name: `${commandArgs.name} #${count}`,
|
|
detail: `${commandArgs.name} #${count}`,
|
|
definition: {
|
|
type: 'GitHub Local Actions',
|
|
commandArgs: commandArgs,
|
|
historyIndex: historyIndex,
|
|
count: count,
|
|
start: start,
|
|
logPath: logPath
|
|
},
|
|
source: 'GitHub Local Actions',
|
|
scope: workspaceFolder || TaskScope.Workspace,
|
|
isBackground: true,
|
|
presentationOptions: {
|
|
reveal: TaskRevealKind.Always,
|
|
focus: false,
|
|
clear: true,
|
|
close: false,
|
|
echo: true,
|
|
panel: TaskPanelKind.Dedicated,
|
|
showReuseMessage: false
|
|
},
|
|
problemMatchers: [],
|
|
runOptions: {},
|
|
group: TaskGroup.Build,
|
|
execution: new CustomExecution(async (resolvedDefinition: TaskDefinition): Promise<Pseudoterminal> => {
|
|
const writeEmitter = new EventEmitter<string>();
|
|
const closeEmitter = new EventEmitter<number>();
|
|
|
|
writeEmitter.event(async data => {
|
|
try {
|
|
// Create log file if it does not exist
|
|
try {
|
|
await fs.access(logPath);
|
|
} catch (error: any) {
|
|
await fs.writeFile(logPath, '');
|
|
}
|
|
|
|
// Append data to log file
|
|
await fs.appendFile(logPath, data);
|
|
} catch (error: any) { }
|
|
});
|
|
|
|
const handleIO = () => {
|
|
let lastline: string = "";
|
|
return async (data: any) => {
|
|
let xdata: string = data.toString();
|
|
let lines: string[] = xdata.split('\n').filter((line: string) => line !== '');
|
|
if (lastline?.length > 0) {
|
|
lines[0] = lastline + lines[0];
|
|
lastline = "";
|
|
}
|
|
if (!xdata.endsWith("\n")) {
|
|
lastline = lines.pop() || "";
|
|
}
|
|
for await (const line of lines) {
|
|
const dateString = new Date().toString();
|
|
|
|
let message: string;
|
|
try {
|
|
const parsedMessage = JSON.parse(line);
|
|
if (typeof parsedMessage.msg === 'string') {
|
|
message = `${parsedMessage.job ? `[${parsedMessage.job}] ` : ``}${parsedMessage.msg}`;
|
|
} else {
|
|
message = line;
|
|
}
|
|
|
|
// Update job and step status in workspace history
|
|
if (parsedMessage.jobID) {
|
|
let jobName: string = parsedMessage.jobID;
|
|
try {
|
|
if (parsedMessage.jobID in commandArgs.workflow.yaml.jobs && commandArgs.workflow.yaml.jobs[parsedMessage.jobID].name) {
|
|
jobName = commandArgs.workflow.yaml.jobs[parsedMessage.jobID].name;
|
|
}
|
|
} catch (error: any) { }
|
|
|
|
let jobIndex = this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs!
|
|
.findIndex(job => job.name === jobName);
|
|
if (jobIndex < 0) {
|
|
|
|
// Add new job with setup step
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs!.push({
|
|
name: jobName,
|
|
status: HistoryStatus.Running,
|
|
date: {
|
|
start: dateString
|
|
},
|
|
steps: [
|
|
{
|
|
id: "--setup-job", // Special id for setup job
|
|
name: 'Setup Job',
|
|
status: HistoryStatus.Running,
|
|
date: {
|
|
start: dateString
|
|
}
|
|
}
|
|
]
|
|
});
|
|
jobIndex = this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs!.length - 1;
|
|
}
|
|
|
|
const isCompleteJobStep = this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps!.length > 1;
|
|
if (parsedMessage.stepID || isCompleteJobStep) {
|
|
let stepName: string;
|
|
let stepId: string;
|
|
if (!parsedMessage.stepID && isCompleteJobStep) {
|
|
stepName = 'Complete Job';
|
|
stepId = "--complete-job"; // Special Id for complete job
|
|
} else {
|
|
stepName = parsedMessage.stage !== 'Main' ? `${parsedMessage.stage} ${parsedMessage.step}` : parsedMessage.step;
|
|
stepId = parsedMessage.stepID[0];
|
|
}
|
|
|
|
if (this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![0].status === HistoryStatus.Running) {
|
|
// TODO: How to know if setup job step failed?
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![0].status = HistoryStatus.Success;
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![0].date.end = dateString;
|
|
}
|
|
|
|
let stepIndex = this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps!
|
|
.findIndex(step => step.id === stepId && step.name === stepName);
|
|
if (stepIndex < 0) {
|
|
// Add new step
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps!.push({
|
|
id: stepId,
|
|
name: stepName,
|
|
status: HistoryStatus.Running,
|
|
date: {
|
|
start: dateString
|
|
}
|
|
});
|
|
stepIndex = this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps!.length - 1;
|
|
}
|
|
|
|
if (parsedMessage.stepResult) {
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![stepIndex].status =
|
|
parsedMessage.stepResult === 'success' ? HistoryStatus.Success : HistoryStatus.Failed;
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![stepIndex].date.end = dateString;
|
|
}
|
|
}
|
|
|
|
if (parsedMessage.jobResult) {
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].status =
|
|
parsedMessage.jobResult === 'success' ? HistoryStatus.Success : HistoryStatus.Failed;
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].date.end =
|
|
dateString;
|
|
}
|
|
}
|
|
} catch (error: any) {
|
|
message = line;
|
|
}
|
|
|
|
if (userOptions.includes(Option.Json)) {
|
|
message = line;
|
|
}
|
|
|
|
writeEmitter.fire(`${message.trimEnd()}\r\n`);
|
|
historyTreeDataProvider.refresh();
|
|
}
|
|
await this.storageManager.update(StorageKey.WorkspaceHistory, this.historyManager.workspaceHistory);
|
|
}
|
|
};
|
|
|
|
let shell = env.shell;
|
|
switch (process.platform) {
|
|
case Platform.windows:
|
|
shell = 'cmd';
|
|
break;
|
|
case Platform.mac:
|
|
shell = 'zsh';
|
|
break;
|
|
case Platform.linux:
|
|
shell = 'bash';
|
|
break;
|
|
}
|
|
|
|
const exec = childProcess.spawn(
|
|
command,
|
|
{
|
|
cwd: commandArgs.path,
|
|
shell: shell,
|
|
env: {
|
|
...process.env,
|
|
...settings.secrets
|
|
.filter(secret => secret.value)
|
|
.reduce((previousValue, currentValue) => {
|
|
previousValue[currentValue.key] = currentValue.value;
|
|
return previousValue;
|
|
}, {} as Record<string, string>)
|
|
}
|
|
}
|
|
);
|
|
exec.stdout.on('data', handleIO());
|
|
exec.stderr.on('data', handleIO());
|
|
exec.on('exit', async (code, signal) => {
|
|
const dateString = new Date().toString();
|
|
|
|
// Set execution status and end time in workspace history
|
|
if (this.historyManager.workspaceHistory[commandArgs.path][historyIndex].status === HistoryStatus.Running) {
|
|
const jobAndStepStatus = (!code && code !== 0) ? HistoryStatus.Cancelled : HistoryStatus.Unknown;
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs?.forEach((job, jobIndex) => {
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps?.forEach((step, stepIndex) => {
|
|
if (step.status === HistoryStatus.Running) {
|
|
// Update status of all running steps
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![stepIndex].status = jobAndStepStatus;
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].steps![stepIndex].date.end = dateString;
|
|
}
|
|
});
|
|
|
|
if (job.status === HistoryStatus.Running) {
|
|
// Update status of all running jobs
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].status = jobAndStepStatus;
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].jobs![jobIndex].date.end = dateString;
|
|
}
|
|
});
|
|
|
|
// Update history status
|
|
if (code === 0) {
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].status = HistoryStatus.Success;
|
|
} else if (!code) {
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].status = HistoryStatus.Cancelled;
|
|
} else {
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].status = HistoryStatus.Failed;
|
|
}
|
|
}
|
|
this.historyManager.workspaceHistory[commandArgs.path][historyIndex].date.end = dateString;
|
|
historyTreeDataProvider.refresh();
|
|
await this.storageManager.update(StorageKey.WorkspaceHistory, this.historyManager.workspaceHistory);
|
|
|
|
if (signal === 'SIGINT') {
|
|
writeEmitter.fire(`\r\nTask interrupted.\r\n`);
|
|
closeEmitter.fire(code || 1);
|
|
} else {
|
|
writeEmitter.fire(`\r\nTask exited with exit code ${code}.\r\n`);
|
|
closeEmitter.fire(code || 0);
|
|
}
|
|
});
|
|
exec.on('close', (code) => {
|
|
closeEmitter.fire(code || 0);
|
|
});
|
|
|
|
return {
|
|
onDidWrite: writeEmitter.event,
|
|
onDidClose: closeEmitter.event,
|
|
open: async (initialDimensions: TerminalDimensions | undefined): Promise<void> => {
|
|
writeEmitter.fire(`${displayCommand}\r\n\r\n`);
|
|
},
|
|
handleInput: (data: string) => {
|
|
if (data === '\x03') {
|
|
exec.kill('SIGINT');
|
|
exec.stdout.destroy();
|
|
exec.stdin.destroy();
|
|
exec.stderr.destroy();
|
|
} else {
|
|
exec.stdin.write(data === '\r' ? '\r\n' : data);
|
|
}
|
|
},
|
|
close: () => {
|
|
exec.kill('SIGINT');
|
|
exec.stdout.destroy();
|
|
exec.stdin.destroy();
|
|
exec.stderr.destroy();
|
|
},
|
|
};
|
|
})
|
|
});
|
|
|
|
// Add new entry to workspace history
|
|
this.historyManager.workspaceHistory[commandArgs.path].push({
|
|
index: historyIndex,
|
|
count: count,
|
|
name: `${commandArgs.name}`,
|
|
status: HistoryStatus.Running,
|
|
date: {
|
|
start: start.toString()
|
|
},
|
|
taskExecution: taskExecution,
|
|
commandArgs: commandArgs,
|
|
logPath: logPath,
|
|
jobs: []
|
|
});
|
|
historyTreeDataProvider.refresh();
|
|
await this.storageManager.update(StorageKey.WorkspaceHistory, this.historyManager.workspaceHistory);
|
|
}
|
|
|
|
async install(packageManager: string) {
|
|
const command = this.installationCommands[packageManager];
|
|
if (command) {
|
|
await tasks.executeTask({
|
|
name: 'nektos/act',
|
|
detail: 'Install nektos/act',
|
|
definition: {
|
|
type: 'nektos/act installation',
|
|
ghCliInstall: command.includes('gh-act')
|
|
},
|
|
source: 'GitHub Local Actions',
|
|
scope: TaskScope.Workspace,
|
|
isBackground: true,
|
|
presentationOptions: {
|
|
reveal: TaskRevealKind.Always,
|
|
focus: false,
|
|
clear: true,
|
|
close: false,
|
|
echo: true,
|
|
panel: TaskPanelKind.Shared,
|
|
showReuseMessage: false
|
|
},
|
|
problemMatchers: [],
|
|
runOptions: {},
|
|
group: TaskGroup.Build,
|
|
execution: new ShellExecution(command)
|
|
});
|
|
}
|
|
}
|
|
} |