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

    Properties

    Name Value
    svn:executable *