Solaris/buildpkg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
buildpkg/buildpkg.packaging.irix
Tom G. Christensen 432baeee55 A major overhaul. 
New functionality added:
- 'hide' meta file to list files that should be 'nohist' in the IDB
- 'ops' meta file to list files and associated ops
- 'depends' meta file to list prereqs for the specfile.

Several new functions where introduced and a few old ones where
updated.

Fixed a bug in create_idb which resulted in all toplevel image
descriptions being set to the first one listed in image.conf

Extended subsys.conf to use wildcards to match files
for the subsystems

What's missing currently is the ability to check
if there are unpackaged files left in the staging
area, like rpm does.

New functionality has been ligthly tested
2003-12-06 14:55:30 +00:00

446 lines
11 KiB
Plaintext
Raw Blame History

#
# Function library for buildpkg framework
# It adds support for creating Irix packages in 'inst' format
#
# Define tool programs
# *only* platform specific packaging tools should be listed here
# generic tools go in buildpkg.functions
GENDIST=/usr/sbin/gendist
GZIP=/usr/people/tgc/bin/gzip
BZIP2=/usr/local/bin/bzip2
STRIP=/bin/true
# Configuration vars
imageconf=$buildpkgbase/scripts/image.conf
subsysconf=$buildpkgbase/scripts/subsys.conf
idbfile=$metadir/$topdir.idb
specfile=$metadir/$topdir.spec
depends=$metadir/depends
opsfile=$metadir/ops
hidefile=$metadir/hide
# Preformat manpages since Irix is not likely to have nroff available
catman=1
# Other
# Comment these declarations to get it to run with ksh
declare -a pc # Array of product categories (image.subsys)
declare -a pd # Array of matching descriptions
declare -a pctop # Array of toplevel product categories (image)
declare -a pdtop # Array of matching descriptions
declare -a reqs # Array of subsystems with prereqs
declare -a reqp # Array of prereqs (should match up with reqs)
declare -a hide # Files that should be "hidden" with nohist
declare -a opfiles # Files that should have an ops associated
declare -a opscript # Ops to associate with opfiles
#override defaults
pkgprefix=tgc_
pkgname=$pkgprefix$topdir
os=irix`$UNAME -r`
cpu=mips3
distfile=$topdir-$version-$pkgver.tgc-$os-$cpu-$pkgdirdesig.tardist
META_CLEAN="$topdir.spec $topdir.idb"
#####################################################
# Internal helper functions
#####################################################
indent4=" "
indent8=" "
indent12=" "
indent16=" "
# fix_ver(): "normalize" a version-pkgver pair
# params: $1=version
# Removes any '.' and '-' characters from a version string
fix_ver()
{
local ver=`echo $1 | $SED -e 's/\.//g' -e 's/-//g' -e 's/[a-zA-Z]//g'`
echo $ver
}
# spec_header()
# param: $1=product name $2=description
spec_header()
{
echo "product $1"
echo "$indent4 id \"$2\""
}
spec_footer()
{
echo "endproduct"
}
# spec_img_header()
# param: $1=image name $2=image description $3=version
spec_img_header()
{
local nver=$(fix_ver $3)
echo "$indent4 image $1"
echo "$indent8 id \"$2\""
echo "$indent8 version $nver"
echo "$indent8 order 9999"
}
# spec_img_footer()
spec_img_footer()
{
echo "$indent4 endimage"
}
# spec_subsys_header()
# param: $1=image $2=subsys $3=description
spec_subsys_header()
{
echo "$indent8 subsys $2 default"
echo "$indent12 id \"$3\""
echo "$indent12 replaces self"
echo "$indent12 exp $pkgname.$1.$2"
}
# spec_subsys_req()
# param: $1=prereq
spec_subsys_req()
{
echo "$indent16 prereq ( $1 )"
}
# spec_subsys_footer()
# param: none
spec_subsys_footer()
{
echo "$indent8 endsubsys"
}
# compute_octal()
# Description: Computes the octal value from a permission list (_rwxrwxrwx)
# param: $1=permission list
# Caveats: It won't pickup sticky bit and mandatory locking bit
compute_octal()
{
perm=$1
v=0; d1=0; d2=0; d3=0; d4=0
# User part
if [ "${perm:1:1}" == "r" ]; then
let "v = v + 4" # set read bit
fi
if [ "${perm:2:1}" == "w" ]; then
let "v = v + 2" # set write bit
fi
if [ "${perm:3:1}" == "x" ]; then
let "v = v + 1" # set executable bit
elif [ "${perm:3:1}" == "s" ]; then
let "v = v + 1" # set executable bit
let "d1 = d1 + 4" # Set setuid bit
fi
d2=$v; v=0
# Group part
if [ "${perm:4:1}" == "r" ]; then
let "v = v + 4" # set read bit
fi
if [ "${perm:5:1}" == "w" ]; then
let "v = v + 2" # set write bit
fi
if [ "${perm:6:1}" == "x" ]; then
let "v = v + 1" # set executable bit
elif [ "${perm:6:1}" == "s" ]; then
let "v = v + 1" # set executable bit
let "d1 = d1 + 2" # Set setgid bit
fi
d3=$v; v=0;
# Other part
if [ "${perm:7:1}" == "r" ]; then
let "v = v + 4" # set read bit
fi
if [ "${perm:8:1}" == "w" ]; then
let "v = v + 2" # set write bit
fi
if [ "${perm:9:1}" == "x" ]; then
let "v = v + 1" # set executable bit
fi
d4=$v; v=0
echo $d1$d2$d3$d4
}
# check_hide(): Should the file be "hidden"
# params: $1=file to check against $hide
check_hide()
{
local file=$1
for ((i=0; $i < ${#hide[@]}; i++))
do
if [ "${hide[$i]}" == "$file" ]; then
echo 1
fi
done
}
# check_ops(): Is there an opscript associated with $1
# param: $1=file to check
check_ops()
{
local file=$1
local return
echo "file is $file" >> /tmp/debug
for ((i=0; $i < ${#opfiles[@]}; i++))
do
echo "opfiles $i is ${opfiles[$i]}" >> /tmp/debug
if [ "${opfiles[$i]}" == "$file" ]; then
return="${opscript[$i]}"
fi
done
echo $return
}
# add_files()
# Create IDB entries for all files in a specfic product category
# Takes the following parameters
# $1 = dirname to descend into
# $2 = product_category to assign files
# $3 = permissions to set on the files we find
# $4 = user
# $5 = group
add_files()
{
local perm=$3
local FILES=`$FIND $1 -type f -print`
for i in $FILES
do
if [ "$3" == "keep" ]; then
permlist=`$LS -l $i | $CUT -d " " -f 1`
perm=$(compute_octal $permlist)
fi
nohist=$(check_hide $i)
doop=$(check_ops $i)
if [ ! -z "$nohist" ]; then
echo "f $perm $4 $5 ${topinstalldir:1}/$i $i $pkgname.$2 nohist" >>$idbfile
else
if [ ! -z "$doop" ]; then
echo "f $perm $4 $5 ${topinstalldir:1}/$i $i $pkgname.$2 $doop" >>$idbfile
else
echo "f $perm $4 $5 ${topinstalldir:1}/$i $i $pkgname.$2" >>$idbfile
fi
fi
done
local FILES=`$FIND $1 -type l -print`
for i in $FILES
do
if [ "$3" == "keep" ]; then
permlist=`$LS -l $i | $CUT -d " " -f 1`
perm=`compute_octal $permlist`
fi
local temp=`$LS -l $i|$CUT -d '>' -f 2`
local symval=${temp# }
echo "l $perm $4 $5 ${topinstalldir:1}/$i $i $pkgname.$2 symval($symval)" >>$idbfile
done
}
# fetch_imageconf(): Fetch a list of toplevel image entries with descriptions
# params: none
# Discard the ones that we don't have any subsystems for FIXME!
fetch_imageconf()
{
pctopidx=0
while read image desc
do
pctop[$pctopidx]=$image
pdtop[$pctopidx]=$desc
let "pctopidx = $pctopidx + 1"
done < $imageconf
}
# fetch_depends(): Fetch a list of subsystems and their prereqs
# params: none
#
fetch_depends()
{
reqidx=0
while read ss req
do
reqs[$reqidx]=$ss
if [ "$req" == "auto" ]; then # auto create depend on sw.base
nver=$(fix_ver "$version-$pkgver")
req="$pkgname $nver $nver"
fi
reqp[$reqidx]=$req
let "reqidx = $reqidx + 1"
done < $depends
}
# fetch_ops(): Fetch ops
# params: none
# Populates the firstop and lastop variables
# and the opfiles and opscript arrays
fetch_ops()
{
opsidx=0
while read optype op
do
case $optype in
'firstop')
firstop="$op"
;;
'lastop')
lastop="$op"
;;
esac
opfiles[$opsidx]=$optype
opscript[$opsidx]=$op
let "opsidx = $opsidx + 1"
done < $opsfile
}
#fetch_hide(): Fetch list of files to "hide"
#params: none
fetch_hide()
{
hideidx=0
while read filen
do
hide[$hideidx]=$filen
let "hideidx = $hideidx + 1"
done < $hidefile
}
##################################
# "external" functions
##################################
# create_idb(): Create the .idb file
# params: none
# Read each line in the subsys config file
# and check if we have a $dir in our staging area
create_idb()
{
fetch_hide
fetch_ops
local index=0
local found=0
while read dir pdcat perm user group desc
do
dironly=${dir%/*}
found=0
if [ -d $dironly ]; then # This exists
add_files "$dir" $pdcat $perm $user $group
for i in ${pc[@]} # If $pdcat is already there then don't add it again
do
if [ "$i" = "$pdcat" ]; then
found=1
break # It's already there so skip out
fi
done
if [ $found -eq 0 ]; then
pc[$index]=$pdcat
pd[$index]=$desc
let "index = $index + 1"
fi
fi
done < $subsysconf
$SORT +4u -6 < $idbfile > $metadir/idbtemp
lines=$(wc -l < $metadir/idbtemp)
if [ ! -z $firstop ]; then
echo "$(head -1 $metadir/idbtemp) $firstop" > $metadir/idbtemp2
tail +2 $metadir/idbtemp >> $metadir/idbtemp2
else
mv $metadir/idbtemp $metadir/idbtemp2
fi
if [ ! -z $lastop ]; then
let "lines=$lines - 1"
echo "$(head -$lines $metadir/idbtemp2)" > $idbfile
echo "$(tail -1 $metadir/idbtemp2) $lastop" >> $idbfile
else
mv $metadir/idbtemp2 $idbfile
fi
$RM -f $metadir/idbtemp $metadir/idbtemp2
}
# create_spec(): Create the .spec file.
# params: none
# Uses pkgname & pkgdesc variables
# Iterate through pctop and for each iteration find
# all entries in pc belonging to that image
#
create_spec()
{
fetch_imageconf
fetch_depends
spec_header $pkgname "$name $version-$pkgver" > $specfile
pcsize=${#pc[@]}
pctopsize=${#pctop[@]}
for ((i=0; i < $pctopsize; i++))
do
local pcidx=0
spec_img_header ${pctop[$i]} "${pdtop[$i]}" $version-$pkgver >> $specfile
while [ "$pcidx" -lt "$pcsize" ]
do
rv=`$EXPR match "${pc[$pcidx]}" ''${pctop[$i]}''`
if [ ! "$rv" -eq 0 ]; then # We got a hit!
spec_subsys_header ${pctop[$i]} `echo ${pc[$pcidx]}|$CUT -d . -f 2` "${pd[$pcidx]}" >> $specfile
reqsize=${#reqs[@]}
for ((j=0; j < $reqsize; j++))
do
if [ "${reqs[$j]}" == "${pc[$pcidx]}" ]; then
spec_subsys_req "${reqp[$j]}" >> $specfile
fi
done
spec_subsys_footer >> $specfile
fi
let "pcidx = $pcidx + 1"
done
spec_img_footer >> $specfile
done
spec_footer >> $specfile
}
# make_dist(): Create inst image
# params: $1=[shortroot]
# Run gendist to create the instimage
make_dist()
{
local arg1=${1-'x'}
if [ "$arg1" == "shortroot" ]; then
sbase=$stagedir
else
sbase=$stagedir/$topinstalldir
fi
local disttmp=/tmp/disttmp$$
$MKDIR $disttmp
$GENDIST -rbase $topinstalldir -sbase $sbase -idb $idbfile -spec $specfile -dist $disttmp
setdir $disttmp
$VTAR -cf $distdir/$distfile $pkgname*
setdir stage
$RM -rf $disttmp
echo "Done. Package was created as $distfile"
}
# generic_pack(): Build package using files from 'install' stage
# params: $1 - indicating whether or not the root is complete as described below
# We expect generic_install to have made $stagedir the "root" dir
# in that all paths below will be complete (ie. /usr/local/bin and not
# just bin) *unless* $1=shortroot.
generic_pack()
{
clean meta
# Verify if $1 is defined
local arg1=${1-'x'}
case $arg1 in
'x') if [ $catman -eq 1 -a -d $stagedir$topinstalldir/man ]; then
setdir $stagedir$topinstalldir/man
fix_man
fi
setdir $stagedir$topinstalldir
create_idb
create_spec
make_dist
;;
'shortroot') if [ $catman -eq 1 -a -d $stagedir/man ]; then
setdir $stagedir/man
fix_man
fi
setdir stage
create_idb
create_spec
make_dist shortroot
;;
'*') error $E_BAD_ARGS generic_pack
;;
esac
}
Reference in New Issue View Git Blame Copy Permalink