X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=yardstick%2Fcommon%2Futils.py;h=f2455be3a7fa014e2e0a791e4e414eb09ed8df99;hb=refs%2Fchanges%2F51%2F38251%2F9;hp=7a64b8ca23d24592274d4dbd4100acee16d29de2;hpb=d29df23ae5057fe0ccded6f8d8f3e36a084a78b3;p=yardstick.git diff --git a/yardstick/common/utils.py b/yardstick/common/utils.py index 7a64b8ca2..f2455be3a 100644 --- a/yardstick/common/utils.py +++ b/yardstick/common/utils.py @@ -18,6 +18,7 @@ from __future__ import absolute_import from __future__ import print_function +import datetime import errno import logging import os @@ -26,7 +27,7 @@ import sys import collections import socket import random -from functools import reduce +import ipaddress from contextlib import closing import yaml @@ -106,19 +107,6 @@ def parse_yaml(file_path): return value -def get_param(key, default=''): - - conf_file = os.environ.get('CONF_FILE', '/etc/yardstick/yardstick.yaml') - - conf = parse_yaml(conf_file) - try: - return reduce(lambda a, b: a[b], key.split('.'), conf) - except KeyError: - if not default: - raise - return default - - def makedirs(d): try: os.makedirs(d) @@ -148,7 +136,7 @@ def source_env(env_file): p = subprocess.Popen(". %s; env" % env_file, stdout=subprocess.PIPE, shell=True) output = p.communicate()[0] - env = dict((line.split('=', 1) for line in output.splitlines())) + env = dict(line.split('=', 1) for line in output.splitlines() if '=' in line) os.environ.update(env) return env @@ -221,12 +209,12 @@ def flatten_dict_key(data): for v in data.values()): return data - for k, v in six.iteritems(data): + for k, v in data.items(): if isinstance(v, collections.Mapping): - for n_k, n_v in six.iteritems(v): + for n_k, n_v in v.items(): next_data["%s.%s" % (k, n_k)] = n_v # use list because iterable is too generic - elif isinstance(v, list): + elif isinstance(v, collections.Iterable) and not isinstance(v, six.string_types): for index, item in enumerate(v): next_data["%s%d" % (k, index)] = item else: @@ -267,7 +255,6 @@ def set_dict_value(dic, keys, value): return_dic = dic for key in keys.split('.'): - return_dic.setdefault(key, {}) if key == keys.split('.')[-1]: return_dic[key] = value @@ -282,3 +269,137 @@ def get_free_port(ip): port = random.randint(5000, 10000) if s.connect_ex((ip, port)) != 0: return port + + +def mac_address_to_hex_list(mac): + octets = ["0x{:02x}".format(int(elem, 16)) for elem in mac.split(':')] + assert len(octets) == 6 and all(len(octet) == 4 for octet in octets) + return octets + + +def safe_ip_address(ip_addr): + """ get ip address version v6 or v4 """ + try: + return ipaddress.ip_address(six.text_type(ip_addr)) + except ValueError: + logging.error("%s is not valid", ip_addr) + return None + + +def get_ip_version(ip_addr): + """ get ip address version v6 or v4 """ + try: + address = ipaddress.ip_address(six.text_type(ip_addr)) + except ValueError: + logging.error("%s is not valid", ip_addr) + return None + else: + return address.version + + +def ip_to_hex(ip_addr, separator=''): + try: + address = ipaddress.ip_address(six.text_type(ip_addr)) + except ValueError: + logging.error("%s is not valid", ip_addr) + return ip_addr + + if address.version != 4: + return ip_addr + + if not separator: + return '{:08x}'.format(int(address)) + + return separator.join('{:02x}'.format(octet) for octet in address.packed) + + +def try_int(s, *args): + """Convert to integer if possible.""" + try: + return int(s) + except (TypeError, ValueError): + return args[0] if args else s + + +class SocketTopology(dict): + + @classmethod + def parse_cpuinfo(cls, cpuinfo): + socket_map = {} + + lines = cpuinfo.splitlines() + + core_details = [] + core_lines = {} + for line in lines: + if line.strip(): + name, value = line.split(":", 1) + core_lines[name.strip()] = try_int(value.strip()) + else: + core_details.append(core_lines) + core_lines = {} + + for core in core_details: + socket_map.setdefault(core["physical id"], {}).setdefault( + core["core id"], {})[core["processor"]] = ( + core["processor"], core["core id"], core["physical id"]) + + return cls(socket_map) + + def sockets(self): + return sorted(self.keys()) + + def cores(self): + return sorted(core for cores in self.values() for core in cores) + + def processors(self): + return sorted( + proc for cores in self.values() for procs in cores.values() for + proc in procs) + + +def config_to_dict(config): + return {section: dict(config.items(section)) for section in + config.sections()} + + +def validate_non_string_sequence(value, default=None, raise_exc=None): + if isinstance(value, collections.Sequence) and not isinstance(value, str): + return value + if raise_exc: + raise raise_exc + return default + + +def join_non_strings(separator, *non_strings): + try: + non_strings = validate_non_string_sequence(non_strings[0], raise_exc=RuntimeError) + except (IndexError, RuntimeError): + pass + return str(separator).join(str(non_string) for non_string in non_strings) + + +class ErrorClass(object): + + def __init__(self, *args, **kwargs): + if 'test' not in kwargs: + raise RuntimeError + + def __getattr__(self, item): + raise AttributeError + + +class Timer(object): + def __init__(self): + super(Timer, self).__init__() + self.start = self.delta = None + + def __enter__(self): + self.start = datetime.datetime.now() + return self + + def __exit__(self, *_): + self.delta = datetime.datetime.now() - self.start + + def __getattr__(self, item): + return getattr(self.delta, item)