path: root/bin/common-functions

#!/bin/sh

# contains functions used by more than one script

# TODO:
#  maybe source PKGBUILD instead of 'makepkg --printsrcinfo' and 'mksrcinfo'?

# find_pkgbuild repository package
# find the PKGBUILD of $package from $repository

find_pkgbuild() {

  local PKGBUILD='' repo file package_path

  if [ -f "${repo_paths__archlinux32}/$2/$1/PKGBUILD" ]; then
    # If this package has some modification,
    repo="$(find_git_repository_to_package_repository "$2")"
    eval package_path="$(printf '$repo_paths__%s' "${repo}")/$1"
    if ! [ -d "${package_path}" ]; then
      # create some dummy files if it is also new.
      mkdir -p "${package_path}/repos/$2-x86_64"
      touch "${package_path}/repos/$2-x86_64/PKGBUILD"
    fi
  fi

  for repo in ${repo_names}; do
    if [ "${repo}" = "archlinux32" ]; then
      # this is not a repository of packages
      continue
    fi
    eval package_path="$(printf '$repo_paths__%s' "${repo}")/$1"
    if ! [ -d "${package_path}" ]; then
      continue
    fi
    PKGBUILD="$(
      ls "${package_path}/repos/$2-"*"/PKGBUILD" 2> /dev/null | \
        tr ' ' '\n' | \
        grep -v -- '-i686/PKGBUILD$' | \
        grep -v -- '-\(staging\|testing\)-[^/]\+/PKGBUILD$' | \
        sort | \
        tail -n1
    )"
    if [ -n "${PKGBUILD}" ]; then
      echo "${PKGBUILD}"
      break
    fi
  done
}

# apply customizations to a package
#  (to be executed in the package's directory)

# TODO:
#  mangle $arch in PKBUILDs to contain i486, i586, i686

apply_package_customizations() {
  if [ ! -f 'PKGBUILD' ]; then
    >&2 echo 'PKGBUILD not found.'
    pwd
    exit 1
  fi

  local repo package

  repo="$(pwd)"
  package="${repo%/*/*}"
  package="${package##*/}"
  repo="${repo##*/}"
  repo="${repo%-any}"
  repo="${repo%-x86_64}"

  if [ ! -f 'PKGBUILD.changes-applied' ]; then
    # add i686 to the arch list
    sed '/^arch=[^#]*any/!s|^\(arch=(\)\([^#]*)\)\s*\(#.*\)\?$|\1'"'i686'"' \2|' -i 'PKGBUILD'
    if [ -f "${repo_paths__archlinux32}/${repo}/${package}/PKGBUILD" ]; then
      # If this package has modifications (or is new), apply them now:
      # append PKGBUILD
      cat "${repo_paths__archlinux32}/${repo}/${package}/PKGBUILD" >> \
        'PKGBUILD'
      # copy (and overwrite) other files
      for file in "${repo_paths__archlinux32}/${repo}/${package}/"*; do
        if [ -f "${file}" ] && [ "${file##*/}" != 'PKGBUILD' ]; then
          cp "${file}" ./
        fi
      done
    fi
    touch 'PKGBUILD.changes-applied'
  fi
}

# find_repository_with_commit commit
# find the repository which has $commit

find_repository_with_commit() {

  local repository

  for repository in ${repo_names}; do
    if [ "$(eval git -C "$(printf '$repo_paths__%s' "${repository}")" cat-file -t "$1" 2> /dev/null)" = "commit" ]; then
      echo "${repository}"
      return 0
    fi
  done
  >&2 echo "can't find repository with commit '$1'"
  exit 1

}

# find_git_repository_to_package_repository repository
# find the git repository which tracks the package repository $repository

find_git_repository_to_package_repository() {

  local repository

  for repository in ${repo_names}; do
    if [ "${repository}" = "archlinux32" ]; then
      continue
    fi
    if [ -n "$(
      (
        eval ls "$(printf '$repo_paths__%s' "${repository}")/"*"/repos" | \
          grep -v ':$' | \
          sed 's|-[^-]\+$||' | \
          sort -u
        echo "$1"
      ) | \
        sort | \
        uniq -d
      )" ]; then
      echo "${repository}"
      return 0
    fi
  done
  >&2 echo "can't find git repository with package repository '$1'"
  exit 1

}

# package_locked_broken_or_blocked package git_revision mod_git_revision repository
# return if package - of given repository and revisions - is [locked or broken or blocked]

package_locked_broken_or_blocked() {
  [ -f "${work_dir}/package-states/$1.$2.$3.$4.locked" ] || \
    [ -f "${work_dir}/package-states/$1.$2.$3.$4.broken" ] || \
    [ -f "${work_dir}/package-states/$1.$2.$3.$4.blocked" ]
}

# generate_package_metadata $package $git_revision $mod_git_revision $repository
# or
# generate_package_metadata $package.$git_revision.$mod_git_revision.$repository
# generate the meta data files of a package (dependencies, built packages, ...)

