yardstick/benchmark/core/task.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Ericsson AB and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10 """ Handler for yardstick command 'task' """
  11
  12 from __future__ import absolute_import
  13 from __future__ import print_function
  14 import sys
  15 import os
  16 from collections import OrderedDict
  17
  18 import yaml
  19 import atexit
  20 import ipaddress
  21 import time
  22 import logging
  23 import uuid
  24 import collections
  25
  26 from six.moves import filter
  27 from jinja2 import Environment
  28
  29 from yardstick.benchmark.contexts.base import Context
  30 from yardstick.benchmark.runners import base as base_runner
  31 from yardstick.common.yaml_loader import yaml_load
  32 from yardstick.dispatcher.base import Base as DispatcherBase
  33 from yardstick.common.task_template import TaskTemplate
  34 from yardstick.common import utils
  35 from yardstick.common import constants
  36 from yardstick.common.html_template import report_template
  37
  38 output_file_default = "/tmp/yardstick.out"
  39 config_file = '/etc/yardstick/yardstick.conf'
  40 test_cases_dir_default = "tests/opnfv/test_cases/"
  41 LOG = logging.getLogger(__name__)
  42 JOIN_TIMEOUT = 60
  43
  44
  45 class Task(object):     # pragma: no cover
  46     """Task commands.
  47
  48        Set of commands to manage benchmark tasks.
  49     """
  50
  51     def __init__(self):
  52         self.contexts = []
  53         self.outputs = {}
  54
  55     def _set_dispatchers(self, output_config):
  56         dispatchers = output_config.get('DEFAULT', {}).get('dispatcher',
  57                                                            'file')
  58         out_types = [s.strip() for s in dispatchers.split(',')]
  59         output_config['DEFAULT']['dispatcher'] = out_types
  60
  61     def start(self, args, **kwargs):
  62         """Start a benchmark scenario."""
  63
  64         atexit.register(self.atexit_handler)
  65
  66         task_id = getattr(args, 'task_id')
  67         self.task_id = task_id if task_id else str(uuid.uuid4())
  68
  69         self._set_log()
  70
  71         try:
  72             output_config = utils.parse_ini_file(config_file)
  73         except Exception:
  74             # all error will be ignore, the default value is {}
  75             output_config = {}
  76
  77         self._init_output_config(output_config)
  78         self._set_output_config(output_config, args.output_file)
  79         LOG.debug('Output configuration is: %s', output_config)
  80
  81         self._set_dispatchers(output_config)
  82
  83         # update dispatcher list
  84         if 'file' in output_config['DEFAULT']['dispatcher']:
  85             result = {'status': 0, 'result': {}}
  86             utils.write_json_to_file(args.output_file, result)
  87
  88         total_start_time = time.time()
  89         parser = TaskParser(args.inputfile[0])
  90
  91         if args.suite:
  92             # 1.parse suite, return suite_params info
  93             task_files, task_args, task_args_fnames = \
  94                 parser.parse_suite()
  95         else:
  96             task_files = [parser.path]
  97             task_args = [args.task_args]
  98             task_args_fnames = [args.task_args_file]
  99
 100         LOG.debug("task_files:%s, task_args:%s, task_args_fnames:%s",
 101                   task_files, task_args, task_args_fnames)
 102
 103         if args.parse_only:
 104             sys.exit(0)
 105
 106         testcases = {}
 107         # parse task_files
 108         for i in range(0, len(task_files)):
 109             one_task_start_time = time.time()
 110             parser.path = task_files[i]
 111             scenarios, run_in_parallel, meet_precondition, contexts = \
 112                 parser.parse_task(self.task_id, task_args[i],
 113                                   task_args_fnames[i])
 114
 115             self.contexts.extend(contexts)
 116
 117             if not meet_precondition:
 118                 LOG.info("meet_precondition is %s, please check envrionment",
 119                          meet_precondition)
 120                 continue
 121
 122             case_name = os.path.splitext(os.path.basename(task_files[i]))[0]
 123             try:
 124                 data = self._run(scenarios, run_in_parallel, args.output_file)
 125             except KeyboardInterrupt:
 126                 raise
 127             except Exception:
 128                 LOG.exception("Running test case %s failed!", case_name)
 129                 testcases[case_name] = {'criteria': 'FAIL', 'tc_data': []}
 130             else:
 131                 testcases[case_name] = {'criteria': 'PASS', 'tc_data': data}
 132
 133             if args.keep_deploy:
 134                 # keep deployment, forget about stack
 135                 # (hide it for exit handler)
 136                 self.contexts = []
 137             else:
 138                 for context in self.contexts[::-1]:
 139                     context.undeploy()
 140                 self.contexts = []
 141             one_task_end_time = time.time()
 142             LOG.info("Task %s finished in %d secs", task_files[i],
 143                      one_task_end_time - one_task_start_time)
 144
 145         result = self._get_format_result(testcases)
 146
 147         self._do_output(output_config, result)
 148         self._generate_reporting(result)
 149
 150         total_end_time = time.time()
 151         LOG.info("Total finished in %d secs",
 152                  total_end_time - total_start_time)
 153
 154         scenario = scenarios[0]
 155         LOG.info("To generate report, execute command "
 156                  "'yardstick report generate %(task_id)s %(tc)s'", scenario)
 157         LOG.info("Task ALL DONE, exiting")
 158         return result
 159
 160     def _generate_reporting(self, result):
 161         env = Environment()
 162         with open(constants.REPORTING_FILE, 'w') as f:
 163             f.write(env.from_string(report_template).render(result))
 164
 165         LOG.info("Report can be found in '%s'", constants.REPORTING_FILE)
 166
 167     def _set_log(self):
 168         log_format = '%(asctime)s %(name)s %(filename)s:%(lineno)d %(levelname)s %(message)s'
 169         log_formatter = logging.Formatter(log_format)
 170
 171         utils.makedirs(constants.TASK_LOG_DIR)
 172         log_path = os.path.join(constants.TASK_LOG_DIR, '{}.log'.format(self.task_id))
 173         log_handler = logging.FileHandler(log_path)
 174         log_handler.setFormatter(log_formatter)
 175         log_handler.setLevel(logging.DEBUG)
 176
 177         logging.root.addHandler(log_handler)
 178
 179     def _init_output_config(self, output_config):
 180         output_config.setdefault('DEFAULT', {})
 181         output_config.setdefault('dispatcher_http', {})
 182         output_config.setdefault('dispatcher_file', {})
 183         output_config.setdefault('dispatcher_influxdb', {})
 184         output_config.setdefault('nsb', {})
 185
 186     def _set_output_config(self, output_config, file_path):
 187         try:
 188             out_type = os.environ['DISPATCHER']
 189         except KeyError:
 190             output_config['DEFAULT'].setdefault('dispatcher', 'file')
 191         else:
 192             output_config['DEFAULT']['dispatcher'] = out_type
 193
 194         output_config['dispatcher_file']['file_path'] = file_path
 195
 196         try:
 197             target = os.environ['TARGET']
 198         except KeyError:
 199             pass
 200         else:
 201             k = 'dispatcher_{}'.format(output_config['DEFAULT']['dispatcher'])
 202             output_config[k]['target'] = target
 203
 204     def _get_format_result(self, testcases):
 205         criteria = self._get_task_criteria(testcases)
 206
 207         info = {
 208             'deploy_scenario': os.environ.get('DEPLOY_SCENARIO', 'unknown'),
 209             'installer': os.environ.get('INSTALLER_TYPE', 'unknown'),
 210             'pod_name': os.environ.get('NODE_NAME', 'unknown'),
 211             'version': os.environ.get('YARDSTICK_BRANCH', 'unknown')
 212         }
 213
 214         result = {
 215             'status': 1,
 216             'result': {
 217                 'criteria': criteria,
 218                 'task_id': self.task_id,
 219                 'info': info,
 220                 'testcases': testcases
 221             }
 222         }
 223
 224         return result
 225
 226     def _get_task_criteria(self, testcases):
 227         criteria = any(t.get('criteria') != 'PASS' for t in testcases.values())
 228         if criteria:
 229             return 'FAIL'
 230         else:
 231             return 'PASS'
 232
 233     def _do_output(self, output_config, result):
 234         dispatchers = DispatcherBase.get(output_config)
 235
 236         for dispatcher in dispatchers:
 237             dispatcher.flush_result_data(result)
 238
 239     def _run(self, scenarios, run_in_parallel, output_file):
 240         """Deploys context and calls runners"""
 241         for context in self.contexts:
 242             context.deploy()
 243
 244         background_runners = []
 245
 246         result = []
 247         # Start all background scenarios
 248         for scenario in filter(_is_background_scenario, scenarios):
 249             scenario["runner"] = dict(type="Duration", duration=1000000000)
 250             runner = self.run_one_scenario(scenario, output_file)
 251             background_runners.append(runner)
 252
 253         runners = []
 254         if run_in_parallel:
 255             for scenario in scenarios:
 256                 if not _is_background_scenario(scenario):
 257                     runner = self.run_one_scenario(scenario, output_file)
 258                     runners.append(runner)
 259
 260             # Wait for runners to finish
 261             for runner in runners:
 262                 status = runner_join(runner)
 263                 if status != 0:
 264                     raise RuntimeError
 265                 self.outputs.update(runner.get_output())
 266                 result.extend(runner.get_result())
 267                 LOG.info("Runner ended, output in %s", output_file)
 268         else:
 269             # run serially
 270             for scenario in scenarios:
 271                 if not _is_background_scenario(scenario):
 272                     runner = self.run_one_scenario(scenario, output_file)
 273                     status = runner_join(runner)
 274                     if status != 0:
 275                         LOG.error('Scenario: %s ERROR', scenario.get('type'))
 276                         raise RuntimeError
 277                     self.outputs.update(runner.get_output())
 278                     result.extend(runner.get_result())
 279                     LOG.info("Runner ended, output in %s", output_file)
 280
 281         # Abort background runners
 282         for runner in background_runners:
 283             runner.abort()
 284
 285         # Wait for background runners to finish
 286         for runner in background_runners:
 287             status = runner.join(JOIN_TIMEOUT)
 288             if status is None:
 289                 # Nuke if it did not stop nicely
 290                 base_runner.Runner.terminate(runner)
 291                 runner.join(JOIN_TIMEOUT)
 292             base_runner.Runner.release(runner)
 293
 294             self.outputs.update(runner.get_output())
 295             result.extend(runner.get_result())
 296             print("Background task ended")
 297         return result
 298
 299     def atexit_handler(self):
 300         """handler for process termination"""
 301         base_runner.Runner.terminate_all()
 302
 303         if self.contexts:
 304             LOG.info("Undeploying all contexts")
 305             for context in self.contexts[::-1]:
 306                 context.undeploy()
 307
 308     def _parse_options(self, op):
 309         if isinstance(op, dict):
 310             return {k: self._parse_options(v) for k, v in op.items()}
 311         elif isinstance(op, list):
 312             return [self._parse_options(v) for v in op]
 313         elif isinstance(op, str):
 314             return self.outputs.get(op[1:]) if op.startswith('$') else op
 315         else:
 316             return op
 317
 318     def run_one_scenario(self, scenario_cfg, output_file):
 319         """run one scenario using context"""
 320         runner_cfg = scenario_cfg["runner"]
 321         runner_cfg['output_filename'] = output_file
 322
 323         options = scenario_cfg.get('options', {})
 324         scenario_cfg['options'] = self._parse_options(options)
 325
 326         # TODO support get multi hosts/vms info
 327         context_cfg = {}
 328         if "host" in scenario_cfg:
 329             context_cfg['host'] = Context.get_server(scenario_cfg["host"])
 330
 331         if "target" in scenario_cfg:
 332             if is_ip_addr(scenario_cfg["target"]):
 333                 context_cfg['target'] = {}
 334                 context_cfg['target']["ipaddr"] = scenario_cfg["target"]
 335             else:
 336                 context_cfg['target'] = Context.get_server(
 337                     scenario_cfg["target"])
 338                 if self._is_same_heat_context(scenario_cfg["host"],
 339                                               scenario_cfg["target"]):
 340                     context_cfg["target"]["ipaddr"] = \
 341                         context_cfg["target"]["private_ip"]
 342                 else:
 343                     context_cfg["target"]["ipaddr"] = \
 344                         context_cfg["target"]["ip"]
 345
 346         if "targets" in scenario_cfg:
 347             ip_list = []
 348             for target in scenario_cfg["targets"]:
 349                 if is_ip_addr(target):
 350                     ip_list.append(target)
 351                     context_cfg['target'] = {}
 352                 else:
 353                     context_cfg['target'] = Context.get_server(target)
 354                     if self._is_same_heat_context(scenario_cfg["host"],
 355                                                   target):
 356                         ip_list.append(context_cfg["target"]["private_ip"])
 357                     else:
 358                         ip_list.append(context_cfg["target"]["ip"])
 359             context_cfg['target']['ipaddr'] = ','.join(ip_list)
 360
 361         if "nodes" in scenario_cfg:
 362             context_cfg["nodes"] = parse_nodes_with_context(scenario_cfg)
 363             context_cfg["networks"] = get_networks_from_nodes(
 364                 context_cfg["nodes"])
 365         runner = base_runner.Runner.get(runner_cfg)
 366
 367         LOG.info("Starting runner of type '%s'", runner_cfg["type"])
 368         runner.run(scenario_cfg, context_cfg)
 369
 370         return runner
 371
 372     def _is_same_heat_context(self, host_attr, target_attr):
 373         """check if two servers are in the same heat context
 374         host_attr: either a name for a server created by yardstick or a dict
 375         with attribute name mapping when using external heat templates
 376         target_attr: either a name for a server created by yardstick or a dict
 377         with attribute name mapping when using external heat templates
 378         """
 379         for context in self.contexts:
 380             if context.__context_type__ != "Heat":
 381                 continue
 382
 383             host = context._get_server(host_attr)
 384             if host is None:
 385                 continue
 386
 387             target = context._get_server(target_attr)
 388             if target is None:
 389                 return False
 390
 391             # Both host and target is not None, then they are in the
 392             # same heat context.
 393             return True
 394
 395         return False
 396
 397
 398 class TaskParser(object):       # pragma: no cover
 399     """Parser for task config files in yaml format"""
 400
 401     def __init__(self, path):
 402         self.path = path
 403
 404     def _meet_constraint(self, task, cur_pod, cur_installer):
 405         if "constraint" in task:
 406             constraint = task.get('constraint', None)
 407             if constraint is not None:
 408                 tc_fit_pod = constraint.get('pod', None)
 409                 tc_fit_installer = constraint.get('installer', None)
 410                 LOG.info("cur_pod:%s, cur_installer:%s,tc_constraints:%s",
 411                          cur_pod, cur_installer, constraint)
 412                 if (cur_pod is None) or (tc_fit_pod and cur_pod not in tc_fit_pod):
 413                     return False
 414                 if (cur_installer is None) or (tc_fit_installer and cur_installer
 415                                                not in tc_fit_installer):
 416                     return False
 417         return True
 418
 419     def _get_task_para(self, task, cur_pod):
 420         task_args = task.get('task_args', None)
 421         if task_args is not None:
 422             task_args = task_args.get(cur_pod, task_args.get('default'))
 423         task_args_fnames = task.get('task_args_fnames', None)
 424         if task_args_fnames is not None:
 425             task_args_fnames = task_args_fnames.get(cur_pod, None)
 426         return task_args, task_args_fnames
 427
 428     def parse_suite(self):
 429         """parse the suite file and return a list of task config file paths
 430            and lists of optional parameters if present"""
 431         LOG.info("\nParsing suite file:%s", self.path)
 432
 433         try:
 434             with open(self.path) as stream:
 435                 cfg = yaml_load(stream)
 436         except IOError as ioerror:
 437             sys.exit(ioerror)
 438
 439         self._check_schema(cfg["schema"], "suite")
 440         LOG.info("\nStarting scenario:%s", cfg["name"])
 441
 442         test_cases_dir = cfg.get("test_cases_dir", test_cases_dir_default)
 443         test_cases_dir = os.path.join(constants.YARDSTICK_ROOT_PATH,
 444                                       test_cases_dir)
 445         if test_cases_dir[-1] != os.sep:
 446             test_cases_dir += os.sep
 447
 448         cur_pod = os.environ.get('NODE_NAME', None)
 449         cur_installer = os.environ.get('INSTALLER_TYPE', None)
 450
 451         valid_task_files = []
 452         valid_task_args = []
 453         valid_task_args_fnames = []
 454
 455         for task in cfg["test_cases"]:
 456             # 1.check file_name
 457             if "file_name" in task:
 458                 task_fname = task.get('file_name', None)
 459                 if task_fname is None:
 460                     continue
 461             else:
 462                 continue
 463             # 2.check constraint
 464             if self._meet_constraint(task, cur_pod, cur_installer):
 465                 valid_task_files.append(test_cases_dir + task_fname)
 466             else:
 467                 continue
 468             # 3.fetch task parameters
 469             task_args, task_args_fnames = self._get_task_para(task, cur_pod)
 470             valid_task_args.append(task_args)
 471             valid_task_args_fnames.append(task_args_fnames)
 472
 473         return valid_task_files, valid_task_args, valid_task_args_fnames
 474
 475     def parse_task(self, task_id, task_args=None, task_args_file=None):
 476         """parses the task file and return an context and scenario instances"""
 477         LOG.info("Parsing task config: %s", self.path)
 478
 479         try:
 480             kw = {}
 481             if task_args_file:
 482                 with open(task_args_file) as f:
 483                     kw.update(parse_task_args("task_args_file", f.read()))
 484             kw.update(parse_task_args("task_args", task_args))
 485         except TypeError:
 486             raise TypeError()
 487
 488         try:
 489             with open(self.path) as f:
 490                 try:
 491                     input_task = f.read()
 492                     rendered_task = TaskTemplate.render(input_task, **kw)
 493                 except Exception as e:
 494                     LOG.exception('Failed to render template:\n%s\n', input_task)
 495                     raise e
 496                 LOG.debug("Input task is:\n%s\n", rendered_task)
 497
 498                 cfg = yaml_load(rendered_task)
 499         except IOError as ioerror:
 500             sys.exit(ioerror)
 501
 502         self._check_schema(cfg["schema"], "task")
 503         meet_precondition = self._check_precondition(cfg)
 504
 505         # TODO: support one or many contexts? Many would simpler and precise
 506         # TODO: support hybrid context type
 507         if "context" in cfg:
 508             context_cfgs = [cfg["context"]]
 509         elif "contexts" in cfg:
 510             context_cfgs = cfg["contexts"]
 511         else:
 512             context_cfgs = [{"type": "Dummy"}]
 513
 514         contexts = []
 515         name_suffix = '-{}'.format(task_id[:8])
 516         for cfg_attrs in context_cfgs:
 517             try:
 518                 cfg_attrs['name'] = '{}{}'.format(cfg_attrs['name'],
 519                                                   name_suffix)
 520             except KeyError:
 521                 pass
 522             # default to Heat context because we are testing OpenStack
 523             context_type = cfg_attrs.get("type", "Heat")
 524             context = Context.get(context_type)
 525             context.init(cfg_attrs)
 526             contexts.append(context)
 527
 528         run_in_parallel = cfg.get("run_in_parallel", False)
 529
 530         # add tc and task id for influxdb extended tags
 531         for scenario in cfg["scenarios"]:
 532             task_name = os.path.splitext(os.path.basename(self.path))[0]
 533             scenario["tc"] = task_name
 534             scenario["task_id"] = task_id
 535             # embed task path into scenario so we can load other files
 536             # relative to task path
 537             scenario["task_path"] = os.path.dirname(self.path)
 538
 539             change_server_name(scenario, name_suffix)
 540
 541             try:
 542                 for node in scenario['nodes']:
 543                     scenario['nodes'][node] += name_suffix
 544             except KeyError:
 545                 pass
 546
 547         # TODO we need something better here, a class that represent the file
 548         return cfg["scenarios"], run_in_parallel, meet_precondition, contexts
 549
 550     def _check_schema(self, cfg_schema, schema_type):
 551         """Check if config file is using the correct schema type"""
 552
 553         if cfg_schema != "yardstick:" + schema_type + ":0.1":
 554             sys.exit("error: file %s has unknown schema %s" % (self.path,
 555                                                                cfg_schema))
 556
 557     def _check_precondition(self, cfg):
 558         """Check if the environment meet the precondition"""
 559
 560         if "precondition" in cfg:
 561             precondition = cfg["precondition"]
 562             installer_type = precondition.get("installer_type", None)
 563             deploy_scenarios = precondition.get("deploy_scenarios", None)
 564             tc_fit_pods = precondition.get("pod_name", None)
 565             installer_type_env = os.environ.get('INSTALL_TYPE', None)
 566             deploy_scenario_env = os.environ.get('DEPLOY_SCENARIO', None)
 567             pod_name_env = os.environ.get('NODE_NAME', None)
 568
 569             LOG.info("installer_type: %s, installer_type_env: %s",
 570                      installer_type, installer_type_env)
 571             LOG.info("deploy_scenarios: %s, deploy_scenario_env: %s",
 572                      deploy_scenarios, deploy_scenario_env)
 573             LOG.info("tc_fit_pods: %s, pod_name_env: %s",
 574                      tc_fit_pods, pod_name_env)
 575             if installer_type and installer_type_env:
 576                 if installer_type_env not in installer_type:
 577                     return False
 578             if deploy_scenarios and deploy_scenario_env:
 579                 deploy_scenarios_list = deploy_scenarios.split(',')
 580                 for deploy_scenario in deploy_scenarios_list:
 581                     if deploy_scenario_env.startswith(deploy_scenario):
 582                         return True
 583                 return False
 584             if tc_fit_pods and pod_name_env:
 585                 if pod_name_env not in tc_fit_pods:
 586                     return False
 587         return True
 588
 589
 590 def is_ip_addr(addr):
 591     """check if string addr is an IP address"""
 592     try:
 593         addr = addr.get('public_ip_attr', addr.get('private_ip_attr'))
 594     except AttributeError:
 595         pass
 596
 597     try:
 598         ipaddress.ip_address(addr.encode('utf-8'))
 599     except ValueError:
 600         return False
 601     else:
 602         return True
 603
 604
 605 def _is_background_scenario(scenario):
 606     if "run_in_background" in scenario:
 607         return scenario["run_in_background"]
 608     else:
 609         return False
 610
 611
 612 def parse_nodes_with_context(scenario_cfg):
 613     """parse the 'nodes' fields in scenario """
 614     # ensure consistency in node instantiation order
 615     return OrderedDict((nodename, Context.get_server(scenario_cfg["nodes"][nodename]))
 616                        for nodename in sorted(scenario_cfg["nodes"]))
 617
 618
 619 def get_networks_from_nodes(nodes):
 620     """parse the 'nodes' fields in scenario """
 621     networks = {}
 622     for node in nodes.values():
 623         if not node:
 624             continue
 625         interfaces = node.get('interfaces', {})
 626         for interface in interfaces.values():
 627             # vld_id is network_name
 628             network_name = interface.get('network_name')
 629             if not network_name:
 630                 continue
 631             network = Context.get_network(network_name)
 632             if network:
 633                 networks[network['name']] = network
 634     return networks
 635
 636
 637 def runner_join(runner):
 638     """join (wait for) a runner, exit process at runner failure"""
 639     status = runner.join()
 640     base_runner.Runner.release(runner)
 641     return status
 642
 643
 644 def print_invalid_header(source_name, args):
 645     print("Invalid %(source)s passed:\n\n %(args)s\n"
 646           % {"source": source_name, "args": args})
 647
 648
 649 def parse_task_args(src_name, args):
 650     if isinstance(args, collections.Mapping):
 651         return args
 652
 653     try:
 654         kw = args and yaml_load(args)
 655         kw = {} if kw is None else kw
 656     except yaml.parser.ParserError as e:
 657         print_invalid_header(src_name, args)
 658         print("%(source)s has to be YAML. Details:\n\n%(err)s\n"
 659               % {"source": src_name, "err": e})
 660         raise TypeError()
 661
 662     if not isinstance(kw, dict):
 663         print_invalid_header(src_name, args)
 664         print("%(src)s had to be dict, actually %(src_type)s\n"
 665               % {"src": src_name, "src_type": type(kw)})
 666         raise TypeError()
 667     return kw
 668
 669
 670 def change_server_name(scenario, suffix):
 671     try:
 672         host = scenario['host']
 673     except KeyError:
 674         pass
 675     else:
 676         try:
 677             host['name'] += suffix
 678         except TypeError:
 679             scenario['host'] += suffix
 680
 681     try:
 682         target = scenario['target']
 683     except KeyError:
 684         pass
 685     else:
 686         try:
 687             target['name'] += suffix
 688         except TypeError:
 689             scenario['target'] += suffix
 690
 691     try:
 692         key = 'targets'
 693         scenario[key] = ['{}{}'.format(a, suffix) for a in scenario[key]]
 694     except KeyError:
 695         pass