Saltar a contenido

Elina Traffic Generator (Elina-TG)

Introducción

Elina Traffic Generator (elina-tg) es una potente herramienta de generación de tráfico por línea de comandos que se utiliza para simular una gran variedad de comportamientos de aplicaciones y de red. Puede generar varios flujos simultáneos de tráfico TCP, UDP y RTP con parámetros altamente configurables, incluidos el tamaño de los paquetes, tasas variables, IPv4/IPv6, marcados QoS (DSCP) y cargas útiles sofisticadas y personalizables.

Panel de control

Elina-TG puede utilizarse como herramienta independiente para pruebas de red y validación de QoS. También puede ejecutarse junto al QoS-Agent de LatenceTech en la misma ruta de red: Elina-TG genera una carga de tipo aplicación mientras el Agent mide la latencia, el jitter y la pérdida en los paneles de control del Analyzer.

Panel de control

Cómo funciona

Elina-TG funciona según un modelo cliente/servidor. Una instancia «cliente» lee un archivo de configuración de flujos y envía tráfico, mientras que una instancia «servidor» escucha ese tráfico, mide métricas clave como la pérdida de paquetes y el jitter, y registra los resultados. La herramienta puede funcionar en los modos client, server o both (para pruebas sencillas en bucle local en una sola máquina). También incluye un potente modo schedule para orquestar secuencias de prueba complejas basadas en el tiempo, y un modo aggregate para fusionar las estadísticas de varias ejecuciones.

Configuración

El paquete de release es un binario Linux autónomo (más las configuraciones y la documentación). No es necesario ningún paso de instalación de Python.

Requisitos del sistema:

  • Linux x86_64
  • GLIBC 2.35 o más reciente (p. ej. Ubuntu 22.04+ / Debian 12+). Los hosts más antiguos, como Ubuntu 20.04 (GLIBC 2.31), no pueden ejecutar el binario.

1. Descargar y descomprimir la herramienta:

wget https://api.latence.ca/software/elina-tg.zip
unzip elina-tg.zip
cd elina-tg-release

2. Verificar el binario:

./elina-tg --help

Invoque siempre ./elina-tg desde el directorio elina-tg-release (no se añade a su PATH).

Modos de funcionamiento

1. Una prueba sencilla en bucle local (Primeros pasos) Es la mejor forma de verificar su instalación. Ejecuta tanto un cliente como un servidor en su máquina local durante 15 segundos.

# Ejecutar la prueba en modo detallado y guardar los resultados
./elina-tg both --duration 15 -v --stats_file mis_primeros_resultados_prueba.json

Tras la ejecución, se imprime un resumen legible en la consola y se guardan estadísticas JSON detalladas en el archivo especificado.

2. Una prueba Cliente/Servidor (Dos máquinas) Esto simula el tráfico en un enlace de red real.

  • En la máquina servidor (por ejemplo, IP 192.168.1.101): Inicie el servidor para escuchar el tráfico definido en el archivo de configuración básico.
./elina-tg server --config configs/basic/flows_config_basic.json --listen_ip 0.0.0.0 -v
  • En la máquina cliente: Envíe tráfico al servidor durante 60 segundos.
./elina-tg client --config configs/basic/flows_config_basic.json --dest_ip 192.168.1.101 --duration 60 -v

3. Modo planificador (Secuencias de prueba automatizadas) Este modo ejecuta una serie de acciones cliente/servidor definidas en un archivo de planificación. Es ideal para emular patrones de tráfico complejos y variables en el tiempo.

# Ejecutar la simulación predefinida de e-Gaming ITU-T G.1051
./elina-tg schedule --schedule_config configs/itu_g1051_egaming/schedule_config_egaming_g1051.json -v

Referencia de la línea de comandos

./elina-tg <mode> [options]

Modos

  • client — Generar tráfico a partir de una configuración de flujos.
  • server — Escuchar el tráfico y recopilar estadísticas.
  • both — Ejecutar cliente y servidor juntos (bucle local / pruebas en un solo host).
  • schedule — Ejecutar una secuencia temporizada a partir de una configuración de planificación (JSON o CSV).
  • aggregate — Fusionar varios archivos de estadísticas JSON en un informe.

