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 951 - (show annotations) (download) (as text)
    Sat Nov 21 14:31:50 2009 UTC (14 years, 5 months ago) by niro
    File MIME type: application/x-sh
    File size: 39601 byte(s) 
    -fixed varibale/function export issues with magefile generation in split_packages
    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 # restore smage environment
    848 split_restore_variables
    849 done
    850 echo
    851 # unset all saved smage variables
    852 split_unset_variables
    853
    854 else
    855 echo
    856 build_mage_script
    857 echo
    858 fi
    859 fi
    860
    861 # now unset all uneeded vars to be safe
    862 # unset PKGNAME <-- don't do that; smage needs this var
    863 # unset to be safe (quotes needed !)
    864 # for i in ${SPECIAL_FUNCTIONS}
    865 # do
    866 # unset "${i}"
    867 # done
    868 unset SPECIAL_FUNCTIONS
    869 # for i in ${SPECIAL_VARS}
    870 # do
    871 # unset "${i}"
    872 # done
    873 unset SPECIAL_VARS
    874 unset STATE
    875 unset DESCRIPTION
    876 unset HOMEPAGE
    877 unset PKGTYPE
    878 unset INHERITS
    879 unset DEPEND
    880 unset SDEPEND
    881 unset PROVIDE
    882 unset preinstall
    883 unset postinstall
    884 unset preremove
    885 unset postremove
    886 }
    887
    888 split_save_variables()
    889 {
    890 export SAVED_PNAME="${PNAME}"
    891 export SAVED_PVER="${PVER}"
    892 export SAVED_PBUILD="${PBUILD}"
    893 export SAVED_PCATEGORIE="${PCATEGORIE}"
    894 export SAVED_DESCRIPTION="${DESCRIPTION}"
    895 export SAVED_HOMEPAGE="${HOMEPAGE}"
    896 export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
    897 export SAVED_STATE="${STATE}"
    898 export SAVED_PKGTYPE="${PKGTYPE}"
    899 export SAVED_INHERITS="${INHERITS}"
    900 export SAVED_DEPEND="${DEPEND}"
    901 export SAVED_SDEPEND="${SDEPEND}"
    902 export SAVED_PROVIDE="${PROVIDE}"
    903 export SAVED_NOPKGBUILD="${NOPKGBUILD}"
    904
    905 # bindir too
    906 export SAVED_BINDIR="${BINDIR}"
    907
    908 # export the SPLIT_PACKAGE_BASE
    909 export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
    910
    911 # functions
    912 if [[ ! -z $(typeset -f preinstall) ]]
    913 then
    914 # rename the old one
    915 local saved_preinstall
    916 saved_preinstall=SAVED_$(typeset -f preinstall)
    917 eval "${saved_preinstall}"
    918 export -f SAVED_preinstall
    919 fi
    920
    921 if [[ ! -z $(typeset -f postinstall) ]]
    922 then
    923 # rename the old one
    924 local saved_postinstall
    925 saved_postinstall=SAVED_$(typeset -f postinstall)
    926 eval "${saved_postinstall}"
    927 export -f SAVED_postinstall
    928 fi
    929
    930 if [[ ! -z $(typeset -f preremove) ]]
    931 then
    932 # rename the old one
    933 local saved_preremove
    934 saved_preremove=SAVED_$(typeset -f preremove)
    935 eval "${saved_preremove}"
    936 export -f SAVED_preremove
    937 fi
    938
    939 if [[ ! -z $(typeset -f postremove) ]]
    940 then
    941 # rename the old one
    942 local saved_postremove
    943 saved_postremove=SAVED_$(typeset -f postremove)
    944 eval "${saved_postremove}"
    945 export -f SAVED_postremove
    946 fi
    947 }
    948
    949 split_restore_variables()
    950 {
    951 export PNAME="${SAVED_PNAME}"
    952 export PVER="${SAVED_PVER}"
    953 export PBUILD="${SAVED_PBUILD}"
    954 export PCATEGORIE="${SAVED_PCATEGORIE}"
    955 export DESCRIPTION="${SAVED_DESCRIPTION}"
    956 export HOMEPAGE="${SAVED_HOMEPAGE}"
    957 export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
    958 export STATE="${SAVED_STATE}"
    959 export PKGTYPE="${SAVED_PKGTYPE}"
    960 export INHERITS="${SAVED_INHERITS}"
    961 export DEPEND="${SAVED_DEPEND}"
    962 export SDEPEND="${SAVED_SDEPEND}"
    963 export PROVIDE="${SAVED_PROVIDE}"
    964 export NOPKGBUILD="${SAVED_NOPKGBUILD}"
    965
    966 # bindir too
    967 export BINDIR="${SAVED_BINDIR}"
    968
    969 # functions
    970 if [[ ! -z $(typeset -f SAVED_preinstall) ]]
    971 then
    972 # rename the old one
    973 local saved_preinstall
    974 saved_preinstall=$(typeset -f SAVED_preinstall)
    975 eval "${saved_preinstall/SAVED_/}"
    976 export -f preinstall
    977 fi
    978
    979 if [[ ! -z $(typeset -f SAVED_postinstall) ]]
    980 then
    981 # rename the old one
    982 local saved_postinstall
    983 saved_postinstall=$(typeset -f SAVED_postinstall)
    984 eval "${saved_postinstall/SAVED_/}"
    985 export -f postinstall
    986 fi
    987
    988 if [[ ! -z $(typeset -f SAVED_preremove) ]]
    989 then
    990 # rename the old one
    991 local saved_preremove
    992 saved_preremove=$(typeset -f SAVED_preremove)
    993 eval "${saved_preremove/SAVED_/}"
    994 export -f preremove
    995 fi
    996
    997 if [[ ! -z $(typeset -f SAVED_postremove) ]]
    998 then
    999 # rename the old one
    1000 local saved_postremove
    1001 saved_postremove=$(typeset -f SAVED_postremove)
    1002 eval "${saved_postremove/SAVED_/}"
    1003 export -f postremove
    1004 fi
    1005 }
    1006
    1007 split_unset_variables()
    1008 {
    1009 # unset saved vars; not needed anymore
    1010 unset SAVED_PNAME
    1011 unset SAVED_PVER
    1012 unset SAVED_PBUILD
    1013 unset SAVED_PCATEGORIE
    1014 unset SAVED_DESCRIPTION
    1015 unset SAVED_HOMEPAGE
    1016 unset SAVED_SPECIAL_VARS
    1017 unset SAVED_STATE
    1018 unset SAVED_PKGTYPE
    1019 unset SAVED_INHERITS
    1020 unset SAVED_DEPEND
    1021 unset SAVED_SDEPEND
    1022 unset SAVED_PROVIDE
    1023 unset SAVED_BINDIR
    1024 unset SAVED_NOPKGBUILD
    1025 unset SPLIT_PACKAGE_BASE
    1026 unset -f SAVED_preinstall
    1027 unset -f SAVED_postinstall
    1028 unset -f SAVED_preremove
    1029 unset -f SAVED_postremove
    1030 }
    1031
    1032 export_inherits()
    1033 {
    1034 local include="$1"
    1035 shift
    1036
    1037 while [ "$1" ]
    1038 do
    1039 local functions="$1"
    1040
    1041 # sanity checks
    1042 [ -z "${include}" ] && die "export_inherits(): \$include not given."
    1043 [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    1044
    1045 eval "${functions}() { ${include}_${functions} ; }"
    1046
    1047 # debug
    1048 [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    1049
    1050 shift
    1051 done
    1052 }
    1053
    1054 generate_package_md5sum()
    1055 {
    1056 local dest
    1057 local pcat
    1058 local pname
    1059 local pver
    1060 local pbuild
    1061 local parch
    1062 local target
    1063 local pkgname
    1064
    1065 # very basic getops
    1066 for i in $*
    1067 do
    1068 case $1 in
    1069 --pcat|-c) shift; pcat="$1" ;;
    1070 --pname|-n) shift; pname="$1" ;;
    1071 --pver|-v) shift; pver="$1" ;;
    1072 --pbuild|-b) shift; pbuild="$1" ;;
    1073 --parch|a) shift; parch="$1" ;;
    1074 --target|t) shift; target="$1" ;;
    1075 esac
    1076 shift
    1077 done
    1078
    1079 # sanity checks; abort if not given
    1080 [ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
    1081 [ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
    1082 [ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
    1083 [ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
    1084 [ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
    1085
    1086 # check needed global vars
    1087 [ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
    1088 [ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
    1089
    1090 # fix target as it may be empty !
    1091 [ -n "${target}" ] && target="-${target}"
    1092
    1093
    1094 # build pkgname
    1095 pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
    1096
    1097 # build pkg-md5-sum only if requested
    1098 if [[ ${REGEN_MAGE_TREE} = true ]]
    1099 then
    1100 echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
    1101
    1102 # abort if not exist
    1103 if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
    1104 then
    1105 echo -e "${COLRED}! exists${COLDEFAULT}"
    1106 return 0
    1107 fi
    1108
    1109 # if MAGE_TREE_DEST not set use BUILDDIR
    1110 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    1111
    1112 # setup md5 dir
    1113 dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
    1114 install -d ${dest}
    1115
    1116 # gen md5sum
    1117 ( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
    1118 > ${dest}/${pkgname}.md5
    1119 echo -e "${COLGREEN}done${COLDEFAULT}"
    1120 fi
    1121 }
    1122
    1123 source_pkg_build()
    1124 {
    1125 if [[ ${PKGTYPE} = virtual ]]
    1126 then
    1127 echo "Virtual package detected; src-pkg-tarball not necessary ..."
    1128 return 0
    1129 fi
    1130
    1131 if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
    1132 then
    1133 echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
    1134 return 0
    1135 fi
    1136
    1137 [ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
    1138
    1139 echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
    1140
    1141 # include the smage2 file
    1142 cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
    1143
    1144 ( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
    1145 [[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
    1146 mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
    1147
    1148 echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
    1149 }
    1150
    1151 step_by_step()
    1152 {
    1153 if [[ ${STEP_BY_STEP} = true ]]
    1154 then
    1155 echo -e "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
    1156 echo "Press [enter] to continue"
    1157 read
    1158 fi
    1159 }
    1160
    1161
    1162 # print out our version
    1163 showversion
    1164 echo
    1165
    1166 if [ -z "$1" ]
    1167 then
    1168 echo "No .smage2 file given. Exiting."
    1169 echo
    1170 exit 1
    1171 fi
    1172
    1173 # updating smage2-scripts
    1174 if [[ $1 = update ]]
    1175 then
    1176 if [ ! -d ${SOURCEDIR} ]
    1177 then
    1178 install -d ${SOURCEDIR}
    1179 fi
    1180 syncsmage2
    1181 exit 0
    1182 fi
    1183
    1184 # creates md5sums for smages to given dir
    1185 if [[ $1 = calcmd5 ]]
    1186 then
    1187 if [ $# -ge 3 ]
    1188 then
    1189 SMAGENAME="$2"
    1190 MD5DIR="$3"
    1191 source ${SMAGENAME} || die "download source failed"
    1192
    1193 # overridable sourcedir; must be declared after source of the smage2
    1194 CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"
    1195
    1196 [ -z "${SRC_URI}" ] && die "Nothing declared to calculate."
    1197
    1198 # end of array
    1199 EOA=${#SRC_URI[*]}
    1200
    1201 [ ! -d ${MD5DIR} ] && install -d ${MD5DIR}
    1202
    1203 # clear md5sum file
    1204 MY_MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
    1205 echo -n > ${MY_MD5_FILE}
    1206
    1207 for ((i=0; i < EOA; i++))
    1208 do
    1209 # url to file
    1210 my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
    1211
    1212 # subdir in sources dir; the my_SRCI_URI file goes to there
    1213 my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
    1214
    1215 # if my_src_uri_dest is not equal my_src_uri; than an other dir is used
    1216 if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
    1217 then
    1218 MY_SRC_FILE="${my_SRC_URI_DEST}/$(basename ${SRC_URI[${i}]})"
    1219 else
    1220 MY_SRC_FILE="$(basename ${SRC_URI[${i}]})"
    1221 fi
    1222
    1223 if [ -e "${CALC_SOURCEDIR}/${MY_SRC_FILE}" ]
    1224 then
    1225 echo "calculating $(basename ${MY_SRC_FILE}) ..."
    1226 ( cd ${CALC_SOURCEDIR}; md5sum "${MY_SRC_FILE}" ) >> ${MY_MD5_FILE}
    1227 else
    1228 echo "WARNING: File '$(basename ${MY_SRC_FILE}) not found in ${CALC_SOURCEDIR}."
    1229 fi
    1230
    1231 # unset them to be shure
    1232 unset my_SRC_URI
    1233 unset my_SRC_URI_DEST
    1234 unset my_SRC_URI_MIRROR
    1235 unset my_SOURCEDIR
    1236 done
    1237
    1238 echo
    1239 echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
    1240 echo
    1241 else
    1242 echo "Usage: Calculating MD5 Sums:"
    1243 echo " $(basename $0) calcmd5 /path/to/SMAGENAME /path/to/MD5DIR"
    1244 echo
    1245 echo
    1246 echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
    1247 echo
    1248 exit 1
    1249 fi
    1250
    1251 exit 0
    1252 fi
    1253
    1254 # download sources
    1255 if [ "$1" == "download" -a -n "$2" ]
    1256 then
    1257 if [ ! -d ${SMAGESCRIPTSDIR} ]
    1258 then
    1259 install -d ${SMAGESCRIPTSDIR}
    1260 fi
    1261
    1262 # get smage
    1263 SMAGENAME="$2"
    1264 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1265 source ${SMAGENAME} || die "download source failed"
    1266
    1267 download_sources
    1268 exit 0
    1269 fi
    1270
    1271 # regen-mage-tree
    1272 if [ "$1" == "only-regen-tree" -a -n "$2" ]
    1273 then
    1274 # set correct SMAGENAME
    1275 SMAGENAME="$2"
    1276 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1277 source ${SMAGENAME} || die "regen: smage2 not found"
    1278
    1279 regen_mage_tree
    1280
    1281 # build several targets
    1282 if [[ -n ${MAGE_TARGETS} ]]
    1283 then
    1284 for target in ${MAGE_TARGETS}
    1285 do
    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 --target "${target}"
    1294 done
    1295
    1296 # build several subpackages
    1297 elif [[ -n ${SPLIT_PACKAGES} ]]
    1298 then
    1299 split_save_variables
    1300 for subpackage in ${SPLIT_PACKAGE}
    1301 do
    1302 # get the right variables for the split
    1303 export PNAME="${subpackage}"
    1304 split_info_${subpackage}
    1305 # build md5sum for existing packages
    1306 generate_package_md5sum \
    1307 --pcat "${PCATEGORIE}" \
    1308 --pname "${PNAME}" \
    1309 --pver "${PVER}" \
    1310 --pbuild "${PBUILD}" \
    1311 --parch "${ARCH}"
    1312 # restore smage environment
    1313 split_restore_variables
    1314 done
    1315 # unset all saved smage variables
    1316 split_unset_variables
    1317
    1318 else
    1319 # build md5sum for existing packages
    1320 generate_package_md5sum \
    1321 --pcat "${PCATEGORIE}" \
    1322 --pname "${PNAME}" \
    1323 --pver "${PVER}" \
    1324 --pbuild "${PBUILD}" \
    1325 --parch "${ARCH}"
    1326 fi
    1327
    1328 exit 0
    1329 fi
    1330
    1331 if [ "$1" == "--create-src-tarball" -a -n "$2" ]
    1332 then
    1333 # set correct SMAGENAME
    1334 SMAGENAME="$2"
    1335 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1336
    1337 echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"
    1338
    1339 source ${SMAGENAME} || die "regen: smage2 not found"
    1340
    1341 if [[ -d ${SOURCEDIR}/${PNAME} ]]
    1342 then
    1343 echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
    1344 rm -rf ${SOURCEDIR}/${PKGNAME}
    1345 fi
    1346
    1347 download_sources
    1348 source_pkg_build ${SMAGENAME}
    1349 exit 0
    1350 fi
    1351
    1352 if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
    1353 then
    1354 SRCPKGTARBALL="${2}"
    1355 USE_SRC_PKG_TARBALL=true
    1356
    1357 # abort if given file is not a source pkg
    1358 [[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."
    1359
    1360 # set correct SMAGENAME; use the one that the src_pkg provide
    1361 # /path/to/SOURCEDIR/PNAME/SMAGENAME
    1362 SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"
    1363
    1364 echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"
    1365
    1366 [[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}
    1367
    1368 # unpack srctarball
    1369 [[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."
    1370
    1371 tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die "Error unpackung src-tarball ${SRCPKGTARBALL}"
    1372
    1373 [[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
    1374 fi
    1375
    1376
    1377 [ ! -e ${MLIBDIR}/pkgbuild_dir.sh ] && die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."
    1378 [ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
    1379 die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
    1380 [ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
    1381 [ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
    1382 [ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
    1383 [ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
    1384 [ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
    1385 [ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
    1386 [ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"
    1387
    1388 source ${SMAGENAME} || die "source failed"
    1389 PKGNAME="${PNAME}-${PVER}-${ARCH}-${PBUILD}"
    1390 MD5DIR="$(dirname ${SMAGENAME})/md5"
    1391 SMAGE_LOG_CMD="tee -a /var/log/smage/${PKGNAME}.log"
    1392
    1393 xtitle "Compiling ${PKGNAME}"
    1394 echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"
    1395
    1396 # auto regen mage tree if requested
    1397 regen_mage_tree
    1398
    1399 if [[ ${CREATE_SRC_PKG_TARBALL} = true ]]
    1400 then
    1401 if [[ -d ${SOURCEDIR}/${PNAME} ]]
    1402 then
    1403 echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
    1404 rm -rf ${SOURCEDIR}/${PNAME}
    1405 fi
    1406 fi
    1407
    1408 # download sources
    1409 [[ ${USE_SRC_PKG_TARBALL} != true ]] && download_sources
    1410
    1411 # fixes some issues with these functions
    1412 export -f src_prepare || die "src_prepare export failed"
    1413 export -f src_compile || die "src_compile export failed"
    1414 export -f src_install || die "src_install export failed"
    1415
    1416 # fixes some compile issues
    1417 export CHOST="${CHOST}" || die "CHOST export failed"
    1418 export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
    1419 export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
    1420 export BINDIR="${BINDIR}" || die "BINDIR export failed"
    1421 export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"
    1422
    1423
    1424 # setup distcc
    1425 # setup for distcc goes *before* ccache, so ccache comes before distcc in path
    1426 [[ ${SMAGE_USE_DISTCC} = true ]] && setup_distcc_environment
    1427
    1428 # setup ccache
    1429 [[ ${SMAGE_USE_CCACHE} = true ]] && setup_ccache_environment
    1430
    1431 # small sleep to show our settings
    1432 sleep 1
    1433
    1434 # cleans up build if a previously one exists
    1435 if [ -d ${BUILDDIR} ]
    1436 then
    1437 rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
    1438 fi
    1439 install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."
    1440
    1441 # cleans up srcdir if a previously unpacked one exists
    1442 if [ -d ${SRCDIR} ]
    1443 then
    1444 rm -rf ${SRCDIR}
    1445 fi
    1446
    1447 # cleans up bindir if a previous build exists or creates a new one
    1448 if [ -d ${BINDIR} ]
    1449 then
    1450 rm -rf ${BINDIR}
    1451 fi
    1452 install -d ${BINDIR} || die "couldn't create \$BINDIR."
    1453
    1454 # cleans up package temp dir if a previous build exists
    1455 if [ -d ${BUILDDIR}/${PKGNAME} ]
    1456 then
    1457 rm -rf ${BUILDDIR}/${PKGNAME}
    1458 fi
    1459
    1460 # cleans up timestamp if one exists
    1461 if [ -f /var/tmp/timestamp ]
    1462 then
    1463 mage rmstamp
    1464 fi
    1465
    1466 # setup build loggins
    1467 [[ ! -d /var/log/smage ]] && install -d /var/log/smage
    1468 echo -e "### Build started on $(date) ###\n" > /var/log/smage/${PKGNAME}.log
    1469
    1470 src_prepare | ${SMAGE_LOG_CMD}
    1471 die_pipestatus 0 "src_prepare failed"
    1472 step_by_step $_
    1473
    1474 src_compile | ${SMAGE_LOG_CMD}
    1475 die_pipestatus 0 "src_compile failed"
    1476 step_by_step $_
    1477
    1478 # build several subpackages
    1479 if [[ -n ${SPLIT_PACKAGES} ]]
    1480 then
    1481 # save bindir & pname
    1482 split_save_variables
    1483 export SAVED_BINDIR="${BINDIR}"
    1484 for subpackage in ${SPLIT_PACKAGES}
    1485 do
    1486 if typeset -f src_install_${subpackage} > /dev/null
    1487 then
    1488 # export subpackage bindir
    1489 export BINDIR="${SAVED_BINDIR}_${subpackage}"
    1490 # export PNAME, several internal function and include
    1491 # rely on this variable
    1492 export PNAME="${subpackage}"
    1493
    1494 echo
    1495 echo -en "${COLBLUE}*** ${COLDEFAULT}"
    1496 echo -en " Running ${COLGREEN}split src_install()${COLDEFAULT}"
    1497 echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
    1498 echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."
    1499
    1500 src_install_${subpackage} | ${SMAGE_LOG_CMD}
    1501 die_pipestatus 0 "src_install_${subpackage} failed"
    1502 step_by_step $_
    1503 fi
    1504 done
    1505 # restore bindir & pname
    1506 split_restore_variables
    1507 # unset all saved smage variables
    1508 split_unset_variables
    1509 else
    1510 src_install | ${SMAGE_LOG_CMD}
    1511 die_pipestatus 0 "src_install failed"
    1512 step_by_step $_
    1513 fi
    1514
    1515 # compressing doc, info & man files
    1516 if [[ -n ${SPLIT_PACKAGES} ]]
    1517 then
    1518 for subpackage in ${SPLIT_PACKAGE}
    1519 do
    1520 mcompressdocs ${BINDIR}_${subpackage}
    1521 done
    1522 else
    1523 mcompressdocs ${BINDIR}
    1524 fi
    1525
    1526
    1527 # stripping all bins and libs
    1528 case ${NOSTRIP} in
    1529 true|TRUE|yes|y)
    1530 echo -e "NOSTRIP=true detected; Package will not be stripped ..."
    1531 ;;
    1532 *)
    1533 if [[ -n ${SPLIT_PACKAGES} ]]
    1534 then
    1535 for subpackage in ${SPLIT_PACKAGE}
    1536 do
    1537 echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
    1538 mstripbins ${BINDIR}_${subpackage}
    1539 echo -e "${COLBLUE}===${COLGREEN} stripping libraries ...${COLDEFAULT}"
    1540 mstriplibs ${BINDIR}_${subpackage}
    1541 done
    1542 else
    1543 echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
    1544 mstripbins ${BINDIR}
    1545 echo -e "${COLBLUE}===${COLGREEN} stripping libraries ...${COLDEFAULT}"
    1546 mstriplibs ${BINDIR}
    1547 fi
    1548 ;;
    1549 esac
    1550
    1551 # the new buildpkg command
    1552 case ${NOPKGBUILD} in
    1553 true|TRUE|yes|y)
    1554 echo -e "NOPGKBUILD=true detected; Package will not be build ..."
    1555 ;;
    1556 *)
    1557 # build several targets
    1558 if [[ -n ${MAGE_TARGETS} ]]
    1559 then
    1560 for target in ${MAGE_TARGETS}
    1561 do
    1562 # check if an special target_pkgbuild exists
    1563 if typeset -f ${target}_pkgbuild > /dev/null
    1564 then
    1565 # run it
    1566 ${target}_pkgbuild
    1567 fi
    1568 # now create the target package
    1569 ${MLIBDIR}/pkgbuild_dir.sh \
    1570 "${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD}" \
    1571 ${BINDIR} || die "target: ${target} package-build failed"
    1572
    1573 # build pkg-md5-sum if requested
    1574 generate_package_md5sum \
    1575 --pcat "${PCATEGORIE}" \
    1576 --pname "${PNAME}" \
    1577 --pver "${PVER}" \
    1578 --pbuild "${PBUILD}" \
    1579 --parch "${ARCH}" \
    1580 --target "${target}"
    1581
    1582 echo -e "${COLGREEN}\nPackage ${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
    1583 done
    1584
    1585 # build several subpackages
    1586 elif [[ -n ${SPLIT_PACKAGES} ]]
    1587 then
    1588 split_save_variables
    1589 for subpackage in ${SPLIT_PACKAGES}
    1590 do
    1591 # get the right variables for the split
    1592 export PNAME="${subpackage}"
    1593 split_info_${PNAME}
    1594
    1595 # jump to next one if NOPKGBUILD is set in split_info
    1596 case ${NOPKGBUILD} in
    1597 true|TRUE|yes|y) continue ;;
    1598 esac
    1599
    1600 # check if an special subpackage_pkgbuild exists
    1601 if typeset -f ${PNAME}_pkgbuild > /dev/null
    1602 then
    1603 # run it
    1604 ${PNAME}_pkgbuild
    1605 fi
    1606 # now create the target package
    1607 ${MLIBDIR}/pkgbuild_dir.sh \
    1608 "${PNAME}-${PVER}-${ARCH}-${PBUILD}" \
    1609 "${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
    1610
    1611 # build pkg-md5-sum if requested
    1612 generate_package_md5sum \
    1613 --pcat "${PCATEGORIE}" \
    1614 --pname "${PNAME}" \
    1615 --pver "${PVER}" \
    1616 --pbuild "${PBUILD}" \
    1617 --parch "${ARCH}"
    1618
    1619 echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
    1620
    1621 # restore smage environment
    1622 split_restore_variables
    1623 done
    1624 # unset all saved smage variables
    1625 split_unset_variables
    1626
    1627 else
    1628 ${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"
    1629
    1630 # build pkg-md5-sum if requested
    1631 generate_package_md5sum \
    1632 --pcat "${PCATEGORIE}" \
    1633 --pname "${PNAME}" \
    1634 --pver "${PVER}" \
    1635 --pbuild "${PBUILD}" \
    1636 --parch "${ARCH}"
    1637
    1638 echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
    1639 fi
    1640
    1641 # build src-pkg-tarball if requested
    1642 [[ ${CREATE_SRC_PKG_TARBALL} = true ]] && source_pkg_build ${SMAGENAME}
    1643 ;;
    1644 esac
    1645
    1646 if [[ ${SMAGE_BUILD_LOGGING} != false ]]
    1647 then
    1648 bzip2 -9f /var/log/smage/${PKGNAME}.log
    1649 else
    1650 [[ -f /var/log/smage/${PKGNAME}.log ]] && rm /var/log/smage/${PKGNAME}.log
    1651 fi
    1652
    1653 # for sure
    1654 unset NOPKGBUILD
    1655 unset NOSTRIP
    1656
    1657 xtitleclean

    Properties

    Name Value
    svn:executable *