ulib.sh

Go to the documentation of this file.

#!/usr/bin/env 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 
 
if   [[ -n "${BASH_SOURCE}" ]]; then
    export ULIB_DIR=$(dirname "${BASH_SOURCE[0]}")
elif [[ -n "${ZSH_VERSION}" ]]; then
    export ULIB_DIR=$(dirname "${(%):-%x}")
else
    export ULIB_DIR=$(dirname "${0}")
fi
 
# 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}
    eval value=$2
    
    echo -n $key | tr ":" "\n" | grep "^${value}$" | 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=`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 (( `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()
{
    if [[ $(uname) == "Darwin" ]]; then
      arp $(hostname) | cut -d '(' -f 2 | cut -d ')' -f 1
    else
      hostname --all-ip-addresses | cut --delimiter=' ' -f1
    fi
}
 
 
#
# Get process identifier.
#
# \param          [hostname]
# \param          process name
# \return         PID
#
function get_pid()
{
    if (( $# == 1 )); then
      exec pgrep $1
    fi
    if (( $# == 2 )); then
      exec ssh $1 pgrep $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 get time.
#
function get_time()
{
    if [[ $(uname) == "Darwin" ]]; then
      date +%s
    else
      date +%s.%N
    fi
}
 
#
# Method to start timer
#
function timer_start()
{
    let "TIMER = $(get_time)"
}
 
 
#
# Method to stop timer
#
function timer_stop()
{
    let "TIMER = $(get_time) - $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" $(($(get_time) - $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"