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

typeset -i TIMER=0                    # timer
export     TIMER

export DEFAULT_OPTION=-               # default option 


# Wild card for any valid run number to be used as ${~ANY_RUN_NUMBER}.

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

export PI=3.14159265359

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


#
# 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" || "$variable" == "-h!" ]]; then
       return 0
   fi
    done

    return 1
}


#
# Method to print usage of script and exit.
#
# \param  1-N     usage
#
function usage()
{
    echo "$*"
    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
}


#
# 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
}


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


#
# 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 get file name of source code.
#
# \param  1       executable file
# \return         source     file
#
function get_source()
{
    file=`which $1 2> /dev/null`

    if [[ -n "${file}" && -x ${file} ]]; then
   if [[ $file = *.sh || $file = *.csh ]]; then
       source=${file}
   else
       source=`${file} -v 2> /dev/null | sed -n 's/source: *//p'`
   fi
    else
   source=$1
    fi

    echo $source
}


#
# 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
}


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

    eval unset $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 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 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()
{
    TIMER=$(date +%s)
}


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


#
# Method to print timer
#
function timer_print()
{
    echo "Elapsed time $TIMER s."
}


#
# 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"
}