lfs

#!/bin/bash

set -e

prog="$(basename $0)"
cd "$(dirname $0)"

source ./env

stages="stage1a stage1b stage1c stage2 final"
for stage in $stages; do
    images+="lfs-${stage} "
done

usage() {
    cat <<EOF

Usage: $prog <command>

EOF
    exit 2
}

assert-stage() {
    if [ -z "$stage" ] ; then
        echo "$prog: error: stage name should preceed command"
        exit 1
    fi
}

timestamp() {
    date +"%Y-%m-%d %H:%m:%S"
}

lfs-env() {
    env | grep -e "^lfs_" | sort
}

lfs-init() {
    if [ "$stage" == "stage1a" ] ; then
        build_arg="--build-arg lfs_host_image=${lfs_host_image}"
    elif [ "$stage" == "final" ] ; then
        build_arg="--build-arg lfs_init_user=${lfs_init_user}"
    fi

    set -x
    bash -c "source ./env ; env | grep -e '^lfs_'" > eval.env

    podman stop -t 0    lfs-$stage || true
    podman rm -f        lfs-$stage || true

    podman build --tag lfs-$stage $build_arg containers/lfs-$stage
    podman create \
        --name      lfs-$stage \
        --hostname  lfs-$stage \
        --env-file  eval.env \
        --userns    keep-id \
        --volume    "./build/sources:/build/rpmbuild/SOURCES:z" \
        --volume    "./build/${stage}/rpms:/build/rpmbuild/RPMS:z" \
        --volume    "./build/${stage}/srpms:/build/rpmbuild/SRPMS:z" \
        --volume    .:/build/lfs-rpm:z \
        lfs-$stage
    podman start lfs-$stage
}

lfs-spectool() {
    (
    set -x
    ./spectool -d "with_lfs_stage1 1" -d "lfs_version ${lfs_version}" -g -C build/sources $1
    )
}

lfs-download() {
    specs=$@
    [ -z "$specs" ] && specs="$(ls specs/*.spec | grep -v '#' | sort)"
    for spec in $specs; do
        lfs-spectool $spec
    done
}

lfs-build() {
    method=$1
    shift
    specs=$*

    [ -z "$specs" ] && specs="$(cat containers/lfs-$stage/$stage.pkg.txt)"
    echo "" >> build/logs/build.log

    for spec in $specs; do
        if [ ! -f "$spec" ] ; then
            echo "$prog: error: $spec: file not found"
            continue
        fi
        package=$(basename "$spec" .spec)
        if [ "$package" == "libstdc++" ]; then
            rpmbuild_pkg_flags="--with lfs_gcc_libstdcpp_only"
        elif [ "$package" == "gcc" ] && [ "$stage" == "stage1b" ] ; then
            rpm_pkg_flags="--replacefiles"
        fi

        if [ "$method" == "--reinstall" ] ; then
            rpm_pkg_flags="$rpm_pkg_flags --replacefiles"
        fi

        if [ ! -z "$*" ] || ! podman exec lfs-$stage rpm -q $package ; then
            lfs-spectool "$spec"
            echo "$stage:$package" > build/logs/last-started
            echo "[$(timestamp)] start $stage:$package" >> build/logs/build.log
            echo -e "\n----- building $stage:$package"
            ( set -e -x -o pipefail
            podman exec lfs-$stage rpmbuild \
                $rpmbuild_flags \
                $rpmbuild_pkg_flags \
                lfs-rpm/${spec} 2>&1 \
                | tee build/logs/${stage}/${package}.log
            podman exec --user root lfs-$stage rpm \
                $method \
                $rpm_flags \
                $rpm_pkg_flags \
                rpmbuild/RPMS/$lfs_arch/${package}-*.rpm  2>&1 \
                | tee --append build/logs/${stage}/${package}.log
            )
            echo "$stage:$package" > build/logs/last-success
            echo "[$(timestamp)] done  $stage:$package" >> build/logs/build.log
        fi
    done
}

lfs-export() {
    case $stage in
        stage1a)
            (
            set -x
            podman exec --user root -t lfs-${stage} tar -C /lfs -c -z -f /build/lfs-rpm/build/${stage}/lfs-${stage}.tar.gz  .
            cp build/${stage}/lfs-${stage}.tar.gz containers/lfs-${next_stage}
            )
            ;;
        stage1b)
            (
            set -x
            podman exec --user root -t lfs-${stage} tar -C /lfs -c -z -f /build/lfs-rpm/build/${stage}/lfs-${stage}.tar.gz --exclude=./tools .
            cp build/${stage}/lfs-${stage}.tar.gz containers/lfs-${next_stage}
            )
            ;;
        stage1c)
            (
            set -x
            podman exec --user root -t lfs-$stage \
                tar -C / -c -z -f /build/lfs-rpm/build/${stage}/lfs-$stage.tar.gz \
                --exclude='./build' \
                --exclude='./tmp/*' \
                --exclude './home/*' \
                --exclude './root/*' \
                --exclude './dev/*' \
                --exclude './proc/*' \
                --exclude './sys/*' \
                --exclude './var/lib/rpm/*' \
                .
            cp build/${stage}/lfs-${stage}.tar.gz containers/lfs-${next_stage}
            )
            ;;
        stage2)
            (
            set -x
            podman exec --user root -t lfs-$stage \
                tar -C / -c -z -f /build/lfs-rpm/build/${stage}/lfs-$stage.tar.gz \
                --exclude='./build' \
                --exclude='./tmp/*' \
                --exclude './home/*' \
                --exclude './root/*' \
                --exclude './dev/*' \
                --exclude './proc/*' \
                --exclude './sys/*' \
                .
            rm -rf build/boot
            podman cp "lfs-$stage:/boot" build/boot
            cp build/${stage}/lfs-${stage}.tar.gz containers/lfs-${next_stage}
            )
            ;;
        final)
            (
            set -x
            podman exec --user root -t lfs-$stage \
                tar -C / -c -z -f /build/lfs-rpm/build/${stage}/lfs-$stage.tar.gz \
                --exclude='./build' \
                --exclude='./tmp/*' \
                --exclude './dev/*' \
                --exclude './proc/*' \
                --exclude './sys/*' \
                .
            )
            ;;
        *)
            echo "export not defined for $stage"
            exit 1
            ;;
    esac
}

