Salut @WesPenre 
L’erreur devrait se trouver plus haut que ce qu’inclut votre capture d’écran. Pourriez-vous coller votre journal complet ici afin que les gens puissent voir quel pourrait être le problème ?
Quelqu’un peut-il me dire comment créer un journal d’erreurs si je ne peux pas me connecter à Discourse ? Puis-je le trouver dans WinSCP ? Si oui, quel est le répertoire et le nom du journal ?
Est-ce cela ? Il s’agit du fichier lanceur :
#!/usr/bin/env bash
usage () {
echo "Usage : lanceur COMMANDE CONFIG [--skip-prereqs] [--docker-args STRING]"
echo "Commandes :"
echo " start : Démarrer/initialiser un conteneur"
echo " stop : Arrêter un conteneur en cours d'exécution"
echo " restart : Redémarrer un conteneur"
echo " destroy : Arrêter et supprimer un conteneur"
echo " enter : Ouvrir un shell pour exécuter des commandes à l'intérieur du conteneur"
echo " logs : Afficher les journaux Docker d'un conteneur"
echo " bootstrap : Initialiser un conteneur pour la configuration basée sur un modèle"
echo " run : Exécuter la commande donnée avec la configuration dans le contexte de la dernière image initialisée"
echo " rebuild : Reconstruire un conteneur (supprimer l'ancien, initialiser, démarrer le nouveau)"
echo " cleanup : Supprimer tous les conteneurs arrêtés depuis plus de 24 heures"
echo " start-cmd : Générer la commande Docker utilisée pour démarrer le conteneur"
echo
echo "Options :"
echo " --skip-prereqs Ne pas vérifier les prérequis du lanceur"
echo " --docker-args Arguments supplémentaires à transmettre lors de l'exécution de Docker"
echo " --skip-mac-address Ne pas attribuer d'adresse MAC"
echo " --run-image Remplacer l'image utilisée pour l'exécution du conteneur"
exit 1
}
# pour une réexécution potentielle ultérieure
SAVED_ARGV=("$@")
command=$1
config=$2
# user_args_argv est assigné une seule fois lors de l'analyse du vecteur d'arguments.
user_args_argv=""
# user_args est mutable : sa valeur peut changer lors de l'analyse des modèles.
# Sur-ensemble de user_args_argv.
user_args=""
user_run_image=""
if [[ $command == "run" ]]; then
run_command=$3
fi
while [ ${#} -gt 0 ]; do
case "${1}" in
--debug)
DEBUG="1"
;;
--skip-prereqs)
SKIP_PREREQS="1"
;;
--skip-mac-address)
SKIP_MAC_ADDRESS="1"
;;
--docker-args)
user_args_argv="$2"
user_args="$user_args_argv"
shift
;;
--run-image)
user_run_image="$2"
shift
;;
esac
shift 1
done
if [ -z "$command" -o -z "$config" -a "$command" != "cleanup" ]; then
usage
fi
# Docker n'aime pas les caractères majuscules, les espaces ou les caractères spéciaux, détectez-le maintenant avant de tout construire et de le découvrir ensuite
re='[[:upper:]/ !@#$%^&*()+~`=]'
if [[ $config =~ $re ]];
then
echo
echo "ERREUR : Le nom de configuration '$config' ne doit pas contenir de majuscules, d'espaces ou de caractères spéciaux. Corrigez le nom de configuration et relancez $0."
echo
exit 1
fi
cd "$(dirname "$0")"
pups_version='v1.0.3'
docker_min_version='17.03.1'
docker_rec_version='17.06.2'
git_min_version='1.8.0'
git_rec_version='1.8.0'
kernel_min_version='4.4.0'
config_file=containers/"$config".yml
cidbootstrap=cids/"$config"_bootstrap.cid
local_discourse=local_discourse
image="discourse/base:2.0.20230217-0055"
image_stable="discourse/base:2.0.20230116-0051"
docker_path=`which docker.io 2> /dev/null || which docker`
git_path=`which git`
if [ "${SUPERVISED}" = "true" ]; then
restart_policy="--restart=no"
attach_on_start="-a"
attach_on_run="-a stdout -a stderr"
else
attach_on_run="-d"
fi
if [ -n "$DOCKER_HOST" ]; then
docker_ip=`sed -e 's/^tcp:\/\/\(.*\):.*$/\1/' <<< "$DOCKER_HOST"`
elif [ -x "$(which ip 2>/dev/null)" ]; then
docker_ip=`ip addr show docker0 | \
grep 'inet ' | \
awk '{ split($2,a,"/"); print a[1] }';`
else
docker_ip=`ifconfig | \
grep -B1 "inet addr" | \
awk '{ if ( $1 == "inet" ) { print $2 } else if ( $2 == "Link" ) { printf "%s:" ,$1 } }' | \
grep docker0 | \
awk -F: '{ print $3 }';`
fi
# Depuis https://stackoverflow.com/a/44660519/702738
compare_version() {
if [[ $1 == $2 ]]; then
return 1
fi
local IFS=.
local i a=(${1%%[^0-9.]*}) b=(${2%%[^0-9.]*})
local arem=${1#${1%%[^0-9.]*}} brem=${2#${2%%[^0-9.]*}}
for ((i=0; i<${#a[@]} || i<${#b[@]}; i++)); do
if ((10#${a[i]:-0} < 10#${b[i]:-0})); then
return 1
elif ((10#${a[i]:-0} > 10#${b[i]:-0})); then
return 0
fi
done
if [ "$arem" '<' "$brem" ]; then
return 1
elif [ "$arem" '>' "$brem" ]; then
return 0
fi
return 1
}
fatal () {
echo -e "\n$1\n"
exit "${2:-1}"
}
install_docker() {
echo "Docker n'est pas installé, vous devrez installer Docker pour exécuter le lanceur"
echo "Voir https://docs.docker.com/installation/"
exit 1
}
pull_image() {
# Ajouter une seule nouvelle tentative pour contourner les erreurs TLS de Docker Hub
$docker_path pull $image || $docker_path pull $image
}
check_prereqs() {
if [ -z $docker_path ]; then
install_docker
fi
# 1. le démon Docker est-il en cours d'exécution ?
# nous envoyons stderr vers /dev/null car nous ne nous soucions pas des avertissements,
# il se plaint généralement de la mémoire swap, ce qui n'a pas d'importance
test=`$docker_path info 2> /dev/null`
if [[ $? -ne 0 ]] ; then
echo "Impossible de se connecter au démon Docker - vérifiez qu'il est en cours d'exécution et que vous y avez accès"
exit 1
fi
# 2. exécute-t-on un pilote de stockage approuvé ?
if ! $docker_path info 2> /dev/null | egrep -q 'Storage Driver: (btrfs|aufs|zfs|overlay2)$'; then
echo "Votre installation Docker n'utilise pas un pilote de stockage pris en charge. Si nous continuions, votre installation pourrait être corrompue."
echo "overlay2 est le pilote de stockage recommandé, bien que zfs et aufs puissent également fonctionner."
echo "D'autres pilotes de stockage sont connus pour poser problème."
echo "Vous pouvez déterminer quel système de fichiers vous utilisez en exécutant \"docker info\" et en regardant la ligne 'Storage Driver'."
echo
echo "Si vous souhaitez continuer malgré tout en utilisant votre pilote de stockage non pris en charge existant,"
echo "lisez le code source du lanceur et trouvez comment contourner cette vérification."
exit 1
fi
# 3. exécute-t-on la version recommandée de Docker ?
test=($($docker_path --version)) # Obtenir la chaîne de version de Docker
test=${test[2]//,/} # Obtenir uniquement la version et supprimer la virgule si elle existe
# Au moins la version minimale de Docker
if compare_version "${docker_min_version}" "${test}"; then
echo "ERREUR : La version Docker ${test} n'est pas prise en charge, veuillez mettre à niveau vers au moins ${docker_min_version}, ou recommandé ${docker_rec_version}"
exit 1
fi
# Recommander une version plus récente de Docker
if compare_version "${docker_rec_version}" "${test}"; then
echo "AVERTISSEMENT : La version Docker ${test} est obsolète, recommandez une mise à niveau vers ${docker_rec_version} ou une version ultérieure."
fi
arm=false
case $(uname -m) in
armv7l)
echo "ERREUR : L'architecture ARM 32 bits n'est pas prise en charge. Vérifiez si votre matériel prend en charge ARM64, qui est pris en charge à titre expérimental."
exit 1
;;
aarch64 | arm64)
echo "AVERTISSEMENT : Le support pour aarch64 est expérimental pour le moment. Veuillez signaler tout problème sur https://meta.discourse.org/tag/arm"
image="discourse/base:aarch64"
arm=true
;;
x86_64)
echo "Architecture x86_64 détectée."
;;
*)
echo "ERREUR : architecture inconnue détectée."
exit 1
;;
esac
# 4. l'image Docker Discourse est-elle téléchargée ?
test=`$docker_path images | awk '{print $1 ":" $2 }' | grep "$image"`
# Le support expérimental ARM est sur un tag fixe, toujours tirer
if [ -z "$test" ] || [ $arm = true ]; then
echo
echo "AVERTISSEMENT : Nous allons commencer à télécharger l'image de base Discourse"
echo "Ce processus peut prendre de quelques minutes à une heure, selon la vitesse de votre réseau"
echo
echo "Veuillez être patient"
echo
pull_image
fi
# utiliser une image plus ancienne pour stable
version=$(cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['params']['version']")
if [ "$version" = "stable" ]; then
image=$image_stable
pull_image
fi
# 5. exécute-t-on la version recommandée de Git ?
test=($($git_path --version)) # Obtenir la chaîne de version de Git
test=${test[2]//,/} # Obtenir uniquement la version et supprimer la virgule si elle existe
# Au moins la version minimale
if compare_version "${git_min_version}" "${test}"; then
echo "ERREUR : La version Git ${test} n'est pas prise en charge, veuillez mettre à niveau vers au moins ${git_min_version}, ou recommandé ${git_rec_version}"
exit 1
fi
# Recommander la meilleure version
if compare_version "${git_rec_version}" "${test}"; then
echo "AVERTISSEMENT : La version Git ${test} est obsolète, recommandez une mise à niveau vers ${git_rec_version} ou une version ultérieure."
fi
# Vérifier la version minimale du noyau en raison de https://bugs.ruby-lang.org/issues/13885
test=($(uname -r))
# Au moins la version minimale
if compare_version "${kernel_min_version}" "${test}"; then
echo "ERREUR : La version du noyau ${test} n'est pas prise en charge, veuillez mettre à niveau vers au moins ${kernel_min_version}"
exit 1
fi
# 6. peut-on attacher stderr / stdout / tty ?
test=`$docker_path run $user_args -i --rm -a stdout -a stderr $image echo working`
if [[ "$test" =~ "working" ]] ; then : ; else
echo "Votre installation Docker ne fonctionne pas correctement"
echo
echo "Voir : https://meta.discourse.org/t/docker-error-on-bootstrap/13657/18?u=sam"
exit 1
fi
# 7. assez d'espace pour l'initialisation dans le dossier Docker
folder=`$docker_path info --format '{{.DockerRootDir}}'`
safe_folder=${folder:-/var/lib/docker}
if [[ -d $safe_folder && $(stat -f --format="%a*%S" $safe_folder)/1024**3 -lt 5 ]] ; then
echo "Vous avez moins de 5 Go d'espace libre sur le disque où se trouve $safe_folder. Vous aurez besoin de plus d'espace pour continuer"
df -h $safe_folder
echo
if tty >/dev/null; then
read -p "Souhaitez-vous tenter de libérer de l'espace en nettoyant les images et les conteneurs Docker du système ? (o/N)" -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]
then
$docker_path container prune --force --filter until=24h >/dev/null
$docker_path image prune --all --force --filter until=24h >/dev/null
echo "Si le nettoyage a réussi, vous pouvez réessayer maintenant"
fi
fi
exit 1
fi
# 8. le fichier de définition du conteneur est-il accessible et n'est-il pas non sécurisé (lisible par tous) ?
if [[ ! -e "$config_file" || ! -r "$config_file" ]]; then
echo "ERREUR : $config_file n'existe pas ou n'est pas lisible."
echo
echo "Configurations disponibles ( `cd containers && ls -dm *.yml | tr -s '\n' ' ' | awk '{ gsub(/\.yml/, ""); print }'`)"
exit 1
elif [[ "$(find $config_file -perm -004)" ]]; then
echo "AVERTISSEMENT : Le fichier $config_file est lisible par tous. Vous pouvez sécuriser ce fichier en exécutant : chmod o-rwx $config_file"
fi
}
if [ -z "$SKIP_PREREQS" ] && [ "$command" != "cleanup" ]; then
check_prereqs
fi
set_volumes() {
volumes=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['volumes'].map{|v| '-v ' << v['volume']['host'] << ':' << v['volume']['guest'] << ' '}.join"`
}
set_links() {
links=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['links'].map{|l| '--link ' << l['link']['name'] << ':' << l['link']['alias'] << ' '}.join"`
}
find_templates() {
local templates=`cat $1 | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['templates']"`
local arrTemplates=${templates// / }
if [ ! -z "$templates" ]; then
echo $templates
else
echo ""
fi
}
set_template_info() {
templates=$(find_templates $config_file)
arrTemplates=(${templates// / })
config_data=$(cat $config_file)
input="hack: true"
for template in "${arrTemplates[@]}"
do
[ ! -z $template ] && {
input="$input _FILE_SEPERATOR_ $(cat $template)"
}
done
# nous voulons toujours que notre fichier de configuration soit en dernier pour qu'il prenne la priorité
input="$input _FILE_SEPERATOR_ $config_data"
read -r -d '' env_ruby << 'RUBY'
require 'yaml'
input=STDIN.readlines.join
# par défaut en UTF-8 pour la base de données
env = {'LANG' => 'en_US.UTF-8'}
input.split('_FILE_SEPERATOR_').each do |yml|
yml.strip!
begin
env.merge!(YAML.load(yml)['env'] || {})
rescue Psych::SyntaxError => e
puts e
puts "*ERREUR."
rescue => e
puts yml
p e
end
end
env.each{|k,v| puts "*ERREUR." if v.is_a?(Hash)}
puts env.map{|k,v| "-e\n#{k}=#{v}" }.join("\n")
RUBY
tmp_input_file=$(mktemp)
echo "$input" > "$tmp_input_file"
raw=`exec cat "$tmp_input_file" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$env_ruby"`
rm -f "$tmp_input_file"
env=()
ok=1
while read i; do
if [ "$i" == "*ERREUR." ]; then
ok=0
elif [ -n "$i" ]; then
env[${#env[@]}]="${i//\{\{config\}\}/${config}}"
fi
done <<< "$raw"
if [ "$ok" -ne 1 ]; then
echo "${env[@]}"
echo "Erreur de syntaxe YAML. Veuillez vérifier vos fichiers de configuration containers/*.yml."
exit 1
fi
# étiquettes
read -r -d '' labels_ruby << 'RUBY'
require 'yaml'
input=STDIN.readlines.join
labels = {}
input.split('_FILE_SEPERATOR_').each do |yml|
yml.strip!
begin
labels.merge!(YAML.load(yml)['labels'] || {})
rescue Psych::SyntaxError => e
puts e
puts "*ERREUR."
rescue => e
puts yml
p e
end
end
puts labels.map{|k,v| "-l\n#{k}=#{v}" }.join("\n")
RUBY
tmp_input_file=$(mktemp)
echo "$input" > "$tmp_input_file"
raw=`exec cat "$tmp_input_file" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$labels_ruby"`
rm -f "$tmp_input_file"
labels=()
ok=1
while read i; do
if [ "$i" == "*ERREUR." ]; then
ok=0
elif [ -n "$i" ]; then
labels[${#labels[@]}]=$(echo $i | sed s/{{config}}/${config}/g)
fi
done <<< "$raw"
if [ "$ok" -ne 1 ]; then
echo "${labels[@]}"
echo "Erreur de syntaxe YAML. Veuillez vérifier vos fichiers de configuration containers/*.yml."
exit 1
fi
# exposer
read -r -d '' ports_ruby << 'RUBY'
require 'yaml'
input=STDIN.readlines.join
ports = []
input.split('_FILE_SEPERATOR_').each do |yml|
yml.strip!
begin
ports += (YAML.load(yml)['expose'] || [])
rescue Psych::SyntaxError => e
puts e
puts "*ERREUR."
rescue => e
puts yml
p e
end
end
puts ports.map { |p| p.to_s.include?(':') ? "-p\n#{p}" : "--expose\n#{p}" }.join("\n")
RUBY
tmp_input_file=$(mktemp)
echo "$input" > "$tmp_input_file"
raw=`exec cat "$tmp_input_file" | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e "$ports_ruby"`
rm -f "$tmp_input_file"
ports=()
ok=1
while read i; do
if [ "$i" == "*ERREUR." ]; then
ok=0
elif [ -n "$i" ]; then
ports[${#ports[@]}]=$i
fi
done <<< "$raw"
if [ "$ok" -ne 1 ]; then
echo "${ports[@]}"
echo "Erreur de syntaxe YAML. Veuillez vérifier vos fichiers de configuration containers/*.yml."
exit 1
fi
merge_user_args
}
if [ -z $docker_path ]; then
install_docker
fi
[ "$command" == "cleanup" ] && {
$docker_path container prune --filter until=1h
$docker_path image prune --all --filter until=1h
if [ -d /var/discourse/shared/standalone/postgres_data_old ]; then
echo
echo "Ancien cluster de données de sauvegarde PostgreSQL détecté occupant $(du -hs /var/discourse/shared/standalone/postgres_data_old | awk '{print $1}') détecté"
read -p "Souhaitez-vous le supprimer ? (o/N): " -n 1 -r && echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
echo "suppression de l'ancien cluster de données PostgreSQL à /var/discourse/shared/standalone/postgres_data_old..."
rm -rf /var/discourse/shared/standalone/postgres_data_old*
else
exit 1
fi
fi
exit 0
}
docker_version=($($docker_path --version))
docker_version=${test[2]//,/}
restart_policy=${restart_policy:---restart=always}
set_existing_container(){
existing=`$docker_path ps -a | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
}
run_stop() {
set_existing_container
if [ ! -z $existing ]
then
(
set -x
$docker_path stop -t 30 $config
)
else
echo "$config n'a pas été démarré !"
echo "./discourse-doctor peut aider à diagnostiquer le problème."
exit 1
fi
}
set_run_image() {
run_image=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['run_image']"`
if [ -n "$user_run_image" ]; then
run_image=$user_run_image
elif [ -z "$run_image" ]; then
run_image="$local_discourse/$config"
fi
}
set_boot_command() {
boot_command=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['boot_command']"`
if [ -z "$boot_command" ]; then
no_boot_command=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['no_boot_command']"`
if [ -z "$no_boot_command" ]; then
boot_command="/sbin/boot"
fi
fi
}
merge_user_args() {
local docker_args
docker_args=`cat $config_file | $docker_path run $user_args --rm -i -a stdout -a stdin $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['docker_args']"`
if [[ -n "$docker_args" ]]; then
user_args="$user_args_argv $docker_args"
fi
}
run_start() {
if [ -z "$START_CMD_ONLY" ]
then
existing=`$docker_path ps | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
echo $existing
if [ ! -z $existing ]
then
echo "Rien à faire, votre conteneur a déjà été démarré !"
exit 0
fi
existing=`$docker_path ps -a | awk '{ print $1, $(NF) }' | grep " $config$" | awk '{ print $1 }'`
if [ ! -z $existing ]
then
echo "démarrage du conteneur existant"
(
set -x
$docker_path start $config
)
exit 0
fi
fi
set_template_info
set_volumes
set_links
set_run_image
set_boot_command
# obtenir le nom d'hôte et les paramètres depuis la configuration du conteneur
for envar in "${env[@]}"
do
if [[ $envar == DOCKER_USE_HOSTNAME* ]] || [[ $envar == DISCOURSE_HOSTNAME* ]]
then
# utiliser comme variable d'environnement
eval $envar
fi
done
(
hostname=`hostname -s`
# écraser le nom d'hôte
if [ "$DOCKER_USE_HOSTNAME" = "true" ]
then
hostname=$DISCOURSE_HOSTNAME
else
hostname=$hostname-$config
fi
# nous devons normaliser pour n'avoir que des chaînes autorisées, c'est plus complet mais voyons comment bash fait d'abord
# hostname=`$docker_path run $user_args --rm $image ruby -e 'print ARGV[0].gsub(/[^a-zA-Z-]/, "-")' $hostname`
# docker a ajouté plus de règles de nom d'hôte
hostname=${hostname//_/-}
if [ -z "$SKIP_MAC_ADDRESS" ] ; then
mac_address="--mac-address $($docker_path run $user_args -i --rm -a stdout -a stderr $image /bin/sh -c "echo $hostname | md5sum | sed 's/^\(..\)\(..\)\(..\)\(..\)\(..\).*$/02:\1:\2:\3:\4:\5/'")"
fi
if [ ! -z "$START_CMD_ONLY" ] ; then
docker_path="true"
fi
set -x
$docker_path run --shm-size=512m $links $attach_on_run $restart_policy "${env[@]}" "${labels[@]}" -h "$hostname" \
-e DOCKER_HOST_IP="$docker_ip" --name $config -t "${ports[@]}" $volumes $mac_address $user_args \
$run_image $boot_command
)
exit 0
}
run_run() {
set_template_info
set_volumes
set_links
set_run_image
unset ERR
(exec $docker_path run --rm --shm-size=512m $user_args $links "${env[@]}" -e DOCKER_HOST_IP="$docker_ip" -i -a stdin -a stdout -a stderr $volumes $run_image \
/bin/bash -c "$run_command") || ERR=$?
if [[ $ERR > 0 ]]; then
exit 1
fi
}
run_bootstrap() {
set_template_info
base_image=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['base_image']"`
update_pups=`cat $config_file | $docker_path run $user_args --rm -i -a stdin -a stdout $image ruby -e \
"require 'yaml'; puts YAML.load(STDIN.readlines.join)['update_pups']"`
if [[ ! X"" = X"$base_image" ]]; then
image=$base_image
fi
# l'image de base n'est peut-être pas toujours discourse/base,
# assurons-nous de toujours construire à partir de la dernière version
pull_image
set_volumes
set_links
if $docker_path run $user_args --rm -i $image gem which pups; then
pups_command="/usr/local/bin/pups --stdin"
else
# Retour à la méthode git pull ici si `pups` n'a pas été installé par gem dans l'image de base
pups_command="cd /pups &&"
if [[ ! "false" = $update_pups ]]; then
pups_command="$pups_command git pull && git checkout $pups_version &&"
fi
pups_command="$pups_command /pups/bin/pups --stdin"
fi
echo $pups_command
declare -i BOOTSTRAP_EXITCODE
rm -f $cidbootstrap
echo "$input" | $docker_path run --shm-size=512m $user_args $links "${env[@]}" -e DOCKER_HOST_IP="$docker_ip" --cidfile "$cidbootstrap" -i -a stdin -a stdout -a stderr $volumes $image \
/bin/bash -c "$pups_command"
BOOTSTRAP_EXITCODE=$?
CONTAINER_ID=$(cat "$cidbootstrap")
rm -f "$cidbootstrap"
# code de sortie magique indiquant une nouvelle tentative
if [[ $BOOTSTRAP_EXITCODE -eq 77 ]]; then
$docker_path rm "$CONTAINER_ID"
exit 77
elif [[ $BOOTSTRAP_EXITCODE -gt 0 ]]; then
echo "l'initialisation a échoué avec le code de sortie $BOOTSTRAP_EXITCODE"
echo "** ÉCHEC DE L'INITIALISATION ** veuillez faire défiler vers le haut et rechercher les messages d'erreur antérieurs, il peut y en avoir plus d'un."
echo "./discourse-doctor peut aider à diagnostiquer le problème."
if [[ -n "$DEBUG" ]]; then
if $docker_path commit "$CONTAINER_ID" $local_discourse/$config-debug; then
echo "** DEBUG ** Maintien de l'image pour le diagnostic $local_discourse/$config-debug"
else
echo "** DEBUG ** Échec de l'engagement du conteneur $CONTAINER_ID pour le diagnostic"
fi
fi
$docker_path rm "$CONTAINER_ID"
exit 1
fi
sleep 5
$docker_path commit \
-c "LABEL org.opencontainers.image.created=\"$(TZ=UTC date -Iseconds)\"" \
"$CONTAINER_ID" \
$local_discourse/$config || fatal "ÉCHEC DE L'ENGAGEMENT $CONTAINER_ID"
$docker_path rm "$CONTAINER_ID"
}
case "$command" in
bootstrap)
run_bootstrap
echo "Initialisation réussie, pour démarrer utilisez ./launcher start $config"
exit 0
;;
run)
run_run
exit 0
;;
enter)
exec $docker_path exec -it $config /bin/bash --login
;;
stop)
run_stop
exit 0
;;
logs)
$docker_path logs $config
exit 0
;;
restart)
run_stop
run_start
exit 0
;;
start-cmd)
START_CMD_ONLY="1"
run_start
exit 0;
;;
start)
run_start
exit 0
;;
rebuild)
if [ "$(git symbolic-ref --short HEAD)" == "master" ]; then
git branch -m master main
git fetch origin
git branch -u origin/main main
git remote set-head origin -a
fi
if [ "$(git symbolic-ref --short HEAD)" == "main" ]; then
echo "Assurance que le lanceur est à jour"
git remote update
LOCAL=$(git rev-parse HEAD)
REMOTE=$(git rev-parse @{u})
BASE=$(git merge-base HEAD @{u})
if [ $LOCAL = $REMOTE ]; then
echo "Le lanceur est à jour"
elif [ $LOCAL = $BASE ]; then
echo "Mise à jour du lanceur..."
git pull || (echo 'échec de la mise à jour' && exit 1)
echo "Lanceur mis à jour, redémarrage..."
exec "$0" "${SAVED_ARGV[@]}"
elif [ $REMOTE = $BASE ]; then
echo "Votre version du lanceur est en avance sur origin"
else
echo "Le lanceur a divergé de la source, cela n'est attendu qu'en mode Dev"
fi
fi
set_existing_container
if [ ! -z $existing ]
then
echo "Arrêt de l'ancien conteneur"
(
set -x
$docker_path stop -t 60 $config
)
fi
run_bootstrap
if [ ! -z $existing ]
then
echo "Suppression de l'ancien conteneur"
(
set -x
$docker_path rm $config
)
fi
run_start
exit 0
;;
destroy)
(set -x; $docker_path stop -t 10 $config && $docker_path rm $config) || (echo "$config n'a pas été trouvé" && exit 0)
exit 0
;;
esac
usage
Pour conclure, une petite aide de PM a révélé qu’il s’agissait d’un problème maxmind et que le commenter a permis au bootstrap de se terminer avec succès. 