Template script avancé

[mallek-ahmed]

!/bin/ksh

Définition des fonctions

S001 () { echo "Exécution de S001..."

Vos instructions ici...

return 0 # retourner 0 si tout s'est bien passé, autrement retourner une autre valeur }

S002 () { echo "Exécution de S002..."

Vos instructions ici...

return 0 # retourner 0 si tout s'est bien passé, autrement retourner une autre valeur }

S003 () { echo "Exécution de S003..."

Vos instructions ici...

return 0 # retourner 0 si tout s'est bien passé, autrement retourner une autre valeur }

S004 () { echo "Exécution de S004..."

Vos instructions ici...

return 0 # retourner 0 si tout s'est bien passé, autrement retourner une autre valeur }

main () {

Transformer la chaîne d'entrée en tableau

steps=($1)

Exécuter chaque step

for step in "${steps[@]}"; do $step if [ $? -ne 0 ]; then echo "Erreur lors de l'exécution de l'étape $step" return 1 fi done return 0 }

Appel principal de prog_main

prog_main () { main "$1" if [ $? -ne 0 ]; then echo "Erreur lors de l'exécution de prog_main" exit 1 fi }

Appel de prog_main avec la liste des steps à exécuter

prog_main "S001 S002 S004"

[mallek-ahmed]

main () {

Transformer la chaîne d'entrée en tableau

steps=($1)

Exécuter chaque step

for step in "${steps[@]}"; do $step exit_code=$? if [ $exit_code -ne 0 ]; then echo "Erreur lors de l'exécution de l'étape $step" return $exit_code fi done return 0 }

[mallek-ahmed]

main () {

Transformer la chaîne d'entrée en tableau

steps=($1)

Exécuter chaque step

for step in "${steps[@]}"; do $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step" return $exit_code ;; *) # Tout autre code de sortie est considéré comme une erreur echo "Erreur inattendue lors de l'exécution de l'étape $step" return $exit_code ;; esac done return 0 }

[mallek-ahmed]

!/bin/ksh

Définition des fonctions S001, S002, S003, S004

S001() {

Instructions...

return $? }

S002() {

Instructions...

return $? }

S003() {

Instructions...

return $? }

S004() {

Instructions...

return $? }

Fonction main qui exécute les steps spécifiés

main() {

Transformer la chaîne d'entrée en tableau

steps=($1)

Exécuter chaque step

for step in "${steps[@]}"; do $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step" return $exit_code ;; *) # Tout autre code de sortie est considéré comme une erreur echo "Erreur inattendue lors de l'exécution de l'étape $step" return $exit_code ;; esac done return 0 }

Appel de la fonction principale avec les steps à exécuter

main "S001 S002 S004"

[mallek-ahmed]

!/bin/ksh

Définition des fonctions S001, S002, S003, S004

S001() {

Instructions...

return $? }

S002() {

Instructions...

return $? }

S003() {

Instructions...

return $? }

S004() {

Instructions...

return $? }

Variables globales pour déterminer le début et la fin des steps à exécuter

STEP_BEGIN="S001" STEP_END="S004"

Fonction main qui exécute les steps spécifiés

main() {

Transformer la chaîne d'entrée en tableau

steps=($1)

Booléens pour contrôler le début et la fin des steps

execute=false

Exécuter chaque step

for step in "${steps[@]}"; do if [[ $step == $STEP_BEGIN ]]; then execute=true fi if $execute; then $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step" return $exit_code ;; *) # Tout autre code de sortie est considéré comme une erreur echo "Erreur inattendue lors de l'exécution de l'étape $step" return $exit_code ;; esac fi if [[ $step == $STEP_END ]]; then break fi done return 0 }

Appel de la fonction principale avec les steps à exécuter

main "S001 S002 S003 S004"

[mallek-ahmed]

Proposition pour les paramètres

!/bin/ksh

Définition des fonctions S001, S002, S003, S004

S001() {

Utilisation des arguments : $1, $2, etc.

Instructions...

return $? }

S002() {

Utilisation des arguments : $1, $2, etc.

Instructions...

return $? }

S003() {

Utilisation des arguments : $1, $2, etc.

Instructions...

return $? }

S004() {

Utilisation des arguments : $1, $2, etc.

Instructions...

return $? }

Variables globales pour déterminer le début et la fin des steps à exécuter

STEP_BEGIN="S001" STEP_END="S004"

Fonction main qui exécute les steps spécifiés

main() {

Transformer la chaîne d'entrée en tableau

steps=($1)

Booléens pour contrôler le début et la fin des steps

execute=false

Exécuter chaque step

for step in "${steps[@]}"; do if [[ $step == $STEP_BEGIN ]]; then execute=true fi if $execute; then $step $2 $3 $4 $5 # Passer les arguments aux fonctions exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step" return $exit_code ;; *) # Tout autre code de sortie est considéré comme une erreur echo "Erreur inattendue lors de l'exécution de l'étape $step" return $exit_code ;; esac fi if [[ $step == $STEP_END ]]; then break fi done return 0 }

Appel de la fonction principale avec les steps à exécuter et les arguments à passer

main "S001 S002 S003 S004" $@

[mallek-ahmed]

!/bin/ksh

Définition des fonctions S001, S002, S003, S004... S009

S001() {

Instructions...

return $? }

S002() {

Instructions...

return $? }

S003() {

Instructions...

return $? }

S004() {

Instructions...

return $? }

...

S009() {

Instructions...

return $? }

Variables globales pour déterminer le début et la fin des steps à exécuter

STEP_BEGIN=${1:-"S001"} STEP_END=${2:-"S009"}

Tableau de tous les steps possibles

ALL_STEPS=("S001" "S002" "S003" "S004" "S005" "S006" "S007" "S008" "S009")

Fonction main qui exécute les steps spécifiés

main() {

Booléens pour contrôler le début et la fin des steps

execute=false

Exécuter chaque step

for step in "${ALL_STEPS[@]}"; do if [[ $step == $STEP_BEGIN ]]; then execute=true fi if $execute; then $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step" return $exit_code ;; *) # Tout autre code de sortie est considéré comme une erreur echo "Erreur inattendue lors de l'exécution de l'étape $step" return $exit_code ;; esac fi if [[ $step == $STEP_END ]]; then break fi done return 0 }

Appel de la fonction principale

main

[mallek-ahmed]

!/bin/ksh

Fichier pour stocker l'état

STATE_FILE="state_file.txt"

Variables globales

declare -A GLOBAL_VARS

Fonctions S001, S002, ..., S009

S001() {

Instructions...

GLOBAL_VARS["VAR1"]="new_value1" return $? }

S002() {

Instructions...

GLOBAL_VARS["VAR2"]="new_value2" return $? }

...

S009() {

Instructions...

return $? }

Récupérer l'état à partir du fichier d'état, s'il existe

load_state() { if [ -f "$STATE_FILE" ]; then while IFS='=' read -r key value; do if [ "$key" == "LAST_STEP" ]; then LAST_STEP=$value else GLOBAL_VARS["$key"]=$value fi done < "$STATE_FILE" fi }

Sauvegarder l'état actuel dans le fichier d'état

save_state() {

"$STATE_FILE" for key in "${!GLOBAL_VARS[@]}"; do echo "$key=${GLOBAL_VARS[$key]}" >> "$STATE_FILE" done echo "LAST_STEP=$1" >> "$STATE_FILE" }

Fonction main qui exécute les steps spécifiés

main() {

Tableau de tous les steps possibles

ALL_STEPS=("S001" "S002" "S003" "S004" "S005" "S006" "S007" "S008" "S009")

Charger l'état précédent

load_state

Booléen pour contrôler le début des steps

start=false

if [ -z "$LAST_STEP" ]; then start=true fi

Exécuter chaque step

for step in "${ALL_STEPS[@]}"; do if [ "$step" == "$LAST_STEP" ]; then start=true fi if $start; then $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step"

Sauvegarder l'état avant de sortir

      save_state $step
      exit $exit_code
      ;;
    *) # Tout autre code de sortie est considéré comme une erreur
      echo "Erreur inattendue lors de l'exécution de l'étape $step"
      # Sauvegarder l'état avant de sortir
      save_state $step
      exit $exit_code
      ;;
  esac
  # Sauvegarder l'état après chaque step réussi
  save_state
fi

done }

Appel principal

main

[mallek-ahmed]

!/bin/ksh

Fichier pour stocker l'état

STATE_FILE="state_file.txt"

Variables globales

declare -A GLOBAL_VARS

Fonctions S000, S001, S002, ..., S009

S000() {

Instructions...

return $? }

S001() {

Instructions...

GLOBAL_VARS["VAR1"]="new_value1" return $? }

S002() {

Instructions...

GLOBAL_VARS["VAR2"]="new_value2" return $? }

...

S009() {

Instructions...

return $? }

Récupérer l'état à partir du fichier d'état, s'il existe

load_state() { if [ -f "$STATE_FILE" ]; then while IFS='=' read -r key value; do if [ "$key" == "LAST_STEP" ]; then LAST_STEP=$value else GLOBAL_VARS["$key"]=$value fi done < "$STATE_FILE" fi }

Sauvegarder l'état actuel dans le fichier d'état

save_state() {

"$STATE_FILE" for key in "${!GLOBAL_VARS[@]}"; do echo "$key=${GLOBAL_VARS[$key]}" >> "$STATE_FILE" done echo "LAST_STEP=$1" >> "$STATE_FILE" }

Fonction main qui exécute les steps spécifiés

main() {

Tableau de tous les steps possibles

ALL_STEPS=("S001" "S002" "S003" "S004" "S005" "S006" "S007" "S008" "S009")

Charger l'état précédent

load_state

Booléen pour contrôler le début des steps

start=false

if [ -z "$LAST_STEP" ]; then start=true fi

Exécuter S000 à chaque fois

S000 exit_code=$? if [ $exit_code -ne 0 ]; then echo "Erreur lors de l'exécution de l'étape S000" exit $exit_code fi

Exécuter chaque step

for step in "${ALL_STEPS[@]}"; do if [ "$step" == "$LAST_STEP" ]; then start=true fi if $start; then $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step"

Sauvegarder l'état avant de sortir

      save_state $step
      exit $exit_code
      ;;
    *) # Tout autre code de sortie est considéré comme une erreur
      echo "Erreur inattendue lors de l'exécution de l'étape $step"
      # Sauvegarder l'état avant de sortir
      save_state $step
      exit $exit_code
      ;;
  esac
  # Sauvegarder l'état après chaque step réussi
  save_state $step
fi

done }

Appel principal

main

[mallek-ahmed]

!/bin/ksh

Fichier pour stocker l'état

STATE_FILE="state_file.txt"

Variables globales

declare -A GLOBAL_VARS

Fonctions S000, S001, S002, ..., S009

S000() {

Instructions...

return $? }

S001() {

Instructions...

GLOBAL_VARS["VAR1"]="new_value1" return $? }

S002() {

Instructions...

GLOBAL_VARS["VAR2"]="new_value2" return $? }

...

S009() {

Instructions...

return $? }

Récupérer l'état à partir du fichier d'état, s'il existe

load_state() { if [ -f "$STATE_FILE" ]; then while IFS='=' read -r key value; do if [ "$key" == "LAST_STEP" ]; then LAST_STEP=$value else GLOBAL_VARS["$key"]=$value fi done < "$STATE_FILE" fi }

Sauvegarder l'état actuel dans le fichier d'état

save_state() {

"$STATE_FILE" for key in "${!GLOBAL_VARS[@]}"; do echo "$key=${GLOBAL_VARS[$key]}" >> "$STATE_FILE" done echo "LAST_STEP=$1" >> "$STATE_FILE" }

Fonction main qui exécute les steps spécifiés

main() {

Tableau de tous les steps possibles

ALL_STEPS=("S001" "S002" "S003" "S004" "S005" "S006" "S007" "S008" "S009")

Charger l'état précédent

load_state

Booléen pour contrôler le début des steps

start=false

if [ -z "$LAST_STEP" ]; then start=true fi

Exécuter S000 à chaque fois

S000 exit_code=$? if [ $exit_code -ne 0 ]; then echo "Erreur lors de l'exécution de l'étape S000" exit $exit_code fi

Exécuter chaque step

for step in "${ALL_STEPS[@]}"; do if [ "$step" == "$LAST_STEP" ]; then start=true fi if $start; then $step exit_code=$? case $exit_code in 0) ;; # Pas d'erreur, on continue 2|4) # Warning, on continue echo "Warning lors de l'exécution de l'étape $step" ;; 1|3|5) # Erreur, on arrête echo "Erreur lors de l'exécution de l'étape $step"

Sauvegarder l'état avant de sortir

      save_state $step
      exit $exit_code
      ;;
    *) # Tout autre code de sortie est considéré comme une erreur
      echo "Erreur inattendue lors de l'exécution de l'étape $step"
      # Sauvegarder l'état avant de sortir
      save_state $step
      exit $exit_code
      ;;
  esac
  # Sauvegarder l'état après chaque step réussi
  save_state $step
fi

done

Si le script s'est terminé avec succès, supprimer le fichier d'état

rm -f "$STATE_FILE" return 0 }

Appel principal

main

[mallek-ahmed]

!/bin/ksh

Fichier pour stocker l'état

STATE_FILE="state_file.txt"

Variables globales

declare -A GLOBAL_VARS

Fonctions S000, S001, S002, ..., S009

S000() {

Instructions...

return $? }

S001() {

Instructions...

GLOBAL_VARS["VAR1"]="new_value1" return $? }

S002() {

Instructions...

GLOBAL_VARS["VAR2"]="new_value2" return $? }

...

S009() {

Instructions...

return $? }

Récupérer l'état à partir du fichier d'état, s'il existe

load_state() { if [ -f "$STATE_FILE" ]; then while IFS='=' read -r key value; do if [ "$key" == "LAST_STEP" ]; then LAST_STEP=$value else GLOBAL_VARS["$key"]=$value fi done < "$STATE_FILE" fi }

Sauvegarder l'état actuel dans le fichier d'état

save_state() {

"$STATE_FILE" for key in "${!GLOBAL_VARS[@]}"; do echo "$key=${GLOBAL_VARS[$key]}" >> "$STATE_FILE" done echo "LAST_STEP=$1" >> "$STATE_FILE" }

Fonction main qui exécute les steps spécifiés

main() {

Tableau de tous les steps possibles

ALL_STEPS=("S001" "S002" "S003" "S004" "S005" "S006" "S007" "S008" "S009")

Charger l'état précédent

load_state

Booléen pour contrôler le début des steps

start=false

if [ -z "$LAST_STEP" ]; then start=true fi

Exécuter S000 à chaque fois

S000 exit_code=$? if [ $exit_code -ne 0 ]; then echo "Erreur lors de l'exécution de l'étape S000" exit $exit_code fi

Exécuter chaque step

for step in "${ALL_STEPS[@]}"; do if [ "$step" == "$LAST_STEP" ]; then start=true fi if $start; then

Ajouter la date de début d'exécution

  echo "Début de l'étape $step à $(date)"
  start_time=$(date +%s)

  $step
  exit_code=$?

  # Ajouter la date de fin d'exécution et la durée
  end_time=$(date +%s)
  echo "Fin de l'étape $step à $(date)"
  echo "Durée de l'étape $step : $(($end_time - $start_time)) secondes"

  case $exit_code in
    0) ;;  # Pas d'erreur, on continue
    2|4)   # Warning, on continue
      echo "Warning lors de l'exécution de l'étape $step"
      ;;
    1|3|5) # Erreur, on arrête
      echo "Erreur lors de l'exécution de l'étape $step"
      exit $exit_code
      ;;
    *)     # Autre code de retour, on arrête
      echo "Erreur inconnue lors de l'exécution de l'étape $step"
      exit $exit_code
      ;;
  esac
  # Sauvegarder l'état après chaque step réussi
  save_state $step
fi

done

Supprimer le fichier d'état si toutes les étapes ont été exécutées avec succès

rm -f "$STATE_FILE" }

Appel principal

main

[mallek-ahmed]

Documentation du Script Shell

1. Introduction Le script shell fourni est un modèle de script pour un processus par étapes. Il est conçu pour gérer un processus qui se compose de différentes étapes séquentielles, où chaque étape est définie comme une fonction shell.

Il conserve également l'état d'exécution dans un fichier, ce qui permet de reprendre l'exécution là où elle s'est arrêtée en cas d'erreur. Le script enregistre également des informations détaillées sur le déroulement de chaque étape, y compris la date et l'heure de début et de fin, ainsi que la durée.

2. Comment ça marche 2.1. Définir les étapes Les étapes sont définies comme des fonctions shell. Chaque fonction doit retourner un code de sortie pour indiquer si elle a réussi (0), échoué (1, 3, 5) ou émis un avertissement (2, 4). Le modèle actuel supporte jusqu'à 9 étapes (S001 à S009), mais il peut être étendu pour en soutenir davantage.

Une fonction S000 est également présente. Celle-ci est exécutée avant chaque étape pour charger les fonctions communes et les variables d'environnement. Elle doit être définie selon les besoins de votre application.

2.2. Utiliser des variables globales Les variables globales sont stockées dans un tableau associatif nommé GLOBAL_VARS. Si une étape a besoin de définir une variable globale, elle doit l'ajouter à ce tableau. Par exemple, GLOBAL_VARS["VAR1"]="new_value1". Les variables globales sont automatiquement sauvegardées et restaurées à partir du fichier d'état.

2.3. Gérer les erreurs Si une étape échoue (c'est-à-dire retourne 1, 3 ou 5), le script s'arrête et enregistre l'état actuel dans le fichier d'état. Lors de la prochaine exécution, il reprendra à partir de l'étape qui a échoué.

Si une étape retourne un avertissement (2 ou 4), le script continue à exécuter les étapes suivantes mais affiche un message d'avertissement.

2.4. Suivre l'exécution Le script enregistre des informations détaillées sur l'exécution de chaque étape, y compris la date et l'heure de début et de fin, ainsi que la durée. Ces informations sont affichées à la console.

3. Comment l'utiliser Pour utiliser ce script, vous devez d'abord définir les fonctions pour vos étapes (S000 à S009, ou plus si nécessaire). Chaque fonction doit effectuer le travail nécessaire pour cette étape et retourner un code de sortie approprié.

Ensuite, exécutez le script avec la commande ./mon_script.ksh. Le script commencera à exécuter les étapes en séquence.

Si une erreur se produit, corrigez le problème, puis relancez le script avec la même commande. Le script reprendra à partir de l'étape qui a échoué.

Pour effacer l'état et recommencer depuis le début, supprimez le fichier d'état avec la commande rm state.txt.

4. Parties à ne pas oublier Définir les fonctions pour les étapes S000 à S009. Utiliser GLOBAL_VARS pour définir des variables globales si nécessaire. Tester chaque étape individuellement pour s'assurer qu'elle retourne le bon code de sortie. Ne pas oublier de supprimer le fichier d'état si vous souhaitez recommencer depuis le début. Ce modèle est flexible et peut être adapté pour répondre à divers besoins. Il est recommandé de bien comprendre comment il fonctionne avant de commencer à l'adapter à votre application spécifique.