ads-monitor

#!/bin/bash

# Formatting date and time
date_msg()
{
    echo "$(date +'%F %T') | $(date --date=@$1 +'%F %T')  $2"
}

# Calculating transactions per second
tps() {
    actual_txs=
    tac $1 | grep CLOCK | head -2 | while read line
    do
        if [[ ${line} =~ \[([0-9]+)\]\ CLOCK:\ ([0-9A-F]+).*txs:([0-9]+) ]]; then

            if [ -z "$actual_txs" ]; then
                actual_time=${BASH_REMATCH[1]}
                actual_clock="0x000${BASH_REMATCH[2]}"
                actual_txs=${BASH_REMATCH[3]}
            else
                last_time=${BASH_REMATCH[1]}
                last_clock="0x000${BASH_REMATCH[2]}"
                last_txs=${BASH_REMATCH[3]}

                if [ $(( $actual_clock )) -ge "0" ] && [ $(( $last_clock )) -lt "0" ]; then
                    txs=${actual_txs}
                else
                    txs="$(($actual_txs - $last_txs))"
                fi

                if [ -n "$2" ]; then
                    date_msg ${actual_time} "0x${actual_clock: -3}  $txs"
                else
                    echo ${txs}
                fi

                break
            fi
        fi
    done
}

# Parsing CLOCK log
clock() {

	line=`tac $2 | grep -m 1 -E "^\[[0-9]+\]"`
    regex="^\[([0-9]+)\]\ (\[.*\]\ )?([A-Z ]+:\ )?Awaiting for genesis block time:\ ([0-9]+\ s)"

    if [[ ${line} =~ ${regex} ]]; then
	    if [ -n "$4" ]; then
			 if [ -n "$3" ]; then
		        date_msg ${BASH_REMATCH[1]} "The node will start in ${BASH_REMATCH[4]}"
		    else
		        echo 1
		    fi
		    return
		else
	        >&2 date_msg ${BASH_REMATCH[1]} "The node will start in ${BASH_REMATCH[4]}"
	        echo 0
			return 1
		fi
    fi

    item=$1
    if [[ "$1" = "time" || "$1" = "net" ]]; then
        item=peers
    fi
    sync_regex="^([0-9]+):\[([0-9]+)\]\ (\[.*\]\ )?([A-Z\ ]+:\ )?START\ syncing\ header\ ([0-9A-F]+)$"
    clock_regex="^([0-9]+):\[([0-9]+)\]\ (\[.*\]\ )?([A-Z\ ]+:\ )?CLOCK:\ ([0-9A-F]+).*\ ${item}:([0-9]+).*\ \[,?([,0-9]*)\]"

    sync_line=`tac $2 | grep -n "START syncing header" | head -1`
    clock_line=`tac $2 | grep -n CLOCK | head -1`

	if [[ ${sync_line} =~ ${sync_regex} ]]; then
		sync_num=${BASH_REMATCH[1]}
		sync_time=${BASH_REMATCH[2]}
		sync_block=${BASH_REMATCH[5]}
	fi

	if [[ ${clock_line} =~ ${clock_regex} ]]; then
		clock_num=${BASH_REMATCH[1]}
		clock_time=${BASH_REMATCH[2]}
		clock_count=${BASH_REMATCH[5]}
		clock_val=${BASH_REMATCH[6]}
	    if [ "$1" = "time" ]; then
            clock_val=${clock_time}
        elif [ "$1" = "net" ]; then
            clock_val=${BASH_REMATCH[7]}
        fi
	fi

	if [ -n "${sync_num}" ] && ([ -z "${clock_num}" ] || [ ${sync_num} -le ${clock_num} ]); then
		left_blocks=$(( (`date +%s` / 512) - ("0x${sync_block}" / 512) ))
		if [ -n "$4" ]; then
			 if [ -n "$3" ]; then
		        date_msg ${sync_time} "Database synchronizing; left ${left_blocks} blocks"
		    else
		        echo 2
		    fi
		    return
		else
	        >&2 date_msg ${sync_time} "Database synchronizing; left ${left_blocks} blocks"
	        echo 0
			return 2
		fi
	elif [ -n "${clock_num}" ]; then
        clock="0x000${clock_count}"
        if [ -n "$3" ]; then
            date_msg ${clock_time} "0x${clock: -3}  ${clock_val}"
        elif [ -n "$4" ]; then
            echo $(( 100 + ${clock_val} ))
        else
            echo ${clock_val}
        fi
	else
		if [ -n "$4" ]; then
			 if [ -n "$3" ]; then
		        echo "Error 22: Cannot find CLOCK log"
		    else
		        echo 22
		    fi
		    exit
		else
	        >&2 echo "Error 22: Cannot find CLOCK log"
	        echo 0
	        exit 22
	     fi
	fi
}

# Number of awaiting transactions
txs() {
    clock "txs" $1 $2
}

# Number of active peers
peers() {
    clock "peers" $1 $2
}

# Checks if the node is alive
status() {
    clock "peers" $1 "$2" 1
}

# Number of currently open connections
connections() {
    clock "ticket" $1 $2
}

