utils/parser.py

   1 #!/usr/bin/env python
   2 ##############################################################################
   3 # Copyright (c) 2017 Huawei Technologies Co.,Ltd and others.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 ##############################################################################
  10 '''This file realize the function of how to parser a config file.
  11 This contain Two part:
  12 Frist is Init some variables the will be used.
  13 Second is reading config file.'''
  14
  15 import os
  16 import yaml
  17 import json
  18 import time
  19 from pyroute2 import IPDB
  20 import utils.infra_setup.runner.docker_env as docker_env
  21
  22
  23 class Parser():
  24
  25     bottlenecks_config = {}
  26     bottlenecks_test = {}
  27
  28     @classmethod
  29     def config_init(cls):
  30         cls.code_dir = os.path.dirname(os.path.abspath(__file__))
  31         cls.root_dir = os.path.dirname(cls.code_dir)
  32         cls.test_dir = os.path.join(cls.root_dir, 'testsuites')
  33         config_dir = os.path.join(
  34             cls.root_dir,
  35             'config',
  36             'config.yaml')
  37
  38         with open(config_dir) as file:
  39             config_info = yaml.load(file)
  40             common_config = config_info['common_config']
  41             cls.bottlenecks_config["releng_dir"] = common_config["releng_dir"]
  42             cls.bottlenecks_config["fetch_os"] = common_config["fetch_os_file"]
  43             cls.bottlenecks_config["log_dir"] = common_config['log_dir']
  44             cls.bottlenecks_config["rc_dir"] = common_config['rc_dir']
  45             cls.bottlenecks_config["yardstick_rc_dir"] = \
  46                 common_config['yardstick_rc_dir']
  47             cls.config_dir_check(cls.bottlenecks_config["log_dir"])
  48
  49     @classmethod
  50     def story_read(cls, testcase, story_name):
  51         story_dir = os.path.join(
  52             cls.test_dir,
  53             testcase,
  54             'testsuite_story',
  55             story_name + '.yaml')
  56         with open(story_dir) as file:
  57             story_parser = yaml.load(file)
  58         for case_name in story_parser['testcase']:
  59             Parser.testcase_read(testcase, case_name)
  60
  61         return cls.bottlenecks_test
  62
  63     @classmethod
  64     def testcase_read(cls, testcase, testcase_name):
  65
  66         testcase_dir = os.path.join(
  67             cls.test_dir,
  68             testcase,
  69             'testcase_cfg',
  70             testcase_name)
  71         testcase_local = testcase_dir + ".yaml"
  72         with open(testcase_local) as f:
  73             cls.bottlenecks_test[testcase_name] = yaml.load(f)
  74
  75         return cls.bottlenecks_test
  76
  77     @classmethod
  78     def config_dir_check(cls, dirname):
  79         if dirname is None:
  80             dirname = '/tmp/'
  81         if not os.path.exists(dirname):
  82             os.makedirs(dirname)
  83
  84     @classmethod
  85     def testcase_out_dir(cls, testcase):
  86         file_time = time.strftime('%H_%M', time.localtime(time.time()))
  87         out_name = cls.bottlenecks_config["log_dir"] + testcase + file_time
  88         outfile_name = out_name + ".out"
  89         return outfile_name
  90
  91     @staticmethod
  92     def config_parser(testcase_cfg, parameters):
  93         test_cfg = testcase_cfg['test_config']
  94         stack_cfg = testcase_cfg['stack_config']
  95         # TO-DO add cli parameters to stack_config.
  96         return test_cfg, stack_cfg
  97
  98     @staticmethod
  99     def convert_docker_env(config, ip_type):
 100         if ip_type is "dashboard":
 101             config["contexts"]["dashboard_ip"] = \
 102                 docker_env.ELK_info["ip"] + ":9200"
 103         elif ip_type is "yardstick":
 104             config["contexts"]["yardstick_ip"] = \
 105                 docker_env.yardstick_info["ip"] + ":8888"
 106
 107     @staticmethod
 108     def ip_parser(ip_type):
 109         with IPDB() as ip:
 110             GATEWAY_IP = ip.routes['default'].gateway
 111         if ip_type is "dashboard":
 112             TEST_IP = GATEWAY_IP + ":9200"
 113         elif ip_type is "yardstick_test_ip":
 114             TEST_IP = GATEWAY_IP + ":8888"
 115         return TEST_IP
 116
 117     @staticmethod
 118     def result_to_file(data, file_name):
 119         with open(file_name, "a") as f:
 120             f.write(json.dumps(data, f))
 121             f.write("\n")
 122
 123
 124 class HeatTemplate_Parser():
 125     """parser a Heat template and a method to deploy template to a stack"""
 126
 127     def __init__(self):
 128         self.heat_date = {}
 129         self.heat_date["resources"] = {}
 130         self.heat_date["outputs"] = {}
 131         self.heat_date["heat_template_version"] = "2013-05-23"
 132         self.heat_date["description"] = {"Stack built by the bottlenecks"
 133                                          " framework for root."}
 134
 135     def add_security_group(self, name):
 136         """add to the template a Neutron SecurityGroup"""
 137         security_name = name + "-security_group"
 138         self.heat_date["resources"][security_name] = {
 139             "type": "OS::Neutron::SecurityGroup",
 140             "properties": {
 141                 "name": security_name,
 142                 "description": "Group allowing icmp and upd/tcp on all ports",
 143                 "rules": [
 144                     {"remote_ip_prefix": "0.0.0.0/0",
 145                      "protocol": "tcp",
 146                      "port_range_min": "1",
 147                      "port_range_max": "65535"},
 148                     {"remote_ip_prefix": "0.0.0.0/0",
 149                      "protocol": "udp",
 150                      "port_range_min": "1",
 151                      "port_range_max": "65535"},
 152                     {"remote_ip_prefix": "0.0.0.0/0",
 153                      "protocol": "icmp"}
 154                 ]
 155             }
 156         }
 157
 158         self.heat_date["outputs"][security_name] = {
 159             "description": "ID of Security Group",
 160             "value": {"get_resource": security_name}
 161         }
 162
 163     def add_keypair(self, name):
 164         """add to the template a Nova KeyPair"""
 165         key_name = name + "key"
 166         with open(Parser.root_dir +
 167                   "utils/infra_setup/"
 168                   "bottlenecks_key/bottlenecks_key.pub") as f:
 169             key_content = f.read()
 170             self.heat_date["resources"][key_name] = {
 171                 "type": "OS::Nova::KeyPair",
 172                 "properties": {
 173                     "name": key_name,
 174                     "public_key": key_content
 175                 }
 176             }
 177
 178     def add_network(self, name):
 179         """add to the template a Neutron Net"""
 180         network_name = name + "-net"
 181         self.heat_date["resources"][network_name] = {
 182             "type": "OS::Neutron::Net",
 183             "properties": {"name": network_name}
 184         }
 185
 186     def add_subnet(self, name, cidr):
 187         """add to the template a Neutron Subnet"""
 188         network_name = name + "-net"
 189         subnet_name = name + "-subnet"
 190         self.heat_date["resources"][subnet_name] = {
 191             "type": "OS::Neutron::Subnet",
 192             "depends_on": network_name,
 193             "properties": {
 194                 "name": subnet_name,
 195                 "cidr": cidr,
 196                 "network_id": {"get_resource": network_name}
 197             }
 198         }
 199
 200         self.heat_date["outputs"][subnet_name] = {
 201             "description": "subnet %s ID" % subnet_name,
 202             "value": {"get_resource": subnet_name}
 203         }
 204
 205     def add_router(self, name, ext_gw_net):
 206         """add to the template a Neutron Router and interface"""
 207         router_name = name + "-route"
 208         subnet_name = name + "-subnet"
 209
 210         self.heat_date["resources"][router_name] = {
 211             "type": "OS::Neutron::Router",
 212             "depends_on": [subnet_name],
 213             "properties": {
 214                 "name": router_name,
 215                 "external_gateway_info": {
 216                     "network": ext_gw_net
 217                 }
 218             }
 219         }
 220
 221     def add_router_interface(self, name):
 222         """add to the template a Neutron RouterInterface and interface"""
 223         router_name = name + "-route"
 224         subnet_name = name + "-subnet"
 225         router_if_name = name + "-interface"
 226
 227         self.heat_date["resources"][router_if_name] = {
 228             "type": "OS::Neutron::RouterInterface",
 229             "depends_on": [router_name, subnet_name],
 230             "properties": {
 231                 "router_id": {"get_resource": router_name},
 232                 "subnet_id": {"get_resource": subnet_name}
 233             }
 234         }
 235
 236     def add_server(self, name, image, flavor, user, ports=None):
 237         """add to the template a Nova Server"""
 238
 239         key_name = "bottlenecks-poscakey"
 240         port_name = name + "-port"
 241         self.heat_date["resources"][name] = {
 242             "type": "OS::Nova::Server",
 243             "properties": {
 244                 "name": name,
 245                 "flavor": flavor,
 246                 "image": image,
 247                 "key_name": {"get_resource": key_name},
 248                 "admin_user": user,
 249                 "networks": [{
 250                     "port": {"get_resource": port_name}
 251                 }]
 252             }
 253         }
 254
 255         self.heat_date["outputs"][name] = {
 256             "description": "VM UUID",
 257             "value": {"get_resource": name}
 258         }
 259
 260     def add_port(self, name, stack_name=None):
 261         """add to the template a named Neutron Port"""
 262         network_name = stack_name + "-net"
 263         subnet_name = stack_name + "-subnet"
 264         port_name = name + "-port"
 265         security_name = stack_name + "-security_group"
 266
 267         self.heat_date["resources"][port_name] = {
 268             "type": "OS::Neutron::Port",
 269             "depends_on": [subnet_name],
 270             "properties": {
 271                 "name": port_name,
 272                 "fixed_ips": [{"subnet": {"get_resource": subnet_name}}],
 273                 "network_id": {"get_resource": network_name},
 274                 "replacement_policy": "AUTO",
 275                 "security_groups": [{"get_resource": security_name}]
 276             }
 277         }
 278
 279         self.heat_date["outputs"][port_name] = {
 280             "description": "Address for interface %s" % port_name,
 281             "value": {"get_attr": [port_name, "fixed_ips", 0, "ip_address"]}
 282         }
 283
 284     def add_floating_ip(self, name, stack_name, network_ext):
 285         """add to the template a Nova FloatingIP resource
 286         see: https://bugs.launchpad.net/heat/+bug/1299259
 287         """
 288         port_name = name + "-port"
 289         floating_ip_name = name + "-floating"
 290         router_if_name = stack_name + "-interface"
 291
 292         self.heat_date["resources"][floating_ip_name] = {
 293             "depends_on": [router_if_name, port_name],
 294             "type": "OS::Nova::FloatingIP",
 295             "properties": {
 296                 "pool": network_ext,
 297             }
 298         }
 299         self.heat_date['outputs'][floating_ip_name] = {
 300             'description': 'floating ip %s' % name,
 301             'value': {'get_attr': [name, 'ip']}
 302         }
 303
 304     def add_floating_ip_ass(self, name):
 305         """add to the template a Nova FloatingIP resource
 306         see: https://bugs.launchpad.net/heat/+bug/1299259
 307         """
 308         port_name = name + "-port"
 309         floating_ip_name = name + "-floating"
 310         floating_ass = name + "-floating_ass"
 311
 312         self.heat_date["resources"][floating_ass] = {
 313             "type": 'OS::Neutron::FloatingIPAssociation',
 314             "depends_on": [port_name, floating_ip_name],
 315             "properties": {
 316                 "floatingip_id": {'get_resource': floating_ip_name},
 317                 "port_id": {"get_resource": port_name}
 318             }
 319         }
 320
 321     def get_template_date(self):
 322         return self.heat_date