| ############################################################################## |
| # BASE ENV |
| ############################################################################## |
| TOOLS=$(cd $(dirname -- $0) && pwd) |
| PATH=$TOOLS:/usr/local/symlinks:$PATH |
| export PATH TOOLS |
| |
| umask 0022 |
| |
| if ${HTMLREPORTING:-false} |
| then |
| V_BOLD="<B>" |
| V_REVERSE="$V_BOLD" |
| V_UNDERLINE="<U>" |
| V_VIDOFF_BOLD="</B>" |
| V_VIDOFF_REVERSE="$V_VIDOFF_REVERSE" |
| V_VIDOFF_UNDERLINE="</U>" |
| elif [ -t 1 ] |
| then |
| ## Set some video text attributes for use in error/warning msgs |
| V_REVERSE='[7m' |
| V_UNDERLINE='[4m' |
| V_BOLD='[1m' |
| [ -f /usr/bin/tput ] && V_BLINK=$(tput blink) |
| V_VIDOFF='[m' |
| V_VIDOFF_REVERSE="$V_VIDOFF" |
| V_VIDOFF_BOLD="$V_VIDOFF" |
| V_VIDOFF_UNDERLINE="$V_VIDOFF" |
| fi |
| export V_REVERSE V_UNDERLINE V_BOLD V_BLINK V_VIDOFF |
| |
| # Set some usable highlighted keywords for functions like OkFailed(). |
| OK="${V_BOLD}OK$V_VIDOFF_BOLD" |
| FAILED="${V_REVERSE}FAILED$V_VIDOFF_REVERSE" |
| WARNING="${V_REVERSE}WARNING$V_VIDOFF_REVERSE" |
| YES="${V_BOLD}YES$V_VIDOFF_BOLD" |
| NO="${V_REVERSE}NO$V_VIDOFF_REVERSE" |
| |
| # Set REALUSER |
| #REALUSER=`id -nu` |
| #export REALUSER |
| |
| # Set a PID for use throughout |
| PID=$$;export PID |
| |
| # Save original cmd-line |
| ORIG_CMDLINE="$*" |
| |
| # Define some functions when sourced from PROGrams |
| #[ -n "$PROG" ] && . stdlib.sh |
| |
| # set a basic trap to capture ^C's and other unexpected exits and do the |
| # right thing in TrapClean(). |
| trap TrapClean 2 3 15 |
| |
| ############################################################################## |
| # Standard library of useful shell functions and GLOBALS |
| ############################################################################## |
| |
| # Define logecho() function to display to log and std out |
| # Args can be -n or -r or -nr or -rn ONLY. |
| # -r = raw output - no $PROG: prefix |
| # -n - no newline (just like echo -n) |
| logecho () { |
| # Dynamically set fmtlen |
| local lfmtlen= |
| let lfmtlen=80-${#PROG} |
| N= |
| raw=false |
| case "$1" in |
| -n) N=-n |
| shift |
| ;; |
| -r) raw=true |
| shift |
| ;; |
| -rn|-nr) N=-n;raw=true |
| shift |
| ;; |
| esac |
| |
| # Allow widespread use of logecho without having to |
| # determine if $LOGFILE exists first. |
| # |
| # If -n is set, do not provide autoformatting or you lose the -n affect |
| # Use of -n should only be used on short status lines anyway. |
| if [ ! -f "$LOGFILE" ] |
| then |
| if $raw |
| then |
| echo $N "$*" |
| elif [ "$N" = -n ] |
| then |
| echo $N "$PROG: $*" |
| else |
| # To create a line continuation character |
| #echo $N "$*" |fmt -$lfmtlen |sed -e "1s,^,$PROG: ,g" -e "2,\$s,^,$PROG: .,g" |
| echo $N "$*" |fmt -$lfmtlen |sed "s,^,$PROG: ,g" |
| fi |
| else |
| if $raw |
| then |
| echo $N "$*" | tee -a $LOGFILE |
| elif [ "$N" = -n ] |
| then |
| echo $N "$PROG: $*" | tee -a $LOGFILE |
| else |
| # To create a line continuation character |
| #echo $N "$*" |fmt -$lfmtlen |sed -e "1s,^,$PROG: ,g" -e "2,\$s,^,$PROG: .,g" | tee -a $LOGFILE |
| echo $N "$*" |fmt -$lfmtlen |sed "s,^,$PROG: ,g" | tee -a $LOGFILE |
| fi |
| fi |
| } |
| |
| logrun () { |
| # if no args, take stdin |
| if [ -z "$1" ] |
| then |
| if ${VERBOSE:-true} |
| then |
| tee -a $LOGFILE |
| else |
| tee -a $LOGFILE > /dev/null 2>&1 |
| fi |
| elif [ -f "$LOGFILE" ] |
| then |
| echo >> $LOGFILE |
| echo "CMD: $*" >> $LOGFILE |
| # Special case for "cd" which cannot be run through a pipe (subshell) |
| if ${VERBOSE:-true} && [ "$1" != cd ] |
| then |
| ${*:-:} 2>&1 | tee -a $LOGFILE |
| return ${PIPESTATUS[0]} |
| else |
| ${*:-:} >> $LOGFILE 2>&1 |
| fi |
| else |
| if ${VERBOSE:-false} |
| then |
| $* |
| else |
| $* >/dev/null 2>&1 |
| fi |
| fi |
| } |
| |
| OkFailed () { |
| if logrun $* |
| then |
| logecho -r $OK |
| else |
| logecho -r $FAILED |
| return 1 |
| fi |
| } |
| |
| # Define process output |
| ProcessOutput () { |
| if ${VERBOSE:-true} |
| then |
| tee -a $LOGFILE |
| else |
| tee -a $LOGFILE > /dev/null 2>&1 |
| fi |
| } |
| |
| GeneratePassword () { |
| dd if=/dev/urandom count=1 2> /dev/null | uuencode -m - | sed -ne 2p | cut -c-8 |
| } |
| |
| # TimeStamp < begin | end | done > [ section ] |
| #+ DESCRIPTION |
| #+ TimeStamp begin is run at the beginning of the script to display a |
| #+ 'begin' marker and TimeStamp end is run at the end of the script to |
| #+ display an 'end' marker. |
| #+ TimeStamp will auto-scope to the current shell or you can optionally |
| #+ pass in a second argument as a section identifier if you wish to track |
| #+ multiple times within the same shell. |
| #+ |
| #+ For example, if you call TimeStamp begin and end within one script and then |
| #+ call it again in another script (new shell), you can just use begin and end |
| #+ But if you want to call it twice within the same script use it like this: |
| #+ |
| TimeStamp () |
| { |
| # Always set trace (set -x) back |
| #set +x |
| # |
| action=$1 |
| section=${2:-run} |
| # convert / to underscore |
| section=${section//\//_} |
| # convert : to underscore |
| section=${section//:/_} |
| # convert . to underscore |
| section=${section//./_} |
| |
| case "$action" in |
| begin) |
| # Get time(date) for display and calc |
| eval ${section}start_seconds=$(date '+%s') |
| |
| # Print BEGIN message for $PROG |
| logecho "BEGIN $section on ${HOSTNAME%%.*} $(date)" |
| [ "$section" = run ] && logecho -r |
| ;; |
| end|done) |
| # Check for "START" values before calcing |
| if [ -z "$(eval echo \\$\"${section}start_seconds\")" ] |
| then |
| #display_time="EE:EE:EE - 'end' run without 'begin' in this scope or sourced script using TimeStamp" |
| return 1 |
| else |
| # Get time(date) for display and calc |
| eval ${section}end_seconds=$(date '+%s') |
| |
| # process time |
| start_display_time=$(eval echo \$"${section}start_seconds") |
| # if start time is blank then just exit... |
| [ -z "$start_display_time" ] && return 0 |
| end_display_time=$(eval echo \$"${section}end_seconds") |
| display_time=$(expr ${end_display_time} - ${start_display_time:-0} |\ |
| awk '{ |
| in_seconds=$0 |
| days=in_seconds/86400 |
| remain=in_seconds%86400 |
| hours=remain/3600 |
| remain=in_seconds%3600 |
| minutes=remain/60 |
| seconds=remain%60 |
| printf("%dd %02d:%02d:%02d\n",days, hours, minutes, seconds) |
| }') |
| fi |
| |
| [ "$section" = run ] && logecho -r |
| # To override logecho's 80-column limit, echo directly and pipe to logrun |
| # for verbose/log handling |
| echo "$PROG: DONE $section on ${HOSTNAME%%.*} $(date) ${V_BOLD}in $display_time$V_VIDOFF_BOLD" |VERBOSE=true logrun |
| |
| # NULL these local vars |
| unset ${section}start_seconds ${section}end_seconds |
| ;; |
| esac |
| } |
| |
| TrapClean () { |
| # If user ^C's at read then tty is hosed, so make it sane again |
| stty sane |
| logecho -r |
| logecho -r |
| logecho "^C caught!" |
| Exit 1 "Exiting..." |
| } |
| |
| CleanExit () { |
| # cleanup CLEANEXIT_RM |
| # Sanity check the list |
| # should we test that each arg is a absolute path? |
| if echo "$CLEANEXIT_RM" |fgrep -qw / |
| then |
| logecho "/ found in CLEANEXIT_RM. Skipping Cleanup..." |
| else |
| if [ -n "$CLEANEXIT_RM" ] |
| then |
| logecho "Cleaning up:$CLEANEXIT_RM" |
| else |
| : logecho "Cleaning up..." |
| fi |
| # cd somewhere relatively safe and run cleanup the $CLEANEXIT_RM stack |
| # + some usual suspects... |
| cd /tmp && rm -rf $CLEANEXIT_RM $TMPFILE1 $TMPFILE2 $TMPFILE3 $TMPDIR1 \ |
| $TMPDIR2 $TMPDIR3 |
| fi |
| # display end timestamp when an existing TimeStamp begin was run |
| [ -n "$runstart_seconds" ] && TimeStamp end |
| exit ${1:-0} |
| } |
| |
| # Requires 2 args |
| # - Exit code |
| # - message |
| Exit () { |
| local etype=${1:-0} |
| shift |
| logecho -r |
| logecho $* |
| logecho -r |
| CleanExit $etype |
| } |
| |
| # these 2 kept for backward compat for now |
| Exit0 () { |
| Exit 0 $* |
| } |
| |
| Exit1 () { |
| Exit 1 $* |
| } |
| |
| Askyorn () { |
| local yorn |
| case "$1" in |
| -y) # yes default |
| shift |
| logecho -n "$* ([y]/n)? " |
| read yorn |
| case "$yorn" in |
| [nN]) return 1 ;; |
| *) return 0 ;; |
| esac |
| ;; |
| *) # no default |
| case "$1" in |
| -n) shift ;; |
| esac |
| logecho -n "$* (y/[n])? " |
| read yorn |
| case "$yorn" in |
| [yY]) return 0 ;; |
| *) return 1 ;; |
| esac |
| ;; |
| esac |
| } |
| |
| ############################################################################## |
| netls () { |
| url=${1:-"http://build/packages/kernel/experimental/autotest"} |
| wget -O - $url 2>&1 |sed -ne '/Parent Directory/,/^$/p' | sed 's,<[^>]*> *,,g' |sed -ne '2,$p' |sed '/^$/d' |
| } |
| |
| Spinner () { |
| while true |
| do |
| echo -n "-" |
| sleep 1 |
| echo -n "\\" |
| sleep 1 |
| echo -n "|" |
| sleep 1 |
| echo -n "/" |
| sleep 1 |
| done |
| } |
| |
| # Takes a step number and a string and prints out a section header |
| # If the first arg isn't a number, then it just prints the string |
| StepHeader () { |
| if [[ "$1" == [0-9]* ]] |
| then |
| local step="STEP $1 - " |
| shift |
| fi |
| local msg=$* |
| logecho -r |
| echo -n $V_BOLD |
| logecho "================================================================" |
| logecho "$step$msg" |
| logecho "================================================================" |
| echo -n $V_VIDOFF_BOLD |
| logecho -r |
| } |
| |
| LogfileInit () { |
| local lnum=$2 |
| # Initialize Logfile |
| # only set and shift(savefile) LOGFILE If none was set by calling program |
| if [ -z "$LOGFILE" ] |
| then |
| LOGFILE=${1:-$(pwd)/$PROG.log} |
| savefile file=$LOGFILE num=${lnum:-3} rm=yes |
| echo "CMD: $PROG $ORIG_CMDLINE" >$LOGFILE |
| else |
| echo "CMD: $PROG $ORIG_CMDLINE" >>$LOGFILE |
| fi |
| } |
| |
| CanonicalizePath () { |
| [ -z "$1" ] && return |
| cd -P -- "$(dirname -- "$1")" && |
| printf '%s\n' "$(pwd -P)/$(basename -- "$1")" |
| } |
| |
| ##################################################################### |
| # Set BUGSHELL_PASSWORD |
| ##################################################################### |
| BugshellAuth () { |
| # XXX: Buganizer and SSO. There's no solution yet that will allow |
| # password-less access to buganizer, so prompt for password each run. (awful) |
| # nmlorg trying to fix this: http://b/issue?id=759835 |
| # If I ever want to encrypt this: |
| #encrypted_password=$(echo $buganizer_password |openssl des3 -a -k $cryptkey) |
| #decrypted_password=$(echo "$encrypted_password" |openssl des3 -d -a -k $cryptkey) |
| |
| # Try to get a password from local machine |
| local ldap_password_file=/usr/local/google/$USER/.password |
| BUGANIZER_PASSWORD=$(cat $ldap_password_file 2>&-) |
| |
| until $BUGSHELL --password $BUGANIZER_PASSWORD ls 2>&- |
| do |
| echo |
| read -s -p "$PROG: Access to Buganizer required. Enter your LDAP password: " BUGANIZER_PASSWORD |
| echo |
| done |
| if [ "$(cat $ldap_password_file 2>&-)" != $BUGANIZER_PASSWORD ] |
| then |
| if Askyorn "Store your password (600) in $ldap_password_file" |
| then |
| mkdir -p $(dirname $ldap_password_file) |
| echo $BUGANIZER_PASSWORD > $ldap_password_file |
| chmod 600 $ldap_password_file |
| fi |
| fi |
| } |
| |
| # Takes space separated list of elements and returns a random one |
| PickRandomElement () { |
| # array of strings |
| local llist=($@) |
| local lrange= |
| local lrand=$RANDOM |
| |
| # set range |
| lrange=${#llist[*]} |
| # set boundaries |
| let "lrand %= $lrange" |
| |
| #echo "Random number less than $lrange --- $lrand = ${llist[$lrand]}" |
| echo ${llist[$lrand]} |
| } |
| |
| # It creates a temporary file to expand the environment variables |
| ManHelp () { |
| # Whatever caller is |
| local lprog=$0 |
| local ltmpfile=/tmp/$PROG-manhelp.$$ |
| |
| # Standard usage function |
| if [ "x$usage" = "xyes" -o "x$1" = "x-usage" -o \ |
| "x$1" = "x--usage" -o "x$1" = "x-?" ] |
| then |
| echo 'cat << EOFCAT' >$ltmpfile |
| echo "Usage:" >> $ltmpfile |
| sed -n '/#+ SYNOPSIS/,/^#+ DESCRIPTION/p' $lprog |\ |
| sed -e 's,^#+ ,,g' -e '/^DESCRIPTION/d' >> $ltmpfile |
| echo "EOFCAT" >> $ltmpfile |
| . $ltmpfile |
| rm -f $ltmpfile |
| exit 1 |
| fi |
| |
| # Standard man function |
| if [ "x$man" = "xyes" -o "x$1" = "x-man" -o \ |
| "x$1" = "x--man" -o "x$1" = "x-help" -o "x$1" = "x--help" ] |
| then |
| echo 'cat << EOFCAT' >$ltmpfile |
| grep "^#+" $lprog |cut -c4- >> $ltmpfile |
| echo "EOFCAT" >> $ltmpfile |
| . $ltmpfile | ${PAGER:-"less"} |
| rm -f $ltmpfile |
| exit 1 |
| fi |
| |
| # Standard comments function |
| if [ "x$comments" = "xyes" -o "x$1" = "x-comments" ] |
| then |
| echo |
| egrep "^#\-" $lprog |sed -e 's,^#- *,,g' |
| rm -f $ltmpfile |
| exit 1 |
| fi |
| } |
| |
| # parse cmdline |
| # Run namevalue as a separate script so it can handle quoted args --name="1 2" |
| . namevalue |
| # Run ManHelp to show usage and man pages |
| ManHelp $@ |
| |
| # Keep crostools up to date |
| # symlink may be setting by caller or use $0 |
| # Try it using std git pull or repo sync |
| (cd $(dirname ${symlink:-$0}) && git pull -q >/dev/null 2>&1 ||\ |
| repo sync crostools > /dev/null 2>&1) |
