@@ -15,6 +15,13 @@ telemetry_probe(struct rte_vdev_device *vdev)
int ret;
RTE_SET_USED(vdev);
+ ret = rte_telemetry_selftest();
+ if (ret < 0) {
+ printf("Error - Selftest failed\n");
+ return -1;
+ }
+ printf("Success - Selftest passed\n");
+
ret = rte_telemetry_init(rte_socket_id());
if (ret < 0) {
printf("Error - Telemetry initialisation failed\n");
@@ -20,6 +20,7 @@ LIBABIVER := 1
# library source files
SRCS-$(CONFIG_RTE_LIBRTE_TELEMETRY) := rte_telemetry.c
SRCS-$(CONFIG_RTE_LIBRTE_TELEMETRY) += rte_telemetry_parser.c
+SRCS-$(CONFIG_RTE_LIBRTE_TELEMETRY) += rte_telemetry_parser_test.c
# export include files
SYMLINK-$(CONFIG_RTE_LIBRTE_TELEMETRY)-include := rte_telemetry.h
@@ -1,8 +1,8 @@
# SPDX-License-Identifier: BSD-3-Clause
# Copyright(c) 2018 Intel Corporation
-sources = files('rte_telemetry.c', 'rte_telemetry_parser.c')
-headers = files('rte_telemetry.h', 'rte_telemetry_internal.h', 'rte_telemetry_parser.h')
+sources = files('rte_telemetry.c', 'rte_telemetry_parser.c', 'rte_telemetry_parser_test.c')
+headers = files('rte_telemetry.h', 'rte_telemetry_internal.h', 'rte_telemetry_parser.h', 'rte_telemetry_parser_test.h')
deps += ['metrics', 'ethdev']
cflags += '-DALLOW_EXPERIMENTAL_API'
jansson = cc.find_library('jansson', required: true)
@@ -16,16 +16,34 @@
#include "rte_telemetry.h"
#include "rte_telemetry_internal.h"
#include "rte_telemetry_parser.h"
+#include "rte_telemetry_parser_test.h"
+#include "rte_telemetry_socket_tests.h"
#define BUF_SIZE 1024
#define ACTION_POST 1
#define SLEEP_TIME 10
#define DEFAULT_DPDK_PATH "/var/run/.rte_telemetry"
+#define SELFTEST_VALID_CLIENT "/var/run/valid_client"
+#define SELFTEST_INVALID_CLIENT "/var/run/invalid_client"
+#define SOCKET_TEST_CLIENT_PATH "/var/run/client"
const char *socket_path = DEFAULT_DPDK_PATH;
static telemetry_impl *static_telemetry;
+struct telemetry_message_test {
+ char *test_name;
+ int (*test_func_ptr)(struct telemetry_impl *telemetry, int fd);
+};
+
+struct json_data {
+ char *status_code;
+ char *data;
+ int port;
+ char *stat_name;
+ int stat_value;
+};
+
int32_t
rte_telemetry_check_port_activity(int port_id)
{
@@ -634,7 +652,7 @@ rte_telemetry_reg_ethdev_to_metrics(uint16_t port_id)
static int32_t
rte_telemetry_initial_accept(struct telemetry_impl *telemetry)
{
- int pid;
+ int pid, ret;
RTE_ETH_FOREACH_DEV(pid) {
telemetry->reg_index =
@@ -648,6 +666,17 @@ rte_telemetry_initial_accept(struct telemetry_impl *telemetry)
return -1;
}
telemetry->metrics_register_done = 1;
+ ret = rte_telemetry_socket_messaging_testing(telemetry->reg_index,
+ telemetry->server_fd);
+ if (ret < 0)
+ return -1;
+
+ ret = rte_telemetry_parser_test(telemetry);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Parser Tests Failed\n");
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - All Parser Tests Passed\n");
return 0;
}
@@ -1108,6 +1137,591 @@ rte_telemetry_parse_client_message(struct telemetry_impl *telemetry, char *buf)
return -1;
}
+int32_t
+rte_telemetry_dummy_client_socket(const char *valid_client_path)
+{
+ int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sockfd < 0) {
+ TELEMETRY_LOG_ERR("Error - Test socket creation failure\n");
+ return -1;
+ }
+ struct sockaddr_un addr = {0};
+ addr.sun_family = AF_UNIX;
+ strlcpy(addr.sun_path, valid_client_path, sizeof(addr.sun_path));
+ unlink(valid_client_path);
+
+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ TELEMETRY_LOG_ERR("Error - Test socket binding failure\n");
+ return -1;
+ }
+ if (listen(sockfd, 1) < 0) {
+ TELEMETRY_LOG_ERR("Error - Listen failure\n");
+ return -1;
+ }
+ return sockfd;
+}
+
+int32_t
+rte_telemetry_selftest(void)
+{
+ const char *invalid_client_path = SELFTEST_INVALID_CLIENT;
+ const char *valid_client_path = SELFTEST_VALID_CLIENT;
+ int ret, sockfd;
+
+ TELEMETRY_LOG_INFO("Selftest\n");
+
+ ret = rte_telemetry_init(rte_socket_id());
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Valid initialisation test"
+ " failed\n");
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Valid initialisation test passed\n");
+
+ ret = rte_telemetry_init(rte_socket_id());
+ if (ret != -EALREADY) {
+ TELEMETRY_LOG_ERR("Error - Invalid initialisation test "
+ "failed\n");
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Invalid initialisation test passed\n");
+
+ ret = rte_telemetry_unregister_client(static_telemetry,
+ invalid_client_path);
+ if (ret != -EPERM) {
+ TELEMETRY_LOG_ERR("Error - Invalid unregister test failed\n");
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Invalid unregister test passed\n");
+
+ sockfd = rte_telemetry_dummy_client_socket(valid_client_path);
+ if (sockfd < 0) {
+ TELEMETRY_LOG_ERR("Error - Test socket creation failed\n");
+ return -1;
+ }
+
+ ret = rte_telemetry_register_client(static_telemetry,
+ valid_client_path);
+ if (ret != 0) {
+ TELEMETRY_LOG_ERR("Error - Valid register test failed: %i\n",
+ ret);
+ return -1;
+ }
+ accept(sockfd, NULL, NULL);
+ TELEMETRY_LOG_INFO("Success - Valid register test passed\n");
+
+ ret = rte_telemetry_register_client(static_telemetry,
+ valid_client_path);
+ if (ret != -EINVAL) {
+ TELEMETRY_LOG_ERR("Error - Invalid register test failed: %i\n",
+ ret);
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Invalid register test passed\n");
+
+ ret = rte_telemetry_unregister_client(static_telemetry,
+ invalid_client_path);
+ if (ret != -1) {
+ TELEMETRY_LOG_ERR("Error - Invalid unregister test failed: "
+ "%i\n", ret);
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Invalid unregister test passed\n");
+
+ ret = rte_telemetry_unregister_client(static_telemetry,
+ valid_client_path);
+ if (ret != 0) {
+ TELEMETRY_LOG_ERR("Error - Valid unregister test failed: %i"
+ "\n", ret);
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Valid unregister test passed\n");
+
+ ret = rte_telemetry_cleanup();
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - cleanup() test failed\n");
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Valid cleanup test passed\n");
+
+ return 0;
+}
+
+int32_t
+rte_telemetry_socket_messaging_testing(int index, int socket)
+{
+ struct telemetry_impl *telemetry = calloc(1, sizeof(telemetry_impl));
+ int fd, bad_send_fd, send_fd, bad_fd, bad_recv_fd, recv_fd, ret;
+
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - could not initialize "
+ "Telemetry API\n");
+ return -1;
+ }
+ telemetry->server_fd = socket;
+ telemetry->reg_index = index;
+ TELEMETRY_LOG_INFO("Beginning Telemetry socket message Selftest\n");
+ rte_telemetry_socket_test_setup(telemetry, &send_fd, &recv_fd);
+ TELEMETRY_LOG_INFO("Register valid client test\n");
+
+ ret = rte_telemetry_socket_register_test(telemetry, &fd, send_fd,
+ recv_fd);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Register valid client test "
+ "failed!\n");
+ free(telemetry);
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Register valid client test passed!\n");
+
+ TELEMETRY_LOG_INFO("Register invalid/same client test\n");
+ ret = rte_telemetry_socket_test_setup(telemetry, &bad_send_fd,
+ &bad_recv_fd);
+ ret = rte_telemetry_socket_register_test(telemetry, &bad_fd,
+ bad_send_fd, bad_recv_fd);
+ if (!ret) {
+ TELEMETRY_LOG_ERR("Error - Register invalid/same client test "
+ "failed!\n");
+ free(telemetry);
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - Register invalid/same client test "
+ "passed!\n");
+
+ ret = rte_telemetry_json_socket_message_test(telemetry, fd);
+ if (ret < 0) {
+ free(telemetry);
+ return -1;
+ }
+
+ return 0;
+}
+
+int32_t
+rte_telemetry_socket_register_test(struct telemetry_impl *telemetry, int *fd,
+ int send_fd, int recv_fd)
+{
+ int ret;
+ char good_req_string[BUF_SIZE];
+
+ snprintf(good_req_string, sizeof(good_req_string),
+ "{\"action\":1,\"command\":\"clients\",\"data\":{\"client_path\""
+ ":\"%s\"}}", SOCKET_TEST_CLIENT_PATH);
+
+ listen(recv_fd, 1);
+ ret = send(send_fd, good_req_string, strlen(good_req_string), 0);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not send message over "
+ "socket\n");
+ return -1;
+ }
+ rte_telemetry_run(telemetry);
+ if (telemetry->register_fail_count != 0)
+ return -1;
+ *fd = accept(recv_fd, NULL, NULL);
+ return 0;
+}
+
+int32_t
+rte_telemetry_socket_test_setup(struct telemetry_impl *telemetry, int *send_fd,
+ int *recv_fd)
+{
+ int ret;
+ const char *client_path = SOCKET_TEST_CLIENT_PATH;
+ *send_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+ *recv_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+
+ listen(telemetry->server_fd, 5);
+ struct sockaddr_un addr = {0};
+ addr.sun_family = AF_UNIX;
+ strlcpy(addr.sun_path, socket_path, sizeof(addr.sun_path));
+ ret = connect(*send_fd, (struct sockaddr *) &addr, sizeof(addr));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - could not connect socket\n");
+ return -1;
+ }
+ telemetry->accept_fd = accept(telemetry->server_fd, NULL, NULL);
+
+ struct sockaddr_un addrs = {0};
+ addrs.sun_family = AF_UNIX;
+ strlcpy(addrs.sun_path, client_path, sizeof(addrs.sun_path));
+ unlink(client_path);
+
+ ret = bind(*recv_fd, (struct sockaddr *)&addrs, sizeof(addrs));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - could not bind socket\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int32_t
+rte_telemetry_stat_parse(char *buf, struct json_data *json_data_struct)
+{
+ json_error_t error;
+ json_t *root = json_loads(buf, 0, &error);
+ int arraylen, i;
+ json_t *status, *dataArray, *port, *stats, *name, *value,
+ *dataArrayObj, *statsArrayObj;
+
+ stats = NULL;
+ port = NULL;
+ name = NULL;
+
+ if (buf == NULL) {
+ TELEMETRY_LOG_ERR("Error - JSON message is NULL\n");
+ return -EINVAL;
+ }
+
+ if (!root) {
+ TELEMETRY_LOG_ERR("Error - Could not load JSON object from "
+ "data passed in : %s\n", error.text);
+ return -EPERM;
+ } else if (!json_is_object(root)) {
+ TELEMETRY_LOG_ERR("Error - JSON Request is not a JSON "
+ "object\n");
+ json_decref(root);
+ return -EINVAL;
+ }
+
+ status = json_object_get(root, "status_code");
+ if (!status) {
+ TELEMETRY_LOG_ERR("Error - Request does not have status "
+ "field\n");
+ return -EINVAL;
+ } else if (!json_is_string(status)) {
+ TELEMETRY_LOG_ERR("Error - Status value is not a String\n");
+ return -EINVAL;
+ }
+
+ json_data_struct->status_code = strdup(json_string_value(status));
+
+ dataArray = json_object_get(root, "data");
+ if (!dataArray) {
+ TELEMETRY_LOG_ERR("Error - Request does not have data field\n");
+ return -EINVAL;
+ }
+ arraylen = json_array_size(dataArray);
+ if (arraylen == 0) {
+ json_data_struct->data = "null";
+ return -EINVAL;
+ }
+
+ for (i = 0; i < arraylen; i++) {
+ dataArrayObj = json_array_get(dataArray, i);
+ port = json_object_get(dataArrayObj, "port");
+ stats = json_object_get(dataArrayObj, "stats");
+ }
+
+ if (!port) {
+ TELEMETRY_LOG_ERR("Error - Request does not have port field\n");
+ return -EINVAL;
+ }
+ if (!json_is_integer(port)) {
+ TELEMETRY_LOG_ERR("Error - Port value is not an integer\n");
+ return -EINVAL;
+ }
+
+ json_data_struct->port = json_integer_value(port);
+
+ if (!stats) {
+ TELEMETRY_LOG_ERR("Error - Request does not have stats "
+ "field\n");
+ return -EINVAL;
+ }
+
+ arraylen = json_array_size(stats);
+ for (i = 0; i < arraylen; i++) {
+ statsArrayObj = json_array_get(stats, i);
+ name = json_object_get(statsArrayObj, "name");
+ value = json_object_get(statsArrayObj, "value");
+ }
+ if (!name) {
+ TELEMETRY_LOG_ERR("Error - Request does not have name field\n");
+ return -EINVAL;
+ }
+ if (!json_is_string(name)) {
+ TELEMETRY_LOG_ERR("Error - Stat name value is not a string\n");
+ return -EINVAL;
+ }
+ json_data_struct->stat_name = strdup(json_string_value(name));
+
+ if (!value) {
+ TELEMETRY_LOG_ERR("Error - Request does not have value "
+ "field\n");
+ return -EINVAL;
+ }
+ if (!json_is_integer(value)) {
+ TELEMETRY_LOG_ERR("Error - Stat value is not an integer\n");
+ return -EINVAL;
+ }
+ json_data_struct->stat_value = json_integer_value(value);
+ return 0;
+}
+
+static void
+rte_telemetry_free_test_data(struct json_data *data)
+{
+ free(data->status_code);
+ free(data->stat_name);
+ free(data);
+}
+
+int32_t
+rte_telemetry_valid_json_test(struct telemetry_impl *telemetry, int fd)
+{
+ int ret;
+ char buf[BUF_SIZE];
+ struct json_data *data_struct;
+ const char *status = "Status OK: 200";
+ int port = 0;
+ const char *name = "rx_good_packets";
+ int value = 0;
+ int fail_count = 0;
+ const char *valid_json_message = "{\"action\":0,\"command\":"
+ "\"ports_stats_values_by_name\",\"data\":{\"ports\""
+ ":[0],\"stats\":[\"rx_good_packets\"]}}";
+
+ ret = send(fd, valid_json_message, strlen(valid_json_message), 0);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not send message over "
+ "socket\n");
+ return -1;
+ }
+ rte_telemetry_run(telemetry);
+ int buffer_read = 0;
+ errno = 0;
+ buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
+
+ if (buffer_read == -1) {
+ TELEMETRY_LOG_ERR("Error - Read error\n");
+ return -1;
+ }
+ buf[buffer_read] = '\0';
+ data_struct = calloc(1, sizeof(struct json_data));
+ ret = rte_telemetry_stat_parse(buf, data_struct);
+
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not parse stats\n");
+ fail_count++;
+ }
+
+ if (strcmp(data_struct->status_code, status) != 0) {
+ TELEMETRY_LOG_ERR(" Error - Status code is invalid\n");
+ fail_count++;
+ }
+ if (data_struct->port != port) {
+ TELEMETRY_LOG_ERR("Error - Port is invalid\n");
+ fail_count++;
+ }
+ if (strcmp(data_struct->stat_name, name) != 0) {
+ TELEMETRY_LOG_ERR("Error - Stat name is invalid\n");
+ fail_count++;
+ }
+ if (data_struct->stat_value != value) {
+ TELEMETRY_LOG_ERR("Error - Stat value is invalid\n");
+ fail_count++;
+ }
+ rte_telemetry_free_test_data(data_struct);
+ if (fail_count > 0)
+ return -1;
+
+ TELEMETRY_LOG_INFO("Success - Passed valid JSON message test "
+ "passed\n");
+ return 0;
+}
+
+int32_t
+rte_telemetry_invalid_json_test(struct telemetry_impl *telemetry, int fd)
+{
+ int ret;
+ char buf[BUF_SIZE];
+ int fail_count = 0;
+ const char *invalid_json = "{]";
+ const char *status = "Status Error: Unknown";
+ const char *data = "null";
+ struct json_data *data_struct;
+ int buffer_read = 0;
+ errno = 0;
+
+ ret = send(fd, invalid_json, strlen(invalid_json), 0);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not send message over "
+ "socket\n");
+ return -1;
+ }
+
+ rte_telemetry_run(telemetry);
+ buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
+
+ if (buffer_read == -1) {
+ TELEMETRY_LOG_ERR("Error - Read error\n");
+ return -1;
+ }
+ buf[buffer_read] = '\0';
+
+ data_struct = calloc(1, sizeof(struct json_data));
+ ret = rte_telemetry_stat_parse(buf, data_struct);
+
+ if (ret < 0)
+ TELEMETRY_LOG_ERR("Error - Could not parse stats\n");
+
+ if (strcmp(data_struct->status_code, status) != 0) {
+ TELEMETRY_LOG_ERR("Error - Status code is invalid\n");
+ fail_count++;
+ }
+ if (strcmp(data_struct->data, data) != 0) {
+ TELEMETRY_LOG_ERR("Error - Data status is invalid\n");
+ fail_count++;
+ }
+ rte_telemetry_free_test_data(data_struct);
+ if (fail_count > 0)
+ return -1;
+
+ TELEMETRY_LOG_INFO("Success - Passed invalid JSON message test\n");
+ return 0;
+}
+
+int32_t
+rte_telemetry_json_contents_test(struct telemetry_impl *telemetry, int fd)
+{
+ int ret;
+ char buf[BUF_SIZE];
+ int fail_count = 0;
+ char *status = "Status Error: Invalid Argument 404";
+ char *data = "null";
+ struct json_data *data_struct;
+ const char *invalid_contents = "{\"action\":0,\"command\":"
+ "\"ports_stats_values_by_name\",\"data\":{\"ports\""
+ ":[0],\"stats\":[\"some_invalid_param\","
+ "\"another_invalid_param\"]}}";
+ int buffer_read = 0;
+ errno = 0;
+
+ ret = send(fd, invalid_contents, strlen(invalid_contents), 0);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not send message over "
+ "socket\n");
+ return -1;
+ }
+ rte_telemetry_run(telemetry);
+ buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
+ if (buffer_read == -1) {
+ TELEMETRY_LOG_ERR("Error - Read error\n");
+ return -1;
+ }
+ buf[buffer_read] = '\0';
+ data_struct = calloc(1, sizeof(struct json_data));
+ ret = rte_telemetry_stat_parse(buf, data_struct);
+
+ if (ret < 0)
+ TELEMETRY_LOG_ERR("Error - Could not parse stats\n");
+
+ if (strcmp(data_struct->status_code, status) != 0) {
+ TELEMETRY_LOG_ERR("Error - Status code is invalid\n");
+ fail_count++;
+ }
+ if (strcmp(data_struct->data, data) != 0) {
+ TELEMETRY_LOG_ERR("Error - Data status is invalid\n");
+ fail_count++;
+ }
+ rte_telemetry_free_test_data(data_struct);
+ if (fail_count > 0)
+ return -1;
+
+ TELEMETRY_LOG_INFO("Success - Passed invalid JSON content test\n");
+ return 0;
+}
+
+int32_t
+rte_telemetry_json_empty_test(struct telemetry_impl *telemetry, int fd)
+{
+ int ret;
+ char buf[BUF_SIZE];
+ int fail_count = 0;
+ const char *status = "Status Error: Invalid Argument 404";
+ char *data = "null";
+ struct json_data *data_struct;
+ const char *empty_json = "{}";
+ int buffer_read = 0;
+ errno = 0;
+
+ ret = (send(fd, empty_json, strlen(empty_json), 0));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not send message over "
+ "socket\n");
+ return -1;
+ }
+ rte_telemetry_run(telemetry);
+ buffer_read = recv(fd, buf, BUF_SIZE-1, 0);
+ if (buffer_read == -1) {
+ TELEMETRY_LOG_ERR("Error - Read error\n");
+ return -1;
+ }
+ buf[buffer_read] = '\0';
+ data_struct = calloc(1, sizeof(struct json_data));
+ ret = rte_telemetry_stat_parse(buf, data_struct);
+
+ if (ret < 0)
+ TELEMETRY_LOG_ERR("Error - Could not parse stats\n");
+
+ if (strcmp(data_struct->status_code, status) != 0) {
+ TELEMETRY_LOG_ERR("Error - Status code is invalid\n");
+ fail_count++;
+ }
+ if (strcmp(data_struct->data, data) != 0) {
+ TELEMETRY_LOG_ERR("Error - Data status is invalid\n");
+ fail_count++;
+ }
+ rte_telemetry_free_test_data(data_struct);
+ if (fail_count > 0)
+ return -1;
+
+ TELEMETRY_LOG_INFO("Success - Passed JSON empty message test\n");
+ return 0;
+}
+
+int32_t
+rte_telemetry_json_socket_message_test(struct telemetry_impl *telemetry, int fd)
+{
+ uint16_t i;
+ int ret, fail_count;
+
+ fail_count = 0;
+ struct telemetry_message_test socket_json_tests[] = {
+ {.test_name = "Invalid JSON test",
+ .test_func_ptr = rte_telemetry_invalid_json_test},
+ {.test_name = "Valid JSON test",
+ .test_func_ptr = rte_telemetry_valid_json_test},
+ {.test_name = "JSON contents test",
+ .test_func_ptr = rte_telemetry_json_contents_test},
+ {.test_name = "JSON empty tests",
+ .test_func_ptr = rte_telemetry_json_empty_test}
+ };
+
+#define NUM_TESTS (sizeof(socket_json_tests)/sizeof(socket_json_tests[0]))
+
+ for (i = 0; i < NUM_TESTS; i++) {
+ TELEMETRY_LOG_INFO("%s\n",
+ socket_json_tests[i].test_name);
+ ret = (socket_json_tests[i].test_func_ptr)
+ (telemetry, fd);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - %s failed\n",
+ socket_json_tests[i].test_name);
+ fail_count++;
+ }
+ }
+ if (fail_count > 0) {
+ TELEMETRY_LOG_ERR("Error - Failed %i JSON socket message "
+ "test(s)", fail_count);
+ return -1;
+ }
+ TELEMETRY_LOG_INFO("Success - All JSON tests passed\n");
+ return 0;
+}
+
int telemetry_log_level;
RTE_INIT(rte_telemetry_log_init);
@@ -37,4 +37,16 @@ rte_telemetry_init(uint32_t socket_id);
int32_t
rte_telemetry_cleanup(void);
+/**
+ * Runs various tests to ensure telemetry initialisation and register/unregister
+ * functions are working correctly.
+ *
+ * @return
+ * 0 on success when all tests have passed
+ * @return
+ * -1 on failure when the test has failed
+ */
+int32_t
+rte_telemetry_selftest(void);
+
#endif
@@ -65,4 +65,7 @@ int32_t
rte_telemetry_send_ports_stats_values(uint32_t *metric_ids, int num_metric_ids,
uint32_t *port_ids, int num_port_ids, struct telemetry_impl *telemetry);
+int32_t
+rte_telemetry_socket_messaging_testing(int index, int socket);
+
#endif
new file mode 100644
@@ -0,0 +1,574 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2018 Intel Corporation
+ */
+
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+#include <jansson.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <rte_common.h>
+#include <rte_tailq.h>
+#include <rte_string_fns.h>
+
+#include "rte_telemetry_parser.h"
+
+#define ACTION_GET 0
+#define ACTION_DELETE 2
+
+#define INV_ACTION_VAL 0
+#define INV_COMMAND_VAL 1
+#define INV_DATA_VAL 2
+#define INV_ACTION_FIELD 3
+#define INV_COMMAND_FIELD 4
+#define INV_DATA_FIELD 5
+#define INV_JSON_FORMAT 6
+#define VALID_REQ 7
+
+
+#define TEST_CLIENT "/var/run/test_client"
+
+int32_t
+rte_telemetry_create_test_socket(struct telemetry_impl *telemetry,
+ const char *test_client_path)
+{
+
+ int ret, sockfd;
+
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - Telemetry argument has not been "
+ "initialised\n");
+ return -EINVAL;
+ }
+
+ sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sockfd < 0) {
+ TELEMETRY_LOG_ERR("Error - Test socket creation failure\n");
+ return -1;
+ }
+
+ struct sockaddr_un addr = {0};
+ addr.sun_family = AF_UNIX;
+ strlcpy(addr.sun_path, test_client_path, sizeof(addr.sun_path));
+ unlink(test_client_path);
+
+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ TELEMETRY_LOG_ERR("Error - Test socket binding failure\n");
+ return -1;
+ }
+
+ if (listen(sockfd, 1) < 0) {
+ TELEMETRY_LOG_ERR("Error - Listen failure\n");
+ return -1;
+ }
+
+ ret = rte_telemetry_register_client(telemetry, test_client_path);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Register dummy client failed: %i",
+ ret);
+ return -1;
+ }
+
+ ret = accept(sockfd, NULL, NULL);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Socket accept failed\n");
+ return -1;
+ }
+
+ struct telemetry_client *client;
+ TAILQ_FOREACH(client, &telemetry->client_list_head, client_list)
+ telemetry->request_client = client;
+
+ return 0;
+}
+
+int32_t
+rte_telemetry_format_port_stat_ids(int *port_ids, int num_port_ids,
+ const char * const *stat_names, int num_stat_names, json_t **data)
+{
+
+ int ret;
+ json_t *stat_names_json_array = NULL;
+ json_t *port_ids_json_array = NULL;
+ if (num_port_ids < 0) {
+ TELEMETRY_LOG_ERR("Error - Port Ids Count invalid\n");
+ goto fail;
+ }
+
+ *data = json_object();
+ if (!*data) {
+ TELEMETRY_LOG_ERR("Error - Data json object creation failed\n");
+ goto fail;
+ }
+
+ port_ids_json_array = json_array();
+ if (!port_ids_json_array) {
+ TELEMETRY_LOG_ERR("Error - port_ids_json_array creation "
+ "failed\n");
+ goto fail;
+ }
+
+ uint32_t i;
+ for (i = 0; i < (uint32_t) num_port_ids; i++) {
+ ret = json_array_append(port_ids_json_array,
+ json_integer(port_ids[i]));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - JSON array creation "
+ "failed\n");
+ goto fail;
+ }
+ }
+
+ ret = json_object_set_new(*data, "ports", port_ids_json_array);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting 'ports' value in data object"
+ " failed\n");
+ goto fail;
+ }
+
+ if (stat_names) {
+
+ if (num_stat_names < 0) {
+ TELEMETRY_LOG_ERR("Error - Stat Names Count invalid\n");
+ goto fail;
+ }
+
+ stat_names_json_array = json_array();
+ if (!stat_names_json_array) {
+ TELEMETRY_LOG_ERR("Error - stat_names_json_array "
+ "creation failed\n");
+ goto fail;
+ }
+
+ uint32_t i;
+ for (i = 0; i < (uint32_t) num_stat_names; i++) {
+ ret = json_array_append(stat_names_json_array,
+ json_string(stat_names[i]));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - JSON array creation "
+ " failed\n");
+ goto fail;
+ }
+ }
+
+ ret = json_object_set_new(*data, "stats",
+ stat_names_json_array);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting 'stats' value in "
+ "data object failed\n");
+ goto fail;
+ }
+
+ }
+ return 0;
+
+fail:
+ if (*data)
+ json_decref(*data);
+ if (stat_names_json_array)
+ json_decref(stat_names_json_array);
+ if (port_ids_json_array)
+ json_decref(port_ids_json_array);
+ return -1;
+}
+
+int32_t
+rte_telemetry_create_json_request(int action, char *command,
+ const char *client_path, int *port_ids, int num_port_ids,
+ const char * const *stat_names, int num_stat_names, char **request,
+ int inv_choice)
+{
+ int ret;
+ json_t *root = json_object();
+
+ if (!root) {
+ TELEMETRY_LOG_ERR("Error - Could not create root json "
+ "object\n");
+ goto fail;
+ }
+
+ if (inv_choice == INV_ACTION_FIELD) {
+ ret = json_object_set_new(root, "ac--on", json_integer(action));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting invalid action "
+ "field in root object failed\n");
+ goto fail;
+ }
+ } else {
+ ret = json_object_set_new(root, "action", json_integer(action));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting valid action field "
+ "in root object failed\n");
+ goto fail;
+ }
+ }
+
+ if (inv_choice == INV_COMMAND_FIELD) {
+ ret = json_object_set_new(root, "co---nd",
+ json_string(command));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting invalid command "
+ "field in root object failed\n");
+ goto fail;
+ }
+ } else {
+ ret = json_object_set_new(root, "command",
+ json_string(command));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting valid command "
+ "field in root object failed\n");
+ goto fail;
+ }
+ }
+
+ json_t *data = json_null();
+ if (client_path) {
+ data = json_object();
+ if (!data) {
+ TELEMETRY_LOG_ERR("Error - Data json object creation "
+ "failed\n");
+ goto fail;
+ }
+
+ ret = json_object_set_new(data, "client_path",
+ json_string(client_path));
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting valid client_path "
+ "field in data object failed\n");
+ goto fail;
+ }
+
+ } else if (port_ids) {
+ ret = rte_telemetry_format_port_stat_ids(port_ids, num_port_ids,
+ stat_names, num_stat_names, &data);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Formatting Port/Stat "
+ "arrays failed\n");
+ goto fail;
+ }
+
+ }
+
+ if (inv_choice == INV_DATA_FIELD) {
+ ret = json_object_set_new(root, "d--a", data);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting invalid data "
+ "field in data object failed\n");
+ goto fail;
+ }
+ } else {
+ ret = json_object_set_new(root, "data", data);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Setting valid data field "
+ "in data object failed\n");
+ goto fail;
+ }
+ }
+
+ *request = json_dumps(root, 0);
+ if (!*request) {
+ TELEMETRY_LOG_ERR("Error - Converting JSON root object to "
+ "char* failed\n");
+ goto fail;
+ }
+
+ json_decref(root);
+ return 0;
+
+fail:
+ if (root)
+ json_decref(root);
+ return -1;
+}
+
+int32_t
+rte_telemetry_send_get_ports_and_stats_request(struct telemetry_impl *telemetry,
+ int action_choice, char *command_choice, int inv_choice)
+{
+ int ret;
+ char *request;
+
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - Telemetry argument has not been "
+ "initialised\n");
+ return -EINVAL;
+ }
+
+ char *client_path_data = NULL;
+
+ if (inv_choice == INV_ACTION_VAL)
+ action_choice = -1;
+ else if (inv_choice == INV_COMMAND_VAL)
+ command_choice = "INVALID_COMMAND";
+ else if (inv_choice == INV_DATA_VAL)
+ client_path_data = "INVALID_DATA";
+
+ ret = rte_telemetry_create_json_request(action_choice, command_choice,
+ client_path_data, NULL, -1, NULL, -1, &request, inv_choice);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not create JSON Request\n");
+ return -1;
+ }
+
+ if (inv_choice == INV_JSON_FORMAT)
+ request++;
+
+ ret = rte_telemetry_parse(telemetry, request);
+ if (ret < 0) {
+ TELEMETRY_LOG_WARN("Warning - Could not parse JSON Request\n");
+ return -1;
+ }
+ return 0;
+}
+
+int32_t
+rte_telemetry_send_get_ports_details_request(struct telemetry_impl *telemetry,
+ int action_choice, int *port_ids, int num_port_ids, int inv_choice)
+{
+ int ret;
+ char *request;
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - Telemetry argument has not been "
+ "initialised\n");
+ return -EINVAL;
+ }
+
+ char *command = "ports_details";
+
+ if (inv_choice == INV_ACTION_VAL)
+ action_choice = -1;
+ else if (inv_choice == INV_COMMAND_VAL)
+ command = "INVALID_COMMAND";
+ else if (inv_choice == INV_DATA_VAL)
+ port_ids = NULL;
+
+
+ ret = rte_telemetry_create_json_request(action_choice, command, NULL,
+ port_ids, num_port_ids, NULL, -1, &request, inv_choice);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not create JSON Request\n");
+ return -1;
+ }
+
+ if (inv_choice == INV_JSON_FORMAT)
+ request++;
+
+ ret = rte_telemetry_parse(telemetry, request);
+ if (ret < 0) {
+ TELEMETRY_LOG_WARN("Warning - Could not parse JSON Request\n");
+ return -1;
+ }
+ return 0;
+}
+
+int32_t
+rte_telemetry_send_stats_values_by_name_request(struct telemetry_impl
+ *telemetry, int action_choice, int *port_ids, int num_port_ids,
+ const char * const *stat_names, int num_stat_names,
+ int inv_choice)
+{
+ int ret;
+ char *request;
+
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - Telemetry argument has not been "
+ "initialised\n");
+ return -EINVAL;
+ }
+
+ char *command = "ports_stats_values_by_name";
+
+ if (inv_choice == INV_ACTION_VAL)
+ action_choice = -1;
+ else if (inv_choice == INV_COMMAND_VAL)
+ command = "INVALID_COMMAND";
+ else if (inv_choice == INV_DATA_VAL) {
+ port_ids = NULL;
+ stat_names = NULL;
+ }
+
+
+ ret = rte_telemetry_create_json_request(action_choice, command, NULL,
+ port_ids, num_port_ids, stat_names, num_stat_names,
+ &request, inv_choice);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not create JSON Request\n");
+ return -1;
+ }
+
+ if (inv_choice == INV_JSON_FORMAT)
+ request++;
+
+ ret = rte_telemetry_parse(telemetry, request);
+ if (ret < 0) {
+ TELEMETRY_LOG_WARN("Warning - Could not parse JSON Request\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int32_t
+rte_telemetry_send_unreg_request(struct telemetry_impl *telemetry,
+ int action_choice, const char *client_path, int inv_choice)
+{
+ int ret;
+ char *request;
+
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - Telemetry argument has not been "
+ "initialised\n");
+ return -EINVAL;
+ }
+
+ char *command = "clients";
+
+ if (inv_choice == INV_ACTION_VAL)
+ action_choice = -1;
+ else if (inv_choice == INV_COMMAND_VAL)
+ command = "INVALID_COMMAND";
+ else if (inv_choice == INV_DATA_VAL)
+ client_path = NULL;
+
+ ret = rte_telemetry_create_json_request(action_choice, command,
+ client_path, NULL, -1, NULL, -1, &request, inv_choice);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not create JSON Request\n");
+ return -1;
+ }
+
+ if (inv_choice == INV_JSON_FORMAT)
+ request++;
+
+ ret = rte_telemetry_parse(telemetry, request);
+ if (ret < 0) {
+ TELEMETRY_LOG_WARN("Warning - Could not parse JSON Request\n");
+ return -1;
+ }
+ return 0;
+}
+
+int32_t
+rte_telemetry_parser_test(struct telemetry_impl *telemetry)
+{
+ int ret;
+
+ if (!telemetry) {
+ TELEMETRY_LOG_ERR("Error - Telemetry argument has not been "
+ "initialised\n");
+ return -EINVAL;
+ }
+
+ const char *client_path = TEST_CLIENT;
+ ret = rte_telemetry_create_test_socket(telemetry, client_path);
+ if (ret < 0) {
+ TELEMETRY_LOG_ERR("Error - Could not create test request "
+ "client socket\n");
+ return -1;
+ }
+
+ int port_ids[] = {0, 1};
+ int num_port_ids = RTE_DIM(port_ids);
+
+ static const char * const stat_names[] = {"tx_good_packets",
+ "rx_good_packets"};
+ int num_stat_names = RTE_DIM(stat_names);
+
+ static const char * const test_types[] = {
+ "INVALID ACTION VALUE TESTS",
+ "INVALID COMMAND VALUE TESTS",
+ "INVALID DATA VALUE TESTS",
+ "INVALID ACTION FIELD TESTS",
+ "INVALID COMMAND FIELD TESTS",
+ "INVALID DATA FIELD TESTS",
+ "INVALID JSON FORMAT TESTS",
+ "VALID TESTS"
+ };
+
+
+#define NUM_TEST_TYPES (sizeof(test_types)/sizeof(const char * const))
+
+ uint32_t i;
+ for (i = 0; i < NUM_TEST_TYPES; i++) {
+ TELEMETRY_LOG_INFO("%s\n",
+ test_types[i]);
+
+ ret = rte_telemetry_send_get_ports_and_stats_request(telemetry,
+ ACTION_GET, "ports", i);
+ if (ret != 0 && i == VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports valid test "
+ "failed\n");
+ return -EPERM;
+ } else if (ret != -1 && i != VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports invalid test"
+ " failed\n");
+ return -EPERM;
+ }
+
+ TELEMETRY_LOG_INFO("Success - Get ports test passed\n");
+
+ ret = rte_telemetry_send_get_ports_details_request(telemetry,
+ ACTION_GET, port_ids, num_port_ids, i);
+ if (ret != 0 && i == VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports details valid\n");
+ return -EPERM;
+ } else if (ret != -1 && i != VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports details "
+ "invalid\n");
+ return -EPERM;
+ }
+
+ TELEMETRY_LOG_INFO("Success - Get ports details test passed\n");
+
+ ret = rte_telemetry_send_get_ports_and_stats_request(telemetry,
+ ACTION_GET, "port_stats", i);
+ if (ret != 0 && i == VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get port stats valid "
+ "test\n");
+ return -EPERM;
+ } else if (ret != -1 && i != VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports stats invalid"
+ " test failed\n");
+ return -EPERM;
+ }
+
+ TELEMETRY_LOG_INFO("Success - Get ports stats test passed\n");
+
+ ret = rte_telemetry_send_stats_values_by_name_request(telemetry,
+ ACTION_GET, port_ids, num_port_ids,
+ stat_names, num_stat_names, i);
+ if (ret != 0 && i == VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports stats values by"
+ " name valid test failed\n");
+ return -EPERM;
+ } else if (ret != -1 && i != VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Get ports stats values by"
+ " name invalid test failed\n");
+ return -EPERM;
+ }
+
+ TELEMETRY_LOG_INFO("Success - Get ports stats values by name"
+ " test passed\n");
+
+ ret = rte_telemetry_send_unreg_request(telemetry, ACTION_DELETE,
+ client_path, i);
+ if (ret != 0 && i == VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Deregister valid test "
+ "failed\n");
+ return -EPERM;
+ } else if (ret != -1 && i != VALID_REQ) {
+ TELEMETRY_LOG_ERR("Error - Deregister invalid test"
+ " failed\n");
+ return -EPERM;
+ }
+
+ TELEMETRY_LOG_INFO("Success - Deregister test passed\n");
+ }
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2018 Intel Corporation
+ */
+
+#ifndef _RTE_TELEMETRY_PARSER_TEST_H_
+#define _RTE_TELEMETRY_PARSER_TEST_H_
+
+int32_t
+rte_telemetry_parser_test(struct telemetry_impl *telemetry);
+
+int32_t
+rte_telemetry_format_port_stat_ids(int *port_ids, int num_port_ids,
+ const char * const stat_names, int num_stat_names, json_t **data);
+
+int32_t
+rte_telemetry_create_json_request(int action, char *command,
+ const char *client_path, int *port_ids, int num_port_ids,
+ const char * const stat_names, int num_stat_names, char **request,
+ int inv_choice);
+
+int32_t
+rte_telemetry_send_get_ports_and_stats_request(struct telemetry_impl *telemetry,
+ int action_choice, char *command_choice, int inv_choice);
+
+int32_t
+rte_telemetry_send_get_ports_details_request(struct telemetry_impl *telemetry,
+ int action_choice, int *port_ids, int num_port_ids, int inv_choice);
+
+int32_t
+rte_telemetry_send_stats_values_by_name_request(struct telemetry_impl
+ *telemetry, int action_choice, int *port_ids, int num_port_ids,
+ const char * const stat_names, int num_stat_names,
+ int inv_choice);
+
+int32_t
+rte_telemetry_send_unreg_request(int action_choice, const char *client_path,
+ int inv_choice);
+
+#endif
new file mode 100644
@@ -0,0 +1,36 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2018 Intel Corporation
+ */
+
+#include <stdbool.h>
+
+#include "rte_telemetry_internal.h"
+
+#ifndef _RTE_TELEMETRY_SOCKET_TESTING_H_
+#define _RTE_TELEMETRY_SOCKET_TESTING_H_
+
+int32_t
+rte_telemetry_json_socket_message_test(struct telemetry_impl *telemetry,
+ int fd);
+
+int32_t
+rte_telemetry_invalid_json_test(struct telemetry_impl *telemetry, int fd);
+
+int32_t
+rte_telemetry_valid_json_test(struct telemetry_impl *telemetry, int fd);
+
+int32_t
+rte_telemetry_json_contents_test(struct telemetry_impl *telemetry, int fd);
+
+int32_t
+rte_telemetry_json_empty_test(struct telemetry_impl *telemetry, int fd);
+
+int32_t
+rte_telemetry_socket_register_test(struct telemetry_impl *telemetry, int *fd,
+ int send_fd, int recv_fd);
+
+int32_t
+rte_telemetry_socket_test_setup(struct telemetry_impl *telemetry, int *send_fd,
+ int *recv_fd);
+
+#endif
@@ -2,5 +2,6 @@ DPDK_18.05 {
global:
rte_telemetry_init;
+ rte_telemetry_selftest;
local: *;
};