tools/dreport

#! /bin/bash

help=$"
        dreport creates an archive(xz compressed) consisting of the following:
                * Configuration information
                * Debug information
                * A summary report
        The type parameter controls the content of the data. The generated
        archive is stored in the user specified location.

usage: dreport [OPTION]

Options:
        -n, —-name <name>     Name to be used for the archive.
                              Default name format obmcdump_<id>_<epochtime>
        -d, —-dir <directory> Archive directory to copy the compressed report.
                              Default output directory is /tmp
        -i, —-id <id>         Dump identifier to associate with the archive.
                              Identifiers include numeric characters.
                              Default dump identifier is 0
        -t, —-type <type>     Data collection type. Valid types are
                              "user", "core".
                              Default type is "user" initiated.
        -f, —-file <file>     Optional file to be included in the archive.
                              Absolute path of the file must be passed as
                              parameter. This is useful to include application
                              core in the dump.
        -s, --size <size>     Maximum allowed size(in KB) of the archive.
                              Report will be truncated in case size exceeds
                              this limit. Default size is 500KB.
        -v, —-verbose         Increase logging verbosity.
        -V, --version         Output version information.
        -q, —-quiet           Only log fatal errors to stderr
        -h, —-help            Display this help and exit.
"

#CONSTANTS
declare -r TRUE=1
declare -r FALSE=0
declare -r UNLIMITED="unlimited"
declare -r SUMMARY_DUMP="summary"
declare -r TYPE_USER="user"
declare -r TYPE_CORE="core"
declare -r SUMMARY_LOG="summary.log"
declare -r DREPORT_LOG="dreport.log"
declare -r TMP_DIR="/tmp"
declare -r EPOCHTIME=$(date +"%s")

#Error Codes
declare -r SUCCESS="0"
declare -r INTERNAL_FAILURE="1"
declare -r RESOURCE_UNAVAILABLE="2"

#VARIABLES
declare -x name=""
declare -x dump_dir="/tmp"
declare -x dump_id="00000000"
declare -x dump_type=$TYPE_USER
declare -x verbose=$FALSE
declare -x quiet=$FALSE
declare -x dump_size="unlimited"
declare -x name_dir=""
declare -x optional_file=""
declare -x dreport_log=""
declare -x summary_log=""
declare -x cur_dump_size=0

# @brief Calculate file or directory compressed size based on input
#        and check whether the size in the the allowed size limit.
#        Remove the file or directory from the name_dir
#        if the check fails.
# @param $1 Source file or directory
# @return 0 on success, error code if size exceeds the limit.
# Limitation: compress and tar will have few bytes size difference
#            between tar and compression approch.
function check_size()
{
    source=$1

    #No size check required incase dump_size is set to unlimited
    if [ $dump_size = $UNLIMITED ]; then
        return 0
    fi

    #get the file or directory size
    if [[ -d $source ]] && [[ -n $source ]]; then
        tar -cf "$source.tar" -C \
                 $(dirname "$source") $(basename "$source")
        size=$(stat -c%s "$source.tar")
        rm "$source.tar"
    else
        size=$(stat -c%s "$source")
    fi

    if [ $((size + cur_dump_size)) -gt $dump_size ]; then
        #Exceed the allowed limit,
        #tar and compress the files and check the size
        tar -Jcf "$name_dir.tar.xz" -C \
                  $(dirname "$name_dir") $(basename "$name_dir")
        size=$(stat -c%s "$name_dir.tar.xz")
        if [ $size -gt $dump_size ]; then
            #Remove the the specific data from the name_dir and contniue
            rm "$source" "$name_dir.tar.xz"
            return $RESOURCE_UNAVAILABLE
        else
            rm "$name_dir.tar.xz"
        fi
    fi

    #Remove the compressed file from the name directory
    cur_dump_size=$((size + cur_dump_size))
    return $SUCCESS
}

# @brief Initial version of the summary log
init_summary()
{
   log_summary "Name:          $name.tar.xz"
   log_summary "Epochtime:     $EPOCHTIME"
   log_summary "ID:            $dump_id"
   log_summary "Type:          $dump_type"
   log_summary "Optional file: $optional_file"
}

# @brief Check the validity of user inputs and initialize global
#        variables. Create directory for temporary data collection
# @return 0 on success, error code otherwise

