[SOLVED] Almost there just need a global progress bar

Question

Heya,
There's no man page for bar so I have looked at the code a bit. I am trying to have a progress bar to copy a folder with many files including symbolic links (unfortunately pycp does not support them yet). With the -s parameter, I can specify the approximate size of what I am copying but it works only if it is a single file.
I have also tried pv, pipemeter, orphan advcp, ecp, scp and I am now desperate.
Would someone be kind enough to help me ?
[tamikana@archlinux ~]$ cat /usr/bin/bar
#! /bin/sh
# bar
# 'cat' with ASCII progress bar
# (c) Henrik Theiling
BAR_VERSION=1.4
# Synopsis:
# 'bar' works just like 'cat', but shows a progress bar in ASCII art on stderr.
# The script's main function is meant to be usable in any Bourne shell to be
# suitable for install scripts without the need for any additional tool.
# Shell Script Usage: bar [options] [files]
# Options:
# -h displays help
# Examples:
# Normal pipe:
# : bar mypack.tar.bz2 | tar xjpf -
# Individual pipe for each file:
# : bar -c 'tar xjpf -' mypack1.tar.bz2 mypack2.tar.bz2
# Individual pipe, using ${bar_file} variable:
# : bar -c 'echo ${bar_file}: ; gzip -dc | tar tvf -' \
# : -e .tar.gz \
# : file1 file2 file3 file4 file5 \
# : > package-list.txt
# Programs and shell commands:
# Required (otherwise this fails):
# if, then, else, fi, expr, test, cat, eval, exec
# shell functions
# test:
# a = b
# a -lt b
# a -gt b
# a -le b
# -f a
# -n a
# -z a
# expr:
# a + b
# a - b
# a '*' b
# a / b
# a : b
# Optional (otherwise this does not show the bar):
# grep, dd, echo, ls, sed, cut
# ls:
# must output the file size at fifth position.
# The command line interface also uses:
# awk
####>-SCHNIPP-<########################################################
bar_cat()
# Use this shell function in your own install scripts.
# Options:
# Width of the bar (in ten characters). The default is 76 characters.
test -z "${BAR_WIDTH}" && test -n "${COLUMNS}" && BAR_WIDTH=${COLUMNS}
# Check syntax:
( expr "${BAR_WIDTH}" + 0 >/dev/null 2>&1 ) || BAR_WIDTH=0
BAR_WIDTH=`expr ${BAR_WIDTH} + 0` || BAR_WIDTH=0
test "x${BAR_WIDTH}" = x0 && BAR_WIDTH=76
# Maximal block size to use for dd.
test -n "${BAR_BS}" || BAR_BS=1048567
# BEGIN PERC
# Whether to show a percentage.
test -n "${BAR_PERC}" || BAR_PERC=1
# END PERC
# BEGIN ETA
# Whether to show estimated time of arrival (ETA).
test -n "${BAR_ETA}" || BAR_ETA=1
# END ETA
# Width of the trace display:
# BEGIN TRACE
test -n "${BAR_TRACE_WIDTH}" || BAR_TRACE_WIDTH=10
# END TRACE
# The command to execute for every given file. Each file
# is piped into this command individually. By default, the
# files are simply dumped to stdout.
test -n "${BAR_CMD}" || BAR_CMD=cat
# The characters to be used in the bar
test -n "${BAR_L}" || BAR_L='['
test -n "${BAR_R}" || BAR_R=']'
test -n "${BAR_C0}" || BAR_C0='.'
test -n "${BAR_C1}" || BAR_C1='='
# Additional extension to add to each file:
#BAR_EXT=${BAR_EXT-}
# Whether to clear bar after termination. Otherwise keep the full bar.
#BAR_CLEAR=${BAR_CLEAR-0}
# Unless switched off by user, use the bar by default:
test -n "${BAR_OK}" || BAR_OK=1
BAR_WIDTH=`expr ${BAR_WIDTH} - 3`
bar_trace=''
# BEGIN TRACE
if test "x${BAR_TRACE}" = x1
then
BAR_WIDTH=`expr ${BAR_WIDTH} - ${BAR_TRACE_WIDTH}`
bar_lauf=${BAR_TRACE_WIDTH}
bar_t_space=''
bar_t_dot=''
while test "${bar_lauf}" -gt 1
do
bar_t_space="${bar_t_space} "
bar_t_dot="${bar_t_dot}."
bar_lauf=`expr ${bar_lauf} - 1`
done
bar_trace="${bar_t_space} "
fi
# END TRACE
bar_eta=''
BAR_GET_TIME='echo'
# BEGIN ETA
( expr 1 + ${SECONDS} >/dev/null 2>&1 ) || BAR_ETA=0
if test "x${BAR_ETA}" = x1
then
BAR_GET_TIME='( echo ${SECONDS} )'
BAR_WIDTH=`expr ${BAR_WIDTH} - 6`
bar_eta='--:-- '
fi
# END ETA
bar_perc=''
# BEGIN PERC
if test "x${BAR_PERC}" = x1
then
BAR_WIDTH=`expr ${BAR_WIDTH} - 5`
bar_perc=' 0% '
fi
# END PERC
BAR_GET_SIZE='( ls -l "${BAR_DIR}${bar_file}${BAR_EXT}" | sed "s@ *@ @g" | cut -d " " -f 5 ) 2>/dev/null'
# portable?
# check features:
( ( echo a ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | dd bs=2 count=2 ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | grep a ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | sed 's@ *@ @g' ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | cut -d ' ' -f 1 ) >/dev/null 2>&1 ) || BAR_OK=0
# check ranges:
test "${BAR_WIDTH}" -ge 4 || BAR_OK=0
BAR_ECHO='echo'
BAR_E_C1=''
BAR_E_C2=''
BAR_E_NL='echo'
# Does echo accept -n without signalling an error?
if echo -n abc >/dev/null 2>&1
then
BAR_E_C1='-n'
fi
# Check how to print a line without newline:
if ( ( ${BAR_ECHO} "${BAR_E_C1}" abc ; echo 1,2,3 ) | grep n ) >/dev/null 2>&1
then
# Try echo \c:
if ( ( ${BAR_ECHO} 'xyz\c' ; echo 1,2,3 ) | grep c ) >/dev/null 2>&1
then
# Try printf:
if ( ( printf 'ab%s' c ; echo 1,2,3 ) | grep abc ) >/dev/null 2>&1
then
BAR_ECHO='printf'
BAR_E_C1='%s'
else
BAR_ECHO=':'
BAR_E_C1=''
BAR_E_NL=':'
BAR_OK=0
fi
else
BAR_E_C1=''
BAR_E_C2='\c'
fi
fi
# prepare initial bar:
bar_shown=0
if test "${BAR_OK}" = 1
then
bar_lauf=0
bar_graph=''
while test `expr ${bar_lauf} + 5` -le "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C0}${BAR_C0}${BAR_C0}${BAR_C0}${BAR_C0}"
bar_lauf=`expr ${bar_lauf} + 5`
done
while test "${bar_lauf}" -lt "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C0}"
bar_lauf=`expr ${bar_lauf} + 1`
done
${BAR_E_C2}" 1>&2_eta}${bar_perc}${BAR_L}${bar_graph}${BAR_R}
bar_shown=1
fi
# for shifting large numbers so that expr can handle them:
# Assume we can compute up to 2147483647, thus 9 arbitrary digits.
# We must be able to do + of two numbers of 9 digits length. Ok.
# BEGIN LARGE
( ( test 1999999998 = `expr 999999999 + 999999999` ) >/dev/null 2>&1 ) || BAR_OK=0
bar_large_num="........."
bar_div=""
# END LARGE
bar_numsuff=""
# find size:
bar_size=0
if test -n "${BAR_SIZE}"
then
bar_size=${BAR_SIZE}
# BEGIN LARGE
while expr "${bar_size}" : "${bar_large_num}" >/dev/null 2>&1
do
bar_div="${bar_div}."
bar_numsuff="${bar_numsuff}0"
bar_size=`expr "${bar_size}" : '\(.*\).$'`
done
# END LARGE
BAR_GET_SIZE="echo '${BAR_SIZE}'"
else
for bar_file
do
bar_size1=0
if test -f "${BAR_DIR}${bar_file}${BAR_EXT}"
then
bar_size1=`eval "${BAR_GET_SIZE}"`
# BEGIN LARGE
# divide and upround by pattern matching:
if test -n "${bar_div}"
then
bar_size1=`expr "${bar_size1}" : '\(.*\)'${bar_div}'$'` || bar_size1=0
fi
# adjust if still too large:
while expr "${bar_size1}" : "${bar_large_num}" >/dev/null 2>&1
do
bar_div="${bar_div}."
bar_numsuff="${bar_numsuff}0"
bar_size1=`expr "${bar_size1}" : '\(.*\).$'`
bar_size=`expr "${bar_size}" : '\(.*\).$'` || bar_size=0
done
# upround if necessary:
if test -n "${bar_div}"
then
bar_size1=`expr "${bar_size1}" + 1`
fi
# END LARGE
# add to total size:
bar_size=`expr ${bar_size} + ${bar_size1}`
# BEGIN LARGE
# adjust if still too large:
while expr "${bar_size}" : "${bar_large_num}" >/dev/null 2>&1
do
bar_div="${bar_div}."
bar_numsuff="${bar_numsuff}0"
bar_size=`expr "${bar_size}" : '\(.*\).$'`
done
# END LARGE
else
BAR_OK=0
fi
done
fi
bar_quad=`expr ${BAR_WIDTH} '*' ${BAR_WIDTH}`
test "${bar_size}" -gt "${bar_quad}" || BAR_OK=0
if test "${BAR_OK}" = 0
then
# For some reason, we cannot display the bar. Thus plain operation:
for bar_file
do
if test "${bar_file}" = "/dev/stdin"
then
eval "${BAR_CMD}"
else
eval "${BAR_CMD}" < "${BAR_DIR}${bar_file}${BAR_EXT}"
fi
done
else
# Compute wanted bytes per step:
bar_want_bps=`expr ${bar_size} + ${BAR_WIDTH}`
bar_want_bps=`expr ${bar_want_bps} - 1`
bar_want_bps=`expr ${bar_want_bps} / ${BAR_WIDTH}`
# Compute block count per step to keep within maximum block size:
bar_count=1
if test "${bar_want_bps}" -gt "${BAR_BS}"
then
bar_count=`expr ${bar_want_bps} + ${BAR_BS}`
bar_count=`expr ${bar_count} - 1`
bar_count=`expr ${bar_count} / ${BAR_BS}`
fi
# Compute block size for given count:
bar_wc=`expr ${BAR_WIDTH} '*' ${bar_count}`
bar_bs=`expr ${bar_size} + ${bar_wc}`
bar_bs=`expr ${bar_bs} - 1`
bar_bs=`expr ${bar_bs} / ${bar_wc}`
# Compute bs * count, the bytes per step:
bar_bps=`expr ${bar_bs} '*' ${bar_count}`
# Compute bytes per hundredth:
bar_bph=`expr ${bar_size} + 99`
bar_bph=`expr ${bar_bph} / 100`
# Run loop:
bar_pos=0
bar_graph="${BAR_L}"
bar_cur_char=0
bar_t0=`eval "${BAR_GET_TIME}" 2>/dev/null` || bar_t0=0
for bar_file
do
# BEGIN TRACE
if test "x${BAR_TRACE}" = x1
then
bar_trace=`expr "${bar_file}" : '.*/\([^/][^/]*\)$'` || bar_trace="${bar_file}"
bar_trace=`expr "${bar_trace}${bar_t_space}" : '\('${bar_t_dot}'\)'`
bar_trace="${bar_trace} "
fi
# END TRACE
# Initial character position in bar for file:
bar_char=`expr ${bar_pos} / ${bar_want_bps}` || bar_char=0
while test "${bar_char}" -gt `expr ${bar_cur_char} + 4`
do
bar_graph="${bar_graph}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}"
bar_cur_char=`expr ${bar_cur_char} + 5`
done
while test "${bar_char}" -gt "${bar_cur_char}"
do
bar_graph="${bar_graph}${BAR_C1}"
bar_cur_char=`expr ${bar_cur_char} + 1`
done
# Get file size. This must work now (we checked with test -f before).
bar_size1=`eval "${BAR_GET_SIZE}" 2>/dev/null` || bar_size1=0
# BEGIN LARGE
# Divide and upround by pattern matching:
if test -n "${bar_div}"
then
bar_size1=`expr "${bar_size1}" : '\(.*\)'${bar_div}'$'` || bar_size1=0
bar_size1=`expr "${bar_size1}" + 1`
fi
# END LARGE
# loop:
bar_total=0
exec 6>&1
exec 5<"${BAR_DIR}${bar_file}${BAR_EXT}"
while test "${bar_total}" -lt "${bar_size1}"
do
dd bs="${bar_bs}" count="${bar_count}${bar_numsuff}" <&5 >&6 2>/dev/null
bar_total=`expr ${bar_total} + ${bar_bps}`
if test "${bar_total}" -gt "${bar_size1}"
then
bar_total="${bar_size1}"
fi
bar_pos1=`expr ${bar_pos} + ${bar_total}`
bar_proz=`expr ${bar_pos1} / ${bar_bph}` || bar_proz=0
# BEGIN PERC
if test "x${BAR_PERC}" = x1
then
bar_perc=" ${bar_proz}% "
bar_perc=`expr "${bar_perc}" : '.*\(.....\)$'`
fi
# END PERC
# BEGIN ETA
if test "x${BAR_ETA}" = x1
then
bar_diff=`eval "${BAR_GET_TIME}" 2>/dev/null` || bar_diff=0
bar_diff=`expr ${bar_diff} - ${bar_t0} 2>/dev/null` || bar_diff=0
bar_100p=`expr 100 - ${bar_proz}` || bar_100p=0
bar_diff=`expr ${bar_diff} '*' ${bar_100p}` || bar_diff=0
bar_diff=`expr ${bar_diff} + ${bar_proz}` || bar_diff=0
bar_diff=`expr ${bar_diff} - 1` || bar_diff=0
bar_diff=`expr ${bar_diff} / ${bar_proz} 2>/dev/null` || bar_diff=0
if test "${bar_diff}" -gt 0
then
bar_t_unit=":"
if test "${bar_diff}" -gt 2700
then
bar_t_uni="h"
bar_diff=`expr ${bar_diff} / 60`
fi
bar_diff_h=`expr ${bar_diff} / 60` || bar_diff_h=0
if test "${bar_diff_h}" -gt 99
then
bar_eta=" ${bar_diff_h}${bar_t_unit} "
else
bar_diff_hi=`expr ${bar_diff_h} '*' 60` || bar_diff_hi=0
bar_diff=`expr ${bar_diff} - ${bar_diff_hi}` || bar_diff=0
bar_diff=`expr "00${bar_diff}" : '.*\(..\)$'`
bar_eta=" ${bar_diff_h}${bar_t_unit}${bar_diff} "
fi
bar_eta=`expr "${bar_eta}" : '.*\(......\)$'`
fi
fi
# END ETA
bar_char=`expr ${bar_pos1} / ${bar_want_bps}` || bar_char=0
while test "${bar_char}" -gt "${bar_cur_char}"
do
bar_graph="${bar_graph}${BAR_C1}"
${bar_trace}${bar_eta}${bar_perc}${bar_graph}${BAR_E_C2}" 1>&2
bar_cur_char=`expr ${bar_cur_char} + 1`
done
done
) | eval "${BAR_CMD}"
bar_pos=`expr ${bar_pos} + ${bar_size1}`
done
# ${BAR_ECHO} "${BAR_E_C1}" "${BAR_R}${BAR_E_C2}" 1>&2
fi
if test "${bar_shown}" = 1
then
# BEGIN TRACE
test "x${BAR_TRACE}" = x1 && bar_trace="${bar_t_space} "
# END TRACE
# BEGIN ETA
test "x${BAR_ETA}" = x1 && bar_eta=' '
# END ETA
if test "x${BAR_CLEAR}" = x1
then
# BEGIN PERC
test "x${BAR_PERC}" = x1 && bar_perc=' '
# END PERC
bar_lauf=0
bar_graph=''
while test `expr ${bar_lauf} + 5` -le "${BAR_WIDTH}"
do
bar_graph="${bar_graph} "
bar_lauf=`expr ${bar_lauf} + 5`
done
while test "${bar_lauf}" -lt "${BAR_WIDTH}"
do
bar_graph="${bar_graph} "
bar_lauf=`expr ${bar_lauf} + 1`
done
${BAR_E_C2}" 1>&2_eta}${bar_perc} ${bar_graph}
else
# BEGIN PERC
test "x${BAR_PERC}" = x1 && bar_perc='100% '
# END PERC
bar_lauf=0
bar_graph=''
while test `expr ${bar_lauf} + 5` -le "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}"
bar_lauf=`expr ${bar_lauf} + 5`
done
while test "${bar_lauf}" -lt "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C1}"
bar_lauf=`expr ${bar_lauf} + 1`
done
${bar_trace}${bar_eta}${bar_perc}${BAR_L}${bar_graph}${BAR_R}${BAR_E_C2}" 1>&2
${BAR_E_NL} 1>&2
fi
fi
####>-SCHNAPP-<########################################################
BAR_AWK_0=''
# Command line interface:
while test -n "$1"
do
case "$1" in
-o|-c|-w|-0|-1|-e|-d|-b|-s|-\[\]|-\[|-\]|-T)
if test -z "$2"
then
echo "$0: Error: A non-empty argument was expected after $1" 1>&2
fi
BAR_ARG="$1"
BAR_OPT="$2"
shift
shift
-o*|-c*|-w*|-0*|-1*|-e*|-d*|-b*|-T*)
BAR_ARG=`expr "$1" : '\(-.\)'`
BAR_OPT=`expr "$1" : '-.\(.*\)$'`
shift
-h|-n|-p|-D|-D-|-q|-V|-t|-E|-L)
BAR_ARG="$1"
BAR_OPT=""
shift
--) shift
break
-*) echo "$0: Error: Unrecognized option: $1" 1>&2
exit 1
break
esac
case "${BAR_ARG}" in
-h) echo 'Usage: bar [-n] [-p] [-q] [-o FILE] [-c CMD] [-s SIZE] [-b SIZE]'
echo ' [-w WIDTH] [-0/1/[/] CHAR] [-d DIR] [-e EXT] [Files]'
echo ' bar -V'
echo ' bar -D'
echo ' bar -D-'
echo 'Options:'
echo ' -h displays help'
echo ' -o FILE sets output file'
echo ' -c CMD sets individual execution command'
echo ' -e EXT append an extension to each file'
echo ' -d DIR prepend this prefix to each file (a directory must end in /)'
echo ' -s SIZE expected number of bytes. Use for pipes. This is a hint'
echo ' only that must be greater or equal to the amount actually'
echo ' processed. Further, this only works for single files.'
echo ' -b SIZE maximal block size (bytes) (default: 1048567)'
echo ' -w WIDTH width in characters (default: terminal width-3 or 76)'
echo ' -0 CHAR character for empty bar (default: .)'
echo ' -1 CHAR character for full bar (default: =)'
echo ' -[ CHAR first character of bar (default: [)'
echo ' -] CHAR last character of bar (default: ])'
echo ' -n clears bar after termination'
echo ' -t traces (=displays) which file is processed'
echo ' -T WIDTH no of characters reserved for the file display of -t'
echo ' -p hides percentage'
echo ' -E hides estimated time display'
echo ' -q hides the whole bar, be quiet'
echo ' -D tries to dump the bar_cat() shell function, then exit.'
echo ' Here, -t, -p, -E remove the corresponding feature completely.'
echo ' Further, -L removes large file support from the code.'
echo ' -D- same as -D, but dumps the function body only'
echo ' -V displays version number'
echo ' -- end of options: only file names follow'
exit 0
-n) BAR_CLEAR=1
-L) BAR_LARGE=0
BAR_AWK_0="${BAR_AWK_0} /END *LARGE/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *LARGE/ {x=0} ;"
-t) BAR_TRACE=1
BAR_AWK_0="${BAR_AWK_0} /END *TRACE/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *TRACE/ {x=0} ;"
-T) BAR_TRACE_WIDTH="${BAR_OPT}"
-q) BAR_OK=0
-p) BAR_PERC=0
BAR_AWK_0="${BAR_AWK_0} /END *PERC/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *PERC/ {x=0} ;"
-E) BAR_ETA=0
BAR_AWK_0="${BAR_AWK_0} /END *ETA/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *ETA/ {x=0} ;"
-V) echo "bar v${BAR_VERSION}"
exit 0
-D) echo "BAR_VERSION=${BAR_VERSION}"
awk "${BAR_AWK_0}"'{sub(/ *#.*$/,"")} ; /^bar_cat/ {x=1} ; {sub(/^ */,"")} ; /./ {if(x)print} ; /^}/ {x=0}' "$0"
exit 0
-D-) echo "BAR_VERSION=${BAR_VERSION}"
awk "${BAR_AWK_0}"'{sub(/ *#.*$/,"")} ; /^}/ {x=0} ; {sub(/^ */,"")} ; /./ {if(x)print} ; /^{/ {x=1}' "$0"
exit 0
-o) exec 1>"${BAR_OPT}"
-c) BAR_CMD="${BAR_OPT}"
-b) BAR_BS="${BAR_OPT}"
if BAR_RAW=`expr "${BAR_BS}" : '\(.*\)k$'`
then
BAR_BS=`expr ${BAR_RAW} '*' 1024`
elif BAR_RAW=`expr "${BAR_BS}" : '\(.*\)M$'`
then
BAR_BS=`expr ${BAR_RAW} '*' 1048567`
fi
-s) BAR_SIZE="${BAR_OPT}"
if BAR_RAW=`expr "${BAR_SIZE}" : '\(.*\)k$'`
then
BAR_SIZE=`expr ${BAR_RAW} '*' 1024`
elif BAR_RAW=`expr "${BAR_SIZE}" : '\(.*\)M$'`
then
BAR_SIZE=`expr ${BAR_RAW} '*' 1048567`
fi
if test "$#" -gt 1
then
echo "Error: -s cannot be specified for multiple input files." 1>&2
exit 1
fi
-e) BAR_EXT="${BAR_OPT}"
-d) BAR_DIR="${BAR_OPT}"
-0) BAR_C0="${BAR_OPT}"
-1) BAR_C1="${BAR_OPT}"
-\[) BAR_L="${BAR_OPT}"
-\]) BAR_R="${BAR_OPT}"
BAR_L="${BAR_OPT}"
BAR_R="${BAR_OPT}"
-w) BAR_WIDTH="${BAR_OPT}"
esac
done
# Invoke main function:
if test "$#" = 0
then
bar_cat /dev/stdin
else
bar_cat "$@"
fi
EDIT: solved https://bbs.archlinux.org/viewtopic.php … 85#p498885
It seems like I have not tried every potential packages after all
Last edited by tamikana (2011-10-30 16:04:46)

Answer 1

This might help http://www.dwcourse.com/dreamweaver/ten-commandments-spry-menubars.php#one
Also, if you use DW CS5 click on Live Code and Live View. Then when clicking on the menu items in Live View, watch the changes in classes that occur. This mifgt give you a clue of what to do.
Cheers,
Gramps