Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mage/usr/lib/mage/smage2.sh

    Contents of /trunk/mage/usr/lib/mage/smage2.sh

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 943 - (show annotations) (download) (as text)
    Fri Nov 20 22:39:11 2009 UTC (14 years, 5 months ago) by niro
    File MIME type: application/x-sh
    File size: 38478 byte(s) 
    -fixed broken die_pipestatus() function
-added the first attempt for split-package support
    1 #!/bin/bash
    2
    3 # compiles/installs .smage2 source install scripts
    4 # needs pkgbuild_dir (mage)
    5
    6 # SMAGE2
    7 # $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/smage2.sh,v 1.62 2007-11-28 10:47:50 niro Exp $
    8
    9 #01.10.2004
    10 # added ccache support
    11 # added distcc support
    12
    13 # set default user mage.rc
    14 : ${MAGERC="/etc/mage.rc"}
    15
    16 ## setup ##
    17 PKGSUFFIX="mpk"
    18 SRCPKGSUFFIX="mpks"
    19 SMAGENAME="$1"
    20 SMAGESUFFIX="smage2"
    21 MLIBDIR=/usr/lib/mage
    22 SMAGEVERSION="$( < ${MLIBDIR}/version)"
    23
    24 ## only for tests -> normally in /etc/rc.d/init.d/functions
    25 COLRED="\033[1;6m\033[31m"
    26 COLGREEN="\033[1;6m\033[32m"
    27 COLYELLOW="\033[1;6m\033[33m"
    28 COLBLUE="\033[1;6m\033[34m"
    29 COLMAGENTA="\033[1;6m\033[35m"
    30 COLWHITE="\033[1;6m\033[37m"
    31 COLGRAY="\033[0;6m\033[37m"
    32 COLBOLD="\033[1m"
    33 COLDEFAULT="\033[0m"
    34
    35 if [[ ${NOCOLORS} = true ]]
    36 then
    37 COLRED=""
    38 COLGREEN=""
    39 COLYELLOW=""
    40 COLBLUE=""
    41 COLMAGENTA=""
    42 COLWHITE=""
    43 COLGRAY=""
    44 COLBOLD=""
    45 COLDEFAULT=""
    46 fi
    47
    48 # export default C locale
    49 export LC_ALL=C
    50
    51 source /etc/mage.rc.global
    52 source ${MAGERC}
    53
    54 # set PKGDIR and BUILDDIR and BINDIR to MROOT
    55 if [[ -n ${MROOT} ]]
    56 then
    57 export PKGDIR=${MROOT}/${PKGDIR}
    58 export BUILDDIR=${MROOT}/${BUILDDIR}
    59 export BINDIR=${MROOT}/${BINDIR}
    60 fi
    61
    62 showversion()
    63 {
    64 echo -en "Magellan Source Install v${SMAGEVERSION} "
    65 echo -e "-- Niels Rogalla (niro@magellan-linux.de)"
    66 }
    67
    68 die()
    69 {
    70 xtitleclean
    71 echo -e ${COLRED}"Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."${COLDEFAULT}
    72 echo "SMAGE failed: $@"
    73 exit 1
    74 }
    75
    76 die_pipestatus()
    77 {
    78 # the status change if we do any parameter declarations!!
    79 # dont do this anymore, keep this in mind!
    80 #
    81 # local pos="$1"
    82 # local comment="$2"
    83 #
    84 # [ ${PIPESTATUS[${pos}]} -ne 0 ] && die "${comment}"
    85 #
    86 [ ${PIPESTATUS[$1]} -ne 0 ] && die "$2"
    87 }
    88
    89 xtitle()
    90 {
    91 if [[ ${TERM} = xterm ]]
    92 then
    93 echo -ne "\033]0;[sMage: $@]\007"
    94 fi
    95 return 0
    96 }
    97
    98 xtitleclean()
    99 {
    100 if [[ ${TERM} = xterm ]]
    101 then
    102 echo -ne "\033]0;\007"
    103 fi
    104 return 0
    105 }
    106
    107 syncsmage2()
    108 {
    109 xtitle "Updating smage2-script tree ..."
    110 local i
    111 for i in ${SMAGE2RSYNC}
    112 do
    113 rsync ${RSYNC_FETCH_OPTIONS} ${i} ${SMAGESCRIPTSDIR}
    114 if [[ $? = 0 ]]
    115 then
    116 break
    117 else
    118 continue
    119 fi
    120 done
    121
    122 # clean up backup files (foo~)
    123 find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'
    124
    125 xtitleclean
    126 }
    127
    128 # $1 filename
    129 get_db_md5_sum()
    130 {
    131 local DB_FILE
    132 local MD5_FILE
    133 local i
    134
    135 DB_ENTRY="$(basename $1)"
    136 MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} ${SMAGESUFFIX})"
    137
    138 i="$(cat ${MD5_FILE}| grep ${DB_ENTRY} | cut -d' ' -f1)"
    139
    140 echo "${i}"
    141 }
    142
    143 download_sources()
    144 {
    145
    146 [ -z "${SRC_URI}" ] && echo -e "\nNothing declared to download.\n" && return 0
    147
    148 local EOA=${#SRC_URI[*]}
    149 local my_SRC_URI
    150 local my_SRC_URI_DEST
    151 local my_SRC_URI_MIRROR
    152 local my_SOURCEDIR
    153 local DB_MD5_SUM_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
    154 local FETCHING
    155 local i mirror
    156
    157
    158 # install SRCDIR/PNAME if not exist
    159 [ ! -d ${SOURCEDIR}/${PNAME} ] && install -d ${SOURCEDIR}/${PNAME}
    160
    161 # check if FETCHING is needed
    162 ( cd ${SOURCEDIR}/${PNAME}; md5sum --check ${DB_MD5_SUM_FILE} &> /dev/null )
    163 if [[ $? = 0 ]]
    164 then
    165 # md5's ok, no fetching needed
    166 FETCHING=false
    167 else
    168 FETCHING=true
    169 fi
    170
    171 for ((i=0; i < EOA; i++))
    172 do
    173 # url to file
    174 my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
    175
    176 # subdir in sources dir; the my_SRCI_URI file goes to there
    177 my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
    178
    179 # if my_src_uri_dest is not equal my_src_uri; than an other dir is used
    180 if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
    181 then
    182 my_SOURCEDIR="${SOURCEDIR}/${PNAME}/${my_SRC_URI_DEST}"
    183 else
    184 my_SOURCEDIR="${SOURCEDIR}/${PNAME}"
    185 fi
    186
    187 # create the SOURCEDIR
    188 install -d ${my_SOURCEDIR}
    189
    190 # if an mirrored file than replace first the mirror uri
    191 if [[ -n $(echo ${my_SRC_URI} | grep 'mirror://') ]]
    192 then
    193 for mirror in ${MIRRORS}
    194 do
    195 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|mirror:/|${mirror}/sources|g")"
    196
    197 if [[ ${FETCHING} = true ]]
    198 then
    199 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    200 wget \
    201 --passive-ftp \
    202 --tries 3 \
    203 --continue \
    204 --progress bar \
    205 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    206 "${my_SRC_URI_MIRROR}"
    207 if [[ $? = 0 ]]
    208 then
    209 break
    210 else
    211 continue
    212 fi
    213 fi
    214 done
    215 elif [[ -n $(echo ${my_SRC_URI} | grep 'sourceforge://') ]]
    216 then
    217 for mirror in ${SOURCEFORGE_MIRRORS}
    218 do
    219 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|sourceforge:/|${mirror}|g")"
    220
    221 if [[ ${FETCHING} = true ]]
    222 then
    223 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    224 wget \
    225 --passive-ftp \
    226 --tries 3 \
    227 --continue \
    228 --progress bar \
    229 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    230 "${my_SRC_URI_MIRROR}"
    231 if [[ $? = 0 ]]
    232 then
    233 break
    234 else
    235 continue
    236 fi
    237 fi
    238 done
    239 elif [[ -n $(echo ${my_SRC_URI} | grep 'gnu://') ]]
    240 then
    241 for mirror in ${GNU_MIRRORS}
    242 do
    243 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|gnu:/|${mirror}|g")"
    244
    245 if [[ ${FETCHING} = true ]]
    246 then
    247 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    248 wget \
    249 --passive-ftp \
    250 --tries 3 \
    251 --continue \
    252 --progress bar \
    253 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    254 "${my_SRC_URI_MIRROR}"
    255 if [[ $? = 0 ]]
    256 then
    257 break
    258 else
    259 continue
    260 fi
    261 fi
    262 done
    263 elif [[ -n $(echo ${my_SRC_URI} | grep 'kde://') ]]
    264 then
    265 for mirror in ${KDE_MIRRORS}
    266 do
    267 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|kde:/|${mirror}|g")"
    268
    269 if [[ ${FETCHING} = true ]]
    270 then
    271 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    272 wget \
    273 --passive-ftp \
    274 --tries 3 \
    275 --continue \
    276 --progress bar \
    277 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    278 "${my_SRC_URI_MIRROR}"
    279 if [[ $? = 0 ]]
    280 then
    281 break
    282 else
    283 continue
    284 fi
    285 fi
    286 done
    287 elif [[ -n $(echo ${my_SRC_URI} | grep 'gnome://') ]]
    288 then
    289 for mirror in ${GNOME_MIRRORS}
    290 do
    291 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|gnome:/|${mirror}|g")"
    292
    293 if [[ ${FETCHING} = true ]]
    294 then
    295 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    296 wget \
    297 --passive-ftp \
    298 --tries 3 \
    299 --continue \
    300 --progress bar \
    301 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    302 "${my_SRC_URI_MIRROR}"
    303 if [[ $? = 0 ]]
    304 then
    305 break
    306 else
    307 continue
    308 fi
    309 fi
    310 done
    311 else
    312 if [[ ${FETCHING} = true ]]
    313 then
    314 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI}${COLDEFAULT}"
    315 wget \
    316 --passive-ftp \
    317 --tries 3 \
    318 --continue \
    319 --progress bar \
    320 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI})" \
    321 "${my_SRC_URI}"
    322 fi
    323 fi
    324
    325 # unset them to be shure
    326 unset my_SRC_URI
    327 unset my_SRC_URI_DEST
    328 unset my_SRC_URI_MIRROR
    329 unset my_SOURCEDIR
    330 done
    331
    332 # recheck md5 sums
    333 echo
    334 echo -e "${COLBLUE}===${COLGREEN} Checking MD5 sums:${COLDEFAULT}"
    335 ( cd ${SOURCEDIR}/${PNAME}; md5sum --check ${DB_MD5_SUM_FILE} ) || die "md5 failed"
    336 echo
    337
    338 # not needed anymore
    339 unset SRC_URI
    340 }
    341
    342 # dummy function, used if that not exist in smage file
    343 src_prepare()
    344 {
    345 echo "no src_prepare defined"
    346 sleep 2
    347 return 0
    348 }
    349
    350 # dummy function, used if that not exist in smage file
    351 src_compile()
    352 {
    353 echo "no src_compile defined"
    354 sleep 2
    355 return 0
    356 }
    357
    358 # dummy function, used if that not exist in smage file
    359 src_install()
    360 {
    361 echo "no src_install defined"
    362 sleep 2
    363 return 0
    364 }
    365
    366 mlibdir()
    367 {
    368 local libdir=lib
    369 [[ ${ARCH} = x86_64 ]] && libdir=lib64
    370
    371 echo "${libdir}"
    372 }
    373
    374 mconfigure()
    375 {
    376 if [ -x ./configure ]
    377 then
    378 ./configure \
    379 --prefix=/usr \
    380 --host=${CHOST} \
    381 --build=${CHOST} \
    382 --mandir=/usr/share/man \
    383 --infodir=/usr/share/info \
    384 --datadir=/usr/share \
    385 --sysconfdir=/etc \
    386 --localstatedir=/var/lib \
    387 --libdir=/usr/$(mlibdir) \
    388 "$@" || die "mconfigure failed"
    389 else
    390 echo "configure is not an executable ..."
    391 exit 1
    392 fi
    393 }
    394
    395 minstall()
    396 {
    397 if [ -f ./[mM]akefile -o -f ./GNUmakefile ]
    398 then
    399 make prefix=${BINDIR}/usr \
    400 datadir=${BINDIR}/usr/share \
    401 infodir=${BINDIR}/usr/share/info \
    402 localstatedir=${BINDIR}/var/lib \
    403 mandir=${BINDIR}/usr/share/man \
    404 sysconfdir=${BINDIR}/etc \
    405 libdir=${BINDIR}/usr/$(mlibdir) \
    406 "$@" install || die "minstall failed"
    407 else
    408 die "no Makefile found"
    409 fi
    410 }
    411
    412 mmake()
    413 {
    414 make ${MAKEOPTS} ${EXTRA_EMAKE} "$@"
    415 }
    416
    417 munpack()
    418 {
    419 local SRCFILE
    420 local IFTAR
    421 local DEST
    422
    423 SRCFILE=$1
    424
    425 if [[ -z $2 ]]
    426 then
    427 DEST=${BUILDDIR}
    428 else
    429 DEST=$2
    430 fi
    431
    432 [[ ! -d ${DEST} ]] && install -d ${DEST}
    433
    434 case "${SRCFILE##*.}" in
    435 bz2)
    436 IFTAR="$(basename $SRCFILE .bz2)"
    437 IFTAR="${IFTAR##*.}"
    438 if [[ ${IFTAR} = tar ]]
    439 then
    440 tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.bz2 unpack failed."
    441 else
    442 pushd ${DEST} > /dev/null
    443 bzcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .bz2) || die ".bz2 unpack failed."
    444 popd > /dev/null
    445 fi
    446 ;;
    447 gz)
    448 IFTAR="$(basename $SRCFILE .gz)"
    449 IFTAR="${IFTAR##*.}"
    450 if [[ ${IFTAR} = tar ]]
    451 then
    452 tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.gz unpack failed."
    453 else
    454 pushd ${DEST} > /dev/null
    455 zcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .gz) || die ".gz unpack failed."
    456 popd > /dev/null
    457 fi
    458 ;;
    459 tbz2|mpks|mpk)
    460 tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tbz2 unpack failed."
    461 ;;
    462 tgz)
    463 tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tgz unpack failed."
    464 ;;
    465 rar)
    466 unrar x ${SOURCEDIR}/${PNAME}/${SRCFILE} ${DEST} || die ".rar unpack failed."
    467 ;;
    468 zip|xpi)
    469 unzip ${SOURCEDIR}/${PNAME}/${SRCFILE} -d ${DEST} || die ".zip unpack failed."
    470 ;;
    471 rpm)
    472 pushd ${DEST} > /dev/null
    473 rpm2targz ${SOURCEDIR}/${PNAME}/${SRCFILE} || die "rpm2targz: .rpm unpack failed."
    474 tar --no-same-owner -xvzf ${SRCFILE/.rpm/.tar.gz} || die "tar: .rpm unpack failed."
    475 if [[ -f ${DEST}/${SRCFILE/.rpm/.tar.gz} ]]
    476 then
    477 rm ${DEST}/${SRCFILE/.rpm/.tar.gz}
    478 fi
    479 ;;
    480 *)
    481 die "munpack failed"
    482 ;;
    483 esac
    484 }
    485
    486 mpatch()
    487 {
    488 local PATCHOPTS
    489 local PATCHFILE
    490 local i
    491
    492 PATCHOPTS=$1
    493 PATCHFILE=$2
    494
    495 if [[ -z $2 ]]
    496 then
    497 PATCHFILE=$1
    498
    499 ## patch level auto-detection, get patch level
    500 for ((i=0; i < 10; i++))
    501 do
    502 patch --dry-run -Np${i} -i ${SOURCEDIR}/${PNAME}/${PATCHFILE} > /dev/null
    503 if [[ $? = 0 ]]
    504 then
    505 PATCHOPTS="-Np${i}"
    506 break
    507 fi
    508 done
    509 fi
    510
    511 echo -e "${COLBLUE}*** ${COLGREEN}Applying patch '${PATCHFILE}'${COLDEFAULT}"
    512 patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}
    513 }
    514
    515 mlibtoolize()
    516 {
    517 local opts="$@"
    518 [[ -z ${opts} ]] && opts="--copy --force"
    519
    520 libtoolize ${opts} || die "running: mlibtoolize ${opts}"
    521 }
    522
    523 minstalldocs()
    524 {
    525 local docfiles
    526 docfiles="$@"
    527
    528 if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]
    529 then
    530 install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."
    531 fi
    532
    533 for i in ${docfiles}
    534 do
    535 cat ${i} | gzip -9c > ${i}.gz || die "gzipping docs."
    536 install -m 0644 ${SRCDIR}/${i}.gz \
    537 ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "coping docs."
    538 done
    539 }
    540
    541 mstriplibs()
    542 {
    543 local stripdir="$@"
    544
    545 [ -z "${stripdir}" ] && stripdir=${BINDIR}
    546 find ${stripdir} | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
    547 }
    548
    549 mstripbins()
    550 {
    551 local stripdir="$@"
    552
    553 [ -z "${stripdir}" ] && stripdir=${BINDIR}
    554 find ${stripdir} | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
    555 }
    556
    557 mcompressdocs()
    558 {
    559 local bindir="$@"
    560
    561 if [ -d ${bindir}/usr/share/man ]
    562 then
    563 echo -e "${COLBLUE}===${COLGREEN} compressing man-pages ...${COLDEFAULT}"
    564 ${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/man
    565 fi
    566
    567 if [ -d ${bindir}/usr/share/info ]
    568 then
    569 echo -e "${COLBLUE}===${COLGREEN} compressing info-pages ...${COLDEFAULT}"
    570 ${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/info
    571 fi
    572 }
    573
    574 sminclude()
    575 {
    576 local i
    577
    578 if [[ -n "$@" ]]
    579 then
    580 for i in $@
    581 do
    582 echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
    583 source ${SMAGESCRIPTSDIR}/include/${i}.sminc
    584 done
    585 echo
    586 fi
    587 }
    588
    589 setup_distcc_environment()
    590 {
    591 if [ -x /usr/bin/distcc ]
    592 then
    593 echo -e "${COLBLUE}---${COLGREEN} Using DistCC for compilation ...${COLDEFAULT}"
    594 export PATH=/usr/$(mlibdir)/distcc/bin:${PATH} || die "distcc: could not export new $PATH"
    595
    596 export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"
    597
    598 # creating distcc tempdir
    599 install -o distcc -g daemon -d ${DISTCC_DIR}
    600 chmod 1777 ${DISTCC_DIR}
    601 fi
    602 }
    603
    604 setup_ccache_environment()
    605 {
    606 if [ -x /usr/bin/ccache ]
    607 then
    608 echo -e "${COLBLUE}---${COLGREEN} Using CCache for compilation ...${COLDEFAULT}"
    609 export PATH=/usr/$(mlibdir)/ccache/bin:${PATH} || die "ccache: could not export new $PATH"
    610 fi
    611 }
    612
    613
    614 # fixes given dependencies to match a MAGE_TARGET
    615 # fix_mage_deps -target s/depend # <-- note -target !
    616 fix_mage_deps()
    617 {
    618 local target="$1"
    619 local depend="$2"
    620 local NDEPEND
    621 local sym dep cat pver pname
    622
    623 # deps and provides are special
    624 # they must be fixed to match the target
    625
    626 # run this only if target and depend is not empty
    627 if [ -n "${target}" ] && [ -n "${depend}" ]
    628 then
    629 # fix DEPEND
    630 while read sym dep
    631 do
    632 # ignore empty lines
    633 [[ -z ${dep} ]] && continue
    634
    635 cat="$(dirname ${dep})"
    636 # change if not virtual
    637 if [[ ${cat} = virtual ]]
    638 then
    639 pname="$(basename ${dep})"
    640 else
    641 # fix pver to target-pver
    642 # to get pname-target-pver
    643
    644 # doing it backwards !
    645 pver="${dep##*-}"
    646 # full pver
    647 pname="$(basename ${dep/-${pver}/})${target}-${pver}"
    648 fi
    649
    650 # do not add empty lines
    651 if [ -z "${NDEPEND}" ]
    652 then
    653 NDEPEND="${sym} ${cat}/${pname}"
    654 else
    655 NDEPEND="${NDEPEND}
    656 ${sym} ${cat}/${pname}"
    657 fi
    658
    659 unset cat pname pver
    660 done << EOF
    661 ${depend}
    662 EOF
    663 # set NDEPEND to DEPEND
    664 depend="${NDEPEND}"
    665 fi
    666
    667 echo "${depend}"
    668 }
    669
    670 # build_mage_script(): helper functions for regen_mage_tree()
    671 # generates an mage file with given information in smage file
    672 # needs at least:
    673 # PNAME name of pkg
    674 # PVER version
    675 # PBUILD revision
    676 # PCATEGORIE categorie of the pkg
    677 # STATE state of pkg stable|unstable|old
    678 # DESCRIPTION va short description (opt)
    679 # HOMEPAGE homepage (opt)
    680 # DEPEND runtime dependencies (opt)
    681 # SDEPEND add. needed deps to build the pkg (opt)
    682 # PROVIDE provides a virtual (opt)
    683 #
    684 # special tags:
    685 # PKGTYPE type of pkg
    686 # INHERITS which functions get included
    687 # SPECIAL_FUNCTIONS special functions which should also be added
    688 # warning: they get killed before the build starts !
    689 # SPLIT_PACKAGES names of all subpackages which are splitted from parent
    690 # SPLIT_PACKAGE_BASE base package name for splitpackages
    691 # (only in the resulting magefile}
    692 #
    693 # MAGE_TREE_DEST target destination of the generated tree
    694 # REGEN_MAGE_TREE set to 'true' to enable this
    695 #
    696 # gets called with build_mage_script target
    697 build_mage_script()
    698 {
    699 local magefile
    700 local dest
    701 local target
    702 local split_pkg_base
    703 local sym
    704 local depname
    705
    706 # if MAGE_TREE_DEST not set use BUILDDIR
    707 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    708
    709 # determinate which suffix this mage file should get, if any
    710 [[ $1 = --target ]] && shift && target="-$1"
    711
    712 # mark package as splitpackage
    713 [[ $1 = --split-pkg-base ]] && shift && split_pkg_base="$1"
    714
    715 # name of magefile
    716 magefile="${PNAME}${target}-${PVER}-${PBUILD}.mage"
    717
    718 # destination to magefile
    719 dest="${MAGE_TREE_DEST}/${PCATEGORIE}/${PNAME}${target}/${magefile}"
    720
    721 # show what we are doing
    722 echo -e "${COLBLUE}===${COLGREEN} generating mage file:${COLDEFAULT}"
    723 echo "${dest}"
    724
    725 install -d "$(dirname ${dest})"
    726 # now build the mage file
    727 > ${dest}
    728
    729 # header
    730 echo '# $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/smage2.sh,v 1.62 2007-11-28 10:47:50 niro Exp $' >> ${dest}
    731 echo >> ${dest}
    732
    733 # pgkname and state
    734 echo "PKGNAME=\"${PNAME}${target}-${PVER}-\${ARCH}-${PBUILD}\"" >> ${dest}
    735 echo "STATE=\"${STATE}\"" >> ${dest}
    736 echo >> ${dest}
    737
    738 # description and homepage
    739 echo "DESCRIPTION=\"${DESCRIPTION}\"" >> ${dest}
    740 echo "HOMEPAGE=\"${HOMEPAGE}\"" >> ${dest}
    741 echo >> ${dest}
    742
    743 # special tags and vars
    744 echo "PKGTYPE=\"${PKGTYPE}\"" >> ${dest}
    745
    746 # echo MAGE_TARGETS ## note -target is needed !
    747 echo "MAGE_TARGETS=\"${target}\"" >> ${dest}
    748 echo >> ${dest}
    749
    750 # split package base
    751 echo "SPLIT_PACKAGE_BASE=\"${split_pkg_base}\"" >> ${dest}
    752 echo >> ${dest}
    753
    754 # add special vars
    755 if [ -n "${SPECIAL_VARS}" ]
    756 then
    757 local i
    758 for i in ${SPECIAL_VARS}
    759 do
    760 # being tricky here :)
    761 echo "${i}=\"$(eval echo \$${i})\"" >> ${dest}
    762 done
    763 echo >> ${dest}
    764 fi
    765
    766 # add at least all includes
    767 if [ -n "${INHERITS}" ]
    768 then
    769 echo -n "minclude" >> ${dest}
    770 local i
    771 for i in ${INHERITS}
    772 do
    773 echo -n " ${i}" >> ${dest}
    774 done
    775 echo >> ${dest}
    776 fi
    777 echo >> ${dest}
    778
    779 # deps and provides
    780 echo "DEPEND=\"$(fix_mage_deps "${target}" "${DEPEND}")\"" >> ${dest}
    781 echo >> ${dest}
    782 echo "SDEPEND=\"$(fix_mage_deps "${target}" "${SDEPEND}")\"" >> ${dest}
    783 echo >> ${dest}
    784 echo "PROVIDE=\"${PROVIDE}\"" >> ${dest}
    785 echo >> ${dest}
    786
    787 # add special functions
    788 if [ -n "${SPECIAL_FUNCTIONS}" ]
    789 then
    790 local i
    791 for i in ${SPECIAL_FUNCTIONS}
    792 do
    793 # add to mage (quotes needed !)
    794 typeset -f "${i}" >> ${dest}
    795 echo >> ${dest}
    796 # unset to be safe (quotes needed !)
    797 #unset "${i}" <-- later to get every target built
    798 done
    799 echo >> ${dest}
    800 fi
    801
    802 # pre|post-install|removes
    803 typeset -f preinstall >> ${dest}
    804 echo >> ${dest}
    805 typeset -f postinstall >> ${dest}
    806 echo >> ${dest}
    807 typeset -f preremove >> ${dest}
    808 echo >> ${dest}
    809 typeset -f postremove >> ${dest}
    810 echo >> ${dest}
    811 }
    812
    813 regen_mage_tree()
    814 {
    815 local i
    816
    817 # build them only if requested
    818 if [[ ${REGEN_MAGE_TREE} = true ]]
    819 then
    820 # run it without targets
    821 if [[ -n ${MAGE_TARGETS} ]]
    822 then
    823 # build for each target a mage file
    824 # run it with several targets
    825 echo
    826 for i in ${MAGE_TARGETS}
    827 do
    828 build_mage_script --target "${i}"
    829 done
    830 echo
    831
    832 # run it for splitpackages
    833 elif [[ -n ${SPLIT_PACKAGES} ]]
    834 then
    835 local split_pkg_base="${PNAME}"
    836 # save smage environment
    837 split_save_variables
    838 # build for each subpackage a mage file
    839 # run it with several targets
    840 echo
    841 for i in ${SPLIT_PACKAGES}
    842 do
    843 # get the right variables for the split
    844 export PNAME="${i}"
    845 split_info_${i}
    846 build_mage_script --split-pkg-base "${split_pkg_base}"
    847 done
    848 echo
    849 # restore smage environment
    850 split_restore_variables
    851
    852 else
    853 echo
    854 build_mage_script
    855 echo
    856 fi
    857 fi
    858
    859 # now unset all uneeded vars to be safe
    860 # unset PKGNAME <-- don't do that; smage needs this var
    861 # unset to be safe (quotes needed !)
    862 # for i in ${SPECIAL_FUNCTIONS}
    863 # do
    864 # unset "${i}"
    865 # done
    866 unset SPECIAL_FUNCTIONS
    867 # for i in ${SPECIAL_VARS}
    868 # do
    869 # unset "${i}"
    870 # done
    871 unset SPECIAL_VARS
    872 unset STATE
    873 unset DESCRIPTION
    874 unset HOMEPAGE
    875 unset PKGTYPE
    876 unset INHERITS
    877 unset DEPEND
    878 unset SDEPEND
    879 unset PROVIDE
    880 unset preinstall
    881 unset postinstall
    882 unset preremove
    883 unset postremove
    884 }
    885
    886 split_save_variables()
    887 {
    888 export SAVED_PNAME="${PNAME}"
    889 export SAVED_PVER="${PVER}"
    890 export SAVED_PBUILD="${PBUILD}"
    891 export SAVED_PCATEGORIE="${PCATEGORIE}"
    892 export SAVED_DESCRIPTION="${DESCRIPTION}"
    893 export SAVED_HOMEPAGE="${HOMEPAGE}"
    894 export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
    895 export SAVED_STATE="${STATE}"
    896 export SAVED_PKGTYPE="${PKGTYPE}"
    897 export SAVED_INHERITS="${INHERITS}"
    898 export SAVED_DEPEND="${DEPEND}"
    899 export SAVED_SDEPEND="${SDEPEND}"
    900 export SAVED_PROVIDE="${PROVIDE}"
    901
    902 # functions
    903 if [[ ! -z $(typeset -f preinstall) ]]
    904 then
    905 # rename the old one
    906 local saved_preinstall
    907 saved_preinstall=SAVED_$(typeset -f preinstall)
    908 eval "${saved_preinstall}"
    909 export -f SAVED_preinstall
    910 fi
    911
    912 if [[ ! -z $(typeset -f postinstall) ]]
    913 then
    914 # rename the old one
    915 local saved_postinstall
    916 saved_postinstall=SAVED_$(typeset -f postinstall)
    917 eval "${saved_postinstall}"
    918 export -f SAVED_postinstall
    919 fi
    920
    921 if [[ ! -z $(typeset -f preremove) ]]
    922 then
    923 # rename the old one
    924 local saved_preremove
    925 saved_preremove=SAVED_$(typeset -f preremove)
    926 eval "${saved_preremove}"
    927 export -f SAVED_preremove
    928 fi
    929
    930 if [[ ! -z $(typeset -f postremove) ]]
    931 then
    932 # rename the old one
    933 local saved_postremove
    934 saved_postremove=SAVED_$(typeset -f postremove)
    935 eval "${saved_postremove}"
    936 export -f SAVED_postremove
    937 fi
    938 }
    939
    940 split_restore_variables()
    941 {
    942 export PNAME="${SAVED_PNAME}"
    943 export PVER="${SAVED_PVER}"
    944 export PBUILD="${SAVED_PBUILD}"
    945 export PCATEGORIE="${SAVED_PCATEGORIE}"
    946 export DESCRIPTION="${SAVED_DESCRIPTION}"
    947 export HOMEPAGE="${SAVED_HOMEPAGE}"
    948 export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
    949 export STATE="${SAVED_STATE}"
    950 export PKGTYPE="${SAVED_PKGTYPE}"
    951 export INHERITS="${SAVED_INHERITS}"
    952 export DEPEND="${SAVED_DEPEND}"
    953 export SDEPEND="${SAVED_SDEPEND}"
    954 export PROVIDE="${SAVED_PROVIDE}"
    955
    956 # functions
    957 if [[ ! -z $(typeset -f SAVED_preinstall) ]]
    958 then
    959 # rename the old one
    960 local saved_preinstall
    961 saved_preinstall=$(typeset -f SAVED_preinstall)
    962 eval "${saved_preinstall/SAVED_/}"
    963 export -f preinstall
    964 fi
    965
    966 if [[ ! -z $(typeset -f SAVED_postinstall) ]]
    967 then
    968 # rename the old one
    969 local saved_postinstall
    970 saved_postinstall=$(typeset -f SAVED_postinstall)
    971 eval "${saved_postinstall/SAVED_/}"
    972 export -f postinstall
    973 fi
    974
    975 if [[ ! -z $(typeset -f SAVED_preremove) ]]
    976 then
    977 # rename the old one
    978 local saved_preremove
    979 saved_preremove=$(typeset -f SAVED_preremove)
    980 eval "${saved_preremove/SAVED_/}"
    981 export -f preremove
    982 fi
    983
    984 if [[ ! -z $(typeset -f SAVED_postremove) ]]
    985 then
    986 # rename the old one
    987 local saved_postremove
    988 saved_postremove=$(typeset -f SAVED_postremove)
    989 eval "${saved_postremove/SAVED_/}"
    990 export -f postremove
    991 fi
    992
    993 # unset saved vars; not needed anymore
    994 unset SAVED_PNAME
    995 unset SAVED_PVER
    996 unset SAVED_PBUILD
    997 unset SAVED_PCATEGORIE
    998 unset SAVED_DESCRIPTION
    999 unset SAVED_HOMEPAGE
    1000 unset SAVED_SPECIAL_VARS
    1001 unset SAVED_STATE
    1002 unset SAVED_PKGTYPE
    1003 unset SAVED_INHERITS
    1004 unset SAVED_DEPEND
    1005 unset SAVED_SDEPEND
    1006 unset SAVED_PROVIDE
    1007 unset -f SAVED_preinstall
    1008 unset -f SAVED_postinstall
    1009 unset -f SAVED_preremove
    1010 unset -f SAVED_postremove
    1011 }
    1012
    1013 export_inherits()
    1014 {
    1015 local include="$1"
    1016 shift
    1017
    1018 while [ "$1" ]
    1019 do
    1020 local functions="$1"
    1021
    1022 # sanity checks
    1023 [ -z "${include}" ] && die "export_inherits(): \$include not given."
    1024 [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    1025
    1026 eval "${functions}() { ${include}_${functions} ; }"
    1027
    1028 # debug
    1029 [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    1030
    1031 shift
    1032 done
    1033 }
    1034
    1035 generate_package_md5sum()
    1036 {
    1037 local dest
    1038 local pcat
    1039 local pname
    1040 local pver
    1041 local pbuild
    1042 local parch
    1043 local target
    1044 local pkgname
    1045
    1046 # very basic getops
    1047 for i in $*
    1048 do
    1049 case $1 in
    1050 --pcat|-c) shift; pcat="$1" ;;
    1051 --pname|-n) shift; pname="$1" ;;
    1052 --pver|-v) shift; pver="$1" ;;
    1053 --pbuild|-b) shift; pbuild="$1" ;;
    1054 --parch|a) shift; parch="$1" ;;
    1055 --target|t) shift; target="$1" ;;
    1056 esac
    1057 shift
    1058 done
    1059
    1060 # sanity checks; abort if not given
    1061 [ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
    1062 [ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
    1063 [ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
    1064 [ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
    1065 [ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
    1066
    1067 # check needed global vars
    1068 [ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
    1069 [ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
    1070
    1071 # fix target as it may be empty !
    1072 [ -n "${target}" ] && target="-${target}"
    1073
    1074
    1075 # build pkgname
    1076 pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
    1077
    1078 # build pkg-md5-sum only if requested
    1079 if [[ ${REGEN_MAGE_TREE} = true ]]
    1080 then
    1081 echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
    1082
    1083 # abort if not exist
    1084 if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
    1085 then
    1086 echo -e "${COLRED}! exists${COLDEFAULT}"
    1087 return 0
    1088 fi
    1089
    1090 # if MAGE_TREE_DEST not set use BUILDDIR
    1091 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    1092
    1093 # setup md5 dir
    1094 dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
    1095 install -d ${dest}
    1096
    1097 # gen md5sum
    1098 ( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
    1099 > ${dest}/${pkgname}.md5
    1100 echo -e "${COLGREEN}done${COLDEFAULT}"
    1101 fi
    1102 }
    1103
    1104 source_pkg_build()
    1105 {
    1106 if [[ ${PKGTYPE} = virtual ]]
    1107 then
    1108 echo "Virtual package detected; src-pkg-tarball not necessary ..."
    1109 return 0
    1110 fi
    1111
    1112 if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
    1113 then
    1114 echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
    1115 return 0
    1116 fi
    1117
    1118 [ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
    1119
    1120 echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
    1121
    1122 # include the smage2 file
    1123 cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
    1124
    1125 ( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
    1126 [[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
    1127 mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
    1128
    1129 echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
    1130 }
    1131
    1132 step_by_step()
    1133 {
    1134 if [[ ${STEP_BY_STEP} = true ]]
    1135 then
    1136 echo "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
    1137 echo "Press [enter] to continue"
    1138 read
    1139 fi
    1140 }
    1141
    1142
    1143 # print out our version
    1144 showversion
    1145 echo
    1146
    1147 if [ -z "$1" ]
    1148 then
    1149 echo "No .smage2 file given. Exiting."
    1150 echo
    1151 exit 1
    1152 fi
    1153
    1154 # updating smage2-scripts
    1155 if [[ $1 = update ]]
    1156 then
    1157 if [ ! -d ${SOURCEDIR} ]
    1158 then
    1159 install -d ${SOURCEDIR}
    1160 fi
    1161 syncsmage2
    1162 exit 0
    1163 fi
    1164
    1165 # creates md5sums for smages to given dir
    1166 if [[ $1 = calcmd5 ]]
    1167 then
    1168 if [ $# -ge 3 ]
    1169 then
    1170 SMAGENAME="$2"
    1171 MD5DIR="$3"
    1172 source ${SMAGENAME} || die "download source failed"
    1173
    1174 # overridable sourcedir; must be declared after source of the smage2
    1175 CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"
    1176
    1177 [ -z "${SRC_URI}" ] && die "Nothing declared to calculate."
    1178
    1179 # end of array
    1180 EOA=${#SRC_URI[*]}
    1181
    1182 [ ! -d ${MD5DIR} ] && install -d ${MD5DIR}
    1183
    1184 # clear md5sum file
    1185 MY_MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
    1186 echo -n > ${MY_MD5_FILE}
    1187
    1188 for ((i=0; i < EOA; i++))
    1189 do
    1190 # url to file
    1191 my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
    1192
    1193 # subdir in sources dir; the my_SRCI_URI file goes to there
    1194 my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
    1195
    1196 # if my_src_uri_dest is not equal my_src_uri; than an other dir is used
    1197 if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
    1198 then
    1199 MY_SRC_FILE="${my_SRC_URI_DEST}/$(basename ${SRC_URI[${i}]})"
    1200 else
    1201 MY_SRC_FILE="$(basename ${SRC_URI[${i}]})"
    1202 fi
    1203
    1204 if [ -e "${CALC_SOURCEDIR}/${MY_SRC_FILE}" ]
    1205 then
    1206 echo "calculating $(basename ${MY_SRC_FILE}) ..."
    1207 ( cd ${CALC_SOURCEDIR}; md5sum "${MY_SRC_FILE}" ) >> ${MY_MD5_FILE}
    1208 else
    1209 echo "WARNING: File '$(basename ${MY_SRC_FILE}) not found in ${CALC_SOURCEDIR}."
    1210 fi
    1211
    1212 # unset them to be shure
    1213 unset my_SRC_URI
    1214 unset my_SRC_URI_DEST
    1215 unset my_SRC_URI_MIRROR
    1216 unset my_SOURCEDIR
    1217 done
    1218
    1219 echo
    1220 echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
    1221 echo
    1222 else
    1223 echo "Usage: Calculating MD5 Sums:"
    1224 echo " $(basename $0) calcmd5 /path/to/SMAGENAME /path/to/MD5DIR"
    1225 echo
    1226 echo
    1227 echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
    1228 echo
    1229 exit 1
    1230 fi
    1231
    1232 exit 0
    1233 fi
    1234
    1235 # download sources
    1236 if [ "$1" == "download" -a -n "$2" ]
    1237 then
    1238 if [ ! -d ${SMAGESCRIPTSDIR} ]
    1239 then
    1240 install -d ${SMAGESCRIPTSDIR}
    1241 fi
    1242
    1243 # get smage
    1244 SMAGENAME="$2"
    1245 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1246 source ${SMAGENAME} || die "download source failed"
    1247
    1248 download_sources
    1249 exit 0
    1250 fi
    1251
    1252 # regen-mage-tree
    1253 if [ "$1" == "only-regen-tree" -a -n "$2" ]
    1254 then
    1255 # set correct SMAGENAME
    1256 SMAGENAME="$2"
    1257 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1258 source ${SMAGENAME} || die "regen: smage2 not found"
    1259
    1260 regen_mage_tree
    1261
    1262 # build several targets
    1263 if [[ -n ${MAGE_TARGETS} ]]
    1264 then
    1265 for target in ${MAGE_TARGETS}
    1266 do
    1267 # build md5sum for existing packages
    1268 generate_package_md5sum \
    1269 --pcat "${PCATEGORIE}" \
    1270 --pname "${PNAME}" \
    1271 --pver "${PVER}" \
    1272 --pbuild "${PBUILD}" \
    1273 --parch "${ARCH}" \
    1274 --target "${target}"
    1275 done
    1276
    1277 # build several subpackages
    1278 elif [[ -n ${SPLIT_PACKAGES} ]]
    1279 then
    1280 split_save_variables
    1281 for subpackage in ${SPLIT_PACKAGE}
    1282 do
    1283 # get the right variables for the split
    1284 export PNAME="${subpackage}"
    1285 split_info_${subpackage}
    1286 # build md5sum for existing packages
    1287 generate_package_md5sum \
    1288 --pcat "${PCATEGORIE}" \
    1289 --pname "${PNAME}" \
    1290 --pver "${PVER}" \
    1291 --pbuild "${PBUILD}" \
    1292 --parch "${ARCH}"
    1293 done
    1294 split_restore_variables
    1295
    1296 else
    1297 # build md5sum for existing packages
    1298 generate_package_md5sum \
    1299 --pcat "${PCATEGORIE}" \
    1300 --pname "${PNAME}" \
    1301 --pver "${PVER}" \
    1302 --pbuild "${PBUILD}" \
    1303 --parch "${ARCH}"
    1304 fi
    1305
    1306 exit 0
    1307 fi
    1308
    1309 if [ "$1" == "--create-src-tarball" -a -n "$2" ]
    1310 then
    1311 # set correct SMAGENAME
    1312 SMAGENAME="$2"
    1313 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1314
    1315 echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"
    1316
    1317 source ${SMAGENAME} || die "regen: smage2 not found"
    1318
    1319 if [[ -d ${SOURCEDIR}/${PNAME} ]]
    1320 then
    1321 echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
    1322 rm -rf ${SOURCEDIR}/${PKGNAME}
    1323 fi
    1324
    1325 download_sources
    1326 source_pkg_build ${SMAGENAME}
    1327 exit 0
    1328 fi
    1329
    1330 if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
    1331 then
    1332 SRCPKGTARBALL="${2}"
    1333 USE_SRC_PKG_TARBALL=true
    1334
    1335 # abort if given file is not a source pkg
    1336 [[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."
    1337
    1338 # set correct SMAGENAME; use the one that the src_pkg provide
    1339 # /path/to/SOURCEDIR/PNAME/SMAGENAME
    1340 SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"
    1341
    1342 echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"
    1343
    1344 [[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}
    1345
    1346 # unpack srctarball
    1347 [[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."
    1348
    1349 tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die "Error unpackung src-tarball ${SRCPKGTARBALL}"
    1350
    1351 [[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
    1352 fi
    1353
    1354
    1355 [ ! -e ${MLIBDIR}/pkgbuild_dir.sh ] && die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."
    1356 [ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
    1357 die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
    1358 [ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
    1359 [ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
    1360 [ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
    1361 [ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
    1362 [ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
    1363 [ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
    1364 [ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"
    1365
    1366 source ${SMAGENAME} || die "source failed"
    1367 PKGNAME="${PNAME}-${PVER}-${ARCH}-${PBUILD}"
    1368 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1369 SMAGE_LOG_CMD="tee -a /var/log/smage/${PKGNAME}.log"
    1370
    1371 xtitle "Compiling ${PKGNAME}"
    1372 echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"
    1373
    1374 # auto regen mage tree if requested
    1375 regen_mage_tree
    1376
    1377 if [[ ${CREATE_SRC_PKG_TARBALL} = true ]]
    1378 then
    1379 if [[ -d ${SOURCEDIR}/${PNAME} ]]
    1380 then
    1381 echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
    1382 rm -rf ${SOURCEDIR}/${PNAME}
    1383 fi
    1384 fi
    1385
    1386 # download sources
    1387 [[ ${USE_SRC_PKG_TARBALL} != true ]] && download_sources
    1388
    1389 # fixes some issues with these functions
    1390 export -f src_prepare || die "src_prepare export failed"
    1391 export -f src_compile || die "src_compile export failed"
    1392 export -f src_install || die "src_install export failed"
    1393
    1394 # fixes some compile issues
    1395 export CHOST="${CHOST}" || die "CHOST export failed"
    1396 export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
    1397 export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
    1398 export BINDIR="${BINDIR}" || die "BINDIR export failed"
    1399 export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"
    1400
    1401
    1402 # setup distcc
    1403 # setup for distcc goes *before* ccache, so ccache comes before distcc in path
    1404 [[ ${SMAGE_USE_DISTCC} = true ]] && setup_distcc_environment
    1405
    1406 # setup ccache
    1407 [[ ${SMAGE_USE_CCACHE} = true ]] && setup_ccache_environment
    1408
    1409 # small sleep to show our settings
    1410 sleep 1
    1411
    1412 # cleans up build if a previously one exists
    1413 if [ -d ${BUILDDIR} ]
    1414 then
    1415 rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
    1416 fi
    1417 install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."
    1418
    1419 # cleans up srcdir if a previously unpacked one exists
    1420 if [ -d ${SRCDIR} ]
    1421 then
    1422 rm -rf ${SRCDIR}
    1423 fi
    1424
    1425 # cleans up bindir if a previous build exists or creates a new one
    1426 if [ -d ${BINDIR} ]
    1427 then
    1428 rm -rf ${BINDIR}
    1429 fi
    1430 install -d ${BINDIR} || die "couldn't create \$BINDIR."
    1431
    1432 # cleans up package temp dir if a previous build exists
    1433 if [ -d ${BUILDDIR}/${PKGNAME} ]
    1434 then
    1435 rm -rf ${BUILDDIR}/${PKGNAME}
    1436 fi
    1437
    1438 # cleans up timestamp if one exists
    1439 if [ -f /var/tmp/timestamp ]
    1440 then
    1441 mage rmstamp
    1442 fi
    1443
    1444 # setup build loggins
    1445 [[ ! -d /var/log/smage ]] && install -d /var/log/smage
    1446 echo -e "### Build started on $(date) ###\n" > /var/log/smage/${PKGNAME}.log
    1447
    1448 src_prepare | ${SMAGE_LOG_CMD}
    1449 die_pipestatus 0 "src_prepare failed"
    1450 step_by_step $_
    1451
    1452 src_compile | ${SMAGE_LOG_CMD}
    1453 die_pipestatus 0 "src_compile failed"
    1454 step_by_step $_
    1455
    1456 # build several subpackages
    1457 if [[ -n ${SPLIT_PACKAGES} ]]
    1458 then
    1459 # save bindir
    1460 export SAVED_BINDIR="${BINDIR}"
    1461 for subpackage in ${SPLIT_PACKAGES}
    1462 do
    1463 if typeset -f src_install_${subpackage} > /dev/null
    1464 then
    1465 # export subpackage bindir
    1466 export BINDIR="${SAVED_BINDIR}_${subpackage}"
    1467 src_install_${subpackage} | ${SMAGE_LOG_CMD}
    1468 die_pipestatus 0 "src_install_${subpackage} failed"
    1469 step_by_step $_
    1470 fi
    1471 done
    1472 # restore bindir
    1473 export BINDIR="${SAVED_BINDIR}"
    1474 unset SAVED_BINDIR
    1475 else
    1476 src_install | ${SMAGE_LOG_CMD}
    1477 die_pipestatus 0 "src_install failed"
    1478 step_by_step $_
    1479 fi
    1480
    1481 echo -e "${COLGREEN}DEB${COLRED}UG!${COLDEFAULT}"
    1482
    1483 # compressing doc, info & man files
    1484 if [[ -n ${SPLIT_PACKAGES} ]]
    1485 then
    1486 for subpackage in ${SPLIT_PACKAGE}
    1487 do
    1488 mcompressdocs ${BINDIR}_${subpackage}
    1489 done
    1490 else
    1491 mcompressdocs ${BINDIR}
    1492 fi
    1493
    1494
    1495 # stripping all bins and libs
    1496 case ${NOSTRIP} in
    1497 true|TRUE|yes|y)
    1498 echo -e "NOSTRIP=true detected; Package will not be stripped ..."
    1499 ;;
    1500 *)
    1501 if [[ -n ${SPLIT_PACKAGES} ]]
    1502 then
    1503 for subpackage in ${SPLIT_PACKAGE}
    1504 do
    1505 echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
    1506 mstripbins ${BINDIR}_${subpackage}
    1507 echo -e "${COLBLUE}===${COLGREEN} stripping libraries ...${COLDEFAULT}"
    1508 mstriplibs ${BINDIR}_${subpackage}
    1509 done
    1510 else
    1511 echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
    1512 mstripbins ${BINDIR}
    1513 echo -e "${COLBLUE}===${COLGREEN} stripping libraries ...${COLDEFAULT}"
    1514 mstriplibs ${BINDIR}
    1515 fi
    1516 ;;
    1517 esac
    1518
    1519 # the new buildpkg command
    1520 case ${NOPKGBUILD} in
    1521 true|TRUE|yes|y)
    1522 echo -e "NOPGKBUILD=true detected; Package will not be build ..."
    1523 ;;
    1524 *)
    1525 # build several targets
    1526 if [[ -n ${MAGE_TARGETS} ]]
    1527 then
    1528 for target in ${MAGE_TARGETS}
    1529 do
    1530 # check if an special target_pkgbuild exists
    1531 if typeset -f ${target}_pkgbuild > /dev/null
    1532 then
    1533 # run it
    1534 ${target}_pkgbuild
    1535 fi
    1536 # now create the target package
    1537 ${MLIBDIR}/pkgbuild_dir.sh \
    1538 "${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD}" \
    1539 ${BINDIR} || die "target: ${target} package-build failed"
    1540
    1541 # build pkg-md5-sum if requested
    1542 generate_package_md5sum \
    1543 --pcat "${PCATEGORIE}" \
    1544 --pname "${PNAME}" \
    1545 --pver "${PVER}" \
    1546 --pbuild "${PBUILD}" \
    1547 --parch "${ARCH}" \
    1548 --target "${target}"
    1549
    1550 echo -e "${COLGREEN}\nPackage ${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
    1551 done
    1552
    1553 # build several subpackages
    1554 elif [[ -n ${SPLIT_PACKAGES} ]]
    1555 then
    1556 split_save_variables
    1557 for subpackage in ${SPLIT_PACKAGES}
    1558 do
    1559 # get the right variables for the split
    1560 export PNAME="${subpackage}"
    1561 split_info_${PNAME}
    1562
    1563 # check if an special subpackage_pkgbuild exists
    1564 if typeset -f ${PNAME}_pkgbuild > /dev/null
    1565 then
    1566 # run it
    1567 ${PNAME}_pkgbuild
    1568 fi
    1569 # now create the target package
    1570 ${MLIBDIR}/pkgbuild_dir.sh \
    1571 "${PNAME}-${PVER}-${ARCH}-${PBUILD}" \
    1572 "${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
    1573
    1574 # build pkg-md5-sum if requested
    1575 generate_package_md5sum \
    1576 --pcat "${PCATEGORIE}" \
    1577 --pname "${PNAME}" \
    1578 --pver "${PVER}" \
    1579 --pbuild "${PBUILD}" \
    1580 --parch "${ARCH}"
    1581
    1582 echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
    1583 done
    1584 split_restore_variables
    1585
    1586 else
    1587 ${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"
    1588
    1589 # build pkg-md5-sum if requested
    1590 generate_package_md5sum \
    1591 --pcat "${PCATEGORIE}" \
    1592 --pname "${PNAME}" \
    1593 --pver "${PVER}" \
    1594 --pbuild "${PBUILD}" \
    1595 --parch "${ARCH}"
    1596
    1597 echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
    1598 fi
    1599
    1600 # build src-pkg-tarball if requested
    1601 [[ ${CREATE_SRC_PKG_TARBALL} = true ]] && source_pkg_build ${SMAGENAME}
    1602 ;;
    1603 esac
    1604
    1605 if [[ ${SMAGE_BUILD_LOGGING} != false ]]
    1606 then
    1607 bzip2 -9f /var/log/smage/${PKGNAME}.log
    1608 else
    1609 [[ -f /var/log/smage/${PKGNAME}.log ]] && rm /var/log/smage/${PKGNAME}.log
    1610 fi
    1611
    1612 # for sure
    1613 unset NOPKGBUILD
    1614 unset NOSTRIP
    1615
    1616 xtitleclean

    Properties

    Name Value
    svn:executable *