function initialize()
{
    #Dump file name
    if [ -z $name ]; then
        name=$"obmcdump_"$dump_id"_$EPOCHTIME"
    fi

    #Create temporary data directory.
    mkdir -p "$TMP_DIR/$name"
    if [ $? -ne 0 ]; then
        echo "Error: Failed to create the temporary directory."
        return $RESOURCE_UNAVAILABLE;
    fi

    #name directory
    name_dir="$TMP_DIR/$name"

    #dreport log file
    dreport_log="$name_dir/$DREPORT_LOG"

    #summary log file
    summary_log="$name_dir/$SUMMARY_LOG"

    #Type
    if [[ !($dump_type = $TYPE_USER || $dump_type = $TYPE_CORE) ]]; then
       log_error "Invalid -type, Only summary log is available"
       dump_type=$SUMMARY_DUMP
    fi

    #Size
    #Check the input is integer.
    if [ "$dump_size" -eq "$dump_size" ] 2>/dev/null; then
       #Converts in to bytes.
       dump_size="$((dump_size * 1024))"
    else
       dump_size=$UNLIMITED
    fi

    return $SUCCESS
}

# @brief Packaging the dump and transferring to dump location.
function package()
{
    mkdir -p "$dump_dir"
    if [ $? -ne 0 ]; then
        log_error "Could not create the destination directory $dump_dir"
        dest_dir=$TMP_DIR
    fi

    #TODO openbmc/openbmc#1506 Enable file level compression.
    #tar and compress the files.
    tar_file="$name_dir.tar.xz"
    tar -Jcf "$tar_file" -C "$TMP_DIR" "$name"

    #remove the temporary name specific directory
    rm -r "$name_dir"

    #check the file size is in the allowed limit
    if [ $(stat -c%s "$tar_file") -gt $dump_size ]; then
       echo "File size exceeds the limit allowed"
       rm -rf "$TMP_DIR"
       exit 1
       #TODO openbmc/openbmc#1506 Revisit the error handling
    fi

    echo "Report is available in $dump_dir"

    if [ "$TMP_DIR" == "$dump_dir" ]; then
       return
    fi

    #copy the compressed tar file into the destination
    cp "$tar_file" "$dump_dir"
    if [ $? -ne 0 ]; then
        echo "Failed to copy the $tar_file to $dump_dir"
        return
    else
        rm -rf "$TMP_DIR"
    fi
}
# @brief log the error message
# @param error message
function log_error()
{
   echo "ERROR: $@" >> $dreport_log
   if ((quiet != TRUE)); then
      echo "ERROR: $@" >&2
   fi
}

# @brief log warning message
# @param warning message
function log_warning()
{
    if ((verbose == TRUE)); then
        echo "WARNING: $@" >> $dreport_log
        if ((quiet != TRUE)); then
            echo "WARNING: $@" >&2
        fi
    fi
}

# @brief log info message
# @param info message
function log_info()
{
    if ((verbose == TRUE)); then
        echo "INFO: $@" >> $dreport_log
        if ((quiet != TRUE)); then
            echo "INFO: $@" >&1
        fi
    fi
}

# @brief log summary message
# @param message
function log_summary()
{
    echo "$@" >> $summary_log
    if ((quiet != TRUE)); then
        echo "$@" >&1
    fi
}

# @brief Main function
function main()
{
    #initialize the global variables and
    #create temporary storage locations
    initialize
    result=$?
    if [[ ${result} -ne $SUCCESS ]]; then
        echo $(date -u)" Error: Failed to initialize, Exiting"
        exit;
    fi

    #Initilize the summary log
    init_summary

    #TODO Add Dump report generating script.

    package  #package the dump
}

TEMP=`getopt -o n:d:i:t:s:f:vVqh \
      --long name:,dir:,dumpid:,type:,size:,file:,verbose,version,quiet,help \
      -- "$@"`

if [ $? -ne 0 ]
then
    echo "Error: Invalid options"
    exit 1
fi

eval set -- "$TEMP"

while [[ $# -gt 1 ]]; do
    key="$1"
    case $key in
        -n|--name)
            name=$2
            shift 2;;
        -d|--dir)
            dump_dir=$2
            shift 2;;
        -i|--dumpid)
            dump_id=$2
            shift 2;;
        -t|--type)
            dump_type=$2
            shift 2;;
        -s|--size)
            dump_size=$2
            shift 2;;
        -f|--file)
            optional_file=$2
            shift 2;;
        -v|—-verbose)
            verbose=$TRUE
            shift;;
        -V|--version)
            shift;;
        -q|—-quiet)
            quiet=$TRUE
            shift;;
        -h|--help)
            echo "$help"
            exit;;
        *) # unknown option
            log_error "Unknown argument: $1"
            log_info "$help"
            exit 1;;
    esac
done

main #main program
exit $?