pantry/scripts/build/build.ts

168 lines
5 KiB
TypeScript
Raw Normal View History

import { useCellar, usePantry, usePrefix } from "hooks"
2022-09-20 14:53:40 +03:00
import { link, hydrate } from "prefab"
import { Installation, Package } from "types"
import useShellEnv, { expand } from "hooks/useShellEnv.ts"
import { run, undent, host, tuplize } from "utils"
import { str as pkgstr } from "utils/pkg.ts"
import fix_pkg_config_files from "./fix-pkg-config-files.ts"
2022-09-20 14:53:40 +03:00
import Path from "path"
const cellar = useCellar()
const pantry = usePantry()
2022-09-20 14:53:40 +03:00
const { platform } = host()
export interface BuildResult {
installation: Installation
src?: Path
}
export default async function _build(pkg: Package): Promise<BuildResult> {
2022-09-23 16:54:00 +03:00
try {
2022-09-28 18:14:46 +03:00
return await __build(pkg)
2022-09-23 16:54:00 +03:00
} catch (e) {
2022-09-25 15:41:58 +03:00
cellar.keg(pkg).isDirectory()?.isEmpty()?.rm() // dont leave empty kegs around
2022-09-23 16:54:00 +03:00
throw e
}
}
async function __build(pkg: Package): Promise<BuildResult> {
2022-09-25 15:41:58 +03:00
const [deps, wet, resolved] = await calc_deps()
await clean()
2022-11-28 18:52:20 +03:00
const env = await mkenv()
2022-09-23 16:54:00 +03:00
const dst = cellar.keg(pkg).mkpath()
const [src, src_tarball] = await fetch_src(pkg) ?? []
const installation = await build()
await link(installation)
await fix_binaries(installation)
await fix_pkg_config_files(installation)
return { installation, src: src_tarball }
//////// utils
async function calc_deps() {
const deps = await pantry.getDeps(pkg)
2022-10-26 04:55:49 +03:00
const wet = await hydrate([...deps.runtime, ...deps.build])
deps.runtime.push(...wet.pkgs)
2022-09-25 15:41:58 +03:00
const resolved = await Promise.all(wet.pkgs.map(pkg => cellar.resolve(pkg)))
return tuplize(deps, wet, resolved)
}
async function clean() {
const installation = await should_clean()
// If we clean deno.land, it breaks the rest of the process.
if (installation && installation.pkg.project !== "deno.land") {
console.log({ cleaning: installation.path })
2022-09-23 16:54:00 +03:00
for await (const [path] of installation.path.ls()) {
// we delete contents rather than the directory itself to prevent broken vx.y symlinks
path.rm({ recursive: true })
}
}
async function should_clean() {
if (pkg.project == 'tea.xyz') return
// only required as we aren't passing everything into hydrate
const depends_on_self = () => deps.build.some(x => x.project === pkg.project)
2022-09-20 14:53:40 +03:00
const wet_dep = () => wet.pkgs.some(x => x.project === pkg.project)
// provided this package doesn't transitively depend on itself (yes this happens)
// clean out the destination prefix first
2022-09-20 14:53:40 +03:00
if (!wet.bootstrap_required.has(pkg.project) && !depends_on_self() && !wet_dep()) {
2022-09-21 10:46:24 +03:00
return await cellar.has(pkg)
}
}
}
2022-11-28 18:52:20 +03:00
async function mkenv() {
const env = await useShellEnv({ installations: resolved})
if (platform == 'darwin') {
2022-10-07 17:51:40 +03:00
env['MACOSX_DEPLOYMENT_TARGET'] = ['11.0']
}
2023-01-24 17:10:36 +03:00
env['PATH'].push("$PATH")
return env
}
async function build() {
const bld = src ?? Path.mktmp({ prefix: pkg.project }).join("wd").mkdir()
2022-09-25 15:41:58 +03:00
const sh = await pantry.getScript(pkg, 'build', resolved)
2022-12-01 16:42:25 +03:00
const brewkit = new URL(import.meta.url).path().parent().parent().join("brewkit")
const cmd = bld.parent().join("build.sh").write({ force: true, text: undent`
#!/bin/bash
set -e
set -o pipefail
set -x
cd "${bld}"
export SRCROOT="${bld}"
2022-10-07 17:51:40 +03:00
${expand(env)}
2022-12-01 16:42:25 +03:00
export PATH=${brewkit}:"$PATH"
${sh}
`
2022-11-09 19:20:28 +03:00
}).chmod(0o700)
2022-09-25 15:41:58 +03:00
// copy in auxillary files from pantry directory
2022-09-25 17:41:14 +03:00
for await (const [path, {isFile}] of pantry.getYAML(pkg).path.parent().ls()) {
2022-09-25 15:41:58 +03:00
if (isFile) {
path.cp({ into: bld.join("props").mkdir() })
2022-09-25 15:41:58 +03:00
}
}
2022-11-17 22:29:15 +03:00
await run({ cmd }) // WELCOME TO THE BUILD
return { path: dst, pkg }
}
async function fix_binaries(installation: Installation) {
const prefix = usePrefix().join("tea.xyz/var/pantry/scripts/brewkit")
const env = {
TEA_PREFIX: usePrefix().string,
}
2022-09-20 14:53:40 +03:00
switch (host().platform) {
case 'darwin':
return await run({
cmd: [
prefix.join('fix-machos.rb'),
installation.path,
...['bin', 'lib', 'libexec'].map(x => installation.path.join(x)).filter(x => x.isDirectory())
],
env
})
case 'linux':
return await run({
cmd: [
prefix.join('fix-elf.ts'),
installation.path,
...[...deps.runtime, pkg].map(pkgstr)
],
env
})
}
}
}
2022-12-07 18:33:12 +03:00
async function fetch_src(pkg: Package): Promise<[Path, Path] | undefined> {
console.log('fetching', pkgstr(pkg))
// we run this as a script because we dont want these deps imported into *this* env
// since that leads to situations where we depend on things we didnt expect to
const script = new URL(import.meta.url).path().parent().parent().join('fetch.ts')
const proc = Deno.run({
cmd: [script.string, pkgstr(pkg)],
stdout: 'piped'
})
const [out, status] = await Promise.all([proc.output(), proc.status()])
if (!status.success) throw new Error()
const [dstdir, tarball] = new TextDecoder().decode(out).split("\n")
2022-12-07 18:33:12 +03:00
if (!tarball) {
// no tarball, e.g. tea.xyz/gx/cc
return undefined
}
return [new Path(dstdir), new Path(tarball)]
}