rgrep

#!/usr/bin/env bash

# Time-stamp: <2017-11-10 12:58:29 Friday by ahei>

# @file rgrep.sh
# @version 1.0
# @author ahei

readonly PROGRAM_NAME="rgrep"
readonly PROGRAM_VERSION="1.0.0"

home=`cd $(dirname "$0") && pwd`

version()
{
    echo "${PROGRAM_NAME} ${PROGRAM_VERSION}"
    exit 1
}

# echo to stderr
echoe()
{
    printf "$*\n" 1>&2
}

usage()
{
    local code=1
    local redirect
    
    if [ $# -gt 0 ]; then
        code="$1"
    fi

    if [ "$code" != 0 ]; then
        redirect="1>&2"
    fi

    eval cat "$redirect" << EOF
usage: ${PROGRAM_NAME} [OPTIONS] (-H <HOST> | <CLUSTER>) <PATTERN> [<FILES>]

Options:
    -h <HOUR>
        Set which hour file to grep.
    -d <DAY>
        Set which day file to grep.
    -D <DAY>
        Search all files about this day.
    -m <MONTH>
        Set which month file to grep.
    -S  Do not sort files by date time you specified.
    -B <TIME_BEGIN>
        Set time begin string on every line.
    -E <TIME_END>
        Set time end string on every line.
    -k FIELD_INDEX
        Sort files by which field.
    -t SEP
        Set field delimiter.
    GERP
        Environment variable used to specify which grep to use.
    -C  No color display.
    -l  Only search current host.
    -g GREP_OPTIONS
        Set grep's options.
    -o REMOTE_OPTIONS
        Set remote's options.
    -n  Do not really execute command, only print command to execute.
    -P  When output, do not insert host prefix.
    -v  Output version info.
EOF

    exit "$code"
}

# $1: pattern
# $2: month
# $3: day
# $4: hour
getTimeStr()
{
    local pattern=$1
    local month=$2
    local day=$3
    local hour=$4
    local timeStr="$pattern"
    
    if (( month < 0 )); then
        month=$(date -d "$((-month)) months ago" +%m)
        month=${month#0}
    fi
    if (( day < 0 )); then
        if [ ! "$month" ]; then
            month=$(date -d "$((-day)) days ago" +%m)
            month=${month#0}
        fi
        day=$(date -d "$((-day)) days ago" +%d)
        day=${day#0}
    fi
    if [ "$hour" != '*' ] && (( hour < 0 )); then
        hour=$(printf "%1d" $(date -d "$((-hour)) hours ago" +%k))
    fi
    
    if [ "$month" ]; then
        timeStr=$(sed -r "s/%m/$(printf %02d $month)/g" <<< "$timeStr")
    fi
    if [ "$day" ]; then
        timeStr=$(sed -r "s/%d/$(printf %02d $day)/g" <<< "$timeStr")
        timeStr=$(sed -r "s/%e/$(printf %2d $day)/g" <<< "$timeStr")
    fi
    if [ "$hour" ] ; then
        if [ "$hour" != '*' ]; then
            timeStr=$(sed -r "s/%H|%I/$(printf %02d $hour)/g" <<< "$timeStr")
            timeStr=$(sed -r "s/%k|%l/$(printf %2d $hour)/g" <<< "$timeStr")
        else
            timeStr=$(sed -r "s/%H|%I/$hour/g" <<< "$timeStr")
            timeStr=$(sed -r "s/%k|%l/$hour/g" <<< "$timeStr")
        fi
    fi

    timeStr=$(date +"$timeStr")
    echo -n "$timeStr"
}

# $1 cluster
# $2 day
# $3 hour
getFiles()
{
    local cluster=$1
    local month=$2
    local day=$3
    local hour=$4
    local files
    
    for key in "${!clusterFiles[@]}"; do
        if grep -qx "$key" <<< "$cluster"; then
            files="${clusterFiles[$key]}"
        fi
    done

    if [ ! "$files" ]; then
        echo -n "$files"
        return
    fi

    getTimeStr "$files" "$month" "$day" "$hour"
}

sortFiles()
{
    if [ "$noSort" ] || [ "$isExecute" = 0 ]; then
        cat
        return
    fi
    
    cat | awk -F"$fieldDelimiter" -v timeBegin="$timeBegin" -v timeEnd="$timeEnd" -v keyField="$keyField" '{
if (keyField) {results[$ keyField FNR] = $ 0; next; }

prefix = ":"; # grep maybe have color output
begin = index($ 0, prefix timeBegin);
if (begin == 0) {begin = index($ 0, timeBegin);}
else {timeBegin = prefix timeBegin;}
end = index($ 0, timeEnd);
timeStr = substr($ 0, begin + length(timeBegin), end - begin - length(timeBegin));
if (length(timeStr) < 10) print;
else results[timeStr FNR] = $ 0;
} END {
size = asorti(results, sortedResults);
for (i = 1; i <= size; i++) print results[sortedResults[i]]}'
}

optInd=1
colorOption=--color=always
fieldDelimiter=" "
remoteOptions=-q

options=":h:d:vo:H:CSB:E:D:ng:lm:k:t:P"
[ ! "$NOT_ADJUST_OPTIONS" ] && eval set -- $(getopt -o "$options" -- "$@")
while getopts "$options" OPT; do
    case "$OPT" in
        H)
            hosts="$hosts $OPTARG"
            ;;

        C)
            colorOption=
            ;;
            
        o)
            remoteOptions="$OPTARG"
            ;;

        n)
            remoteOptions="$remoteOptions -n -V"
            isExecute=0
            ;;

        S)
            noSort=1
            ;;

        B)
            timeBegin="$OPTARG"
            ;;

        E)
            timeEnd="$OPTARG"
            ;;
        
        h)
            hour="$OPTARG"
            ;;
            
        d)
            day="$OPTARG"
            ;;

        D)
            day="$OPTARG"
            hour='*'
            ;;

        m)
            month="$OPTARG"
            ;;
        
        g)
            grepOptions="$OPTARG"
            ;;

        l)
            searchLocal=1
            ;;

        k)
            keyField="$OPTARG"
            ;;

        t)
            fieldDelimiter="$OPTARG"
            ;;
        
        P)
            remoteOptions="$remoteOptions -P"
            noPrefix=1
            ;;
        
        v)
            version
            ;;

        :)
            case "${OPTARG}" in
                ?)
                    echoe "Option \`-${OPTARG}' need argument.\n"
                    usage
            esac
            ;;

        ?)
            echoe "Invalid option \`-${OPTARG}'.\n"
            usage
            ;;
    esac