# JSON with all metrics
all_metrics() {
    time=$(clock "time" $1)
    time=$((( time / 512 ) * 512))
    block=$(printf "%X\n" $time)
    network=$(clock "net" $1)
    echo "\
{\
\"date\":\"$(date --iso-8601=seconds)\",\
\"block\":\"${block}\",\
\"status\":$(status $1),\
\"transactions\":$(txs $1),\
\"peers\":$(peers $1),\
\"connections\":$(connections $1),\
\"network\":[${network}]\
}"
}

# Check node configuration
check_stderr() {

	err=0

	if [ ! -d ${working_dir} ]; then
	    message="The node has not been configured - cannot find working directory \"${working_dir}\""
		err=11
	elif [ ! -f ${stderr_path} ]; then
        message="The node has not been started - cannot find STDERR file \"${stderr_path}\""
		err=12
	else
		line=`tac ${stderr_path} | grep -m 1 .`
	    regex="^\[([0-9]+)\]"
	    if [[ ${line} =~ ${regex} ]]; then
			if [ $(date +"%s") -ge $((BASH_REMATCH[1] + 10)) ]; then
	            message="The node seems to be dead"
		        err=13
			fi
		else
	        message="Cannot parse STDERR file \"${stderr_path}\""
			err=21
		fi
	fi

	if [ ${err} -gt 0 ] ; then
		if [ "${cmd}" = "status" ]; then
			if [ -n "${verbose}" ]; then
		        echo "Error ${err}: ${message}"
		    else
		        echo ${err}
		    fi
		    exit
		else
		    >&2 echo "Error ${err}: ${message}"
		    echo 0
		    exit ${err}
		fi
	fi
}

# Display error message
show_error() {
    >&2 echo "Error: $1"
    >&2 echo
    >&2 show_usage
    exit 1
}

# Display help message
show_help() {
    echo "Monitor the ADS network."
    echo
    show_usage
}

default_working_dir=~/.adsd
default_stderr="error.log"

# Display usage message
show_usage() {
    echo "Usage"
    echo "  $0 [options] <command>"
    echo
    echo "Commands"
    echo "  status                   checks if the node is alive"
    echo "  tps                      transactions per second"
    echo "  txs                      the number of awaiting transactions"
    echo "  peers                    the number of active peers"
    echo "  conns                    the number of currently open connections"
    echo "  all                      JSON with all metrics"
    echo
    echo "Options"
    echo "  -w, --working-dir <DIR>  working directory (default '${default_working_dir}')"
    echo "  -e, --stderr-path <FILE> absolute path to STDERR (default '${default_stderr}' in working directory)"
    echo "  -v, --verbose            verbose mode"
    echo "  -c, --continuous         continuous monitoring"
    echo "  -h, --help               display this help and exit"
}

# Parsing options
PARAMS=""
while (( "$#" )); do
    case "$1" in
        -v|--verbose)
            verbose=1
            shift 1
        ;;
        -c|--continuous)
            continuous=1
            shift 1
        ;;
        -[vc][vc])
            if [[ $1 = *"v"* ]]; then verbose=1; fi
            if [[ $1 = *"c"* ]]; then continuous=1; fi
            shift 1
        ;;
        -w|--working-dir)
            if [ -z "$2" ]; then
                show_error "Working directory is required"
            fi
            working_dir=$2
            shift 2
        ;;
        -e|--stderr-path)
            if [ -z "$2" ]; then
                show_error "Path to stderr is required"
            fi
            stderr_path=$2
            shift 2
        ;;
        -h|-\?|--help)
            show_help
            exit 0
        ;;
        --) # End argument parsing
            shift
            break
        ;;
        -*|--*=) # Unsupported flags
            show_error "Unsupported flag $1"
        ;;
        *) # Preserve positional arguments
            PARAMS="$PARAMS $1"
            shift
        ;;
    esac
done
# Set positional arguments in their proper place
eval set -- "${PARAMS}"

if [ -z "$1" ]; then
    show_error "Command is required"
fi
if [ -n "$2" ]; then
    show_error "To many arguments"
fi

cmd=$1

# Checking paths and dirs

if [ -z "$working_dir" ]; then
    working_dir=${default_working_dir}
fi

working_dir=`readlink -m ${working_dir}`

if [ -z "$stderr_path" ]; then
    stderr_path="${working_dir}/${default_stderr}"
fi

stderr_path=`readlink -m ${stderr_path}`

# Parsing command
command=
case "${cmd}" in
    status) command="status ${stderr_path} ${verbose}" ;;
    tps)    command="tps ${stderr_path} ${verbose}" ;;
    txs)    command="txs ${stderr_path} ${verbose}" ;;
    peers)  command="peers ${stderr_path} ${verbose}" ;;
    conns)  command="connections ${stderr_path} ${verbose}" ;;
    all)    command="all_metrics ${stderr_path}" ;;
    *)      show_error "Unsupported command \"${cmd}\"" ;;
esac

# Runs the monitor in a loop
if [ -n "${continuous}" ]; then
    while true; do
        check_stderr
        ${command}
        sleep 1
    done
else
	check_stderr
	${command};
	err=$?
    if [ ${err} -gt 0 ]; then
        exit ${err}
    fi
fi