Source code for yardstick.vTC.apexlake.experimental_framework.heat_template_generation

# Copyright (c) 2015 Intel Research and Development Ireland Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.

Generation of the heat templates from the base template

import json
import os
import shutil
from experimental_framework import common
from experimental_framework.constants import framework_parameters as fp

[docs]class TreeNode: """ This class represent the node of the configuration tree.\ Each node represents a single configuration value for a single configuration parameter. """ def __init__(self): self.up = None self.down = [] self.variable_name = '' self.variable_value = 0
[docs] def add_child(self, node): """ Adds a node as a child for the current node :param node: node to be added as a child (type: TreeNode) :return: None """ node.up = self self.down.append(node)
[docs] def get_parent(self): """ Returns the parent node of the current one :return type: TreeNode """ return self.up
[docs] def get_children(self): """ Returns the children of the current node :return type: list of TreeNode """ if len(self.down) == 0: # return [self] return [] return self.down
[docs] def get_variable_name(self): """ Returns the name of the variable correspondent to the current node :return type: str """ return self.variable_name
[docs] def get_variable_value(self): """ Returns the value of the variable correspondent to the current node :return type: str or int """ return self.variable_value
[docs] def set_variable_name(self, name): """ Sets the name of the variable for the current node :param name: Name of the variable (type: str) :return None """ self.variable_name = name
[docs] def set_variable_value(self, value): """ Sets the value of the variable for the current node :param value: value of the variable (type: str) :return None """ self.variable_value = value
[docs] def get_path(self): """ Returns all the path from the current node to the root of the tree. :return type: list of TreeNode """ ret_val = [] if not self.up: ret_val.append(self) return ret_val for node in self.up.get_path(): ret_val.append(node) ret_val.append(self) return ret_val
def __str__(self): return str(self.variable_name) + " --> " + str(self.variable_value) def __repr__(self): return str(self.variable_name) + " = " + str(self.variable_value) @staticmethod def _get_leaves(node, leaves): """ Returns all the leaves of a tree. It changes the "leaves" list. :param node: root of the tree (type: TreeNode) :param leaves: partial list of leaves (type: list of TreeNode) :return type: None """ children = node.get_children() if len(children) == 0: leaves.append(node) return for child in children: TreeNode._get_leaves(child, leaves) @staticmethod
[docs] def get_leaves(node): """ Returns all the leaves of a tree. :param node: root of the tree (TreeNode) :return type: list """ leaves = list() TreeNode._get_leaves(node, leaves) return leaves
[docs]def generates_templates(base_heat_template, deployment_configuration): """ Generates the heat templates for the experiments :return: None """ # Load useful parameters from file template_dir = common.get_template_dir() template_file_extension = fp.TEMPLATE_FILE_EXTENSION template_base_name = base_heat_template variables = deployment_configuration # Delete the templates eventually generated in previous running of the # framework"Removing the heat templates previously generated") command = "rm {}{}_*".format(template_dir, template_name) os.system(command) # Creation of the tree with all the new configurations"Creation of the tree with all the new configurations") tree = TreeNode() for variable in variables: leaves = TreeNode.get_leaves(tree) common.LOG.debug("LEAVES: " + str(leaves)) common.LOG.debug("VALUES: " + str(variables[variable])) for value in variables[variable]: for leaf in leaves: new_node = TreeNode() new_node.set_variable_name(variable) new_node.set_variable_value(value) leaf.add_child(new_node) common.LOG.debug("CONFIGURATION TREE: " + str(tree))"Heat Template and metadata file creation") leaves = TreeNode.get_leaves(tree) counter = 1 for leaf in leaves: heat_template_vars = leaf.get_path() if os.path.isabs(template_base_name): base_template = template_base_name else: base_template = template_dir + template_base_name new_template = template_dir + template_name new_template += "_" + str(counter) + template_file_extension shutil.copy(base_template, new_template) metadata = dict() for var in heat_template_vars: if var.get_variable_name(): common.replace_in_file(new_template, "#" + var.get_variable_name(), var.get_variable_value()) metadata[var.get_variable_name()] = var.get_variable_value() # Save the metadata on a JSON file with open(new_template + ".json", 'w') as outfile: json.dump(metadata, outfile) common.LOG.debug("Heat Templates and Metadata file " + str(counter) + " created") counter += 1 # Creation of the template files - 1) + " Heat Templates and Metadata files " "created")
[docs]def get_all_heat_templates(template_dir, template_file_extension): """ Loads and returns all the generated heat templates :param template_dir: directory to search in (type: str) :param template_file_extension: extension of the file for templates (type: str) :return: type: list """ template_files = list() for dirname, dirnames, filenames in os.walk(template_dir): for filename in filenames: if template_file_extension in filename and \ filename.endswith(template_file_extension) and \ template_name in filename: template_files.append(filename) template_files.sort() return template_files