Opciones habituales

  • --config FILE — Configuración de flujos JSON (por defecto: configs/basic/flows_config_basic.json).
  • --dest_ip IP — IP de destino del cliente (por defecto: 127.0.0.1).
  • --listen_ip IP — IP de escucha del servidor (por defecto: 0.0.0.0).
  • --base_port PORT — Puerto base de los flujos; cada flujo utiliza base_port + index salvo que se sobrescriba (por defecto: 5000).
  • --duration SECONDS — Duración del envío del cliente (por defecto: 10).
  • --stats_file PATH — Escribir las estadísticas JSON. Si pasa un simple nombre de archivo, se añade una marca de tiempo UTC.
  • --stats_interval SECONDS — Mostrar una instantánea de estadísticas en directo cada N segundos (0 = desactivado).
  • --ipv6 — Forzar IPv6 (también se activa automáticamente si se detecta una dirección IPv6 en --dest_ip / --listen_ip).
  • -v / -vv — Registro detallado / debug. -q — Silencioso.
  • --version — Mostrar la versión y salir.

Planificación y sincronización horaria

  • --start_at DATETIME — Iniciar el cliente a una hora precisa (se recomienda ISO 8601 UTC, p. ej. 2025-08-27T14:30:00Z).
  • --schedule_config FILE — Archivo de planificación para el modo schedule (.json o .csv).
  • --check_time_sync — Verificar la sincronización del reloj (NTP y/o sincronización personalizada) antes del inicio.
  • --time_sync_port_offset OFFSET — Desplazamiento de puerto relativo a base_port para el servicio de sincronización (por defecto: -1).
  • --time_sync_threshold SECONDS — Desfase de reloj máximo aceptable (por defecto: 1.0).
  • --ntp_server_host HOST — Servidor NTP que se consultará (por defecto: pool.ntp.org).

Modo aggregate

  • --inputs FILE [FILE ...] — Archivos de estadísticas JSON de entrada que se fusionarán.
  • --output FILE — Ruta del informe agregado (por defecto: aggregate_report.json).
./elina-tg aggregate --inputs run1.json run2.json --output campaign_report.json

Referencia de configuración de los flujos

Las configuraciones de flujos son objetos JSON. Cada clave de primer nivel es un Flow ID único. Los puertos se asignan como base_port + flow_index salvo que se defina dest_port_override. Hay un esquema JSON disponible en configs/schemas/flow-config.schema.json para la validación en el editor.

Ejemplo anotado mínimo (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
    }
  }
}

Parámetros comunes

  • protocol (obligatorio) — "UDP", "TCP" o "RTP".
  • size (obligatorio) — Tamaño objetivo del paquete en bytes.
  • rate — Paquetes por segundo estáticos. Utilice 0 para la velocidad máxima. Se ignora si se define rate_profile o rate_control. Se requiere uno de rate, rate_profile o rate_control.
  • type — Cadena definida por el usuario e integrada en la carga útil para su identificación.
  • start_delay_seconds — Retardo antes de que este flujo empiece a enviar.
  • dest_port_override — Sustituir el puerto de destino asignado automáticamente.
  • dscp — Valor DSCP (0–63) para el marcado QoS de IP.

Control de la tasa

  • rate_profile — Tabla de fases { "rate", "duration_seconds" }. Sustituye a rate.
  • rate_control — Control granular; sustituye a rate y a rate_profile:
    • Burst: "mode": "burst" con packets_per_burst, rate_in_burst_pps, pause_between_bursts_ms
    • Intervalo entre paquetes: "mode": "ipg" con ipg_ms

Carga útil, TCP y RTP

  • payload_config — mode: "random" (por defecto), "pattern" (hex) o "file". incremental_fields opcional para integrar contadores en desplazamientos de bytes.
  • tcp_config — concurrent_connections, enable_keepalive, behavior ("stream" o "request_response"), más tamaño/timeout/retardo del servidor para el modo petición-respuesta.
  • rtp_config (obligatorio para RTP) — payload_type, ssrc ("auto" o entero), media_clock_rate, simulated_media_rate, marker_bit_logic opcional.

Funcionalidades avanzadas

Echo del servidor (reflexión de paquetes)

Defina "server_config": { "behavior": "echo" } en un flujo UDP o TCP para que el servidor devuelva los paquetes al remitente. Útil para pruebas de tipo ida y vuelta.

./elina-tg both --config configs/features/flows_config_echo.json --duration 15 -v

Seguimiento de secuencia UDP (pérdida / desorden)

Combine los incremental_fields de la carga útil con "server_config": { "sequence_tracking": { "enabled": true, "offset": N, "size": 4 } }. El servidor informa de las estimaciones de pérdida y de desorden en el JSON de estadísticas.

./elina-tg both --config configs/features/flows_config_seq_tracking.json --duration 15 -v

Estadísticas en directo

