kmx.io/shpkg/share/shpkg/shpkg.subr

• Show log

  Commit

• Hash : 0325c898
  Author : Thomas de Grivel
  Date : 2023-02-18T16:23:10
  

  wip ci
  

Download

• share/shpkg/shpkg.subr

• #!/bin/sh
  # Copyright 2023 Thomas de Grivel <thodg@kmx.io>
  
  set -e
  
  # Config
  
  SHPKG_DATE="$(date +%F_%T)"
  
  : ${SHPKG_DIR:=~/shpkg}
  
  SHPKG_ETC_DIR="${SHPKG_DIR}/etc/shpkg"
  SHPKG_INCLUDE_DIR="${SHPKG_DIR}/include"
  SHPKG_LIB_DIR="${SHPKG_DIR}/lib"
  SHPKG_LOG_DIR="${SHPKG_DIR}/var/log/shpkg"
  SHPKG_SHARE_DIR="${SHPKG_DIR}/share/shpkg"
  SHPKG_SRC_DIR="${SHPKG_DIR}/src"
  SHPKG_VAR_DB_DIR="${SHPKG_DIR}/var/db/shpkg"
  
  SHPKG_PREFIX="${SHPKG_DIR}"
  
  # Console output
  
  : ${SHPKG_VERBOSE:=3}
  
  SHPKG_COLOR_BLUE="$(printf '\33[0;34m')"
  SHPKG_COLOR_PURPLE="$(printf '\33[0;35m')"
  SHPKG_COLOR_RESET="$(printf '\33[0m\n')"
  
  verbose__puts () {
      if [ "x$1" = "x1" ]; then
          if [ "$SHPKG_VERBOSE" -lt 2 ]; then
              return
          fi
          echo -n "${SHPKG_COLOR_BLUE}"
      elif [ "x$1" = "x2" ]; then
          if [ "$SHPKG_VERBOSE" -lt 1 ]; then
              return
          fi
          echo -n "${SHPKG_COLOR_PURPLE}"
      else
          err 1 "bad verbose level"
      fi
      shift
      echo -n "$@"
      echo "${SHPKG_COLOR_RESET}"
  }
  
  verbose () {
      if [ "x$1" = "x-k" ]; then
          VERBOSE_KEEP_GOING=Yes
          shift
      else
          VERBOSE_KEEP_GOING=No
      fi
      if [ "x$1" = "x-n" ]; then
          shift
          verbose__puts "$@"
      else
          verbose__puts "$@"
          shift
          if [ "${SHPKG_VERBOSE}" -lt 3 ]; then
              if [ "x${VERBOSE_KEEP_GOING}" = "xYes" ]; then
                  "$@" >/dev/null || true
              else
                  "$@" >/dev/null
              fi
          else
              if [ "x${VERBOSE_KEEP_GOING}" = "xYes" ]; then
                  "$@" || true
              else
                  "$@"
              fi
          fi
      fi
  }
  
  err () {
      R="$1"
      shift
      {
          printf '\33[0;31m'
          echo -n "$0:" error: "$@"
          printf '\33[0m\n'
      } >&2
      verbose 1 exit "$R"
  }
  
  # Logging
  
  shpkg_log () {
      SHPKG_NAME="$1"
      shift
      shpkg_start_logging "${SHPKG_NAME}"
      shpkg_redirect_err "$@" >> "${SHPKG_LOG}" &
      PID1=$!
      tail -n 1000000 -f "${SHPKG_LOG}" &
      PID2=$!
      set +e
      wait $PID1
      RET=$?
      kill $PID2
      wait $PID2
      return $RET
  }
  
  shpkg_redirect_err () {
      "$@" 2>&1
  }
  
  shpkg_start_logging () {
      SHPKG_LOG_ALL_DIR="${SHPKG_LOG_DIR}/all"
      SHPKG_LOG_NAME="$1_${SHPKG_DATE}_$$.log"
      SHPKG_LOG="${SHPKG_LOG_ALL_DIR}/${SHPKG_LOG_NAME}"
      SHPKG_LOG_RELATIVE="../all/${SHPKG_LOG_NAME}"
      SHPKG_LOG_RET="${SHPKG_LOG}.ret"
      SHPKG_LOG_TAGS_DIR="${SHPKG_LOG_DIR}/tags"
      SHPKG_LOG_TMP_DIR="${SHPKG_LOG_DIR}/tmp"
      if [ -f "${SHPKG_LOG}" ]; then
          err 1 "log file already present"
      fi
      if ! [ -d "${SHPKG_LOG_ALL_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_LOG_ALL_DIR}"
      fi
      {
          verbose -n 2 "shpkg_start_logging: see log with less -R ${SHPKG_LOG}"
          if ! [ -d "${SHPKG_LOG_TAGS_DIR}" ]; then
              verbose 1 mkdir -p "${SHPKG_LOG_TAGS_DIR}"
          fi
          if ! [ -d "${SHPKG_LOG_TMP_DIR}" ]; then
              verbose 1 mkdir -p "${SHPKG_LOG_TMP_DIR}"
          fi
      } | tee "${SHPKG_LOG}"
  }
  
  shpkg_tag_log () {
      SHPKG_LOG_TAG="$1"
      SHPKG_LOG_TAG_PATH="${SHPKG_LOG_TAGS_DIR}/${SHPKG_LOG_TAG}"
      verbose -n 2 "Logging to ${SHPKG_LOG_TAG_PATH}"
      if [ -f "${SHPKG_LOG_TAG_PATH}.tmp" ]; then
          verbose 1 rm "${SHPKG_LOG_TAG_PATH}.tmp"
      fi
      ( verbose 1 cd "${SHPKG_LOG_TAGS_DIR}" &&
            verbose 1 ln -s "${SHPKG_LOG_RELATIVE}" "${SHPKG_LOG_TAG}.tmp" &&
            verbose 1 mv "${SHPKG_LOG_TAG}.tmp" "${SHPKG_LOG_TAG}"; )
  }
  
  # Locking
  
  shpkg_lock () {
      SHPKG_LOCK_DIR="${SHPKG_DIR}/var/lib/shpkg/locks"
      SHPKG_LOCK_NAME="$1"
      shift
      SHPKG_LOCK="${SHPKG_LOCK_DIR}/${SHPKG_LOCK_NAME}"
      verbose -n 2 "Locking ${SHPKG_LOCK}"
      if ! [ -d "${SHPKG_LOCK_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_LOCK_DIR}"
      fi
      while ! ( set -C; 2>/dev/null >"${SHPKG_LOCK}"; ); do
          sleep 1
      done
      trap "rm -f '${SHPKG_LOCK}'" EXIT
  }
  
  # Config
  
  shpkg_config () {
      # C compiler
      if [ "x${CC}" = "x" ]; then
          if which cc >/dev/null; then
              CC=cc
          elif which gcc >/dev/null; then
              CC=gcc
          elif which egcc >/dev/null; then
              CC=egcc
          else
              err 1 "C compiler not found."
          fi
      fi
      # C build variables
      export CPPFLAGS="${CPPFLAGS} -I${SHPKG_INCLUDE_DIR}"
      export LDFLAGS="${LDFLAGS} -L${SHPKG_LIB_DIR}"
      export PKG_CONFIG_PATH="${SHPKG_LIB_DIR}/pkgconfig"
      # Target architecture
      SHPKG_TARGET="$(LC_ALL=C.UTF-8 ${CC} -v 2>&1 | grep '^Target: ' | head -n 1 | cut -c 9-)"
      SHPKG_TARGET_DIR="${SHPKG_DIR}/target/${SHPKG_TARGET}"
      SHPKG_FAKE_DIR="${SHPKG_TARGET_DIR}/fake"
      SHPKG_OBJ_DIR="${SHPKG_TARGET_DIR}/obj"
      SHPKG_PACKAGE_DIR="${SHPKG_TARGET_DIR}/packages"
      SHPKG_TAG_DIR="${SHPKG_TARGET_DIR}/tag"
      # OS detection
      SHPKG_OS="$(uname)"
      SHPKG_OS_="${SHPKG_OS}"
      if [ "x${SHPKG_OS}" = "xLinux" ]; then
          SHPKG_DISTRIB="$(uname -a | grep -io -e Debian -e gentoo -e Ubuntu | sed -e 's|gentoo|Gentoo|')"
          SHPKG_OS="${SHPKG_OS}/${SHPKG_DISTRIB}"
          SHPKG_OS_="${SHPKG_OS_}_${SHPKG_DISTRIB}"
      fi
      SHPKG_OS_DIR="${SHPKG_SHARE_DIR}/${SHPKG_OS}"
      # Number of CPU cores
      if which nproc >/dev/null 2>&1; then
          SHPKG_NCPU="$(nproc --all)"
      elif which sysctl >/dev/null 2>&1; then
          SHPKG_NCPU="$(sysctl -n hw.ncpu)"
      else
          SHPKG_NCPU=1
      fi
      verbose -n 2 "${SHPKG_NCPU} CPU cores."
      # SHA256
      if which sha256 >/dev/null 2>&1; then
          SHPKG_SHA256=sha256
      elif which sha256sum >/dev/null 2>&1; then
          SHPKG_SHA256=sha256sum
      else
          err 1 "sha256 executable not found"
      fi
      # CI
      : ${SHPKG_CI_DIR:=~/shpkg/ci}
      SHPKG_CI_BUILD_DIR="${SHPKG_CI_DIR}/build"
      SHPKG_CI_CHANGED_FILES="${SHPKG_CI_DIR}/changed_files"
      SHPKG_CI_LOG_DIR="${SHPKG_CI_DIR}/log/${SHPKG_OS_}/${SHPKG_TARGET}"
      SHPKG_CI_RUNNING="${SHPKG_CI_DIR}/running"
      SHPKG_CI_STATUS_DIR="${SHPKG_CI_DIR}/status/${SHPKG_OS_}/${SHPKG_TARGET}"
      # Directories
      if ! [ -d "${SHPKG_CI_LOG_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_CI_LOG_DIR}"
      fi
      if ! [ -d "${SHPKG_CI_STATUS_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_CI_STATUS_DIR}"
      fi
      if ! [ -d "${SHPKG_FAKE_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_FAKE_DIR}"
      fi
      if ! [ -d "${SHPKG_PACKAGE_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_PACKAGE_DIR}"
      fi
      if ! [ -d "${SHPKG_SRC_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_SRC_DIR}"
      fi
      if ! [ -d "${SHPKG_VAR_DB_DIR}" ]; then
          verbose 1 mkdir -p "${SHPKG_VAR_DB_DIR}"
      fi
      # CI
      echo -n > "${SHPKG_CI_RUNNING}"
      trap "shpkg_ci_status_trap" EXIT
  }
  
  # Repo index
  
  SHPKG_REPO_INDEX="${SHPKG_SHARE_DIR}/repo_index"
  if ! [ -f "${SHPKG_REPO_INDEX}" ]; then
      err 1 "${SHPKG_REPO_INDEX}: not found"
  fi
  
  shpkg_depends_on () {
      shpkg_repo_info "$@" | cut -d ' ' -f 5 | tr ',' ' '
  }
  
  shpkg_dir () {
      shpkg_repo_info "$@" | cut -d ' ' -f 2
  }
  
  shpkg_git_branch () {
      shpkg_repo_info "$@" | cut -d ' ' -f 4
  }
  
  shpkg_git_url () {
      shpkg_repo_info "$@" | cut -d ' ' -f 3
  }
  
  shpkg_repo_info () {
      [ "x$#" = "x1" ] || return 1
      grep "^$1 " "${SHPKG_REPO_INDEX}"
  }
  
  shpkg_src_parent_dir () {
      dirname "$(shpkg_dir "${SHPKG_REPO}")"
  }
  
  # SHA256
  
  shpkg_sha256 () {
      sha256 "$@"
  }
  
  shpkg_sha256sum () {
      for F; do
          echo -n "SHA256 ($F) = "
          sha256sum "$F" | cut -d ' ' -f 1
      done
  }
  
  # Source repository
  
  shpkg_checkout () {
      TREE="$1"
      shift
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_checkout: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          if ! [ -d "${SHPKG_REPO_SRC_DIR}" ]; then
              ( verbose 2 shpkg_clone "${SHPKG_REPO}"; )
          fi
          SHPKG_REPO_VERSION_A="$(shpkg_version "${SHPKG_REPO}")"
          ( verbose 1 cd "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}" &&
                verbose 1 git fetch origin "$TREE" &&
                verbose 1 git checkout "$TREE" &&
                verbose 1 git submodule update; )
          SHPKG_REPO_VERSION_B="$(shpkg_version "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_VERSION_A}" != "x${SHPKG_REPO_VERSION_B}" ]; then
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.checkout.log"; )
          fi
      done
  }
  
  shpkg_clone () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_clone: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_PARENT_DIR="$(shpkg_src_parent_dir "${SHPKG_REPO}")"
          SHPKG_REPO_GIT_BRANCH="$(shpkg_git_branch "${SHPKG_REPO}")"
          SHPKG_REPO_GIT_URL="$(shpkg_git_url "${SHPKG_REPO}")"
          SHPKG_REPO_BASENAME="$(basename "${SHPKG_REPO_DIR}")"
          if ! [ -d "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}" ]; then
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.clone.log"; )
              verbose 1 mkdir -p "${SHPKG_SRC_DIR}/${SHPKG_REPO_PARENT_DIR}"
              ( verbose 1 cd "${SHPKG_SRC_DIR}/${SHPKG_REPO_PARENT_DIR}" &&
                    verbose 1 git clone "${SHPKG_REPO_GIT_URL}" -b "${SHPKG_REPO_GIT_BRANCH}" "${SHPKG_REPO_BASENAME}" &&
                    verbose 1 cd "${SHPKG_REPO_BASENAME}" &&
                    verbose 1 git submodule init &&
                    verbose 1 git submodule update
              )
              SHPKG_REPO_HASH="$(shpkg_hash "${SHPKG_REPO}")"
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.tree_${SHPKG_REPO_GIT_BRANCH}.log"; )
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.commit_${SHPKG_REPO_HASH}.log"; )
          fi
      done
  }
  
  shpkg_fetch () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          SHPKG_REPO_LOG_FETCH="${SHPKG_LOG_TMP_DIR}/${SHPKG_REPO}.fetch.log"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_fetch: unknown repo: $SHPKG_REPO"
          fi
          ( verbose 1 cd "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}" &&
                verbose -n 1 git fetch --recurse-submodules --tags &&
                git fetch --recurse-submodules --tags | tee "${SHPKG_REPO_LOG_FETCH}"; )
          if [ -s "${SHPKG_REPO_LOG_FETCH}" ]; then
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.fetch.log"; )
          fi
      done
  }
  
  shpkg_pull () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_pull: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_VERSION_A="$(shpkg_version "${SHPKG_REPO}")"
          ( verbose 1 cd "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}" &&
                verbose 1 git pull &&
                verbose 1 git submodule update; )
          SHPKG_REPO_VERSION_B="$(shpkg_version "${SHPKG_REPO}")"
          SHPKG_REPO_VERSION_B_TREE="$(echo "${SHPKG_REPO_VERSION_B}" | cut -d - -f 1)"
          if [ "x${SHPKG_REPO_VERSION_A}" != "x${SHPKG_REPO_VERSION_B}" ]; then
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.pull.log"; )
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.tree_${SHPKG_REPO_VERSION_B_TREE}.log"; )
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.version_${SHPKG_REPO_VERSION_B}.log"; )
          fi
      done
  }
  
  shpkg_clean_sources () {
      for SHPKG_REPO; do
          ( verbose 2 shpkg_clean_configure "${SHPKG_REPO}"; )
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          SHPKG_REPO_PARENT_DIR="$(shpkg_src_parent_dir "${SHPKG_REPO}")"
          verbose 1 rm -rf "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          verbose -n 1 "rmdir ${SHPKG_SRC_DIR}/${SHPKG_REPO_PARENT_DIR}"
          rmdir "${SHPKG_SRC_DIR}/${SHPKG_REPO_PARENT_DIR}" 2>/dev/null || true
      done
  }
  
  shpkg_hash () {
      SHPKG_REPO_DIR="$(shpkg_dir "$1")"
      if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
          err 1 "shpkg_hash: unknown repo: $1"
      fi
      SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
      if [ -d "${SHPKG_REPO_SRC_DIR}/.git" ]; then
          SHPKG_REPO_HASH="$(git -C "${SHPKG_REPO_SRC_DIR}" show-ref --head HEAD | cut -d ' ' -f 1 | head -n 1)"
          echo "${SHPKG_REPO_HASH}"
      fi
  }
  
  shpkg_version () {
      SHPKG_REPO_DIR="$(shpkg_dir "$1")"
      if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
          err 1 "shpkg_version: unknown repo: $SHPKG_REPO"
      fi
      SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
      if [ -d "${SHPKG_REPO_SRC_DIR}/.git" ]; then
          SHPKG_REPO_HASH="$(git -C "${SHPKG_REPO_SRC_DIR}" show-ref --head HEAD | cut -d ' ' -f 1 | head -n 1)"
          SHPKG_REPO_HEAD="$(git -C "${SHPKG_REPO_SRC_DIR}" show-ref | grep "${SHPKG_REPO_HASH}" | grep ' refs/heads/' | sed -e 's,^.* refs/heads/,,')"
          echo "${SHPKG_REPO_HEAD}-${SHPKG_REPO_HASH}"
      fi
  }
  
  # Building from sources
  
  shpkg_autogen () {
      verbose 2 shpkg_clone "$@"
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          if [ -x "${SHPKG_REPO_SRC_DIR}/autogen" ]; then
              ( verbose 1 cd "${SHPKG_REPO_SRC_DIR}" &&
                    verbose 1 ./autogen; )
          elif [ -f "${SHPKG_REPO_SRC_DIR}/autogen.sh" ]; then
              ( verbose 1 cd "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}" &&
                    verbose 1 sh autogen.sh; )
          elif [ -x "${SHPKG_REPO_SRC_DIR}/bootstrap" ]; then
              ( verbose 1 cd "${SHPKG_REPO_SRC_DIR}" &&
                    verbose 1 ./bootstrap; )
          fi
      done
  }
  
  shpkg_build () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_build: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_OBJ_DIR="${SHPKG_OBJ_DIR}/${SHPKG_REPO_DIR}"
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
  	if shpkg__tag_is_absent build-done; then
              verbose 2 shpkg_ci_status "${SHPKG_REPO}.build.status" running
  	    ( if ! verbose 2 shpkg_configure "${SHPKG_REPO}"; then
                    exit 1
                fi; )
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.build.log"; )
              SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
              if [ -f "${SHPKG_REPO_SRC_DIR}/Makefile" ]; then
  		( verbose 1 cd "${SHPKG_REPO_SRC_DIR}"
                    if verbose 1 make -j "${SHPKG_NCPU}"; then
                        verbose 2 shpkg_ci_status "${SHPKG_REPO}.build.status" ok
                    else
                        exit 1
                    fi ; ) || exit 1
              elif [ -f "${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}/CMakeLists.txt" ]; then
  		if verbose 1 cmake -j "${SHPKG_NCPU}" --build "${SHPKG_REPO_OBJ_DIR}"; then
                      verbose 2 shpkg_ci_status "${SHPKG_REPO}.build.status" ok
                  else
                      exit 1
                  fi
              fi
              shpkg__tag_write build-done
  	fi
      done
  }
  
  shpkg_checksum () {
      find . -type f | cut -c 3- | while read F; do
          "shpkg_${SHPKG_SHA256}" "$F"
      done
  }
  
  shpkg_clean_build () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_clean_build: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_OBJ_DIR="${SHPKG_OBJ_DIR}/${SHPKG_REPO_DIR}"
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
          if [ -f "${SHPKG_REPO_SRC_DIR}/Makefile" ]; then
  	    ( verbose 1 cd "${SHPKG_REPO_SRC_DIR}" &&
                    verbose 1 make clean; )
          fi
          if [ -d "${SHPKG_REPO_OBJ_DIR}" ]; then
              verbose 1 rm -rf "${SHPKG_REPO_OBJ_DIR}"
          fi
          shpkg__tag_remove build-done
      done
  }
  
  shpkg_clean_configure () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_clean_configure: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
          shpkg__tag_remove configure-done
      done
  }
  
  shpkg_configure () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_configure: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_FAKE_DIR="$(shpkg_fake_dir "${SHPKG_REPO}")"
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
  	if shpkg__tag_is_absent configure-done; then
              verbose 2 shpkg_ci_status "${SHPKG_REPO}.configure.status" running
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.configure.log"; )
              ( verbose 2 shpkg_autogen "${SHPKG_REPO}"; )
              SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
              if ! [ -d "${SHPKG_REPO_FAKE_DIR}" ]; then
                  verbose 1 mkdir -p "${SHPKG_REPO_FAKE_DIR}"
              fi
              if [ -x "${SHPKG_REPO_SRC_DIR}/configure" ]; then
                  ( verbose 1 cd "${SHPKG_REPO_SRC_DIR}"
                    verbose 1 ./configure --prefix "${SHPKG_PREFIX}" )
              elif [ -x "${SHPKG_REPO_SRC_DIR}/configure.sh" ]; then
                  ( verbose 1 cd "${SHPKG_REPO_SRC_DIR}"
                    verbose 1 ./configure.sh --prefix "${SHPKG_PREFIX}" )
              elif [ -f "${SHPKG_REPO_SRC_DIR}/CMakeLists.txt" ]; then
                  verbose 1 cmake -S "${SHPKG_REPO_SRC_DIR}" -B "${SHPKG_OBJ_DIR}/${SHPKG_REPO_DIR}" -D CMAKE_INSTALL_PREFIX:PATH="${SHPKG_PREFIX}" -D BUILD_SHARED_LIBS=ON
              fi
              shpkg__tag_write configure-done
              verbose 2 shpkg_ci_status "${SHPKG_REPO}.configure.status" ok
          fi
      done
  }
  
  shpkg_fake () {
      verbose 2 shpkg_build "$@"
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          SHPKG_REPO_FAKE_DIR="$(shpkg_fake_dir "${SHPKG_REPO}")"
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.fake.log"; )
          if [ -d "${SHPKG_REPO_FAKE_DIR}" ]; then
  	    verbose 1 rm -rf "${SHPKG_REPO_FAKE_DIR}"
  	fi
          verbose 1 mkdir -p "${SHPKG_REPO_FAKE_DIR}"
          if [ -f "${SHPKG_REPO_SRC_DIR}/Makefile" ]; then
              ( verbose 1 cd "${SHPKG_REPO_SRC_DIR}" &&
                    verbose 1 make prefix="${SHPKG_REPO_FAKE_DIR}" install; )
          elif [ -f "${SHPKG_REPO_SRC_DIR}/CMakeLists.txt" ]; then
              verbose 1 cmake --install "${SHPKG_OBJ_DIR}/${SHPKG_REPO_DIR}" --prefix "${SHPKG_REPO_FAKE_DIR}"
          fi
      done
  }
  
  shpkg_fake_dir () {
      echo "${SHPKG_FAKE_DIR}/$(shpkg_dir "$1")${SHPKG_PREFIX}"
  }
  
  shpkg_package () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_package: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
          SHPKG_REPO_PACKAGE="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}-${SHPKG_REPO_VERSION}.tgz"
  	if ! [ -f "${SHPKG_REPO_PACKAGE}" ]; then
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.package.log"; )
              SHPKG_REPO_FAKE_DIR="$(shpkg_fake_dir "${SHPKG_REPO}")"
  	    verbose 2 shpkg_fake "${SHPKG_REPO}"
              SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
              SHPKG_REPO_PACKAGE="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}-${SHPKG_REPO_VERSION}.tgz"
              SHPKG_REPO_PACKAGE_CHECKSUM="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}-${SHPKG_REPO_VERSION}.SHA256"
              SHPKG_REPO_PACKAGE_DIR="$(dirname "${SHPKG_REPO_PACKAGE}")"
              if ! [ -d "${SHPKG_REPO_PACKAGE_DIR}" ]; then
  		verbose 1 mkdir -p "${SHPKG_REPO_PACKAGE_DIR}"
              fi
              ( verbose 1 cd "${SHPKG_REPO_FAKE_DIR}" &&
                    verbose -n 1 "shpkg_checksum > ${SHPKG_REPO_PACKAGE_CHECKSUM}" &&
                    shpkg_checksum > "${SHPKG_REPO_PACKAGE_CHECKSUM}" &&
  		  verbose -n 1 "pax -wz . > ${SHPKG_REPO_PACKAGE}" &&
  		  pax -wz . > "${SHPKG_REPO_PACKAGE}" )
  	fi
      done
  }
  
  # requires checked-out sources (git clone first)
  
  shpkg__tag_is_absent() {
      SHPKG_REPO_TAG_DIR="${SHPKG_TAG_DIR}/${SHPKG_REPO_DIR}/${SHPKG_REPO_VERSION}"
      if [ -f "${SHPKG_REPO_TAG_DIR}/$1" ]; then
          verbose -n 2 "${SHPKG_REPO_TAG_DIR}/$1: present"
          false
      else
          verbose -n 2 "${SHPKG_REPO_TAG_DIR}/$1: absent"
          true
      fi
  }
  
  shpkg__tag_remove() {
      for SHPKG_TAG; do
          SHPKG_REPO_TAG_DIR="${SHPKG_TAG_DIR}/${SHPKG_REPO_DIR}/${SHPKG_REPO_VERSION}"
          if [ -f "${SHPKG_REPO_TAG_DIR}/${SHPKG_TAG}" ]; then
              verbose 1 rm "${SHPKG_REPO_TAG_DIR}/${SHPKG_TAG}"
          fi
      done
  }
  
  shpkg__tag_write() {
      for SHPKG_TAG; do
          SHPKG_REPO_TAG_DIR="${SHPKG_TAG_DIR}/${SHPKG_REPO_DIR}/${SHPKG_REPO_VERSION}"
          if ! [ -d "${SHPKG_REPO_TAG_DIR}" ]; then
              verbose 1 mkdir -p "${SHPKG_REPO_TAG_DIR}"
          fi
          verbose -n 1 "echo ${SHPKG_DATE} > ${SHPKG_REPO_TAG_DIR}/${SHPKG_TAG}"
          echo "${SHPKG_DATE}" > "${SHPKG_REPO_TAG_DIR}/${SHPKG_TAG}"
      done
  }
  
  # Packages
  
  shpkg_is_installed () {
      SHPKG_REPO="$1"
      SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
      if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
          err 1 "shpkg_is_installed: unknown repo: $SHPKG_REPO"
      fi
      SHPKG_REPO_INSTALLED="${SHPKG_VAR_DB_DIR}/installed/${SHPKG_REPO_DIR}"
      if [ -f "${SHPKG_REPO_INSTALLED}" ]; then
          verbose -n 2 "shpkg_is_installed ${SHPKG_REPO} -> true"
          true
      else
          verbose -n 2 "shpkg_is_installed ${SHPKG_REPO} -> false"
          false
      fi
  }
  
  shpkg_is_system_package () {
      if grep -Eq "^$1\$" "${SHPKG_OS_DIR}/system_packages"; then
          verbose -n 2 "shpkg_is_system_package $1 -> true"
          true
      else
          verbose -n 2 "shpkg_is_system_package $1 -> false"
          false
      fi
  }
  
  shpkg_install () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_install: unknown repo: $SHPKG_REPO"
          fi
          if ! shpkg_is_system_package "${SHPKG_REPO_DIR}"; then
              SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
              SHPKG_REPO_PACKAGE="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}-${SHPKG_REPO_VERSION}.tgz"
  	    SHPKG_REPO_INSTALLED="${SHPKG_VAR_DB_DIR}/installed/${SHPKG_REPO_DIR}"
  	    SHPKG_REPO_INSTALLED_DIR="$(dirname "${SHPKG_REPO_INSTALLED}")"
  	    if ! shpkg_is_installed "${SHPKG_REPO}"; then
                  ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.install.log"; )
  	        ( verbose 2 shpkg_install_dependencies "${SHPKG_REPO}"; )
  	        ( verbose 2 shpkg_build "${SHPKG_REPO}"; )
  	        ( verbose 2 shpkg_package "${SHPKG_REPO}"; )
                  SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
                  SHPKG_REPO_PACKAGE="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}-${SHPKG_REPO_VERSION}.tgz"
                  SHPKG_REPO_PACKAGE_CHECKSUM="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}-${SHPKG_REPO_VERSION}.SHA256"
                  ( verbose 1 cd "${SHPKG_DIR}" &&
  		      verbose -n 1 "pax -rdz < ${SHPKG_REPO_PACKAGE}" &&
  		      pax -rdz < "${SHPKG_REPO_PACKAGE}"; )
  	        if ! [ -d "${SHPKG_REPO_INSTALLED_DIR}" ]; then
  		    verbose 1 mkdir -p "${SHPKG_REPO_INSTALLED_DIR}"
  	        fi
  	        verbose -n 1 "echo Version: ${SHPKG_REPO_VERSION} > ${SHPKG_REPO_INSTALLED}"
  	        echo "Version: ${SHPKG_REPO_VERSION}" > "${SHPKG_REPO_INSTALLED}"
                  verbose -n 1 "cat ${SHPKG_REPO_PACKAGE_CHECKSUM} >> ${SHPKG_REPO_INSTALLED}"
                  cat "${SHPKG_REPO_PACKAGE_CHECKSUM}" >> "${SHPKG_REPO_INSTALLED}"
                  verbose 1 libtool --mode=finish "${SHPKG_LIB_DIR}"
  	    fi
          fi
      done
  }
  
  shpkg_install_dependencies () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_install_dependencies: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_DEPENDS_ON="$(shpkg_depends_on "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DEPENDS_ON}" != "x" ]; then
              ( verbose 2 shpkg_install ${SHPKG_REPO_DEPENDS_ON}; )
          fi
      done
  }
  
  shpkg_installed_version () {
      SHPKG_REPO="$1"
      SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
      SHPKG_REPO_INSTALLED="${SHPKG_VAR_DB_DIR}/installed/${SHPKG_REPO_DIR}"
      if [ -f "${SHPKG_REPO_INSTALLED}" ]; then
          head -n 1 "${SHPKG_REPO_INSTALLED}" | \
              sed -e 's/^Version: //'
      fi
  }
  
  shpkg_latest_is_installed () {
      SHPKG_REPO="$1"
      SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
      SHPKG_REPO_INSTALLED_VERSION="$(shpkg_installed_version "${SHPKG_REPO}")"
      SHPKG_REPO_VERSION="$(shpkg_version "${SHPKG_REPO}")"
      if [ "x${SHPKG_REPO_INSTALLED_VERSION}" = "x${SHPKG_REPO_VERSION}" ]; then
          verbose -n 2 "shpkg_latest_is_installed ${SHPKG_REPO} -> true"
          true
      else
          verbose -n 2 "shpkg_latest_is_installed ${SHPKG_REPO} -> false"
          false
      fi
  }
      
  shpkg_uninstall () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_uninstall: unknown repo: $SHPKG_REPO"
          fi
  	SHPKG_REPO_INSTALLED="${SHPKG_VAR_DB_DIR}/installed/${SHPKG_REPO_DIR}"
          if [ -f "${SHPKG_REPO_INSTALLED}" ]; then
              verbose 2 shpkg_ci_status "${SHPKG_REPO}.uninstall.status" running
              ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.uninstall.log"; )
              verbose 1 cd "${SHPKG_DIR}"
              grep -v : "${SHPKG_REPO_INSTALLED}" |
                  cut -d '(' -f 2 |
                  cut -d ')' -f 1 |
                  while read F; do
                      if grep -E "^SHA256 \\($F\\) = " "${SHPKG_REPO_INSTALLED}" |
                              "${SHPKG_SHA256}" -c; then
                          verbose 1 rm "$F"
                      fi
                  done
              verbose 1 rm "${SHPKG_REPO_INSTALLED}"
          fi
      done
  }
  
  shpkg_upgrade () {
      verbose 2 shpkg_upgrade_shpkg
      if [ $# -gt 0 ]; then
          verbose 2 shpkg_upgrade_rec "$@"
      fi
  }
  
  shpkg_upgrade_rec () {
      ( verbose 2 shpkg_upgrade_dependencies "$@"; )
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_upgrade_rec: unknown repo: ${SHPKG_REPO}"
          fi
          if ! shpkg_is_system_package "${SHPKG_REPO_DIR}"; then
              verbose 2 shpkg_pull "${SHPKG_REPO}"
              if ! shpkg_latest_is_installed "${SHPKG_REPO}"; then
                  ( verbose 2 shpkg_tag_log "${SHPKG_REPO}.upgrade.log"; )
                  verbose 2 shpkg_build "${SHPKG_REPO}"
                  verbose 2 shpkg_package "${SHPKG_REPO}"
                  verbose 2 shpkg_uninstall "${SHPKG_REPO}"
                  verbose 2 shpkg_install "${SHPKG_REPO}"
              fi
          else
              true
          fi
      done
  }
  
  shpkg_upgrade_dependencies () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_upgrade_dependencies: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_DEPENDS_ON="$(shpkg_depends_on "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DEPENDS_ON}" != "x" ]; then
              ( verbose 2 shpkg_upgrade_rec ${SHPKG_REPO_DEPENDS_ON}; )
          fi
      done
  }
  
  # Misc
  
  shpkg_clean_all () {
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          SHPKG_REPO_FAKE_DIR="$(shpkg_fake_dir "${SHPKG_REPO}")"
          verbose 1 rm -rf "${SHPKG_REPO_FAKE_DIR}"
          SHPKG_REPO_OBJ_DIR="${SHPKG_OBJ_DIR}/${SHPKG_REPO_DIR}"
          verbose 1 rm -rf "${SHPKG_REPO_OBJ_DIR}"
          SHPKG_REPO_PACKAGE="${SHPKG_PACKAGE_DIR}/${SHPKG_REPO_DIR}"
          verbose 1 rm -rf "${SHPKG_REPO_PACKAGE}"-*
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          verbose 1 rm -rf "${SHPKG_REPO_SRC_DIR}"
          SHPKG_REPO_TAG_DIR="${SHPKG_TAG_DIR}/${SHPKG_REPO_DIR}"
          verbose 1 rm -rf "${SHPKG_REPO_TAG_DIR}"
      done
  }
  
  shpkg_installed () {
      grep -Ev '\s+#' "${SHPKG_REPO_INDEX}" |
          grep -Eo '^[^#]*' |
          while read SHPKG_REPO SHPKG_REPO_DIR REST; do
              SHPKG_REPO_INSTALLED="${SHPKG_VAR_DB_DIR}/installed/${SHPKG_REPO_DIR}"
              if [ -f "${SHPKG_REPO_INSTALLED}" ]; then
                  echo -n "${SHPKG_REPO} "
              fi
          done
      echo
  }
  
  shpkg_list () {
      grep -Ev '\s+#' "${SHPKG_REPO_INDEX}" |
          grep -Eo '^[^#]*' |
          while read SHPKG_REPO SHPKG_REPO_DIR REST; do
              SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
              SHPKG_REPO_INSTALLED="${SHPKG_VAR_DB_DIR}/installed/${SHPKG_REPO_DIR}"
              if [ -d "${SHPKG_REPO_SRC_DIR}" ] ||
                 [ -f "${SHPKG_REPO_INSTALLED}" ]; then
                  echo "${SHPKG_REPO}"
              fi
              if [ -d "${SHPKG_REPO_SRC_DIR}" ]; then
                  echo "  Sources: ${SHPKG_REPO_SRC_DIR}"
              fi
              if [ -f "${SHPKG_REPO_INSTALLED}" ]; then
                  head -n 1 "${SHPKG_REPO_INSTALLED}" | \
                      sed -e 's/^Version: /  Installed: /'
              fi
          done
  }
  
  shpkg_upgrade_shpkg () {
      ( verbose 1 cd "${SHPKG_DIR}" &&
            verbose 1 git pull &&
            verbose 1 . "${SHPKG_DIR}/share/shpkg/shpkg.subr"; )
  }
  
  # CI
  
  cut_prefix () {
      LEN=$(echo -n "$1" | wc -c | tr -d ' ')
      if [ "x$(echo "$2" | cut -c 1-${LEN})" = "x$1" ]; then
          echo "$2" | cut -c $((${LEN} + 1))-
      fi
  }
          
  shpkg_ci_changed_file () {
      SUFFIX="$(cut_prefix "${SHPKG_CI_DIR}" "$1")"
      if [ "x$SUFFIX" = "x" ]; then
          err 1 "shpkg_ci_changed_file: file not in ci dir: $1"
      fi
      echo "$SUFFIX" >> "${SHPKG_CI_CHANGED_FILES}"
      echo "shpkg_ci_changed_file $SUFFIX"
  }
  
  log_status () {
      STATUS_FILE="$(log_status_file "$1")"
      if [ -f "${STATUS_FILE}" ]; then
          cat "${STATUS_FILE}"
      else
          #echo "unknown"
          echo "unknown(${STATUS_FILE})"
      fi
  }
  
  log_status_file () {
      echo "${SHPKG_CI_STATUS_DIR}/$(basename "$1" .log).status"
  }
  
  log2html () {
      {
          TITLE="$(echo "$1" | ansi2html)"
          STATUS="$(log_status "$1")"
          IMG="$(basename "$1" .log).png"
          cat <<EOF
  <!DOCTYPE html>
  <html lang="en">
    <head>
      <meta charset="utf-8"/>
      <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
      <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
      <title>${TITLE}</title>
      <link rel="stylesheet" href="/_assets/app.css">
      <script defer type="text/javascript" src="/_assets/app.js"></script>
      <link rel="icon" type="image/png" sizes="64x64" href="${IMG}">
    </head>
    <body>
      <div class="ci-header">
        <a href="./"><i class="fas fa-asterisk"></i> All logs</a>
      </div>
      <h1>
        <img src="${IMG}" class="status-${STATUS}"/>
        ${TITLE}
      </h1>
      <pre><code>
  EOF
          ansi2html < "$1"
          cat <<EOF
  </code></pre>
      <div class="ci-footer">
        <a href="https://git.kmx.io/kmx.io/shpkg">shpkg_ci</a>
      </div>
    </body>
  </html>
  EOF
      } > "$1.html.tmp"
      mv "$1.html.tmp" "$1.html"
      shpkg_ci_changed_file "$1.html"
  }
  
  logs2html () {
      for F in "${SHPKG_CI_LOG_DIR}"/*.log; do
          STATUS_FILE="$(log_status_file "$F")"
          if [ ! -f "$F.html" ] ||
                 [ "$F" -nt "$F.html" ] ||
                 [ "${STATUS_FILE}" -nt "$F.html" ] ||
                 [ "$0" -nt "$F.html" ]; then
              verbose 2 log2html "$F"
          fi
      done
  }
  
  shpkg_ci_main () {
      echo -n > "${SHPKG_CI_CHANGED_FILES}"
      verbose 2 shpkg_ci_status "shpkg_ci.status" running
      for SHPKG_REPO; do
          SHPKG_REPO_DIR="$(shpkg_dir "${SHPKG_REPO}")"
          if [ "x${SHPKG_REPO_DIR}" = "x" ]; then
              err 1 "shpkg_ci: unknown repo: $SHPKG_REPO"
          fi
          SHPKG_REPO_SRC_DIR="${SHPKG_SRC_DIR}/${SHPKG_REPO_DIR}"
          if ! [ -d "${SHPKG_REPO_SRC_DIR}" ]; then
              verbose 2 shpkg_clone "${SHPKG_REPO}"
          else
              verbose 2 shpkg_pull "${SHPKG_REPO}"
          fi
          SHPKG_REPO_GIT_BRANCH="$(shpkg_git_branch "${SHPKG_REPO}")"
          SHPKG_REPO_HASH="$(shpkg_hash "${SHPKG_REPO}")"
          verbose 2 shpkg_tag_log "${SHPKG_REPO}.ci.log"
          verbose 2 shpkg_tag_log "${SHPKG_REPO}.ci.branch_${SHPKG_REPO_GIT_BRANCH}.log"
          verbose 2 shpkg_tag_log "${SHPKG_REPO}.ci.commit_${SHPKG_REPO_HASH}.log"
          SHPKG_REPO_BUILD_DIR="${SHPKG_CI_BUILD_DIR}/${SHPKG_REPO}"
          if ! [ -d "${SHPKG_REPO_BUILD_DIR}" ]; then
              # first bootstrap
              ( verbose 2 shpkg_bootstrap "${SHPKG_REPO_BUILD_DIR}"; )
          else
              # run shpkg upgrade
              ( . "${SHPKG_REPO_BUILD_DIR}/etc/shpkg/profile"
                verbose -n 2 shpkg upgrade "${SHPKG_REPO}"
                if ! ( . "${SHPKG_REPO_BUILD_DIR}/share/shpkg/shpkg.subr";
                       shpkg_upgrade "${SHPKG_REPO}"; ); then
                    shpkg_ci_status_ko_grep "^${SHPKG_REPO}[.]"
                fi; )
              if verbose 1 cp -p "${SHPKG_REPO_BUILD_DIR}/var/log/shpkg/tags/${SHPKG_REPO}".*.log "${SHPKG_CI_LOG_DIR}"; then
                  verbose 2 logs2html
                  verbose 2 shpkg_ci_status2png
              fi
          fi
          ( verbose 2 shpkg_bootstrap -f "${SHPKG_REPO_BUILD_DIR}"; )
          ( . "${SHPKG_REPO_BUILD_DIR}/etc/shpkg/profile"
            verbose -n 2 shpkg install "${SHPKG_REPO}"
            if ! ( . "${SHPKG_REPO_BUILD_DIR}/share/shpkg/shpkg.subr";
                   shpkg_install "${SHPKG_REPO}"; ); then
                exit 1
            fi; )
          verbose 2 shpkg_ci_status "${SHPKG_REPO}.ci.status" ok
          verbose 2 shpkg_ci_status "${SHPKG_REPO}.ci.branch_${SHPKG_REPO_GIT_BRANCH}.status" ok
          verbose 2 shpkg_ci_status "${SHPKG_REPO}.ci.commit_${SHPKG_REPO_HASH}.status" ok
          SHPKG_CI_COPY=No
          if verbose 1 cp -p "${SHPKG_REPO_BUILD_DIR}/var/log/shpkg/tags/${SHPKG_REPO}".*.log "${SHPKG_CI_LOG_DIR}"; then
              SHPKG_CI_COPY=Yes
          fi
          if verbose 1 cp -p "${SHPKG_DIR}/var/log/shpkg/tags/${SHPKG_REPO}.ci.log" "${SHPKG_DIR}/var/log/shpkg/tags/${SHPKG_REPO}".ci.*.log "${SHPKG_CI_LOG_DIR}"; then
              SHPKG_CI_COPY=Yes
          fi
          if [ "x${SHPKG_CI_COPY}" = "xYes" ]; then
              verbose 2 logs2html
              verbose 2 shpkg_ci_status2png
          fi
      done
      verbose 2 shpkg_ci_status "shpkg_ci.status" ok
      verbose 2 logs2html
      verbose 2 shpkg_ci_status2png
  }
  
  # state machine :
  #  any -> running
  #  running -> ko, ok
  # additionaly status will be changed to ko if aborted while running
  shpkg_ci_status () {
      SHPKG_CI_STATUS_FILE="${SHPKG_CI_STATUS_DIR}/$1"
      if [ -f "${SHPKG_CI_STATUS_FILE}" ]; then
          SHPKG_CI_STATUS="$(cat "${SHPKG_CI_STATUS_FILE}")"
      else
          SHPKG_CI_STATUS=unknown
      fi
      if [ "x$2" = "xrunning" ]; then
          verbose -n 2 "Status change: $1: ${SHPKG_CI_STATUS} -> $2"
          verbose -n 1 "echo $2 > ${SHPKG_CI_STATUS_FILE}"
          echo "$2" > "${SHPKG_CI_STATUS_FILE}"
          shpkg_ci_changed_file "${SHPKG_CI_STATUS_FILE}"
          echo "$1" >> "${SHPKG_CI_RUNNING}"
          shpkg_ci_changed_file "${SHPKG_CI_RUNNING}"
      elif [ "x${SHPKG_CI_STATUS}" = "xrunning" ]; then
          verbose -n 2 "Status change: $1: ${SHPKG_CI_STATUS} -> $2"
          verbose -n 1 "echo $2 > ${SHPKG_CI_STATUS_FILE}"
          echo "$2" > "${SHPKG_CI_STATUS_FILE}"
          shpkg_ci_changed_file "${SHPKG_CI_STATUS_FILE}"
          grep -v "^$1\$" "${SHPKG_CI_RUNNING}" > "${SHPKG_CI_RUNNING}.tmp"
          mv "${SHPKG_CI_RUNNING}.tmp" "${SHPKG_CI_RUNNING}"
          shpkg_ci_changed_file "${SHPKG_CI_RUNNING}"
      else
          verbose -n 2 "Status change blocked: $1: ${SHPKG_CI_STATUS} -> $2"
      fi
  }
  
  shpkg_ci_status_trap () {
      if [ -f "${SHPKG_CI_RUNNING}" ]; then
          for F in $(cat "${SHPKG_CI_RUNNING}"); do
              SHPKG_CI_STATUS_FILE="${SHPKG_CI_STATUS_DIR}/$F"
              SHPKG_CI_STATUS="$(cat "${SHPKG_CI_STATUS_FILE}")"
              if ! [ "x${SHPKG_CI_STATUS}" = "xrunning" ]; then
                  err 1 "shpkg_ci_status_trap: status is ${SHPKG_CI_STATUS}"
              fi
              verbose -n 1 "echo ko > '${SHPKG_CI_STATUS_FILE}'"
              echo ko > "${SHPKG_CI_STATUS_FILE}"
              shpkg_ci_changed_file "${SHPKG_CI_STATUS_FILE}"
          done
          rm "${SHPKG_CI_RUNNING}"
      fi
  }
  
  shpkg_ci_status_trap_grep () {
      if [ -f "${SHPKG_CI_RUNNING}" ]; then
          for F in $(grep "$1" "${SHPKG_CI_RUNNING}"); do
              SHPKG_CI_STATUS_FILE="${SHPKG_CI_STATUS_DIR}/$F"
              SHPKG_CI_STATUS="$(cat "${SHPKG_CI_STATUS_FILE}")"
              if ! [ "x${SHPKG_CI_STATUS}" = "xrunning" ]; then
                  err 1 "shpkg_ci_status_trap: status is ${SHPKG_CI_STATUS}"
              fi
              verbose -n 1 "echo ko > '${SHPKG_CI_STATUS_FILE}'"
              echo ko > "${SHPKG_CI_STATUS_FILE}"
              shpkg_ci_changed_file "${SHPKG_CI_STATUS_FILE}"
          done
          echo -n > "${SHPKG_CI_RUNNING}"
          shpkg_ci_changed_file "${SHPKG_CI_RUNNING}"
      fi
  }
  
  shpkg_ci_status2png () {
      for F in "${SHPKG_CI_STATUS_DIR}"/*.status; do
          STATUS="$(cat "$F")"
          I="${SHPKG_CI_LOG_DIR}/$(basename "$F" .status).png"
          if ! [ -f "$I" ] ||
                  [ "$F" -nt "$I" ]; then
              verbose 1 cp "${SHPKG_DIR}/share/shpkg/img/status_${STATUS}.64.png" "$I"
              shpkg_ci_changed_file "$I"
          fi
      done
  }
  

Download