Lab : fiabiliser les scripts de Signalements

$ sudo apt install shellcheck bats bats-support bats-assert make gzip util-linux procps git

#!/usr/bin/env bash
# preparer-bac-a-sable : crée des exports et des pièces jointes d'essai pour le lab Bash.
# Usage : preparer-bac-a-sable RÉPERTOIRE   (créé s'il n'existe pas ; refuse s'il n'est pas vide)

set -Eeuo pipefail
export LC_ALL=C.UTF-8

readonly EN_TETE='id,type,commune,date'

(( $# == 1 )) || { printf 'Usage : %s RÉPERTOIRE\n' "${0##*/}" >&2; exit 2; }
bac=$1
mkdir -p -- "$bac"
bac=$(readlink -f -- "$bac")
if [[ -n $(find "$bac" -mindepth 1 -maxdepth 1 -print -quit) ]]; then
  printf '%s : %s n'"'"'est pas vide, choisissez un répertoire neuf\n' "${0##*/}" "$bac" >&2
  exit 1
fi
mkdir -p -- "$bac/exports/publies" "$bac/pj/2025 archives" "$bac/pj/2026" "$bac/bucket"

# exporter JOUR NOMBRE : un export valide de NOMBRE signalements, fins de ligne Unix.
exporter() {
  local jour=$1 n=$2 i
  local -a types=(nid-de-poule lampadaire tag encombrant)
  {
    printf '%s\n' "$EN_TETE"
    for (( i = 1; i <= n; i++ )); do
      printf '%d,%s,Exempleville,%s\n' "$i" "${types[i % ${#types[@]}]}" "$jour"
    done
  } > "$bac/exports/signalements-$jour.csv"
}

exporter 2026-10-07 120
exporter 2026-10-05 3
printf '%s\n' "$EN_TETE" > "$bac/exports/signalements-2026-10-06.csv"         # en-tête seul
: > "$bac/exports/signalements-2026-10-04.csv"                                 # vide
printf '%s\r\n' "$EN_TETE" "1,tag,Exempleville,2026-10-03" \
  > "$bac/exports/signalements-2026-10-03.csv"                                 # CRLF, valide
printf '%s\n' "id;type;commune;date" "1;tag;Exempleville;2026-10-02" \
  > "$bac/exports/signalements-2026-10-02.csv"                                 # séparateur ;

# Pièces jointes : anciennes (à purger) aux noms hostiles, récentes (à garder).
pj=$bac/pj
touch -d '400 days ago' -- "$pj/2025 archives/photo du 12 mars.jpg" \
  "$pj/2025 archives/-rf.jpg" "$pj/2025 archives/photo*.jpg" \
  "$pj/2025 archives/"$'deux\nlignes.jpg' "$pj/2025 archives/ espace-devant.jpg"
touch -d '40 days ago' -- "$pj/2026/moyenne.jpg"
touch -d '10 days ago' -- "$pj/2026/recente.jpg" "$pj/2025 archives/photo1.jpg"

cat > "$bac/essai.conf" <<'FIN'
# Configuration d'essai de publier-export : clé=valeur, sans guillemets.
DESTINATION=s3://sig-exports-recette
FIN

printf 'Bac à sable prêt dans %s :\n' "$bac"
printf '  export PUBLIER_EXPORT_REPERTOIRE=%q\n' "$bac/exports"
printf '  export PUBLIER_EXPORT_VERROU=%q\n' "$bac/verrou"
printf '  export PUBLIER_EXPORT_CONFIG=%q\n' "$bac/essai.conf"
printf '  export PURGER_REPERTOIRE=%q\n' "$bac/pj"

$ ./preparer-bac-a-sable ~/bac-signalements
Bac à sable prêt dans /home/vous/bac-signalements :
  export PUBLIER_EXPORT_REPERTOIRE=/home/vous/bac-signalements/exports
  export PUBLIER_EXPORT_VERROU=/home/vous/bac-signalements/verrou
  export PUBLIER_EXPORT_CONFIG=/home/vous/bac-signalements/essai.conf
  export PURGER_REPERTOIRE=/home/vous/bac-signalements/pj

#!/usr/bin/env bash
# verifier-lab : vérifie de l'extérieur le dépôt signalements-outils du lab Bash.
# Usage : verifier-lab [CHEMIN_DU_DEPOT]   (par défaut : le répertoire courant)
# Chaque contrôle affiche OK ou ÉCHEC ; le code de sortie vaut 0 si tout passe, 1 sinon.
# Ne touche à rien hors d'un répertoire de travail temporaire, supprimé à la sortie.

set -Eeuo pipefail
shopt -s inherit_errexit
export LC_ALL=C.UTF-8

readonly JOUR=2026-10-07
readonly MOIS=2026/10
readonly EN_TETE='id,type,commune,date'
readonly MARQUE_ATTENTE=lab-aws-attente

depot=""
travail=""
echecs=0
total=0

# --- Infrastructure -------------------------------------------------------

nettoyer() {
  # Une doublure en attente qui aurait survécu à un contrôle raté.
  pkill -u "$(id -u)" -f "^$MARQUE_ATTENTE " 2> /dev/null || true
  if [[ -n $travail ]]; then
    rm -rf -- "$travail"
  fi
}
trap nettoyer EXIT
trap 'exit 130' INT
trap 'exit 143' TERM

mourir() {
  printf 'verifier-lab : %s\n' "$*" >&2
  exit 1
}

# controle LIBELLÉ COMMANDE...
#   Attention (leçon 9) : la commande s'exécute dans la condition d'un if, où
#   set -e est suspendu. Les fonctions de contrôle enchaînent donc leurs tests
#   par && ou se terminent par un test explicite, sans compter sur set -e.
controle() {
  local libelle=$1
  shift
  total=$((total + 1))
  if "$@"; then
    printf 'OK     %s\n' "$libelle"
  else
    printf 'ÉCHEC  %s\n' "$libelle"
    echecs=$((echecs + 1))
  fi
}

# Environnement minimal et maîtrisé pour lancer publier-export : aucune variable
# héritée du poste ne doit changer son comportement. Les variables d'essai
# (CONFIG_ESSAI, DESTINATION_ESSAI, LAB_AWS_CODE, LAB_AWS_ATTENTE) s'ajoutent si
# elles sont définies. Remplit le tableau global commande_publier.
commande_publier=()
preparer_publier() {
  commande_publier=(env -i HOME="$travail/maison" PATH="$travail/doublures:$PATH"
    LC_ALL=C.UTF-8 HORODATER=0
    PUBLIER_EXPORT_REPERTOIRE="$travail/exports"
    PUBLIER_EXPORT_VERROU="$travail/verrou"
    PUBLIER_EXPORT_CONFIG="${CONFIG_ESSAI:-$travail/absente.conf}"
    LAB_AWS_JOURNAL="$travail/aws.log" LAB_BUCKET="$travail/bucket")
  [[ -z ${DESTINATION_ESSAI:-} ]] || commande_publier+=(PUBLIER_EXPORT_DESTINATION="$DESTINATION_ESSAI")
  [[ -z ${LAB_AWS_CODE:-} ]] || commande_publier+=(LAB_AWS_CODE="$LAB_AWS_CODE")
  [[ -z ${LAB_AWS_ATTENTE:-} ]] || commande_publier+=(LAB_AWS_ATTENTE="$LAB_AWS_ATTENTE")
  commande_publier+=("$depot/bin/publier-export")
}

# lancer_publier [ARGUMENTS...] : remplit code, et les fichiers sortie et erreurs.
code=0
lancer_publier() {
  code=0
  preparer_publier
  "${commande_publier[@]}" "$@" > "$travail/sortie" 2> "$travail/erreurs" < /dev/null || code=$?
}

lancer_purger() {
  code=0
  env -i HOME="$travail/maison" PATH="$PATH" LC_ALL=C.UTF-8 HORODATER=0 \
    PURGER_REPERTOIRE="$travail/pj" \
    "$depot/bin/purger-pieces-jointes" "$@" \
    > "$travail/sortie" 2> "$travail/erreurs" < /dev/null || code=$?
}

# Remet à zéro les exports, le seau simulé et le journal de la doublure.
reinitialiser() {
  rm -rf -- "$travail/exports" "$travail/bucket" "$travail/verrou"
  mkdir -p -- "$travail/exports/publies" "$travail/bucket"
  : > "$travail/aws.log"
}

# creer_export CONTENU : écrit l'export du jour testé, tel quel (printf %b).
creer_export() {
  printf '%b' "$1" > "$travail/exports/signalements-$JOUR.csv"
}

export_valide() {
  creer_export "$EN_TETE\n1,nid-de-poule,Exempleville,$JOUR\n2,lampadaire,Exempleville,$JOUR\n"
}

aws_non_appele() { [[ ! -s $travail/aws.log ]]; }
sortie_vide() { [[ ! -s $travail/sortie ]]; }
erreurs_non_vides() { [[ -s $travail/erreurs ]]; }
aucun_travail_restant() { ! compgen -G "$travail/exports/publies/.travail.*" > /dev/null; }

# La doublure de aws du vérificateur, indépendante de celle du lecteur.
ecrire_doublure() {
  mkdir -p -- "$travail/doublures"
  cat > "$travail/doublures/aws" <<'FIN'
#!/usr/bin/env bash
# Doublure de aws : note l'appel, puis simule s3 cp et s3api head-object.
printf '%s\n' "$*" >> "${LAB_AWS_JOURNAL:?}"
if [[ -n ${LAB_AWS_ATTENTE:-} ]]; then
  # Un seul processus, renommé pour être retrouvé : voir la leçon 10.
  exec -a lab-aws-attente sleep "$LAB_AWS_ATTENTE"
fi
if (( ${LAB_AWS_CODE:-0} != 0 )); then
  echo "doublure aws : échec simulé" >&2
  exit "$LAB_AWS_CODE"
fi
case "$1 $2" in
  "s3 cp")
    source=${*: -2:1}
    cible=${*: -1}
    mkdir -p -- "${LAB_BUCKET:?}/$(dirname -- "${cible#s3://}")"
    cp -- "$source" "$LAB_BUCKET/${cible#s3://}"
    ;;
  "s3api head-object")
    while (( $# > 0 )); do
      case $1 in
        --bucket) seau=$2; shift ;;
        --key) cle=$2; shift ;;
      esac
      shift
    done
    stat -c %s -- "${LAB_BUCKET:?}/$seau/$cle"
    ;;
  *)
    echo "doublure aws : appel non prévu : $*" >&2
    exit 99
    ;;
esac
FIN
  chmod 0755 "$travail/doublures/aws"
}

