ulib.sh

Go to the documentation of this file.

#!/bin/zsh
#
#
# \author mdejong
#
#--------------------------------------------------------------------------------------
#
#                   Utility script for zsh library functions.
#
#--------------------------------------------------------------------------------------


version=1.0

if [[ "$DEBUG" == "" ]]; then
typeset -i DEBUG=0                    # debug level
export     DEBUG
fi

export DEFAULT_OPTION=-               # default option 

export ULIB_DIR=${0:h}                # ulib directory

# Wild card for any valid detector identifier or run number; to be used as ${~ANY}.

export ANY_ID="[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]"

export PI=3.1415926535897931

export BLUE="\e[94m"
export GREEN="\e[92m"
export RED="\e[91m"
export RESET="\e[0m"
export BOLD="\e[1m"

export TIMESTAMP=\#splitline{}{\#splitline{%d-%m-%y}{\ \ %H:%M}}%F1970-01-01\ 00:00:00

# Array of variable set / unset with set_variable / unset_variable (see below).

typeset -A  ULIB_VARIABLES
export      ULIB_VARIABLES

# Array of variables with default values defined with set_variable: or set_variable+ (see below).

typeset -A  UDEF_VARIABLES
export      UDEF_VARIABLES

#
# debug messages
#
function fatal()   { 
    echo -e $RED`date` FATAL   $* $RESET 
    exit 1
} 
function error()   { if (( $DEBUG >= 0 )); then echo -e $RED`date` ERROR   $* $RESET; fi }
function notice()  { if (( $DEBUG >= 1 )); then echo -e     `date` NOTICE  $* ; fi }
function status()  { if (( $DEBUG >= 2 )); then echo -e     `date` STATUS  $* ; fi }
function warning() { if (( $DEBUG >= 2 )); then echo -e     `date` WARNING $* ; fi }
function debug()   { if (( $DEBUG >= 3 )); then echo -e     `date` DEBUG   $* ; fi }


#
# Method to check for usage of script.
#
# \param  1-N     list of command line options
# \return         0 for option -h; else 1
#
function do_usage()
{
    for variable in $*; do
        if [[ "$variable" == "-h!" ]]; then
            DEBUG=3
        fi
    done

    for variable in $*; do
        if [[ "$variable" == "-h" || "$variable" == "-h!" ]]; then
            return 0
        fi
    done

    return 1
}


#
# Method to print usage of script and exit.
#
# \param  1-N     usage
#
function usage()
{
    echo "$*"

    if (( $DEBUG >= 3 )); then
        print_array UDEF_VARIABLES
    fi

    exit
}


#
# Method to print environment variables.
#
function print_env()
{
    env
}


#
# check exit code
# The last parameter refers to the exit code.
#
# \param  1-N     message
# \param  N       exit code
#
function check_exit_code()
{
    if (( $argv[-1] )); then
        error  $*
        exit   $argv[-1]
    else
        notice $*
    fi
}


#
# check exit code alias
#
alias CHECK_EXIT_CODE="check_exit_code \$0 \$* \$?"


#
# test quality
#
# \param  1       first  value
# \param  2       second value
#
function test_equality
{
    if [[ "$1" != "$2" ]]; then
        fatal "<$1> != <$2>"
    else
        debug "<$1> == <$2>"
    fi
}


#
# Method to check if inside a conda env.
#
function has_conda()
{
    if [ -n "${CONDA_PREFIX+1}" ]; then
        return 0
    else
        return 1
    fi
}


#
# Method to check for CC Lyon.
#
# \return         1 for CC Lyon; else 0
#
function is_CCLyon()
{
    LOCALHOST=`hostname`

    if [[ -n "${LOCALHOST}" && "${LOCALHOST:0:2}" =  "cc" ]]; then
        return 0
    else
        return 1
    fi
}


# Method to check if the local host corresponds to one of the Nikhef computer clusters
#
# \return           1 if local host corresponds to one of the Nikhef computer clusters; else false
#
function is_CCNikhef()
{
    LOCALHOST=`hostname`

    if [[ -n "${LOCALHOST}" && "${LOCALHOST:0:4}" == "stbc" ]]; then
        return 0
    else
        return 1
    fi
}


#
# Method to define variable.
#
# \param  1       variable
#
function define_variable()
{
    local variable=$1

    eval export $variable
}


#
# Method to set variable.
# Note that a value equal to $DEFAULT_OPTION will not modify the variable.
#
# \param  1       variable
# \param  2-N     value(s)
#
function set_variable()
{
    local variable=$1
    shift

    if [[ "$*" != "$DEFAULT_OPTION" ]]; then
        eval export $variable=\"$\*\"
    fi

    eval ULIB_VARIABLES\[$variable\]=\"\$${variable}\"
}