lfs-bootstrap() {
    if [ "$stage" == "stage1c" ] ; then
        lfs-spectool specs/cmake.spec
        lfs-spectool specs/elfutils.spec
        lfs-spectool specs/rpm.spec
        podman exec --user root -t lfs-stage1c lfs-rpm/containers/lfs-stage1c/rpm-bootstrap.sh
    else
        echo "$prog: error: no bootstrap for this stage"
        exit 1
    fi
}

lfs-mkimage() {
    set -x
    rm -f "$lfs_root_img"
    truncate -s $lfs_root_size "$lfs_root_img"
    sudo mkfs -t ext4 "$lfs_root_img"
    sudo mkdir -p /run/lfs
    sudo mount "$lfs_root_img" /run/lfs
    sudo tar xf build/final/lfs-final.tar.gz -C /run/lfs
    sudo cp -r containers/lfs-final/overlay/* /run/lfs
    sudo umount /run/lfs
}

lfs-install() {
    set -x
    sudo mkdir -p ${lfs_install_dir}
    sudo cp ${lfs_root_img} ${lfs_install_dir}
    sudo cp build/boot/vmlinuz ${lfs_install_dir}/lfs-${lfs_version}-vmlinuz
}

lfs-build-all() {
    ./lfs download

    ./lfs 1a init
    ./lfs 1a build
    ./lfs 1a export

    ./lfs 1b init
    ./lfs 1b build
    ./lfs 1b export

    ./lfs 1c init
    ./lfs 1c bootstrap
    ./lfs 1c build
    ./lfs 1c export

    ./lfs 2 init
    ./lfs 2 build
    ./lfs 2 export

    ./lfs final init
    ./lfs final export
}

lfs-clean() {
    set -x
    rm -rf
    for stage in $stages; do
        rm -rf "build/${stage}"
    done
    rm -rf build/logs
    rm -rf containers/*/*.tar.gz
    rm -f eval.env
    podman stop --time 0 --ignore   $images || true
    podman rmi --force              $images || true
}

lfs-dist-clean() {
    set -x
    lfs-reset
    rm -rf build
}

mkdir -p build/{sources,logs}

for mkstage in $stages; do
    mkdir -p build/$mkstage/{rpms,srpms}
    mkdir -p build/logs/$mkstage
done

if [ "$with_check" != "1" ] ; then
    rpm_nocheck="--nocheck"
fi

case $1 in
    stage1a|1a)
        shift
        stage=stage1a
        next_stage=stage1b
        rpmbuild_flags="-bb $rpm_nocheck"
        rpm_flags="--nodeps"
        ;;
    stage1b|1b)
        shift
        stage=stage1b
        next_stage=stage1c
        rpmbuild_flags="-bb $rpm_nocheck"
        rpm_flags="--nodeps"
        ;;
    stage1c|1c)
        shift
        stage=stage1c
        next_stage=stage2
        rpmbuild_flags="-bb $rpm_nocheck"
        rpm_flags="--nodeps"
        ;;
    stage2|2)
        shift
        stage=stage2
        next_stage=final
        rpmbuild_flags="-ba $rpm_nocheck"
        rpm_flags="--nodeps"
        ;;
    final)
        shift
        stage=final
        ;;
esac


case $1 in
    env)        lfs-env ;;
    download)   shift ; lfs-download "$@" ;;
    init)       assert-stage && lfs-init ;;
    start)      assert-stage && podman start lfs-$stage ;;
    stop)       assert-stage && podman stop --timeout 0 lfs-$stage ;;
    build)      assert-stage && lfs-build --install ;;
    rpm)        assert-stage && shift ; lfs-build --reinstall "$@" ;;
    shell)      assert-stage && exec podman exec -it lfs-$stage /bin/bash ;;
    root)       assert-stage && exec podman exec --user root -it lfs-$stage /bin/bash ;;
    export)     assert-stage && lfs-export ;;
    bootstrap)  assert-stage && lfs-bootstrap ;;
    mkimage)    lfs-mkimage ;;
    install)    lfs-install ;;
    clean)      lfs-clean ;;
    dist-clean) lfs-dist-clean ;;
    build-all)  lfs-build-all ;;
    *)
        echo "$prog: error: invalid command" 1>&2
        usage
        ;;
esac