mirror of
https://github.com/ivabus/pantry
synced 2024-11-27 02:35:08 +03:00
129 lines
No EOL
3.5 KiB
TypeScript
Executable file
129 lines
No EOL
3.5 KiB
TypeScript
Executable file
#!/usr/bin/env -S tea -E
|
|
|
|
/* ---
|
|
args:
|
|
- deno
|
|
- run
|
|
- --allow-net
|
|
- --allow-run
|
|
- --allow-env
|
|
- --allow-read=/opt/
|
|
- --allow-write=/opt/
|
|
- --import-map={{ srcroot }}/import-map.json
|
|
--- */
|
|
|
|
import { Installation, parsePackageRequirement } from "types"
|
|
import { Path } from "types"
|
|
import useCellar from "hooks/useCellar.ts"
|
|
import { run } from "utils"
|
|
import useCache from "hooks/useCache.ts"
|
|
import useFlags from "hooks/useFlags.ts"
|
|
import { crypto } from "deno/crypto/mod.ts"
|
|
import { encodeToString } from "encodeToString"
|
|
|
|
useFlags()
|
|
|
|
const cellar = useCellar()
|
|
const filesListName = 'files.txt'
|
|
|
|
const bottles: Path[] = []
|
|
const fileLists: Path[] = []
|
|
for (const pkg of Deno.args.map(parsePackageRequirement)) {
|
|
console.log({ bottling: { pkg } })
|
|
|
|
const installation = await cellar.resolve(pkg)
|
|
const path = await bottle(installation)
|
|
const checksum = await sha256(path)
|
|
|
|
if (!path) throw new Error("wtf: bottle already exists")
|
|
if (!checksum) throw new Error("failed to compute checksum")
|
|
|
|
console.log({ bottled: { path } })
|
|
|
|
bottles.push(path)
|
|
bottles.push(checksum)
|
|
fileLists.push(installation.path.join(filesListName))
|
|
}
|
|
|
|
if (bottles.length === 0) throw new Error("no input provided")
|
|
|
|
const encode = (() => { const e = new TextEncoder(); return e.encode.bind(e) })()
|
|
|
|
const bottleList = bottles.map(x => x.string).join(" ")
|
|
await Deno.stdout.write(encode(`::set-output name=bottles::${bottleList}\n`))
|
|
|
|
const paths = [...bottles, ...fileLists].map(x => x.string).join('%0A')
|
|
await Deno.stdout.write(encode(`::set-output name=filenames::${paths}\n`))
|
|
|
|
|
|
//------------------------------------------------------------------------- funcs
|
|
async function bottle({ path: kegdir, pkg }: Installation): Promise<Path> {
|
|
|
|
const files = await walk(kegdir, path => {
|
|
/// HACK: `go` requires including the `src` dir
|
|
const isGo = kegdir.string.match(/\/go.dev\//)
|
|
switch (path.relative({ to: kegdir })) {
|
|
case 'src':
|
|
return isGo ? 'accumulate' : 'skip'
|
|
case 'build.sh':
|
|
case filesListName:
|
|
return 'skip'
|
|
default:
|
|
return 'accumulate'
|
|
}
|
|
})
|
|
const relativePaths = files.map(x => x.relative({ to: cellar.prefix }))
|
|
const filelist = kegdir
|
|
.join(filesListName)
|
|
.write({
|
|
text: relativePaths.join("\n")
|
|
})
|
|
const tarball = useCache().bottle(pkg)
|
|
|
|
await run({
|
|
cmd: [
|
|
"tar", "zcf", tarball, "--files-from", filelist
|
|
],
|
|
cwd: cellar.prefix
|
|
})
|
|
|
|
return tarball
|
|
}
|
|
|
|
// using our own because of: https://github.com/denoland/deno_std/issues/1359
|
|
// but frankly this also is more suitable for our needs here
|
|
type Continuation = 'accumulate' | 'skip'
|
|
|
|
export async function walk(root: Path, body: (entry: Path) => Continuation): Promise<Path[]> {
|
|
const rv: Path[] = []
|
|
const stack: Path[] = [root]
|
|
|
|
do {
|
|
root = stack.pop()!
|
|
for await (const [path, entry] of root.ls()) {
|
|
switch (body(path)) {
|
|
case 'accumulate':
|
|
if (entry.isDirectory) {
|
|
stack.push(path)
|
|
} else {
|
|
rv.push(path)
|
|
}
|
|
break
|
|
case 'skip':
|
|
continue
|
|
}
|
|
}
|
|
} while (stack.length > 0)
|
|
|
|
return rv
|
|
}
|
|
|
|
async function sha256(file: Path): Promise<Path> {
|
|
const file_contents = await Deno.readFile(file.string)
|
|
const checksum = encodeToString(new Uint8Array(await crypto.subtle.digest("SHA-256", file_contents)))
|
|
const checksum_contents = new TextEncoder().encode(`${checksum} ${file.basename()}`)
|
|
const checksum_file = new Path(`${file.string}.sha256sum`)
|
|
await Deno.writeFile(checksum_file.string, checksum_contents)
|
|
|
|
return checksum_file
|
|
} |