Elina Traffic Generator (Elina-TG)
Introduction
Elina Traffic Generator (elina-tg) est un puissant outil de génération de trafic en ligne de commande utilisé pour simuler une grande variété de comportements d'application et de réseau. Il peut générer plusieurs flux simultanés de trafic TCP, UDP et RTP avec des paramètres hautement configurables, y compris la taille des paquets, les taux variables, IPv4/IPv6, les marquages QoS (DSCP) et des charges utiles sophistiquées et personnalisables.

Elina-TG peut être utilisé comme outil autonome pour les tests réseau et la validation QoS. Il peut aussi s'exécuter aux côtés du QoS-Agent LatenceTech sur le même chemin réseau : Elina-TG génère une charge de type applicatif tandis que l'Agent mesure la latence, le jitter et la perte sur les tableaux de bord Analyzer.

Comment ça fonctionne
Elina-TG fonctionne selon un modèle client/serveur. Une instance « client » lit un fichier de configuration de flux et envoie du trafic, tandis qu'une instance « serveur » écoute ce trafic, mesure des métriques clés comme la perte de paquets et le jitter, et enregistre les résultats. L'outil peut fonctionner en modes client, server ou both (pour de simples tests en boucle locale sur une seule machine). Il inclut également un puissant mode schedule pour orchestrer des séquences de test complexes basées sur le temps, et un mode aggregate pour fusionner les statistiques de plusieurs exécutions.
Configuration
Le paquet de release est un binaire Linux autonome (plus les configs et la documentation). Aucune étape d'installation Python n'est requise.
Exigences système :
- Linux x86_64
- GLIBC 2.35 ou plus récent (par ex. Ubuntu 22.04+ / Debian 12+). Les hôtes plus anciens tels qu'Ubuntu 20.04 (GLIBC 2.31) ne peuvent pas exécuter le binaire.
1. Télécharger et décompresser l'outil :
wget https://api.latence.ca/software/elina-tg.zip
unzip elina-tg.zip
cd elina-tg-release
2. Vérifier le binaire :
./elina-tg --help
Invoquez toujours ./elina-tg depuis le répertoire elina-tg-release (il n'est pas ajouté à votre PATH).
Modes de fonctionnement
1. Un test en boucle locale simple (Premiers pas) C'est la meilleure façon de vérifier votre installation. Il exécute à la fois un client et un serveur sur votre machine locale pendant 15 secondes.
# Exécuter le test en mode verbeux et enregistrer les résultats
./elina-tg both --duration 15 -v --stats_file mes_premiers_resultats_test.json
Après l'exécution, un résumé lisible est imprimé sur la console, et des statistiques JSON détaillées sont enregistrées dans le fichier spécifié.
2. Un test Client/Serveur (Deux machines) Cela simule le trafic sur une liaison réseau réelle.
- Sur la machine serveur (par exemple, IP 192.168.1.101) : Démarrez le serveur pour écouter le trafic défini dans le fichier de configuration de base.
./elina-tg server --config configs/basic/flows_config_basic.json --listen_ip 0.0.0.0 -v
- Sur la machine cliente : Envoyez du trafic au serveur pendant 60 secondes.
./elina-tg client --config configs/basic/flows_config_basic.json --dest_ip 192.168.1.101 --duration 60 -v
3. Mode planificateur (Séquences de test automatisées) Ce mode exécute une série d'actions client/serveur définies dans un fichier de planification. Il est idéal pour émuler des modèles de trafic complexes et variables dans le temps.
# Exécuter la simulation e-Gaming ITU-T G.1051 prédéfinie
./elina-tg schedule --schedule_config configs/itu_g1051_egaming/schedule_config_egaming_g1051.json -v
Référence de la ligne de commande
./elina-tg <mode> [options]
Modes
client— Générer du trafic à partir d'une config de flux.server— Écouter le trafic et collecter les statistiques.both— Exécuter client et serveur ensemble (boucle locale / tests mono-hôte).schedule— Exécuter une séquence temporisée depuis une config de planification (JSON ou CSV).aggregate— Fusionner plusieurs fichiers de stats JSON en un rapport.
Options courantes
--config FILE— Configuration de flux JSON (défaut :configs/basic/flows_config_basic.json).--dest_ip IP— IP de destination du client (défaut :127.0.0.1).--listen_ip IP— IP d'écoute du serveur (défaut :0.0.0.0).--base_port PORT— Port de base des flux ; chaque flux utilisebase_port + indexsauf surcharge (défaut :5000).--duration SECONDS— Durée d'envoi du client (défaut :10).--stats_file PATH— Écrire les stats JSON. Si vous passez un simple nom de fichier, un horodatage UTC est ajouté.--stats_interval SECONDS— Afficher un instantané de stats en direct toutes les N secondes (0= désactivé).--ipv6— Forcer IPv6 (aussi activé automatiquement si une adresse IPv6 est détectée dans--dest_ip/--listen_ip).-v/-vv— Journalisation verbeuse / debug.-q— Silencieux.--version— Afficher la version et quitter.
Planification et synchronisation horaire
--start_at DATETIME— Démarrer le client à une heure précise (ISO 8601 UTC recommandé, ex.2025-08-27T14:30:00Z).--schedule_config FILE— Fichier de planification pour le modeschedule(.jsonou.csv).--check_time_sync— Vérifier la sync d'horloge (NTP et/ou sync personnalisée) avant le démarrage.--time_sync_port_offset OFFSET— Décalage de port relatif àbase_portpour le service de sync (défaut :-1).--time_sync_threshold SECONDS— Écart d'horloge maximal acceptable (défaut :1.0).--ntp_server_host HOST— Serveur NTP à interroger (défaut :pool.ntp.org).
Mode aggregate
--inputs FILE [FILE ...]— Fichiers de stats JSON d'entrée à fusionner.--output FILE— Chemin du rapport agrégé (défaut :aggregate_report.json).
./elina-tg aggregate --inputs run1.json run2.json --output campaign_report.json
Référence de configuration des flux
Les configs de flux sont des objets JSON. Chaque clé de premier niveau est un Flow ID unique. Les ports sont assignés comme base_port + flow_index sauf si dest_port_override est défini. Un schéma JSON est disponible dans configs/schemas/flow-config.schema.json pour la validation dans l'éditeur.
Exemple annoté minimal (configs/basic/flows_config_basic.json) :
{
"F1_UDP_SIMPLE": {
"protocol": "UDP",
"size": 128,
"rate": 10,
"type": "BASIC_UDP_PAYLOAD",
"dscp": 0
},
"F2_TCP_SIMPLE": {
"protocol": "TCP",
"size": 512,
"rate": 5,
"type": "BASIC_TCP_STREAM",
"concurrent_connections": 5,
"enable_keepalive": true,
"start_delay_seconds": 1
},
"F3_RTP_AUDIO_SIM": {
"protocol": "RTP",
"size": 172,
"rate": 50,
"type": "SIMPLE_AUDIO_SIM",
"dscp": 46,
"rtp_config": {
"payload_type": 96,
"ssrc": "auto",
"media_clock_rate": 8000,
"simulated_media_rate": 50
}
}
}
Paramètres communs
protocol(obligatoire) —"UDP","TCP"ou"RTP".size(obligatoire) — Taille cible du paquet en octets.rate— Paquets par seconde statiques. Utilisez0pour la vitesse maximale. Ignoré sirate_profileourate_controlest défini. L'un derate,rate_profileourate_controlest requis.type— Chaîne définie par l'utilisateur intégrée dans la charge utile pour l'identification.start_delay_seconds— Délai avant que ce flux commence à envoyer.dest_port_override— Remplacer le port de destination assigné automatiquement.dscp— Valeur DSCP (0–63) pour le marquage QoS IP.
Contrôle de débit
rate_profile— Tableau de phases{ "rate", "duration_seconds" }. Remplacerate.rate_control— Contrôle granulaire ; remplacerateetrate_profile:- Burst :
"mode": "burst"avecpackets_per_burst,rate_in_burst_pps,pause_between_bursts_ms - Intervalle inter-paquets :
"mode": "ipg"avecipg_ms
- Burst :
Charge utile, TCP et RTP
payload_config—mode:"random"(défaut),"pattern"(hex) ou"file".incremental_fieldsoptionnel pour intégrer des compteurs à des offsets d'octets.tcp_config—concurrent_connections,enable_keepalive,behavior("stream"ou"request_response"), plus taille/timeout/délai serveur pour le mode requête-réponse.rtp_config(obligatoire pour RTP) —payload_type,ssrc("auto"ou entier),media_clock_rate,simulated_media_rate,marker_bit_logicoptionnel.
Fonctionnalités avancées
Echo serveur (réflexion de paquets)
Définissez "server_config": { "behavior": "echo" } sur un flux UDP ou TCP pour que le serveur renvoie les paquets à l'expéditeur. Utile pour des tests de type aller-retour.
./elina-tg both --config configs/features/flows_config_echo.json --duration 15 -v
Suivi de séquence UDP (perte / désordre)
Combinez les incremental_fields de la charge utile avec "server_config": { "sequence_tracking": { "enabled": true, "offset": N, "size": 4 } }. Le serveur rapporte les estimations de perte et de désordre dans le JSON de stats.
./elina-tg both --config configs/features/flows_config_seq_tracking.json --duration 15 -v
Stats en direct
Utilisez --stats_interval N pour afficher un instantané de stats toutes les N secondes pendant une exécution.
Mode aggregate
Fusionner les stats de campagnes multi-exécutions ou multi-nœuds :
./elina-tg aggregate --inputs node_a.json node_b.json --output combined.json
Planifications CSV
--schedule_config accepte .csv aussi bien que .json. Voir configs/features/schedule_example.csv pour la disposition des colonnes (event_id, action, start_UTC_datetime, start_offset_from_previous_end, params_json).
Lecture des résultats
Résumé console
À la fin d'une exécution client, server ou both (sauf -q), Elina-TG affiche un tableau récapitulatif :
- Client — paquets envoyés, octets envoyés et débit atteint par flux.
- Serveur — paquets/octets reçus par port et jitter moyen (inter-arrivée UDP ou RTP RFC 3550, selon le flux).
Une barre de progression s'affiche pendant les exécutions client / both hors mode silencieux.
Fichier de stats JSON (--stats_file)
Structure de premier niveau :
{
"overall_simulation_summary": {},
"client_flow_details": {},
"server_port_activity": {}
}
overall_simulation_summary— Version, heures de début/fin, famille IP et arguments CLI utilisés (utile pour la reproductibilité).client_flow_details— Par Flow ID : écho de config pluspackets_sent,bytes_sent,achieved_rate_pps,achieved_bitrate_bpset champs temporels.server_port_activity— Par port : paquets/octets reçus, comptes de connexions TCP, compteurs d'echo optionnels,jitter_statsUDP, et jitter RTP par SSRC sousssrc_data. Avec le suivi de séquence activé, les estimations de perte/désordre apparaissent aussi ici.
Niveaux de verbosité : -q (erreurs seulement), défaut (info + résumé), -v (détail), -vv (debug).
Pour la liste complète des champs, voir documentation/Statistics_Logs.md dans le paquet.
La bibliothèque de profils prédéfinis
Elina-TG est livré avec une riche bibliothèque de profils de simulation dans le répertoire configs/.
Vous devrez les modifier pour les adapter à vos cas d'usage.
Ceux-ci sont organisés par catégorie :
/basic— Configurations simples pour commencer (flux par défaut + planification minimale)./features— Démos de fonctionnalités avancées (charges utiles, burst/IPG, echo, suivi de séquence, variantes TCP/UDP/RTP, exemple de planification CSV)./ipv6— Exemples de flux IPv6 (et dual-stack)./iot— Motifs de type IoT (ex. heartbeat compteur d'eau et stats périodiques via planification)./teams&/zoom— Trafic d'appels vidéo Microsoft Teams et Zoom émulé, avec marquages QoS réalistes./itu_g1051_egaming— Simulation e-Gaming ITU-T G.1051 basée sur le planificateur./itu_g1051_dronecontrol— Trafic de contrôle de drone télécommandé fortement asymétrique (uplink pilote + downlink vidéo).
Pour des instructions détaillées sur l'utilisation de ces profils avancés, veuillez vous référer aux guides simulating-*.md situés dans chaque répertoire respectif. Un aperçu de toutes les configs figure aussi dans configs/README-configs.md.
Visualisation des résultats dans les tableaux de bord LatenceTech
Elina-TG ne se connecte pas au QoS-Agent ni à l'Analyzer. Exécutez-le aux côtés d'un Agent qui mesure déjà le même chemin réseau : générez une charge applicative spécifique (par exemple un profil Zoom ou jeu) et observez la latence, le jitter et la perte de paquets évoluer en temps réel sur les tableaux de bord Analyzer.
Notes importantes
- Linux / GLIBC : Le binaire de release nécessite GLIBC 2.35+ (Ubuntu 22.04 ou plus récent). Sur les systèmes plus anciens, vous verrez une erreur du type
version 'GLIBC_2.35' not found. - Permissions pour DSCP/QoS : Sur certains systèmes, la définition des valeurs DSCP peut nécessiter des privilèges élevés (par ex.
sudo ./elina-tg ...). - Chemins du planificateur : Lors de l'utilisation du planificateur, assurez-vous que les chemins
flow_config_filedans votre fichier de planification sont corrects et relatifs au répertoire racine du projet. - Documentation détaillée : Pour un aperçu complet de toutes les fonctionnalités et du schéma JSON des statistiques, voir
README.mdetdocumentation/Statistics_Logs.mddans le paquet.