import ipaddress
import logging
import os
+import pydoc
import random
import re
import signal
import subprocess
import sys
import time
+import threading
+import math
import six
from flask import jsonify
def get_port_mac(sshclient, port):
cmd = "ifconfig |grep HWaddr |grep %s |awk '{print $5}' " % port
- status, stdout, stderr = sshclient.execute(cmd)
+ _, stdout, _ = sshclient.execute(cmd, raise_on_error=True)
- if status:
- raise RuntimeError(stderr)
return stdout.rstrip()
def get_port_ip(sshclient, port):
cmd = "ifconfig %s |grep 'inet addr' |awk '{print $2}' " \
"|cut -d ':' -f2 " % port
- status, stdout, stderr = sshclient.execute(cmd)
+ _, stdout, _ = sshclient.execute(cmd, raise_on_error=True)
- if status:
- raise RuntimeError(stderr)
return stdout.rstrip()
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)
+ try:
+ octets = ["0x{:02x}".format(int(elem, 16)) for elem in mac.split(':')]
+ except ValueError:
+ raise exceptions.InvalidMacAddress(mac_address=mac)
+ if len(octets) != 6 or all(len(octet) != 4 for octet in octets):
+ raise exceptions.InvalidMacAddress(mac_address=mac)
return octets
+def make_ipv4_address(ip_addr):
+ return ipaddress.IPv4Address(six.text_type(ip_addr))
+
+
+def get_ip_range_count(iprange):
+ start_range, end_range = iprange.split("-")
+ start = int(make_ipv4_address(start_range))
+ end = int(make_ipv4_address(end_range))
+ return end - start
+
+
+def get_ip_range_start(iprange):
+ return str(make_ipv4_address(iprange.split("-")[0]))
+
+
def safe_ip_address(ip_addr):
""" get ip address version v6 or v4 """
try:
def __del__(self): # pragma: no cover
signal.alarm(0)
+ def delta_time_sec(self):
+ return (datetime.datetime.now() - self.start).total_seconds()
+
def read_meminfo(ssh_client):
"""Read "/proc/meminfo" file and parse all keys and values"""
return output
+def setup_hugepages(ssh_client, size_kb):
+ """Setup needed number of hugepages for the size specified"""
+
+ NR_HUGEPAGES_PATH = '/proc/sys/vm/nr_hugepages'
+ meminfo = read_meminfo(ssh_client)
+ hp_size_kb = int(meminfo['Hugepagesize'])
+ hp_number = int(math.ceil(size_kb / float(hp_size_kb)))
+ ssh_client.execute(
+ 'echo %s | sudo tee %s' % (hp_number, NR_HUGEPAGES_PATH))
+ hp = six.BytesIO()
+ ssh_client.get_file_obj(NR_HUGEPAGES_PATH, hp)
+ hp_number_set = int(hp.getvalue().decode('utf-8').splitlines()[0])
+ logger.info('Hugepages size (kB): %s, number claimed: %s, number set: %s',
+ hp_size_kb, hp_number, hp_number_set)
+ return hp_size_kb, hp_number, hp_number_set
+
+
def find_relative_file(path, task_path):
"""
Find file in one of places: in abs of path or relative to a directory path,
def wait_until_true(predicate, timeout=60, sleep=1, exception=None):
"""Wait until callable predicate is evaluated as True
+ When in a thread different from the main one, Timer(timeout) will fail
+ because signal is not handled. In this case
+
:param predicate: (func) callable deciding whether waiting should continue
:param timeout: (int) timeout in seconds how long should function wait
:param sleep: (int) polling interval for results in seconds
:param exception: exception instance to raise on timeout. If None is passed
(default) then WaitTimeout exception is raised.
"""
- try:
- with Timer(timeout=timeout):
- while not predicate():
+ if isinstance(threading.current_thread(), threading._MainThread):
+ try:
+ with Timer(timeout=timeout):
+ while not predicate():
+ time.sleep(sleep)
+ except exceptions.TimerTimeout:
+ if exception and issubclass(exception, Exception):
+ raise exception # pylint: disable=raising-bad-type
+ raise exceptions.WaitTimeout
+ else:
+ with Timer() as timer:
+ while timer.delta_time_sec() < timeout:
+ if predicate():
+ return
time.sleep(sleep)
- except exceptions.TimerTimeout:
if exception and issubclass(exception, Exception):
raise exception # pylint: disable=raising-bad-type
raise exceptions.WaitTimeout
finally:
sock.close()
return ret
+
+
+def safe_cast(value, type_to_convert, default_value):
+ """Convert value to type, in case of error return default_value
+
+ :param value: value to convert
+ :param type_to_convert: type to convert, could be "type" or "string"
+ :param default_value: default value to return
+ :return: converted value or default_value
+ """
+ if isinstance(type_to_convert, type):
+ _type = type_to_convert
+ else:
+ _type = pydoc.locate(type_to_convert)
+ if not _type:
+ raise exceptions.InvalidType(type_to_convert=type_to_convert)
+
+ try:
+ return _type(value)
+ except ValueError:
+ return default_value