summaryrefslogtreecommitdiffstats
path: root/deploy/dea.py
blob: 1ac048e06b84e8bb587085a7588cd657a7db9352 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
###############################################################################
# Copyright (c) 2015 Ericsson AB and others.
# szilard.cserey@ericsson.com
# 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
###############################################################################


import yaml
import io
import netaddr


class DeploymentEnvironmentAdapter(object):

    def __init__(self, yaml_path):
        self.dea_struct = None
        self.parse_yaml(yaml_path)
        self.network_names = []
        self.collect_network_names()

    def modify_ip(self, ip_addr, index, val):
        ip_str = str(netaddr.IPAddress(ip_addr))
        decimal_list = map(int, ip_str.split('.'))
        decimal_list[index] = val
        return '.'.join(map(str, decimal_list))

    def parse_yaml(self, yaml_path):
        with io.open(yaml_path) as yaml_file:
            self.dea_struct = yaml.load(yaml_file)

    def get_env_name(self):
        return self.get_property('environment')['name']

    def get_env_net_segment_type(self):
        return self.get_property('environment')['net_segment_type']

    def get_fuel_config(self):
        return self.dea_struct['fuel']

    def get_fuel_ip(self):
        fuel_conf = self.get_fuel_config()
        return fuel_conf['ADMIN_NETWORK']['ipaddress']

    def get_fuel_netmask(self):
        fuel_conf = self.get_fuel_config()
        return fuel_conf['ADMIN_NETWORK']['netmask']

    def get_fuel_gateway(self):
        ip = self.get_fuel_ip()
        return self.modify_ip(ip, 3, 1)

    def get_fuel_hostname(self):
        fuel_conf = self.get_fuel_config()
        return fuel_conf['HOSTNAME']

    def get_fuel_dns(self):
        fuel_conf = self.get_fuel_config()
        return fuel_conf['DNS_UPSTREAM']

    def get_node_property(self, node_id, property_name):
        for node in self.dea_struct['nodes']:
            if node['id'] == node_id and property_name in node:
                return node[property_name]

    def get_node_roles(self, node_id):
        return self.get_node_property(node_id, 'role')

    def get_node_main_role(self, node_id, fuel_node_id):
        if node_id == fuel_node_id:
            return 'fuel'
        roles = self.get_node_roles(node_id)
        return 'controller' if 'controller' in roles else 'compute'

    def get_node_ids(self):
        node_ids = []
        for node in self.dea_struct['nodes']:
            node_ids.append(node['id'])
        return node_ids

    def get_property(self, property_name):
        return self.dea_struct[property_name]

    def collect_network_names(self):
        self.network_names = []
        for network in self.dea_struct['network']['networks']:
            self.network_names.append(network['name'])

    def get_network_names(self):
        return self.network_names

    def get_dns_list(self):
        settings = self.get_property('settings')
        dns_list = settings['editable']['external_dns']['dns_list']['value']
        return [d.strip() for d in dns_list.split(',')]

    def get_ntp_list(self):
        settings = self.get_property('settings')
        ntp_list = settings['editable']['external_ntp']['ntp_list']['value']
        return [n.strip() for n in ntp_list.split(',')]

    def get_blade_node_map(self):
        return self.dea_struct['blade_node_map']
