falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/programs/dtappintegrate/dtappintegrate.src

484 lines
18 KiB
Plaintext
Executable File
Raw Permalink Blame History

XCOMM!KORNSHELL
XCOMM $XConsortium: dtappintegrate.src /main/4 1996/04/21 19:27:37 drk $
XCOMM ###################################################################
XCOMM #
XCOMM dtappintegrate #
XCOMM #
XCOMM (c) Copyright 1996 Digital Equipment Corporation. #
XCOMM (c) Copyright 1993,1994,1996 Hewlett-Packard Company. #
XCOMM (c) Copyright 1993,1994,1996 International Business Machines Corp.#
XCOMM (c) Copyright 1993,1994,1996 Sun Microsystems, Inc. #
XCOMM (c) Copyright 1996 Novell, Inc. #
XCOMM (c) Copyright 1996 FUJITSU LIMITED. #
XCOMM (c) Copyright 1996 Hitachi. #
XCOMM (c) Copyright 1993, 1994 Unix System Labs, Inc., a subsidiary of #
XCOMM Novell, Inc. #
XCOMM #
XCOMM This is the dt application integration script to assist #
XCOMM in integrating applications into COSE Desktop Environment. #
XCOMM #
XCOMM syntax: dtappintegrate -s <source> [-t <target>] [-l <lang>] [-u]#
XCOMM where #
XCOMM -s indicates application's root location. #
XCOMM source the path name of the application's root. #
XCOMM -t indicates a new location for the #
XCOMM application's group files. #
XCOMM target the path name of the target location. #
XCOMM -l indicates the language for this application. #
XCOMM language the language name as used by $LANG #
XCOMM environment variable. #
XCOMM -u indicates to unintegrate the application. #
XCOMM #
XCOMM #
XCOMM ###################################################################
XCOMM ------------------------------------------------------------------#
XCOMM ShowSyntax #
XCOMM #
XCOMM This routine is used to echo the command line syntax. #
XCOMM #
XCOMM input: #
XCOMM none #
XCOMM #
XCOMM return codes: #
XCOMM 0 - success #
XCOMM #
XCOMM ------------------------------------------------------------------#
function ShowSyntax
{
echo "Usage: $SCRIPT_NAME -s <source> [-t <target>] [-l <language>] [-u]" | tee -a "$LOGFILE"
return 0
}
XCOMM ------------------------------------------------------------------#
XCOMM GetAbsolutePath #
XCOMM #
XCOMM This routine is to resolve a path to its actual path, #
XCOMM following links, etc. #
XCOMM #
XCOMM input: #
XCOMM $1 = path #
XCOMM #
XCOMM output: #
XCOMM absolute path #
XCOMM #
XCOMM ------------------------------------------------------------------#
function GetAbsolutePath
{
if [ "/" = "$1" ]; then
echo "$2"
elif [ -L "$1" ]; then
GetAbsolutePath "$(find . -name "$1" | awk '{print $NF}')" "$2"
else
{
if [ "." = "$1" ] || [ ".." = "$1" ]; then
GetAbsolutePath / /"$(basename "$1")""$2"
else
GetAbsolutePath "$(dirname "$1")" /"$(basename "$1")""$2"
fi
}
fi
}
XCOMM ------------------------------------------------------------------#
XCOMM GetRelativePath #
XCOMM #
XCOMM This routine is used to determine the relative path of #
XCOMM of the source path from the target path. #
XCOMM #
XCOMM input: #
XCOMM $1 = absolute source path #
XCOMM $2 = absolute target path #
XCOMM #
XCOMM return codes: #
XCOMM 0 - success #
XCOMM 1 - error #
XCOMM #
XCOMM ------------------------------------------------------------------#
function GetRelativePath
{
$AWK 'BEGIN {
src = ARGV[1]
dest = ARGV[2]
a = split(src, A, "/");
b = split(dest, B, "/");
s = 0;
for (i = 2; i < a && i < b; i++) {
if (match(A[i],B[i])) {
++s;
} else {
break;
}
}
for (i = 0 ; i <= (a - s - 2); i++) {
printf("../")
}
for (i = 2 + s; i <= b; i++) {
printf("%s%s", B[i], (i < b) ? "/":"\n");
}
}' "$2" "$1"
}
XCOMM ------------------------------------------------------------------#
XCOMM LinkCfgs #
XCOMM #
XCOMM This routine creates the actual links from the application's#
XCOMM root config files to the target location. #
XCOMM #
XCOMM input: #
XCOMM #
XCOMM return codes: #
XCOMM n - number of files integrated or unintegrated #
XCOMM #
XCOMM ------------------------------------------------------------------#
function LinkCfgs
{
typeset source=$1 target=$2 torf=$3 spath="" tpath="" cfgfile="" rpath=""
typeset pattern="" files=""
shift;shift;shift
if [[ -L $source || -L $(dirname "$source") ]]
then
spath=$(GetAbsolutePath "$source")
else
spath=$source
fi
if [[ -L $target || -L $(dirname "$target") ]]
then
tpath=$(GetAbsolutePath "$target")
else
tpath=$target
fi
rpath=""
for pattern in "$@"
do
if [[ $pattern = "(*)" ]]
then
files=$(ls -d "$source/"STAR 2>/dev/null)
else
files=$(ls -d "$source/$pattern" 2>/dev/null)
fi
if $files
then
count=$(echo "$files" | wc -w)
for cfgfile in $files
do
basecfg=$(basename "$cfgfile")
if [[ $torf = TRUE ]]
then
if [[ $rpath = "" ]]
then
rpath=$(GetRelativePath "$spath" "$tpath")
fi
rm -f "$tpath"/"$basecfg"
echo "ln -sf $rpath/$basecfg $tpath/$basecfg" >> "$LOGFILE"
ln -sf "$rpath/$basecfg" "$tpath/$basecfg" >> "$LOGFILE" 2>&1
else
if rm "$tpath"/"$basecfg" >/dev/null 2>&1
then
echo "rm $tpath/$basecfg" >> "$LOGFILE"
fi
fi
done
fi
done
return "$count"
}
XCOMM ------------------------------------------------------------------#
XCOMM IntegrateUnintegrate #
XCOMM #
XCOMM This routine integrates the files into the cose desktop #
XCOMM environment or unintegrates them depending on the boolean #
XCOMM input parameter. #
XCOMM #
XCOMM input: #
XCOMM $1 = Integrate or not. TRUE=integrate. FALSE=unintegrate. #
XCOMM #
XCOMM return codes: #
XCOMM 0 - work was done #
XCOMM 1 - no work done #
XCOMM #
XCOMM ------------------------------------------------------------------#
function IntegrateUnintegrate
{
typeset torf=$1 srcs="" trgs="" fpats="" tpath="" spath="" rpath="" languages="" lang=""
typeset srcabs="" trgabs=""
integer i=0 icons=0 types=1 help=2 appmgr=3
srcabs=$(GetAbsolutePath "$APP_ROOT")
trgabs=$(GetAbsolutePath "$APP_TARGET")
srcs[0]=$srcabs$ICONS$APP_LANG
srcs[1]=$srcabs$TYPES$APP_LANG
srcs[2]=$srcabs$HELP$APP_LANG
srcs[3]=$srcabs$APPMANAGER$APP_LANG
trgs[0]=$trgabs$ICONS$APP_LANG
trgs[1]=$trgabs$TYPES$APP_LANG
trgs[2]=$trgabs$HELP$APP_LANG
trgs[3]=$trgabs$APPMANAGER$APP_LANG
fpats[0]="$PIXMAP_FILES $BITMAP_FILES"
fpats[1]="$ACTIONDB_FILES"
fpats[2]="$HELPVOLUME_FILES_OLD $HELPVOLUME_FILES_NEW $HELPFAMILY_FILES"
fpats[3]="$APPMAN_FILES"
rc=1
while (( i < 4 ))
do
if [[ $APP_LANG = "" ]]
then
if languages=$(ls -d "${srcs[i]}"/COMMENT_STAR 2>/dev/null)
then
for lang in $languages
do
baselang=$(basename "$lang")
if [[ -d $lang ]]
then
if [[ $torf = TRUE ]]
then
if [[ ! -d ${trgs[i]}/$baselang ]]
then
mkdir -p "${trgs[i]}"/"$baselang"
fi
fi
if ! LinkCfgs "${srcs[i]}/$baselang" "${trgs[i]}/$baselang" "$torf" "${fpats[i]}"
then
rc=0
fi
fi
done
fi
else
if ! LinkCfgs "${srcs[i]}" "${trgs[i]}" "$torf" "${fpats[i]}"
then
rc=0
fi
fi
i=$((i+1))
done
return $rc
}
XCOMM ------------------------------------------------------------------#
XCOMM ExitOut #
XCOMM #
XCOMM Exit the program. #
XCOMM #
XCOMM input: #
XCOMM $1 = return code #
XCOMM #
XCOMM ------------------------------------------------------------------#
function ExitOut
{
typeset retcode=$1
echo "<<<<<<< END OF APPLICATION INTEGRATION >>>>>>>" >> "$LOGFILE"
echo "See $LOGFILE file for more information"
exit "$retcode"
}
XCOMM ----<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>-----
XCOMM ----<<<<<<<<<<<.-------------------------.>>>>>>>>>>>-----
XCOMM ----<<<<<<<<<<<| |>>>>>>>>>>>-----
XCOMM ----<<<<<<<<<<<| START OF MAIN ROUTINE |>>>>>>>>>>>>-----
XCOMM ----<<<<<<<<<<<|_________________________|>>>>>>>>>>>-----
XCOMM ----<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>-----
XCOMM -------------------------------------------------------------------
XCOMM Initialize variables
XCOMM -------------------------------------------------------------------
sFLAG=0
tFLAG=0
uFLAG=0
TYPES=/types
APPMANAGER=/appmanager
ICONS=/icons
HELP=/help
APPCONFIG=/dt/appconfig
CONFIG_TOP=CDE_CONFIGURATION_TOP
DT=$(basename $CONFIG_TOP)
APP_TARGET=${CONFIG_TOP%/$DT}$APPCONFIG
PIXMAP_FILES="*.pm"
BITMAP_FILES="*.bm"
HELPVOLUME_FILES_OLD="*.hv"
HELPVOLUME_FILES_NEW="*.sdl"
HELPFAMILY_FILES="*.hf"
ACTIONDB_FILES="*.dt"
APPMAN_FILES="(*)"
ID=$(id)
LOGFILE=$(mktemp /tmp/dtappint.logXXXXXXXXXXXXXXXX)
PATH=CDE_INSTALLATION_TOP/bin:/usr/bin:/bin
XCOMM -------------------------------------------------------------------
XCOMM Save application's name in variable.
XCOMM -------------------------------------------------------------------
SCRIPT_NAME=$0
XCOMM -------------------------------------------------------------------
XCOMM Check if root user. Exit if not.
XCOMM -------------------------------------------------------------------
ID=${ID##*uid=}
ID=${ID#*\(}
ID=${ID%%\)*}
if [[ $ID != root ]]
then
echo "Error: Must be root user to run $0!" >&2
exit 3
fi
XCOMM -------------------------------------------------------------------
XCOMM Put prolog into log file.
XCOMM -------------------------------------------------------------------
echo "<<<<<<< START OF APPLICATION INTEGRATION >>>>>>>" > "$LOGFILE"
XCOMM -------------------------------------------------------------------
XCOMM Put the date of application integration into the log file.
XCOMM -------------------------------------------------------------------
date >> "$LOGFILE"
XCOMM -------------------------------------------------------------------
XCOMM Put the command line into the log file.
XCOMM -------------------------------------------------------------------
echo "$SCRIPT_NAME $*" >> "$LOGFILE"
XCOMM -------------------------------------------------------------------
XCOMM Check if there are no command line arguments.
XCOMM If none, then display the command syntax.
XCOMM -------------------------------------------------------------------
if [[ $# = 0 ]]
then
ShowSyntax
ExitOut 0
fi
XCOMM -------------------------------------------------------------------
XCOMM Parse the command line into flags and variables.
XCOMM -------------------------------------------------------------------
while getopts s:t:l:u flag
do
case $flag in
s) sFLAG=1
APP_ROOT="$OPTARG";;
t) tFLAG=1
APP_TARGET="$OPTARG";;
l) APP_LANG="$OPTARG";;
u) uFLAG=1;;
?) echo " "
ShowSyntax
ExitOut 2;;
esac
done
XCOMM -------------------------------------------------------------------
XCOMM Check if application's root was specified and is valid.
XCOMM -------------------------------------------------------------------
if [[ $sFLAG = 0 ]]
then
echo "Error: Did not specify -s option!" >&2
ExitOut 4
else
if [[ ! -d $APP_ROOT ]]
then
APP_PATH=$APP_ROOT
echo "Error: $APP_PATH is not a directory!" >&2
ExitOut 4
fi
if [[ ! -r $APP_ROOT ]] || [[ ! -x $APP_ROOT ]]
then
APP_PATH=$APP_ROOT
echo "Error: Can not read $APP_PATH directory!" >&2
ExitOut 4
fi
fi
if [[ ${APP_ROOT%%/COMMENT_STAR} != "" ]]
then
APP_ROOT=$(pwd)/$APP_ROOT
fi
XCOMM -------------------------------------------------------------------
XCOMM If target is specified, do some sanity checks on this path.
XCOMM -------------------------------------------------------------------
if [[ $tFLAG = 1 ]]
then
if [[ ! -d $APP_TARGET ]]
then
APP_PATH=$APP_TARGET
echo "Error: $APP_PATH is not a directory!" >&2
ExitOut 4
fi
if [[ ! -r $APP_TARGET ]] || [[ ! -x $APP_TARGET ]]
then
APP_PATH=$APP_TARGET
echo "Error: Can not read $APP_PATH directory!" >&2
ExitOut 4
fi
if [[ ${APP_TARGET%%/COMMENT_STAR} != "" ]]
then
APP_TARGET=$(pwd)/$APP_TARGET
fi
fi
XCOMM -------------------------------------------------------------------
XCOMM Set up variables.
XCOMM -------------------------------------------------------------------
APP_ROOT=$APP_ROOT$APPCONFIG
if [[ $APP_LANG != "" ]]
then
APP_LANG=/$APP_LANG
fi
XCOMM -------------------------------------------------------------------
XCOMM Unintegrate the application by un-doing the integration steps.
XCOMM -------------------------------------------------------------------
if [[ $uFLAG = 1 ]]
then
if IntegrateUnintegrate FALSE
then
echo "Unintegration Complete"
else
echo "No files to unintegrate"
fi
ExitOut 0
fi
XCOMM -------------------------------------------------------------------
XCOMM See if these directories exist. If they don't, then create them.
XCOMM -------------------------------------------------------------------
for i in $APP_TARGET$ICONS$APP_LANG $APP_TARGET$TYPES$APP_LANG $APP_TARGET$APPMANAGER$APP_LANG $APP_TARGET$HELP$APP_LANG
do
if [[ ! -d $i ]]
then
mkdir -p "$i"
fi
done
XCOMM -------------------------------------------------------------------
XCOMM Determine which awk to use.
XCOMM -------------------------------------------------------------------
if ! type nawk > /dev/null 2>&1
then
AWK="awk"
else
AWK="nawk"
fi
XCOMM -------------------------------------------------------------------
XCOMM Integrate the application.
XCOMM -------------------------------------------------------------------
if IntegrateUnintegrate TRUE
then
echo "Integration Complete"
else
echo "No files to integrate"
fi
XCOMM -------------------------------------------------------------------
XCOMM Exit
XCOMM -------------------------------------------------------------------
ExitOut 0
Reference in New Issue View Git Blame Copy Permalink