From 42ec8de762bce2ef549fcfb8005fc1dfce66d4ae Mon Sep 17 00:00:00 2001 From: eric sciple Date: Mon, 18 Nov 2019 16:20:01 -0500 Subject: [PATCH] toolrunner should which tool before invoking (#220) --- README.md | 7 +- __tests__/exec.test.ts | 196 +++++++++++++++++++++++++++ __tests__/scripts/print-args-cmd.cmd | 12 ++ __tests__/scripts/print-args-sh.sh | 11 ++ package.json | 2 +- src/toolrunner.ts | 21 +++ 6 files changed, 243 insertions(+), 6 deletions(-) create mode 100644 __tests__/scripts/print-args-cmd.cmd create mode 100755 __tests__/scripts/print-args-sh.sh diff --git a/README.md b/README.md index e3eff74..7897ba5 100644 --- a/README.md +++ b/README.md @@ -48,13 +48,10 @@ await exec.exec('node', ['index.js', 'foo=bar'], options); #### Exec tools not in the PATH -You can use it in conjunction with the `which` function from `@actions/io` to execute tools that are not in the PATH: +You can specify the full path for tools not in the PATH: ```js const exec = require('@actions/exec'); -const io = require('@actions/io'); -const pythonPath: string = await io.which('python', true) - -await exec.exec(`"${pythonPath}"`, ['main.py']); +await exec.exec('"/path/to/my-tool"', ['arg1']); ``` diff --git a/__tests__/exec.test.ts b/__tests__/exec.test.ts index e0b6964..c0a5dda 100644 --- a/__tests__/exec.test.ts +++ b/__tests__/exec.test.ts @@ -121,6 +121,38 @@ describe('@actions/exec', () => { } }) + it('Runs exec successfully with command from PATH', async () => { + const execOptions = getExecOptions() + const outStream = new StringStream() + execOptions.outStream = outStream + let output = '' + execOptions.listeners = { + stdout: (data: Buffer) => { + output += data.toString() + } + } + + let exitCode = 1 + let tool: string + let args: string[] + if (IS_WINDOWS) { + tool = 'cmd' + args = ['/c', 'echo', 'hello'] + } else { + tool = 'sh' + args = ['-c', 'echo hello'] + } + + exitCode = await exec.exec(tool, args, execOptions) + + expect(exitCode).toBe(0) + const rootedTool = await io.which(tool, true) + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${rootedTool} ${args.join(' ')}` + ) + expect(output.trim()).toBe(`hello`) + }) + it('Exec fails with error on bad call', async () => { const _testExecOptions = getExecOptions() @@ -418,6 +450,134 @@ describe('@actions/exec', () => { fs.unlinkSync(semaphorePath) }) + it('Exec roots relative tool path using unrooted options.cwd', async () => { + let exitCode: number + let command: string + if (IS_WINDOWS) { + command = './print-args-cmd' // let ToolRunner resolve the extension + } else { + command = './print-args-sh.sh' + } + const execOptions = getExecOptions() + execOptions.cwd = 'scripts' + const outStream = new StringStream() + execOptions.outStream = outStream + let output = '' + execOptions.listeners = { + stdout: (data: Buffer) => { + output += data.toString() + } + } + + const originalCwd = process.cwd() + try { + process.chdir(__dirname) + exitCode = await exec.exec(`${command} hello world`, [], execOptions) + } catch (err) { + process.chdir(originalCwd) + throw err + } + + expect(exitCode).toBe(0) + const toolPath = path.resolve( + __dirname, + execOptions.cwd, + `${command}${IS_WINDOWS ? '.cmd' : ''}` + ) + if (IS_WINDOWS) { + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${process.env.ComSpec} /D /S /C "${toolPath} hello world"` + ) + } else { + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${toolPath} hello world` + ) + } + expect(output.trim()).toBe(`args[0]: "hello"${os.EOL}args[1]: "world"`) + }) + + it('Exec roots relative tool path using rooted options.cwd', async () => { + let command: string + if (IS_WINDOWS) { + command = './print-args-cmd' // let ToolRunner resolve the extension + } else { + command = './print-args-sh.sh' + } + const execOptions = getExecOptions() + execOptions.cwd = path.join(__dirname, 'scripts') + const outStream = new StringStream() + execOptions.outStream = outStream + let output = '' + execOptions.listeners = { + stdout: (data: Buffer) => { + output += data.toString() + } + } + + const exitCode = await exec.exec(`${command} hello world`, [], execOptions) + + expect(exitCode).toBe(0) + const toolPath = path.resolve( + __dirname, + execOptions.cwd, + `${command}${IS_WINDOWS ? '.cmd' : ''}` + ) + if (IS_WINDOWS) { + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${process.env.ComSpec} /D /S /C "${toolPath} hello world"` + ) + } else { + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${toolPath} hello world` + ) + } + expect(output.trim()).toBe(`args[0]: "hello"${os.EOL}args[1]: "world"`) + }) + + it('Exec roots relative tool path using process.cwd', async () => { + let exitCode: number + let command: string + if (IS_WINDOWS) { + command = 'scripts/print-args-cmd' // let ToolRunner resolve the extension + } else { + command = 'scripts/print-args-sh.sh' + } + const execOptions = getExecOptions() + const outStream = new StringStream() + execOptions.outStream = outStream + let output = '' + execOptions.listeners = { + stdout: (data: Buffer) => { + output += data.toString() + } + } + + const originalCwd = process.cwd() + try { + process.chdir(__dirname) + exitCode = await exec.exec(`${command} hello world`, [], execOptions) + } catch (err) { + process.chdir(originalCwd) + throw err + } + + expect(exitCode).toBe(0) + const toolPath = path.resolve( + __dirname, + `${command}${IS_WINDOWS ? '.cmd' : ''}` + ) + if (IS_WINDOWS) { + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${process.env.ComSpec} /D /S /C "${toolPath} hello world"` + ) + } else { + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${toolPath} hello world` + ) + } + expect(output.trim()).toBe(`args[0]: "hello"${os.EOL}args[1]: "world"`) + }) + if (IS_WINDOWS) { // Win specific quoting tests it('execs .exe with verbatim args (Windows)', async () => { @@ -572,6 +732,42 @@ describe('@actions/exec', () => { ) }) + it('execs .cmd from path (Windows)', async () => { + // this test validates whether a .cmd is resolved from the PATH when the extension is not specified + const cmd = 'print-args-cmd' // note, not print-args-cmd.cmd + const cmdPath = path.join(__dirname, 'scripts', `${cmd}.cmd`) + const args: string[] = ['my arg 1', 'my arg 2'] + const outStream = new StringStream() + let output = '' + const options = { + outStream: outStream, + listeners: { + stdout: (data: Buffer) => { + output += data.toString() + } + } + } + + const originalPath = process.env['Path'] + try { + process.env['Path'] = `${originalPath};${path.dirname(cmdPath)}` + const exitCode = await exec.exec(`${cmd}`, args, options) + expect(exitCode).toBe(0) + expect(outStream.getContents().split(os.EOL)[0]).toBe( + `[command]${ + process.env.ComSpec + } /D /S /C "${cmdPath} "my arg 1" "my arg 2""` + ) + expect(output.trim()).toBe( + 'args[0]: "my arg 1"\r\n' + + 'args[1]: "my arg 2"' + ) + } catch (err) { + process.env['Path'] = originalPath + throw err + } + }) + it('execs .cmd with arg quoting (Windows)', async () => { // this test validates .cmd quoting rules are applied, not the default libuv rules const cmdPath = path.join( diff --git a/__tests__/scripts/print-args-cmd.cmd b/__tests__/scripts/print-args-cmd.cmd new file mode 100644 index 0000000..7f3e4e6 --- /dev/null +++ b/__tests__/scripts/print-args-cmd.cmd @@ -0,0 +1,12 @@ +@echo off +setlocal +set index=0 + +:check_arg +set arg=%1 +if not defined arg goto :eof +set "arg=%arg:"=%" +echo args[%index%]: "%arg%" +set /a index=%index%+1 +shift +goto check_arg \ No newline at end of file diff --git a/__tests__/scripts/print-args-sh.sh b/__tests__/scripts/print-args-sh.sh new file mode 100755 index 0000000..40f18cb --- /dev/null +++ b/__tests__/scripts/print-args-sh.sh @@ -0,0 +1,11 @@ +#!/usr/bin/env bash + +# store arguments in a special array +args=("$@") +# get number of elements +ELEMENTS=${#args[@]} + +# echo each element +for (( i=0;i<$ELEMENTS;i++)); do + echo "args[$i]: \"${args[${i}]}\"" +done \ No newline at end of file diff --git a/package.json b/package.json index a57920e..ee3a773 100644 --- a/package.json +++ b/package.json @@ -32,7 +32,7 @@ "bugs": { "url": "https://github.com/actions/toolkit/issues" }, - "devDependencies": { + "dependencies": { "@actions/io": "^1.0.1" } } diff --git a/src/toolrunner.ts b/src/toolrunner.ts index 32dc5f9..2182fed 100644 --- a/src/toolrunner.ts +++ b/src/toolrunner.ts @@ -1,8 +1,11 @@ import * as os from 'os' import * as events from 'events' import * as child from 'child_process' +import * as path from 'path' import * as stream from 'stream' import * as im from './interfaces' +import * as io from '@actions/io' +import * as ioUtil from '@actions/io/lib/io-util' /* eslint-disable @typescript-eslint/unbound-method */ @@ -392,6 +395,24 @@ export class ToolRunner extends events.EventEmitter { * @returns number */ async exec(): Promise { + // root the tool path if it is unrooted and contains relative pathing + if ( + !ioUtil.isRooted(this.toolPath) && + (this.toolPath.includes('/') || + (IS_WINDOWS && this.toolPath.includes('\\'))) + ) { + // prefer options.cwd if it is specified, however options.cwd may also need to be rooted + this.toolPath = path.resolve( + process.cwd(), + this.options.cwd || process.cwd(), + this.toolPath + ) + } + + // if the tool is only a file name, then resolve it from the PATH + // otherwise verify it exists (add extension on Windows if necessary) + this.toolPath = await io.which(this.toolPath, true) + return new Promise((resolve, reject) => { this._debug(`exec tool: ${this.toolPath}`) this._debug('arguments:')