es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Lógica de script bash para iterar a través de 24 elementos de 6 en 6, esperando a que esas tareas se completen y luego hacer los siguientes 6 elementos hasta que se completen los 24 elementos.

#!/bin/bash
#Uso: runprocess.sh $1{duhname} $2{prefijo-de-nombre} $3{‘listas-de-elementos’}
DUHNAME=$1
PREFIX=$2
SUFFIXES=$3

function esperar_por_procesos {
HACIENDOALGO=$1
#Comprobar procesos en ejecución:
while [ $HACIENDOALGO -ne 0 ]
do
sleep 10
#Comprobar procesos en ejecución
bin/grep -i doingstuff | /usr/bin/cut -d ‘>’ -f 2 | /usr/bin/cut -d ‘<‘ -f 1
HACIENDOALGO=$1
sleep 60
done
}

function hacer_algo { #sufijo
SUFIJO=$1
#Llamar a un proceso para que se ejecute en cada elemento
EL_NOMBRE=$PREFIX$NUM
/usr/bin/curl -v -X POST EL_NOMBRE
}

COMIENZO DEL SCRIPT PRINCIPAL

esperar_por_procesos 1
for NUM in $SUFFIXES
do
hacer_algo $NUM &
if (( $NUM % 6 == 0 )); then
esperar_por_procesos 1
fi
done

FIN DEL SCRIPT PRINCIPAL

Así que tengo esto funcionando para hacer_algo 1 NUM a la vez, pero quiero hacer 6 cosas a la vez y luego esperar a que todas se completen para luego hacer las siguientes 6 NUM en la lista SUFFIX. ¿Debo convertir esto en una matriz?

runprocess.sh $1{duhname} $2{prefijo-de-nombre} $3{‘listas-de-elementos’}
duhname DUHONL
prefijo-de-nombre TheMain
listas-de-elementos “01 05 09 13 17 21 02 06 10 14 18 22 03 07 11 15 19 23 04 08 12 16 20 24”

Me he perdido.
Cualquier enlace a un ejemplo similar sería apreciado
Pensamientos, gracias de antemano.

Tags:  , ,

Answer

  1. Avatar for davy.ai

    Puede utilizar un arreglo para almacenar la lista de elementos y luego iterar a través del arreglo para llamar a la función do_this_thing. Aquí hay un ejemplo de cómo puede hacerlo:

    #!/bin/bash
    #Uso: runprocess.sh $1{duhname} $2{prefijo-de-nombre} $3{'listas-de-elementos'}
    DUHNAME=$1
    PREFIX=$2
    SUFFIXES=$3
    
    # Cree un arreglo a partir de la lista de elementos
    SUFFIX_ARRAY=($SUFFIXES)
    
    function wait_for_processes {
        DOINGSTUFF=$1
        # Verifica procesos en ejecución:
        while [ $DOINGSTUFF -ne 0 ]
        do
            sleep 10
            # Verifica procesos en ejecución
            bin/grep -i doingstuff | /usr/bin/cut -d '>' -f 2 | /usr/bin/cut -d '<' -f 1
            DOINGSTUFF=$1
            sleep 60
        done
    }
    
    function do_this_thing { #sufijo
        SUFFIX=$1
        # Llame a un proceso para ejecutar contra cada elemento
        THE_NAME=$PREFIX$NUM
        /usr/bin/curl -v -X POST THE_NAME
    }
    
    #####        INICIA EL SCRIPT PRINCIPAL      ############
    wait_for_process 1
    # Itera a través del arreglo de elementos
    for NUM in ${SUFFIX_ARRAY[@]}
    do
        do_this_thing $NUM
        wait_for_process 1
    done
    #####        TERMINA EL SCRIPT PRINCIPAL      ############
    

Comments are closed.