From patchwork Fri Aug 21 12:51:14 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Power, Ciara" X-Patchwork-Id: 75818 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 1E013A04AF; Fri, 21 Aug 2020 15:01:00 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id A19541C0CD; Fri, 21 Aug 2020 15:00:43 +0200 (CEST) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by dpdk.org (Postfix) with ESMTP id 60BAF1C0B7 for ; Fri, 21 Aug 2020 15:00:40 +0200 (CEST) IronPort-SDR: Fa0yxA7mkNbbctF8XWPvn5YFRZAswU2liNloaP2deiJi1TaOdGAbesXaqNR+dyEJM3Et6n3xKi +aoMCeBFtTKw== X-IronPort-AV: E=McAfee;i="6000,8403,9719"; a="135584591" X-IronPort-AV: E=Sophos;i="5.76,335,1592895600"; d="scan'208";a="135584591" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Aug 2020 06:00:39 -0700 IronPort-SDR: ppBXIdW4ibQAqaVFoPVs/7F0qYRWV3Na7YIkRvq6RqStRYPe15RX6oSjmpQJsZeqQgL5hJcPhp iPLF116Csm5A== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.76,335,1592895600"; d="scan'208";a="473039095" Received: from silpixa00399953.ir.intel.com (HELO silpixa00399953.ger.corp.intel.com) ([10.237.222.53]) by orsmga005.jf.intel.com with ESMTP; 21 Aug 2020 06:00:37 -0700 From: Ciara Power To: dev@dpdk.org Cc: keith.wiles@intel.com, bruce.richardson@intel.com, Louise Kilheeney , Ciara Power , Kevin Laatz Date: Fri, 21 Aug 2020 13:51:14 +0100 Message-Id: <20200821125115.52998-3-ciara.power@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200821125115.52998-1-ciara.power@intel.com> References: <20200612105344.15383-1-ciara.power@intel.com> <20200821125115.52998-1-ciara.power@intel.com> Subject: [dpdk-dev] [PATCH v8 2/3] test/test_telemetry_data: add unit tests for data to JSON X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Louise Kilheeney This patch adds tests for verifying telemetry data structures are converted to JSON as expected. Both flat and recursive data structures are tested, for all possible value types. The app connects to the telemetry socket as a client, and registers one command with a corresponding callback function. Each time the callback function is called, it copies a global data variable to the data pointer passed in by telemetry. When a test case is run, the test case function builds up the global data variable with the relevant data types, and the expected json string output which should be generated from that. The 'test_output()' function is used to trigger the callback and ensure the actual output matches that expected. Signed-off-by: Louise Kilheeney Signed-off-by: Ciara Power Acked-by: Bruce Richardson --- app/test/Makefile | 1 + app/test/meson.build | 5 +- app/test/test_telemetry_data.c | 369 +++++++++++++++++++++++++++++++++ 3 files changed, 373 insertions(+), 2 deletions(-) create mode 100644 app/test/test_telemetry_data.c diff --git a/app/test/Makefile b/app/test/Makefile index f4065271e4..1cb64089c1 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -145,6 +145,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_LPM) += test_lpm6.c SRCS-$(CONFIG_RTE_LIBRTE_LPM) += test_lpm6_perf.c SRCS-$(CONFIG_RTE_LIBRTE_TELEMETRY) += test_telemetry_json.c +SRCS-$(CONFIG_RTE_LIBRTE_TELEMETRY) += test_telemetry_data.c SRCS-y += test_debug.c SRCS-y += test_errno.c diff --git a/app/test/meson.build b/app/test/meson.build index 786a213972..4a72fe5b61 100644 --- a/app/test/meson.build +++ b/app/test/meson.build @@ -170,6 +170,7 @@ test_deps = ['acl', 'ring', 'security', 'stack', + 'telemetry', 'timer' ] @@ -345,8 +346,8 @@ if dpdk_conf.has('RTE_LIBRTE_SKELETON_EVENTDEV_PMD') test_deps += 'pmd_skeleton_event' endif if dpdk_conf.has('RTE_LIBRTE_TELEMETRY') - test_sources += 'test_telemetry_json.c' - fast_tests += [['telemetry_json_autotest', true]] + test_sources += ['test_telemetry_json.c', 'test_telemetry_data.c'] + fast_tests += [['telemetry_json_autotest', true], ['telemetry_data_autotest', true]] endif # The following linkages of drivers are required because diff --git a/app/test/test_telemetry_data.c b/app/test/test_telemetry_data.c new file mode 100644 index 0000000000..7a31e68a78 --- /dev/null +++ b/app/test/test_telemetry_data.c @@ -0,0 +1,369 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2020 Intel Corporation + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "test.h" +#include "telemetry_data.h" + +#define TELEMETRY_VERSION "v2" +#define REQUEST_CMD "/test" +#define BUF_SIZE 1024 +#define TEST_OUTPUT(exp) test_output(__func__, exp) + +static struct rte_tel_data response_data; +static int sock; + +/* + * This function is the callback registered with Telemetry to be used when + * the /test command is requested. This callback returns the global data built + * up by the individual test cases. + */ +static int +test_cb(const char *cmd __rte_unused, const char *params __rte_unused, + struct rte_tel_data *d) +{ + *d = response_data; + return 0; +} + +/* + * This function is called by each test case function. It communicates with + * the telemetry socket by requesting the /test command, and reading the + * response. The expected response is passed in by the test case function, + * and is compared to the actual response received from Telemetry. + */ +static int +test_output(const char *func_name, const char *expected) +{ + int bytes; + char buf[BUF_SIZE * 16]; + if (write(sock, REQUEST_CMD, strlen(REQUEST_CMD)) < 0) { + printf("%s: Error with socket write - %s\n", __func__, + strerror(errno)); + return -1; + } + bytes = read(sock, buf, sizeof(buf) - 1); + if (bytes < 0) { + printf("%s: Error with socket read - %s\n", __func__, + strerror(errno)); + return -1; + } + buf[bytes] = '\0'; + printf("%s: buf = '%s', expected = '%s'\n", func_name, buf, expected); + return strncmp(expected, buf, sizeof(buf)); +} + +static int +test_dict_with_array_int_values(void) +{ + int i; + + struct rte_tel_data *child_data = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data, RTE_TEL_INT_VAL); + + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL); + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 5; i++) { + rte_tel_data_add_array_int(child_data, i); + rte_tel_data_add_array_int(child_data2, i); + } + + rte_tel_data_add_dict_container(&response_data, "dict_0", + child_data, 0); + rte_tel_data_add_dict_container(&response_data, "dict_1", + child_data2, 0); + + return TEST_OUTPUT("{\"/test\":{\"dict_0\":[0,1,2,3,4]," + "\"dict_1\":[0,1,2,3,4]}}"); +} + +static int +test_array_with_array_int_values(void) +{ + int i; + + struct rte_tel_data *child_data = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data, RTE_TEL_INT_VAL); + + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL); + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); + + for (i = 0; i < 5; i++) { + rte_tel_data_add_array_int(child_data, i); + rte_tel_data_add_array_int(child_data2, i); + } + rte_tel_data_add_array_container(&response_data, child_data, 0); + rte_tel_data_add_array_container(&response_data, child_data2, 0); + + return TEST_OUTPUT("{\"/test\":[[0,1,2,3,4],[0,1,2,3,4]]}"); +} + +static int +test_case_array_int(void) +{ + int i; + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_INT_VAL); + for (i = 0; i < 5; i++) + rte_tel_data_add_array_int(&response_data, i); + return TEST_OUTPUT("{\"/test\":[0,1,2,3,4]}"); +} + +static int +test_case_add_dict_int(void) +{ + int i = 0; + char name_of_value[8]; + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 5; i++) { + sprintf(name_of_value, "dict_%d", i); + rte_tel_data_add_dict_int(&response_data, name_of_value, i); + } + + return TEST_OUTPUT("{\"/test\":{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2," + "\"dict_3\":3,\"dict_4\":4}}"); +} + +static int +test_case_array_string(void) +{ + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); + rte_tel_data_add_array_string(&response_data, "aaaa"); + rte_tel_data_add_array_string(&response_data, "bbbb"); + rte_tel_data_add_array_string(&response_data, "cccc"); + rte_tel_data_add_array_string(&response_data, "dddd"); + rte_tel_data_add_array_string(&response_data, "eeee"); + + return TEST_OUTPUT("{\"/test\":[\"aaaa\",\"bbbb\",\"cccc\",\"dddd\"," + "\"eeee\"]}"); +} + +static int +test_case_add_dict_string(void) +{ + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + rte_tel_data_add_dict_string(&response_data, "dict_0", "aaaa"); + rte_tel_data_add_dict_string(&response_data, "dict_1", "bbbb"); + rte_tel_data_add_dict_string(&response_data, "dict_2", "cccc"); + rte_tel_data_add_dict_string(&response_data, "dict_3", "dddd"); + + return TEST_OUTPUT("{\"/test\":{\"dict_0\":\"aaaa\",\"dict_1\":" + "\"bbbb\",\"dict_2\":\"cccc\",\"dict_3\":\"dddd\"}}"); +} + + +static int +test_dict_with_array_string_values(void) +{ + struct rte_tel_data *child_data = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); + + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + rte_tel_data_add_array_string(child_data, "aaaa"); + rte_tel_data_add_array_string(child_data2, "bbbb"); + + rte_tel_data_add_dict_container(&response_data, "dict_0", + child_data, 0); + rte_tel_data_add_dict_container(&response_data, "dict_1", + child_data2, 0); + + return TEST_OUTPUT("{\"/test\":{\"dict_0\":[\"aaaa\"],\"dict_1\":" + "[\"bbbb\"]}}"); +} + +static int +test_array_with_array_string_values(void) +{ + struct rte_tel_data *child_data = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); + + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); + + rte_tel_data_add_array_string(child_data, "aaaa"); + rte_tel_data_add_array_string(child_data2, "bbbb"); + + rte_tel_data_add_array_container(&response_data, child_data, 0); + rte_tel_data_add_array_container(&response_data, child_data2, 0); + + return TEST_OUTPUT("{\"/test\":[[\"aaaa\"],[\"bbbb\"]]}"); +} + +static int +test_case_array_u64(void) +{ + int i; + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_U64_VAL); + for (i = 0; i < 5; i++) + rte_tel_data_add_array_u64(&response_data, i); + return TEST_OUTPUT("{\"/test\":[0,1,2,3,4]}"); +} + +static int +test_case_add_dict_u64(void) +{ + int i = 0; + char name_of_value[8]; + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 5; i++) { + sprintf(name_of_value, "dict_%d", i); + rte_tel_data_add_dict_u64(&response_data, name_of_value, i); + } + return TEST_OUTPUT("{\"/test\":{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2," + "\"dict_3\":3,\"dict_4\":4}}"); +} + +static int +test_dict_with_array_u64_values(void) +{ + int i; + + struct rte_tel_data *child_data = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data, RTE_TEL_U64_VAL); + + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_U64_VAL); + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 10; i++) { + rte_tel_data_add_array_u64(child_data, i); + rte_tel_data_add_array_u64(child_data2, i); + } + + rte_tel_data_add_dict_container(&response_data, "dict_0", + child_data, 0); + rte_tel_data_add_dict_container(&response_data, "dict_1", + child_data2, 0); + + return TEST_OUTPUT("{\"/test\":{\"dict_0\":[0,1,2,3,4,5,6,7,8,9]," + "\"dict_1\":[0,1,2,3,4,5,6,7,8,9]}}"); +} + +static int +test_array_with_array_u64_values(void) +{ + int i; + + struct rte_tel_data *child_data = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data, RTE_TEL_U64_VAL); + + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_U64_VAL); + + memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); + + for (i = 0; i < 5; i++) { + rte_tel_data_add_array_u64(child_data, i); + rte_tel_data_add_array_u64(child_data2, i); + } + rte_tel_data_add_array_container(&response_data, child_data, 0); + rte_tel_data_add_array_container(&response_data, child_data2, 0); + + return TEST_OUTPUT("{\"/test\":[[0,1,2,3,4],[0,1,2,3,4]]}"); +} + +static int +connect_to_socket(void) +{ + char buf[BUF_SIZE]; + int sock, bytes; + struct sockaddr_un telem_addr; + + sock = socket(AF_UNIX, SOCK_SEQPACKET, 0); + if (sock < 0) { + printf("\n%s: Error creating socket: %s\n", __func__, + strerror(errno)); + return -1; + } + telem_addr.sun_family = AF_UNIX; + snprintf(telem_addr.sun_path, sizeof(telem_addr.sun_path), + "%s/dpdk_telemetry.%s", rte_eal_get_runtime_dir(), + TELEMETRY_VERSION); + if (connect(sock, (struct sockaddr *) &telem_addr, + sizeof(telem_addr)) < 0) + printf("\n%s: Error connecting to socket: %s\n", __func__, + strerror(errno)); + + bytes = read(sock, buf, sizeof(buf) - 1); + if (bytes < 0) { + printf("%s: Error with socket read - %s\n", __func__, + strerror(errno)); + return -1; + } + buf[bytes] = '\0'; + printf("\n%s: %s\n", __func__, buf); + return sock; +} + +static int +test_telemetry_data(void) +{ + typedef int (*test_case)(void); + unsigned int i = 0; + + sock = connect_to_socket(); + if (sock <= 0) + return -1; + + test_case test_cases[] = {test_case_array_string, + test_case_array_int, test_case_array_u64, + test_case_add_dict_int, test_case_add_dict_u64, + test_case_add_dict_string, + test_dict_with_array_int_values, + test_dict_with_array_u64_values, + test_dict_with_array_string_values, + test_array_with_array_int_values, + test_array_with_array_u64_values, + test_array_with_array_string_values }; + + rte_telemetry_register_cmd(REQUEST_CMD, test_cb, "Test"); + for (i = 0; i < RTE_DIM(test_cases); i++) { + if (test_cases[i]() != 0) { + close(sock); + return -1; + } + } + close(sock); + return 0; +} + +REGISTER_TEST_COMMAND(telemetry_data_autotest, test_telemetry_data);