#
# Method to set variable.
# The second variable corresponds to a possible default value.
# If this variable is defined, the first variable is set to its value
# else to the given value(s).
#
# \param  1       variable
# \param  2       variable
# \param  3-N     value(s)
#
function set_variable:()
{
    local variable=$1
    shift

    local optional=$1
    shift

    eval value=\"\${$optional:-"$*"}\"

    set_variable $variable $value

    UDEF_VARIABLES[$variable]="$optional -> $value"
}


#
# Method to set variable.
# The second variable corresponds to a possible default value.
# If this variable is defined, the first variable is set to the given value(s)
# else to an empty value.
#
# \param  1       variable
# \param  2       variable
# \param  3-N     value(s)
#
function set_variable+()
{
    local variable=$1
    shift

    local optional=$1
    shift

    eval value=\"\${$optional+"$*"}\"

    set_variable $variable $value

    UDEF_VARIABLES[$variable]="$optional -> $value"
}


#
# Method to locally set variable.
# Note that a value equal to $DEFAULT_OPTION will not modify the variable.
#
# \param  1       variable
# \param  2-N     value(s)
#
function set_local_variable()
{
    local variable=$1
    shift

    if [[ "$*" != "$DEFAULT_OPTION" ]]; then
        eval $variable=\"$\*\"
    fi
}


#
# Method to unset variable.
#
# \param  1       variable
#
function unset_variable()
{
    local variable=$1

    eval unset $variable
    eval unset \"ULIB_VARIABLES\[$variable\]\"
}


#
# Method to print variables.
#
# \param  1-N     list of variables
#
function print_variable()
{
    for variable in $*; do
        eval value=\${$variable}
        printf "%-20s = %s\n" ${variable} "${value}"
    done
}


