Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

458 lines (388 sloc) 13.765 kb
#!/bin/bash
# #
# This code is written for Lunar Linux, see #
# http://lunar-linux.org #
# #
############################################################
# #
# $FUNCTIONS/depends #
# includes find_depends is_depends in_depends #
# remove_depends add_depends run_depends #
# satisfy_depends #
# #
# 20020710 #
# #
############################################################
# #
# Copyrighted Kagan Kongar 2002 under GPLv2 #
# #
# Copyright Auke Kok 2004 under GPLv2 #
# #
############################################################
# function : find_depends
# usage : find_depends "module name"
# purpose : recursive dependency finder, no need to be installed
# NOTE: this only finds required dependencies!
function find_depends() {
local TMP_FDEPS
debug_msg "find_depends ($@)"
find_depends_intern() {
local DEP DEPS DEPFILE SECTION
SECTION=$(find_section $1)
if echo $SECTION | grep -q '^zlocal' ; then
# this module lives in zlocal
# now we need to run the depends file
# you guessed it: local decls.
depends() {
echo "$1"
}
optional_depends() {
# No quotes, this prevent us from parsing newlines
# if someone by accident add a newline in optional_depends
:
}
# yeah, this sucks:
message() {
:
}
DEPFILE=$MOONBASE/$SECTION/$1/DEPENDS
if [ -e $DEPFILE ] ; then
DEPS=$(MODULE=$1 . $DEPFILE)
fi
else
DEPS=$(awk -F: -v mod=$1 '{if ($1==mod){print $2}}' "$DEPENDS_CACHE")
fi
for DEP in $DEPS ; do
DEP=$(unalias "$DEP")
# this is our shortcut out:
if ! grep -qx "$DEP" "$TMP_FDEPS" ; then
echo "$DEP" >> $TMP_FDEPS
if grep -q "^$1:$DEP:required:" "$DEPENDS_CACHE" ; then
echo "$DEP"
find_depends_intern "$DEP"
fi
fi
done
}
TMP_FDEPS=$(temp_create "found.depends")
find_depends_intern $(unalias $1)
temp_destroy $TMP_FDEPS
}
# function : sort_by_dependency
# usage : LIST=$(sort_by_dependency $LIST)
# purpose : return a LIST sorted by dependency
sort_by_dependency() {
local TMP_LIST TMP_ALL TMP_TSRT A B
debug_msg "sort_by_dependency ($@)"
TMP_LIST=$(temp_create "deptree.in")
TMP_ALL=$(temp_create "deptree.all")
for M in $* ; do
echo "$M" >> $TMP_LIST
done
# tsort the existing dep relations in all of moonbase
TMP_TSRT=$(temp_create "dependency.sort")
awk -F: '{print $1,$2}' "$DEPENDS_CACHE" | while read A B ; do
B=$(MODULE=$A NEVER_ASK=1 DEPS_ONLY= unalias $B)
echo "$A $B" >> $TMP_TSRT
done
tsort "$TMP_TSRT" 2> /dev/null | tac > $TMP_ALL
temp_destroy $TMP_TSRT
# append all modules that do not have a DEPENDS file at all at the end
# note that this is logically WRONG, but it actually will help with
# unincluded depends, and therefore is *better* behaviour
for M in $* ; do
if ! grep -q -x "$M" "$TMP_ALL" ; then
echo $M >> $TMP_ALL
fi
done
# now reverse grep over the files:
cat "$TMP_ALL" | grep -x -f "$TMP_LIST"
temp_destroy $TMP_LIST
temp_destroy $TMP_ALL
}
is_depends() {
debug_msg "is_depends ($@)"
# Is $1 a previously selected dependency of any module.
return $(grep -q ":$1:on:" "$DEPENDS_STATUS")
}
in_depends() {
debug_msg "in_depends ($@)"
# Was $2 presented as a dependency for module $1
return $(grep -q "^$1:$2:on:" "$DEPENDS_STATUS")
}
remove_depends() {
debug_msg "remove_depends ($@)"
lock_file $DEPENDS_STATUS_BACKUP &&
lock_file $DEPENDS_STATUS ||
return 1
if [ -n "$2" ] ; then
if grep -q "^$1:$2:" "$DEPENDS_STATUS" ; then
grep -v "^$1:$2:" $DEPENDS_STATUS_BACKUP > $DEPENDS_STATUS
verbose_msg "removing depends for \"$1\" on \"$2\""
fi
elif grep -q "^$1:" "$DEPENDS_STATUS" ; then
grep -v "^$1:" "$DEPENDS_STATUS_BACKUP" | \
grep -v ":$1:on:optional:" > $DEPENDS_STATUS
verbose_msg "removing all depends for and optional on \"$1\""
fi
cp $DEPENDS_STATUS $DEPENDS_STATUS_BACKUP
unlock_file $DEPENDS_STATUS &&
unlock_file $DEPENDS_STATUS_BACKUP
}
add_depends() {
debug_msg "add_depends ($@)"
if ! grep -q "^$1:$2:$3:$4:$5:$6$" "$DEPENDS_STATUS" ; then
lock_file $DEPENDS_STATUS_BACKUP &&
lock_file $DEPENDS_STATUS &&
if grep -q "^$1:$2:" "$DEPENDS_STATUS" ; then
grep -v "^$1:$2:" "$DEPENDS_STATUS_BACKUP" > $DEPENDS_STATUS
else
verbose_msg "adding \"$4\" depends for \"$1\" on \"$2\" ($3)"
fi
echo "$1:$2:$3:$4:$5:$6" >> $DEPENDS_STATUS &&
cp $DEPENDS_STATUS $DEPENDS_STATUS_BACKUP &&
unlock_file $DEPENDS_STATUS &&
unlock_file $DEPENDS_STATUS_BACKUP
fi
}
run_depends() {
debug_msg "run_depends ($@)"
# local definitions of depends and optional_depends!
depends() {
local DEP
debug_msg " depends ($@)"
DEP=$(unalias $1)
if grep -q "^$DEP\$" "$TEMP_PREPAREDDEPS" 2>/dev/null ; then
return 0
fi
if module_installed $DEP ; then
add_depends "$MODULE" "$DEP" "on" "required" "$2" "$3"
echo "$DEP" >> $TEMP_PREPAREDDEPS
elif ! is_depends $DEP ! module_installed $DEP && ! module_held $DEP ; then
if module_exiled $DEP ; then
message "${MODULE_COLOR}${MODULE}:${PROBLEM_COLOR} ! Error: required dependency ${MODULE_COLOR}$DEP${DEFAULT_COLOR}${PROBLEM_COLOR} is exiled and cannot be installed${DEFAULT_COLOR}"
return 1
else
message "${MODULE_COLOR}${MODULE}:${DEFAULT_COLOR}" \
"${MESSAGE_COLOR}Adding required dependency${DEFAULT_COLOR}" \
"${MODULE_COLOR}$DEP${DEFAULT_COLOR}"
add_depends "$MODULE" "$DEP" "on" "required" "$2" "$3"
lin --deps $DEP
echo "$DEP" >> $TEMP_PREPAREDDEPS
fi
fi
}
optional_depends() {
debug_msg " optional_depends ($@)"
local DEP DEFAULT DEPMOD_AVAIL
# parameters: $1 = module name
# $2 = configure parameter if module wanted
# $3 = configure parameter if module declined
# $4 = description of why to use this module
DEP=$(unalias $1)
if ! grep -q "^$MODULE:$DEP:" "$DEPENDS_STATUS" ; then
if module_exiled $DEP ; then
verbose_msg "\"$MODULE\" optionally depends on exiled module \"$DEP\""
add_depends "$MODULE" "$DEP" "off" "optional" "$2" "$3"
else
if module_installed $DEP ; then
DEFAULT="y"
else
DEFAULT="n"
fi
if module_installed $DEP ; then
DEPMOD_AVAIL="Use optional (${FILE_COLOR}installed${QUERY_COLOR}) module ${MODULE_COLOR}$DEP${DEFAULT_COLOR}${MESSAGE_COLOR}"
else
DEPMOD_AVAIL="Install & use optional (${PROBLEM_COLOR}not installed${QUERY_COLOR}) module ${MODULE_COLOR}$DEP${DEFAULT_COLOR}${MESSAGE_COLOR}"
fi
# this is shortcut case s1) as discussed in lunar-dev ML
if module_installed $DEP && [ -z "$2" -a -z "$3" ] ; then
verbose_msg "Auto-adding optional dependency \"$DEP\""
add_depends "$MODULE" "$DEP" "on" "optional" "$2" "$3"
lin --deps $DEP
elif query "$DEPMOD_AVAIL
${QUERY_COLOR}Purpose: ${DEFAULT_COLOR}${MESSAGE_COLOR}$4 ${QUERY_COLOR}?" $DEFAULT ; then
add_depends "$MODULE" "$DEP" "on" "optional" "$2" "$3"
lin --deps $DEP
else
add_depends "$MODULE" "$DEP" "off" "optional" "$2" "$3"
fi
fi
fi
}
grep -q "^"$MODULE"\$" "$TEMP_PREPAREDDEPS" 2>/dev/null && return 0
if has_module_file $MODULE DEPENDS ; then
if [ -n "$SINGLE_MODULE" ] ; then
# we only need to show this once, but we get here twice per module
message "${CHECK_COLOR}Checking dependencies for" \
"${MODULE_COLOR}${MODULE}" \
"${DEFAULT_COLOR}"
fi
run_module_file $MODULE DEPENDS
fi
}
# function : satisfy_depends
# usage : satisfy_depends (operates on $MODULE variable)
# purpose : re-check module deps based on DEPENDS_CONFIG and DEPENDS_STATUS
# NOTE: this is where a missing dependency gets installed! IOW we really do
# "satisfy" any dependencies here!
satisfy_depends() {
local TMP_FILE DEP_MODULE DEP_STATUS DEP_ON DEP_OFF LINE
debug_msg "satisfy_depends ($@)"
if [ -n "$DEPS_ONLY" ] ; then
return 0
fi
# make sure we start with clean OPTS here:
unset OPTS
if [ -s "$MODULE_CONFIG" ] ; then
. $MODULE_CONFIG
fi
TMP_FILE=$(temp_create "${MODULE}.satify-depends")
grep "^$MODULE:" "$DEPENDS_STATUS" > $TMP_FILE
# first recursively check if all required dependencies are installed
for DEP_MODULE in $(find_depends $MODULE | grep -v '%') ; do
if [ $DEP_MODULE != $MODULE ]; then
if ! module_installed $DEP_MODULE ; then
if ! SINGLE_MODULE=1 lin $SILENT $COMPILE $DEP_MODULE ; then
exit 1
fi
fi
fi
done
# then parse $OPTS
while read LINE; do
DEP_MODULE=$(echo $LINE | cut -d: -f2)
DEP_STATUS=$(echo $LINE | cut -d: -f3)
DEP_ON=$(echo $LINE | cut -d: -f5)
DEP_OFF=$(echo $LINE | cut -d: -f6)
if [ -n "$FIX" ] ; then
if [ $DEP_STATUS == "on" ] ; then
lin $FIX $DEP_MODULE
fi
elif [ "$DEP_STATUS" == "off" ] || module_exiled $DEP_MODULE ; then
OPTS="$OPTS $DEP_OFF"
elif [ "$DEP_STATUS" == "on" ] && ! module_installed $DEP_MODULE && \
! module_held $DEP_MODULE ; then
if SINGLE_MODULE=1 lin $DEPS_ONLY $SILENT $COMPILE $DEP_MODULE ; then
OPTS="$OPTS $DEP_ON"
else
exit 1
fi
else
OPTS="$OPTS $DEP_ON"
fi
done < $TMP_FILE
temp_destroy $TMP_FILE
}
# conflicts... remove conflicting modules
conflicts() {
local DEP
debug_msg "conflicts ($@)"
DEP=$1
if module_installed $DEP ; then
message "${PROBLEM_COLOR}WARNING: ${DEFAULT_COLOR}${MODULE_COLOR}$DEP${DEFAULT_COLOR}${PROBLEM_COLOR} conflicts with module ${MODULE_COLOR}$MODULE${DEFAULT_COLOR}"
if query "Do you want to remove module ${DEFAULT_COLOR}${MODULE_COLOR}$DEP${DEFAULT_COLOR}${QUERY_COLOR} ? " n ; then
lrm $DEP
else
message "${PROBLEM_COLOR}ERROR: Cannot continue installing conflicting modules, exiting!${DEFAULT_COLOR}"
exit 1
fi
fi
true
}
run_conflicts() {
debug_msg "run_conflicts ($@)"
if has_module_file $MODULE CONFLICTS ; then
run_module_file $MODULE CONFLICTS
fi
}
build_module_depends() {
debug_msg "build_module_depends ($@)"
if [ -n "$DEPS_ONLY" ] ; then
(
if ! run_conflicts $1 ; then
exit 1
fi &&
run_details $1 &&
run_configure &&
RECONFIGURE= run_depends
)
else
if ! run_conflicts $1 ; then
exit 1
fi &&
run_details $1 &&
RECONFIGURE= run_depends &&
RECONFIGURE= satisfy_depends
fi
}
build_depends() {
debug_msg "build_depends ($@)"
for MODULE in $@ ; do
if ! module_installed $MODULE || [ ! -n "$PROBE" ] ; then
if ! module_held $MODULE ; then
build_module_depends $MODULE
else
verbose_msg "Skipping dependency checking of held module \"$MODULE\""
fi
fi
done
}
create_depends_cache()
{(
local TMP_DEP_CACHE DEPFILES DEPFILE MODULE
debug_msg "create_depends_cache($@)"
if [ ! -w $DEPENDS_CACHE -a -e $DEPENDS_CACHE ] ; then
return 1
fi
if [ $MODULE_INDEX -nt $DEPENDS_CACHE ] ; then
verbose_msg "Generating a new depends cache..."
TMP_DEP_CACHE=$(temp_create "depends.cache")
# you guessed it: local decls.
depends() {
echo "$MODULE:$1:required:$2:$3:"
}
optional_depends() {
# No quotes, this prevent us from parsing newlines
# if someone by accident add a newline in optional_depends
echo $MODULE:$1:optional:$2:$3:$4
}
# yeah, this sucks:
message() {
:
}
# speedups for system moonbases:
if [ "$MOONBASE" == "/var/lib/lunar/moonbase" ] ; then
DEPFILES=$(grep "/DEPENDS$" "$INSTALL_LOGS/moonbase-$(installed_version moonbase)")
# don't forget zlocal:
if [ "$ZLOCAL_OVERRIDES" == "on" ] ; then
DEPFILES="$DEPFILES $(find $MOONBASE/zlocal -type f -name DEPENDS)"
fi
else
if [ "$ZLOCAL_OVERRIDES" != "on" ] ; then
DEPFILES=$(find $MOONBASE -type f -name DEPENDS ! -regex "$MOONBASE/zlocal/.*")
else
DEPFILES=$(find $MOONBASE -type f -name DEPENDS)
fi
fi
# fast method for re-creating the depends.cache, might take long though
for DEPFILE in $DEPFILES ; do
TMP=${DEPFILE%/*} MODULE=${TMP##*/} . $DEPFILE
done > $TMP_DEP_CACHE &&
install -m644 $TMP_DEP_CACHE $DEPENDS_CACHE
temp_destroy $TMP_DEP_CACHE
else
verbose_msg "Skipping depends cache regeneration"
fi
)}
# list all installed modules depending on $1
list_installed_depending() {
local SUBDEP
debug_msg "list_installed_depending($2)"
for SUBDEP in $(grep ":$1:" "$DEPENDS_CACHE" | cut -d: -f1) ; do
if $(module_installed $SUBDEP ) ; then
list_installed_depending $SUBDEP | sort | uniq
echo $SUBDEP
fi
done
}
Jump to Line
Something went wrong with that request. Please try again.