The Tor Browser: security/nss/automation/buildbot-slave/build.sh@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 #! /bin/bash

     3 # Ensure a failure of the first command inside a pipe

     4 # won't be hidden by commands later in the pipe.

     5 # (e.g. as in ./dosomething | grep)

     7 set -o pipefail

     9 proc_args()

    10 {

    11     while [ -n "$1" ]; do

    12         OPT=$(echo $1 | cut -d= -f1)

    13         VAL=$(echo $1 | cut -d= -f2)

    15         case $OPT in

    16             "--build-nss")

    17                 BUILD_NSS=1

    18                 ;;

    19             "--test-nss")

    20                 TEST_NSS=1

    21                 ;;

    22             "--build-jss")

    23                 BUILD_JSS=1

    24                 ;;

    25             "--test-jss")

    26                 TEST_JSS=1

    27                 ;;

    28             "--memtest")

    29                 NSS_TESTS="memleak"

    30                 export NSS_TESTS

    31                 ;;

    32             "--nojsssign")

    33                 NO_JSS_SIGN=1

    34                 ;;

    35             *)

    36                 echo "Usage: $0 ..."

    37                 echo "    --memtest   - run the memory leak tests"

    38                 echo "    --nojsssign - try to sign jss"

    39                 echo "    --build-nss"

    40                 echo "    --build-jss"

    41                 echo "    --test-nss"

    42                 echo "    --test-jss"

    43                 exit 1

    44                 ;;

    45         esac

    47         shift

    48     done

    49 }

    51 set_env()

    52 {

    53     TOPDIR=$(pwd)

    54     HGDIR=$(pwd)$(echo "/hg")

    55     OUTPUTDIR=$(pwd)$(echo "/output")

    56     LOG_ALL="${OUTPUTDIR}/all.log"

    57     LOG_TMP="${OUTPUTDIR}/tmp.log"

    59     echo "hello" |grep --line-buffered hello >/dev/null 2>&1

    60     [ $? -eq 0 ] && GREP_BUFFER="--line-buffered"

    61 }

    63 print_log()

    64 {

    65     DATE=$(date "+TB [%Y-%m-%d %H:%M:%S]")

    66     echo "${DATE} $*"

    67     echo "${DATE} $*" >> ${LOG_ALL}

    68 }

    70 print_result()

    71 {

    72     TESTNAME=$1

    73     RET=$2

    74     EXP=$3

    76     if [ ${RET} -eq ${EXP} ]; then

    77         print_log "${TESTNAME} PASSED"

    78     else

    79         print_log "${TESTNAME} FAILED"

    80     fi

    81 }

    83 print_env()

    84 {

    85     print_log "######## Environment variables ########"

    87     uname -a | tee -a ${LOG_ALL}

    88     if [ -e "/etc/redhat-release" ]; then

    89         cat "/etc/redhat-release" | tee -a ${LOG_ALL}

    90     fi

    91     # don't print the MAIL command, it might contain a password

    92     env | grep -v "^MAIL=" | tee -a ${LOG_ALL}

    93 }

    95 set_cycle()

    96 {

    97     BITS=$1

    98     OPT=$2

   100     if [ "${BITS}" = "64" ]; then

   101         USE_64=1

   102         JAVA_HOME=${JAVA_HOME_64}

   103         PORT_DBG=${PORT_64_DBG}

   104         PORT_OPT=${PORT_64_OPT}

   105     else

   106         USE_64=

   107         JAVA_HOME=${JAVA_HOME_32}

   108         PORT_DBG=${PORT_32_DBG}

   109         PORT_OPT=${PORT_32_OPT}

   110     fi

   111     export USE_64

   112     export JAVA_HOME

   114     BUILD_OPT=

   115     if [ "${OPT}" = "OPT" ]; then

   116         BUILD_OPT=1

   117         XPCLASS=xpclass.jar

   118         PORT=${PORT_OPT}

   119     else

   120         BUILD_OPT=

   121         XPCLASS=xpclass_dbg.jar

   122         PORT=${PORT_DBG}

   123     fi

   124     export BUILD_OPT

   126     PORT_JSS_SERVER=$(expr ${PORT} + 20)

   127     PORT_JSSE_SERVER=$(expr ${PORT} + 40)

   129     export PORT

   130     export PORT_JSS_SERVER

   131     export PORT_JSSE_SERVER

   132 }

   134 build_nss()

   135 {

   136     print_log "######## NSS - build - ${BITS} bits - ${OPT} ########"

   138     print_log "$ cd ${HGDIR}/nss"

   139     cd ${HGDIR}/nss

   141     print_log "$ ${MAKE} ${NSS_BUILD_TARGET}"

   142     #${MAKE} ${NSS_BUILD_TARGET} 2>&1 | tee -a ${LOG_ALL} | grep ${GREP_BUFFER} "^${MAKE}"

   143     ${MAKE} ${NSS_BUILD_TARGET} 2>&1 | tee -a ${LOG_ALL}

   144     RET=$?

   145     print_result "NSS - build - ${BITS} bits - ${OPT}" ${RET} 0

   147     if [ ${RET} -eq 0 ]; then

   148         return 0

   149     else

   150         tail -100 ${LOG_ALL}

   151         return ${RET}

   152     fi

   153 }

   155 build_jss()

   156 {

   157     print_log "######## JSS - build - ${BITS} bits - ${OPT} ########"

   159     print_log "$ cd ${HGDIR}/jss"

   160     cd ${HGDIR}/jss

   162     print_log "$ ${MAKE} ${JSS_BUILD_TARGET}"

   163     #${MAKE} ${JSS_BUILD_TARGET} 2>&1 | tee -a ${LOG_ALL} | grep ${GREP_BUFFER} "^${MAKE}"

   164     ${MAKE} ${JSS_BUILD_TARGET} 2>&1 | tee -a ${LOG_ALL}

   165     RET=$?

   166     print_result "JSS build - ${BITS} bits - ${OPT}" ${RET} 0

   167     [ ${RET} -eq 0 ] || return ${RET}

   169     print_log "$ cd ${HGDIR}/dist"

   170     cd ${HGDIR}/dist

   172     if [ -z "${NO_JSS_SIGN}" ]; then

   173 	print_log "cat ${TOPDIR}/keystore.pw | ${JAVA_HOME}/bin/jarsigner -keystore ${TOPDIR}/keystore -internalsf ${XPCLASS} jssdsa"

   174 	cat ${TOPDIR}/keystore.pw | ${JAVA_HOME}/bin/jarsigner -keystore ${TOPDIR}/keystore -internalsf ${XPCLASS} jssdsa >> ${LOG_ALL} 2>&1

   175 	RET=$?

   176 	print_result "JSS - sign JAR files - ${BITS} bits - ${OPT}" ${RET} 0

   177 	[ ${RET} -eq 0 ] || return ${RET}

   178     fi

   179     print_log "${JAVA_HOME}/bin/jarsigner -verify -certs ${XPCLASS}"

   180     ${JAVA_HOME}/bin/jarsigner -verify -certs ${XPCLASS} >> ${LOG_ALL} 2>&1

   181     RET=$?

   182     print_result "JSS - verify JAR files - ${BITS} bits - ${OPT}" ${RET} 0

   183     [ ${RET} -eq 0 ] || return ${RET}

   185     return 0

   186 }

   188 test_nss()

   189 {

   190     print_log "######## NSS - tests - ${BITS} bits - ${OPT} ########"

   192     if [ "${OS_TARGET}" = "Android" ]; then

   193 	print_log "$ cd ${HGDIR}/nss/tests/remote"

   194 	cd ${HGDIR}/nss/tests/remote

   195 	print_log "$ make test_android"

   196 	make test_android 2>&1 | tee ${LOG_TMP} | grep ${GREP_BUFFER} ": #"

   197 	OUTPUTFILE=${HGDIR}/tests_results/security/*.1/output.log

   198     else

   199 	print_log "$ cd ${HGDIR}/nss/tests"

   200 	cd ${HGDIR}/nss/tests

   201 	print_log "$ ./all.sh"

   202 	./all.sh 2>&1 | tee ${LOG_TMP} | grep ${GREP_BUFFER} ": #"

   203 	OUTPUTFILE=${LOG_TMP}

   204     fi

   206     cat ${LOG_TMP} >> ${LOG_ALL}

   207     tail -n2 ${HGDIR}/tests_results/security/*.1/results.html | grep END_OF_TEST >> ${LOG_ALL}

   208     RET=$?

   210     print_log "######## details of detected failures (if any) ########"

   211     grep -B50 FAIL ${OUTPUTFILE}

   212     [ $? -eq 1 ] || RET=1

   214     print_result "NSS - tests - ${BITS} bits - ${OPT}" ${RET} 0

   215     return ${RET}

   216 }

   218 test_jss()

   219 {

   220     print_log "######## JSS - tests - ${BITS} bits - ${OPT} ########"

   222     print_log "$ cd ${HGDIR}/jss"

   223     cd ${HGDIR}/jss

   225     print_log "$ ${MAKE} platform"

   226     PLATFORM=$(${MAKE} platform)

   227     print_log "PLATFORM=${PLATFORM}"

   229     print_log "$ cd ${HGDIR}/jss/org/mozilla/jss/tests"

   230     cd ${HGDIR}/jss/org/mozilla/jss/tests

   232     print_log "$ perl all.pl dist ${HGDIR}/dist/${PLATFORM}"

   233     perl all.pl dist ${HGDIR}/dist/${PLATFORM} 2>&1 | tee ${LOG_TMP}

   234     cat ${LOG_TMP} >> ${LOG_ALL}

   236     tail -n2 ${LOG_TMP} | grep JSSTEST_RATE > /dev/null

   237     RET=$?

   239     grep FAIL ${LOG_TMP}

   240     [ $? -eq 1 ] || RET=1

   242     print_result "JSS - tests - ${BITS} bits - ${OPT}" ${RET} 0

   243     return ${RET}

   244 }

   246 build_and_test()

   247 {

   248     if [ -n "${BUILD_NSS}" ]; then

   249         build_nss

   250         [ $? -eq 0 ] || return 1

   251     fi

   253     if [ -n "${TEST_NSS}" ]; then

   254         test_nss

   255         [ $? -eq 0 ] || return 1

   256     fi

   258     if [ -n "${BUILD_JSS}" ]; then

   259         build_jss

   260         [ $? -eq 0 ] || return 1

   261     fi

   263     if [ -n "${TEST_JSS}" ]; then

   264         test_jss

   265         [ $? -eq 0 ] || return 1

   266     fi

   268     return 0

   269 }

   271 run_cycle()

   272 {

   273     print_env

   274     build_and_test

   275     RET=$?

   277     grep ^TinderboxPrint ${LOG_ALL}

   279     return ${RET}

   280 }

   282 prepare()

   283 {

   284     rm -rf ${OUTPUTDIR}.oldest >/dev/null 2>&1

   285     mv ${OUTPUTDIR}.older ${OUTPUTDIR}.oldest >/dev/null 2>&1

   286     mv ${OUTPUTDIR}.old ${OUTPUTDIR}.older >/dev/null 2>&1

   287     mv ${OUTPUTDIR}.last ${OUTPUTDIR}.old >/dev/null 2>&1

   288     mv ${OUTPUTDIR} ${OUTPUTDIR}.last >/dev/null 2>&1

   289     mkdir -p ${OUTPUTDIR}

   291     if [ -z "${NSS_DISABLE_ECC}" -a -n "${NSS_ECC_MORE_THAN_SUITE_B}" ]; then

   292         cd ${HGDIR}/nss

   293         ECF="lib/freebl/ecl/ecl-curve.h"

   294 	print_log "hg revert -r NSS_3_11_1_RTM ${ECF}"

   295         hg revert -r NSS_3_11_1_RTM security/nss/${ECF}

   296         cp -f security/nss/${ECF} ${ECF}

   297     fi

   299     return 0

   300 }

   302 move_results()

   303 {

   304     cd ${HGDIR}

   305     if [ -n "${TEST_NSS}" ]; then

   306 	mv -f tests_results ${OUTPUTDIR}

   307     fi

   308     tar -c -z --dereference -f ${OUTPUTDIR}/dist.tgz dist

   309     rm -rf dist

   310 }

   312 run_all()

   313 {

   314     set_cycle ${BITS} ${OPT}

   315     prepare

   316     run_cycle

   317     RESULT=$?

   318     print_log "### result of run_cycle is ${RESULT}"

   319     move_results

   320     return ${RESULT}

   321 }

   323 main()

   324 {

   325     VALID=0

   326     RET=1

   328     for BITS in 32 64; do

   329         echo ${RUN_BITS} | grep ${BITS} > /dev/null

   330         [ $? -eq 0 ] || continue

   331         for OPT in DBG OPT; do

   332             echo ${RUN_OPT} | grep ${OPT} > /dev/null

   333             [ $? -eq 0 ] || continue

   335             VALID=1

   336             set_env

   337             run_all

   338             RET=$?

   339 	    print_log "### result of run_all is ${RET}"

   340         done

   341     done

   343     if [ ${VALID} -ne 1 ]; then

   344         echo "Need to set valid bits/opt values."

   345         return 1

   346     fi

   348     return ${RET}

   349 }

   351 #function killallsub()

   352 #{

   353 #    FINAL_RET=$?

   354 #    for proc in `jobs -p`

   355 #    do

   356 #        kill -9 $proc

   357 #    done

   358 #    return ${FINAL_RET}

   359 #}

   360 #trap killallsub EXIT

   362 #IS_RUNNING_FILE="./build-is-running"

   364 #if [ -a $IS_RUNNING_FILE ]; then

   365 #    echo "exiting, because old job is still running"

   366 #    exit 1

   367 #fi

   369 #touch $IS_RUNNING_FILE

   371 echo "tinderbox args: $0 $@"

   372 . ${ENVVARS}

   373 proc_args "$@"

   374 main

   376 #RET=$?

   377 #rm $IS_RUNNING_FILE

   378 #exit ${RET}

The Tor Browser / file revision

security/nss/automation/buildbot-slave/build.sh@b8a032363ba2

security/nss/automation/buildbot-slave/build.sh