#!/usr/bin/env python ############################################################################## # Copyright (c) 2017 Huawei Technologies Co.,Ltd and others. # # All rights reserved. This program and the accompanying materials # are made available under the terms of the Apache License, Version 2.0 # which accompanies this distribution, and is available at # http://www.apache.org/licenses/LICENSE-2.0 ############################################################################## '''This file realize the function of how to parser a config file. This contain Two part: Frist is Init some variables the will be used. Second is reading config file.''' import os import yaml import json import time from pyroute2 import IPDB import utils.infra_setup.runner.docker_env as docker_env class Parser(): bottlenecks_config = {} bottlenecks_test = {} @classmethod def config_init(cls): cls.code_dir = os.path.dirname(os.path.abspath(__file__)) cls.root_dir = os.path.dirname(cls.code_dir) cls.test_dir = os.path.join(cls.root_dir, 'testsuites') config_dir = os.path.join( cls.root_dir, 'config', 'config.yaml') with open(config_dir) as file: config_info = yaml.load(file) common_config = config_info['common_config'] cls.bottlenecks_config["releng_dir"] = common_config["releng_dir"] cls.bottlenecks_config["fetch_os"] = common_config["fetch_os_file"] cls.bottlenecks_config["log_dir"] = common_config['log_dir'] cls.bottlenecks_config["rc_dir"] = common_config['rc_dir'] cls.bottlenecks_config["yardstick_rc_dir"] = \ common_config['yardstick_rc_dir'] cls.config_dir_check(cls.bottlenecks_config["log_dir"]) @classmethod def story_read(cls, testcase, story_name): story_dir = os.path.join( cls.test_dir, testcase, 'testsuite_story', story_name + '.yaml') with open(story_dir) as file: story_parser = yaml.load(file) for case_name in story_parser['testcase']: Parser.testcase_read(testcase, case_name) return cls.bottlenecks_test @classmethod def testcase_read(cls, testcase, testcase_name): testcase_dir = os.path.join( cls.test_dir, testcase, 'testcase_cfg', testcase_name) testcase_local = testcase_dir + ".yaml" with open(testcase_local) as f: cls.bottlenecks_test[testcase_name] = yaml.load(f) return cls.bottlenecks_test @classmethod def config_dir_check(cls, dirname): if dirname is None: dirname = '/tmp/' if not os.path.exists(dirname): os.makedirs(dirname) @classmethod def testcase_out_dir(cls, testcase): file_name = os.getenv("OUTPUT_FILE") if file_name is None: file_suffix = time.strftime('%H_%M', time.localtime(time.time())) suffix_name = "_" + str(file_suffix) out_name = cls.bottlenecks_config["log_dir"] + testcase outfile_name = out_name + suffix_name + ".out" else: out_name = str(file_name) outfile_name = cls.bottlenecks_config["log_dir"] + out_name return outfile_name @staticmethod def config_parser(testcase_cfg, parameters): test_cfg = testcase_cfg['test_config'] stack_cfg = testcase_cfg['stack_config'] # TO-DO add cli parameters to stack_config. return test_cfg, stack_cfg @staticmethod def convert_docker_env(config, ip_type): if ip_type is "dashboard": config["contexts"]["dashboard_ip"] = \ docker_env.ELK_info["ip"] + ":9200" elif ip_type is "yardstick": config["contexts"]["yardstick_ip"] = \ docker_env.yardstick_info["ip"] + ":8888" @staticmethod def ip_parser(ip_type): with IPDB() as ip: GATEWAY_IP = ip.routes['default'].gateway if ip_type is "dashboard": TEST_IP = GATEWAY_IP + ":9200" elif ip_type is "yardstick_test_ip": TEST_IP = GATEWAY_IP + ":8888" return TEST_IP @staticmethod def result_to_file(data, file_name): with open(file_name, "a") as f: f.write(json.dumps(data, f)) f.write("\n") class HeatTemplate_Parser(): """parser a Heat template and a method to deploy template to a stack""" def __init__(self): self.heat_date = {} self.heat_date["resources"] = {} self.heat_date["outputs"] = {} self.heat_date["heat_template_version"] = "2013-05-23" self.heat_date["description"] = {"Stack built by the bottlenecks" " framework for root."} def add_security_group(self, name): """add to the template a Neutron SecurityGroup""" security_name = name + "-security_group" self.heat_date["resources"][security_name] = { "type": "OS::Neutron::SecurityGroup", "properties": { "name": security_name, "description": "Group allowing icmp and upd/tcp on all ports", "rules": [ {"remote_ip_prefix": "0.0.0.0/0", "protocol": "tcp", "port_range_min": "1", "port_range_max": "65535"}, {"remote_ip_prefix": "0.0.0.0/0", "protocol": "udp", "port_range_min": "1", "port_range_max": "65535"}, {"remote_ip_prefix": "0.0.0.0/0", "protocol": "icmp"} ] } } self.heat_date["outputs"][security_name] = { "description": "ID of Security Group", "value": {"get_resource": security_name} } def add_keypair(self, name): """add to the template a Nova KeyPair""" key_name = name + "key" with open(Parser.root_dir + "utils/infra_setup/" "bottlenecks_key/bottlenecks_key.pub") as f: key_content = f.read() self.heat_date["resources"][key_name] = { "type": "OS::Nova::KeyPair", "properties": { "name": key_name, "public_key": key_content } } def add_network(self, name): """add to the template a Neutron Net""" network_name = name + "-net" self.heat_date["resources"][network_name] = { "type": "OS::Neutron::Net", "properties": {"name": network_name} } def add_subnet(self, name, cidr): """add to the template a Neutron Subnet""" network_name = name + "-net" subnet_name = name + "-subnet" self.heat_date["resources"][subnet_name] = { "type": "OS::Neutron::Subnet", "depends_on": network_name, "properties": { "name": subnet_name, "cidr": cidr, "network_id": {"get_resource": network_name} } } self.heat_date["outputs"][subnet_name] = { "description": "subnet %s ID" % subnet_name, "value": {"get_resource": subnet_name} } def add_router(self, name, ext_gw_net): """add to the template a Neutron Router and interface""" router_name = name + "-route" subnet_name = name + "-subnet" self.heat_date["resources"][router_name] = { "type": "OS::Neutron::Router", "depends_on": [subnet_name], "properties": { "name": router_name, "external_gateway_info": { "network": ext_gw_net } } } def add_router_interface(self, name): """add to the template a Neutron RouterInterface and interface""" router_name = name + "-route" subnet_name = name + "-subnet" router_if_name = name + "-interface" self.heat_date["resources"][router_if_name] = { "type": "OS::Neutron::RouterInterface", "depends_on": [router_name, subnet_name], "properties": { "router_id": {"get_resource": router_name}, "subnet_id": {"get_resource": subnet_name} } } def add_server(self, name, image, flavor, user, ports=None): """add to the template a Nova Server""" key_name = "bottlenecks-poscakey" port_name = name + "-port" self.heat_date["resources"][name] = { "type": "OS::Nova::Server", "properties": { "name": name, "flavor": flavor, "image": image, "key_name": {"get_resource": key_name}, "admin_user": user, "networks": [{ "port": {"get_resource": port_name} }] } } self.heat_date["outputs"][name] = { "description": "VM UUID", "value": {"get_resource": name} } def add_port(self, name, stack_name=None): """add to the template a named Neutron Port""" network_name = stack_name + "-net" subnet_name = stack_name + "-subnet" port_name = name + "-port" security_name = stack_name + "-security_group" self.heat_date["resources"][port_name] = { "type": "OS::Neutron::Port", "depends_on": [subnet_name], "properties": { "name": port_name, "fixed_ips": [{"subnet": {"get_resource": subnet_name}}], "network_id": {"get_resource": network_name}, "replacement_policy": "AUTO", "security_groups": [{"get_resource": security_name}] } } self.heat_date["outputs"][port_name] = { "description": "Address for interface %s" % port_name, "value": {"get_attr": [port_name, "fixed_ips", 0, "ip_address"]} } def add_floating_ip(self, name, stack_name, network_ext): """add to the template a Nova FloatingIP resource see: https://bugs.launchpad.net/heat/+bug/1299259 """ port_name = name + "-port" floating_ip_name = name + "-floating" router_if_name = stack_name + "-interface" self.heat_date["resources"][floating_ip_name] = { "depends_on": [router_if_name, port_name], "type": "OS::Nova::FloatingIP", "properties": { "pool": network_ext, } } self.heat_date['outputs'][floating_ip_name] = { 'description': 'floating ip %s' % name, 'value': {'get_attr': [name, 'ip']} } def add_floating_ip_ass(self, name): """add to the template a Nova FloatingIP resource see: https://bugs.launchpad.net/heat/+bug/1299259 """ port_name = name + "-port" floating_ip_name = name + "-floating" floating_ass = name + "-floating_ass" self.heat_date["resources"][floating_ass] = { "type": 'OS::Neutron::FloatingIPAssociation', "depends_on": [port_name, floating_ip_name], "properties": { "floatingip_id": {'get_resource': floating_ip_name}, "port_id": {"get_resource": port_name} } } def get_template_date(self): return self.heat_date