From patchwork Wed Jun 22 12:14:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Juraj_Linke=C5=A1?= X-Patchwork-Id: 113251 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9BC91A04FD; Wed, 22 Jun 2022 14:15:37 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 08F4142B76; Wed, 22 Jun 2022 14:15:04 +0200 (CEST) Received: from lb.pantheon.sk (lb.pantheon.sk [46.229.239.20]) by mails.dpdk.org (Postfix) with ESMTP id 3A61D4282C for ; Wed, 22 Jun 2022 14:15:00 +0200 (CEST) Received: from localhost (localhost [127.0.0.1]) by lb.pantheon.sk (Postfix) with ESMTP id 61BFB31475; Wed, 22 Jun 2022 14:14:59 +0200 (CEST) X-Virus-Scanned: amavisd-new at siecit.sk Received: from lb.pantheon.sk ([127.0.0.1]) by localhost (lb.pantheon.sk [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id y_oClyWmhOA1; Wed, 22 Jun 2022 14:14:58 +0200 (CEST) Received: from entguard.lab.pantheon.local (unknown [46.229.239.141]) by lb.pantheon.sk (Postfix) with ESMTP id D704331471; Wed, 22 Jun 2022 14:14:52 +0200 (CEST) From: =?utf-8?q?Juraj_Linke=C5=A1?= To: thomas@monjalon.net, david.marchand@redhat.com, jerinjacobk@gmail.com, ronan.randles@intel.com, Honnappa.Nagarahalli@arm.com, ohilyard@iol.unh.edu, lijuan.tu@intel.com Cc: dev@dpdk.org, =?utf-8?q?Juraj_Linke=C5=A1?= Subject: [PATCH v1 7/8] dts: add dts runtime workflow module Date: Wed, 22 Jun 2022 12:14:47 +0000 Message-Id: <20220622121448.3304251-8-juraj.linkes@pantheon.tech> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220622121448.3304251-1-juraj.linkes@pantheon.tech> References: <20220622121448.3304251-1-juraj.linkes@pantheon.tech> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org The module is responsilbe for running DTS. It handles the creation of objects and eventually the whole DTS workflow, such as running node setups, test gathering, setup and execution and various cleanups. Signed-off-by: Juraj Linkeš --- dts/framework/dts.py | 128 +++++++++++++++++++++++++++++++++++++++++ dts/framework/utils.py | 36 ++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 dts/framework/dts.py diff --git a/dts/framework/dts.py b/dts/framework/dts.py new file mode 100644 index 0000000000..59eb163e89 --- /dev/null +++ b/dts/framework/dts.py @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2010-2019 Intel Corporation +# + +import atexit # register callback when exit +import configparser # config parse module +import os # operation system module +import sys + +import framework.logger as logger +import framework.settings as settings # dts settings + +from .config import TopologyConf +from .exception import ConfigParseException +from .logger import getLogger +from .node import Node +from .utils import check_dts_python_version, create_parallel_locks + +log_handler = None + + +def dts_parse_config(config, section): + """ + Parse execution file configuration. + """ + sut_nodes = [sut_.strip() for sut_ in config.get(section, "sut").split(",")] + + return sut_nodes + + +def dts_nodes_init(nodeInsts): + """ + Create dts SUT/TG instance and initialize them. + """ + sut_nodes = [] + + sut_id = 0 + for nodeInst in nodeInsts: + sut_node = Node(nodeInst, sut_id) + sut_nodes.append(sut_node) + sut_id += 1 + + return sut_nodes + + +def dts_nodes_exit(sut_nodes): + """ + Call SUT and TG exit function after execution finished + """ + for sut_node in sut_nodes: + sut_node.node_exit() + + +def run_all( + config_file, + verbose, +): + """ + Main process of DTS, it will run all test suites in the config file. + """ + + global log_handler + + # check the python version of the server that run dts + check_dts_python_version() + + # init log_handler handler + if verbose is True: + logger.set_verbose() + + log_handler = getLogger("dts") + + # Read config file + dts_cfg_folder = settings.load_global_setting(settings.DTS_CFG_FOLDER) + if dts_cfg_folder != "": + config_file = dts_cfg_folder + os.sep + config_file + + config = configparser.SafeConfigParser() + load_cfg = config.read(config_file) + if len(load_cfg) == 0: + raise ConfigParseException(config_file) + + topo_conf = TopologyConf() + nodes = topo_conf.load_topo_config() + + # for all Execution sections + for section in config.sections(): + nodeInsts = list() + + # verify if the delimiter is good if the lists are vertical + sut_nodes = dts_parse_config(config, section) + for sut in sut_nodes: + log_handler.info("\nSUT " + sut) + + # look up in nodes - to find the matching IP + for sut in sut_nodes: + for node in nodes: + if node["section"] == sut: + nodeInsts.append(node) + break + + # only run on the SUT in known nodes + if len(nodeInsts) == 0: + log_handler.error(" SKIP UNKNOWN NODE") + continue + + # init global lock + create_parallel_locks(len(sut_nodes)) + + # init SUT, TG node + sut_nodes = dts_nodes_init(nodeInsts) + # register exit action + atexit.register(quit_execution, sut_nodes) + + dts_nodes_exit(sut_nodes) + + +def quit_execution(sut_nodes): + """ + Close session to SUT and TG before quit. + Return exit status when failure occurred. + """ + for sut_node in sut_nodes: + # close all session + sut_node.node_exit() + + log_handler.info("DTS ended") + sys.exit(0) diff --git a/dts/framework/utils.py b/dts/framework/utils.py index a8e739f7b2..0800aa8158 100644 --- a/dts/framework/utils.py +++ b/dts/framework/utils.py @@ -2,10 +2,23 @@ # Copyright(c) 2010-2014 Intel Corporation # +import sys import threading from functools import wraps +def create_parallel_locks(num_suts): + """ + Create thread lock dictionary based on SUTs number + """ + global locks_info + locks_info = [] + for _ in range(num_suts): + lock_info = dict() + lock_info["update_lock"] = threading.RLock() + locks_info.append(lock_info) + + def parallel_lock(num=1): """ Wrapper function for protect parallel threads, allow multiple threads @@ -90,3 +103,26 @@ def RED(text): def GREEN(text): return "\x1B[" + "32;1m" + str(text) + "\x1B[" + "0m" + + +def check_dts_python_version(): + if ( + sys.version_info.major < 3 + or (sys.version_info.major == 3 and sys.version_info.minor < 6) + or ( + sys.version_info.major == 3 + and sys.version_info.minor == 6 + and sys.version_info.micro < 9 + ) + ): + print( + RED( + ( + "WARNING: Dts running node python version is lower than python 3.6, " + "it is deprecated for use in DTS, " + "and will not work in future releases." + ) + ), + file=sys.stderr, + ) + print(RED("Please use Python >= 3.6.9 instead"), file=sys.stderr)