1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Intel Corporation
8 #include <sys/socket.h>
13 #include <rte_metrics.h>
14 #include <rte_option.h>
15 #include <rte_string_fns.h>
16 #include <rte_lcore.h>
18 #include "rte_telemetry.h"
19 #include "rte_telemetry_internal.h"
20 #include "rte_telemetry_parser.h"
21 #include "rte_telemetry_socket_tests.h"
27 #define SELFTEST_VALID_CLIENT "/var/run/dpdk/valid_client"
28 #define SELFTEST_INVALID_CLIENT "/var/run/dpdk/invalid_client"
29 #define SOCKET_TEST_CLIENT_PATH "/var/run/dpdk/client"
31 static telemetry_impl *static_telemetry;
33 struct telemetry_message_test {
34 const char *test_name;
35 int (*test_func_ptr)(struct telemetry_impl *telemetry, int fd);
46 /* global array of functions pointers to metrics library */
47 const struct metrics_functions *metrics_fns;
50 rte_telemetry_set_metrics_fns(const struct metrics_functions *fns)
56 rte_telemetry_get_runtime_dir(char *socket_path, size_t size)
58 snprintf(socket_path, size, "%s/telemetry", rte_eal_get_runtime_dir());
62 rte_telemetry_write_to_socket(struct telemetry_impl *telemetry,
63 const char *json_string)
67 if (telemetry == NULL) {
68 TELEMETRY_LOG_ERR("Could not initialise TELEMETRY_API");
72 if (telemetry->request_client == NULL) {
73 TELEMETRY_LOG_ERR("No client has been chosen to write to");
77 if (json_string == NULL) {
78 TELEMETRY_LOG_ERR("Invalid JSON string!");
82 ret = send(telemetry->request_client->fd,
83 json_string, strlen(json_string), 0);
85 TELEMETRY_LOG_ERR("Failed to write to socket for client: %s",
86 telemetry->request_client->file_path);
94 rte_telemetry_send_error_response(struct telemetry_impl *telemetry,
98 const char *status_code, *json_buffer;
101 if (error_type == -EPERM)
102 status_code = "Status Error: Unknown";
103 else if (error_type == -EINVAL)
104 status_code = "Status Error: Invalid Argument 404";
105 else if (error_type == -ENOMEM)
106 status_code = "Status Error: Memory Allocation Error";
108 TELEMETRY_LOG_ERR("Invalid error type");
112 root = json_object();
115 TELEMETRY_LOG_ERR("Could not create root JSON object");
119 ret = json_object_set_new(root, "status_code", json_string(status_code));
121 TELEMETRY_LOG_ERR("Status code field cannot be set");
126 ret = json_object_set_new(root, "data", json_null());
128 TELEMETRY_LOG_ERR("Data field cannot be set");
133 json_buffer = json_dumps(root, 0);
136 ret = rte_telemetry_write_to_socket(telemetry, json_buffer);
138 TELEMETRY_LOG_ERR("Could not write to socket");
146 rte_telemetry_send_global_stats_values(struct telemetry_encode_param *ep,
147 struct telemetry_impl *telemetry)
150 char *json_buffer = NULL;
152 if (telemetry == NULL) {
153 TELEMETRY_LOG_ERR("Invalid telemetry argument");
157 ret = metrics_fns->encode_json_format(ep, &json_buffer);
159 TELEMETRY_LOG_ERR("JSON encode function failed");
160 ret = rte_telemetry_send_error_response(telemetry, ret);
162 TELEMETRY_LOG_ERR("Could not send error");
166 ret = rte_telemetry_write_to_socket(telemetry, json_buffer);
168 TELEMETRY_LOG_ERR("Could not write to socket");
176 rte_telemetry_send_ports_stats_values(struct telemetry_encode_param *ep,
177 struct telemetry_impl *telemetry)
180 char *json_buffer = NULL;
182 if (telemetry == NULL) {
183 TELEMETRY_LOG_ERR("Invalid telemetry argument");
188 TELEMETRY_LOG_ERR("Invalid encode param argument");
192 if (ep->pp.num_metric_ids < 0) {
193 TELEMETRY_LOG_ERR("Invalid num_metric_ids, must be positive");
197 if (ep->pp.num_port_ids < 0) {
198 TELEMETRY_LOG_ERR("Invalid num_port_ids, must be positive");
202 ret = metrics_fns->get_ports_stats_json(ep, telemetry->reg_index,
205 TELEMETRY_LOG_ERR("Function for get_ports_stats_json"
207 ret = rte_telemetry_send_error_response(telemetry, ret);
209 TELEMETRY_LOG_ERR("Could not send error");
213 ret = rte_telemetry_write_to_socket(telemetry, json_buffer);
215 TELEMETRY_LOG_ERR("Could not write to socket");
222 ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
224 TELEMETRY_LOG_ERR("Could not send error");
229 rte_telemetry_initial_accept(struct telemetry_impl *telemetry)
234 ret = metrics_fns->reg_all_ethdev(&telemetry->metrics_register_done,
235 telemetry->reg_index);
237 TELEMETRY_LOG_ERR("Failed to register ethdev metrics");
238 ret = rte_telemetry_send_error_response(telemetry, ret);
240 TELEMETRY_LOG_ERR("Could not send error");
245 ret = rte_telemetry_socket_messaging_testing(telemetry->reg_index[0],
246 telemetry->server_fd);
250 ret = rte_telemetry_parser_test(telemetry);
252 TELEMETRY_LOG_ERR("Parser Tests Failed");
256 TELEMETRY_LOG_INFO("Success - All Parser Tests Passed");
263 rte_telemetry_read_client(struct telemetry_impl *telemetry)
266 int ret, buffer_read;
268 buffer_read = read(telemetry->accept_fd, buf, BUF_SIZE-1);
270 if (buffer_read == -1) {
271 TELEMETRY_LOG_ERR("Read error");
273 } else if (buffer_read == 0) {
276 buf[buffer_read] = '\0';
277 ret = rte_telemetry_parse_client_message(telemetry, buf);
279 TELEMETRY_LOG_WARN("Parse message failed");
284 if (close(telemetry->accept_fd) < 0) {
285 TELEMETRY_LOG_ERR("Close TELEMETRY socket failed");
289 telemetry->accept_fd = 0;
295 rte_telemetry_accept_new_client(struct telemetry_impl *telemetry)
299 if (telemetry->accept_fd <= 0) {
300 ret = listen(telemetry->server_fd, 1);
302 TELEMETRY_LOG_ERR("Listening error with server fd");
306 telemetry->accept_fd = accept(telemetry->server_fd, NULL, NULL);
307 if (telemetry->accept_fd >= 0 &&
308 telemetry->metrics_register_done == 0) {
309 ret = rte_telemetry_initial_accept(telemetry);
311 TELEMETRY_LOG_ERR("Failed to run initial configurations/tests");
316 ret = rte_telemetry_read_client(telemetry);
318 TELEMETRY_LOG_ERR("Failed to read socket buffer");
327 rte_telemetry_read_client_sockets(struct telemetry_impl *telemetry)
330 telemetry_client *client;
331 char client_buf[BUF_SIZE];
334 TAILQ_FOREACH(client, &telemetry->client_list_head, client_list) {
335 bytes = read(client->fd, client_buf, BUF_SIZE-1);
338 client_buf[bytes] = '\0';
339 telemetry->request_client = client;
340 ret = rte_telemetry_parse(telemetry, client_buf);
342 TELEMETRY_LOG_WARN("Parse socket input failed: %i",
353 rte_telemetry_run(void *userdata)
356 struct telemetry_impl *telemetry = userdata;
358 if (telemetry == NULL) {
359 TELEMETRY_LOG_WARN("TELEMETRY could not be initialised");
363 ret = rte_telemetry_accept_new_client(telemetry);
365 TELEMETRY_LOG_ERR("Accept and read new client failed");
369 ret = rte_telemetry_read_client_sockets(telemetry);
371 TELEMETRY_LOG_ERR("Client socket read failed");
379 *rte_telemetry_run_thread_func(void *userdata)
382 struct telemetry_impl *telemetry = userdata;
384 if (telemetry == NULL) {
385 TELEMETRY_LOG_ERR("%s passed a NULL instance", __func__);
389 while (telemetry->thread_status) {
390 rte_telemetry_run(telemetry);
391 ret = usleep(SLEEP_TIME);
393 TELEMETRY_LOG_ERR("Calling thread could not be put to sleep");
399 rte_telemetry_set_socket_nonblock(int fd)
404 TELEMETRY_LOG_ERR("Invalid fd provided");
408 flags = fcntl(fd, F_GETFL, 0);
412 return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
416 rte_telemetry_create_socket(struct telemetry_impl *telemetry)
419 struct sockaddr_un addr;
420 char socket_path[BUF_SIZE];
422 if (telemetry == NULL)
425 telemetry->server_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
426 if (telemetry->server_fd == -1) {
427 TELEMETRY_LOG_ERR("Failed to open socket");
431 ret = rte_telemetry_set_socket_nonblock(telemetry->server_fd);
433 TELEMETRY_LOG_ERR("Could not set socket to NONBLOCK");
437 addr.sun_family = AF_UNIX;
438 rte_telemetry_get_runtime_dir(socket_path, sizeof(socket_path));
439 strlcpy(addr.sun_path, socket_path, sizeof(addr.sun_path));
442 if (bind(telemetry->server_fd, (struct sockaddr *)&addr,
444 TELEMETRY_LOG_ERR("Socket binding error");
451 if (close(telemetry->server_fd) < 0) {
452 TELEMETRY_LOG_ERR("Close TELEMETRY socket failed");
460 rte_telemetry_init(void)
464 const char *telemetry_ctrl_thread = "telemetry";
466 if (static_telemetry) {
467 TELEMETRY_LOG_WARN("TELEMETRY structure already initialised");
471 static_telemetry = calloc(1, sizeof(struct telemetry_impl));
472 if (static_telemetry == NULL) {
473 TELEMETRY_LOG_ERR("Memory could not be allocated");
477 static_telemetry->socket_id = rte_socket_id();
479 ret = pthread_attr_init(&attr);
481 TELEMETRY_LOG_ERR("Pthread attribute init failed");
485 ret = rte_telemetry_create_socket(static_telemetry);
487 ret = rte_telemetry_cleanup();
489 TELEMETRY_LOG_ERR("TELEMETRY cleanup failed");
492 TAILQ_INIT(&static_telemetry->client_list_head);
494 ret = rte_ctrl_thread_create(&static_telemetry->thread_id,
495 telemetry_ctrl_thread, &attr, rte_telemetry_run_thread_func,
496 (void *)static_telemetry);
497 static_telemetry->thread_status = 1;
500 ret = rte_telemetry_cleanup();
502 TELEMETRY_LOG_ERR("TELEMETRY cleanup failed");
506 if (rte_telemetry_new_init() != 0)
513 rte_telemetry_client_cleanup(struct telemetry_client *client)
517 ret = close(client->fd);
518 free(client->file_path);
522 TELEMETRY_LOG_ERR("Close client socket failed");
530 rte_telemetry_cleanup(void)
533 struct telemetry_impl *telemetry = static_telemetry;
534 telemetry_client *client, *temp_client;
536 TAILQ_FOREACH_SAFE(client, &telemetry->client_list_head, client_list,
538 TAILQ_REMOVE(&telemetry->client_list_head, client, client_list);
539 ret = rte_telemetry_client_cleanup(client);
541 TELEMETRY_LOG_ERR("Client cleanup failed");
546 ret = close(telemetry->server_fd);
548 TELEMETRY_LOG_ERR("Close TELEMETRY socket failed");
553 telemetry->thread_status = 0;
554 pthread_join(telemetry->thread_id, NULL);
556 static_telemetry = NULL;
562 rte_telemetry_unregister_client(struct telemetry_impl *telemetry,
563 const char *client_path)
566 telemetry_client *client, *temp_client;
568 if (telemetry == NULL) {
569 TELEMETRY_LOG_WARN("TELEMETRY is not initialised");
573 if (client_path == NULL) {
574 TELEMETRY_LOG_ERR("Invalid client path");
578 if (TAILQ_EMPTY(&telemetry->client_list_head)) {
579 TELEMETRY_LOG_ERR("There are no clients currently registered");
583 TAILQ_FOREACH_SAFE(client, &telemetry->client_list_head, client_list,
585 if (strcmp(client_path, client->file_path) == 0) {
586 TAILQ_REMOVE(&telemetry->client_list_head, client,
588 ret = rte_telemetry_client_cleanup(client);
591 TELEMETRY_LOG_ERR("Client cleanup failed");
599 TELEMETRY_LOG_WARN("Couldn't find client, possibly not registered yet.");
603 ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
605 TELEMETRY_LOG_ERR("Could not send error");
610 rte_telemetry_register_client(struct telemetry_impl *telemetry,
611 const char *client_path)
614 struct sockaddr_un addrs;
616 if (telemetry == NULL) {
617 TELEMETRY_LOG_ERR("Could not initialize TELEMETRY API");
621 if (client_path == NULL) {
622 TELEMETRY_LOG_ERR("Invalid client path");
626 telemetry_client *client;
627 TAILQ_FOREACH(client, &telemetry->client_list_head, client_list) {
628 if (strcmp(client_path, client->file_path) == 0) {
629 TELEMETRY_LOG_WARN("'%s' already registered",
635 fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
637 TELEMETRY_LOG_ERR("Client socket error");
641 ret = rte_telemetry_set_socket_nonblock(fd);
643 TELEMETRY_LOG_ERR("Could not set socket to NONBLOCK");
647 addrs.sun_family = AF_UNIX;
648 strlcpy(addrs.sun_path, client_path, sizeof(addrs.sun_path));
649 telemetry_client *new_client = malloc(sizeof(telemetry_client));
650 new_client->file_path = strdup(client_path);
653 if (connect(fd, (struct sockaddr *)&addrs, sizeof(addrs)) == -1) {
654 TELEMETRY_LOG_ERR("TELEMETRY client connect to %s didn't work",
656 ret = rte_telemetry_client_cleanup(new_client);
658 TELEMETRY_LOG_ERR("Client cleanup failed");
664 TAILQ_INSERT_HEAD(&telemetry->client_list_head, new_client, client_list);
670 rte_telemetry_parse_client_message(struct telemetry_impl *telemetry, char *buf)
674 json_t *root = json_loads(buf, 0, &error);
677 TELEMETRY_LOG_WARN("Could not load JSON object from data passed in : %s",
680 } else if (!json_is_object(root)) {
681 TELEMETRY_LOG_WARN("JSON Request is not a JSON object");
685 json_t *action = json_object_get(root, "action");
686 if (action == NULL) {
687 TELEMETRY_LOG_WARN("Request does not have action field");
689 } else if (!json_is_integer(action)) {
690 TELEMETRY_LOG_WARN("Action value is not an integer");
694 json_t *command = json_object_get(root, "command");
695 if (command == NULL) {
696 TELEMETRY_LOG_WARN("Request does not have command field");
698 } else if (!json_is_string(command)) {
699 TELEMETRY_LOG_WARN("Command value is not a string");
703 action_int = json_integer_value(action);
704 if (action_int != ACTION_POST) {
705 TELEMETRY_LOG_WARN("Invalid action code");
709 if (strcmp(json_string_value(command), "clients") != 0) {
710 TELEMETRY_LOG_WARN("Invalid command");
714 json_t *data = json_object_get(root, "data");
716 TELEMETRY_LOG_WARN("Request does not have data field");
720 json_t *client_path = json_object_get(data, "client_path");
721 if (client_path == NULL) {
722 TELEMETRY_LOG_WARN("Request does not have client_path field");
726 if (!json_is_string(client_path)) {
727 TELEMETRY_LOG_WARN("Client_path value is not a string");
731 ret = rte_telemetry_register_client(telemetry,
732 json_string_value(client_path));
734 TELEMETRY_LOG_ERR("Could not register client");
735 telemetry->register_fail_count++;
742 TELEMETRY_LOG_WARN("Client attempted to register with invalid message");
748 rte_telemetry_dummy_client_socket(const char *valid_client_path)
750 int sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
751 struct sockaddr_un addr = {0};
754 TELEMETRY_LOG_ERR("Test socket creation failure");
758 addr.sun_family = AF_UNIX;
759 strlcpy(addr.sun_path, valid_client_path, sizeof(addr.sun_path));
760 unlink(valid_client_path);
762 if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
763 TELEMETRY_LOG_ERR("Test socket binding failure");
767 if (listen(sockfd, 1) < 0) {
768 TELEMETRY_LOG_ERR("Listen failure");
776 rte_telemetry_selftest(void)
778 const char *invalid_client_path = SELFTEST_INVALID_CLIENT;
779 const char *valid_client_path = SELFTEST_VALID_CLIENT;
782 TELEMETRY_LOG_INFO("Selftest");
784 ret = rte_telemetry_init();
786 TELEMETRY_LOG_ERR("Valid initialisation test failed");
790 TELEMETRY_LOG_INFO("Success - Valid initialisation test passed");
792 ret = rte_telemetry_init();
793 if (ret != -EALREADY) {
794 TELEMETRY_LOG_ERR("Invalid initialisation test failed");
798 TELEMETRY_LOG_INFO("Success - Invalid initialisation test passed");
800 ret = rte_telemetry_unregister_client(static_telemetry,
801 invalid_client_path);
803 TELEMETRY_LOG_ERR("Invalid unregister test failed");
807 TELEMETRY_LOG_INFO("Success - Invalid unregister test passed");
809 sockfd = rte_telemetry_dummy_client_socket(valid_client_path);
811 TELEMETRY_LOG_ERR("Test socket creation failed");
815 ret = rte_telemetry_register_client(static_telemetry, valid_client_path);
817 TELEMETRY_LOG_ERR("Valid register test failed: %i", ret);
821 accept(sockfd, NULL, NULL);
822 TELEMETRY_LOG_INFO("Success - Valid register test passed");
824 ret = rte_telemetry_register_client(static_telemetry, valid_client_path);
825 if (ret != -EINVAL) {
826 TELEMETRY_LOG_ERR("Invalid register test failed: %i", ret);
830 TELEMETRY_LOG_INFO("Success - Invalid register test passed");
832 ret = rte_telemetry_unregister_client(static_telemetry,
833 invalid_client_path);
835 TELEMETRY_LOG_ERR("Invalid unregister test failed: %i", ret);
839 TELEMETRY_LOG_INFO("Success - Invalid unregister test passed");
841 ret = rte_telemetry_unregister_client(static_telemetry, valid_client_path);
843 TELEMETRY_LOG_ERR("Valid unregister test failed: %i", ret);
847 TELEMETRY_LOG_INFO("Success - Valid unregister test passed");
849 ret = rte_telemetry_cleanup();
851 TELEMETRY_LOG_ERR("Cleanup test failed");
855 TELEMETRY_LOG_INFO("Success - Valid cleanup test passed");
861 rte_telemetry_socket_messaging_testing(int index, int socket)
863 struct telemetry_impl *telemetry = calloc(1, sizeof(telemetry_impl));
864 int fd, bad_send_fd, send_fd, bad_fd, bad_recv_fd, recv_fd, ret;
866 if (telemetry == NULL) {
867 TELEMETRY_LOG_ERR("Could not initialize Telemetry API");
871 telemetry->server_fd = socket;
872 telemetry->reg_index[0] = index;
873 TELEMETRY_LOG_INFO("Beginning Telemetry socket message Selftest");
874 rte_telemetry_socket_test_setup(telemetry, &send_fd, &recv_fd);
875 TELEMETRY_LOG_INFO("Register valid client test");
877 ret = rte_telemetry_socket_register_test(telemetry, &fd, send_fd,
880 TELEMETRY_LOG_ERR("Register valid client test failed!");
885 TELEMETRY_LOG_INFO("Success - Register valid client test passed!");
887 TELEMETRY_LOG_INFO("Register invalid/same client test");
888 ret = rte_telemetry_socket_test_setup(telemetry, &bad_send_fd,
890 ret = rte_telemetry_socket_register_test(telemetry, &bad_fd,
891 bad_send_fd, bad_recv_fd);
893 TELEMETRY_LOG_ERR("Register invalid/same client test failed!");
898 TELEMETRY_LOG_INFO("Success - Register invalid/same client test passed!");
900 ret = rte_telemetry_json_socket_message_test(telemetry, fd);
911 rte_telemetry_socket_register_test(struct telemetry_impl *telemetry, int *fd,
912 int send_fd, int recv_fd)
915 char good_req_string[BUF_SIZE];
917 snprintf(good_req_string, sizeof(good_req_string),
918 "{\"action\":1,\"command\":\"clients\",\"data\":{\"client_path\""
919 ":\"%s\"}}", SOCKET_TEST_CLIENT_PATH);
923 ret = send(send_fd, good_req_string, strlen(good_req_string), 0);
925 TELEMETRY_LOG_ERR("Could not send message over socket");
929 rte_telemetry_run(telemetry);
931 if (telemetry->register_fail_count != 0)
934 *fd = accept(recv_fd, NULL, NULL);
940 rte_telemetry_socket_test_setup(struct telemetry_impl *telemetry, int *send_fd,
944 const char *client_path = SOCKET_TEST_CLIENT_PATH;
945 char socket_path[BUF_SIZE];
946 struct sockaddr_un addr = {0};
947 struct sockaddr_un addrs = {0};
948 *send_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
949 *recv_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
951 listen(telemetry->server_fd, 5);
952 addr.sun_family = AF_UNIX;
953 rte_telemetry_get_runtime_dir(socket_path, sizeof(socket_path));
954 strlcpy(addr.sun_path, socket_path, sizeof(addr.sun_path));
956 ret = connect(*send_fd, (struct sockaddr *) &addr, sizeof(addr));
958 TELEMETRY_LOG_ERR("Could not connect socket");
962 telemetry->accept_fd = accept(telemetry->server_fd, NULL, NULL);
964 addrs.sun_family = AF_UNIX;
965 strlcpy(addrs.sun_path, client_path, sizeof(addrs.sun_path));
968 ret = bind(*recv_fd, (struct sockaddr *)&addrs, sizeof(addrs));
970 TELEMETRY_LOG_ERR("Could not bind socket");
978 rte_telemetry_stat_parse(char *buf, struct json_data *json_data_struct)
981 json_t *root = json_loads(buf, 0, &error);
983 json_t *status, *dataArray, *port, *stats, *name, *value, *dataArrayObj,
991 TELEMETRY_LOG_ERR("JSON message is NULL");
996 TELEMETRY_LOG_ERR("Could not load JSON object from data passed in : %s",
999 } else if (!json_is_object(root)) {
1000 TELEMETRY_LOG_ERR("JSON Request is not a JSON object");
1005 status = json_object_get(root, "status_code");
1007 TELEMETRY_LOG_ERR("Request does not have status field");
1009 } else if (!json_is_string(status)) {
1010 TELEMETRY_LOG_ERR("Status value is not a string");
1014 json_data_struct->status_code = strdup(json_string_value(status));
1016 dataArray = json_object_get(root, "data");
1017 if (dataArray == NULL) {
1018 TELEMETRY_LOG_ERR("Request does not have data field");
1022 arraylen = json_array_size(dataArray);
1023 if (arraylen == 0) {
1024 json_data_struct->data = "null";
1028 for (i = 0; i < arraylen; i++) {
1029 dataArrayObj = json_array_get(dataArray, i);
1030 port = json_object_get(dataArrayObj, "port");
1031 stats = json_object_get(dataArrayObj, "stats");
1035 TELEMETRY_LOG_ERR("Request does not have port field");
1039 if (!json_is_integer(port)) {
1040 TELEMETRY_LOG_ERR("Port value is not an integer");
1044 json_data_struct->port = json_integer_value(port);
1046 if (stats == NULL) {
1047 TELEMETRY_LOG_ERR("Request does not have stats field");
1051 arraylen = json_array_size(stats);
1052 for (i = 0; i < arraylen; i++) {
1053 statsArrayObj = json_array_get(stats, i);
1054 name = json_object_get(statsArrayObj, "name");
1055 value = json_object_get(statsArrayObj, "value");
1059 TELEMETRY_LOG_ERR("Request does not have name field");
1063 if (!json_is_string(name)) {
1064 TELEMETRY_LOG_ERR("Stat name value is not a string");
1068 json_data_struct->stat_name = strdup(json_string_value(name));
1070 if (value == NULL) {
1071 TELEMETRY_LOG_ERR("Request does not have value field");
1075 if (!json_is_integer(value)) {
1076 TELEMETRY_LOG_ERR("Stat value is not an integer");
1080 json_data_struct->stat_value = json_integer_value(value);
1086 rte_telemetry_free_test_data(struct json_data *data)
1088 free(data->status_code);
1089 free(data->stat_name);
1094 rte_telemetry_valid_json_test(struct telemetry_impl *telemetry, int fd)
1100 int buffer_read = 0;
1102 struct json_data *data_struct;
1104 const char *status = "Status OK: 200";
1105 const char *name = "rx_good_packets";
1106 const char *valid_json_message = "{\"action\":0,\"command\":"
1107 "\"ports_stats_values_by_name\",\"data\":{\"ports\""
1108 ":[0],\"stats\":[\"rx_good_packets\"]}}";
1110 ret = send(fd, valid_json_message, strlen(valid_json_message), 0);
1112 TELEMETRY_LOG_ERR("Could not send message over socket");
1116 rte_telemetry_run(telemetry);
1117 buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
1119 if (buffer_read == -1) {
1120 TELEMETRY_LOG_ERR("Read error");
1124 buf[buffer_read] = '\0';
1125 data_struct = calloc(1, sizeof(struct json_data));
1126 ret = rte_telemetry_stat_parse(buf, data_struct);
1129 TELEMETRY_LOG_ERR("Could not parse stats");
1133 if (strcmp(data_struct->status_code, status) != 0) {
1134 TELEMETRY_LOG_ERR("Status code is invalid");
1138 if (data_struct->port != port) {
1139 TELEMETRY_LOG_ERR("Port is invalid");
1143 if (strcmp(data_struct->stat_name, name) != 0) {
1144 TELEMETRY_LOG_ERR("Stat name is invalid");
1148 if (data_struct->stat_value != value) {
1149 TELEMETRY_LOG_ERR("Stat value is invalid");
1153 rte_telemetry_free_test_data(data_struct);
1157 TELEMETRY_LOG_INFO("Success - Passed valid JSON message test passed");
1163 rte_telemetry_invalid_json_test(struct telemetry_impl *telemetry, int fd)
1168 const char *invalid_json = "{]";
1169 const char *status = "Status Error: Unknown";
1170 const char *data = "null";
1171 struct json_data *data_struct;
1172 int buffer_read = 0;
1175 ret = send(fd, invalid_json, strlen(invalid_json), 0);
1177 TELEMETRY_LOG_ERR("Could not send message over socket");
1181 rte_telemetry_run(telemetry);
1182 buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
1184 if (buffer_read == -1) {
1185 TELEMETRY_LOG_ERR("Read error");
1189 buf[buffer_read] = '\0';
1191 data_struct = calloc(1, sizeof(struct json_data));
1192 ret = rte_telemetry_stat_parse(buf, data_struct);
1195 TELEMETRY_LOG_ERR("Could not parse stats");
1197 if (strcmp(data_struct->status_code, status) != 0) {
1198 TELEMETRY_LOG_ERR("Status code is invalid");
1202 if (strcmp(data_struct->data, data) != 0) {
1203 TELEMETRY_LOG_ERR("Data status is invalid");
1207 rte_telemetry_free_test_data(data_struct);
1211 TELEMETRY_LOG_INFO("Success - Passed invalid JSON message test");
1217 rte_telemetry_json_contents_test(struct telemetry_impl *telemetry, int fd)
1222 const char *status = "Status Error: Invalid Argument 404";
1223 const char *data = "null";
1224 struct json_data *data_struct;
1225 const char *invalid_contents = "{\"action\":0,\"command\":"
1226 "\"ports_stats_values_by_name\",\"data\":{\"ports\""
1227 ":[0],\"stats\":[\"some_invalid_param\","
1228 "\"another_invalid_param\"]}}";
1229 int buffer_read = 0;
1232 ret = send(fd, invalid_contents, strlen(invalid_contents), 0);
1234 TELEMETRY_LOG_ERR("Could not send message over socket");
1238 rte_telemetry_run(telemetry);
1239 buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
1241 if (buffer_read == -1) {
1242 TELEMETRY_LOG_ERR("Read error");
1246 buf[buffer_read] = '\0';
1247 data_struct = calloc(1, sizeof(struct json_data));
1248 ret = rte_telemetry_stat_parse(buf, data_struct);
1251 TELEMETRY_LOG_ERR("Could not parse stats");
1253 if (strcmp(data_struct->status_code, status) != 0) {
1254 TELEMETRY_LOG_ERR("Status code is invalid");
1258 if (strcmp(data_struct->data, data) != 0) {
1259 TELEMETRY_LOG_ERR("Data status is invalid");
1263 rte_telemetry_free_test_data(data_struct);
1267 TELEMETRY_LOG_INFO("Success - Passed invalid JSON content test");
1273 rte_telemetry_json_empty_test(struct telemetry_impl *telemetry, int fd)
1278 const char *status = "Status Error: Invalid Argument 404";
1279 const char *data = "null";
1280 struct json_data *data_struct;
1281 const char *empty_json = "{}";
1282 int buffer_read = 0;
1285 ret = (send(fd, empty_json, strlen(empty_json), 0));
1287 TELEMETRY_LOG_ERR("Could not send message over socket");
1291 rte_telemetry_run(telemetry);
1292 buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
1294 if (buffer_read == -1) {
1295 TELEMETRY_LOG_ERR("Read error");
1299 buf[buffer_read] = '\0';
1300 data_struct = calloc(1, sizeof(struct json_data));
1301 ret = rte_telemetry_stat_parse(buf, data_struct);
1304 TELEMETRY_LOG_ERR("Could not parse stats");
1306 if (strcmp(data_struct->status_code, status) != 0) {
1307 TELEMETRY_LOG_ERR("Status code is invalid");
1311 if (strcmp(data_struct->data, data) != 0) {
1312 TELEMETRY_LOG_ERR("Data status is invalid");
1316 rte_telemetry_free_test_data(data_struct);
1321 TELEMETRY_LOG_INFO("Success - Passed JSON empty message test");
1327 rte_telemetry_json_socket_message_test(struct telemetry_impl *telemetry, int fd)
1330 int ret, fail_count;
1333 struct telemetry_message_test socket_json_tests[] = {
1334 {.test_name = "Invalid JSON test",
1335 .test_func_ptr = rte_telemetry_invalid_json_test},
1336 {.test_name = "Valid JSON test",
1337 .test_func_ptr = rte_telemetry_valid_json_test},
1338 {.test_name = "JSON contents test",
1339 .test_func_ptr = rte_telemetry_json_contents_test},
1340 {.test_name = "JSON empty tests",
1341 .test_func_ptr = rte_telemetry_json_empty_test}
1344 #define NUM_TESTS RTE_DIM(socket_json_tests)
1346 for (i = 0; i < NUM_TESTS; i++) {
1347 TELEMETRY_LOG_INFO("%s", socket_json_tests[i].test_name);
1348 ret = (socket_json_tests[i].test_func_ptr)
1351 TELEMETRY_LOG_ERR("%s failed",
1352 socket_json_tests[i].test_name);
1357 if (fail_count > 0) {
1358 TELEMETRY_LOG_ERR("Failed %i JSON socket message test(s)",
1363 TELEMETRY_LOG_INFO("Success - All JSON tests passed");
1368 int telemetry_log_level;
1370 static struct rte_option option = {
1371 .name = "telemetry",
1372 .usage = "Enable telemetry backend",
1373 .cb = &rte_telemetry_init,
1377 RTE_INIT(rte_telemetry_register)
1379 telemetry_log_level = rte_log_register("lib.telemetry");
1380 if (telemetry_log_level >= 0)
1381 rte_log_set_level(telemetry_log_level, RTE_LOG_ERR);
1383 rte_option_register(&option);