# Dump a list of leaf ports from a working system # Leaf ports are ports that have nothing depending upon them # These are generally the top-level ports; everything else should # be pulled in by them leaf_ports() { ( cd /var/db/pkg; ls -1 ) | while read pkg do pkg_info -Rq "${pkg}" | grep -q '' || pkg_info -oq "${pkg}" done | sort } ##################### # targets: config-recursive fetch-recursive install clean ######## # # Configuration variable setup # ######## # Base directory for everything base_dir="/usr/home/cyberleo/vitanitest" # Final directory for built packages (Outside chroot) final_pkg_dir="${base_dir}/pkg" final_bdeps_dir="${base_dir}/bdeps" # Chroot directory chroot_dir="${base_dir}/root" # Package directories, must be under ${chroot_dir} pkg_dir="${chroot_dir}/pkg" bdeps_dir="${pkg_dir}/bdeps" # Compute in-chroot pkg and bdeps dirs chroot_pkg_dir="${pkg_dir##${chroot_dir}}" chroot_bdeps_dir="${bdeps_dir##${chroot_dir}}" # Chroot environment chroot_env=" USER=root HOME=/root LOGNAME=root PATH=:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin SHELL=/bin/sh TERM=${TERM} " # Tempvars unset _port_config_recursive_cache ######## # # Boilerplate functions # ######## meh() { printf " \033[1;32m*\033[0m %s\n" "${*}" >&2; } omg() { printf " \033[1;33m*\033[0m %s\n" "${*}" >&2; } wtf() { printf " \033[1;31m*\033[0m %s\n" "${*}" >&2; exit 1; } ######## # # Chroot handling # ######## # Setup a chroot chsetup() { # Necessary mountpoints mkdir -p "${chroot_dir}/dev" || return 1 mount -t devfs devfs "${chroot_dir}/dev" || return 1 mkdir -p "${chroot_dir}/usr/ports" || return 1 mount -t nullfs /usr/ports "${chroot_dir}/usr/ports" || return 1 # Chroot configuration cp -f /etc/resolv.conf "${chroot_dir}/etc/resolv.conf" || return 1 # Target package directories mkdir -p "${pkg_dir}" || return 1 mkdir -p "${bdeps_dir}" || return 1 } # Tear down a chroot chteardown() { umount "${chroot_dir}/usr/ports" umount "${chroot_dir}/dev" } # Evaluate a command line within the chroot cheval() { meh "cheval ${*}" chroot "${chroot_dir}" env -i ${chroot_env} /bin/sh -c "cd ${chroot_pkg_dir}; ${*}" } # Run chrooted make chmake() { local port="/usr/ports/${1##/usr/ports/}" shift cheval "make -C ${port} ${*}" } ######## # # Port Dependency Tracking # ######## # Translate port origin to package name port2pkg() { while [ "${1}" ] do meh "port2pkg ${1}" chmake "${1}" -V PKGNAME shift done } # Build dependencies (shallow, recursive, package) port_bdeps() { while [ "${1}" ] do meh "bdeps ${1}" chmake "${1}" build-depends-list | sed -e 's#^/usr/ports/##' shift done } port_all_bdeps() { port_bdeps "${@}" | while read port do echo "${port}" port_bdeps "${port}" port_rdeps "${port}" done | sort | uniq } pkg_bdeps() { port2pkg $(port_all_bdeps "${@}") } # Runtime dependencies (shallow, recursive, package) port_rdeps() { while [ "${1}" ] do meh "rdeps ${1}" chmake "${1}" run-depends-list | sed -e 's#^/usr/ports/##' shift done } port_all_rdeps() { port_rdeps "${@}" | while read port do echo "${port}" port_rdeps "${port}" done | sort | uniq } pkg_rdeps() { port2pkg $(port_all_rdeps "${@}") } # All dependencies (shallow, recursive, package) port_deps() { while [ "${1}" ] do meh "deps ${1}" chmake "${1}" all-depends-list | sed -e 's#^/usr/ports/##' shift done } port_all_deps() { port_deps "${@}" | while read port do echo "${port}" port_deps "${port}" done | sort | uniq } pkg_deps() { port2pkg $(port_all_deps "${@}") } ######## # # Port Configuration Handling # ######## # Run make config on a list of ports port_config() { while [ "${1}" ] do meh "config ${1}" chmake "${1}" config < /dev/tty shift done } # Make config-conditional for a list of ports, and all dependencies port_config_recursive() { _port_config_recursive_cache="${_port_config_recursive_cache:- }" while [ "${1}" ] do # Do not use config-recursive because it computes the depchain first; # instead, manually compute the depchain after each config to ensure the # proper depchain is followed. Use config-conditional to avoid dialog # if the config is already complete. Also use a cache to avoid re-config # and re-recurse on previously handled port branches. if echo "${_port_config_recursive_cache}" | grep -qv " ${1} " then meh "config-recursive ${1}" chmake "${1}" config-conditional < /dev/tty port_config_recursive $(port_deps "${1}") _port_config_recursive_cache="${_port_config_recursive_cache} ${1} " fi shift done } # Remove saved config for a list of ports port_rmconfig() { while [ "${1}" ] do meh "rmconfig ${1}" chmake "${1}" rmconfig shift done } # Remove saved config for a list of ports and all dependencies port_rmconfig_recursive() { meh "rmconfig-recursive ${*}" port_rmconfig $(echo "${@}" $(port_all_deps "${@}") | sort | uniq) } # Obliterate saved configuration for all ports port_rmconfig_all() { meh "rmconfig-all" cheval "cd /var/db/ports; find . -name 'options' -delete; find . -type d | xargs rmdir 2>/dev/null" } # Restore port build options from cpio port_load_config() { meh "load-config" cheval "cd /var/db/ports; cpio -iv" } # Dump port build options to cpio port_save_config() { meh "save-config" cheval "cd /var/db/ports; find . -type d -o -type f -name options | cpio -ovHnewc" } ######## # # Port building and packaging # ######## # Copy dependency packages into tree pkgs_load() { for pkg in $(port2pkg $(port_all_deps "${1}")) do cp "${final_bdeps}/${pkg}.tbz" "${bdeps_dir}" 2>/dev/null && meh "Loaded dependent ${pkg}" done } # Copy and install dependency packages port_load_deps() { pkgs_load "${1}" ls "${bdeps_dir}"/*.tbz 2>/dev/null && cheval "cd ${chroot_bdeps_dir}; pkg_add -vF *" } # Copy generated packages out of tree pkgs_final() { ls "${pkg_dir}"/*.tbz 2>/dev/null && mv -v "${pkg_dir}"/*.tbz "${final_pkg_dir}" ls "${bdeps_dir}"/*.tbz 2>/dev/null && mv -v "${bdeps_dir}"/*.tbz "${final_bdeps_dir}" # link everything into ${bdeps_dir} so we can find it easily later ( cd "${final_pkg_dir}"; find . -type f | cpio -pl "${final_bdeps_dir}" ) } # Build and install a port port_build() { chmake "${1}" clean build install clean } # Package a port port_package() { cheval "pkg_create -Rvb $(port2pkg "${1}")" } # Package port build dependencies port_stash_bdeps() { for pkg in $(pkg_bdeps "${1}") do cheval "cd ${chroot_bdeps_dir}; pkg_create -vb ${pkg}" done } # Delete all installed packages (hope you saved them first) pkg_delete_all() { cheval "pkg_delete -f \*" }
Note: You are viewing an old version of this page. View the current version.