done

shift $((OPTIND - 1))

[ -z "$GREP" ] && GREP=grep

if [ "$keyField" ]; then
    if [ ! "$noPrefix" ]; then
        if ! ((keyField++)); then
            echoe "Invalid key field \`$OPTARG'!"
            exit 1
        fi
    fi
fi

if { [ ! "$timeBegin" ] || [ ! "$timeEnd" ]; } && [ ! "$keyField" ]; then
    noSort=1
fi

if [ ! "$hosts" ]; then
    cluster=$1
    if [ ! "$cluster" ]; then
        echoe "Must specify cluster!"
        usage
    fi
    
    shift
fi
    
if [ $# -lt 1 ]; then
    echoe "Must specify pattern!"
    usage
fi

pattern=$1
shift

if [ $# -ge 1 ]; then
    files="$@"
else
    if [ -z "$cluster" ]; then
        echoe "No files specified, must specify cluster!"
        usage
    fi
    
    declare -A clusterFiles
    . /etc/remoterc 2>/dev/null
    . ~/.remoterc 2>/dev/null
    files=$(getFiles "$cluster" "$month" "$day" "$hour")
    if [ ! "$files" ]; then
        echoe "No files specified for cluster $cluster!"
        usage
    fi
fi

command="$GREP $grepOptions $colorOption '$pattern' $files"
if [ "$searchLocal" = 1 ]; then
    if [ "$isExecute" = 0 ]; then
        echo "$command"
    else
        eval "$command"
    fi
    exit
fi

remote $remoteOptions -H "$hosts" -p "$fieldDelimiter" $cluster "$command" | sortFiles