path: root/bin/why-dont-you

#!/bin/sh

# usage: why_dont_you $action $package1 $package2 ...

# investigate, why a certain operation is not done with certain packages

# shellcheck source=conf/default.conf
. "${0%/*}/../conf/default.conf"

action="$1"
shift

tmp_dir=$(mktemp -d)
trap 'rm -rf --one-file-system "${tmp_dir}"' EXIT

case "${action}" in

  'build')

    for pkg in "$@"; do
      (
        grep "^$(str_to_regex "${pkg}") " "${work_dir}/build-list" || \
          >&2 printf '"%s" is not on the build list.\n' "${pkg}"
      ) | \
        while read -r package git_revision mod_git_revision repository; do

          if package_locked_or_blocked "${package}" "${git_revision}" "${mod_git_revision}" "${repository}"; then
            printf '"%s" is locked or blocked\n' "${pkg}"
            continue
          fi

          unmet_dependencies=$(find_dependencies_on_build_list "${package}" "${git_revision}" "${mod_git_revision}" "${repository}")
          if [ -n "${unmet_dependencies}" ]; then
            printf '"%s" has unmet dependencies:\n' "${package}"
            echo "${unmet_dependencies}" | \
              while read -r dep; do
                grep -lxF "${dep}" "${work_dir}/package-infos/"*".builds" | \
                  sed '
                    s|^.*/||
                    s|\(\.[^.]\+\)\{4\}||
                  '
              done | \
              sort -u
            printf '\n'

            continue
          fi

          if [ -f "${work_dir}/package-states/${package}.${git_revision}.${mod_git_revision}.${repository}.broken" ]; then
            printf '"%s" is broken (%sx built), but would be built\n' \
              "${pkg}" \
              "$(wc -l < "${work_dir}/package-states/${package}.${git_revision}.${mod_git_revision}.${repository}.broken")"
          else
            printf '"%s" would be built\n' "${pkg}"
          fi
        done

    done

  ;;

  'stabilize'|'unstage')

    if [ "${action}" = 'stabilize' ]; then
      suffix='tested'
    else
      suffix='done'
    fi

    {
      grep -vxF 'break_loops' "${work_dir}/build-list" | \
        awk '{print $1 "." $2 "." $3 "." $4}'
      if [ "${action}" = 'stabilize' ]; then
        find "${work_dir}/package-states" -maxdepth 1 \( \
          -name '*.done' -o \
          -name '*.testing' \
        \) -printf '%f\n' | \
          sed 's|\.[^.]\+$||'
      fi
    } | \
      sort -u > \
      "${tmp_dir}/unmoveable-list"

    {
      tr ' ' '.' < \
        "${work_dir}/build-list"
      find "${work_dir}/package-states" -maxdepth 1 -name "*.${suffix}" -printf '%f\n' | \
        sed 's|\.[^.]\+$||'
    } | \
      sort -u > \
      "${tmp_dir}/moveable-list"

    cat "${tmp_dir}/moveable-list" "${tmp_dir}/unmoveable-list" | \
      sed '
        s|^|'"${work_dir}/package-infos/"'|
        s|$|.run-depends|
      ' | \
      # base is boring, so we ignore it (might give result "... can be unstaged" although it _will_not_ be unstaged!
      xargs -r grep -vHxF 'base' | \
      sed '
        s|^[^:]*/||
        s|\.run-depends:| |
      ' | \
      sort -k2,2 > \
      "${tmp_dir}/all-run-depends"

    for pkg in "$@"; do

      if ! state_file=$(
          grep "^$(str_to_regex "${pkg}")\(\.[^.]\+\)\{3\}$" "${tmp_dir}/moveable-list"
        ) || \
        [ ! -f "${work_dir}/package-states/${state_file}.${suffix}" ]; then
        printf '"%s" is not %s yet!\n' "${pkg}" "${suffix}"
        continue
      fi

      echo "${state_file}" > "${tmp_dir}/dependent.new"
      touch "${tmp_dir}/dependent"

      while [ -s "${tmp_dir}/dependent.new" ]; do
        cat "${tmp_dir}/dependent.new" "${tmp_dir}/dependent" | \
          sort -u | \
          sponge "${tmp_dir}/dependent"

        sed '
          s|^|'"${work_dir}"'/package-infos/|
          s|$|.builds|
        ' "${tmp_dir}/dependent.new" | \
          xargs -r cat | \
          sort -u | \
          join -1 1 -2 2 -o 2.1 - "${tmp_dir}/all-run-depends" | \
          sort -u | \
          sponge "${tmp_dir}/dependent.new"

        cat "${tmp_dir}/dependent.new" "${tmp_dir}/dependent" "${tmp_dir}/dependent" | \
          sort | \
          uniq -u | \
          sponge "${tmp_dir}/dependent.new"
      done

      dependent_unmoveable=$(
        join -1 1 -2 1 -o 2.1 "${tmp_dir}/unmoveable-list" "${tmp_dir}/dependent"
      )

      if [ -n "${dependent_unmoveable}" ]; then
        printf 'The following packages are dependent on "%s", but cannot be %sd:\n' "${pkg}" "${action}"
        echo "${dependent_unmoveable}" | \
          while read -r sf; do
            printf '%s' "${sf}"
            if [ -f "${work_dir}/package-states/${sf}.testing" ]; then
              printf ' (not tested yet)'
            elif [ -f "${work_dir}/package-states/${sf}.done" ]; then
              printf ' (not unstaged yet)'
            elif tr ' ' '.' < \
              "${work_dir}/build-list" | \
              grep -qxF "${sf}"; then
              printf ' (not built yet)'
            fi
            printf '\n'
          done
        printf '\n'
        continue
      fi

      printf 'Package "%s" can be %sd.\n' "${pkg}" "${action}"

    done

  ;;

  'keep'|'stubbornly_keep')

    find '/var/lib/pacman/sync' -name '*.db' -execdir bsdtar -tf '{}' \; | \
      sed -n '
        s|-[^-]\+-[^-]\+/$||
        T
        p
      ' | \
      sort -u > \
      "${tmp_dir}/upstream-packages"

    while read -r pkg; do

      if builds_file=$(
        find "${work_dir}/package-infos" -maxdepth 1 -printf '%f\n' | \
          grep -m1 "^$(str_to_regex "${pkg}")\(\.[^.]\+\)\{3\}\.builds\$"
        ); then

        builds_file="${builds_file%.*}"
        prepo="${builds_file##*.}"
        builds_file="${builds_file%.*}"
        mod_rev="${builds_file##*.}"
        builds_file="${builds_file%.*}"
        rev="${builds_file##*.}"

      else

        found_PKGBUILD=false
        mod_rev=$(cat "${work_dir}/archlinux32.revision")
        for repo in ${repo_names}; do
          eval 'repo_path="${repo_paths__'"${repo}"'}"'
          rev=$(cat "${work_dir}/${repo}.revision")
          if [ "${repo}" = 'archlinux32' ]; then
            if git -C "${repo_path}" archive "${mod_rev}" | \
              grep -q "^[^/]\+/$(str_to_regex "${pkg}")/PKGBUILD\$"; then
              prepo=$(
                git -C "${repo_path}" archive "${mod_rev}" | \
                  grep "^[^/]\+/$(str_to_regex "${pkg}")/PKGBUILD\$" | \
                  cut -d/ -f1
              )
              found_PKGBUILD=true
              break
            fi
          else
            prepo=$(
              git -C "${repo_path}" archive "${rev}" -- "${pkg}/repos" 2>/dev/null | \
                tar -t 2> /dev/null | \
                grep '^[^/]\+/repos/[^/]\+/PKGBUILD$' | \
                grep -v -- '-i686/PKGBUILD$' | \
                grep -v -- '[-/]\(staging\|testing\|unstable\)-[^/]\+/PKGBUILD$' | \
                sed '
                  s|^[^/]\+/repos/\([^/]\+\)-[^/-]\+/PKGBUILD$|\1|
                ' | \
                head -n1
            )
            if [ -n "${prepo}" ]; then
              found_PKGBUILD=true
              break
            fi
          fi
        done
        if ! ${found_PKGBUILD}; then
          continue
        fi

        generate_package_metadata "${pkg}" "${rev}" "${mod_rev}" "${prepo}"

      fi

      sed "s|^|${pkg} builds |" "${work_dir}/package-infos/${pkg}.${rev}.${mod_rev}.${prepo}.builds" >> \
        "${tmp_dir}/deleted.builds"

    done < \
      "${work_dir}/deletion-list"

    sort -k3,3 "${tmp_dir}/deleted.builds" | \
      sponge "${tmp_dir}/deleted.builds"

    for pkg in "$@"; do

      if ! grep -qxF "${pkg}" "${work_dir}/deletion-list"; then
        printf 'Package "%s" is not on the deletion list.\n' "${pkg}"
        continue
      fi

      if ! grep -qxF "${pkg}" "${tmp_dir}/upstream-packages"; then
        printf 'Package "%s" is not available upstream.\n' "${pkg}"
        if [ "${action}" = 'keep' ]; then
          continue
        fi
      fi

      if git -C "${repo_paths__archlinux32}" archive "$(cat "${work_dir}/archlinux32.revision")" -- blacklist | \
        tar -Ox 'blacklist' | \
        sed '
          s/\s*#.*$//
          /^\s*$/d
        ' | \
        grep -qxF "${pkg}"; then
        printf 'Package "%s" is explicitely blacklisted.\n' "${pkg}"
        continue
      fi

      if [ "lib32-${pkg#lib32-}" = "${pkg}" ]; then
        printf 'Package "%s" is a library from multilib.\n' "${pkg}"
        continue
      fi

      build_depends=$(
        find "${work_dir}/package-infos" -maxdepth 1 -name "${pkg}.*.build-depends"
      )
      if [ -z "${build_depends}" ]; then
        printf 'Package "%s" was deleted in the git repositories.\n' "${pkg}"
        continue
      fi

      build_depends=$(
        sort -u "${build_depends}"
      )

      errors=$(
        (
          # shellcheck disable=SC2086
          printf '%s\n' ${build_depends}
          awk '{print $3}' "${tmp_dir}/deleted.builds" | \
            sort -u
        ) | \
          sort | \
          uniq -d | \
          join -1 1 -2 3 -o 2.1,2.2,2.3 - "${tmp_dir}/deleted.builds"
      )
      if [ -n "${errors}" ]; then
        printf 'Package "%s" has dependencies on the deletion list:\n' "${pkg}"
        # shellcheck disable=SC2086,SC2183
        printf '%s %s %s\n' ${errors}
        printf '\n'
        continue
      fi

      printf 'It seems, package "%s" should not be deleted.\n' "${pkg}"

    done

  ;;

  *)
    >&2 printf 'unknown action "%s"\n' "${action}"
    exit 1

esac