def verify_required_params(required_params, actual_params):
error_messages = []
for required_key, key_info in required_params.iteritems():
expected_type = key_info[0]
expected_value = key_info[1]
optional = len(key_info) == 3 and key_info[2] is False
if required_key not in actual_params:
error_messages.append('Missing required param "{0}"'.format(required_key))
continue
actual_value = actual_params[required_key]
if HelperToolbox.check_type(actual_value, expected_type)[0] is False:
error_messages.append('Required param "{0}" is of type "{1}" but we expected type "{2}"'.format(required_key, type(actual_value), expected_type))
continue
if expected_value is None or (optional is True and actual_value in ('', None)):
continue
if expected_type == list:
if type(expected_value) == Toolbox.compiled_regex_type: # List of strings which need to match regex
for item in actual_value:
if not re.match(expected_value, item):
error_messages.append('Required param "{0}" has an item "{1}" which does not match regex "{2}"'.format(required_key, item, expected_value.pattern))
else:
if HelperToolbox.check_type(expected_value, list)[0] is True and actual_value not in expected_value:
error_messages.append('Required param "{0}" with value "{1}" should be 1 of the following: {2}'.format(required_key, actual_value, expected_value))
elif HelperToolbox.check_type(expected_value, Toolbox.compiled_regex_type)[0] is True and not re.match(expected_value, actual_value):
error_messages.append('Required param "{0}" with value "{1}" does not match regex "{2}"'.format(required_key, actual_value, expected_value.pattern))
if error_messages:
raise RuntimeError('\n' + '\n'.join(error_messages))
def verify_required_params(required_params, actual_params, exact_match=False):
"""
Verify whether the actual parameters match the required parameters
:param required_params: Required parameters which actual parameters have to meet
:param actual_params: Actual parameters to check for validity
:param exact_match: Keys of both dictionaries must be identical
:return: None
"""
error_messages = []
if not isinstance(required_params, dict) or not isinstance(actual_params, dict):
raise RuntimeError('Required and actual parameters must be of type dictionary')
if exact_match is True:
for key in set(actual_params.keys()).difference(required_params.keys()):
error_messages.append('Missing key "{0}" in required_params'.format(key))
for required_key, key_info in required_params.iteritems():
expected_type = key_info[0]
expected_value = key_info[1]
optional = len(key_info) == 3 and key_info[2] is False
if optional is True and (required_key not in actual_params or actual_params[required_key] in ('', None)):
continue
if required_key not in actual_params:
error_messages.append('Missing required param "{0}" in actual parameters'.format(required_key))
continue
actual_value = actual_params[required_key]
if HelperToolbox.check_type(actual_value, expected_type)[0] is False:
error_messages.append('Required param "{0}" is of type "{1}" but we expected type "{2}"'.format(required_key, type(actual_value), expected_type))
continue
if expected_value is None:
continue
if expected_type == list:
if type(expected_value) == Toolbox.compiled_regex_type: # List of strings which need to match regex
for item in actual_value:
if not re.match(expected_value, item):
error_messages.append('Required param "{0}" has an item "{1}" which does not match regex "{2}"'.format(required_key, item, expected_value.pattern))
elif expected_type == dict:
Toolbox.verify_required_params(expected_value, actual_params[required_key])
elif expected_type == int:
if isinstance(expected_value, list) and actual_value not in expected_value:
error_messages.append('Required param "{0}" with value "{1}" should be 1 of the following: {2}'.format(required_key, actual_value, expected_value))
if isinstance(expected_value, dict):
minimum = expected_value.get('min', sys.maxint * -1)
maximum = expected_value.get('max', sys.maxint)
if not minimum <= actual_value <= maximum:
error_messages.append('Required param "{0}" with value "{1}" should be in range: {2} - {3}'.format(required_key, actual_value, minimum, maximum))
else:
if HelperToolbox.check_type(expected_value, list)[0] is True and actual_value not in expected_value:
error_messages.append('Required param "{0}" with value "{1}" should be 1 of the following: {2}'.format(required_key, actual_value, expected_value))
elif HelperToolbox.check_type(expected_value, Toolbox.compiled_regex_type)[0] is True and not re.match(expected_value, actual_value):
error_messages.append('Required param "{0}" with value "{1}" does not match regex "{2}"'.format(required_key, actual_value, expected_value.pattern))
if error_messages:
raise RuntimeError('\n' + '\n'.join(error_messages))
def verify_required_params(required_params, actual_params):
error_messages = []
for required_key, key_info in required_params.iteritems():
expected_type = key_info[0]
expected_value = key_info[1]
optional = len(key_info) == 3 and key_info[2] is False
if required_key not in actual_params:
error_messages.append(
'Missing required param "{0}"'.format(required_key))
continue
actual_value = actual_params[required_key]
if HelperToolbox.check_type(actual_value,
expected_type)[0] is False:
error_messages.append(
'Required param "{0}" is of type "{1}" but we expected type "{2}"'
.format(required_key, type(actual_value), expected_type))
continue
if expected_value is None or (optional is True
and actual_value in ('', None)):
continue
if expected_type == list:
if type(
expected_value
) == Toolbox.compiled_regex_type: # List of strings which need to match regex
for item in actual_value:
if not re.match(expected_value, item):
error_messages.append(
'Required param "{0}" has an item "{1}" which does not match regex "{2}"'
.format(required_key, item,
expected_value.pattern))
else:
if HelperToolbox.check_type(
expected_value, list
)[0] is True and actual_value not in expected_value:
error_messages.append(
'Required param "{0}" with value "{1}" should be 1 of the following: {2}'
.format(required_key, actual_value, expected_value))
elif HelperToolbox.check_type(
expected_value, Toolbox.compiled_regex_type
)[0] is True and not re.match(expected_value, actual_value):
error_messages.append(
'Required param "{0}" with value "{1}" does not match regex "{2}"'
.format(required_key, actual_value,
expected_value.pattern))
if error_messages:
raise RuntimeError('\n' + '\n'.join(error_messages))
def _backend_property(self, function, dynamic):
"""
Handles the internal caching of dynamic properties
"""
caller_name = dynamic.name
cache_key = '{0}_{1}'.format(self._key, caller_name)
mutex = volatile_mutex(cache_key)
try:
cached_data = self._volatile.get(cache_key)
if cached_data is None:
if dynamic.locked:
mutex.acquire()
cached_data = self._volatile.get(cache_key)
if cached_data is None:
function_info = inspect.getargspec(function)
if 'dynamic' in function_info.args:
cached_data = function(dynamic=dynamic) # Load data from backend
else:
cached_data = function()
if cached_data is not None:
correct, allowed_types, given_type = Toolbox.check_type(cached_data, dynamic.return_type)
if not correct:
raise TypeError('Dynamic property {0} allows types {1}. {2} given'.format(
caller_name, str(allowed_types), given_type
))
if dynamic.timeout > 0:
self._volatile.set(cache_key, cached_data, dynamic.timeout)
return cached_data
finally:
mutex.release()
def _backend_property(self, function, dynamic):
"""
Handles the internal caching of dynamic properties
"""
caller_name = dynamic.name
cache_key = '{0}_{1}'.format(self._key, caller_name)
mutex = VolatileMutex(cache_key)
try:
cached_data = self._volatile.get(cache_key)
if cached_data is None:
if dynamic.locked:
mutex.acquire()
cached_data = self._volatile.get(cache_key)
if cached_data is None:
function_info = inspect.getargspec(function)
if 'dynamic' in function_info.args:
cached_data = function(dynamic=dynamic) # Load data from backend
else:
cached_data = function()
if cached_data is not None:
correct, allowed_types, given_type = Toolbox.check_type(cached_data, dynamic.return_type)
if not correct:
raise TypeError('Dynamic property {0} allows types {1}. {2} given'.format(
caller_name, str(allowed_types), given_type
))
if dynamic.timeout > 0:
self._volatile.set(cache_key, cached_data, dynamic.timeout)
return cached_data
finally:
mutex.release()
def _set_property(self, prop, value):
"""
Setter for a simple property that will validate the type
"""
self.dirty = True
if value is None:
self._data[prop.name] = value
else:
correct, allowed_types, given_type = Toolbox.check_type(value, prop.property_type)
if correct:
self._data[prop.name] = value
else:
raise TypeError('Property {0} allows types {1}. {2} given'.format(
prop.name, str(allowed_types), given_type
))
def _set_property(self, prop, value):
"""
Setter for a simple property that will validate the type
"""
self.dirty = True
if value is None:
self._data[prop.name] = value
else:
correct, allowed_types, given_type = Toolbox.check_type(value, prop.property_type)
if correct:
self._data[prop.name] = value
else:
raise TypeError('Property {0} allows types {1}. {2} given'.format(
prop.name, str(allowed_types), given_type
))
def verify_required_params(required_params, actual_params):
"""
Verify whether the actual parameters match the required parameters
:param required_params: Required parameters which actual parameters have to meet
:param actual_params: Actual parameters to check for validity
:return: None
"""
error_messages = []
for required_key, key_info in required_params.iteritems():
expected_type = key_info[0]
expected_value = key_info[1]
optional = len(key_info) == 3 and key_info[2] is False
if optional is True and (required_key not in actual_params
or actual_params[required_key]
in ('', None)):
continue
if required_key not in actual_params:
error_messages.append(
'Missing required param "{0}"'.format(required_key))
continue
actual_value = actual_params[required_key]
if HelperToolbox.check_type(actual_value,
expected_type)[0] is False:
error_messages.append(
'Required param "{0}" is of type "{1}" but we expected type "{2}"'
.format(required_key, type(actual_value), expected_type))
continue
if expected_value is None:
continue
if expected_type == list:
if type(
expected_value
) == Toolbox.compiled_regex_type: # List of strings which need to match regex
for item in actual_value:
if not re.match(expected_value, item):
error_messages.append(
'Required param "{0}" has an item "{1}" which does not match regex "{2}"'
.format(required_key, item,
expected_value.pattern))
elif expected_type == dict:
Toolbox.verify_required_params(expected_value,
actual_params[required_key])
elif expected_type == int:
if isinstance(expected_value,
list) and actual_value not in expected_value:
error_messages.append(
'Required param "{0}" with value "{1}" should be 1 of the following: {2}'
.format(required_key, actual_value, expected_value))
if isinstance(expected_value, dict):
minimum = expected_value.get('min', sys.maxint * -1)
maximum = expected_value.get('max', sys.maxint)
if not minimum <= actual_value <= maximum:
error_messages.append(
'Required param "{0}" with value "{1}" should be in range: {2} - {3}'
.format(required_key, actual_value, minimum,
maximum))
else:
if HelperToolbox.check_type(
expected_value, list
)[0] is True and actual_value not in expected_value:
error_messages.append(
'Required param "{0}" with value "{1}" should be 1 of the following: {2}'
.format(required_key, actual_value, expected_value))
elif HelperToolbox.check_type(
expected_value, Toolbox.compiled_regex_type
)[0] is True and not re.match(expected_value, actual_value):
error_messages.append(
'Required param "{0}" with value "{1}" does not match regex "{2}"'
.format(required_key, actual_value,
expected_value.pattern))
if error_messages:
raise RuntimeError('\n' + '\n'.join(error_messages))
def verify_required_params(required_params, actual_params):
error_messages = []
for required_key, key_info in required_params.iteritems():
expected_type = key_info[0]
expected_value = key_info[1]
optional = len(key_info) == 3 and key_info[2] is False
if optional is True and (required_key not in actual_params or actual_params[required_key] in ("", None)):
continue
if required_key not in actual_params:
error_messages.append('Missing required param "{0}"'.format(required_key))
continue
actual_value = actual_params[required_key]
if HelperToolbox.check_type(actual_value, expected_type)[0] is False:
error_messages.append(
'Required param "{0}" is of type "{1}" but we expected type "{2}"'.format(
required_key, type(actual_value), expected_type
)
)
continue
if expected_value is None:
continue
if expected_type == list:
if type(expected_value) == Toolbox.compiled_regex_type: # List of strings which need to match regex
for item in actual_value:
if not re.match(expected_value, item):
error_messages.append(
'Required param "{0}" has an item "{1}" which does not match regex "{2}"'.format(
required_key, item, expected_value.pattern
)
)
elif expected_type == dict:
Toolbox.verify_required_params(expected_value, actual_params[required_key])
elif expected_type == int:
if isinstance(expected_value, list) and actual_value not in expected_value:
error_messages.append(
'Required param "{0}" with value "{1}" should be 1 of the following: {2}'.format(
required_key, actual_value, expected_value
)
)
if isinstance(expected_value, dict):
minimum = expected_value.get("min", sys.maxint * -1)
maximum = expected_value.get("max", sys.maxint)
if not minimum <= actual_value <= maximum:
error_messages.append(
'Required param "{0}" with value "{1}" should be in range: {2} - {3}'.format(
required_key, actual_value, minimum, maximum
)
)
else:
if HelperToolbox.check_type(expected_value, list)[0] is True and actual_value not in expected_value:
error_messages.append(
'Required param "{0}" with value "{1}" should be 1 of the following: {2}'.format(
required_key, actual_value, expected_value
)
)
elif HelperToolbox.check_type(expected_value, Toolbox.compiled_regex_type)[0] is True and not re.match(
expected_value, actual_value
):
error_messages.append(
'Required param "{0}" with value "{1}" does not match regex "{2}"'.format(
required_key, actual_value, expected_value.pattern
)
)
if error_messages:
raise RuntimeError("\n" + "\n".join(error_messages))
