summaryrefslogtreecommitdiffstats
path: root/compass-tasks/db/api/utils.py
diff options
context:
space:
mode:
Diffstat (limited to 'compass-tasks/db/api/utils.py')
-rw-r--r--compass-tasks/db/api/utils.py1286
1 files changed, 0 insertions, 1286 deletions
diff --git a/compass-tasks/db/api/utils.py b/compass-tasks/db/api/utils.py
deleted file mode 100644
index a44f26e..0000000
--- a/compass-tasks/db/api/utils.py
+++ /dev/null
@@ -1,1286 +0,0 @@
-# Copyright 2014 Huawei Technologies Co. Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Utils for database usage."""
-
-import functools
-import inspect
-import logging
-import netaddr
-import re
-
-from inspect import isfunction
-from sqlalchemy import and_
-from sqlalchemy import or_
-
-from compass.db import exception
-from compass.db import models
-from compass.utils import util
-
-
-def model_query(session, model):
- """model query.
-
- Return sqlalchemy query object.
- """
- if not issubclass(model, models.BASE):
- raise exception.DatabaseException("model should be sublass of BASE!")
-
- return session.query(model)
-
-
-def _default_list_condition_func(col_attr, value, condition_func):
- """The default condition func for a list of data.
-
- Given the condition func for single item of data, this function
- wrap the condition_func and return another condition func using
- or_ to merge the conditions of each single item to deal with a
- list of data item.
-
- Args:
- col_attr: the colomn name
- value: the column value need to be compared.
- condition_func: the sqlalchemy condition object like ==
-
- Examples:
- col_attr is name, value is ['a', 'b', 'c'] and
- condition_func is ==, the returned condition is
- name == 'a' or name == 'b' or name == 'c'
- """
- conditions = []
- for sub_value in value:
- condition = condition_func(col_attr, sub_value)
- if condition is not None:
- conditions.append(condition)
- if conditions:
- return or_(*conditions)
- else:
- return None
-
-
-def _one_item_list_condition_func(col_attr, value, condition_func):
- """The wrapper condition func to deal with one item data list.
-
- For simplification, it is used to reduce generating too complex
- sql conditions.
- """
- if value:
- return condition_func(col_attr, value[0])
- else:
- return None
-
-
-def _model_condition_func(
- col_attr, value,
- item_condition_func,
- list_condition_func=_default_list_condition_func
-):
- """Return sql condition based on value type."""
- if isinstance(value, list):
- if not value:
- return None
- if len(value) == 1:
- return item_condition_func(col_attr, value)
- return list_condition_func(
- col_attr, value, item_condition_func
- )
- else:
- return item_condition_func(col_attr, value)
-
-
-def _between_condition(col_attr, value):
- """Return sql range condition."""
- if value[0] is not None and value[1] is not None:
- return col_attr.between(value[0], value[1])
- if value[0] is not None:
- return col_attr >= value[0]
- if value[1] is not None:
- return col_attr <= value[1]
- return None
-
-
-def model_order_by(query, model, order_by):
- """append order by into sql query model."""
- if not order_by:
- return query
- order_by_cols = []
- for key in order_by:
- if isinstance(key, tuple):
- key, is_desc = key
- else:
- is_desc = False
- if isinstance(key, basestring):
- if hasattr(model, key):
- col_attr = getattr(model, key)
- else:
- continue
- else:
- col_attr = key
- if is_desc:
- order_by_cols.append(col_attr.desc())
- else:
- order_by_cols.append(col_attr)
- return query.order_by(*order_by_cols)
-
-
-def _model_condition(col_attr, value):
- """Generate condition for one column.
-
- Example for col_attr is name:
- value is 'a': name == 'a'
- value is ['a']: name == 'a'
- value is ['a', 'b']: name == 'a' or name == 'b'
- value is {'eq': 'a'}: name == 'a'
- value is {'lt': 'a'}: name < 'a'
- value is {'le': 'a'}: name <= 'a'
- value is {'gt': 'a'}: name > 'a'
- value is {'ge': 'a'}: name >= 'a'
- value is {'ne': 'a'}: name != 'a'
- value is {'in': ['a', 'b']}: name in ['a', 'b']
- value is {'notin': ['a', 'b']}: name not in ['a', 'b']
- value is {'startswith': 'abc'}: name like 'abc%'
- value is {'endswith': 'abc'}: name like '%abc'
- value is {'like': 'abc'}: name like '%abc%'
- value is {'between': ('a', 'c')}: name >= 'a' and name <= 'c'
- value is [{'lt': 'a'}]: name < 'a'
- value is [{'lt': 'a'}, {'gt': c'}]: name < 'a' or name > 'c'
- value is {'lt': 'c', 'gt': 'a'}: name > 'a' and name < 'c'
-
- If value is a list, the condition is the or relationship among
- conditions of each item.
- If value is dict and there are multi keys in the dict, the relationship
- is and conditions of each key.
- Otherwise the condition is to compare the column with the value.
- """
- if isinstance(value, list):
- basetype_values = []
- composite_values = []
- for item in value:
- if isinstance(item, (list, dict)):
- composite_values.append(item)
- else:
- basetype_values.append(item)
- conditions = []
- if basetype_values:
- if len(basetype_values) == 1:
- condition = (col_attr == basetype_values[0])
- else:
- condition = col_attr.in_(basetype_values)
- conditions.append(condition)
- for composite_value in composite_values:
- condition = _model_condition(col_attr, composite_value)
- if condition is not None:
- conditions.append(condition)
- if not conditions:
- return None
- if len(conditions) == 1:
- return conditions[0]
- return or_(*conditions)
- elif isinstance(value, dict):
- conditions = []
- if 'eq' in value:
- conditions.append(_model_condition_func(
- col_attr, value['eq'],
- lambda attr, data: attr == data,
- lambda attr, data, item_condition_func: attr.in_(data)
- ))
- if 'lt' in value:
- conditions.append(_model_condition_func(
- col_attr, value['lt'],
- lambda attr, data: attr < data,
- _one_item_list_condition_func
- ))
- if 'gt' in value:
- conditions.append(_model_condition_func(
- col_attr, value['gt'],
- lambda attr, data: attr > data,
- _one_item_list_condition_func
- ))
- if 'le' in value:
- conditions.append(_model_condition_func(
- col_attr, value['le'],
- lambda attr, data: attr <= data,
- _one_item_list_condition_func
- ))
- if 'ge' in value:
- conditions.append(_model_condition_func(
- col_attr, value['ge'],
- lambda attr, data: attr >= data,
- _one_item_list_condition_func
- ))
- if 'ne' in value:
- conditions.append(_model_condition_func(
- col_attr, value['ne'],
- lambda attr, data: attr != data,
- lambda attr, data, item_condition_func: attr.notin_(data)
- ))
- if 'in' in value:
- conditions.append(col_attr.in_(value['in']))
- if 'notin' in value:
- conditions.append(col_attr.notin_(value['notin']))
- if 'startswith' in value:
- conditions.append(_model_condition_func(
- col_attr, value['startswith'],
- lambda attr, data: attr.like('%s%%' % data)
- ))
- if 'endswith' in value:
- conditions.append(_model_condition_func(
- col_attr, value['endswith'],
- lambda attr, data: attr.like('%%%s' % data)
- ))
- if 'like' in value:
- conditions.append(_model_condition_func(
- col_attr, value['like'],
- lambda attr, data: attr.like('%%%s%%' % data)
- ))
- if 'between' in value:
- conditions.append(_model_condition_func(
- col_attr, value['between'],
- _between_condition
- ))
- conditions = [
- condition
- for condition in conditions
- if condition is not None
- ]
- if not conditions:
- return None
- if len(conditions) == 1:
- return conditions[0]
- return and_(conditions)
- else:
- condition = (col_attr == value)
- return condition
-
-
-def model_filter(query, model, **filters):
- """Append conditons to query for each possible column."""
- for key, value in filters.items():
- if isinstance(key, basestring):
- if hasattr(model, key):
- col_attr = getattr(model, key)
- else:
- continue
- else:
- col_attr = key
- condition = _model_condition(col_attr, value)
- if condition is not None:
- query = query.filter(condition)
- return query
-
-
-def replace_output(**output_mapping):
- """Decorator to recursively relace output by output mapping.
-
- The replacement detail is described in _replace_output.
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- return _replace_output(
- func(*args, **kwargs), **output_mapping
- )
- return wrapper
- return decorator
-
-
-def _replace_output(data, **output_mapping):
- """Helper to replace output data.
-
- Example:
- data = {'a': 'hello'}
- output_mapping = {'a': 'b'}
- returns: {'b': 'hello'}
-
- data = {'a': {'b': 'hello'}}
- output_mapping = {'a': 'b'}
- returns: {'b': {'b': 'hello'}}
-
- data = {'a': {'b': 'hello'}}
- output_mapping = {'a': {'b': 'c'}}
- returns: {'a': {'c': 'hello'}}
-
- data = [{'a': 'hello'}, {'a': 'hi'}]
- output_mapping = {'a': 'b'}
- returns: [{'b': 'hello'}, {'b': 'hi'}]
- """
- if isinstance(data, list):
- return [
- _replace_output(item, **output_mapping)
- for item in data
- ]
- if not isinstance(data, dict):
- raise exception.InvalidResponse(
- '%s type is not dict' % data
- )
- info = {}
- for key, value in data.items():
- if key in output_mapping:
- output_key = output_mapping[key]
- if isinstance(output_key, basestring):
- info[output_key] = value
- else:
- info[key] = (
- _replace_output(value, **output_key)
- )
- else:
- info[key] = value
- return info
-
-
-def get_wrapped_func(func):
- """Get wrapped function instance.
-
- Example:
- @dec1
- @dec2
- myfunc(*args, **kwargs)
-
- get_wrapped_func(myfunc) returns function object with
- following attributes:
- __name__: 'myfunc'
- args: args
- kwargs: kwargs
- otherwise myfunc is function object with following attributes:
- __name__: partial object ...
- args: ...
- kwargs: ...
- """
- if func.func_closure:
- for closure in func.func_closure:
- if isfunction(closure.cell_contents):
- return get_wrapped_func(closure.cell_contents)
- return func
- else:
- return func
-
-
-def wrap_to_dict(support_keys=[], **filters):
- """Decrator to convert returned object to dict.
-
- The details is decribed in _wrapper_dict.
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- return _wrapper_dict(
- func(*args, **kwargs), support_keys, **filters
- )
- return wrapper
- return decorator
-
-
-def _wrapper_dict(data, support_keys, **filters):
- """Helper for warpping db object into dictionary.
-
- If data is list, convert it to a list of dict
- If data is Base model, convert it to dict
- for the data as a dict, filter it with the supported keys.
- For each filter_key, filter_value in filters, also filter
- data[filter_key] by filter_value recursively if it exists.
-
- Example:
- data is models.Switch, it will be converted to
- {
- 'id': 1, 'ip': '10.0.0.1', 'ip_int': 123456,
- 'credentials': {'version': 2, 'password': 'abc'}
- }
- Then if support_keys are ['id', 'ip', 'credentials'],
- it will be filtered to {
- 'id': 1, 'ip': '10.0.0.1',
- 'credentials': {'version': 2, 'password': 'abc'}
- }
- Then if filters is {'credentials': ['version']},
- it will be filtered to {
- 'id': 1, 'ip': '10.0.0.1',
- 'credentials': {'version': 2}
- }
- """
- logging.debug(
- 'wrap dict %s by support_keys=%s filters=%s',
- data, support_keys, filters
- )
- if isinstance(data, list):
- return [
- _wrapper_dict(item, support_keys, **filters)
- for item in data
- ]
- if isinstance(data, models.HelperMixin):
- data = data.to_dict()
- if not isinstance(data, dict):
- raise exception.InvalidResponse(
- 'response %s type is not dict' % data
- )
- info = {}
- try:
- for key in support_keys:
- if key in data and data[key] is not None:
- if key in filters:
- filter_keys = filters[key]
- if isinstance(filter_keys, dict):
- info[key] = _wrapper_dict(
- data[key], filter_keys.keys(),
- **filter_keys
- )
- else:
- info[key] = _wrapper_dict(
- data[key], filter_keys
- )
- else:
- info[key] = data[key]
- return info
- except Exception as error:
- logging.exception(error)
- raise error
-
-
-def replace_filters(**kwarg_mapping):
- """Decorator to replace kwargs.
-
- Examples:
- kwargs: {'a': 'b'}, kwarg_mapping: {'a': 'c'}
- replaced kwargs to decorated func:
- {'c': 'b'}
-
- replace_filters is used to replace caller's input
- to make it understandable by models.py.
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- replaced_kwargs = {}
- for key, value in kwargs.items():
- if key in kwarg_mapping:
- replaced_kwargs[kwarg_mapping[key]] = value
- else:
- replaced_kwargs[key] = value
- return func(*args, **replaced_kwargs)
- return wrapper
- return decorator
-
-
-def supported_filters(
- support_keys=[],
- optional_support_keys=[],
- ignore_support_keys=[],
-):
- """Decorator to check kwargs keys.
-
- keys in kwargs and in ignore_support_keys will be removed.
- If any unsupported keys found, a InvalidParameter
- exception raises.
-
- Args:
- support_keys: keys that must exist.
- optional_support_keys: keys that may exist.
- ignore_support_keys: keys should be ignored.
-
- Assumption: args without default value is supposed to exist.
- You can add them in support_keys or not but we will make sure
- it appears when we call the decorated function.
- We do best match on both args and kwargs to make sure if the
- key appears or not.
-
- Examples:
- decorated func: func(a, b, c=3, d=4, **kwargs)
-
- support_keys=['e'] and call func(e=5):
- raises: InvalidParameter: missing declared arg
- support_keys=['e'] and call func(1,2,3,4,5,e=6):
- raises: InvalidParameter: caller sending more args
- support_keys=['e'] and call func(1,2):
- raises: InvalidParameter: supported keys ['e'] missing
- support_keys=['d', 'e'] and call func(1,2,e=3):
- raises: InvalidParameter: supported keys ['d'] missing
- support_keys=['d', 'e'] and call func(1,2,d=4, e=3):
- passed
- support_keys=['d'], optional_support_keys=['e']
- and call func(1,2, d=3):
- passed
- support_keys=['d'], optional_support_keys=['e']
- and call func(1,2, d=3, e=4, f=5):
- raises: InvalidParameter: unsupported keys ['f']
- support_keys=['d'], optional_support_keys=['e'],
- ignore_support_keys=['f']
- and call func(1,2, d=3, e=4, f=5):
- passed to decorated keys: func(1,2, d=3, e=4)
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **filters):
- wrapped_func = get_wrapped_func(func)
- argspec = inspect.getargspec(wrapped_func)
- wrapped_args = argspec.args
- args_defaults = argspec.defaults
- # wrapped_must_args are positional args caller must pass in.
- if args_defaults:
- wrapped_must_args = wrapped_args[:-len(args_defaults)]
- else:
- wrapped_must_args = wrapped_args[:]
- # make sure any positional args without default value in
- # decorated function should appear in args or filters.
- if len(args) < len(wrapped_must_args):
- remain_args = wrapped_must_args[len(args):]
- for remain_arg in remain_args:
- if remain_arg not in filters:
- raise exception.InvalidParameter(
- 'function missing declared arg %s '
- 'while caller sends args %s' % (
- remain_arg, args
- )
- )
- # make sure args should be no more than positional args
- # declared in decorated function.
- if len(args) > len(wrapped_args):
- raise exception.InvalidParameter(
- 'function definition args %s while the caller '
- 'sends args %s' % (
- wrapped_args, args
- )
- )
- # exist_args are positional args caller has given.
- exist_args = dict(zip(wrapped_args, args)).keys()
- must_support_keys = set(support_keys)
- all_support_keys = must_support_keys | set(optional_support_keys)
- wrapped_supported_keys = set(filters) | set(exist_args)
- unsupported_keys = (
- set(filters) - set(wrapped_args) -
- all_support_keys - set(ignore_support_keys)
- )
- # unsupported_keys are the keys that are not in support_keys,
- # optional_support_keys, ignore_support_keys and are not passed in
- # by positional args. It means the decorated function may
- # not understand these parameters.
- if unsupported_keys:
- raise exception.InvalidParameter(
- 'filter keys %s are not supported for %s' % (
- list(unsupported_keys), wrapped_func
- )
- )
- # missing_keys are the keys that must exist but missing in
- # both positional args or kwargs.
- missing_keys = must_support_keys - wrapped_supported_keys
- if missing_keys:
- raise exception.InvalidParameter(
- 'filter keys %s not found for %s' % (
- list(missing_keys), wrapped_func
- )
- )
- # We filter kwargs to eliminate ignore_support_keys in kwargs
- # passed to decorated function.
- filtered_filters = dict([
- (key, value)
- for key, value in filters.items()
- if key not in ignore_support_keys
- ])
- return func(*args, **filtered_filters)
- return wrapper
- return decorator
-
-
-def input_filters(
- **filters
-):
- """Decorator to filter kwargs.
-
- For key in kwargs, if the key exists and filters
- and the return of call filters[key] is False, the key
- will be removed from kwargs.
-
- The function definition of filters[key] is
- func(value, *args, **kwargs) compared with decorated
- function func(*args, **kwargs)
-
- The function is used to filter kwargs in case some
- kwargs should be removed conditionally depends on the
- related filters.
-
- Examples:
- filters={'a': func(value, *args, **kwargs)}
- @input_filters(**filters)
- decorated_func(*args, **kwargs)
- func returns False.
- Then when call decorated_func(a=1, b=2)
- it will be actually called the decorated func with
- b=2. a=1 will be removed since it does not pass filtering.
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- filtered_kwargs = {}
- for key, value in kwargs.items():
- if key in filters:
- if filters[key](value, *args, **kwargs):
- filtered_kwargs[key] = value
- else:
- logging.debug(
- 'ignore filtered input key %s' % key
- )
- else:
- filtered_kwargs[key] = value
- return func(*args, **filtered_kwargs)
- return wrapper
- return decorator
-
-
-def _obj_equal_or_subset(check, obj):
- """Used by output filter to check if obj is in check."""
- if check == obj:
- return True
- if not issubclass(obj.__class__, check.__class__):
- return False
- if isinstance(obj, dict):
- return _dict_equal_or_subset(check, obj)
- elif isinstance(obj, list):
- return _list_equal_or_subset(check, obj)
- else:
- return False
-
-
-def _list_equal_or_subset(check_list, obj_list):
- """Used by output filter to check if obj_list is in check_list"""
- if not isinstance(check_list, list):
- return False
- return set(check_list).issubset(set(obj_list))
-
-
-def _dict_equal_or_subset(check_dict, obj_dict):
- """Used by output filter to check if obj_dict in check_dict."""
- if not isinstance(check_dict, dict):
- return False
- for key, value in check_dict.items():
- if (
- key not in obj_dict or
- not _obj_equal_or_subset(check_dict[key], obj_dict[key])
- ):
- return False
- return True
-
-
-def general_filter_callback(general_filter, obj):
- """General filter function to filter output.
-
- Since some fields stored in database is json encoded and
- we want to do the deep match for the json encoded field to
- do the filtering in some cases, we introduces the output_filters
- and general_filter_callback to deal with this kind of cases.
-
- We do special treatment for key 'resp_eq' to check if
- obj is the recursively subset of general_filter['resp_eq']
-
-
- Example:
- obj: 'b'
- general_filter: {}
- returns: True
-
- obj: 'b'
- general_filter: {'resp_in': ['a', 'b']}
- returns: True
-
- obj: 'b'
- general_filter: {'resp_in': ['a']}
- returns: False
-
- obj: 'b'
- general_filter: {'resp_eq': 'b'}
- returns: True
-
- obj: 'b'
- general_filter: {'resp_eq': 'a'}
- returns: False
-
- obj: 'b'
- general_filter: {'resp_range': ('a', 'c')}
- returns: True
-
- obj: 'd'
- general_filter: {'resp_range': ('a', 'c')}
- returns: False
-
- If there are multi keys in dict, the output is filtered
- by and relationship.
-
- If the general_filter is a list, the output is filtered
- by or relationship.
-
- Supported general filters: [
- 'resp_eq', 'resp_in', 'resp_lt',
- 'resp_le', 'resp_gt', 'resp_ge',
- 'resp_match', 'resp_range'
- ]
- """
- if isinstance(general_filter, list):
- if not general_filter:
- return True
- return any([
- general_filter_callback(item, obj)
- for item in general_filter
- ])
- elif isinstance(general_filter, dict):
- if 'resp_eq' in general_filter:
- if not _obj_equal_or_subset(
- general_filter['resp_eq'], obj
- ):
- return False
- if 'resp_in' in general_filter:
- in_filters = general_filter['resp_in']
- if not any([
- _obj_equal_or_subset(in_filer, obj)
- for in_filer in in_filters
- ]):
- return False
- if 'resp_lt' in general_filter:
- if obj >= general_filter['resp_lt']:
- return False
- if 'resp_le' in general_filter:
- if obj > general_filter['resp_le']:
- return False
- if 'resp_gt' in general_filter:
- if obj <= general_filter['resp_gt']:
- return False
- if 'resp_ge' in general_filter:
- if obj < general_filter['resp_gt']:
- return False
- if 'resp_match' in general_filter:
- if not re.match(general_filter['resp_match'], obj):
- return False
- if 'resp_range' in general_filter:
- resp_range = general_filter['resp_range']
- if not isinstance(resp_range, list):
- resp_range = [resp_range]
- in_range = False
- for range_start, range_end in resp_range:
- if range_start <= obj <= range_end:
- in_range = True
- if not in_range:
- return False
- return True
- else:
- return True
-
-
-def filter_output(filter_callbacks, kwargs, obj, missing_ok=False):
- """Filter ouput.
-
- For each key in filter_callbacks, if it exists in kwargs,
- kwargs[key] tells what we need to filter. If the call of
- filter_callbacks[key] returns False, it tells the obj should be
- filtered out of output.
- """
- for callback_key, callback_value in filter_callbacks.items():
- if callback_key not in kwargs:
- continue
- if callback_key not in obj:
- if missing_ok:
- continue
- else:
- raise exception.InvalidResponse(
- '%s is not in %s' % (callback_key, obj)
- )
- if not callback_value(
- kwargs[callback_key], obj[callback_key]
- ):
- return False
- return True
-
-
-def output_filters(missing_ok=False, **filter_callbacks):
- """Decorator to filter output list.
-
- Each filter_callback should have the definition like:
- func({'resp_eq': 'a'}, 'a')
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- filtered_obj_list = []
- obj_list = func(*args, **kwargs)
- for obj in obj_list:
- if filter_output(
- filter_callbacks, kwargs, obj, missing_ok
- ):
- filtered_obj_list.append(obj)
- return filtered_obj_list
- return wrapper
- return decorator
-
-
-def _input_validates(args_validators, kwargs_validators, *args, **kwargs):
- """Used by input_validators to validate inputs."""
- for i, value in enumerate(args):
- if i < len(args_validators) and args_validators[i]:
- args_validators[i](value)
- for key, value in kwargs.items():
- if kwargs_validators.get(key):
- kwargs_validators[key](value)
-
-
-def input_validates(*args_validators, **kwargs_validators):
- """Decorator to validate input.
-
- Each validator should have definition like:
- func('00:01:02:03:04:05')
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- _input_validates(
- args_validators, kwargs_validators,
- *args, **kwargs
- )
- return func(*args, **kwargs)
- return wrapper
- return decorator
-
-
-def _input_validates_with_args(
- args_validators, kwargs_validators, *args, **kwargs
-):
- """Validate input with validators.
-
- Each validator takes the arguments of the decorated function
- as its arguments. The function definition is like:
- func(value, *args, **kwargs) compared with the decorated
- function func(*args, **kwargs).
- """
- for i, value in enumerate(args):
- if i < len(args_validators) and args_validators[i]:
- args_validators[i](value, *args, **kwargs)
- for key, value in kwargs.items():
- if kwargs_validators.get(key):
- kwargs_validators[key](value, *args, **kwargs)
-
-
-def input_validates_with_args(
- *args_validators, **kwargs_validators
-):
- """Decorator to validate input."""
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- _input_validates_with_args(
- args_validators, kwargs_validators,
- *args, **kwargs
- )
- return func(*args, **kwargs)
- return wrapper
- return decorator
-
-
-def _output_validates_with_args(
- kwargs_validators, obj, *args, **kwargs
-):
- """Validate output with validators.
-
- Each validator takes the arguments of the decorated function
- as its arguments. The function definition is like:
- func(value, *args, **kwargs) compared with the decorated
- function func(*args, **kwargs).
- """
- if isinstance(obj, list):
- for item in obj:
- _output_validates_with_args(
- kwargs_validators, item, *args, **kwargs
- )
- return
- if isinstance(obj, models.HelperMixin):
- obj = obj.to_dict()
- if not isinstance(obj, dict):
- raise exception.InvalidResponse(
- 'response %s type is not dict' % str(obj)
- )
- try:
- for key, value in obj.items():
- if key in kwargs_validators:
- kwargs_validators[key](value, *args, **kwargs)
- except Exception as error:
- logging.exception(error)
- raise error
-
-
-def output_validates_with_args(**kwargs_validators):
- """Decorator to validate output.
-
- The validator can take the arguments of the decorated
- function as its arguments.
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- obj = func(*args, **kwargs)
- if isinstance(obj, list):
- for obj_item in obj:
- _output_validates_with_args(
- kwargs_validators, obj_item,
- *args, **kwargs
- )
- else:
- _output_validates_with_args(
- kwargs_validators, obj,
- *args, **kwargs
- )
- return obj
- return wrapper
- return decorator
-
-
-def _output_validates(kwargs_validators, obj):
- """Validate output.
-
- Each validator has following signature:
- func(value)
- """
- if isinstance(obj, list):
- for item in obj:
- _output_validates(kwargs_validators, item)
- return
- if isinstance(obj, models.HelperMixin):
- obj = obj.to_dict()
- if not isinstance(obj, dict):
- raise exception.InvalidResponse(
- 'response %s type is not dict' % str(obj)
- )
- try:
- for key, value in obj.items():
- if key in kwargs_validators:
- kwargs_validators[key](value)
- except Exception as error:
- logging.exception(error)
- raise error
-
-
-def output_validates(**kwargs_validators):
- """Decorator to validate output."""
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kwargs):
- obj = func(*args, **kwargs)
- if isinstance(obj, list):
- for obj_item in obj:
- _output_validates(kwargs_validators, obj_item)
- else:
- _output_validates(kwargs_validators, obj)
- return obj
- return wrapper
- return decorator
-
-
-def get_db_object(session, table, exception_when_missing=True, **kwargs):
- """Get db object.
-
- If not exception_when_missing and the db object can not be found,
- return None instead of raising exception.
- """
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s get db object %s from table %s',
- id(session), kwargs, table.__name__)
- db_object = model_filter(
- model_query(session, table), table, **kwargs
- ).first()
- logging.debug(
- 'session %s got db object %s', id(session), db_object
- )
- if db_object:
- return db_object
-
- if not exception_when_missing:
- return None
-
- raise exception.RecordNotExists(
- 'Cannot find the record in table %s: %s' % (
- table.__name__, kwargs
- )
- )
-
-
-def add_db_object(session, table, exception_when_existing=True,
- *args, **kwargs):
- """Create db object.
-
- If not exception_when_existing and the db object exists,
- Instead of raising exception, updating the existing db object.
- """
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s add object %s atributes %s to table %s',
- id(session), args, kwargs, table.__name__)
- argspec = inspect.getargspec(table.__init__)
- arg_names = argspec.args[1:]
- arg_defaults = argspec.defaults
- if not arg_defaults:
- arg_defaults = []
- if not (
- len(arg_names) - len(arg_defaults) <= len(args) <= len(arg_names)
- ):
- raise exception.InvalidParameter(
- 'arg names %s does not match arg values %s' % (
- arg_names, args)
- )
- db_keys = dict(zip(arg_names, args))
- if db_keys:
- db_object = session.query(table).filter_by(**db_keys).first()
- else:
- db_object = None
-
- new_object = False
- if db_object:
- logging.debug(
- 'got db object %s: %s', db_keys, db_object
- )
- if exception_when_existing:
- raise exception.DuplicatedRecord(
- '%s exists in table %s' % (db_keys, table.__name__)
- )
- else:
- db_object = table(**db_keys)
- new_object = True
-
- for key, value in kwargs.items():
- setattr(db_object, key, value)
-
- if new_object:
- session.add(db_object)
- session.flush()
- db_object.initialize()
- db_object.validate()
- logging.debug(
- 'session %s db object %s added', id(session), db_object
- )
- return db_object
-
-
-def list_db_objects(session, table, order_by=[], **filters):
- """List db objects.
-
- If order by given, the db objects should be sorted by the ordered keys.
- """
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s list db objects by filters %s in table %s',
- id(session), filters, table.__name__
- )
- db_objects = model_order_by(
- model_filter(
- model_query(session, table),
- table,
- **filters
- ),
- table,
- order_by
- ).all()
- logging.debug(
- 'session %s got listed db objects: %s',
- id(session), db_objects
- )
- return db_objects
-
-
-def del_db_objects(session, table, **filters):
- """delete db objects."""
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s delete db objects by filters %s in table %s',
- id(session), filters, table.__name__
- )
- query = model_filter(
- model_query(session, table), table, **filters
- )
- db_objects = query.all()
- query.delete(synchronize_session=False)
- logging.debug(
- 'session %s db objects %s deleted', id(session), db_objects
- )
- return db_objects
-
-
-def update_db_objects(session, table, updates={}, **filters):
- """Update db objects."""
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s update db objects by filters %s in table %s',
- id(session), filters, table.__name__)
- db_objects = model_filter(
- model_query(session, table), table, **filters
- ).all()
- for db_object in db_objects:
- logging.debug('update db object %s: %s', db_object, updates)
- update_db_object(session, db_object, **updates)
- logging.debug(
- 'session %s db objects %s updated',
- id(session), db_objects
- )
- return db_objects
-
-
-def update_db_object(session, db_object, **kwargs):
- """Update db object."""
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s update db object %s by value %s',
- id(session), db_object, kwargs
- )
- for key, value in kwargs.items():
- setattr(db_object, key, value)
- session.flush()
- db_object.update()
- db_object.validate()
- logging.debug(
- 'session %s db object %s updated',
- id(session), db_object
- )
- return db_object
-
-
-def del_db_object(session, db_object):
- """Delete db object."""
- if not session:
- raise exception.DatabaseException('session param is None')
- with session.begin(subtransactions=True):
- logging.debug(
- 'session %s delete db object %s',
- id(session), db_object
- )
- session.delete(db_object)
- logging.debug(
- 'session %s db object %s deleted',
- id(session), db_object
- )
- return db_object
-
-
-def check_ip(ip):
- """Check ip is ip address formatted."""
- try:
- netaddr.IPAddress(ip)
- except Exception as error:
- logging.exception(error)
- raise exception.InvalidParameter(
- 'ip address %s format uncorrect' % ip
- )
-
-
-def check_mac(mac):
- """Check mac is mac address formatted."""
- try:
- netaddr.EUI(mac)
- except Exception as error:
- logging.exception(error)
- raise exception.InvalidParameter(
- 'invalid mac address %s' % mac
- )
-
-
-NAME_PATTERN = re.compile(r'[a-zA-Z0-9][a-zA-Z0-9_-]*')
-
-
-def check_name(name):
- """Check name meeting name format requirement."""
- if not NAME_PATTERN.match(name):
- raise exception.InvalidParameter(
- 'name %s does not match the pattern %s' % (
- name, NAME_PATTERN.pattern
- )
- )
-
-
-def _check_ipmi_credentials_ip(ip):
- check_ip(ip)
-
-
-def check_ipmi_credentials(ipmi_credentials):
- """Check ipmi credentials format is correct."""
- if not ipmi_credentials:
- return
- if not isinstance(ipmi_credentials, dict):
- raise exception.InvalidParameter(
- 'invalid ipmi credentials %s' % ipmi_credentials
-
- )
- for key in ipmi_credentials:
- if key not in ['ip', 'username', 'password']:
- raise exception.InvalidParameter(
- 'unrecognized field %s in ipmi credentials %s' % (
- key, ipmi_credentials
- )
- )
- for key in ['ip', 'username', 'password']:
- if key not in ipmi_credentials:
- raise exception.InvalidParameter(
- 'no field %s in ipmi credentials %s' % (
- key, ipmi_credentials
- )
- )
- check_ipmi_credential_field = '_check_ipmi_credentials_%s' % key
- this_module = globals()
- if check_ipmi_credential_field in this_module:
- this_module[check_ipmi_credential_field](
- ipmi_credentials[key]
- )
- else:
- logging.debug(
- 'function %s is not defined', check_ipmi_credential_field
- )
-
-
-def _check_switch_credentials_version(version):
- if version not in ['1', '2c', '3']:
- raise exception.InvalidParameter(
- 'unknown snmp version %s' % version
- )
-
-
-def check_switch_credentials(credentials):
- """Check switch credentials format is correct."""
- if not credentials:
- return
- if not isinstance(credentials, dict):
- raise exception.InvalidParameter(
- 'credentials %s is not dict' % credentials
- )
- for key in credentials:
- if key not in ['version', 'community']:
- raise exception.InvalidParameter(
- 'unrecognized key %s in credentials %s' % (key, credentials)
- )
- for key in ['version', 'community']:
- if key not in credentials:
- raise exception.InvalidParameter(
- 'there is no %s field in credentials %s' % (key, credentials)
- )
-
- key_check_func_name = '_check_switch_credentials_%s' % key
- this_module = globals()
- if key_check_func_name in this_module:
- this_module[key_check_func_name](
- credentials[key]
- )
- else:
- logging.debug(
- 'function %s is not defined',
- key_check_func_name
- )