README and fix interval in MQTT/QUIC publisher

fases/implementacao/pub_sub_hiredis/teste/.gitignore

@@ -7,4 +7,4 @@ hiredis/
 #ignorar a pasta do mbedtls
 mbedtls/
 
-**/build/
+**/build/

fases/implementacao/pub_sub_hiredis/teste/Analise/README.md

@@ -0,0 +1,149 @@
+# Teste de Latência e análise dos dados
+
+Nesse diretório poderá ser visto o tutorial de execução de como fazer os testes e por último a análise dos dados.
+
+## Como é feito o teste de latência ?
+
+O publisher irá enviar o tempo atual em nanosegundos e o subscriber irá, quando receber a mensagem do publisher, obter o tempo atual e salvar no Redis.
+
+
+## Teste de latência MQTT/TCP sem TLS
+
+
+- ### Subscriber (`tcp/sub`)
+    1. Verifique se o diretório possui uma pasta `build`, pois é lá onde você vai criar o seu executável, caso nao exista, crie uma pasta com o comando:
+        ```bash
+        mkdir build && cd build
+        ```
+    2. Compile o projeto com o comando:
+        ```bash
+        cmake .. && make
+        ```
+    3. Lembre de colocar uma chave redis condizente com o que você quer, aqui colocarei **teste_latencia_tcp**;
+
+     - Exemplo(depois de você fazer os passos anteriores, `sub/build`):
+        ```bash
+        ./sub_tcp sub mqtt-tcp://broker.emqx.io:1883 0 teste_latencia_tcp teste_latencia_tcp
+        ```
+
+- ### Publisher (`tcp/pub`)
+    1. Verifique se o diretório possui uma pasta `build`, pois é lá onde você vai criar o seu executável, caso nao exista, crie uma pasta com o comando:
+        ```bash
+        mkdir build && cd build
+        ```
+    2. Compile o projeto com o comando:
+        ```bash
+        cmake .. && make
+        ```
+    3. Realize o teste, lembrando de colocar como parâmetro o **intervalo de envio** igual para todos(quic, tcp ou tls). Nesse caso eu deixarei 10 ms. Mas você pode alterar para qualquer outro valor;
+
+    4. Envie pelo menos 10 mil pacotes
+
+    - Exemplo(depois de você fazer os passos anteriores, `pub/build`):
+
+        ```bash
+        ./pub_tcp mqtt-tcp://broker.emqx.io:1883 0 teste_latencia_tcp 10 10000
+        ```
+
+## Teste de Latência MQTT/TCP com TLS
+
+- ### Subscriber(`tcp/sub_tls`)
+    1. Verifique se o diretório possui uma pasta `build`, pois é lá onde você vai criar o seu executável, caso nao exista, crie uma pasta com o comando:
+        ```bash
+        mkdir build && cd build
+        ```
+
+    2. Compile o projeto com o comando, lembrando de adicionar a flag para a compilação:
+        ```bash
+        cmake -DNNG_ENABLE_TLS=ON .. && make
+        ```
+    3. Lembre de colocar uma chave redis condizente com o que você quer, aqui colocarei **teste_latencia_tls**;
+    - Exemplo(depois de você fazer os passos anteriores, `sub_tls/build`):
+        ```bash
+        ./sub_tls -u tls+mqtt-tcp://broker.emqx.io:8883 -t teste_latencia_tls -q 0 -r teste_latencia_tls
+        ```
+
+- ### Publisher(`tcp/pub_tls`)
+
+    1. Verifique se o diretório possui uma pasta `build`, pois é lá onde você vai criar o seu executável, caso nao exista, crie uma pasta com o comando:
+        ```bash
+        mkdir build && cd build
+        ```
+    2. Compile o projeto com o comando, lembrando de adicionar a flag para a compilação:
+        ```bash
+        cmake -DNNG_ENABLE_TLS=ON .. && make
+        ```
+    3. Realize o teste, lembrando de colocar como parâmetro o **intervalo de envio** igual para todos(quic, tcp ou tls). Nesse caso eu deixarei 10 ms. Mas você pode alterar para qualquer outro valor;
+
+    - Exemplo(depois de você fazer os passos anteriores, `pub_tls/build`):
+        ```bash
+        ./tls -u tls+mqtt-tcp://broker.emqx.io:8883 -t teste_latencia_tls -q 0 -i 10 -n 10000
+        ```
+
+## Teste de latência MQTT/QUIC
+
+- ### Subscriber(`quic/sub`)
+
+    1. Verifique se o diretório possui uma pasta `build`, pois é lá onde você vai criar o seu executável, caso nao exista, crie uma pasta com o comando:
+        ```bash
+        mkdir build && cd build
+        ```
+    2. Compile o projeto com o comando:
+        ```bash
+        cmake .. && make
+        ```
+    3. Lembre de colocar uma chave redis condizente com o que você quer, aqui colocarei **teste_latencia_quic**;
+
+    - Exemplo (depois de você fazer os passos anteriores, `sub/build`):
+        ```bash
+        ./sub sub "mqtt-quic://broker.emqx.io:14567" 0 teste_latencia_quic teste_latencia_quic
+        ```
+
+
+- ### Publisher(`quic/pub`)
+
+    1. Verifique se o diretório possui uma pasta `build`, pois é lá onde você vai criar o seu executável, caso nao exista, crie uma pasta com o comando:
+        ```bash
+        mkdir build && cd build
+        ```
+    2. Compile o projeto com o comando:
+        ```bash
+        cmake .. && make
+        ```
+    3. Realize o teste, lembrando de colocar como parâmetro o **intervalo de envio** igual para todos(quic, tcp ou tls). Nesse caso eu deixarei 10 ms. Mas você pode alterar para qualquer outro valor.
+
+    - Exemplo(depois de você fazer os passos anteriores, `pub/build`):
+        ```bash
+        ./publisher mqtt-quic://broker.emqx.io:14567 0 teste_latencia_quic 10000 10
+        ```
+
+## Redis-cli
+
+Para acessar o redis na linha de comando apenas digite(lembrando de estar com o serviço do redis ativo):
+
+```bash
+redis-cli
+```
+- ### Features do redis para verificação do teste
+    - Comando para saber quais são todas as chaves:
+    ```bash
+    keys *
+    ```
+    - Comando para saber quais são todos os dados de uma chave
+    ```bash
+    lrange <key> 0 -1
+    ```
+
+## Como gerar os documentos de análise ?
+
+- Primeiro devemos instalar as dependências necessárias com :
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+- Depois executar o código que irá fazer a análise:
+
+    ```bash
+    python3 analise.py
+    ```
+- ### OBS: Os arquivos gerados estão dentro da pasta com o mesmo nome da chave redis.

