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 1291 - (show annotations) (download) (as text)
    Fri May 27 12:54:34 2011 UTC (12 years, 11 months ago) by niro
    File MIME type: application/x-sh
    File size: 39691 byte(s) 
    -added mautoreconf() function
    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 source ${MLIBDIR}/mage4.functions.sh
    54
    55 # set PKGDIR and BUILDDIR and BINDIR to MROOT
    56 if [[ -n ${MROOT} ]]
    57 then
    58 export PKGDIR=${MROOT}/${PKGDIR}
    59 export BUILDDIR=${MROOT}/${BUILDDIR}
    60 export BINDIR=${MROOT}/${BINDIR}
    61 fi
    62
    63 showversion()
    64 {
    65 echo -en "Magellan Source Install v${SMAGEVERSION} "
    66 echo -e "-- Niels Rogalla (niro@magellan-linux.de)"
    67 }
    68
    69 die()
    70 {
    71 xtitleclean
    72 echo -e ${COLRED}"Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."${COLDEFAULT}
    73 echo "SMAGE failed: $@"
    74 exit 1
    75 }
    76
    77 die_pipestatus()
    78 {
    79 # the status change if we do any parameter declarations!!
    80 # dont do this anymore, keep this in mind!
    81 #
    82 # local pos="$1"
    83 # local comment="$2"
    84 #
    85 # [ ${PIPESTATUS[${pos}]} -ne 0 ] && die "${comment}"
    86 #
    87 [ ${PIPESTATUS[$1]} -ne 0 ] && die "$2"
    88 }
    89
    90 xtitle()
    91 {
    92 if [[ ${TERM} = xterm ]]
    93 then
    94 echo -ne "\033]0;[sMage: $@]\007"
    95 fi
    96 return 0
    97 }
    98
    99 xtitleclean()
    100 {
    101 if [[ ${TERM} = xterm ]]
    102 then
    103 echo -ne "\033]0;\007"
    104 fi
    105 return 0
    106 }
    107
    108 syncsmage2()
    109 {
    110 xtitle "Updating smage2-script tree ..."
    111 local i
    112 for i in ${SMAGE2RSYNC}
    113 do
    114 rsync ${RSYNC_FETCH_OPTIONS} ${i} ${SMAGESCRIPTSDIR}
    115 if [[ $? = 0 ]]
    116 then
    117 break
    118 else
    119 continue
    120 fi
    121 done
    122
    123 # clean up backup files (foo~)
    124 find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'
    125
    126 xtitleclean
    127 }
    128
    129 # $1 filename
    130 get_db_md5_sum()
    131 {
    132 local DB_FILE
    133 local MD5_FILE
    134 local i
    135
    136 DB_ENTRY="$(basename $1)"
    137 MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} ${SMAGESUFFIX})"
    138
    139 i="$(cat ${MD5_FILE}| grep ${DB_ENTRY} | cut -d' ' -f1)"
    140
    141 echo "${i}"
    142 }
    143
    144 download_sources()
    145 {
    146
    147 [ -z "${SRC_URI}" ] && echo -e "\nNothing declared to download.\n" && return 0
    148
    149 local EOA=${#SRC_URI[*]}
    150 local my_SRC_URI
    151 local my_SRC_URI_DEST
    152 local my_SRC_URI_MIRROR
    153 local my_SOURCEDIR
    154 local DB_MD5_SUM_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
    155 local FETCHING
    156 local i mirror
    157 local wget_opts
    158
    159 # filter wget command if busybox was found
    160 wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
    161
    162 # install SRCDIR/PNAME if not exist
    163 [ ! -d ${SOURCEDIR}/${PNAME} ] && install -d ${SOURCEDIR}/${PNAME}
    164
    165 # check if FETCHING is needed
    166 ( cd ${SOURCEDIR}/${PNAME}; md5sum -c ${DB_MD5_SUM_FILE} &> /dev/null )
    167 if [[ $? = 0 ]]
    168 then
    169 # md5's ok, no fetching needed
    170 FETCHING=false
    171 else
    172 FETCHING=true
    173 fi
    174
    175 for ((i=0; i < EOA; i++))
    176 do
    177 # url to file
    178 my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
    179
    180 # subdir in sources dir; the my_SRCI_URI file goes to there
    181 my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
    182
    183 # if my_src_uri_dest is not equal my_src_uri; than an other dir is used
    184 if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
    185 then
    186 my_SOURCEDIR="${SOURCEDIR}/${PNAME}/${my_SRC_URI_DEST}"
    187 else
    188 my_SOURCEDIR="${SOURCEDIR}/${PNAME}"
    189 fi
    190
    191 # create the SOURCEDIR
    192 install -d ${my_SOURCEDIR}
    193
    194 # if an mirrored file than replace first the mirror uri
    195 if [[ -n $(echo ${my_SRC_URI} | grep 'mirror://') ]]
    196 then
    197 for mirror in ${MIRRORS}
    198 do
    199 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|mirror:/|${mirror}/sources|g")"
    200
    201 if [[ ${FETCHING} = true ]]
    202 then
    203 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    204 wget \
    205 ${wget_opts} \
    206 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    207 "${my_SRC_URI_MIRROR}"
    208 if [[ $? = 0 ]]
    209 then
    210 break
    211 else
    212 continue
    213 fi
    214 fi
    215 done
    216 elif [[ -n $(echo ${my_SRC_URI} | grep 'sourceforge://') ]]
    217 then
    218 for mirror in ${SOURCEFORGE_MIRRORS}
    219 do
    220 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|sourceforge:/|${mirror}|g")"
    221
    222 if [[ ${FETCHING} = true ]]
    223 then
    224 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    225 wget \
    226 ${wget_opts} \
    227 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    228 "${my_SRC_URI_MIRROR}"
    229 if [[ $? = 0 ]]
    230 then
    231 break
    232 else
    233 continue
    234 fi
    235 fi
    236 done
    237 elif [[ -n $(echo ${my_SRC_URI} | grep 'gnu://') ]]
    238 then
    239 for mirror in ${GNU_MIRRORS}
    240 do
    241 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|gnu:/|${mirror}|g")"
    242
    243 if [[ ${FETCHING} = true ]]
    244 then
    245 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    246 wget \
    247 ${wget_opts} \
    248 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    249 "${my_SRC_URI_MIRROR}"
    250 if [[ $? = 0 ]]
    251 then
    252 break
    253 else
    254 continue
    255 fi
    256 fi
    257 done
    258 elif [[ -n $(echo ${my_SRC_URI} | grep 'kde://') ]]
    259 then
    260 for mirror in ${KDE_MIRRORS}
    261 do
    262 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|kde:/|${mirror}|g")"
    263
    264 if [[ ${FETCHING} = true ]]
    265 then
    266 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    267 wget \
    268 ${wget_opts} \
    269 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    270 "${my_SRC_URI_MIRROR}"
    271 if [[ $? = 0 ]]
    272 then
    273 break
    274 else
    275 continue
    276 fi
    277 fi
    278 done
    279 elif [[ -n $(echo ${my_SRC_URI} | grep 'gnome://') ]]
    280 then
    281 for mirror in ${GNOME_MIRRORS}
    282 do
    283 my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|gnome:/|${mirror}|g")"
    284
    285 if [[ ${FETCHING} = true ]]
    286 then
    287 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI_MIRROR}${COLDEFAULT}"
    288 wget \
    289 ${wget_opts} \
    290 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI_MIRROR})" \
    291 "${my_SRC_URI_MIRROR}"
    292 if [[ $? = 0 ]]
    293 then
    294 break
    295 else
    296 continue
    297 fi
    298 fi
    299 done
    300 else
    301 if [[ ${FETCHING} = true ]]
    302 then
    303 echo -e "${COLBLUE}==>${COLGREEN} fetching ${my_SRC_URI}${COLDEFAULT}"
    304 wget \
    305 ${wget_opts} \
    306 --output-document="${my_SOURCEDIR}/$(basename ${my_SRC_URI})" \
    307 "${my_SRC_URI}"
    308 fi
    309 fi
    310
    311 # unset them to be shure
    312 unset my_SRC_URI
    313 unset my_SRC_URI_DEST
    314 unset my_SRC_URI_MIRROR
    315 unset my_SOURCEDIR
    316 done
    317
    318 # recheck md5 sums
    319 echo
    320 echo -e "${COLBLUE}===${COLGREEN} Checking MD5 sums:${COLDEFAULT}"
    321 ( cd ${SOURCEDIR}/${PNAME}; md5sum -c ${DB_MD5_SUM_FILE} ) || die "md5 failed"
    322 echo
    323
    324 # not needed anymore
    325 unset SRC_URI
    326 }
    327
    328 # dummy function, used if that not exist in smage file
    329 src_prepare()
    330 {
    331 echo "no src_prepare defined"
    332 sleep 2
    333 return 0
    334 }
    335
    336 # dummy function, used if that not exist in smage file
    337 src_compile()
    338 {
    339 echo "no src_compile defined"
    340 sleep 2
    341 return 0
    342 }
    343
    344 # dummy function, used if that not exist in smage file
    345 src_install()
    346 {
    347 echo "no src_install defined"
    348 sleep 2
    349 return 0
    350 }
    351
    352 mlibdir()
    353 {
    354 local libdir=lib
    355 [[ ${ARCH} = x86_64 ]] && libdir=lib64
    356
    357 echo "${libdir}"
    358 }
    359
    360 mconfigure()
    361 {
    362 if [ -x ./configure ]
    363 then
    364 ./configure \
    365 --prefix=/usr \
    366 --host=${CHOST} \
    367 --build=${CHOST} \
    368 --mandir=/usr/share/man \
    369 --infodir=/usr/share/info \
    370 --datadir=/usr/share \
    371 --sysconfdir=/etc \
    372 --localstatedir=/var/lib \
    373 --libdir=/usr/$(mlibdir) \
    374 "$@" || die "mconfigure failed"
    375 else
    376 echo "configure is not an executable ..."
    377 exit 1
    378 fi
    379 }
    380
    381 minstall()
    382 {
    383 if [ -f ./[mM]akefile -o -f ./GNUmakefile ]
    384 then
    385 make prefix=${BINDIR}/usr \
    386 datadir=${BINDIR}/usr/share \
    387 infodir=${BINDIR}/usr/share/info \
    388 localstatedir=${BINDIR}/var/lib \
    389 mandir=${BINDIR}/usr/share/man \
    390 sysconfdir=${BINDIR}/etc \
    391 libdir=${BINDIR}/usr/$(mlibdir) \
    392 "$@" install || die "minstall failed"
    393 else
    394 die "no Makefile found"
    395 fi
    396 }
    397
    398 mmake()
    399 {
    400 make ${MAKEOPTS} ${EXTRA_EMAKE} "$@"
    401 }
    402
    403 munpack()
    404 {
    405 local SRCFILE
    406 local IFTAR
    407 local DEST
    408
    409 SRCFILE=$1
    410
    411 if [[ -z $2 ]]
    412 then
    413 DEST=${BUILDDIR}
    414 else
    415 DEST=$2
    416 fi
    417
    418 [[ ! -d ${DEST} ]] && install -d ${DEST}
    419
    420 case "${SRCFILE##*.}" in
    421 bz2)
    422 IFTAR="$(basename $SRCFILE .bz2)"
    423 IFTAR="${IFTAR##*.}"
    424 if [[ ${IFTAR} = tar ]]
    425 then
    426 tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.bz2 unpack failed."
    427 else
    428 pushd ${DEST} > /dev/null
    429 bzcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .bz2) || die ".bz2 unpack failed."
    430 popd > /dev/null
    431 fi
    432 ;;
    433 gz)
    434 IFTAR="$(basename $SRCFILE .gz)"
    435 IFTAR="${IFTAR##*.}"
    436 if [[ ${IFTAR} = tar ]]
    437 then
    438 tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.gz unpack failed."
    439 else
    440 pushd ${DEST} > /dev/null
    441 zcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .gz) || die ".gz unpack failed."
    442 popd > /dev/null
    443 fi
    444 ;;
    445 tbz2|mpks|mpk)
    446 tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tbz2 unpack failed."
    447 ;;
    448 tgz)
    449 tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tgz unpack failed."
    450 ;;
    451 rar)
    452 unrar x ${SOURCEDIR}/${PNAME}/${SRCFILE} ${DEST} || die ".rar unpack failed."
    453 ;;
    454 zip|xpi)
    455 unzip ${SOURCEDIR}/${PNAME}/${SRCFILE} -d ${DEST} || die ".zip unpack failed."
    456 ;;
    457 rpm)
    458 pushd ${DEST} > /dev/null
    459 rpm2targz ${SOURCEDIR}/${PNAME}/${SRCFILE} || die "rpm2targz: .rpm unpack failed."
    460 tar --no-same-owner -xvzf ${SRCFILE/.rpm/.tar.gz} || die "tar: .rpm unpack failed."
    461 if [[ -f ${DEST}/${SRCFILE/.rpm/.tar.gz} ]]
    462 then
    463 rm ${DEST}/${SRCFILE/.rpm/.tar.gz}
    464 fi
    465 ;;
    466 *)
    467 die "munpack failed"
    468 ;;
    469 esac
    470 }
    471
    472 mpatch()
    473 {
    474 local PATCHOPTS
    475 local PATCHFILE
    476 local i
    477
    478 PATCHOPTS=$1
    479 PATCHFILE=$2
    480
    481 if [[ -z $2 ]]
    482 then
    483 PATCHFILE=$1
    484
    485 ## patch level auto-detection, get patch level
    486 for ((i=0; i < 10; i++))
    487 do
    488 patch --dry-run -Np${i} -i ${SOURCEDIR}/${PNAME}/${PATCHFILE} > /dev/null
    489 if [[ $? = 0 ]]
    490 then
    491 PATCHOPTS="-Np${i}"
    492 break
    493 fi
    494 done
    495 fi
    496
    497 echo -e "${COLBLUE}*** ${COLGREEN}Applying patch '${PATCHFILE}'${COLDEFAULT}"
    498 patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}
    499 }
    500
    501 mlibtoolize()
    502 {
    503 local opts="$@"
    504 [[ -z ${opts} ]] && opts="--copy --force"
    505
    506 libtoolize ${opts} || die "running: mlibtoolize ${opts}"
    507 }
    508
    509 mautoreconf()
    510 {
    511 local opts="$@"
    512 [[ -z ${opts} ]] && opts="--verbose --install --force"
    513
    514 autoreconf ${opts} || die "running: mautoreconf ${opts}"
    515 }
    516
    517 minstalldocs()
    518 {
    519 local docfiles
    520 docfiles="$@"
    521
    522 if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]
    523 then
    524 install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."
    525 fi
    526
    527 local i
    528 for i in ${docfiles}
    529 do
    530 if [ -f ${i} ]
    531 then
    532 cat ${i} | gzip -9c > ${i}.gz || die "gzipping docs."
    533 install -m 0644 ${SRCDIR}/${i}.gz \
    534 ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "coping docs."
    535 fi
    536 done
    537 }
    538
    539 mstriplibs()
    540 {
    541 local stripdir="$@"
    542
    543 [ -z "${stripdir}" ] && stripdir=${BINDIR}
    544 find ${stripdir} | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
    545 }
    546
    547 mstripbins()
    548 {
    549 local stripdir="$@"
    550
    551 [ -z "${stripdir}" ] && stripdir=${BINDIR}
    552 find ${stripdir} | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
    553 }
    554
    555 mcompressdocs()
    556 {
    557 local bindir="$@"
    558
    559 if [ -d ${bindir}/usr/share/man ]
    560 then
    561 echo -e "${COLBLUE}===${COLGREEN} compressing man-pages ...${COLDEFAULT}"
    562 ${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/man
    563 fi
    564
    565 if [ -d ${bindir}/usr/share/info ]
    566 then
    567 echo -e "${COLBLUE}===${COLGREEN} compressing info-pages ...${COLDEFAULT}"
    568 ${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/info
    569 fi
    570 }
    571
    572 sminclude()
    573 {
    574 local i
    575
    576 if [[ -n "$@" ]]
    577 then
    578 for i in $@
    579 do
    580 echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
    581 source ${SMAGESCRIPTSDIR}/include/${i}.sminc
    582 done
    583 echo
    584 fi
    585 }
    586
    587 setup_distcc_environment()
    588 {
    589 if [ -x /usr/bin/distcc ]
    590 then
    591 echo -e "${COLBLUE}---${COLGREEN} Using DistCC for compilation ...${COLDEFAULT}"
    592 export PATH=/usr/$(mlibdir)/distcc/bin:${PATH} || die "distcc: could not export new $PATH"
    593
    594 export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"
    595
    596 # creating distcc tempdir
    597 install -o distcc -g daemon -d ${DISTCC_DIR}
    598 chmod 1777 ${DISTCC_DIR}
    599 fi
    600 }
    601
    602 setup_ccache_environment()
    603 {
    604 if [ -x /usr/bin/ccache ]
    605 then
    606 echo -e "${COLBLUE}---${COLGREEN} Using CCache for compilation ...${COLDEFAULT}"
    607 export PATH=/usr/$(mlibdir)/ccache/bin:${PATH} || die "ccache: could not export new $PATH"
    608 fi
    609 }
    610
    611
    612 # fixes given dependencies to match a MAGE_TARGET
    613 # fix_mage_deps -target s/depend # <-- note -target !
    614 fix_mage_deps()
    615 {
    616 local target="$1"
    617 local depend="$2"
    618 local NDEPEND
    619 local sym dep cat pver pname
    620
    621 # deps and provides are special
    622 # they must be fixed to match the target
    623
    624 # run this only if target and depend is not empty
    625 if [ -n "${target}" ] && [ -n "${depend}" ]
    626 then
    627 # fix DEPEND
    628 while read sym dep
    629 do
    630 # ignore empty lines
    631 [[ -z ${dep} ]] && continue
    632
    633 cat="$(dirname ${dep})"
    634 # change if not virtual
    635 if [[ ${cat} = virtual ]]
    636 then
    637 pname="$(basename ${dep})"
    638 else
    639 # fix pver to target-pver
    640 # to get pname-target-pver
    641
    642 # doing it backwards !
    643 pver="${dep##*-}"
    644 # full pver
    645 pname="$(basename ${dep/-${pver}/})${target}-${pver}"
    646 fi
    647
    648 # do not add empty lines
    649 if [ -z "${NDEPEND}" ]
    650 then
    651 NDEPEND="${sym} ${cat}/${pname}"
    652 else
    653 NDEPEND="${NDEPEND}
    654 ${sym} ${cat}/${pname}"
    655 fi
    656
    657 unset cat pname pver
    658 done << EOF
    659 ${depend}
    660 EOF
    661 # set NDEPEND to DEPEND
    662 depend="${NDEPEND}"
    663 fi
    664
    665 echo "${depend}"
    666 }
    667
    668 # build_mage_script(): helper functions for regen_mage_tree()
    669 # generates an mage file with given information in smage file
    670 # needs at least:
    671 # PNAME name of pkg
    672 # PVER version
    673 # PBUILD revision
    674 # PCATEGORIE categorie of the pkg
    675 # STATE state of pkg stable|unstable|old
    676 # DESCRIPTION va short description (opt)
    677 # HOMEPAGE homepage (opt)
    678 # DEPEND runtime dependencies (opt)
    679 # SDEPEND add. needed deps to build the pkg (opt)
    680 # PROVIDE provides a virtual (opt)
    681 #
    682 # special tags:
    683 # PKGTYPE type of pkg
    684 # INHERITS which functions get included
    685 # SPECIAL_FUNCTIONS special functions which should also be added
    686 # warning: they get killed before the build starts !
    687 # SPLIT_PACKAGES names of all subpackages which are splitted from parent
    688 # SPLIT_PACKAGE_BASE base package name for splitpackages
    689 # (only in the resulting magefile}
    690 #
    691 # MAGE_TREE_DEST target destination of the generated tree
    692 # REGEN_MAGE_TREE set to 'true' to enable this
    693 #
    694 # gets called with build_mage_script target
    695 build_mage_script()
    696 {
    697 local magefile
    698 local dest
    699 local target
    700 local split_pkg_base
    701 local sym
    702 local depname
    703
    704 # if MAGE_TREE_DEST not set use BUILDDIR
    705 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    706
    707 # determinate which suffix this mage file should get, if any
    708 [[ $1 = --target ]] && shift && target="-$1"
    709
    710 # mark package as splitpackage
    711 [[ $1 = --split-pkg-base ]] && shift && split_pkg_base="$1"
    712
    713 # name of magefile
    714 magefile="${PNAME}${target}-${PVER}-${PBUILD}.mage"
    715
    716 # destination to magefile
    717 dest="${MAGE_TREE_DEST}/${PCATEGORIE}/${PNAME}${target}/${magefile}"
    718
    719 # show what we are doing
    720 echo -e "${COLBLUE}===${COLGREEN} generating mage file:${COLDEFAULT}"
    721 echo "${dest}"
    722
    723 install -d "$(dirname ${dest})"
    724 # now build the mage file
    725 > ${dest}
    726
    727 # header
    728 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}
    729 echo >> ${dest}
    730
    731 # pgkname and state
    732 echo "PKGNAME=\"${PNAME}${target}-${PVER}-\${ARCH}-${PBUILD}\"" >> ${dest}
    733 echo "STATE=\"${STATE}\"" >> ${dest}
    734 echo >> ${dest}
    735
    736 # description and homepage
    737 echo "DESCRIPTION=\"${DESCRIPTION}\"" >> ${dest}
    738 echo "HOMEPAGE=\"${HOMEPAGE}\"" >> ${dest}
    739 echo >> ${dest}
    740
    741 # special tags and vars
    742 echo "PKGTYPE=\"${PKGTYPE}\"" >> ${dest}
    743
    744 # echo MAGE_TARGETS ## note -target is needed !
    745 echo "MAGE_TARGETS=\"${target}\"" >> ${dest}
    746 echo >> ${dest}
    747
    748 # split package base
    749 echo "SPLIT_PACKAGE_BASE=\"${split_pkg_base}\"" >> ${dest}
    750 echo >> ${dest}
    751
    752 # add special vars
    753 if [ -n "${SPECIAL_VARS}" ]
    754 then
    755 local i
    756 for i in ${SPECIAL_VARS}
    757 do
    758 # being tricky here :)
    759 echo "${i}=\"$(eval echo \$${i})\"" >> ${dest}
    760 done
    761 echo >> ${dest}
    762 fi
    763
    764 # add at least all includes
    765 if [ -n "${INHERITS}" ]
    766 then
    767 echo -n "minclude" >> ${dest}
    768 local i
    769 for i in ${INHERITS}
    770 do
    771 echo -n " ${i}" >> ${dest}
    772 done
    773 echo >> ${dest}
    774 fi
    775 echo >> ${dest}
    776
    777 # deps and provides
    778 echo "DEPEND=\"$(fix_mage_deps "${target}" "${DEPEND}")\"" >> ${dest}
    779 echo >> ${dest}
    780 echo "SDEPEND=\"$(fix_mage_deps "${target}" "${SDEPEND}")\"" >> ${dest}
    781 echo >> ${dest}
    782 echo "PROVIDE=\"${PROVIDE}\"" >> ${dest}
    783 echo >> ${dest}
    784
    785 # add special functions
    786 if [ -n "${SPECIAL_FUNCTIONS}" ]
    787 then
    788 local i
    789 for i in ${SPECIAL_FUNCTIONS}
    790 do
    791 # add to mage (quotes needed !)
    792 typeset -f "${i}" >> ${dest}
    793 echo >> ${dest}
    794 # unset to be safe (quotes needed !)
    795 #unset "${i}" <-- later to get every target built
    796 done
    797 echo >> ${dest}
    798 fi
    799
    800 # pre|post-install|removes
    801 typeset -f preinstall >> ${dest}
    802 echo >> ${dest}
    803 typeset -f postinstall >> ${dest}
    804 echo >> ${dest}
    805 typeset -f preremove >> ${dest}
    806 echo >> ${dest}
    807 typeset -f postremove >> ${dest}
    808 echo >> ${dest}
    809 }
    810
    811 regen_mage_tree()
    812 {
    813 local i
    814
    815 # build them only if requested
    816 if [[ ${REGEN_MAGE_TREE} = true ]]
    817 then
    818 # run it without targets
    819 if [[ -n ${MAGE_TARGETS} ]]
    820 then
    821 # build for each target a mage file
    822 # run it with several targets
    823 echo
    824 for i in ${MAGE_TARGETS}
    825 do
    826 build_mage_script --target "${i}"
    827 done
    828 echo
    829
    830 # run it for splitpackages
    831 elif [[ -n ${SPLIT_PACKAGES} ]]
    832 then
    833 local split_pkg_base="${PNAME}"
    834 # save smage environment
    835 split_save_variables
    836 # build for each subpackage a mage file
    837 # run it with several targets
    838 echo
    839 for i in ${SPLIT_PACKAGES}
    840 do
    841 # get the right variables for the split
    842 export PNAME="${i}"
    843 split_info_${i}
    844 build_mage_script --split-pkg-base "${split_pkg_base}"
    845 # restore smage environment
    846 split_restore_variables
    847 done
    848 echo
    849 # unset all saved smage variables
    850 split_unset_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 export SAVED_NOPKGBUILD="${NOPKGBUILD}"
    902
    903 # bindir too
    904 export SAVED_BINDIR="${BINDIR}"
    905
    906 # export the SPLIT_PACKAGE_BASE
    907 export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
    908
    909 # functions
    910 if [[ ! -z $(typeset -f preinstall) ]]
    911 then
    912 # rename the old one
    913 local saved_preinstall
    914 saved_preinstall=SAVED_$(typeset -f preinstall)
    915 eval "${saved_preinstall}"
    916 export -f SAVED_preinstall
    917 fi
    918
    919 if [[ ! -z $(typeset -f postinstall) ]]
    920 then
    921 # rename the old one
    922 local saved_postinstall
    923 saved_postinstall=SAVED_$(typeset -f postinstall)
    924 eval "${saved_postinstall}"
    925 export -f SAVED_postinstall
    926 fi
    927
    928 if [[ ! -z $(typeset -f preremove) ]]
    929 then
    930 # rename the old one
    931 local saved_preremove
    932 saved_preremove=SAVED_$(typeset -f preremove)
    933 eval "${saved_preremove}"
    934 export -f SAVED_preremove
    935 fi
    936
    937 if [[ ! -z $(typeset -f postremove) ]]
    938 then
    939 # rename the old one
    940 local saved_postremove
    941 saved_postremove=SAVED_$(typeset -f postremove)
    942 eval "${saved_postremove}"
    943 export -f SAVED_postremove
    944 fi
    945 }
    946
    947 split_restore_variables()
    948 {
    949 export PNAME="${SAVED_PNAME}"
    950 export PVER="${SAVED_PVER}"
    951 export PBUILD="${SAVED_PBUILD}"
    952 export PCATEGORIE="${SAVED_PCATEGORIE}"
    953 export DESCRIPTION="${SAVED_DESCRIPTION}"
    954 export HOMEPAGE="${SAVED_HOMEPAGE}"
    955 export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
    956 export STATE="${SAVED_STATE}"
    957 export PKGTYPE="${SAVED_PKGTYPE}"
    958 export INHERITS="${SAVED_INHERITS}"
    959 export DEPEND="${SAVED_DEPEND}"
    960 export SDEPEND="${SAVED_SDEPEND}"
    961 export PROVIDE="${SAVED_PROVIDE}"
    962 export NOPKGBUILD="${SAVED_NOPKGBUILD}"
    963
    964 # bindir too
    965 export BINDIR="${SAVED_BINDIR}"
    966
    967 # functions
    968 if [[ ! -z $(typeset -f SAVED_preinstall) ]]
    969 then
    970 # rename the old one
    971 local saved_preinstall
    972 saved_preinstall=$(typeset -f SAVED_preinstall)
    973 eval "${saved_preinstall/SAVED_/}"
    974 export -f preinstall
    975 fi
    976
    977 if [[ ! -z $(typeset -f SAVED_postinstall) ]]
    978 then
    979 # rename the old one
    980 local saved_postinstall
    981 saved_postinstall=$(typeset -f SAVED_postinstall)
    982 eval "${saved_postinstall/SAVED_/}"
    983 export -f postinstall
    984 fi
    985
    986 if [[ ! -z $(typeset -f SAVED_preremove) ]]
    987 then
    988 # rename the old one
    989 local saved_preremove
    990 saved_preremove=$(typeset -f SAVED_preremove)
    991 eval "${saved_preremove/SAVED_/}"
    992 export -f preremove
    993 fi
    994
    995 if [[ ! -z $(typeset -f SAVED_postremove) ]]
    996 then
    997 # rename the old one
    998 local saved_postremove
    999 saved_postremove=$(typeset -f SAVED_postremove)
    1000 eval "${saved_postremove/SAVED_/}"
    1001 export -f postremove
    1002 fi
    1003 }
    1004
    1005 split_unset_variables()
    1006 {
    1007 # unset saved vars; not needed anymore
    1008 unset SAVED_PNAME
    1009 unset SAVED_PVER
    1010 unset SAVED_PBUILD
    1011 unset SAVED_PCATEGORIE
    1012 unset SAVED_DESCRIPTION
    1013 unset SAVED_HOMEPAGE
    1014 unset SAVED_SPECIAL_VARS
    1015 unset SAVED_STATE
    1016 unset SAVED_PKGTYPE
    1017 unset SAVED_INHERITS
    1018 unset SAVED_DEPEND
    1019 unset SAVED_SDEPEND
    1020 unset SAVED_PROVIDE
    1021 unset SAVED_BINDIR
    1022 unset SAVED_NOPKGBUILD
    1023 unset SPLIT_PACKAGE_BASE
    1024 unset -f SAVED_preinstall
    1025 unset -f SAVED_postinstall
    1026 unset -f SAVED_preremove
    1027 unset -f SAVED_postremove
    1028 }
    1029
    1030 export_inherits()
    1031 {
    1032 local include="$1"
    1033 shift
    1034
    1035 while [ "$1" ]
    1036 do
    1037 local functions="$1"
    1038
    1039 # sanity checks
    1040 [ -z "${include}" ] && die "export_inherits(): \$include not given."
    1041 [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    1042
    1043 eval "${functions}() { ${include}_${functions} ; }"
    1044
    1045 # debug
    1046 [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    1047
    1048 shift
    1049 done
    1050 }
    1051
    1052 generate_package_md5sum()
    1053 {
    1054 local dest
    1055 local pcat
    1056 local pname
    1057 local pver
    1058 local pbuild
    1059 local parch
    1060 local target
    1061 local pkgname
    1062
    1063 # very basic getops
    1064 for i in $*
    1065 do
    1066 case $1 in
    1067 --pcat|-c) shift; pcat="$1" ;;
    1068 --pname|-n) shift; pname="$1" ;;
    1069 --pver|-v) shift; pver="$1" ;;
    1070 --pbuild|-b) shift; pbuild="$1" ;;
    1071 --parch|a) shift; parch="$1" ;;
    1072 --target|t) shift; target="$1" ;;
    1073 esac
    1074 shift
    1075 done
    1076
    1077 # sanity checks; abort if not given
    1078 [ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
    1079 [ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
    1080 [ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
    1081 [ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
    1082 [ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
    1083
    1084 # check needed global vars
    1085 [ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
    1086 [ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
    1087
    1088 # fix target as it may be empty !
    1089 [ -n "${target}" ] && target="-${target}"
    1090
    1091
    1092 # build pkgname
    1093 pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
    1094
    1095 # build pkg-md5-sum only if requested
    1096 if [[ ${REGEN_MAGE_TREE} = true ]]
    1097 then
    1098 echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
    1099
    1100 # abort if not exist
    1101 if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
    1102 then
    1103 echo -e "${COLRED}! exists${COLDEFAULT}"
    1104 return 0
    1105 fi
    1106
    1107 # if MAGE_TREE_DEST not set use BUILDDIR
    1108 : ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
    1109
    1110 # setup md5 dir
    1111 dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
    1112 install -d ${dest}
    1113
    1114 # gen md5sum
    1115 ( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
    1116 > ${dest}/${pkgname}.md5
    1117 echo -e "${COLGREEN}done${COLDEFAULT}"
    1118 fi
    1119 }
    1120
    1121 source_pkg_build()
    1122 {
    1123 if [[ ${PKGTYPE} = virtual ]]
    1124 then
    1125 echo "Virtual package detected; src-pkg-tarball not necessary ..."
    1126 return 0
    1127 fi
    1128
    1129 if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
    1130 then
    1131 echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
    1132 return 0
    1133 fi
    1134
    1135 [ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
    1136
    1137 echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
    1138
    1139 # include the smage2 file
    1140 cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
    1141
    1142 ( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
    1143 [[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
    1144 mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
    1145
    1146 echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
    1147 }
    1148
    1149 step_by_step()
    1150 {
    1151 if [[ ${STEP_BY_STEP} = true ]]
    1152 then
    1153 echo -e "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
    1154 echo "Press [enter] to continue"
    1155 read
    1156 fi
    1157 }
    1158
    1159
    1160 # print out our version
    1161 showversion
    1162 echo
    1163
    1164 if [ -z "$1" ]
    1165 then
    1166 echo "No .smage2 file given. Exiting."
    1167 echo
    1168 exit 1
    1169 fi
    1170
    1171 # updating smage2-scripts
    1172 if [[ $1 = update ]]
    1173 then
    1174 if [ ! -d ${SOURCEDIR} ]
    1175 then
    1176 install -d ${SOURCEDIR}
    1177 fi
    1178 syncsmage2
    1179 exit 0
    1180 fi
    1181
    1182 # creates md5sums for smages to given dir
    1183 if [[ $1 = calcmd5 ]]
    1184 then
    1185 if [ $# -ge 2 ]
    1186 then
    1187 SMAGENAME="$2"
    1188 MD5DIR="$3"
    1189 [[ -z ${MD5DIR} ]] && MD5DIR="$(dirname ${SMAGENAME})/md5"
    1190
    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_PACKAGES}
    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_PACKAGES}
    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_PACKAGES}
    1536 do
    1537 echo -e "${COLBLUE}===${COLGREEN} stripping binaries for '${subpackage}' ...${COLDEFAULT}"
    1538 mstripbins ${BINDIR}_${subpackage}
    1539 echo -e "${COLBLUE}===${COLGREEN} stripping libraries for '${subpackage}' ...${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 *