path: root/src/maintenance-tools/parabola-dependents

#!/bin/bash

readonly ABSLIBRE_DIR=/packages/abslibre
readonly ABS_PACKAGES_DIR=/packages/arch/packages
readonly ABS_COMMUNITY_DIR=/packages/arch/community
readonly DEBUG=0

readonly BE_VERBOSE=$( [[ "${1}" == '-v' ]] && echo 1 || echo 0 ) ; (( $BE_VERBOSE )) && shift ;
readonly PKGBUILD_SED_RX='s|/PKGBUILD$|| ; s|([^/]*/)?([^/]+)/([^/]+)$|\2 \3|'
readonly DEP=$( sed -E "${PKGBUILD_SED_RX}" <<<${1} | cut -d ' ' -f 2 )
readonly TRANSITIVE_DEP_RX='( <- [^ ]*)'
readonly DEP_RX='([a-z]*)/([^ ]*)'
readonly DEP_CHAIN_RX="\[${DEP}\]${TRANSITIVE_DEP_RX}?${TRANSITIVE_DEP_RX}* <- ${DEP_RX}$"

# readonly REPOS=( nonprism nonsystemd{-testing,} libre{-testing,}
readonly REPOS=( nonprism{-testing,} nonsystemd{-testing,} libre{-testing,}
                 kernels{-testing,} testing core extra community{-testing,}
                 pcr{-testing,} nonprism-multilib{-testing,} nonsystemd-multilib
                 libre-multilib{-testing,} multilib{-testing,} pcr-multilib{-testing,} )