fases/implementacao/pub_sub_hiredis/teste/Analise/analise.py

@@ -7,16 +7,24 @@
 from docx.shared import Inches
 import os
 
-# Nome da chave Redis
-redis_key = 'quic'
+# Conectar ao Redis
+r = redis.Redis(host='localhost', port=6379, db=0)
+
+# Obter todas as chaves
+keys = r.keys('*')
+
+# Exibir todas as chaves e permitir ao usuário escolher uma
+print("Chaves no Redis:")
+for i, key in enumerate(keys):
+    print(f"{i + 1}. {key.decode('utf-8')}")
+
+choice = int(input("Escolha uma chave digitando o número correspondente: ")) - 1
+redis_key = keys[choice].decode('utf-8')
 
 # Criar diretório para armazenar os arquivos
 output_dir = f'{redis_key}'
 os.makedirs(output_dir, exist_ok=True)
 
-# Conectar ao Redis
-r = redis.Redis(host='localhost', port=6379, db=0)
-
 # Recuperar os dados da chave Redis
 latencies = r.lrange(redis_key, 0, -1)
 latencies = [float(latency.decode('utf-8').strip('"')) for latency in latencies]  # Convertendo para floats

fases/implementacao/pub_sub_hiredis/teste/Analise/requirements.txt