span class="n">verbose: RALLY_STDERR = subprocess.STDOUT else: RALLY_STDERR = open(os.devnull, 'w') """ logging configuration """ logger = logging.getLogger("run_rally") logger.setLevel(logging.DEBUG) ch = logging.StreamHandler() if args.debug: ch.setLevel(logging.DEBUG) else: ch.setLevel(logging.INFO) formatter = logging.Formatter("%(asctime)s - %(name)s - " "%(levelname)s - %(message)s") ch.setFormatter(formatter) logger.addHandler(ch) REPO_PATH=os.environ['repos_dir']+'/functest/' if not os.path.exists(REPO_PATH): logger.error("Functest repository directory not found '%s'" % REPO_PATH) exit(-1) sys.path.append(REPO_PATH + "testcases/") import functest_utils with open("/home/opnfv/functest/conf/config_functest.yaml") as f: functest_yaml = yaml.safe_load(f) f.close() HOME = os.environ['HOME']+"/" ####todo: #SCENARIOS_DIR = REPO_PATH + functest_yaml.get("general"). \ # get("directories").get("dir_rally_scn") SCENARIOS_DIR = REPO_PATH + "testcases/VIM/OpenStack/CI/rally_cert/" ### TEMPLATE_DIR = SCENARIOS_DIR + "scenario/templates" SUPPORT_DIR = SCENARIOS_DIR + "scenario/support" ###todo: FLAVOR_NAME = "m1.tiny" USERS_AMOUNT = 2 TENANTS_AMOUNT = 3 CONTROLLERS_AMOUNT = 2 ### RESULTS_DIR = functest_yaml.get("general").get("directories"). \ get("dir_rally_res") TEST_DB = functest_yaml.get("results").get("test_db_url") FLOATING_NETWORK = functest_yaml.get("general"). \ get("openstack").get("neutron_public_net_name") PRIVATE_NETWORK = functest_yaml.get("general"). \ get("openstack").get("neutron_private_net_name") GLANCE_IMAGE_NAME = functest_yaml.get("general"). \ get("openstack").get("image_name") GLANCE_IMAGE_FILENAME = functest_yaml.get("general"). \ get("openstack").get("image_file_name") GLANCE_IMAGE_FORMAT = functest_yaml.get("general"). \ get("openstack").get("image_disk_format") GLANCE_IMAGE_PATH = functest_yaml.get("general"). \ get("directories").get("dir_functest_data") + "/" + GLANCE_IMAGE_FILENAME CINDER_VOLUME_TYPE_NAME = "volume_test" def push_results_to_db(payload): url = TEST_DB + "/results" installer = functest_utils.get_installer_type(logger) scenario = functest_utils.get_scenario(logger) pod_name = functest_utils.get_pod_name(logger) # TODO pod_name hardcoded, info shall come from Jenkins params = {"project_name": "functest", "case_name": "Rally", "pod_name": pod_name, "installer": installer, "version": scenario, "details": payload} headers = {'Content-Type': 'application/json'} r = requests.post(url, data=json.dumps(params), headers=headers) logger.debug(r) def get_task_id(cmd_raw): """ get task id from command rally result :param cmd_raw: :return: task_id as string """ taskid_re = re.compile('^Task +(.*): started$') for line in cmd_raw.splitlines(True): line = line.strip() match = taskid_re.match(line) if match: return match.group(1) return None def task_succeed(json_raw): """ Parse JSON from rally JSON results :param json_raw: :return: Bool """ rally_report = json.loads(json_raw) rally_report = rally_report[0] if rally_report is None: return False if rally_report.get('result') is None: return False for result in rally_report.get('result'): if len(result.get('error')) > 0: return False return True def build_task_args(test_file_name): task_args = {'service_list': [test_file_name]} task_args['smoke'] = args.smoke task_args['image_name'] = GLANCE_IMAGE_NAME task_args['flavor_name'] = FLAVOR_NAME task_args['glance_image_location'] = GLANCE_IMAGE_PATH task_args['floating_network'] = FLOATING_NETWORK task_args['netid'] = functest_utils.get_network_id(client_dict['neutron'], PRIVATE_NETWORK).encode('ascii', 'ignore') task_args['tmpl_dir'] = TEMPLATE_DIR task_args['sup_dir'] = SUPPORT_DIR task_args['users_amount'] = USERS_AMOUNT task_args['tenants_amount'] = TENANTS_AMOUNT task_args['controllers_amount'] = CONTROLLERS_AMOUNT return task_args def run_task(test_name): # # the "main" function of the script who launch rally for a task # :param test_name: name for the rally test # :return: void # logger.info('starting {} test ...'.format(test_name)) task_file = '{}task.yaml'.format(SCENARIOS_DIR) if not os.path.exists(task_file): logger.error("Task file '%s' does not exist." % task_file) exit(-1) test_file_name = '{}opnfv-{}.yaml'.format(SCENARIOS_DIR + "scenario/", test_name) if not os.path.exists(test_file_name): logger.error("The scenario '%s' does not exist." % test_file_name) exit(-1) logger.debug('Scenario fetched from : {}'.format(test_file_name)) cmd_line = "rally task start --abort-on-sla-failure " + \ "--task {} ".format(task_file) + \ "--task-args \"{}\" ".format(build_task_args(test_name)) logger.debug('running command line : {}'.format(cmd_line)) p = subprocess.Popen(cmd_line, stdout=subprocess.PIPE, stderr=RALLY_STDERR, shell=True) result = "" while p.poll() is None: l = p.stdout.readline() print l.replace('\n', '') result += l task_id = get_task_id(result) logger.debug('task_id : {}'.format(task_id)) if task_id is None: logger.error("failed to retrieve task_id") exit(-1) # check for result directory and create it otherwise if not os.path.exists(RESULTS_DIR): logger.debug('does not exists, we create it'.format(RESULTS_DIR)) os.makedirs(RESULTS_DIR) # write html report file report_file_name = '{}opnfv-{}.html'.format(RESULTS_DIR, test_name) cmd_line = "rally task report {} --out {}".format(task_id, report_file_name) logger.debug('running command line : {}'.format(cmd_line)) os.popen(cmd_line) # get and save rally operation JSON result cmd_line = "rally task results %s" % task_id logger.debug('running command line : {}'.format(cmd_line)) cmd = os.popen(cmd_line) json_results = cmd.read() with open('{}opnfv-{}.json'.format(RESULTS_DIR, test_name), 'w') as f: logger.debug('saving json file') f.write(json_results) with open('{}opnfv-{}.json' .format(RESULTS_DIR, test_name)) as json_file: json_data = json.load(json_file) # Push results in payload of testcase if args.report: logger.debug("Push result into DB") push_results_to_db(json_data) """ parse JSON operation result """ if task_succeed(json_results): print 'Test OK' else: print 'Test KO' def main(): # configure script if not (args.test_name in tests): logger.error('argument not valid') exit(-1) creds_nova = functest_utils.get_credentials("nova") nova_client = novaclient.Client('2',**creds_nova) creds_neutron = functest_utils.get_credentials("neutron") neutron_client = neutronclient.Client(**creds_neutron) creds_keystone = functest_utils.get_credentials("keystone") keystone_client = keystoneclient.Client(**creds_keystone) glance_endpoint = keystone_client.service_catalog.url_for(service_type='image', endpoint_type='publicURL') glance_client = glanceclient.Client(1, glance_endpoint, token=keystone_client.auth_token) creds_cinder = functest_utils.get_credentials("cinder") cinder_client = cinderclient.Client('2',creds_cinder['username'], creds_cinder['api_key'], creds_cinder['project_id'], creds_cinder['auth_url'], service_type="volume") client_dict['neutron'] = neutron_client volume_types = functest_utils.list_volume_types(cinder_client, private=False) if not volume_types: volume_type = functest_utils.create_volume_type(cinder_client, \ CINDER_VOLUME_TYPE_NAME) if not volume_type: logger.error("Failed to create volume type...") exit(-1) else: logger.debug("Volume type '%s' created succesfully..." \ % CINDER_VOLUME_TYPE_NAME) else: logger.debug("Using existing volume type(s)...") image_id = functest_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME) if image_id == '': logger.debug("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME, \ GLANCE_IMAGE_PATH)) image_id = functest_utils.create_glance_image(glance_client,\ GLANCE_IMAGE_NAME,GLANCE_IMAGE_PATH) if not image_id: logger.error("Failed to create the Glance image...") exit(-1) else: logger.debug("Image '%s' with ID '%s' created succesfully ." \ % (GLANCE_IMAGE_NAME, image_id)) else: logger.debug("Using existing image '%s' with ID '%s'..." \ % (GLANCE_IMAGE_NAME,image_id)) if args.test_name == "all": for test_name in tests: if not (test_name == 'all' or test_name == 'vm'): print(test_name) run_task(test_name) else: print(args.test_name) run_task(args.test_name) logger.debug("Deleting image '%s' with ID '%s'..." \ % (GLANCE_IMAGE_NAME, image_id)) if not functest_utils.delete_glance_image(nova_client, image_id): logger.error("Error deleting the glance image") if not volume_types: logger.debug("Deleting volume type '%s'..." \ % CINDER_VOLUME_TYPE_NAME) if not functest_utils.delete_volume_type(cinder_client, volume_type): logger.error("Error in deleting volume type...") if __name__ == '__main__': main()