readonly TEMP_DB_NAME=parabola-dependents
readonly DUMMY_PKGBUILD='pkgname=%s
pkgver=0.0.0
pkgrel=42
pkgdesc="dummy PKGBUILD for experimentation"
arch=(armv7h i686 x86_64)
url=https://nowhere.man
license=(GPL)
provides=(%s)
source=(PKGBUILD)
sha256sums=(SKIP)
package() { echo "created '"'\${pkgname}'"' package" ; }'
readonly USAGE="USAGE:
  parabola-dependents [-v] <PACKAGE_BASE>
  parabola-dependents [-v] <PKGBUILD>
  parabola-dependents [-v] <SODEP>

  List all parabola packages which are dependents of a specified package.
  This includes direct dependents, transitive dependents, and makedepends dependents.

  NOTE: The verbose report does not account for makedepends of packages not in abslibre.

  The positional argument: <PACKAGE_BASE> or <PKGBUILD> may be a 'pkgbase' name,
  or a path to an abslibre 'pkgbase' directory, or a path to a PKGBUILD.
  Paths may be absolute or relative. They will all resolve to a 'pkgbase' name.

  The positional argument: <SODEP> may be of the forms: 'libfoo.so' or 'libfoo.so=1-64'.

  If 'pkgbase' does not exist in any database, a dummy package will be created,
  in memory, upon which for pactree to reflect.

  By default, only first-order dependents are listed,
  with counts of higher-order dependents.

  Note: This script makes no assumption regarding the state of the ABS trees.
        You will need to manage them manually (eg: \`git pull && git checkout master\`).
        It will however, ignore any PKGBUILDs which are not checked-in to the master branch.

  Note: This script can take several minutes to complete, if the dependency-graph is large.

  Options:
    -v
      Itemize all higher-order dependents, displaying the dependency-chain."
readonly INVALID_ARG_MSG="no dependency package specified\n\n${USAGE}"
readonly UNPRIVILEGED_MSG="this script requires super-user privileges"
readonly CBLUE='\033[0;36m'
readonly CRED='\033[0;31m'
readonly CYELLOW='\033[0;33m'
readonly CEND='\033[0m'
readonly SEP_CHAR='='
DB_DIR=''       # Init()
CFG_FILE=''     # Init()
PACMAN_OPTS=''  # Init()
PACTREE_OPTS='' # Init()

ParabolaDependents=()        # CollectResults()
ArchDependents=()            # CollectResults()
ParabolaMakedependents=()    # CollectResults()
ArchMakedependents=()        # CollectResults()
declare -A HiorderDependents # CollectResults()


## helpers ##

Log() # (log_fmt [fmt_args]*)
{
  local log_fmt=$1
  local fmt_args=( "${@:2}" )

  printf "${CBLUE}${log_fmt}${CEND}\n" "${fmt_args[@]}" >&2
}

LogError() # (log_fmt [fmt_args]*)
{
  local log_fmt=$1
  local fmt_args=( "${@:2}" )

  printf "${CRED}ERROR: ${log_fmt}${CEND}\n" "${fmt_args[@]}" >&2
}

LogScriptError() # (source_file func_name line_n)
{
  local source_file="$1"
  local func_name=$2
  local line_n=$3
  local err_loc="$(awk "(( NR == ${line_n} )) { print }" ${source_file})"

  LogError "in ${func_name}\n${line_n}: %s\n" "${err_loc}"
}

Exit() # (log_fmt [fmt_args]*)
{
  LogError "$@" ; exit 1 ;
}

ParsePkgbuilds() # ("abs_dir" "dep_chains")
(
  local abs_dir="$1"
  local dep_chains=( "${@:2}" )
  local pkgbuild repo pkgbase
# echo "ParsePkgbuilds() (${#dep_chains[@]}) dep_chains=${dep_chains[@]}" >&2 # ; return ;
# for ea in "${dep_chains[@]}" ; do echo "=$ea" >&2 ; done ; return ;
  set +o errexit +o errtrace ; trap '' EXIT INT TERM ERR ; # reset debug traps

  cd "${abs_dir}"
  for pkgbuild in $(find . -name PKGBUILD)
  do  git ls-tree master ${pkgbuild} | grep -E '/PKGBUILD$' > /dev/null || continue

# echo "ParsePkgbuilds() pkgbuild=${pkgbuild}" >&2

      source ${pkgbuild}

      if   grep ^${DEP}$ <<<${makedepends[*]} > /dev/null || false
      then # parse direct makedepends
           repo=$(   sed -E "${PKGBUILD_SED_RX}" <<<${pkgbuild} | cut -d ' ' -f 1)
           pkgbase=$(sed -E "${PKGBUILD_SED_RX}" <<<${pkgbuild} | cut -d ' ' -f 2)
           echo ${repo}/${pkgbase}
      else # collect transitive makedepends
           for makedepend in ${makedepends[*]}
           do if   grep -E "( |/)${makedepend}( |$)" <<<${dep_chains[@]} > /dev/null
              then echo "[${pkgbase}] <- ${makedepend}"
echo "ParsePkgbuilds() pkgbuild=${pkgbuild} makedepend=${makedepend} in-chain" >&2
# else echo "ParsePkgbuilds() pkgbuild=${pkgbuild} makedepend=${makedepend} not in-chain" >&2
              fi
           done
      fi
  done
)

IsArchRepo() # (repo)
{
  local repo=$1 ; [[ "${repo}" =~ ^(community|core|extra|multilib|testing)$ ]]
}

IsFirstOrderDep() # ("dep_chain")
{
  local dep_chain="$@"

  (( $(tr '<' '\n' <<<${dep_chain} | wc -l) == 2 ))
}

PrintDependent() # ("dep_chain")
{
  local dep_chain="$@"
  local dep_pkg via_pkg
  declare -i n_hiorder_deps

  if   (( BE_VERBOSE ))
  then # display all transitive dependents
       echo "  ${dep_chain/ /${SEP_CHAR}}"
  elif IsFirstOrderDep "${dep_chain}"
  then # display only first-order dependents
       dep_pkg=$(sed 's|.*<- ||'                 <<<${dep_chain})
       via_pkg=$(sed 's|.*\] <- \([^ ]*\).*|\1|' <<<${dep_chain})
       n_hiorder_deps=${HiorderDependents[${via_pkg}]}

       echo -n "  ${dep_pkg}${SEP_CHAR}"
       (( n_hiorder_deps )) && echo "(plus ${n_hiorder_deps} higher-order deps)" || echo
  fi
}

## business ##

Init()
{
  # find or create the temporary workspace
  readonly DB_DIR="$( db_dir=$(ls -1 -d /tmp/${TEMP_DB_NAME}.??? 2> /dev/null | head -n 1)
                      [[ -d "${db_dir}" ]]                                       &&
                      echo "${db_dir}"                                           ||
                      su $(logname) -c "mktemp -d -p /tmp -t ${TEMP_DB_NAME}.XXX" )"
  readonly CFG_FILE=${DB_DIR}/pacman-all.conf
  readonly PACMAN_OPTS="--config=${CFG_FILE}"
  readonly PACTREE_OPTS="${PACMAN_OPTS} --sync --reverse --chain"

# TODO: `pactree --chain` is an unpublished custom feature
export PATH="/code/pacman-contrib/src:${PATH}"

  # populate or update the temporary package database
  if ! (( DEBUG )) || ! (( $(ls -1 /tmp/${TEMP_DB_NAME}.??? | wc -l) ))
  then Log "updating database ...."
       printf "[options]\nArchitecture = auto\n"                     > ${CFG_FILE}
       printf "DBPath = ${DB_DIR}\n"                                >> ${CFG_FILE}
       for repo in ${REPOS[@]}
       do  printf "[${repo}]\nInclude = /etc/pacman.d/mirrorlist\n" >> ${CFG_FILE}
       done
       pacman ${PACMAN_OPTS} -Sy &> /dev/null
  else Log "skipping database update in DEBUG mode - delete ${DB_DIR} to sync"
  fi

  # create dummy for missing dependency package or sodep
  local log_msg dep pkgbase dummy_pkg
  if   ! pacman ${PACMAN_OPTS} -Ss ^${DEP}$ &> /dev/null
  then if   [[ "${DEP}" =~ (.*)\.so=? ]]
       then log_msg="creating dummy package for sodep: '${DEP}'"
            dep=${DEP} ; pkgbase=$(sed 's|^\([0-9a-z@._+-]*\)|\1|' <<<${BASH_REMATCH[1]}) ;
       else log_msg="pkgbase: '${DEP}' not found - creating dummy package"
            dep=''     ; pkgbase=${DEP} ;
       fi
       dummy_pkg=${pkgbase}-0.0.0-42-$(uname -m).pkg.tar.xz

       [[ ! -f ${DB_DIR}/${dummy_pkg} ]] && Log "${log_msg}" || break

       cd ${DB_DIR}
       printf "${DUMMY_PKGBUILD}\n" "${pkgbase}" "${dep}" > ./PKGBUILD
       su $(logname) -c 'makepkg --force &> /dev/null'

       if   [[ -f ./${dummy_pkg} ]]
       then repo-add ${TEMP_DB_NAME}.db.tar ./${dummy_pkg} &> /dev/null
            printf "[${TEMP_DB_NAME}]\nServer = file://${DB_DIR}\n"  >> ${CFG_FILE}
            pacman ${PACMAN_OPTS} -Sy &> /dev/null

            Log "dummy package '${pkgbase}' created"
       else Exit "makepkg failed"
       fi
  fi
}

CollectResults()
{
  local dep_chains dep_chain
  local via_pkg transitive_pkg found_repo dep_pkg
  local repos_deps=() repo_deps dep_repo dep_deps

  # query database for dependents
  Log "querying database ...."
  mapfile -t dep_chains < <(pactree ${PACTREE_OPTS} ${DEP})

  # compile results
  Log "compiling results ...."
  for dep_chain in "${dep_chains[@]}"
  do  # `pactree` will only report one dependent package,
      # even if packages with duplicate names exist in different repos.
      # Presumably, it selects the first repo in pacman.conf order, as does `pacman`.
      # This is problematic for the purpose of this script;
      # because those duplicates do not necessarily have the same dependencies.
      # In fact, that is a primary motivation for having duplicate packages.
      # So, in order to ignore packages with duplicate names,
      # which are not actually in the dependency chain of the input package,
      # and to report packages with duplicate names
      # which are actually in the dependency chain of the input package,
      # we need to capture the first-order dependent ($via_pkg),
      # the highest-order dependent ($dep_pkg),
      # and the highest-order transitive dependent ($transitive_pkg).
      # $via_pkg is the chain root node, and may be empty,
      # if $dep_pkg is a direct dependent of the input package (example #1).
      # $transitive_pkg is the direct dependency of the leaf node, and may be empty,
      # if $dep_pkg is a direct dependent of the input package (example #1),
      # or if $via_pkg is a direct dependent of $dep_pkg (example #2).
      # $dep_repo is the repo containing the leaf node package under present scrutiny.
      # $dep_pkg is the leaf node package under present scrutiny.
      #
      # Example dep_chains:
      #   1. first-order dep:  '[$DEP] <- $found_repo/$dep_pkg'
      #   2. second-order dep: '[$DEP] <- $via_pkg <- $found_repo/$dep_pkg'
      #   3. high-order dep:   '[$DEP] <- $via_pkg <- $transitive_pkg <- $found_repo/$dep_pkg'
      [[ "${dep_chain}" =~ ${DEP_CHAIN_RX} ]] || Exit "script regex error"

      via_pkg=${BASH_REMATCH[1]/ <- /}
      transitive_pkg=${BASH_REMATCH[2]/ <- /}
      found_repo=${BASH_REMATCH[3]}
      dep_pkg=${BASH_REMATCH[4]}
      mapfile -t repos_deps < <( ( expac ${PACMAN_OPTS} -Ss '%r/%n %D' -l ' ' ${dep_pkg} | \
                                   grep ^[^/]*/${dep_pkg}\ [^/]*$ || :                   ) | \
                                   sed "s|/${dep_pkg} | |"                                   )

      for repo_deps in "${repos_deps[@]}"
      do  dep_repo=$( cut -d ' ' -f 1  <<<${repo_deps})
          dep_deps="$(cut -d ' ' -f 2- <<<${repo_deps})"

          if   [[ " ${dep_deps} " =~ ' '(${DEP}|${via_pkg}|${transitive_pkg})' ' ]]
          then dep_chain="$(sed "s| ${found_repo}/${dep_pkg}$| ${dep_repo}/${dep_pkg}|" <<<${dep_chain})"
          else continue
          fi

          if   IsArchRepo ${dep_repo}
          then ArchDependents+=(     "${dep_chain}" )
          else ParabolaDependents+=( "${dep_chain}" )
          fi
          if   ! IsFirstOrderDep "${dep_chain}"
          then HiorderDependents[${via_pkg}]=$(( ${HiorderDependents[${via_pkg}]} + 1 ))
          fi
      done
  done

  # parse PKGBUILDs for makedepends
  Log "searching abslibre ...."
  ParabolaMakedependents+=( $(ParsePkgbuilds "${ABSLIBRE_DIR}"      "${dep_chains[@]}") )
  Log "searching abs ...."
  ArchMakedependents+=(     $(ParsePkgbuilds "${ABS_PACKAGES_DIR}"  "${dep_chains[@]}") )
  ArchMakedependents+=(     $(ParsePkgbuilds "${ABS_COMMUNITY_DIR}" "${dep_chains[@]}") )
}

PrintReport()
{
  local dep_chain
  local has_firstorder_deps=0

  # report parabola abslibre packages with some degree of run-time dependency
  # on the input package or sodep
  if   (( ${#ParabolaDependents[*]} ))
  then for dep_chain in "${ParabolaDependents[@]}"
       do  IsFirstOrderDep "${dep_chain}" && has_firstorder_deps=1 || :
       done
       if   (( BE_VERBOSE || has_firstorder_deps ))
       then Log "\ndirect$( ! (( BE_VERBOSE )) || echo " and transitive") parabola dependents:"
       fi
# echo "PrintReport() ${ParabolaDependents[*]}"
       for dep_chain in "${ParabolaDependents[@]}"
       do  PrintDependent "${dep_chain}"
       done | column --table --separator="${SEP_CHAR}" --table-wrap=2
  fi

  # report arch abs packages with some degree of run-time dependency
  # on the input package or sodep
  if   (( BE_VERBOSE && ${#ArchDependents[@]} ))
  then Log "\ndirect$( ! (( BE_VERBOSE )) || echo " and transitive") arch dependents:"
       for dep_chain in "${ArchDependents[@]}"
       do  PrintDependent "${dep_chain}"
       done | column --table --separator="${SEP_CHAR}" --table-wrap=2
  else echo -e "\n(${#ArchDependents[@]} arch dependents)"
  fi

  # report parabola abslibre packages with some degree of build-time dependency
  # on the input package or sodep
  if   (( ${#ParabolaMakedependents[*]} ))
  then Log "\nparabola build dependents:"
       printf "  %s\n" ${ParabolaMakedependents[*]}
  fi

  # report arch abs packages with some degree of build-time dependency
  # on the input package or sodep
  if   (( ${#ArchMakedependents[*]} ))
  then Log "\narch build dependents:"
       printf "  %s\n" ${ArchMakedependents[*]}
  fi
}

Cleanup()
{
  if   [[ -d "${DB_DIR}" && "${DB_DIR}" =~ ^${TEMP_DB_NAME}\....$ ]] && ! (( DEBUG ))
  then rm --force --recursive ${DB_DIR}
  fi
}


set -o errexit -o errtrace
trap 'Cleanup'                                                         EXIT INT TERM
trap 'LogScriptError "${BASH_SOURCE[0]}" "${FUNCNAME[0]}" "${LINENO}"' ERR


(( ! EUID )) || ! echo -e "${UNPRIVILEGED_MSG}" || exit 1
(( $#     )) || ! echo -e "${INVALID_ARG_MSG}"  || exit 1


export LC_ALL=C
Init
CollectResults
PrintReport