# --- Contrôles du dépôt ----------------------------------------------------

structure_presente() {
  [[ -x $depot/bin/publier-export && -x $depot/bin/purger-pieces-jointes \
    && -f $depot/lib/commun.sh && -f $depot/Makefile ]]
}

shellcheckrc_correct() {
  local f=$depot/.shellcheckrc
  [[ -f $f ]] && grep -qx 'external-sources=true' "$f" \
    && grep -qx 'source-path=SCRIPTDIR' "$f" && ! grep -q '^disable=' "$f"
}

shellcheck_propre() {
  local -a fichiers=("$depot"/bin/* "$depot/lib/commun.sh" "$depot"/tests/*.bats)
  [[ -d $depot/tests/doublures ]] && fichiers+=("$depot"/tests/doublures/*)
  ( cd -- "$depot" && shellcheck "${fichiers[@]#"$depot"/}" ) > "$travail/shellcheck.txt" 2>&1
}

nombre_de_tests() {   # nombre_de_tests FICHIER MINIMUM
  local n
  [[ -f $1 ]] || return 1
  n=$(bats --count "$1") || return 1
  (( n >= $2 ))
}

# Les tests passent, et aucun n'atteint un vrai aws : un piège en fin de PATH
# laisse une trace si la doublure du lecteur n'a pas pris sa place.
bats_passe() {
  mkdir -p -- "$travail/piege"
  printf '#!/bin/sh\ntouch "%s"\nexit 97\n' "$travail/vrai-aws-appele" > "$travail/piege/aws"
  chmod 0755 "$travail/piege/aws"
  ( cd -- "$depot" && PATH="$travail/piege:$PATH" bats tests/ ) > "$travail/bats.txt" 2>&1 \
    && [[ ! -e $travail/vrai-aws-appele ]]
}

make_verifier_existe() { make -C "$depot" -n verifier > /dev/null 2>&1; }

# --- Contrôles de publier-export --------------------------------------------

aide_et_version() {
  lancer_publier --help
  if (( code != 0 )) || ! grep -q '^Usage' "$travail/sortie"; then
    return 1
  fi
  lancer_publier --version
  (( code == 0 )) && grep -Eq '^publier-export [0-9]+\.[0-9]+\.[0-9]+$' "$travail/sortie"
}

publication_nominale() {
  local seau=$travail/bucket/sig-exports-mairie/$MOIS
  local nom=signalements-$JOUR.csv.gz
  reinitialiser
  export_valide
  lancer_publier --date "$JOUR"
  (( code == 0 )) && sortie_vide \
    && [[ -f $seau/$nom && -f $seau/$nom.sha256 ]] \
    && ( cd -- "$seau" && sha256sum --check --quiet "$nom.sha256" ) \
    && cmp -s <(zcat -- "$seau/$nom") "$travail/exports/signalements-$JOUR.csv" \
    && [[ -f $travail/exports/publies/$nom && -f $travail/exports/publies/$nom.sha256 ]] \
    && aucun_travail_restant
}

point_acces_fr_par() {
  # Chaque appel enregistré vise l'Object Storage de Scaleway à Paris.
  [[ -s $travail/aws.log ]] \
    && ! grep -v -- '--endpoint-url https://s3.fr-par.scw.cloud' "$travail/aws.log" | grep -q .
}

crlf_accepte() {
  reinitialiser
  creer_export "$EN_TETE\r\n1,nid-de-poule,Exempleville,$JOUR\r\n"
  lancer_publier -d "$JOUR"
  (( code == 0 ))
}

# refus_export CONTENU|absent : code 3, message d'erreur, rien de déposé.
refus_export() {
  reinitialiser
  [[ $1 == absent ]] || creer_export "$1"
  lancer_publier -d "$JOUR"
  (( code == 3 )) && erreurs_non_vides && sortie_vide && aws_non_appele && aucun_travail_restant
}

usage_refuse() {
  reinitialiser
  export_valide
  local ligne
  local -a arguments
  for ligne in "-d 07/10/2026" "-d 2026-02-30" "--option-inconnue" "-d"; do
    read -r -a arguments <<< "$ligne"
    lancer_publier "${arguments[@]}"
    if (( code != 2 )) || ! erreurs_non_vides || ! aws_non_appele; then
      return 1
    fi
  done
}

depot_en_echec() {
  reinitialiser
  export_valide
  LAB_AWS_CODE=1 lancer_publier -d "$JOUR"
  (( code == 4 )) && erreurs_non_vides && aucun_travail_restant \
    && [[ ! -e $travail/exports/publies/signalements-$JOUR.csv.gz ]]
}

verrou_respecte() {
  local fd
  reinitialiser
  export_valide
  exec {fd}>> "$travail/verrou"
  flock -n "$fd"
  lancer_publier -d "$JOUR"
  exec {fd}>&-
  (( code == 5 )) && aws_non_appele
}

simulation_sans_aws() {
  reinitialiser
  export_valide
  lancer_publier --dry-run -d "$JOUR"
  (( code == 0 )) && aws_non_appele && aucun_travail_restant \
    && [[ -z $(find "$travail/bucket" -type f) ]] \
    && [[ ! -e $travail/exports/publies/signalements-$JOUR.csv.gz ]]
}

destination_option_et_environnement() {
  reinitialiser
  export_valide
  lancer_publier -d "$JOUR" --destination s3://sig-exports-recette/essai
  if (( code != 0 )) || [[ ! -f $travail/bucket/sig-exports-recette/essai/$MOIS/signalements-$JOUR.csv.gz ]]; then
    return 1
  fi
  reinitialiser
  export_valide
  DESTINATION_ESSAI=s3://sig-exports-env lancer_publier -d "$JOUR"
  (( code == 0 )) && [[ -f $travail/bucket/sig-exports-env/$MOIS/signalements-$JOUR.csv.gz ]]
}

configuration_lue_sans_execution() {
  local config=$travail/essai.conf
  reinitialiser
  export_valide
  printf '%s\n' '# essai' 'DESTINATION=s3://sig-exports-conf' \
    "X=\$(touch $travail/pirate)" > "$config"
  CONFIG_ESSAI=$config lancer_publier -d "$JOUR"
  (( code == 0 )) && [[ ! -e $travail/pirate ]] \
    && [[ -f $travail/bucket/sig-exports-conf/$MOIS/signalements-$JOUR.csv.gz ]]
}

# SIGTERM pendant le dépôt : code 143, aucun répertoire de travail, aucune
# doublure orpheline, et le verrou est rendu (une nouvelle exécution réussit).
sigterm_nettoie() {
  local pid i
  reinitialiser
  export_valide
  LAB_AWS_ATTENTE=30 preparer_publier
  # env remplace son processus par le script : $! est bien celui de publier-export.
  "${commande_publier[@]}" -d "$JOUR" > "$travail/sortie" 2> "$travail/erreurs" < /dev/null &
  pid=$!
  for (( i = 0; i < 100; i++ )); do
    [[ -s $travail/aws.log ]] && break
    sleep 0.1
  done
  if [[ ! -s $travail/aws.log ]]; then
    kill "$pid" 2> /dev/null || true
    wait "$pid" || true
    return 1
  fi
  # Le script doit réagir tout de suite, pas à la fin du dépôt en cours (leçon 10).
  kill -TERM "$pid"
  for (( i = 0; i < 30; i++ )); do
    kill -0 "$pid" 2> /dev/null || break
    sleep 0.1
  done
  if kill -0 "$pid" 2> /dev/null; then
    kill -KILL "$pid" 2> /dev/null || true
    wait "$pid" 2> /dev/null || true
    return 1
  fi
  code=0
  wait "$pid" || code=$?
  (( code == 143 )) || return 1
  for (( i = 0; i < 20; i++ )); do
    pgrep -u "$(id -u)" -f "^$MARQUE_ATTENTE " > /dev/null || break
    sleep 0.1
  done
  if pgrep -u "$(id -u)" -f "^$MARQUE_ATTENTE " > /dev/null || ! aucun_travail_restant; then
    return 1
  fi
  : > "$travail/aws.log"
  lancer_publier -d "$JOUR"
  (( code == 0 ))
}

# --- Contrôles de purger-pieces-jointes ------------------------------------

preparer_pj() {
  local pj=$travail/pj
  rm -rf -- "$pj" "$travail/hors-pj"
  mkdir -p -- "$pj/2025 archives" "$pj/2026" "$travail/hors-pj"
  touch -d '400 days ago' -- "$pj/2025 archives/photo du 12 mars.jpg" \
    "$pj/2025 archives/-rf.jpg" "$pj/2025 archives/photo*.jpg" \
    "$pj/2025 archives/"$'deux\nlignes.jpg' "$travail/hors-pj/temoin.jpg"
  touch -d '40 days ago' -- "$pj/2026/moyenne.jpg"
  touch -d '10 days ago' -- "$pj/2026/recente.jpg" "$pj/2025 archives/photo1.jpg"
  ln -s -- "$travail/hors-pj/temoin.jpg" "$pj/2026/lien-vers-temoin.jpg"
}

anciens_presents() {
  local pj=$travail/pj
  [[ -e "$pj/2025 archives/photo du 12 mars.jpg" && -e "$pj/2025 archives/-rf.jpg" \
    && -e "$pj/2025 archives/photo*.jpg" && -e "$pj/2025 archives/"$'deux\nlignes.jpg' ]]
}

anciens_absents() {
  local pj=$travail/pj
  [[ ! -e "$pj/2025 archives/photo du 12 mars.jpg" && ! -e "$pj/2025 archives/-rf.jpg" \
    && ! -e "$pj/2025 archives/photo*.jpg" && ! -e "$pj/2025 archives/"$'deux\nlignes.jpg' ]]
}

recents_intacts() {
  local pj=$travail/pj
  [[ -e $pj/2026/moyenne.jpg && -e $pj/2026/recente.jpg \
    && -e "$pj/2025 archives/photo1.jpg" && -e $travail/hors-pj/temoin.jpg ]]
}

purge_simulation() {
  preparer_pj
  lancer_purger --dry-run
  (( code == 0 )) && anciens_presents && recents_intacts
}

purge_sans_oui_refusee() {
  preparer_pj
  lancer_purger
  (( code == 2 )) && erreurs_non_vides && anciens_presents
}

purge_seuils_invalides() {
  local valeur
  preparer_pj
  for valeur in 3 zéro 08x 99999; do
    lancer_purger --jours "$valeur" --oui
    (( code == 2 )) || return 1
  done
  lancer_purger --option-inconnue
  (( code == 2 )) && anciens_presents && recents_intacts
}

purge_noms_hostiles() {
  preparer_pj
  lancer_purger --oui
  (( code == 0 )) && anciens_absents && recents_intacts
}

purge_seuil_30() {
  preparer_pj
  lancer_purger --jours 30 --oui
  (( code == 0 )) && [[ ! -e $travail/pj/2026/moyenne.jpg && -e $travail/pj/2026/recente.jpg ]] \
    && [[ -e $travail/hors-pj/temoin.jpg ]]
}

# --- Programme principal ----------------------------------------------------

main() {
  local outil
  depot=$(readlink -f -- "${1:-.}")
  [[ -d $depot ]] || mourir "dépôt introuvable : ${1:-.}"
  for outil in shellcheck bats make flock gzip zcat sha256sum pgrep; do
    command -v "$outil" > /dev/null || mourir "commande requise introuvable : $outil"
  done
  travail=$(mktemp -d -t verifier-lab.XXXXXX)
  mkdir -p -- "$travail/maison"
  ecrire_doublure
  printf 'Dépôt : %s\n\n' "$depot"

  controle "structure : bin/publier-export et bin/purger-pieces-jointes exécutables, lib/commun.sh, Makefile" structure_presente
  if (( echecs > 0 )); then
    mourir "structure incomplète, inutile d'aller plus loin"
  fi
  controle ".shellcheckrc : external-sources, source-path=SCRIPTDIR, aucune désactivation globale" shellcheckrc_correct
  controle "ShellCheck : aucun constat (bin, lib, tests)" shellcheck_propre
  controle "au moins 10 tests pour publier-export" nombre_de_tests "$depot/tests/publier-export.bats" 10
  controle "au moins 4 tests pour purger-pieces-jointes" nombre_de_tests "$depot/tests/purger-pieces-jointes.bats" 4
  controle "bats : tous les tests passent, sans appeler le vrai aws" bats_passe
  controle "make verifier existe" make_verifier_existe

  controle "publier-export : --help et --version" aide_et_version
  controle "publier-export : dépôt nominal, empreinte vérifiable, copie locale, sortie standard vide (code 0)" publication_nominale
  controle "publier-export : chaque appel à aws vise https://s3.fr-par.scw.cloud" point_acces_fr_par
  controle "publier-export : export aux fins de ligne CRLF accepté (code 0)" crlf_accepte
  controle "publier-export : export absent (code 3, rien déposé)" refus_export absent
  controle "publier-export : export vide (code 3, rien déposé)" refus_export ''
  controle "publier-export : en-tête seul (code 3, rien déposé)" refus_export "$EN_TETE\n"
  controle "publier-export : en-tête inattendu (code 3, rien déposé)" refus_export "id;type;commune;date\n1;x;y;$JOUR\n"
  controle "publier-export : dates et options invalides (code 2)" usage_refuse
  controle "publier-export : dépôt en échec (code 4, nettoyage fait)" depot_en_echec
  controle "publier-export : verrou détenu par une autre exécution (code 5)" verrou_respecte
  controle "publier-export : --dry-run n'appelle pas aws et ne laisse rien" simulation_sans_aws
  controle "publier-export : --destination et PUBLIER_EXPORT_DESTINATION respectés" destination_option_et_environnement
  controle "publier-export : configuration lue sans être exécutée" configuration_lue_sans_execution
  controle "publier-export : SIGTERM pendant le dépôt, nettoyage et verrou rendu" sigterm_nettoie

  controle "purger-pieces-jointes : --dry-run ne supprime rien (code 0)" purge_simulation
  controle "purger-pieces-jointes : sans --oui ni terminal, refus (code 2)" purge_sans_oui_refusee
  controle "purger-pieces-jointes : seuils et options invalides (code 2)" purge_seuils_invalides
  controle "purger-pieces-jointes : noms hostiles supprimés, récents et cibles de liens épargnés" purge_noms_hostiles
  controle "purger-pieces-jointes : --jours 30 abaisse le seuil" purge_seuil_30

  printf '\n%d contrôle(s), %d échec(s)\n' "$total" "$echecs"
  if (( echecs > 0 )); then
    printf 'Détails : relancez les scénarios à la main, ou lisez la sortie de shellcheck et bats.\n'
    return 1
  fi
}

main "$@"

Dépôt : /home/vous/signalements-outils

OK     structure : bin/publier-export et bin/purger-pieces-jointes exécutables, lib/commun.sh, Makefile
OK     .shellcheckrc : external-sources, source-path=SCRIPTDIR, aucune désactivation globale
...
OK     purger-pieces-jointes : --jours 30 abaisse le seuil

27 contrôle(s), 0 échec(s)