app/test/test_telemetry_data.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2020 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <sys/socket.h>
   7 #ifndef RTE_EXEC_ENV_WINDOWS
   8 #include <sys/un.h>
   9 #endif
  10 #include <unistd.h>
  11 #include <limits.h>
  12
  13 #include <rte_eal.h>
  14 #include <rte_common.h>
  15 #include <rte_telemetry.h>
  16 #include <rte_string_fns.h>
  17
  18 #include "test.h"
  19 #include "telemetry_data.h"
  20
  21 #define TELEMETRY_VERSION "v2"
  22 #define REQUEST_CMD "/test"
  23 #define BUF_SIZE 1024
  24 #define TEST_OUTPUT(exp) test_output(__func__, exp)
  25
  26 static struct rte_tel_data response_data;
  27 static int sock;
  28
  29 /*
  30  * This function is the callback registered with Telemetry to be used when
  31  * the /test command is requested. This callback returns the global data built
  32  * up by the individual test cases.
  33  */
  34 static int
  35 test_cb(const char *cmd __rte_unused, const char *params __rte_unused,
  36                 struct rte_tel_data *d)
  37 {
  38         *d = response_data;
  39         return 0;
  40 }
  41
  42 /*
  43  * This function is called by each test case function. It communicates with
  44  * the telemetry socket by requesting the /test command, and reading the
  45  * response. The expected response is passed in by the test case function,
  46  * and is compared to the actual response received from Telemetry.
  47  */
  48 static int
  49 test_output(const char *func_name, const char *expected)
  50 {
  51         int bytes;
  52         char buf[BUF_SIZE * 16];
  53         if (write(sock, REQUEST_CMD, strlen(REQUEST_CMD)) < 0) {
  54                 printf("%s: Error with socket write - %s\n", __func__,
  55                                 strerror(errno));
  56                 return -1;
  57         }
  58         bytes = read(sock, buf, sizeof(buf) - 1);
  59         if (bytes < 0) {
  60                 printf("%s: Error with socket read - %s\n", __func__,
  61                                 strerror(errno));
  62                 return -1;
  63         }
  64         buf[bytes] = '\0';
  65         printf("%s: buf = '%s', expected = '%s'\n", func_name, buf, expected);
  66         return strncmp(expected, buf, sizeof(buf));
  67 }
  68
  69 static int
  70 test_dict_with_array_int_values(void)
  71 {
  72         int i;
  73
  74         struct rte_tel_data *child_data = rte_tel_data_alloc();
  75         rte_tel_data_start_array(child_data, RTE_TEL_INT_VAL);
  76
  77         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
  78         rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL);
  79
  80         memset(&response_data, 0, sizeof(response_data));
  81         rte_tel_data_start_dict(&response_data);
  82
  83         for (i = 0; i < 5; i++) {
  84                 rte_tel_data_add_array_int(child_data, i);
  85                 rte_tel_data_add_array_int(child_data2, i);
  86         }
  87
  88         rte_tel_data_add_dict_container(&response_data, "dict_0",
  89          child_data, 0);
  90         rte_tel_data_add_dict_container(&response_data, "dict_1",
  91          child_data2, 0);
  92
  93         return TEST_OUTPUT("{\"/test\":{\"dict_0\":[0,1,2,3,4],"
  94                         "\"dict_1\":[0,1,2,3,4]}}");
  95 }
  96
  97 static int
  98 test_array_with_array_int_values(void)
  99 {
 100         int i;
 101
 102         struct rte_tel_data *child_data = rte_tel_data_alloc();
 103         rte_tel_data_start_array(child_data, RTE_TEL_INT_VAL);
 104
 105         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
 106         rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL);
 107
 108         memset(&response_data, 0, sizeof(response_data));
 109         rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
 110
 111         for (i = 0; i < 5; i++) {
 112                 rte_tel_data_add_array_int(child_data, i);
 113                 rte_tel_data_add_array_int(child_data2, i);
 114         }
 115         rte_tel_data_add_array_container(&response_data, child_data, 0);
 116         rte_tel_data_add_array_container(&response_data, child_data2, 0);
 117
 118         return TEST_OUTPUT("{\"/test\":[[0,1,2,3,4],[0,1,2,3,4]]}");
 119 }
 120
 121 static int
 122 test_case_array_int(void)
 123 {
 124         int i;
 125         memset(&response_data, 0, sizeof(response_data));
 126         rte_tel_data_start_array(&response_data, RTE_TEL_INT_VAL);
 127         for (i = 0; i < 5; i++)
 128                 rte_tel_data_add_array_int(&response_data, i);
 129         return TEST_OUTPUT("{\"/test\":[0,1,2,3,4]}");
 130 }
 131
 132 static int
 133 test_case_add_dict_int(void)
 134 {
 135         int i = 0;
 136         char name_of_value[8];
 137
 138         memset(&response_data, 0, sizeof(response_data));
 139         rte_tel_data_start_dict(&response_data);
 140
 141         for (i = 0; i < 5; i++) {
 142                 sprintf(name_of_value, "dict_%d", i);
 143                 rte_tel_data_add_dict_int(&response_data, name_of_value, i);
 144         }
 145
 146         return TEST_OUTPUT("{\"/test\":{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2,"
 147                         "\"dict_3\":3,\"dict_4\":4}}");
 148 }
 149
 150 static int
 151 test_case_array_string(void)
 152 {
 153         memset(&response_data, 0, sizeof(response_data));
 154         rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL);
 155         rte_tel_data_add_array_string(&response_data, "aaaa");
 156         rte_tel_data_add_array_string(&response_data, "bbbb");
 157         rte_tel_data_add_array_string(&response_data, "cccc");
 158         rte_tel_data_add_array_string(&response_data, "dddd");
 159         rte_tel_data_add_array_string(&response_data, "eeee");
 160
 161         return TEST_OUTPUT("{\"/test\":[\"aaaa\",\"bbbb\",\"cccc\",\"dddd\","
 162                         "\"eeee\"]}");
 163 }
 164
 165 static int
 166 test_case_add_dict_string(void)
 167 {
 168         memset(&response_data, 0, sizeof(response_data));
 169         rte_tel_data_start_dict(&response_data);
 170
 171         rte_tel_data_add_dict_string(&response_data, "dict_0", "aaaa");
 172         rte_tel_data_add_dict_string(&response_data, "dict_1", "bbbb");
 173         rte_tel_data_add_dict_string(&response_data, "dict_2", "cccc");
 174         rte_tel_data_add_dict_string(&response_data, "dict_3", "dddd");
 175
 176         return TEST_OUTPUT("{\"/test\":{\"dict_0\":\"aaaa\",\"dict_1\":"
 177                         "\"bbbb\",\"dict_2\":\"cccc\",\"dict_3\":\"dddd\"}}");
 178 }
 179
 180
 181 static int
 182 test_dict_with_array_string_values(void)
 183 {
 184         struct rte_tel_data *child_data = rte_tel_data_alloc();
 185         rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL);
 186
 187         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
 188         rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL);
 189
 190         memset(&response_data, 0, sizeof(response_data));
 191         rte_tel_data_start_dict(&response_data);
 192
 193         rte_tel_data_add_array_string(child_data, "aaaa");
 194         rte_tel_data_add_array_string(child_data2, "bbbb");
 195
 196         rte_tel_data_add_dict_container(&response_data, "dict_0",
 197          child_data, 0);
 198         rte_tel_data_add_dict_container(&response_data, "dict_1",
 199          child_data2, 0);
 200
 201         return TEST_OUTPUT("{\"/test\":{\"dict_0\":[\"aaaa\"],\"dict_1\":"
 202                         "[\"bbbb\"]}}");
 203 }
 204
 205 static int
 206 test_dict_with_dict_values(void)
 207 {
 208         struct rte_tel_data *dict_of_dicts = rte_tel_data_alloc();
 209         rte_tel_data_start_dict(dict_of_dicts);
 210
 211         struct rte_tel_data *child_data = rte_tel_data_alloc();
 212         rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL);
 213
 214         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
 215         rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL);
 216
 217         memset(&response_data, 0, sizeof(response_data));
 218         rte_tel_data_start_dict(&response_data);
 219
 220         rte_tel_data_add_array_string(child_data, "aaaa");
 221         rte_tel_data_add_array_string(child_data2, "bbbb");
 222         rte_tel_data_add_dict_container(dict_of_dicts, "dict_0",
 223                         child_data, 0);
 224         rte_tel_data_add_dict_container(dict_of_dicts, "dict_1",
 225                         child_data2, 0);
 226         rte_tel_data_add_dict_container(&response_data, "dict_of_dicts",
 227                         dict_of_dicts, 0);
 228
 229         return TEST_OUTPUT("{\"/test\":{\"dict_of_dicts\":{\"dict_0\":"
 230                         "[\"aaaa\"],\"dict_1\":[\"bbbb\"]}}}");
 231 }
 232
 233 static int
 234 test_array_with_array_string_values(void)
 235 {
 236         struct rte_tel_data *child_data = rte_tel_data_alloc();
 237         rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL);
 238
 239         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
 240         rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL);
 241
 242         memset(&response_data, 0, sizeof(response_data));
 243         rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
 244
 245         rte_tel_data_add_array_string(child_data, "aaaa");
 246         rte_tel_data_add_array_string(child_data2, "bbbb");
 247
 248         rte_tel_data_add_array_container(&response_data, child_data, 0);
 249         rte_tel_data_add_array_container(&response_data, child_data2, 0);
 250
 251         return TEST_OUTPUT("{\"/test\":[[\"aaaa\"],[\"bbbb\"]]}");
 252 }
 253
 254 static int
 255 test_case_array_u64(void)
 256 {
 257         int i;
 258         memset(&response_data, 0, sizeof(response_data));
 259         rte_tel_data_start_array(&response_data, RTE_TEL_U64_VAL);
 260         for (i = 0; i < 5; i++)
 261                 rte_tel_data_add_array_u64(&response_data, i);
 262         return TEST_OUTPUT("{\"/test\":[0,1,2,3,4]}");
 263 }
 264
 265 static int
 266 test_case_add_dict_u64(void)
 267 {
 268         int i = 0;
 269         char name_of_value[8];
 270
 271         memset(&response_data, 0, sizeof(response_data));
 272         rte_tel_data_start_dict(&response_data);
 273
 274         for (i = 0; i < 5; i++) {
 275                 sprintf(name_of_value, "dict_%d", i);
 276                 rte_tel_data_add_dict_u64(&response_data, name_of_value, i);
 277         }
 278         return TEST_OUTPUT("{\"/test\":{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2,"
 279                         "\"dict_3\":3,\"dict_4\":4}}");
 280 }
 281
 282 static int
 283 test_dict_with_array_u64_values(void)
 284 {
 285         int i;
 286
 287         struct rte_tel_data *child_data = rte_tel_data_alloc();
 288         rte_tel_data_start_array(child_data, RTE_TEL_U64_VAL);
 289
 290         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
 291         rte_tel_data_start_array(child_data2, RTE_TEL_U64_VAL);
 292
 293         memset(&response_data, 0, sizeof(response_data));
 294         rte_tel_data_start_dict(&response_data);
 295
 296         for (i = 0; i < 10; i++) {
 297                 rte_tel_data_add_array_u64(child_data, i);
 298                 rte_tel_data_add_array_u64(child_data2, i);
 299         }
 300
 301         rte_tel_data_add_dict_container(&response_data, "dict_0",
 302          child_data, 0);
 303         rte_tel_data_add_dict_container(&response_data, "dict_1",
 304          child_data2, 0);
 305
 306         return TEST_OUTPUT("{\"/test\":{\"dict_0\":[0,1,2,3,4,5,6,7,8,9],"
 307                         "\"dict_1\":[0,1,2,3,4,5,6,7,8,9]}}");
 308 }
 309
 310 static int
 311 test_array_with_array_u64_values(void)
 312 {
 313         int i;
 314
 315         struct rte_tel_data *child_data = rte_tel_data_alloc();
 316         rte_tel_data_start_array(child_data, RTE_TEL_U64_VAL);
 317
 318         struct rte_tel_data *child_data2 = rte_tel_data_alloc();
 319         rte_tel_data_start_array(child_data2, RTE_TEL_U64_VAL);
 320
 321         memset(&response_data, 0, sizeof(response_data));
 322         rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
 323
 324         for (i = 0; i < 5; i++) {
 325                 rte_tel_data_add_array_u64(child_data, i);
 326                 rte_tel_data_add_array_u64(child_data2, i);
 327         }
 328         rte_tel_data_add_array_container(&response_data, child_data, 0);
 329         rte_tel_data_add_array_container(&response_data, child_data2, 0);
 330
 331         return TEST_OUTPUT("{\"/test\":[[0,1,2,3,4],[0,1,2,3,4]]}");
 332 }
 333
 334 static int
 335 connect_to_socket(void)
 336 {
 337         char buf[BUF_SIZE];
 338         int sock, bytes;
 339         struct sockaddr_un telem_addr;
 340
 341         sock = socket(AF_UNIX, SOCK_SEQPACKET, 0);
 342         if (sock < 0) {
 343                 printf("\n%s: Error creating socket: %s\n", __func__,
 344                                 strerror(errno));
 345                 return -1;
 346         }
 347         telem_addr.sun_family = AF_UNIX;
 348         snprintf(telem_addr.sun_path, sizeof(telem_addr.sun_path),
 349                         "%s/dpdk_telemetry.%s", rte_eal_get_runtime_dir(),
 350                         TELEMETRY_VERSION);
 351         if (connect(sock, (struct sockaddr *) &telem_addr,
 352                         sizeof(telem_addr)) < 0) {
 353                 printf("\n%s: Error connecting to socket: %s\n", __func__,
 354                                 strerror(errno));
 355                 close(sock);
 356                 return -1;
 357         }
 358
 359         bytes = read(sock, buf, sizeof(buf) - 1);
 360         if (bytes < 0) {
 361                 printf("%s: Error with socket read - %s\n", __func__,
 362                                 strerror(errno));
 363                 close(sock);
 364                 return -1;
 365         }
 366         buf[bytes] = '\0';
 367         printf("\n%s: %s\n", __func__, buf);
 368         return sock;
 369 }
 370
 371 static int
 372 test_telemetry_data(void)
 373 {
 374         typedef int (*test_case)(void);
 375         unsigned int i = 0;
 376
 377         sock = connect_to_socket();
 378         if (sock <= 0)
 379                 return -1;
 380
 381         test_case test_cases[] = {test_case_array_string,
 382                         test_case_array_int, test_case_array_u64,
 383                         test_case_add_dict_int, test_case_add_dict_u64,
 384                         test_case_add_dict_string,
 385                         test_dict_with_array_int_values,
 386                         test_dict_with_array_u64_values,
 387                         test_dict_with_array_string_values,
 388                         test_dict_with_dict_values,
 389                         test_array_with_array_int_values,
 390                         test_array_with_array_u64_values,
 391                         test_array_with_array_string_values };
 392
 393         rte_telemetry_register_cmd(REQUEST_CMD, test_cb, "Test");
 394         for (i = 0; i < RTE_DIM(test_cases); i++) {
 395                 if (test_cases[i]() != 0) {
 396                         close(sock);
 397                         return -1;
 398                 }
 399         }
 400         close(sock);
 401         return 0;
 402 }
 403
 404 REGISTER_TEST_COMMAND(telemetry_data_autotest, test_telemetry_data);