@@ -0,0 +1,5 @@
+redis
+numpy
+matplotlib
+scipy
+python-docx

fases/implementacao/pub_sub_hiredis/teste/installing_compile_project.sh

@@ -25,7 +25,7 @@ dependencies=(
     ninja-build
     libc6-dev
     gcc-multilib
-    //pip-python3
+    pip-python3
 )
 
 # Verifica e instala cada dependência

fases/implementacao/pub_sub_hiredis/teste/quic/pub/README.md

@@ -9,7 +9,7 @@ Nessa implementação, é enviado o tempo atual em nanosegundos para um dado tó
 - Caso você queira publicar no tópico `teste/quic`, na url do broker `mqtt-quic://broker.emqx.io:14567` e com o qos `0` e que queira publicar 1000 pacotes:
 
     ```bash
-    ./publisher mqtt-quic://broker.emqx.io:14567 0 teste/quic 1000
+    ./publisher mqtt-quic://broker.emqx.io:14567 0 teste/quic 1000 10
     ```
 
 - Ele vai se conectar no broker:

fases/implementacao/pub_sub_hiredis/teste/quic/pub/publisher.c

@@ -149,13 +149,14 @@ void publish(const char *topic, int q){
 };
 
 int
-client(int type, const char *url, const char *qos, const char *topic, const char *numero_pub)
+client(int type, const char *url, const char *qos, const char *topic, const char *numero_pub, const char *interval)
 {
+
 	nng_socket  sock;
 	int         rv, sz, q, qpub, i;
 	nng_msg *   msg;
 	const char *arg = "CLIENT FOR QUIC";
-
+	uint32_t intervalo = atoi(interval);
 	/*
 	// Open a quic socket without configuration
 	if ((rv = nng_mqtt_quic_client_open(&sock, url)) != 0) {
@@ -216,7 +217,7 @@ client(int type, const char *url, const char *qos, const char *topic, const char
 
 
 			publish(topic,q);
-			nng_msleep(10);//necessário um atraso pro subscriber poder lidar com as mensagens
+			nng_msleep(intervalo);//necessário um atraso pro subscriber poder lidar com as mensagens
 			//printf("Publicação %d\n", i+1);
 		//msg = mqtt_msg_compose(PUB, q, (char *)topic, (char *)data);
 		//nng_sendmsg(*g_sock, msg, NNG_FLAG_ALLOC);
@@ -247,17 +248,18 @@ client(int type, const char *url, const char *qos, const char *topic, const char
 static void
 printf_helper(char *exec)
 {
-	fprintf(stderr, "Usage: %s <url> <qos> <topic> <num_packets>\n", exec);
+	fprintf(stderr, "Usage: %s <url> <qos> <topic> <num_packets> <interval>\n", exec);
 	//fprintf(stderr, "Usage: %s <url> <qos> <topic>\n", exec);
 	exit(EXIT_FAILURE);
 }
 
 int main(int argc, char **argv) {
-    if (argc < 4) {
+    if (argc < 5) {
         goto error;
     }
+
     //client(PUB, argv[1], argv[2], argv[3], argv[4], argv[5]);
-	client(PUB, argv[1], argv[2], argv[3], argv[4]);
+	client(PUB, argv[1], argv[2], argv[3], argv[4], argv[5]);
 
     return 0;
 

fases/implementacao/pub_sub_hiredis/teste/tcp/pub_tls/tls.c

@@ -277,12 +277,12 @@ char *tempo_para_varchar() {
 
 void usage()
 {
-    fprintf(stderr, "Usage: ./tls [-u URL] [-a CAFILE] [-c CERT] [-k KEY] [-p PASS] [-v VERSION]\n");
+    fprintf(stderr, "Usage: ./tls [-u URL] [-a CAFILE] [-c CERT] [-k KEY] [-p PASS] [-v VERSION] [-t TOPIC] [-q QOS] [-i INTERVAL] [-n NUMBER_PACKETS]\n");
     exit(1);
 }
 
 void usage_definition(){
-    fprintf(stderr, "Usage: tls [-u URL] [-c CAFILE] [-t CERT] [-k KEY] [-p PASS] [-v VERSION]\n");
+    fprintf(stderr, "Usage: tls [-u URL] [-c CAFILE] [-t CERT] [-k KEY] [-p PASS] [-v VERSION] [-t TOPIC] [-q QOS] [-i INTERVAL] [-n NUMBER_PACKETS]\n");
     fprintf(stderr, "  example: tls -u tls+mqtt-tcp://broker.emqx.io:8883 \n");
     fprintf(stderr, "Options:\n");
     fprintf(stderr, "  -u URL      URL of the MQTT broker. Use the port 8883 and tls+mqtt-tcp to url protocol\n");
@@ -293,7 +293,6 @@ void usage_definition(){
     fprintf(stderr, "  -v VERSION  MQTT protocol version (default: 4)\n");
     fprintf(stderr, "  -h          Show this help\n");
     fprintf(stderr, "  -t TOPIC    Topic to publish\n");
-    fprintf(stderr, "  -t TOPIC    Topic to publish\n");
     fprintf(stderr, "  -q QOS      QoS level (default: 0)\n");
     fprintf(stderr, "  -i INTERVAL Interval between packets in milliseconds (default: 1000)\n");
     fprintf(stderr, "  -n NUM      Number of packets to send (default: 1)\n");

fases/implementacao/pub_sub_hiredis/teste/tcp/sub_tls/sub_tls.c

@@ -422,12 +422,12 @@ int tls_client(const char *url, uint8_t proto_ver, const char *ca, const char *c
 
 void usage()
 {
-    fprintf(stderr, "Usage: ./tls [-u URL] [-a CAFILE] [-c CERT] [-k KEY] [-p PASS] [-v VERSION]\n");
+    fprintf(stderr, "Usage: ./sub_tls [-u URL] [-a CAFILE] [-c CERT] [-k KEY] [-p PASS] [-v VERSION] [-t TOPIC] [-q  QOS] [-r REDIS_KEY]\n");
     exit(1);
 }
 
 void usage_definition(){
-    fprintf(stderr, "Usage: tls [-u URL] [-c CAFILE] [-t CERT] [-k KEY] [-p PASS] [-v VERSION]\n");
+    fprintf(stderr, "Usage: sub_tls [-u URL] [-c CAFILE] [-t CERT] [-k KEY] [-p PASS] [-v VERSION] [-t TOPIC] [-q  QOS] [-r REDIS_KEY]\n");
     fprintf(stderr, "  example: tls -u tls+mqtt-tcp://broker.emqx.io:8883 \n");
     fprintf(stderr, "Options:\n");
     fprintf(stderr, "  -u URL      URL of the MQTT broker. Use the port 8883 and tls+mqtt-tcp to url protocol\n");
@@ -438,10 +438,8 @@ void usage_definition(){
     fprintf(stderr, "  -v VERSION  MQTT protocol version (default: 4)\n");
     fprintf(stderr, "  -h          Show this help\n");
     fprintf(stderr, "  -t TOPIC    Topic to publish\n");
-    fprintf(stderr, "  -t TOPIC    Topic to publish\n");
     fprintf(stderr, "  -q QOS      QoS level (default: 0)\n");
-    fprintf(stderr, "  -i INTERVAL Interval between packets in milliseconds (default: 1000)\n");
-    fprintf(stderr, "  -n NUM      Number of packets to send (default: 1)\n");
+    fprintf(stderr, "  -r REDISKEY Redis key to save the latency (default: valores)\n");
     exit(1);
 }
 
@@ -459,7 +457,7 @@ int main(int argc, char const *argv[])
 
     // Elements for latency test
     const char *topic;
-    topic = "teste_davi";
+    topic = "teste_davi"; //TOPICO PADRAO PARA O TOPICO
     uint8_t qos = 0; //default qos is 0
     bool verbose = false;
     const char *redis_key = "valores"; //chave padrão para o redis