yardstick/vTC/apexlake/experimental_framework/api.py

   1 # Copyright (c) 2015 Intel Research and Development Ireland Ltd.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import experimental_framework.benchmarking_unit as b_unit
  16 from experimental_framework import heat_template_generation, common
  17
  18
  19 class FrameworkApi(object):
  20
  21     @staticmethod
  22     def init():
  23         """
  24         Initializes the Framework
  25
  26         :return: None
  27         """
  28         common.init(api=True)
  29
  30     @staticmethod
  31     def get_available_test_cases():
  32         """
  33         Returns a list of available test cases.
  34         This list include eventual modules developed by the user, if any.
  35         Each test case is returned as a string that represents the full name
  36         of the test case and that can be used to get more information
  37         calling get_test_case_features(test_case_name)
  38
  39         :return: list of strings
  40         """
  41         return b_unit.BenchmarkingUnit.get_available_test_cases()
  42
  43     @staticmethod
  44     def get_test_case_features(test_case):
  45         """
  46         Returns a list of features (description, requested parameters,
  47         allowed values, etc.) for a specified test case.
  48
  49         :param test_case: name of the test case (string)
  50                           The string represents the test case and can be
  51                           obtained  calling  "get_available_test_cases()"
  52                           method.
  53
  54         :return: dict() containing the features of the test case
  55         """
  56         if not isinstance(test_case, str):
  57             raise ValueError('The provided test_case parameter has to be '
  58                              'a string')
  59         benchmark = b_unit.BenchmarkingUnit.get_required_benchmarks(
  60             [test_case])[0]
  61         return benchmark.get_features()
  62
  63     @staticmethod
  64     def execute_framework(
  65             test_cases,
  66             iterations,
  67             heat_template,
  68             heat_template_parameters,
  69             deployment_configuration,
  70             openstack_credentials
  71     ):
  72         """
  73         Executes the framework according the inputs
  74
  75         :param test_cases: Test cases to be ran on the workload
  76                             (dict() of dict())
  77                             Each string represents a test case and it is one
  78                             of the strings provided by the
  79                             "get_available_test_cases()" function output.
  80
  81         :param iterations: Number of cycles to be executed (int)
  82
  83         :param heat_template: (string) File name of the heat template of the
  84                             workload to be deployed. It contains the
  85                             parameters to be evaluated in the form of
  86                             #parameter_name. (See heat_templates/vTC.yaml as
  87                             example).
  88
  89         :param heat_template_parameters: (dict) Parameters to be provided
  90                             as input to the heat template.
  91                             See http://docs.openstack.org/developer/heat/
  92                             template_guide/hot_guide.html - section
  93                             "Template input parameters" for further info.
  94
  95         :param deployment_configuration: ( dict[string] = list(strings) ) )
  96                             Dictionary of parameters representing the
  97                             deployment configuration of the workload
  98                             The key is a string corresponding to the name of
  99                             the parameter, the value is a list of strings
 100                             representing the value to be assumed by a specific
 101                             param.
 102                             The parameters are user defined: they have to
 103                             correspond to the place holders (#parameter_name)
 104                             specified in the heat template.
 105
 106         :return: None
 107         """
 108
 109         # Input Validation
 110         common.InputValidation.validate_os_credentials(openstack_credentials)
 111         credentials = openstack_credentials
 112         msg = 'The provided heat_template does not exist'
 113         template = "{}{}".format(common.get_template_dir(), heat_template)
 114         common.InputValidation.validate_file_exist(template, msg)
 115         msg = 'The provided iterations variable must be an integer value'
 116         common.InputValidation.validate_integer(iterations, msg)
 117         msg = 'The provided heat_template_parameters variable must be a ' \
 118               'dictionary'
 119         common.InputValidation.validate_dictionary(heat_template_parameters,
 120                                                    msg)
 121         log_msg = "Generation of all the heat templates " \
 122                   "required by the experiment"
 123         common.LOG.info(log_msg)
 124         heat_template_generation.generates_templates(heat_template,
 125                                                      deployment_configuration)
 126         benchmarking_unit = \
 127             b_unit.BenchmarkingUnit(
 128                 heat_template, credentials, heat_template_parameters,
 129                 iterations, test_cases)
 130         try:
 131             common.LOG.info("Benchmarking Unit initialization")
 132             benchmarking_unit.initialize()
 133             common.LOG.info("Benchmarking Unit Running")
 134             benchmarking_unit.run_benchmarks()
 135         finally:
 136             common.LOG.info("Benchmarking Unit Finalization")
 137             benchmarking_unit.finalize()