#
# Method to print associative array.
#
# \param  1       array
#
function print_array()
{
    array=$1

    len=0

    eval keys=\(\${\(@k\)$array}\)

    for key in $keys; do
        if (( ${#key} > $len )); then
            len=${#key}
        fi
    done
    
    for key in $keys; do
        eval printf \"%-${len}s = %s\\n\" $key \"\$${array}\[$key\]\"
    done
}


#
# Method to check validity of variables.
#
# \param  1-N     list of variables
#
function check_variable()
{
    for variable in $*; do
        eval value=$+${variable}
        if (( ${value} == 0 )); then
            fatal "Variable ${variable} not defined."
        fi
    done
}


#
# Method to set array.
#
# \param  1       array name
# \param  2-N     values
#
function set_array()
{
    local variable=$1
    shift

    eval $variable=\($\*\)
}


#
# Method to expand array.
#
# Tokens <first>-<last> in the array are exanded to <first> <first + 1> .. <last>
#
# \param  1       array name
#
function expand_array()
{
    eval __BUFFER__=\(\$$1\[\*\]\)

    eval $1=\(\)

    for RANGE in $__BUFFER__[*]; do
        for (( i = ${RANGE%%-*}; $i <= ${RANGE##*-}; i += 1 )); do
            eval $1+=\($i\)
        done
    done
}


#
# Method to count directory in ':' separated path list.
#
# \param  1       path list
# \param  2       directory
#
function count_directory()
{
    eval key=\${$1}
    
    echo -n $key | tr ":" "\n" | grep "^\\${2}$" | wc -w
}


#
# Method to remove directory from ':' separated path list.
#
# \param  1       path list
# \param  2       directory
#
function remove_directory()
{
    eval key=\${$1}
    eval value=$2

    if [[ -n "$key" && -n "$value" ]]; then
        export $1=`eval echo $key | tr ":" "\n" | grep -v "^\\\\${value}$" | tr "\n" ":" | sed 's/:\$//'`
    fi
}


#
# Method to remove variable from ':' separated path list.
#
# \param   1      path list
# \param   2      variable
#
function remove_variable()
{
    eval key=\${$1}
    eval value=\${$2}

    if [[ -n "$key" && -n "$value" ]]; then
        remove_directory $1 $value
    fi
}


#
# Method to insert directory into ':' separated path list.
#
# \param   1      path list
# \param   2      directory
#
function insert_directory()
{
    eval key=\${$1}

    if [[ -z "$key" ]]; then
        export $1=$2
    elif (( `eval echo -n $key | tr ":" "\n" | grep "^\\\\${2}$" | wc -w` == 0 )); then
        export $1=$2:${key}
    fi
}


#
# Method to check process path.
#
# \param   1-N    list of process names
#
function check_process()
{
    for process in $*; do

        local bin=`which $process 2>& /dev/null`
        debug "Check process ${process}=${bin}"

        if [ -z "${bin}" ]; then
            fatal "Process ${process} not found."
        fi
    done
}


#
# Method to check file access.
#
# \param   1-N    list of files
#
function check_input_file()
{
    if (( $# == 0 )); then
        fatal "No input file."
    fi
    
    for file in `echo $*`; do

        debug "Check input file: ${file}"

        if   [[ ! -f ${file} ]]; then
            fatal "File ${file} not found."
        elif [[ ! -r ${file} ]]; then
            fatal "File ${file} not readable."
        fi
    done
}


#
# Method to check file access.
#
# \param   1-N    list of files
#
function check_output_file()
{
    for file in `echo $*`; do

        debug "Check output file: ${file}"

        if [[ -f ${file} ]]; then
            fatal "File ${file} already exists."
        fi
    done
}


#
# Method to reuse file.
# Note that this method may require user interaction.
#
# \param   1      file name
# \return         1 when absent; else 0
#
function reuse_file()
{
    if   [[ -f $1 ]]; then
        rm -i $1
    fi

    if   [[ ! -f $1 ]]; then    
        return 1
    else
        return 0
    fi
}


#
# Get host IP address
#
function get_ip_address()
{
    hostname --all-ip-addresses | cut --delimiter=' ' -f1
}


#
# Get process identifier.
#
# \param          [hostname]
# \param          process name
# \return         PID
#
function get_pid()
{
    if   (( $# == 1 )); then
        exec ps h -o "%p" -C $1 
    elif (( $# == 2 )); then
        exec ssh $1 "ps h -o "%p" -C $2"
    fi
}


#
# Method to get least significant digit.
#
# \param          value
# \return         value
#
function getLSD()
{
    printf "%f\n" `echo $1  |  sed -n "s/[+-]\?\([0-9]*.\?[0-9]*\)[1-9]\([0]*.\?\)/\1A\2/p" | sed 's/[1-9]/0/g' | sed 's/A/1/'`
}


#
# Method to start timer
#
function timer_start()
{
    let "TIMER = $(date +%s.%N)"
}


#
# Method to stop timer
#
function timer_stop()
{
    let "TIMER = $(date +%s.%N) - $TIMER"
}


#
# Method to print timer
#
function timer_print()
{
    printf "Elapsed time %1.3f s.\n" $TIMER
}


#
# Method to print lap time
#
function timer_lap()
{
    printf "Elapsed time %1.3f s.\n" $(($(date +%s.%N) - $TIMER))
}


#
# Method to convert associative array to list of equations
#
# \param   1         associative array
#
function make_equation()
{
    local array

    typeset -A array

    eval array=\(\${\(kv\)${1}}\)

    echo -n "\""

    for key in ${(k)array}; do
        echo -n "$key = ${array[${key}]}; "
    done

    echo "\""
}


#
# Test if associative array has given key.
#
# \param   1         associative array
# \param   2         key
# \return            1 if present; else 0
#
has_key()
{
   local var="${1}[$2]"

   echo ${(P)+${var}}
}


#
# Make communication with process.
#
# Note that:
#  - FD_O is the actual file descriptor for writing to actual process and
#  - FD_I is the actual file descriptor for reading from process.
#
# \param   1         process name
# \param   2-N       optional argument(s)
#
function attach()
{
    PROCESS=$1                                      # process

    shift

    ARGS="$*"                                       # optional arguments

    FIFO_O=/tmp/${PROCESS}_writing.$$               # named pipe for writing
    FIFO_I=/tmp/${PROCESS}_reading.$$               # named pipe for reading

    rm -f $FIFO_O
    rm -f $FIFO_I

    mkfifo $FIFO_O                                  # create a new FIFO
    mkfifo $FIFO_I                                  # create a new FIFO

    eval "exec {FD_O}<>$FIFO_O"                     # attach file descriptor to FIFO
    eval "exec {FD_I}<>$FIFO_I"                     # attach file descriptor to FIFO

    # launch process in background and cleanup afterwards

    eval \($PROCESS               \
        $ARGS                     \
        \< $FIFO_O                \
        \> $FIFO_I        \&\&    \
	rm -f $FIFO_O     \&\&    \
	rm -f $FIFO_I\)   \&
}


#
# Remove communication with process.
#
# \param   1         file descriptor for writing to process
#
function detach()
{
    if   (( $# == 0 )); then
        FD=$FD_O
    else
        FD=$1
    fi

    print -u $FD "^D"
}


#
# Write to attachted prcess.
#
function sput()
{
    print -u $FD_O "$*"
}

#
# Read from attachted prcess.
#
function sget()
{
    eval read $* \<\& $FD_I
}


#
# alias to kill all child processes at exit of parent process
#
alias kill_child_processes_at_exit="trap  'kill_child_processes $$'  EXIT"


#
# recursively kill child processes for given parent identifier.
#
# \param  1       parent identifier
#
kill_child_processes()
{
    local pid=$1

    for child in `ps --ppid $pid -ho "%p"`; do
        kill_child_processes $child
    done

    if (( $pid != $$ )); then
        kill -9 $pid >& /dev/null
    fi
}


alias sftpget="$ULIB_DIR/sftpget.zsh"
alias sftpput="$ULIB_DIR/sftpput.zsh"