1170 lines
40 KiB
Bash
Executable File
1170 lines
40 KiB
Bash
Executable File
#!/usr/bin/env bash
|
||
|
||
#
|
||
# Linux BenchTools - Client Benchmark Script
|
||
# Version: 1.1.0
|
||
#
|
||
# Collecte les informations hardware, exécute les benchmarks
|
||
# puis envoie les résultats au serveur backend (payload JSON).
|
||
#
|
||
|
||
set -e
|
||
|
||
#=========================================================
|
||
# Version / variables globales
|
||
#=========================================================
|
||
|
||
BENCH_SCRIPT_VERSION="1.2.0"
|
||
|
||
# Couleurs
|
||
GREEN='\033[0;32m'
|
||
YELLOW='\033[1;33m'
|
||
RED='\033[0;31m'
|
||
BLUE='\033[0;34m'
|
||
NC='\033[0m' # No Color
|
||
|
||
TOTAL_STEPS=8
|
||
CURRENT_STEP=0
|
||
|
||
# Paramètres réseau / API (fixés)
|
||
SERVER_URL="10.0.1.97:8007" # ajouter le port ou le schéma dans send_benchmark_payload si besoin
|
||
API_TOKEN="29855796dacf5cfe75ff9b02d6adf3dd0f9c52db5b53e7abfb4c0df7ece1be0a"
|
||
IPERF_SERVER="10.0.1.97"
|
||
|
||
# Mode DEBUG
|
||
# Mettre à 1 pour afficher le payload JSON complet avant envoi
|
||
# Mettre à 0 pour désactiver le debug
|
||
DEBUG_PAYLOAD="${DEBUG_PAYLOAD:-1}" # Par défaut: 1 (activé)
|
||
# Peut être désactivé via: DEBUG_PAYLOAD=0 bash bench.sh
|
||
|
||
# Forcer locale en anglais pour parsing
|
||
export LC_ALL=C
|
||
|
||
# Ajouter /usr/sbin au PATH pour dmidecode, smartctl, ethtool
|
||
export PATH="/usr/sbin:/sbin:$PATH"
|
||
|
||
# Variables JSON globales
|
||
SYSTEM_INFO="null"
|
||
CPU_INFO="null"
|
||
RAM_INFO="null"
|
||
GPU_INFO="null"
|
||
MOTHERBOARD_INFO="null"
|
||
STORAGE_INFO="[]"
|
||
NETWORK_INFO="[]"
|
||
BENCHMARK_RESULTS="null"
|
||
|
||
#=========================================================
|
||
# Affichage / logs
|
||
#=========================================================
|
||
|
||
log_step() {
|
||
CURRENT_STEP=$((CURRENT_STEP + 1))
|
||
echo -e "${BLUE}[${CURRENT_STEP}/${TOTAL_STEPS}]${NC} $1"
|
||
}
|
||
|
||
log_info() {
|
||
echo -e " ${GREEN}✓${NC} $1"
|
||
}
|
||
|
||
log_warn() {
|
||
echo -e " ${YELLOW}⚠${NC} $1"
|
||
}
|
||
|
||
log_error() {
|
||
echo -e " ${RED}✗${NC} $1"
|
||
}
|
||
|
||
#=========================================================
|
||
# sudo + dépendances
|
||
#=========================================================
|
||
|
||
check_sudo() {
|
||
echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
|
||
echo -e " Linux BenchTools - Client Benchmark Script"
|
||
echo -e " Version ${BENCH_SCRIPT_VERSION}"
|
||
echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
|
||
echo ""
|
||
echo "Ce script nécessite les permissions sudo pour :"
|
||
echo " - dmidecode (infos RAM, carte mère, BIOS)"
|
||
echo " - smartctl (infos disques)"
|
||
echo " - ethtool (vitesse réseau)"
|
||
echo ""
|
||
|
||
if ! sudo -v; then
|
||
log_error "Permissions sudo requises. Relance le script avec sudo."
|
||
exit 1
|
||
fi
|
||
|
||
# Garder sudo actif
|
||
while true; do sudo -n true; sleep 50; kill -0 "$$" || exit; done 2>/dev/null &
|
||
|
||
log_info "Permissions sudo OK"
|
||
echo ""
|
||
}
|
||
|
||
check_dependencies() {
|
||
local missing=()
|
||
local bench_missing=()
|
||
|
||
echo -e "${BLUE}Vérification des dépendances...${NC}"
|
||
|
||
for tool in curl jq lscpu free lsblk ip bc smartctl; do
|
||
command -v "$tool" &>/dev/null || missing+=("$tool")
|
||
done
|
||
|
||
for tool in sysbench fio iperf3; do
|
||
command -v "$tool" &>/dev/null || bench_missing+=("$tool")
|
||
done
|
||
|
||
if [[ ${#missing[@]} -eq 0 && ${#bench_missing[@]} -eq 0 ]]; then
|
||
log_info "Toutes les dépendances de base sont présentes"
|
||
log_info "Vérification des dépendances terminée"
|
||
echo ""
|
||
return
|
||
fi
|
||
|
||
echo ""
|
||
if [[ ${#missing[@]} -gt 0 ]]; then
|
||
log_warn "Outils systèmes manquants: ${missing[*]}"
|
||
fi
|
||
if [[ ${#bench_missing[@]} -gt 0 ]]; then
|
||
log_warn "Outils de benchmark manquants: ${bench_missing[*]}"
|
||
fi
|
||
|
||
if ! command -v apt-get &>/dev/null; then
|
||
log_warn "apt-get non disponible, installation automatique impossible."
|
||
log_info "Vérification des dépendances terminée"
|
||
echo ""
|
||
return
|
||
fi
|
||
|
||
declare -A pkg_map=(
|
||
[curl]="curl"
|
||
[jq]="jq"
|
||
[lscpu]="util-linux"
|
||
[free]="procps"
|
||
[lsblk]="util-linux"
|
||
[ip]="iproute2"
|
||
[bc]="bc"
|
||
[smartctl]="smartmontools"
|
||
[sysbench]="sysbench"
|
||
[fio]="fio"
|
||
[iperf3]="iperf3"
|
||
)
|
||
|
||
local to_install=()
|
||
for t in "${missing[@]}" "${bench_missing[@]}"; do
|
||
[[ -n "${pkg_map[$t]}" ]] && to_install+=("${pkg_map[$t]}")
|
||
done
|
||
|
||
if [[ ${#to_install[@]} -gt 0 ]]; then
|
||
mapfile -t to_install < <(printf '%s\n' "${to_install[@]}" | sort -u)
|
||
echo -e "${BLUE}Installation automatique des paquets manquants...${NC}"
|
||
echo " Paquets: ${to_install[*]}"
|
||
echo ""
|
||
echo "► apt-get update..."
|
||
if ! sudo apt-get update -qq 2>&1 | grep -v "Policy will reject signature"; then
|
||
log_warn "Warning durant apt-get update (on continue)"
|
||
fi
|
||
echo "► apt-get install..."
|
||
if sudo apt-get install -y "${to_install[@]}"; then
|
||
log_info "Installation des dépendances OK"
|
||
else
|
||
log_error "Échec de l'installation des dépendances"
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
log_info "Vérification des dépendances terminée"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Utilitaire bc robuste
|
||
#=========================================================
|
||
|
||
safe_bc() {
|
||
local expr="$1"
|
||
local out
|
||
out=$(echo "$expr" | bc 2>/dev/null) || out="0"
|
||
echo "$out"
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 1 : Système
|
||
#=========================================================
|
||
|
||
collect_system_info() {
|
||
log_step "Collecte des informations système de base"
|
||
|
||
local hostname os_name os_version kernel arch
|
||
|
||
hostname=$(hostname)
|
||
os_name=$(grep '^ID=' /etc/os-release | cut -d= -f2 | tr -d '"')
|
||
os_version=$(grep '^VERSION=' /etc/os-release | cut -d= -f2 | tr -d '"')
|
||
kernel=$(uname -r)
|
||
arch=$(uname -m)
|
||
|
||
SYSTEM_INFO=$(jq -n \
|
||
--arg hostname "$hostname" \
|
||
--arg os_name "$os_name" \
|
||
--arg os_version "$os_version" \
|
||
--arg kernel "$kernel" \
|
||
--arg arch "$arch" \
|
||
'{
|
||
hostname: $hostname,
|
||
os: {
|
||
name: $os_name,
|
||
version: $os_version,
|
||
kernel_version: $kernel,
|
||
architecture: $arch
|
||
}
|
||
}')
|
||
|
||
log_info "Hostname: $hostname"
|
||
log_info "OS: $os_name $os_version"
|
||
log_info "Kernel: $kernel"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 2 : CPU
|
||
#=========================================================
|
||
|
||
collect_cpu_info() {
|
||
log_step "Collecte des informations CPU"
|
||
|
||
local vendor model cores threads
|
||
vendor=$(lscpu | awk -F: '/Vendor ID/ {gsub(/^[ \t]+/,"",$2); print $2}')
|
||
model=$(lscpu | awk -F: '/Model name/ {gsub(/^[ \t]+/,"",$2); print $2}')
|
||
|
||
# Calcul du nombre de cores physiques: Core(s) per socket × Socket(s)
|
||
local cores_per_socket sockets
|
||
cores_per_socket=$(lscpu | awk -F: '/Core\(s\) per socket/ {gsub(/^[ \t]+/,"",$2); gsub(/[^0-9]/,"",$2); print $2}')
|
||
sockets=$(lscpu | awk -F: '/Socket\(s\)/ {gsub(/^[ \t]+/,"",$2); gsub(/[^0-9]/,"",$2); print $2}')
|
||
|
||
# S'assurer que les valeurs sont des nombres valides
|
||
[[ -z "$cores_per_socket" || "$cores_per_socket" == "0" ]] && cores_per_socket=1
|
||
[[ -z "$sockets" || "$sockets" == "0" ]] && sockets=1
|
||
|
||
cores=$((cores_per_socket * sockets))
|
||
|
||
threads=$(nproc)
|
||
|
||
local cpu_mhz cpu_max_mhz base_freq_ghz max_freq_ghz
|
||
cpu_mhz=$(lscpu | awk -F: '/CPU MHz/ {gsub(/^[ \t]+/,"",$2); print $2}')
|
||
cpu_max_mhz=$(lscpu | awk -F: '/CPU max MHz/ {gsub(/^[ \t]+/,"",$2); print $2}')
|
||
|
||
base_freq_ghz="null"
|
||
max_freq_ghz="null"
|
||
if [[ -n "$cpu_mhz" ]]; then
|
||
base_freq_ghz=$(safe_bc "scale=2; $cpu_mhz / 1000")
|
||
fi
|
||
if [[ -n "$cpu_max_mhz" ]]; then
|
||
max_freq_ghz=$(safe_bc "scale=2; $cpu_max_mhz / 1000")
|
||
fi
|
||
|
||
local cache_l1_kb cache_l2_kb cache_l3_kb
|
||
# L1 cache = L1d + L1i
|
||
# Parser format: "384 KiB (12 instances)" ou "6 MiB (12 instances)"
|
||
# Extraire le premier nombre + unité, ignorer "(X instances)"
|
||
# Utilisation de sed pour extraire "nombre unité" puis awk pour convertir MiB en KB
|
||
local cache_l1d cache_l1i
|
||
cache_l1d=$(lscpu | grep 'L1d cache' | sed -n 's/.*:\s*\([0-9]\+\)\s*\(KiB\|MiB\).*/\1 \2/p' | awk '{if ($2 == "MiB") print $1*1024; else print $1}')
|
||
cache_l1i=$(lscpu | grep 'L1i cache' | sed -n 's/.*:\s*\([0-9]\+\)\s*\(KiB\|MiB\).*/\1 \2/p' | awk '{if ($2 == "MiB") print $1*1024; else print $1}')
|
||
cache_l1_kb=$((${cache_l1d:-0} + ${cache_l1i:-0}))
|
||
|
||
cache_l2_kb=$(lscpu | grep 'L2 cache' | sed -n 's/.*:\s*\([0-9]\+\)\s*\(KiB\|MiB\).*/\1 \2/p' | awk '{if ($2 == "MiB") print $1*1024; else print $1}')
|
||
cache_l3_kb=$(lscpu | grep 'L3 cache' | sed -n 's/.*:\s*\([0-9]\+\)\s*\(KiB\|MiB\).*/\1 \2/p' | awk '{if ($2 == "MiB") print $1*1024; else print $1}')
|
||
|
||
local flags
|
||
flags=$(lscpu | awk -F: '/Flags/ {gsub(/^[ \t]+/,"",$2); print $2}')
|
||
local flags_array
|
||
flags_array=$(printf '%s\n' $flags | jq -R . | jq -s .)
|
||
|
||
# Important: on passe les numériques en --arg (string) puis on cast dans jq
|
||
CPU_INFO=$(jq -n \
|
||
--arg vendor "$vendor" \
|
||
--arg model "$model" \
|
||
--arg cores "$cores" \
|
||
--arg threads "$threads" \
|
||
--arg base_freq "$base_freq_ghz" \
|
||
--arg max_freq "$max_freq_ghz" \
|
||
--arg l1 "$cache_l1_kb" \
|
||
--arg l2 "$cache_l2_kb" \
|
||
--arg l3 "$cache_l3_kb" \
|
||
--argjson flags "$flags_array" \
|
||
'{
|
||
vendor: $vendor,
|
||
model: $model,
|
||
cores: ($cores | tonumber? // 0),
|
||
threads: ($threads | tonumber? // 0),
|
||
base_freq_ghz: (if $base_freq == "null" or $base_freq == "" then null else ($base_freq | tonumber?) end),
|
||
max_freq_ghz: (if $max_freq == "null" or $max_freq == "" then null else ($max_freq | tonumber?) end),
|
||
cache_l1_kb: ($l1 | tonumber? // 0),
|
||
cache_l2_kb: ($l2 | tonumber? // 0),
|
||
cache_l3_kb: ($l3 | tonumber? // 0),
|
||
flags: $flags
|
||
}')
|
||
|
||
log_info "CPU: $model"
|
||
log_info "Cores: ${cores:-0}, Threads: ${threads:-0}"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 3 : RAM
|
||
#=========================================================
|
||
|
||
collect_ram_info() {
|
||
log_step "Collecte des informations RAM"
|
||
|
||
local mem_total_kb mem_used_kb mem_free_kb mem_shared_kb
|
||
mem_total_kb=$(free -k | awk '/^Mem:/ {print $2}')
|
||
mem_used_kb=$(free -k | awk '/^Mem:/ {print $3}')
|
||
mem_free_kb=$(free -k | awk '/^Mem:/ {print $4}')
|
||
mem_shared_kb=$(free -k | awk '/^Mem:/ {print $5}')
|
||
|
||
local total_mb used_mb free_mb shared_mb
|
||
total_mb=$((mem_total_kb / 1024))
|
||
used_mb=$((mem_used_kb / 1024))
|
||
free_mb=$((mem_free_kb / 1024))
|
||
shared_mb=$((mem_shared_kb / 1024))
|
||
|
||
local slots_total=0 slots_used=0 ecc=false
|
||
local dimm_layout="[]"
|
||
|
||
if command -v dmidecode &>/dev/null; then
|
||
log_info "[DEBUG] Vérification dmidecode..."
|
||
if sudo dmidecode -t 16 &>/dev/null; then
|
||
log_info "[DEBUG] dmidecode trouvé: $(command -v dmidecode)"
|
||
else
|
||
log_warn "dmidecode accessible mais aucune info DMI"
|
||
fi
|
||
|
||
local slots
|
||
slots=$(sudo dmidecode -t 16 2>/dev/null | awk -F: '/Number Of Devices/ {gsub(/^[ \t]+/,"",$2); print $2}' | head -1)
|
||
[[ -n "$slots" ]] && slots_total="$slots"
|
||
|
||
if sudo dmidecode -t memory 2>/dev/null | grep -q 'Error Correction Type'; then
|
||
if sudo dmidecode -t memory 2>/dev/null | grep 'Error Correction Type' | grep -q 'None'; then
|
||
ecc=false
|
||
else
|
||
ecc=true
|
||
fi
|
||
fi
|
||
|
||
local dimm_data
|
||
dimm_data=$(sudo dmidecode -t 17 | grep -E 'Locator:|Size:|Type:|Speed:|Manufacturer:' | \
|
||
awk '
|
||
/Locator:/ && !/Bank/ { slot=$2; gsub(/_/, "", slot) }
|
||
/Size:/ && /[0-9]+ [GM]B/ {
|
||
size=$2;
|
||
if ($3 == "GB") size=size*1024;
|
||
if ($3 == "MB") size=size;
|
||
}
|
||
/Type:/ && !/Detail/ { type=$2 }
|
||
/Speed:/ && /MHz/ { speed=$2 }
|
||
/Manufacturer:/ {
|
||
manu=$2;
|
||
printf "%s;%s;%s;%s;%s\n", slot, size, type, speed, manu
|
||
}')
|
||
|
||
if [[ -n "$dimm_data" ]]; then
|
||
while IFS=';' read -r slot size type speed manu; do
|
||
[[ -z "$slot" ]] && continue
|
||
slots_used=$((slots_used + 1))
|
||
local entry
|
||
entry=$(jq -n \
|
||
--arg slot "$slot" \
|
||
--arg size_mb "$size" \
|
||
--arg type "$type" \
|
||
--arg speed_mhz "$speed" \
|
||
--arg manu "$manu" \
|
||
'{
|
||
slot: $slot,
|
||
size_mb: ($size_mb | tonumber? // 0),
|
||
type: $type,
|
||
speed_mhz: ($speed_mhz | tonumber? // 0),
|
||
manufacturer: $manu
|
||
}')
|
||
dimm_layout=$(echo "$dimm_layout" | jq --argjson e "$entry" '. + [$e]')
|
||
done <<< "$dimm_data"
|
||
fi
|
||
else
|
||
log_warn "dmidecode non disponible - layout RAM détaillé ignoré"
|
||
fi
|
||
|
||
RAM_INFO=$(jq -n \
|
||
--arg total_mb "$total_mb" \
|
||
--arg used_mb "$used_mb" \
|
||
--arg free_mb "$free_mb" \
|
||
--arg shared_mb "$shared_mb" \
|
||
--arg slots_total "$slots_total" \
|
||
--arg slots_used "$slots_used" \
|
||
--arg ecc_str "$([[ "$ecc" = true ]] && echo true || echo false)" \
|
||
--argjson layout "$dimm_layout" \
|
||
'{
|
||
total_mb: ($total_mb | tonumber? // 0),
|
||
used_mb: ($used_mb | tonumber? // 0),
|
||
free_mb: ($free_mb | tonumber? // 0),
|
||
shared_mb: ($shared_mb | tonumber? // 0),
|
||
slots_total: ($slots_total | tonumber? // 0),
|
||
slots_used: ($slots_used | tonumber? // 0),
|
||
ecc: (if $ecc_str == "true" then true else false end),
|
||
layout: $layout
|
||
}')
|
||
|
||
log_info "RAM Total: ${total_mb}MB (Utilisée: ${used_mb}MB, Libre: ${free_mb}MB)"
|
||
log_info "Slots: ${slots_used}/${slots_total}"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 4 : GPU / Carte mère
|
||
#=========================================================
|
||
|
||
collect_hardware_info() {
|
||
log_step "Collecte GPU, Carte mère, BIOS"
|
||
|
||
local gpu_vendor="null"
|
||
local gpu_model="null"
|
||
local gpu_vram="null"
|
||
local gpu_driver="null"
|
||
|
||
if command -v lspci &>/dev/null; then
|
||
local gpu_line
|
||
gpu_line=$(lspci | grep -iE 'vga|3d' | head -1)
|
||
if [[ -n "$gpu_line" ]]; then
|
||
gpu_model=$(echo "$gpu_line" | sed 's/.*: //')
|
||
if echo "$gpu_line" | grep -qi 'nvidia'; then
|
||
gpu_vendor="NVIDIA"
|
||
# Essayer d'obtenir plus d'infos avec nvidia-smi
|
||
if command -v nvidia-smi &>/dev/null; then
|
||
local nvidia_model nvidia_vram nvidia_driver
|
||
nvidia_model=$(nvidia-smi --query-gpu=name --format=csv,noheader 2>/dev/null | head -1)
|
||
nvidia_vram=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits 2>/dev/null | head -1)
|
||
nvidia_driver=$(nvidia-smi --query-gpu=driver_version --format=csv,noheader 2>/dev/null | head -1)
|
||
|
||
[[ -n "$nvidia_model" ]] && gpu_model="$nvidia_model"
|
||
[[ -n "$nvidia_vram" ]] && gpu_vram="$nvidia_vram"
|
||
[[ -n "$nvidia_driver" ]] && gpu_driver="$nvidia_driver"
|
||
fi
|
||
elif echo "$gpu_line" | grep -qi 'amd'; then
|
||
gpu_vendor="AMD"
|
||
elif echo "$gpu_line" | grep -qi 'intel'; then
|
||
gpu_vendor="Intel"
|
||
else
|
||
gpu_vendor="Unknown"
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
GPU_INFO=$(jq -n \
|
||
--arg vendor "$gpu_vendor" \
|
||
--arg model "$gpu_model" \
|
||
--arg vram "$gpu_vram" \
|
||
--arg driver "$gpu_driver" \
|
||
'{
|
||
vendor: $vendor,
|
||
model: $model,
|
||
memory_dedicated_mb: (if $vram == "null" or $vram == "" then null else ($vram | tonumber?) end),
|
||
driver_version: (if $driver == "null" or $driver == "" then null else $driver end)
|
||
}')
|
||
|
||
if [[ "$gpu_model" != "null" ]]; then
|
||
if [[ "$gpu_vram" != "null" ]]; then
|
||
log_info "GPU: $gpu_model (${gpu_vram}MB VRAM)"
|
||
else
|
||
log_info "GPU: $gpu_model"
|
||
fi
|
||
else
|
||
log_warn "GPU non détecté"
|
||
fi
|
||
|
||
local mb_manufacturer="Unknown" mb_model="Unknown"
|
||
local bios_vendor="Unknown" bios_version="Unknown" bios_date="Unknown"
|
||
|
||
if command -v dmidecode &>/dev/null; then
|
||
mb_manufacturer=$(sudo dmidecode -s baseboard-manufacturer 2>/dev/null || echo "Unknown")
|
||
mb_model=$(sudo dmidecode -s baseboard-product-name 2>/dev/null || echo "Unknown")
|
||
bios_vendor=$(sudo dmidecode -s bios-vendor 2>/dev/null || echo "Unknown")
|
||
bios_version=$(sudo dmidecode -s bios-version 2>/dev/null || echo "Unknown")
|
||
bios_date=$(sudo dmidecode -s bios-release-date 2>/dev/null || echo "Unknown")
|
||
fi
|
||
|
||
MOTHERBOARD_INFO=$(jq -n \
|
||
--arg manu "$mb_manufacturer" \
|
||
--arg model "$mb_model" \
|
||
--arg bvend "$bios_vendor" \
|
||
--arg bver "$bios_version" \
|
||
--arg bdate "$bios_date" \
|
||
'{
|
||
manufacturer: $manu,
|
||
model: $model,
|
||
bios_vendor: $bvend,
|
||
bios_version: $bver,
|
||
bios_date: $bdate
|
||
}')
|
||
|
||
log_info "Motherboard: $mb_manufacturer $mb_model"
|
||
log_info "BIOS: $bios_version ($bios_date)"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 5 : Stockage
|
||
#=========================================================
|
||
|
||
collect_storage_info() {
|
||
log_step "Collecte des informations de stockage"
|
||
|
||
local storage_array="[]"
|
||
local disks
|
||
disks=$(lsblk -d -n -o NAME,TYPE | awk '$2=="disk"{print $1}')
|
||
|
||
for d in $disks; do
|
||
local size_h size_gb rota tran
|
||
size_h=$(lsblk -d -n -o SIZE "/dev/$d")
|
||
rota=$(lsblk -d -n -o ROTA "/dev/$d")
|
||
tran=$(lsblk -d -n -o TRAN "/dev/$d")
|
||
|
||
local disk_type="unknown"
|
||
[[ "$rota" = "0" ]] && disk_type="ssd" || disk_type="hdd"
|
||
|
||
local interface="unknown"
|
||
[[ -n "$tran" ]] && interface="$tran"
|
||
|
||
local model="Unknown" serial="Unknown" temperature="null" smart_health="null"
|
||
if command -v smartctl &>/dev/null; then
|
||
if sudo smartctl -i "/dev/$d" &>/dev/null; then
|
||
local s
|
||
s=$(sudo smartctl -i "/dev/$d" 2>/dev/null)
|
||
model=$(echo "$s" | awk -F: '/Device Model|Model Number/ {gsub(/^[ \t]+/,"",$2); print $2}' | head -1)
|
||
serial=$(echo "$s" | awk -F: '/Serial Number/ {gsub(/^[ \t]+/,"",$2); print $2}' | head -1)
|
||
|
||
# Essayer de récupérer la température et le statut SMART
|
||
local smart_all
|
||
smart_all=$(sudo smartctl -A "/dev/$d" 2>/dev/null || true)
|
||
# Température (diverses variantes selon le type de disque)
|
||
# SATA/HDD: Temperature_Celsius, Airflow_Temperature_Cel, Current Drive Temperature
|
||
# RAW_VALUE est après le "-" (colonne 8 dans la plupart des cas, mais peut varier)
|
||
# On extrait tout après le "-" puis prend le premier nombre
|
||
# NVMe: Temperature: XX Celsius (colonne 2)
|
||
temperature=$(echo "$smart_all" | awk '/Temperature_Celsius|Airflow_Temperature_Cel|Current Drive Temperature/ {for(i=1;i<=NF;i++) if($i=="-" && i<NF) {print $(i+1); exit}}' | head -1 | grep -oE '^[0-9]+' | head -1)
|
||
[[ -z "$temperature" ]] && temperature=$(echo "$smart_all" | awk '/^Temperature:/ {print $2}' | head -1)
|
||
[[ -z "$temperature" ]] && temperature="null"
|
||
|
||
# Statut SMART health
|
||
local health
|
||
health=$(sudo smartctl -H "/dev/$d" 2>/dev/null | awk '/SMART overall-health|SMART Health Status/ {print $NF}' | head -1)
|
||
[[ -n "$health" ]] && smart_health="$health" || smart_health="null"
|
||
fi
|
||
fi
|
||
|
||
size_gb=$(echo "$size_h" | sed 's/[^0-9.]//g')
|
||
|
||
local disk_json
|
||
disk_json=$(jq -n \
|
||
--arg device "$d" \
|
||
--arg model "$model" \
|
||
--arg size "$size_gb" \
|
||
--arg type "$disk_type" \
|
||
--arg interface "$interface" \
|
||
--arg serial "$serial" \
|
||
--arg temp "$temperature" \
|
||
--arg health "$smart_health" \
|
||
'{
|
||
device: $device,
|
||
model: $model,
|
||
size_gb: $size,
|
||
type: $type,
|
||
interface: $interface,
|
||
serial: $serial,
|
||
temperature_c: (if $temp == "null" or $temp == "" then null else ($temp | tonumber?) end),
|
||
smart_health: (if $health == "null" or $health == "" then null else $health end)
|
||
}')
|
||
|
||
storage_array=$(echo "$storage_array" | jq --argjson disk "$disk_json" '. + [$disk]')
|
||
|
||
if [[ "$temperature" != "null" ]]; then
|
||
log_info "Disque: /dev/$d - $model ($size_h, $disk_type, ${temperature}°C)"
|
||
else
|
||
log_info "Disque: /dev/$d - $model ($size_h, $disk_type)"
|
||
fi
|
||
done
|
||
|
||
STORAGE_INFO="$storage_array"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 6 : Réseau
|
||
#=========================================================
|
||
|
||
collect_network_info() {
|
||
log_step "Collecte des informations réseau"
|
||
|
||
local network_array="[]"
|
||
|
||
local iface
|
||
for iface in $(ip -br link show | awk '$2 ~ /UP|UNKNOWN/ {print $1}'); do
|
||
[[ "$iface" =~ ^(lo|docker|br-|veth) ]] && continue
|
||
|
||
local mac
|
||
mac=$(ip link show "$iface" | awk '/link\/ether/ {print $2}')
|
||
[[ -z "$mac" ]] && continue
|
||
|
||
local type="unknown"
|
||
if [[ "$iface" =~ ^(eth|enp|eno) ]]; then
|
||
type="ethernet"
|
||
elif [[ "$iface" =~ ^(wlan|wl) ]]; then
|
||
type="wifi"
|
||
fi
|
||
|
||
local ip_addr
|
||
ip_addr=$(ip -4 addr show "$iface" | awk '/inet /{print $2}' | cut -d/ -f1 | head -1)
|
||
|
||
local speed="" wol_supported=""
|
||
if [[ "$type" = "ethernet" && -x /usr/sbin/ethtool ]]; then
|
||
local e
|
||
e=$(sudo ethtool "$iface" 2>/dev/null || true)
|
||
local spd
|
||
# Extraire seulement le nombre de la vitesse (enlever "Mb/s")
|
||
spd=$(echo "$e" | awk -F: '/Speed:/ {gsub(/^[ \t]+/,"",$2); print $2}' | grep -oE '[0-9]+' | head -1)
|
||
[[ -n "$spd" ]] && speed="$spd"
|
||
local wol
|
||
# Extraire Wake-on-LAN et nettoyer (enlever retours chariot)
|
||
wol=$(echo "$e" | awk -F: '/Wake-on:/ {gsub(/^[ \t]+/,"",$2); print $2}' | tr -d '\n' | head -1)
|
||
if [[ -n "$wol" && "$wol" != "d" ]]; then
|
||
wol_supported="true"
|
||
elif [[ -n "$wol" ]]; then
|
||
wol_supported="false"
|
||
fi
|
||
fi
|
||
|
||
# Convertir wol_supported en booléen ou null pour jq
|
||
local wol_json="null"
|
||
if [[ "$wol_supported" == "true" ]]; then
|
||
wol_json="true"
|
||
elif [[ "$wol_supported" == "false" ]]; then
|
||
wol_json="false"
|
||
fi
|
||
|
||
local net_json
|
||
net_json=$(jq -n \
|
||
--arg name "$iface" \
|
||
--arg type "$type" \
|
||
--arg mac "$mac" \
|
||
--arg ip "${ip_addr:-}" \
|
||
--arg speed "$speed" \
|
||
--argjson wol "$wol_json" \
|
||
'{
|
||
name: $name,
|
||
type: $type,
|
||
mac: $mac,
|
||
ip_address: ( $ip | select(. != "") ),
|
||
speed_mbps: ( ( $speed | tonumber? ) // null ),
|
||
wake_on_lan: $wol
|
||
}' 2>/dev/null || echo '{}')
|
||
|
||
# Vérifier que net_json est valide avant de l'ajouter
|
||
if [[ "$net_json" != "{}" ]] && echo "$net_json" | jq empty 2>/dev/null; then
|
||
network_array=$(echo "$network_array" | jq --argjson net "$net_json" '. + [$net]')
|
||
else
|
||
log_warn "Interface $iface: JSON invalide, ignorée"
|
||
fi
|
||
|
||
log_info "Interface: $iface ($type) - IP: ${ip_addr:-N/A}"
|
||
done
|
||
|
||
NETWORK_INFO="$network_array"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Étape 7 : Benchmarks
|
||
#=========================================================
|
||
|
||
run_benchmarks() {
|
||
log_step "Exécution des benchmarks (peut prendre plusieurs minutes)"
|
||
|
||
# CPU
|
||
local cpu_bench="null"
|
||
if command -v sysbench &>/dev/null; then
|
||
log_info "Benchmark CPU en cours..."
|
||
local cpu_res
|
||
cpu_res=$(sysbench cpu --cpu-max-prime=20000 --threads="$(nproc)" run 2>&1 || true)
|
||
local eps time_s
|
||
eps=$(echo "$cpu_res" | awk '/events per second/ {print $4}')
|
||
time_s=$(echo "$cpu_res" | awk '/total time:/ {gsub(/s/,"",$3); print $3}')
|
||
[[ -z "$eps" ]] && eps=0
|
||
[[ -z "$time_s" ]] && time_s=0
|
||
local cpu_score
|
||
cpu_score=$(safe_bc "scale=2; $eps / 100")
|
||
|
||
cpu_bench=$(jq -n \
|
||
--arg eps "$eps" \
|
||
--arg time "$time_s" \
|
||
--arg score "$cpu_score" \
|
||
'{
|
||
events_per_sec: ($eps | tonumber? // 0),
|
||
duration_s: ($time | tonumber? // 0),
|
||
score: ($score | tonumber? // 0)
|
||
}')
|
||
|
||
log_info "CPU: ${eps} events/sec (score: ${cpu_score})"
|
||
else
|
||
log_warn "sysbench non disponible - CPU bench ignoré"
|
||
fi
|
||
|
||
# Mémoire
|
||
local mem_bench="null"
|
||
if command -v sysbench &>/dev/null; then
|
||
log_info "Benchmark Mémoire en cours..."
|
||
local mem_res
|
||
mem_res=$(sysbench memory --memory-total-size=1G run 2>&1 || true)
|
||
local thr
|
||
# Extraire le throughput - essayer plusieurs patterns
|
||
thr=$(echo "$mem_res" | grep -oP '\d+\.\d+(?= MiB/sec)' | head -1)
|
||
[[ -z "$thr" ]] && thr=$(echo "$mem_res" | awk '/transferred/ {print $(NF-1)}' | head -1)
|
||
[[ -z "$thr" ]] && thr=0
|
||
local mem_score
|
||
mem_score=$(safe_bc "scale=2; $thr / 100")
|
||
|
||
mem_bench=$(jq -n \
|
||
--arg thr "$thr" \
|
||
--arg score "$mem_score" \
|
||
'{
|
||
throughput_mib_s: ($thr | tonumber? // 0),
|
||
score: ($score | tonumber? // 0)
|
||
}')
|
||
|
||
log_info "Mémoire: ${thr} MiB/s (score: ${mem_score})"
|
||
else
|
||
log_warn "sysbench non disponible - Memory bench ignoré"
|
||
fi
|
||
|
||
# Disque
|
||
local disk_bench="null"
|
||
if command -v fio &>/dev/null; then
|
||
log_info "Benchmark Disque en cours (2–3 minutes)..."
|
||
local tmpdir
|
||
tmpdir=$(mktemp -d /tmp/fio-bench-XXXX)
|
||
local fio_res
|
||
fio_res=$(fio --name=bench --ioengine=libaio --rw=randrw --bs=4k \
|
||
--size=500M --numjobs=1 --direct=1 --runtime=30 --time_based \
|
||
--filename="$tmpdir/testfile" --output-format=json 2>/dev/null || echo '{}')
|
||
rm -rf "$tmpdir"
|
||
|
||
if [[ "$fio_res" != "{}" ]]; then
|
||
local rbw wbw riops wiops lat_ns
|
||
rbw=$(echo "$fio_res" | jq '.jobs[0].read.bw // 0')
|
||
wbw=$(echo "$fio_res" | jq '.jobs[0].write.bw // 0')
|
||
riops=$(echo "$fio_res" | jq '.jobs[0].read.iops // 0' | cut -d. -f1)
|
||
wiops=$(echo "$fio_res" | jq '.jobs[0].write.iops // 0' | cut -d. -f1)
|
||
lat_ns=$(echo "$fio_res" | jq '.jobs[0].read.clat_ns.mean // 0')
|
||
|
||
local rmb wmb lat_ms
|
||
rmb=$(safe_bc "scale=2; $rbw / 1024")
|
||
wmb=$(safe_bc "scale=2; $wbw / 1024")
|
||
lat_ms=$(safe_bc "scale=3; $lat_ns / 1000000")
|
||
|
||
local disk_score
|
||
disk_score=$(safe_bc "scale=2; ($rmb + $wmb) / 20")
|
||
|
||
disk_bench=$(jq -n \
|
||
--arg rmb "$rmb" \
|
||
--arg wmb "$wmb" \
|
||
--arg riops "$riops" \
|
||
--arg wiops "$wiops" \
|
||
--arg lat_ms "$lat_ms" \
|
||
--arg score "$disk_score" \
|
||
'{
|
||
read_mb_s: ($rmb | tonumber? // 0),
|
||
write_mb_s: ($wmb | tonumber? // 0),
|
||
iops_read: ($riops | tonumber? // 0),
|
||
iops_write: ($wiops | tonumber? // 0),
|
||
latency_ms: ($lat_ms | tonumber? // 0),
|
||
score: ($score | tonumber? // 0)
|
||
}')
|
||
|
||
log_info "Disque: R=${rmb}MB/s W=${wmb}MB/s (score: ${disk_score})"
|
||
else
|
||
log_warn "Échec du benchmark disque (fio)"
|
||
fi
|
||
else
|
||
log_warn "fio non disponible - Disk bench ignoré"
|
||
fi
|
||
|
||
# Réseau (iperf3)
|
||
local net_bench="null"
|
||
if command -v iperf3 &>/dev/null; then
|
||
local target="$IPERF_SERVER"
|
||
[[ -z "$target" ]] && target="10.0.1.97"
|
||
|
||
log_info "Benchmark Réseau en cours (vers $target)..."
|
||
|
||
if ping -c 1 -W 1 "$target" &>/dev/null; then
|
||
if nc -z "$target" 5201 &>/dev/null; then
|
||
# Test bidirectionnel (upload + download simultanés)
|
||
local bidir_result=$(iperf3 -c "$target" -t 10 --bidir -J 2>/dev/null || echo '{}')
|
||
|
||
local upload_mbps="0"
|
||
local download_mbps="0"
|
||
local ping_ms="null"
|
||
|
||
if [[ "$bidir_result" != "{}" ]]; then
|
||
# Extraire upload (end.sum_sent) et download (end.sum_received)
|
||
local upload_bps=$(echo "$bidir_result" | jq -r '.end.sum_sent.bits_per_second // 0' | tr -d '\n')
|
||
local download_bps=$(echo "$bidir_result" | jq -r '.end.sum_received.bits_per_second // 0' | tr -d '\n')
|
||
|
||
upload_mbps=$(safe_bc "scale=2; $upload_bps / 1000000" | tr -d '\n')
|
||
download_mbps=$(safe_bc "scale=2; $download_bps / 1000000" | tr -d '\n')
|
||
|
||
# Mesurer le ping
|
||
local ping_output=$(ping -c 5 "$target" 2>/dev/null | grep 'avg' || echo "")
|
||
if [[ -n "$ping_output" ]]; then
|
||
ping_ms=$(echo "$ping_output" | awk -F'/' '{print $5}' | tr -d '\n')
|
||
fi
|
||
|
||
# Score réseau
|
||
local net_score=$(safe_bc "scale=2; ($upload_mbps + $download_mbps) / 20" | tr -d '\n')
|
||
|
||
# S'assurer que les valeurs sont valides pour jq
|
||
[[ -z "$upload_mbps" || "$upload_mbps" == "null" ]] && upload_mbps="0"
|
||
[[ -z "$download_mbps" || "$download_mbps" == "null" ]] && download_mbps="0"
|
||
[[ -z "$ping_ms" || "$ping_ms" == "null" ]] && ping_ms="0"
|
||
[[ -z "$net_score" || "$net_score" == "null" ]] && net_score="0"
|
||
|
||
net_bench=$(jq -n \
|
||
--argjson upload "$upload_mbps" \
|
||
--argjson download "$download_mbps" \
|
||
--argjson ping "$ping_ms" \
|
||
--argjson score "$net_score" \
|
||
'{upload_mbps: $upload, download_mbps: $download, ping_ms: $ping, score: $score}')
|
||
|
||
log_info "Réseau: ↑${upload_mbps}Mbps ↓${download_mbps}Mbps (ping: ${ping_ms}ms, score: ${net_score})"
|
||
else
|
||
log_warn "Test iperf3 bidirectionnel échoué - Network bench ignoré"
|
||
fi
|
||
else
|
||
log_warn "Port iperf3 (5201) fermé sur $target - Network bench ignoré"
|
||
fi
|
||
else
|
||
log_warn "Hôte $target non joignable - Network bench ignoré"
|
||
fi
|
||
else
|
||
log_warn "iperf3 non disponible - Network bench ignoré"
|
||
fi
|
||
|
||
# GPU bench non implémenté
|
||
local gpu_bench="null"
|
||
log_warn "GPU bench non implémenté - ignoré"
|
||
|
||
# Score global selon pondérations recommandées :
|
||
# CPU 30%, RAM 20%, Disque 25%, Réseau 15%, GPU 10%
|
||
local scores="" total_weight=0
|
||
|
||
if [[ "$cpu_bench" != "null" ]]; then
|
||
local cs
|
||
cs=$(echo "$cpu_bench" | jq '.score // 0')
|
||
scores="$scores + $cs * 0.30"
|
||
total_weight=$(safe_bc "$total_weight + 0.30")
|
||
fi
|
||
|
||
if [[ "$mem_bench" != "null" ]]; then
|
||
local ms
|
||
ms=$(echo "$mem_bench" | jq '.score // 0')
|
||
scores="$scores + $ms * 0.20"
|
||
total_weight=$(safe_bc "$total_weight + 0.20")
|
||
fi
|
||
|
||
if [[ "$disk_bench" != "null" ]]; then
|
||
local ds
|
||
ds=$(echo "$disk_bench" | jq '.score // 0')
|
||
scores="$scores + $ds * 0.25"
|
||
total_weight=$(safe_bc "$total_weight + 0.25")
|
||
fi
|
||
|
||
if [[ "$net_bench" != "null" ]]; then
|
||
local ns
|
||
ns=$(echo "$net_bench" | jq '.score // 0')
|
||
scores="$scores + $ns * 0.15"
|
||
total_weight=$(safe_bc "$total_weight + 0.15")
|
||
fi
|
||
|
||
if [[ "$gpu_bench" != "null" ]]; then
|
||
local gs
|
||
gs=$(echo "$gpu_bench" | jq '.score // 0')
|
||
scores="$scores + $gs * 0.10"
|
||
total_weight=$(safe_bc "$total_weight + 0.10")
|
||
fi
|
||
|
||
scores=$(echo "$scores" | sed -E 's/^[[:space:]]*\+ //')
|
||
local global_score=0
|
||
if [[ -n "$scores" && "$total_weight" != "0" ]]; then
|
||
global_score=$(safe_bc "scale=2; ($scores) / $total_weight")
|
||
fi
|
||
[[ -z "$global_score" ]] && global_score=0
|
||
|
||
BENCHMARK_RESULTS=$(jq -n \
|
||
--argjson cpu "$cpu_bench" \
|
||
--argjson mem "$mem_bench" \
|
||
--argjson disk "$disk_bench" \
|
||
--argjson net "$net_bench" \
|
||
--argjson gpu "$gpu_bench" \
|
||
--argjson global "$global_score" \
|
||
'{
|
||
cpu: $cpu,
|
||
memory: $mem,
|
||
disk: $disk,
|
||
network: $net,
|
||
gpu: $gpu,
|
||
global_score: $global
|
||
}')
|
||
|
||
log_info "Score global: ${global_score}/100"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# Envoi du payload JSON
|
||
#=========================================================
|
||
|
||
send_benchmark_payload() {
|
||
log_step "Construction du payload JSON et envoi au serveur"
|
||
|
||
# Si SERVER_URL n’a pas de schéma, on préfixe par http://
|
||
local base_url="$SERVER_URL"
|
||
if [[ "$base_url" != http*://* ]]; then
|
||
base_url="http://$base_url"
|
||
fi
|
||
local api_url="${base_url%/}/api/benchmark"
|
||
|
||
local payload
|
||
payload=$(
|
||
jq -n \
|
||
--arg version "$BENCH_SCRIPT_VERSION" \
|
||
--argjson system "$SYSTEM_INFO" \
|
||
--argjson cpu "$CPU_INFO" \
|
||
--argjson ram "$RAM_INFO" \
|
||
--argjson gpu "$GPU_INFO" \
|
||
--argjson mb "$MOTHERBOARD_INFO" \
|
||
--argjson storage "$STORAGE_INFO" \
|
||
--argjson network "$NETWORK_INFO" \
|
||
--argjson bench "$BENCHMARK_RESULTS" \
|
||
'
|
||
{
|
||
device_identifier: $system.hostname,
|
||
bench_script_version: $version,
|
||
|
||
hardware: {
|
||
cpu: ($cpu + {
|
||
microarchitecture: null,
|
||
tdp_w: null
|
||
}),
|
||
|
||
ram: (
|
||
$ram
|
||
| {
|
||
total_mb: .total_mb,
|
||
used_mb: .used_mb,
|
||
free_mb: .free_mb,
|
||
shared_mb: .shared_mb,
|
||
slots_total: .slots_total,
|
||
slots_used: .slots_used,
|
||
ecc: .ecc,
|
||
layout: [
|
||
.layout[]
|
||
| {
|
||
slot,
|
||
size_mb,
|
||
type,
|
||
speed_mhz,
|
||
vendor: .manufacturer,
|
||
part_number: null
|
||
}
|
||
]
|
||
}
|
||
),
|
||
|
||
gpu: (
|
||
if $gpu == null then
|
||
{
|
||
vendor: null,
|
||
model: null,
|
||
driver_version: null,
|
||
memory_dedicated_mb: null,
|
||
memory_shared_mb: null,
|
||
api_support: []
|
||
}
|
||
else
|
||
{
|
||
vendor: $gpu.vendor,
|
||
model: $gpu.model,
|
||
driver_version: null,
|
||
memory_dedicated_mb: null,
|
||
memory_shared_mb: null,
|
||
api_support: []
|
||
}
|
||
end
|
||
),
|
||
|
||
storage: {
|
||
devices: [
|
||
$storage[]
|
||
| {
|
||
name: ("/dev/" + .device),
|
||
type: (.type | ascii_upcase),
|
||
interface,
|
||
capacity_gb: (.size_gb | tonumber? // .size_gb),
|
||
vendor: null,
|
||
model,
|
||
smart_health,
|
||
temperature_c
|
||
}
|
||
],
|
||
partitions: []
|
||
},
|
||
|
||
network: {
|
||
interfaces: [
|
||
$network[]
|
||
| {
|
||
name,
|
||
type,
|
||
mac,
|
||
ip: .ip_address,
|
||
speed_mbps,
|
||
driver: null,
|
||
wake_on_lan
|
||
}
|
||
]
|
||
},
|
||
|
||
motherboard: {
|
||
vendor: $mb.manufacturer,
|
||
model: $mb.model,
|
||
bios_vendor: $mb.bios_vendor,
|
||
bios_version: $mb.bios_version,
|
||
bios_date: $mb.bios_date
|
||
},
|
||
|
||
os: (
|
||
$system.os
|
||
+ { virtualization_type: "none" }
|
||
),
|
||
|
||
sensors: {
|
||
cpu_temp_c: null,
|
||
disk_temps_c: {}
|
||
},
|
||
|
||
raw_info: {
|
||
lscpu: null,
|
||
lsblk: null
|
||
}
|
||
},
|
||
|
||
results: (
|
||
$bench as $b
|
||
| {
|
||
cpu: $b.cpu,
|
||
memory: $b.memory,
|
||
disk: $b.disk,
|
||
network: (
|
||
$b.network
|
||
+ {
|
||
jitter_ms: null,
|
||
packet_loss_percent: null
|
||
}
|
||
),
|
||
gpu: (
|
||
if $b.gpu == null then
|
||
{ glmark2_score: null, score: null }
|
||
else
|
||
$b.gpu
|
||
end
|
||
),
|
||
global_score: $b.global_score
|
||
}
|
||
)
|
||
}
|
||
'
|
||
)
|
||
|
||
# Debug : afficher le payload complet si DEBUG_PAYLOAD=1
|
||
if [[ "${DEBUG_PAYLOAD:-0}" == "1" ]]; then
|
||
echo ""
|
||
echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
|
||
echo -e "${YELLOW}DEBUG: Payload JSON complet${NC}"
|
||
echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
|
||
echo "$payload" | jq '.'
|
||
echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
|
||
echo ""
|
||
|
||
# Sauvegarder le payload dans un fichier avec timestamp
|
||
local debug_file="/tmp/bench_payload_$(date +%Y%m%d_%H%M%S).json"
|
||
echo "$payload" | jq '.' > "$debug_file"
|
||
echo -e "${GREEN}✓${NC} Payload sauvegardé dans: ${debug_file}"
|
||
echo ""
|
||
|
||
read -p "Appuyez sur Entrée pour continuer l'envoi ou Ctrl+C pour annuler..."
|
||
fi
|
||
|
||
log_info "Envoi du payload vers: $api_url"
|
||
|
||
local tmp_resp http_code
|
||
tmp_resp=$(mktemp /tmp/bench_response_XXXXXX.json)
|
||
|
||
# IMPORTANT : on envoie le payload via stdin (pas de @<(...) foireux)
|
||
http_code=$(
|
||
printf '%s\n' "$payload" | curl -sS -o "$tmp_resp" -w "%{http_code}" \
|
||
-X POST "$api_url" \
|
||
-H "Content-Type: application/json" \
|
||
-H "Authorization: Bearer $API_TOKEN" \
|
||
--data-binary @-
|
||
)
|
||
|
||
if [[ "$http_code" != "200" && "$http_code" != "201" ]]; then
|
||
log_error "Erreur lors de l'envoi (HTTP $http_code)"
|
||
echo "Réponse serveur :"
|
||
cat "$tmp_resp"
|
||
rm -f "$tmp_resp"
|
||
exit 1
|
||
fi
|
||
|
||
log_info "Payload envoyé avec succès (HTTP $http_code)"
|
||
rm -f "$tmp_resp"
|
||
echo ""
|
||
}
|
||
|
||
#=========================================================
|
||
# MAIN
|
||
#=========================================================
|
||
|
||
main() {
|
||
check_sudo
|
||
check_dependencies
|
||
|
||
echo -e "${BLUE}Début de la collecte et des benchmarks...${NC}"
|
||
echo ""
|
||
|
||
collect_system_info
|
||
collect_cpu_info
|
||
collect_ram_info
|
||
collect_hardware_info
|
||
collect_storage_info
|
||
collect_network_info
|
||
run_benchmarks
|
||
send_benchmark_payload
|
||
|
||
echo -e "${GREEN}════════════════════════════════════════════════════════${NC}"
|
||
echo -e "${GREEN} Benchmark terminé avec succès !${NC}"
|
||
echo -e "${GREEN}════════════════════════════════════════════════════════${NC}"
|
||
echo ""
|
||
}
|
||
|
||
main "$@"
|