Utilice --stats_interval N para mostrar una instantánea de estadísticas cada N segundos durante una ejecución.

Modo aggregate

Fusionar las estadísticas de campañas de varias ejecuciones o de varios nodos:

./elina-tg aggregate --inputs node_a.json node_b.json --output combined.json

Planificaciones CSV

--schedule_config acepta tanto .csv como .json. Consulte configs/features/schedule_example.csv para ver la disposición de las columnas (event_id, action, start_UTC_datetime, start_offset_from_previous_end, params_json).

Lectura de los resultados

Resumen de la consola

Al final de una ejecución client, server o both (salvo con -q), Elina-TG muestra una tabla resumen:

  • Cliente — paquetes enviados, bytes enviados y tasa alcanzada por flujo.
  • Servidor — paquetes/bytes recibidos por puerto y jitter medio (entre llegadas UDP o RTP RFC 3550, según el flujo).

Se muestra una barra de progreso durante las ejecuciones client / both fuera del modo silencioso.

Archivo de estadísticas JSON (--stats_file)

Estructura de primer nivel:

{
  "overall_simulation_summary": {},
  "client_flow_details": {},
  "server_port_activity": {}
}
  • overall_simulation_summary — Versión, horas de inicio/fin, familia IP y argumentos CLI utilizados (útil para la reproducibilidad).
  • client_flow_details — Por Flow ID: eco de la configuración más packets_sent, bytes_sent, achieved_rate_pps, achieved_bitrate_bps y campos temporales.
  • server_port_activity — Por puerto: paquetes/bytes recibidos, recuentos de conexiones TCP, contadores de echo opcionales, jitter_stats UDP y jitter RTP por SSRC en ssrc_data. Con el seguimiento de secuencia activado, las estimaciones de pérdida/desorden también aparecen aquí.

Niveles de detalle: -q (solo errores), por defecto (info + resumen), -v (detalle), -vv (debug).

Para la lista completa de campos, consulte documentation/Statistics_Logs.md en el paquete.

La biblioteca de perfiles predefinidos

Elina-TG incluye una amplia biblioteca de perfiles de simulación en el directorio configs/.
Deberá modificarlos para adaptarlos a sus casos de uso.
Están organizados por categoría:

  • /basic — Configuraciones sencillas para empezar (flujos predeterminados + planificación mínima).
  • /features — Demostraciones de funcionalidades avanzadas (cargas útiles, burst/IPG, echo, seguimiento de secuencia, variantes TCP/UDP/RTP, ejemplo de planificación CSV).
  • /ipv6 — Ejemplos de flujos IPv6 (y dual-stack).
  • /iot — Patrones de tipo IoT (p. ej. heartbeat de contador de agua y estadísticas periódicas mediante planificación).
  • /teams & /zoom — Tráfico emulado de videollamadas de Microsoft Teams y Zoom, con marcados QoS realistas.
  • /itu_g1051_egaming — Simulación de e-Gaming ITU-T G.1051 basada en el planificador.
  • /itu_g1051_dronecontrol — Tráfico de control de drones teledirigidos fuertemente asimétrico (uplink del piloto + downlink de vídeo).

Para obtener instrucciones detalladas sobre el uso de estos perfiles avanzados, consulte las guías simulating-*.md ubicadas en cada directorio correspondiente. También hay una vista general de todas las configuraciones en configs/README-configs.md.

Visualización de los resultados en los paneles de control de LatenceTech

Elina-TG no se conecta al QoS-Agent ni al Analyzer. Ejecútelo junto a un Agent que ya mida la misma ruta de red: genere una carga de aplicación específica (por ejemplo, un perfil de Zoom o de juego) y observe cómo evolucionan la latencia, el jitter y la pérdida de paquetes en tiempo real en los paneles de control del Analyzer.

Notas importantes

  • Linux / GLIBC: El binario de release requiere GLIBC 2.35+ (Ubuntu 22.04 o más reciente). En sistemas más antiguos, verá un error del tipo version 'GLIBC_2.35' not found.
  • Permisos para DSCP/QoS: En algunos sistemas, la definición de valores DSCP puede requerir privilegios elevados (p. ej. sudo ./elina-tg ...).
  • Rutas del planificador: Al utilizar el planificador, asegúrese de que las rutas flow_config_file de su archivo de planificación son correctas y relativas al directorio raíz del proyecto.
  • Documentación detallada: Para una visión completa de todas las funcionalidades y del esquema JSON de las estadísticas, consulte README.md y documentation/Statistics_Logs.md en el paquete.