Repository navigation
Expand file tree
/
Copy pathtar.ts
More file actions
244 lines (219 loc) · 7.14 KB
/
Copy pathtar.ts
File metadata and controls
244 lines (219 loc) · 7.14 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
import { spawn } from "child_process";
import * as fs from "fs";
import * as stream from "stream";
import { ToolRunner } from "@actions/exec/lib/toolrunner";
import * as io from "@actions/io";
import * as toolcache from "@actions/tool-cache";
import * as semver from "semver";
import { CommandInvocationError } from "./actions-util";
import { Logger } from "./logging";
import { assertNever, cleanUpPath, isBinaryAccessible } from "./util";
const MIN_REQUIRED_BSD_TAR_VERSION = "3.4.3";
const MIN_REQUIRED_GNU_TAR_VERSION = "1.31";
export type TarVersion = {
type: "gnu" | "bsd";
version: string;
};
async function getTarVersion(): Promise<TarVersion> {
const tar = await io.which("tar", true);
let stdout = "";
const exitCode = await new ToolRunner(tar, ["--version"], {
listeners: {
stdout: (data: Buffer) => {
stdout += data.toString();
},
},
}).exec();
if (exitCode !== 0) {
throw new Error("Failed to call tar --version");
}
// Return whether this is GNU tar or BSD tar, and the version number
if (stdout.includes("GNU tar")) {
const match = stdout.match(/tar \(GNU tar\) ([0-9.]+)/);
if (!match?.[1]) {
throw new Error("Failed to parse output of tar --version.");
}
return { type: "gnu", version: match[1] };
} else if (stdout.includes("bsdtar")) {
const match = stdout.match(/bsdtar ([0-9.]+)/);
if (!match?.[1]) {
throw new Error("Failed to parse output of tar --version.");
}
return { type: "bsd", version: match[1] };
} else {
throw new Error("Unknown tar version");
}
}
export interface ZstdAvailability {
available: boolean;
foundZstdBinary: boolean;
version?: TarVersion;
}
export async function isZstdAvailable(
logger: Logger,
): Promise<ZstdAvailability> {
const foundZstdBinary = await isBinaryAccessible("zstd", logger);
try {
const tarVersion = await getTarVersion();
const { type, version } = tarVersion;
logger.info(`Found ${type} tar version ${version}.`);
switch (type) {
case "gnu":
return {
available:
foundZstdBinary &&
// GNU tar only uses major and minor version numbers
semver.gte(
semver.coerce(version)!,
semver.coerce(MIN_REQUIRED_GNU_TAR_VERSION)!,
),
foundZstdBinary,
version: tarVersion,
};
case "bsd":
return {
available:
foundZstdBinary &&
// Do a loose comparison since these version numbers don't contain
// a patch version number.
semver.gte(version, MIN_REQUIRED_BSD_TAR_VERSION),
foundZstdBinary,
version: tarVersion,
};
default:
assertNever(type);
}
} catch (e) {
logger.warning(
"Failed to determine tar version, therefore will assume zstd is not available. " +
`The underlying error was: ${e}`,
);
return { available: false, foundZstdBinary };
}
}
export type CompressionMethod = "gzip" | "zstd";
export async function extract(
tarPath: string,
dest: string,
compressionMethod: CompressionMethod,
tarVersion: TarVersion | undefined,
logger: Logger,
): Promise<string> {
// Ensure destination exists
fs.mkdirSync(dest, { recursive: true });
switch (compressionMethod) {
case "gzip":
// Defensively continue to call the toolcache API as requesting a gzipped
// bundle may be a fallback option.
return await toolcache.extractTar(tarPath, dest);
case "zstd": {
if (!tarVersion) {
throw new Error(
"Could not determine tar version, which is required to extract a Zstandard archive.",
);
}
await extractTarZst(tarPath, dest, tarVersion, logger);
return dest;
}
}
}
/**
* Extract a compressed tar archive
*
* @param tar tar stream, or path to the tar
* @param dest destination directory
*/
export async function extractTarZst(
tar: stream.Readable | string,
dest: string,
tarVersion: TarVersion,
logger: Logger,
): Promise<void> {
logger.debug(
`Extracting to ${dest}.${
tar instanceof stream.Readable
? ` Input stream has high water mark ${tar.readableHighWaterMark}.`
: ""
}`,
);
try {
// Initialize args
//
// `--ignore-zeros` means that trailing zero bytes at the end of an archive will be read
// by `tar` in case a further concatenated archive follows. Otherwise when a tarball built
// by GNU tar, which writes many trailing zeroes, is read by BSD tar, which expects less, then
// BSD tar can hang up the pipe to its filter program early, and if that program is `zstd`
// then it will try to write the remaining zeroes, get an EPIPE error because `tar` has closed
// its end of the pipe, return 1, and `tar` will pass the error along.
//
// See also https://github.com/facebook/zstd/issues/4294
const args = ["-x", "--zstd", "--ignore-zeros"];
if (tarVersion.type === "gnu") {
// Suppress warnings when using GNU tar to extract archives created by BSD tar
args.push("--warning=no-unknown-keyword");
args.push("--overwrite");
}
args.push("-f", tar instanceof stream.Readable ? "-" : tar, "-C", dest);
process.stdout.write(`[command]tar ${args.join(" ")}\n`);
await new Promise<void>((resolve, reject) => {
const tarProcess = spawn("tar", args, { stdio: "pipe" });
let stdout = "";
tarProcess.stdout?.on("data", (data: Buffer) => {
stdout += data.toString();
process.stdout.write(data);
});
let stderr = "";
tarProcess.stderr?.on("data", (data: Buffer) => {
stderr += data.toString();
// Mimic the standard behavior of the toolrunner by writing stderr to stdout
process.stdout.write(data);
});
tarProcess.on("error", (err) => {
reject(new Error(`Error while extracting tar: ${err}`));
});
if (tar instanceof stream.Readable) {
// Use `pipeline` rather than `pipe` so that an error on either stream is reported here
// rather than being emitted as an unhandled `error` event, and so that `tar`'s standard
// input is closed if the download fails partway through.
stream.pipeline(tar, tarProcess.stdin, (err) => {
if (err) {
reject(
new Error(`Error while downloading and extracting tar: ${err}`),
);
}
});
}
tarProcess.on("exit", (code) => {
if (code !== 0) {
reject(
new CommandInvocationError(
"tar",
args,
code ?? undefined,
stdout,
stderr,
),
);
}
resolve();
});
});
} catch (e) {
await cleanUpPath(dest, "extraction destination directory", logger);
throw e;
}
}
const KNOWN_EXTENSIONS: Record<string, CompressionMethod> = {
"tar.gz": "gzip",
"tar.zst": "zstd",
};
export function inferCompressionMethod(
tarPath: string,
): CompressionMethod | undefined {
for (const [ext, method] of Object.entries(KNOWN_EXTENSIONS)) {
if (tarPath.endsWith(`.${ext}`)) {
return method;
}
}
return undefined;
}