Usar BASH para mostrar un indicador de progreso(trabajo)

shell unix

Question

Usando un script bash only, ¿cómo puedes proporcionar un indicador de progreso bash?

Entonces puedo ejecutar un comando de forma bash, y mientras se está ejecutando ese comando, que el usuario sepa que algo está sucediendo.

Answer 1

@ Los comentarios de DavidD sobre la respuesta de Pez Cuckows, este es un ejemplo de cómo se puede capturar el resultado de la barra de progreso en un script y aún ver el control giratorio en la pantalla:

#!/usr/bin/env bash
#############################################################################
###########################################################################
###
### Modified/Rewritten by A.M.Danischewski (c) 2015 v1.1
### Issues: If you find any issues emai1 me at my <first name> dot
### <my last name> at gmail dot com.
###
### Based on scripts posted by Pez Cuckow, William Pursell at:
### http://stackoverflow.com/questions/12498304/using-bash-to-display-/
### a-progress-working-indicator
###
### This program runs a program passed in and outputs a timing of the
### command and it exec''s a new fd for stdout so you can assign a
### variable the output of what was being run.
###
### This is a very new rough draft but could be expanded.
###
### This program is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### This program is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with this program. If not, see <http://www.gnu.org/licenses/>.
###########################################################################
#############################################################################
declare CMD="${1}"
shift ## Clip the first value of the $@, the rest are the options.
declare CMD_OPTIONS="$@"
declare CMD_OUTPUT=""
declare TMP_OUTPUT="/tmp/_${0##*/}_$$_$(date +%Y%m%d%H%M%S%N)"
declare -r SPIN_DELAY="0.1"
declare -i PID=
function usage() {
cat <<EOF
Description: ${0##*/}
This program runs a program passed in and outputs a timing of the
command and it exec''s a new fd for stdout so you can assign a variable
the output of what was being run.
Usage: ${0##*/} <command> [command options]
E.g.
>$ ${0##*/} sleep 5 /&/& echo "hello" /| figlet
Running: sleep 5 && echo hello | figlet, PID 2587:/
real 0m5.003s
user 0m0.000s
sys 0m0.002s
_ _ _
| |__ ___| | | ___
| ''_ / / _ / | |/ _ /
| | | | __/ | | (_) |
|_| |_|/___|_|_|/___/
Done..
>$ var=/$(${0##*/} sleep 5 /&/& echo hi)
Running: sleep 5 && echo hi, PID 32229:-
real 0m5.003s
user 0m0.000s
sys 0m0.001s
Done..
>$ echo /$var
hi
EOF
}
function spin_wait() {
local -a spin
spin[0]="-"
spin[1]="//"
spin[2]="|"
spin[3]="/"
echo -en "Running: ${CMD} ${CMD_OPTIONS}, PID ${PID}: " >&3
while kill -0 ${PID} 2>/dev/random; do
for i in "${spin[@]}"; do
echo -ne "/b$i" >&3
sleep ${SPIN_DELAY}
done
done
}
function run_cmd() {
exec 3>$(tty)
eval "time ${CMD} ${CMD_OPTIONS}" 2>>"${TMP_OUTPUT}" | tee "${TMP_OUTPUT}" &
PID=$! # Set global PID to process id of the command we just ran.
spin_wait
echo -en "/n$(< "${TMP_OUTPUT}")/n" >&3
echo -en "Done../n" >&3
rm "${TMP_OUTPUT}"
exec 3>&-
}
if [[ -z "${CMD}" || "${CMD}" =~ ^-. ]]; then
usage | more && exit 0
else
run_cmd
fi
exit 0

Answer 2

A partir de here se hace referencia a una buena función de centrifugado (con una ligera modificación), que también ayudará al cursor a permanecer en la posición original.

spinner()
{
local pid=$!
local delay=0.75
local spinstr=''|/-/'
while [ "$(ps a | awk ''{print $1}'' | grep $pid)" ]; do
local temp=${spinstr#?}
printf " [%c] " "$spinstr"
local spinstr=$temp${spinstr%"$temp"}
sleep $delay
printf "/b/b/b/b/b/b"
done
printf " /b/b/b/b"
}

con uso:

(a_long_running_task) &
spinner

Answer 3

Aparte del spinner clásico, puedes usar esta barra de progreso

Logra precisión de subcaracter utilizando caracteres de medio bloque

Código incluido en el enlace.

Answer 4

Aquí está mi intento. Soy nuevo en los scripts bash, así que parte de este código puede ser terrible :)

Ejemplo de salida:

El código:

progressBarWidth=20
# Function to draw progress bar
progressBar () {
# Calculate number of fill/empty slots in the bar
progress=$(echo "$progressBarWidth/$taskCount*$tasksDone" | bc -l)
fill=$(printf "%.0f/n" $progress)
if [ $fill -gt $progressBarWidth ]; then
fill=$progressBarWidth
fi
empty=$(($fill-$progressBarWidth))
# Percentage Calculation
percent=$(echo "100/$taskCount*$tasksDone" | bc -l)
percent=$(printf "%0.2f/n" $percent)
if [ $(echo "$percent>100" | bc) -gt 0 ]; then
percent="100.00"
fi
# Output to screen
printf "/r["
printf "%${fill}s" '''' | tr '' '' ▉
printf "%${empty}s" '''' | tr '' '' ░
printf "] $percent%% - $text "
}
## Collect task count
taskCount=33
tasksDone=0
while [ $tasksDone -le $taskCount ]; do
# Do your task
(( tasksDone += 1 ))
# Add some friendly output
text=$(echo "somefile-$tasksDone.dat")
# Draw the progress bar
progressBar $taskCount $taskDone $text
sleep 0.01
done
echo

Puede ver la fuente aquí: https://gist.github.com/F1LT3R/fa7f102b08a514f2c535

Answer 5

Aquí hay un ejemplo de un "indicador de actividad" para una prueba de velocidad de conexión a Internet a través del comando linux "speedtest-cli":

printf ''/n/tInternet speed test: ''
# http://.com/questions/12498304/using-bash-to-display-a-progress-working-indicator
spin[0]="-"
spin[1]="//"
spin[2]="|"
spin[3]="/"
# http://.com/questions/20165057/executing-bash-loop-while-command-is-running
speedtest > .st.txt & ## & : continue running script
pid=$! ## PID of last command
# If this script is killed, kill ''speedtest'':
trap "kill $pid 2> /dev/null" EXIT
# While ''speedtest'' is running:
while kill -0 $pid 2> /dev/null; do
for i in "${spin[@]}"
do
echo -ne "/b$i"
sleep 0.1
done
done
# Disable the trap on a normal exit:
trap - EXIT
printf "/n/t "
grep Download: .st.txt
printf "/t "
grep Upload: .st.txt
echo ''''
rm -f st.txt

Actualización - ejemplo:

Answer 6

Aquí un simple onliner, que uso:

while true; do for X in ''-'' ''/'' ''|'' ''/'; do echo -en "/b$X"; sleep 0.1; done; done

Answer 7

Barra de progreso psicodélica para scripts de bash. Llamar por línea de comando como ''./progressbar xy'' donde ''x'' es un tiempo en segundos e ''y'' es un mensaje para mostrar. La función interna progressbar () también funciona de forma independiente y toma ''x'' como un porcentaje e ''y'' como un mensaje.

#!/bin/bash
if [ "$#" -eq 0 ]; then echo "x is /"time in seconds/" and z is /"message/""; echo "Usage: progressbar x z"; exit; fi
progressbar() {
local loca=$1; local loca2=$2;
declare -a bgcolors; declare -a fgcolors;
for i in {40..46} {100..106}; do
bgcolors+=("$i")
done
for i in {30..36} {90..96}; do
fgcolors+=("$i")
done
local u=$(( 50 - loca ));
local y; local t;
local z; z=$(printf ''%*s'' "$u");
local w=$(( loca * 2 ));
local bouncer=".oO°Oo.";
for ((i=0;i<loca;i++)); do
t="${bouncer:((i%${#bouncer})):1}"
bgcolor="//E[${bgcolors[RANDOM % 14]}m //033[m"
y+="$bgcolor";
done
fgcolor="//E[${fgcolors[RANDOM % 14]}m"
echo -ne " $fgcolor$t$y$z$fgcolor$t //E[96m(//E[36m$w%//E[96m)//E[92m $fgcolor$loca2//033[m/r"
};
timeprogress() {
local loca="$1"; local loca2="$2";
loca=$(bc -l <<< scale=2/;"$loca/50")
for i in {1..50}; do
progressbar "$i" "$loca2";
sleep "$loca";
done
echo -e "/n"
};
timeprogress "$1" "$2"

Answer 8

En este ejemplo usando SCP, estoy demostrando cómo agarrar el id del proceso (pid) y luego hacer algo mientras el proceso se está ejecutando.

Esto muestra un icono de spinnng simple.

/usr/bin/scp [email protected]:file somewhere 2>/dev/null &
pid=$! # Process Id of the previous running command
spin[0]="-"
spin[1]="//"
spin[2]="|"
spin[3]="/"
echo -n "[copying] ${spin[0]}"
while [ kill -0 $pid ]
do
for i in "${spin[@]}"
do
echo -ne "/b$i"
sleep 0.1
done
done

La solución de William Pursell

/usr/bin/scp [email protected]:file somewhere 2>/dev/null &
pid=$! # Process Id of the previous running command
spin=''-/|/''
i=0
while kill -0 $pid 2>/dev/null
do
i=$(( (i+1) %4 ))
printf "/r${spin:$i:1}"
sleep .1
done

Answer 9

Extendí la respuesta de de en su respuesta al mostrar un mensaje de información variable después de la flecha giratoria:

#!/usr/bin/env bash
function spinner() {
local info="$1"
local pid=$!
local delay=0.75
local spinstr=''|/-/'
while kill -0 $pid 2> /dev/null; do
local temp=${spinstr#?}
printf " [%c] $info" "$spinstr"
local spinstr=$temp${spinstr%"$temp"}
sleep $delay
local reset="/b/b/b/b/b/b"
for ((i=1; i<=$(echo $info | wc -c); i++)); do
reset+="/b"
done
printf $reset
done
printf " /b/b/b/b"
}
# usage:
(a_long_running_task) &
spinner "performing long running task..."

No me gusta que si la salida stdout con un spinner se redirige a un archivo, less muestra ^H para cada retroceso en lugar de evitarlos en una salida de archivo. ¿Es posible con un spinner fácil como este?

Answer 10

Si tiene una forma de estimar el porcentaje realizado, como la cantidad actual de archivos procesados ​​y el número total, puede hacer un medidor de progreso lineal simple con un poco de matemática y suposiciones sobre el ancho de la pantalla.

count=0
total=34
pstr="[=======================================================================]"
while [ $count -lt $total ]; do
sleep 0.5 # this is work
count=$(( $count + 1 ))
pd=$(( $count * 73 / $total ))
printf "/r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
done

O en lugar de un medidor lineal, puedes calcular el tiempo restante. Es tan preciso como otras cosas similares.

count=0
total=34
start=`date +%s`
while [ $count -lt $total ]; do
sleep 0.5 # this is work
cur=`date +%s`
count=$(( $count + 1 ))
pd=$(( $count * 73 / $total ))
runtime=$(( $cur-$start ))
estremain=$(( ($runtime * $total / $count)-$runtime ))
printf "/r%d.%d%% complete ($count of $total) - est %d:%0.2d remaining/e[K" $(( $count*100/$total )) $(( ($count*1000/$total)%10)) $(( $estremain/60 )) $(( $estremain%60 ))
done
printf "/ndone/n"

Answer 11

Esta es una técnica bastante fácil:
(simplemente reemplace sleep 20 con el comando que quiera indicar que se está ejecutando)

#!/bin/bash
sleep 20 & PID=$! #simulate a long process
echo "THIS MAY TAKE A WHILE, PLEASE BE PATIENT WHILE ______ IS RUNNING..."
printf "["
# While process is running...
while kill -0 $PID 2> /dev/null; do
printf "▓"
sleep 1
done
printf "] done!"

La salida se ve así:

> THIS MAY TAKE A WHILE, PLEASE BE PATIENT WHILE ______ IS RUNNING...
> [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓] done!

Agrega un ▓ (densidad alta punteada) cada segundo hasta que el proceso se completa.