generate_package_metadata() {

  local package="$1"
  local git_revision="$2"
  local mod_git_revision="$3"
  local repository="$4"
  local file_prefix file PKGBUILD

  if [ $# -eq 1 ]; then
    # second form
    repository="${package##*.}"
    package="${package%.*}"
    mod_git_revision="${package##*.}"
    package="${package%.*}"
    git_revision="${package##*.}"
    package="${package%.*}"
  fi

  file_prefix="${work_dir}/package-infos/${package}.${git_revision}.${mod_git_revision}"

  if [ -e "${file_prefix}.builds" ] && \
    [ -e "${file_prefix}.depends" ] && \
    [ -e "${file_prefix}.needs" ] && \
    [ -e "${file_prefix}.packages" ]; then
    return 0
  fi

  eval git -C "$(printf '$repo_paths__%s' "$(find_repository_with_commit "${git_revision}")")" checkout "${git_revision}"
  eval git -C "$(printf '$repo_paths__%s' "$(find_repository_with_commit "${mod_git_revision}")")" checkout "${mod_git_revision}"

  PKGBUILD="$(find_pkgbuild "${package}" "${repository}")"

  if [ ! -r "${PKGBUILD}" ]; then
    echo "can't find PKGBUILD to package '${package}' from repository '${repository}': '${PKGBUILD}'"
    exit 1
  fi

  (
    cd "${PKGBUILD%/*}"
    apply_package_customizations
    grep -q '\$CARCH' 'PKGBUILD' && \
      CARCH=i686 makepkg --printsrcinfo > \
        "${file_prefix}.SRCINFO" || \
      mksrcinfo -o "${file_prefix}.SRCINFO"
  )

  # otherwise this just calls for trouble
  sed -i '/=\s*$/d' "${file_prefix}.SRCINFO"

  # extract "builds" = provides \cup pkgname
  grep "$(printf '^\\(\tprovides\\|pkgname\\) = ')" "${file_prefix}.SRCINFO" | \
    cut -d= -f2 | \
    sed 's|^\s\+||; s|[<>]$||' | \
    sort -u > \
    "${file_prefix}.builds"

  # extract "packages" = pkgname
  grep '^pkgname = ' "${file_prefix}.SRCINFO" | \
    cut -d= -f2 | \
    sed 's|^\s\+||; s|[<>]$||' | \
    sort -u > \
    "${file_prefix}.packages"

  # extract "needs" = ( makedepends \cup checkdepends ) \setminus "builds"
  (
    grep "$(printf '^\t\\(makedepends\\|checkdepends\\) = ')" "${file_prefix}.SRCINFO" | \
      cut -d= -f2 | \
      sed 's|^\s\+||; s|[<>]$||' | \
      sort -u
    sed 'p' "${file_prefix}.builds"
  ) | \
    sort | \
    uniq -u > \
    "${file_prefix}.needs"

  # extract "depends" = makedepends \cup checkdepends \cup depends
  (
    sed -n "$(printf '/^pkgname = /q;/^\tdepends = /p')" "${file_prefix}.SRCINFO"
    grep "$(printf '^\t\\(makedepends\\|checkdepends\\) = ')" "${file_prefix}.SRCINFO"
  ) | \
    cut -d= -f2 | \
    sed 's|^\s\+||; s|[<>]$||' | \
    sort -u > \
    "${file_prefix}.depends"

  rm "${file_prefix}.SRCINFO"

}

# delete_old_metadata
# delete old (=unneeded) meta data of packages

delete_old_metadata() {

  (
    ls -1 "${work_dir}/package-infos" | \
      sed '
        s|\.\([^.]\+\)\.\([^.]\+\)\.[^.]\+$| \1 \2|
      ' | \
      sort -u
    ls -1 "${work_dir}/package-states" | \
      sed '
        s|\.\([^.]\+\)\.\([^.]\+\)\(\.[^.]\+\)\{2\}$| \1 \2|
      ' | \
      sort -u | \
      sed 'p'
    cut -d' ' -f1,2,3 "${work_dir}/build-list" | \
      sed 'p'
  ) | \
    sort | \
    uniq -u | \
    while read -r pkg rev mod_rev; do
      rm -f "${work_dir}/package-infos/${pkg}.${rev}.${mod_rev}".*
    done
}

# official_or_community $package.$repo_revision.$mod_repo_revision.$repository
# print wether the specified package is an official package (print
# nothing) or a community package (print 'community-')

official_or_community() {
  local package="$1"
  local repository="${package##*.}"
  package="${package%.*}"
  local a32_rev="${package##*.}"
  package="${package%.*.*}"

  case "${repository}" in
    'community')
      echo 'community-'
      ;;
    'multilib')
      if ! git -C "${repo_paths__archlinux32}" archive --format=tar "${a32_rev}" -- 'extra-from-multilib' | \
        tar -Ox | \
        grep -qFx "${package%.*.*.*}"; then
        echo 'community-'
      fi
      ;;
  esac
}

# remove_old_package_versions $package_file
# removes all other versions of $package_file in the current directory

remove_old_package_versions() {

  local package="$1"
  local pkgname="${package%-*-*-*.pkg.tar.xz}"

  ls | \
    grep "^$(str_to_regex "${pkgname}")\(-[^-]\+\)\{3\}\.pkg\.tar\.xz\(\.sig\)\?\$" | \
    grep -v "^$(str_to_regex "${package}")\(\.sig\)\?\$" | \
    xargs -rn1 rm

}

# wait_some_time $minimum $diff
# wait between minimum and minimum+diff seconds (diff defaults to 30)
wait_some_time() {
  local minimum=$1
  local diff=$2
  local random

  if [ -z "${diff}" ]; then
    diff=30
  fi

  random="$(
    dd if='/dev/urandom' count=1 2> /dev/null | \
      cksum | \
      cut -d' ' -f1
  )"

  sleep $((${minimum} + ${random} % ${diff}))
}

# str_to_regex $string
# escape dots for use in regex
str_to_regex() {
  echo "$1" | \
    sed 's|\.|\\.|g'
}