Creating a progress bar for BASH script exporting system log files

Question

Essentially for a set number of systems logs pulled and exported I need to indicate the scripts progress by printing a character "#". This should eventually create a progress bar with a width of 60. Something like what's presented below: ############################################# ,additionally I need the characters to build from left to right indicating the progression of the script.

The Question/Problem that this code was based off of goes as follows: "Use a separate invocation of wevtutil el to get the count of the number of logs and scale this to,say, a width of 60."

SYSNAM=$(hostname)
LOGDIR=${1:-/tmp/${SYSNAM}_logs}

i=0
LOGCOUNT=$( wevtutil el | wc -l )
x=$(( LOGCOUNT/60 ))

wevtutil el | while read ALOG
do
        ALOG="${ALOG%$'\r'}"
        printf "${ALOG}:\r"
        SAFNAM="${ALOG// /_}"
        SAFNAM="${SAFNAM//\//-}"
        wevtutil epl "$ALOG" "${SYSNAM}_${SAFNAM}.evtx"


done

I've attempted methods such as using echo -ne "#", and printf "#%0.s" however the issue that I encounter is that the "#" characters gets printed with each instance of the name of the log file being retrieved; also the pattern is printed vertically rather than horizontally.

LOGCOUNT=$( wevtutil el | wc -l )
x=$(( LOGCOUNT/60 ))

echo  -ne "["
for i in {1..60}
do
        if [[ $(( x*i )) != $LOGCOUNT ]]
        then
                echo -ne "#"
                #printf '#%0.s'
        fi

done
echo "]"
printf "\n"
echo "Transfer Complete."
echo "Total Log Files Transferred: $LOGCOUNT"

I tried previously integrating this code into the first block but no luck. But something tells me that I don't need to establish a whole new loop, I keep thinking that the first block of code only needs a few lines of modification. Anyhow sorry for the lengthy explanation, please let me know if anything additional is needed for assistance--Thank you.

Answer 1

For the sake of this answer I'm going to assume the desired output is a 2-liner that looks something like:

$ statbar
file: /bin/cygdbusmenu-qt5-2.dll
[########                            ]

The following may not work for everyone as it comes down to individual terminal attributes and how they can(not) be manipulated by tput (ie, ymmv) ...

For my sample script I'm going to loop through the contents of /bin, printing the name of each file as I process it, while updating the status bar with a new '#' after each 20 files:

• there are 719 files under my /bin so there should be 35 #'s in my status bar (I add an extra # at the end once processing has completed)
• we'll use a few tput commands to handle cursor/line movement, plus erasing previous output from a line
• for printing the status bar I've pre-calculated the number of #'s and then use 2 variables ... $barspace for spaces, $barhash for #'s; for each 20 files I strip a space off $barspace and add a single # to $barhash; by (re)printing these 2x variables every 20x files I get the appearance of a moving status bar

Putting this all together:

$ cat statbar
clear              # make sure we have plenty of room to display our status bar;
                   # if we're at the bottom of the console/window and we cause the
                   # windows to 'scroll up' then 'tput sc/rc' will not work

tput sc            # save pointer/reference to current terminal line
erase=$(tput el)   # save control code for 'erase (rest of) line'

# init some variables; get a count of the number of files so we can pre-calculate the total length of our status bar

modcount=20
filecount=$(find /bin -type f | wc -l)

# generate a string of filecount/20+1 spaces (35+1 for my particular /bin)

barspace=

for ((i=1; i<=(filecount/modcount+1); i++))
do
        barspace="${barspace} "
done

barhash=           # start with no #'s for this variable

filecount=0        # we'll re-use this variable to keep track of # of files processed so need to reset

while read -r filename
do
        filecount=$((filecount+1))

        tput rc    # return cursor to previously saved terminal line (tput sc)

        # print filename (1st line of output); if shorter than previous filename we need to erase rest of line

        printf "file: ${filename}${erase}\n"

        # print our status bar (2nd line of output) on the first and every ${modcount} pass through loop; 

        if   [ ${filecount} -eq 1 ]
        then
                printf "[${barhash}${barspace}]\n"

        elif [[ $((filecount % ${modcount} )) -eq 0 ]]
        then
                # for every ${modcount}th file we ...

                barspace=${barspace:1:100000}         # strip a space from barspace
                barhash="${barhash}#"                 # add a '#' to barhash
                printf "[${barhash}${barspace}]\n"    # print our new status bar
        fi

done < <(find /bin -type f | sort -V)

# finish up the status bar (should only be 1 space left to 'convert' to a '#')

tput rc

printf "file: -- DONE --\n"

if [ ${#barspace} -gt 0 ]
then
        barspace=${barspace:1:100000}
        barhash="${barhash}#"
fi

printf "[${barhash}${barspace}]\n"

NOTE: While testing I had to periodically reset my terminal in order for the tput commands to function properly, eg:

$ reset
$ statbar

I couldn't get the above to work on any of the (internet) fiddle sites (basically having problems getting tput to work with the web-based 'terminals').

Here's a gif displaying the behavior ...

NOTES:

• the script does print every filename to stdout but since this script isn't actually doing anything with the files in question a) the printfs occur quite rapidly and b) the video/gif only captures a (relatively) few fleeting images ("Duh, Mark!" ?)
• the last printf "file: -- DONE --\n" was added after I created the gif, and I'm being lazy by not generating and uploading a new gif