mirror of https://github.com/captn3m0/Scripts.git
Updated composer and installed prettyping.
This commit is contained in:
parent
ca1c90631f
commit
6e82154bd4
|
@ -0,0 +1,655 @@
|
|||
#!/bin/bash
|
||||
#
|
||||
# Written by Denilson Figueiredo de Sá <denilsonsa@gmail.com>
|
||||
# MIT license
|
||||
#
|
||||
# Requirements:
|
||||
# * bash (tested on 4.20, should work on older versions too)
|
||||
# * gawk (GNU awk, tested on 4.0.1, should work on older versions too)
|
||||
# * ping (from iputils)
|
||||
|
||||
# TODO: Detect the following kind of message and avoid printing it repeatedly.
|
||||
# From 192.168.1.11: icmp_seq=4 Destination Host Unreachable
|
||||
#
|
||||
# TODO: print the destination (also) at the bottom bar. Useful after leaving
|
||||
# the script running for quite some time.
|
||||
#
|
||||
# TODO: Implement audible ping.
|
||||
#
|
||||
# TODO: Autodetect the width of printf numbers, so they will always line up correctly.
|
||||
#
|
||||
# TODO: Test the behavior of this script upon receiving out-of-order packets, like these:
|
||||
# http://www.blug.linux.no/rfc1149/pinglogg.txt
|
||||
#
|
||||
# TODO? How will prettyping behave if it receives a duplicate response?
|
||||
|
||||
print_help() {
|
||||
cat << EOF
|
||||
Usage: $MYNAME [prettyping parameters] <standard ping parameters>
|
||||
|
||||
This script is a wrapper around the system's "ping" tool. It will substitute
|
||||
each ping response line by a colored character, giving a very compact overview
|
||||
of the ping responses.
|
||||
|
||||
prettyping parameters:
|
||||
--[no]color Enable/disable color output. (default: enabled)
|
||||
--[no]multicolor Enable/disable multi-color unicode output. Has no effect if
|
||||
either color or unicode is disabled. (default: enabled)
|
||||
--[no]unicode Enable/disable unicode characters. (default: enabled)
|
||||
--[no]terminal Force the output designed to a terminal. (default: auto)
|
||||
--last <n> Use the last "n" pings at the statistics line. (default: 60)
|
||||
--columns <n> Override auto-detection of terminal dimensions.
|
||||
--lines <n> Override auto-detection of terminal dimensions.
|
||||
--rttmin <n> Minimum RTT represented in the unicode graph. (default: auto)
|
||||
--rttmax <n> Maximum RTT represented in the unicode graph. (default: auto)
|
||||
|
||||
ping parameters handled by prettyping:
|
||||
-a Audible ping is not implemented yet.
|
||||
-f Flood mode is not allowed in prettyping.
|
||||
-q Quiet output is not allowed in prettyping.
|
||||
-R Record route mode is not allowed in prettyping.
|
||||
-v Verbose output seems to be the default mode in ping.
|
||||
|
||||
Tested with Linux ping tool from "iputils" package:
|
||||
http://www.linuxfoundation.org/collaborate/workgroups/networking/iputils
|
||||
EOF
|
||||
}
|
||||
|
||||
# Thanks to people at #bash who pointed me at
|
||||
# http://bash-hackers.org/wiki/doku.php/scripting/posparams
|
||||
parse_arguments() {
|
||||
USE_COLOR=1
|
||||
USE_MULTICOLOR=1
|
||||
USE_UNICODE=1
|
||||
|
||||
if [ -t 1 ]; then
|
||||
IS_TERMINAL=1
|
||||
else
|
||||
IS_TERMINAL=0
|
||||
fi
|
||||
|
||||
LAST_N=60
|
||||
OVERRIDE_COLUMNS=0
|
||||
OVERRIDE_LINES=0
|
||||
RTT_MIN=auto
|
||||
RTT_MAX=auto
|
||||
|
||||
PING_PARAMS=( )
|
||||
|
||||
while [[ $# != 0 ]] ; do
|
||||
case "$1" in
|
||||
-h | -help | --help )
|
||||
print_help
|
||||
exit
|
||||
;;
|
||||
|
||||
# Forbidden ping parameters within prettyping:
|
||||
-f )
|
||||
echo "${MYNAME}: You can't use the -f (flood) option."
|
||||
exit 1
|
||||
;;
|
||||
-R )
|
||||
# -R prints extra information at each ping response.
|
||||
echo "${MYNAME}: You can't use the -R (record route) option."
|
||||
exit 1
|
||||
;;
|
||||
-q )
|
||||
echo "${MYNAME}: You can't use the -q (quiet) option."
|
||||
exit 1
|
||||
;;
|
||||
-v )
|
||||
# -v enables verbose output. However, it seems the output with
|
||||
# or without this option is the same. Anyway, prettyping will
|
||||
# strip this parameter.
|
||||
;;
|
||||
# Note:
|
||||
# Small values for -s parameter prevents ping from being able to
|
||||
# calculate RTT.
|
||||
|
||||
# New parameters:
|
||||
-a )
|
||||
# TODO: Implement audible ping for responses or for missing packets
|
||||
;;
|
||||
|
||||
-color | --color ) USE_COLOR=1 ;;
|
||||
-nocolor | --nocolor ) USE_COLOR=0 ;;
|
||||
-multicolor | --multicolor ) USE_MULTICOLOR=1 ;;
|
||||
-nomulticolor | --nomulticolor ) USE_MULTICOLOR=0 ;;
|
||||
-unicode | --unicode ) USE_UNICODE=1 ;;
|
||||
-nounicode | --nounicode ) USE_UNICODE=0 ;;
|
||||
-terminal | --terminal ) IS_TERMINAL=1 ;;
|
||||
-noterminal | --noterminal ) IS_TERMINAL=0 ;;
|
||||
|
||||
#TODO: Check if these parameters are numbers.
|
||||
-last | --last ) LAST_N="$2" ; shift ;;
|
||||
-columns | --columns ) OVERRIDE_COLUMNS="$2" ; shift ;;
|
||||
-lines | --lines ) OVERRIDE_LINES="$2" ; shift ;;
|
||||
-rttmin | --rttmin ) RTT_MIN="$2" ; shift ;;
|
||||
-rttmax | --rttmax ) RTT_MAX="$2" ; shift ;;
|
||||
|
||||
* )
|
||||
PING_PARAMS+=("$1")
|
||||
;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
if [[ "${RTT_MIN}" -gt 0 && "${RTT_MAX}" -gt 0 && "${RTT_MIN}" -ge "${RTT_MAX}" ]] ; then
|
||||
echo "${MYNAME}: Invalid --rttmin and -rttmax values."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [[ "${#PING_PARAMS[@]}" = 0 ]] ; then
|
||||
echo "${MYNAME}: Missing parameters, use --help for instructions."
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
MYNAME=`basename "$0"`
|
||||
parse_arguments "$@"
|
||||
|
||||
|
||||
export LC_ALL=C
|
||||
|
||||
# Warning! Ugly code ahead!
|
||||
# The code is so ugly that the comments explaining it are
|
||||
# bigger than the code itself!
|
||||
#
|
||||
# Suppose this:
|
||||
#
|
||||
# cmd_a | cmd_b &
|
||||
#
|
||||
# I need the PID of cmd_a. How can I get it?
|
||||
# In bash, $! will give me the PID of cmd_b.
|
||||
#
|
||||
# So, I came up with this ugly solution: open a subshell, like this:
|
||||
#
|
||||
# (
|
||||
# cmd_a &
|
||||
# echo "This is the PID I want $!"
|
||||
# wait
|
||||
# ) | cmd_b
|
||||
|
||||
|
||||
# Ignore Ctrl+C here.
|
||||
# If I don't do this, this shell script is killed before
|
||||
# ping and gawk can finish their work.
|
||||
trap '' 2
|
||||
|
||||
# Now the ugly code.
|
||||
(
|
||||
ping "${PING_PARAMS[@]}" &
|
||||
# Commented out, because it looks like this line is not needed
|
||||
#trap "kill -2 $! ; exit 1" 2 # Catch Ctrl+C here
|
||||
wait
|
||||
) 2>&1 | gawk '
|
||||
# Weird that awk does not come with abs(), so I need to implement it.
|
||||
function abs(x) {
|
||||
return ( (x < 0) ? -x : x )
|
||||
}
|
||||
|
||||
# Ditto for ceiling function.
|
||||
function ceil(x) {
|
||||
return (x == int(x)) ? x : int(x) + 1
|
||||
}
|
||||
|
||||
# Currently, this function is called once, at the beginning of this
|
||||
# script, but it is also possible to call this more than once, to
|
||||
# handle window size changes while this program is running.
|
||||
#
|
||||
# Local variables MUST be declared in argument list, else they are
|
||||
# seen as global. Ugly, but that is how awk works.
|
||||
function get_terminal_size(SIZE,SIZEA) {
|
||||
if( HAS_STTY ) {
|
||||
if( (STTY_CMD | getline SIZE) == 1 ) {
|
||||
split(SIZE, SIZEA, " ")
|
||||
LINES = SIZEA[1]
|
||||
COLUMNS = SIZEA[2]
|
||||
} else {
|
||||
HAS_STTY = 0
|
||||
}
|
||||
close(STTY_CMD)
|
||||
}
|
||||
if ( int('"${OVERRIDE_COLUMNS}"') ) { COLUMNS = int('"${OVERRIDE_COLUMNS}"') }
|
||||
if ( int('"${OVERRIDE_LINES}"') ) { LINES = int('"${OVERRIDE_LINES}"') }
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Functions related to cursor handling
|
||||
|
||||
# Function called whenever a non-dotted line is printed.
|
||||
#
|
||||
# It will move the cursor to the line next to the statistics and
|
||||
# restore the default color.
|
||||
function other_line_is_printed() {
|
||||
if( IS_PRINTING_DOTS ) {
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
printf( ESC_DEFAULT ESC_NEXTLINE ESC_NEXTLINE "\n" )
|
||||
} else {
|
||||
printf( ESC_DEFAULT "\n" )
|
||||
print_statistics_bar()
|
||||
}
|
||||
}
|
||||
IS_PRINTING_DOTS = 0
|
||||
CURR_COL = 0
|
||||
}
|
||||
|
||||
# Function called whenever a non-dotted line is repeated.
|
||||
function other_line_is_repeated() {
|
||||
if (other_line_times < 2) {
|
||||
return
|
||||
}
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
printf( ESC_DEFAULT ESC_ERASELINE "\r" )
|
||||
}
|
||||
printf( "Last message repeated %d times.", other_line_times )
|
||||
if( ! '"${IS_TERMINAL}"' ) {
|
||||
printf( "\n" )
|
||||
}
|
||||
}
|
||||
|
||||
# Prints the newlines required for the live statistics.
|
||||
#
|
||||
# I need to print some newlines and then return the cursor back to its position
|
||||
# to make sure the terminal will scroll.
|
||||
#
|
||||
# If the output is not a terminal, break lines on every LAST_N dots.
|
||||
function print_newlines_if_needed() {
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
# COLUMNS-1 because I want to avoid bugs with the cursor at the last column
|
||||
if( CURR_COL >= COLUMNS-1 ) {
|
||||
CURR_COL = 0
|
||||
}
|
||||
if( CURR_COL == 0 ) {
|
||||
if( IS_PRINTING_DOTS ) {
|
||||
printf( "\n" )
|
||||
}
|
||||
#printf( "\n" "\n" ESC_PREVLINE ESC_PREVLINE ESC_ERASELINE )
|
||||
printf( ESC_DEFAULT "\n" "\n" ESC_CURSORUP ESC_CURSORUP ESC_ERASELINE )
|
||||
}
|
||||
} else {
|
||||
if( CURR_COL >= LAST_N ) {
|
||||
CURR_COL = 0
|
||||
printf( ESC_DEFAULT "\n" )
|
||||
print_statistics_bar()
|
||||
}
|
||||
}
|
||||
CURR_COL++
|
||||
IS_PRINTING_DOTS = 1
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Functions related to the data structure of "Last N" statistics.
|
||||
|
||||
# Clears the data structure.
|
||||
function clear(d) {
|
||||
d["index"] = 0 # The next position to store a value
|
||||
d["size"] = 0 # The array size, goes up to LAST_N
|
||||
}
|
||||
|
||||
# This function stores the value to the passed data structure.
|
||||
# The data structure holds at most LAST_N values. When it is full,
|
||||
# a new value overwrite the oldest one.
|
||||
function store(d, value) {
|
||||
d[d["index"]] = value
|
||||
d["index"]++
|
||||
if( d["index"] >= d["size"] ) {
|
||||
if( d["size"] < LAST_N ) {
|
||||
d["size"]++
|
||||
} else {
|
||||
d["index"] = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Functions related to processing the received response
|
||||
|
||||
function process_rtt(rtt) {
|
||||
# Overall statistics
|
||||
last_rtt = rtt
|
||||
total_rtt += rtt
|
||||
if( last_seq == 0 ) {
|
||||
min_rtt = max_rtt = rtt
|
||||
} else {
|
||||
if( rtt < min_rtt ) min_rtt = rtt
|
||||
if( rtt > max_rtt ) max_rtt = rtt
|
||||
}
|
||||
|
||||
# "Last N" statistics
|
||||
store(lastn_rtt,rtt)
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Functions related to printing the fancy ping response
|
||||
|
||||
# block_index is just a local variable.
|
||||
function print_response_legend(i) {
|
||||
if( '"${USE_UNICODE}"' ) {
|
||||
printf( BLOCK[0] ESC_DEFAULT "%4d ", 0)
|
||||
for( i=1 ; i<BLOCK_LEN ; i++ ) {
|
||||
printf( BLOCK[i] ESC_DEFAULT "%4d ",
|
||||
BLOCK_RTT_MIN + ceil((i-1) * BLOCK_RTT_RANGE / (BLOCK_LEN - 2)) )
|
||||
}
|
||||
printf( "\n" )
|
||||
}
|
||||
|
||||
# Useful code for debugging.
|
||||
#for( i=0 ; i<=BLOCK_RTT_MAX ; i++ ) {
|
||||
# print_received_response(i)
|
||||
# printf( ESC_DEFAULT "%4d\n", i )
|
||||
#}
|
||||
}
|
||||
|
||||
# block_index is just a local variable.
|
||||
function print_received_response(rtt, block_index) {
|
||||
if( '"${USE_UNICODE}"' ) {
|
||||
if( rtt < BLOCK_RTT_MIN ) {
|
||||
block_index = 0
|
||||
} else if( rtt >= BLOCK_RTT_MAX ) {
|
||||
block_index = BLOCK_LEN - 1
|
||||
} else {
|
||||
block_index = 1 + int((rtt - BLOCK_RTT_MIN) * (BLOCK_LEN - 2) / BLOCK_RTT_RANGE)
|
||||
}
|
||||
printf( BLOCK[block_index] )
|
||||
} else {
|
||||
printf( ESC_GREEN "." )
|
||||
}
|
||||
}
|
||||
|
||||
function print_missing_response(rtt) {
|
||||
printf( ESC_RED "!" )
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Functions related to printing statistics
|
||||
|
||||
function print_overall() {
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
printf( "%2d/%3d (%2d%%) lost; %4.0f/" ESC_BOLD "%4.0f" ESC_DEFAULT "/%4.0fms; last: " ESC_BOLD "%4.0f" ESC_DEFAULT "ms",
|
||||
lost,
|
||||
lost+received,
|
||||
(lost*100/(lost+received)),
|
||||
min_rtt,
|
||||
(total_rtt/received),
|
||||
max_rtt,
|
||||
last_rtt )
|
||||
} else {
|
||||
printf( "%2d/%3d (%2d%%) lost; %4.0f/" ESC_BOLD "%4.0f" ESC_DEFAULT "/%4.0fms",
|
||||
lost,
|
||||
lost+received,
|
||||
(lost*100/(lost+received)),
|
||||
min_rtt,
|
||||
(total_rtt/received),
|
||||
max_rtt )
|
||||
}
|
||||
}
|
||||
|
||||
function print_last_n(i, sum, min, avg, max, diffs) {
|
||||
# Calculate and print the lost packets statistics
|
||||
sum = 0
|
||||
for( i=0 ; i<lastn_lost["size"] ; i++ ) {
|
||||
sum += lastn_lost[i]
|
||||
}
|
||||
printf( "%2d/%3d (%2d%%) lost; ",
|
||||
sum,
|
||||
lastn_lost["size"],
|
||||
sum*100/lastn_lost["size"] )
|
||||
|
||||
# Calculate the min/avg/max rtt times
|
||||
sum = diffs = 0
|
||||
min = max = lastn_rtt[0]
|
||||
for( i=0 ; i<lastn_rtt["size"] ; i++ ) {
|
||||
sum += lastn_rtt[i]
|
||||
if( lastn_rtt[i] < min ) min = lastn_rtt[i]
|
||||
if( lastn_rtt[i] > max ) max = lastn_rtt[i]
|
||||
}
|
||||
avg = sum/lastn_rtt["size"]
|
||||
|
||||
# Calculate mdev (mean absolute deviation)
|
||||
for( i=0 ; i<lastn_rtt["size"] ; i++ ) {
|
||||
diffs += abs(lastn_rtt[i] - avg)
|
||||
}
|
||||
diffs /= lastn_rtt["size"]
|
||||
|
||||
# Print the rtt statistics
|
||||
printf( "%4.0f/" ESC_BOLD "%4.0f" ESC_DEFAULT "/%4.0f/%4.0fms (last %d)",
|
||||
min,
|
||||
avg,
|
||||
max,
|
||||
diffs,
|
||||
lastn_rtt["size"] )
|
||||
}
|
||||
|
||||
function print_statistics_bar() {
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
printf( ESC_SAVEPOS ESC_DEFAULT )
|
||||
|
||||
printf( ESC_NEXTLINE ESC_ERASELINE )
|
||||
print_overall()
|
||||
printf( ESC_NEXTLINE ESC_ERASELINE )
|
||||
print_last_n()
|
||||
|
||||
printf( ESC_UNSAVEPOS )
|
||||
} else {
|
||||
print_overall()
|
||||
printf( "\n" )
|
||||
print_last_n()
|
||||
printf( "\n" )
|
||||
}
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Initializations
|
||||
BEGIN {
|
||||
# Easy way to get each value from ping output
|
||||
FS = "="
|
||||
|
||||
############################################################
|
||||
# General internal variables
|
||||
|
||||
# This is needed to keep track of lost packets
|
||||
last_seq = 0
|
||||
|
||||
# The previously printed non-ping-response line
|
||||
other_line = ""
|
||||
other_line_times = 0
|
||||
|
||||
# Variables to keep the screen clean
|
||||
IS_PRINTING_DOTS = 0
|
||||
CURR_COL = 0
|
||||
|
||||
############################################################
|
||||
# Variables related to "overall" statistics
|
||||
received = 0
|
||||
lost = 0
|
||||
total_rtt = 0
|
||||
min_rtt = 0
|
||||
max_rtt = 0
|
||||
last_rtt = 0
|
||||
|
||||
############################################################
|
||||
# Variables related to "last N" statistics
|
||||
LAST_N = int('"${LAST_N}"')
|
||||
|
||||
# Data structures for the "last N" statistics
|
||||
clear(lastn_lost)
|
||||
clear(lastn_rtt)
|
||||
|
||||
############################################################
|
||||
# Terminal height and width
|
||||
|
||||
# These are sane defaults, in case we cannot query the actual terminal size
|
||||
LINES = 24
|
||||
COLUMNS = 80
|
||||
|
||||
# Auto-detecting the terminal size
|
||||
HAS_STTY = 1
|
||||
STTY_CMD = "stty size --file=/dev/tty 2> /dev/null"
|
||||
get_terminal_size()
|
||||
if( '"${IS_TERMINAL}"' && COLUMNS <= 50 ) {
|
||||
print "Warning: terminal width is too small."
|
||||
}
|
||||
|
||||
############################################################
|
||||
# ANSI escape codes
|
||||
|
||||
# Color escape codes.
|
||||
# Fortunately, awk defaults any unassigned variable to an empty string.
|
||||
if( '"${USE_COLOR}"' ) {
|
||||
ESC_DEFAULT = "\033[0m"
|
||||
ESC_BOLD = "\033[1m"
|
||||
#ESC_BLACK = "\033[0;30m"
|
||||
#ESC_GRAY = "\033[1;30m"
|
||||
ESC_RED = "\033[0;31m"
|
||||
ESC_GREEN = "\033[0;32m"
|
||||
ESC_YELLOW = "\033[0;33m"
|
||||
ESC_BLUE = "\033[0;34m"
|
||||
ESC_MAGENTA = "\033[0;35m"
|
||||
ESC_CYAN = "\033[0;36m"
|
||||
ESC_WHITE = "\033[0;37m"
|
||||
ESC_YELLOW_ON_GREEN = "\033[42;33m"
|
||||
ESC_RED_ON_YELLOW = "\033[43;31m"
|
||||
}
|
||||
# Other escape codes, see:
|
||||
# http://en.wikipedia.org/wiki/ANSI_escape_code
|
||||
# http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
|
||||
ESC_NEXTLINE = "\n"
|
||||
ESC_CURSORUP = "\033[A"
|
||||
ESC_SCROLLUP = "\033[S"
|
||||
ESC_SCROLLDOWN = "\033[T"
|
||||
ESC_ERASELINE = "\033[2K"
|
||||
ESC_SAVEPOS = "\0337"
|
||||
ESC_UNSAVEPOS = "\0338"
|
||||
|
||||
# I am avoiding these escapes as they are not listed in:
|
||||
# http://vt100.net/docs/vt100-ug/chapter3.html
|
||||
#ESC_PREVLINE = "\033[F"
|
||||
#ESC_SAVEPOS = "\033[s"
|
||||
#ESC_UNSAVEPOS = "\033[u"
|
||||
|
||||
# I am avoiding this to improve compatibility with (older versions of) tmux
|
||||
#ESC_NEXTLINE = "\033[E"
|
||||
|
||||
############################################################
|
||||
# Unicode characters (based on https://github.com/holman/spark )
|
||||
if( '"${USE_UNICODE}"' ) {
|
||||
BLOCK[ 0] = ESC_GREEN "▁"
|
||||
BLOCK[ 1] = ESC_GREEN "▂"
|
||||
BLOCK[ 2] = ESC_GREEN "▃"
|
||||
BLOCK[ 3] = ESC_GREEN "▄"
|
||||
BLOCK[ 4] = ESC_GREEN "▅"
|
||||
BLOCK[ 5] = ESC_GREEN "▆"
|
||||
BLOCK[ 6] = ESC_GREEN "▇"
|
||||
BLOCK[ 7] = ESC_GREEN "█"
|
||||
BLOCK[ 8] = ESC_YELLOW_ON_GREEN "▁"
|
||||
BLOCK[ 9] = ESC_YELLOW_ON_GREEN "▂"
|
||||
BLOCK[10] = ESC_YELLOW_ON_GREEN "▃"
|
||||
BLOCK[11] = ESC_YELLOW_ON_GREEN "▄"
|
||||
BLOCK[12] = ESC_YELLOW_ON_GREEN "▅"
|
||||
BLOCK[13] = ESC_YELLOW_ON_GREEN "▆"
|
||||
BLOCK[14] = ESC_YELLOW_ON_GREEN "▇"
|
||||
BLOCK[15] = ESC_YELLOW_ON_GREEN "█"
|
||||
BLOCK[16] = ESC_RED_ON_YELLOW "▁"
|
||||
BLOCK[17] = ESC_RED_ON_YELLOW "▂"
|
||||
BLOCK[18] = ESC_RED_ON_YELLOW "▃"
|
||||
BLOCK[19] = ESC_RED_ON_YELLOW "▄"
|
||||
BLOCK[20] = ESC_RED_ON_YELLOW "▅"
|
||||
BLOCK[21] = ESC_RED_ON_YELLOW "▆"
|
||||
BLOCK[22] = ESC_RED_ON_YELLOW "▇"
|
||||
BLOCK[23] = ESC_RED_ON_YELLOW "█"
|
||||
if( '"${USE_MULTICOLOR}"' && '"${USE_COLOR}"' ) {
|
||||
# Multi-color version:
|
||||
BLOCK_LEN = 24
|
||||
BLOCK_RTT_MIN = 10
|
||||
BLOCK_RTT_MAX = 230
|
||||
} else {
|
||||
# Simple version:
|
||||
BLOCK_LEN = 8
|
||||
BLOCK_RTT_MIN = 25
|
||||
BLOCK_RTT_MAX = 175
|
||||
}
|
||||
|
||||
if( int('"${RTT_MIN}"') > 0 && int('"${RTT_MAX}"') > 0 ) {
|
||||
BLOCK_RTT_MIN = int('"${RTT_MIN}"')
|
||||
BLOCK_RTT_MAX = int('"${RTT_MAX}"')
|
||||
} else if( int('"${RTT_MIN}"') > 0 ) {
|
||||
BLOCK_RTT_MIN = int('"${RTT_MIN}"')
|
||||
BLOCK_RTT_MAX = BLOCK_RTT_MIN * (BLOCK_LEN - 1)
|
||||
} else if( int('"${RTT_MAX}"') > 0 ) {
|
||||
BLOCK_RTT_MAX = int('"${RTT_MAX}"')
|
||||
BLOCK_RTT_MIN = int(BLOCK_RTT_MAX / (BLOCK_LEN - 1))
|
||||
}
|
||||
|
||||
BLOCK_RTT_RANGE = BLOCK_RTT_MAX - BLOCK_RTT_MIN
|
||||
print_response_legend()
|
||||
}
|
||||
}
|
||||
|
||||
############################################################
|
||||
# Main loop
|
||||
{
|
||||
# Sample line:
|
||||
# 64 bytes from 8.8.8.8: icmp_seq=1 ttl=49 time=184 ms
|
||||
if( $0 ~ /^[0-9]+ bytes from .*: icmp_[rs]eq=[0-9]+ ttl=[0-9]+ time=[0-9.]+ *ms/ ) {
|
||||
if( other_line_times >= 2 ) {
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
printf( "\n" )
|
||||
} else {
|
||||
other_line_is_repeated()
|
||||
}
|
||||
}
|
||||
other_line = ""
|
||||
other_line_times = 0
|
||||
|
||||
# $1 = useless prefix string
|
||||
# $2 = icmp_seq
|
||||
# $3 = ttl
|
||||
# $4 = time
|
||||
|
||||
# This must be called before incrementing the last_seq variable!
|
||||
rtt = int($4)
|
||||
process_rtt(rtt)
|
||||
|
||||
seq = int($2)
|
||||
|
||||
while( last_seq < seq - 1 ) {
|
||||
# Lost a packet
|
||||
print_newlines_if_needed()
|
||||
print_missing_response()
|
||||
|
||||
last_seq++
|
||||
lost++
|
||||
store(lastn_lost, 1)
|
||||
}
|
||||
|
||||
# Received a packet
|
||||
print_newlines_if_needed()
|
||||
print_received_response(rtt)
|
||||
|
||||
last_seq++
|
||||
received++
|
||||
store(lastn_lost, 0)
|
||||
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
print_statistics_bar()
|
||||
}
|
||||
} else if ( $0 == "" ) {
|
||||
# Do nothing on blank lines.
|
||||
} else {
|
||||
other_line_is_printed()
|
||||
if ( $0 == other_line ) {
|
||||
other_line_times++
|
||||
if( '"${IS_TERMINAL}"' ) {
|
||||
other_line_is_repeated()
|
||||
}
|
||||
} else {
|
||||
other_line = $0
|
||||
other_line_times = 1
|
||||
printf( "%s\n", $0 )
|
||||
}
|
||||
}
|
||||
|
||||
# Not needed when the output is a terminal, but does not hurt either.
|
||||
fflush()
|
||||
}'
|
Loading…
Reference in New Issue