def __init__(self,
field_class,
mutable=False,
required_on_activate=True,
system=False,
validators=None,
nullable=True,
default=None,
sortable=False,
filter_ops=None,
description=""):
"""Init and validate attribute"""
if not issubclass(field_class, fields.AutoTypedField):
raise exc.IncorrectArtifactType(
"Field class %s must be sub-class of AutoTypedField." %
field_class)
self.validators = validators or []
for v in self.validators:
v.check_type_allowed(field_class)
if isinstance(v, val_lib.MaxStrLen):
if v.size > 255 and sortable:
raise exc.IncorrectArtifactType(
"It's forbidden to make attribute %(attr)s "
"sortable if string length can be more than 255 "
"symbols. Maximal allowed length now: %(max)d" % {
"attr": str(field_class),
'max': v.size
})
self.field_class = field_class
self.nullable = nullable
self.default = default
self.vo_attrs = ['nullable', 'default']
self.mutable = mutable
self.required_on_activate = required_on_activate
self.system = system
self.sortable = sortable
if field_class is not glare_fields.BlobField:
self.filter_ops = filter_ops or [FILTER_EQ, FILTER_NEQ, FILTER_IN]
else:
if filter_ops:
raise exc.IncorrectArtifactType(
"Cannot specify filters for blobs")
self.filter_ops = []
self.field_attrs = [
'mutable', 'required_on_activate', 'system', 'sortable',
'filter_ops', 'description'
]
self.description = description
def __init__(self, field_class, element_type, element_validators=None,
**kwargs):
super(CompoundAttribute, self).__init__(field_class, **kwargs)
if self.sortable:
raise exc.IncorrectArtifactType("'sortable' must be False for "
"compound type.")
if element_type is None:
raise exc.IncorrectArtifactType("'element_type' must be set for "
"compound type.")
self.element_type = element_type
self.vo_attrs.append('element_type')
self.field_attrs.append('element_type')
self.element_validators = element_validators or []
def __init__(self, element_type, max_size=255, **kwargs):
if 'default' not in kwargs:
kwargs['default'] = []
if element_type is glare_fields.BlobField:
raise exc.IncorrectArtifactType("List of blobs is not allowed "
"to be specified in artifact.")
super(ListAttribute, self).__init__(glare_fields.List, element_type,
**kwargs)
self.validators.append(val_lib.MaxListSize(max_size))
def check_type_allowed(self, field_type):
if not issubclass(field_type, self.get_allowed_types()):
# try to check if field_type is correct
# in case of element_type passed
allowed_field_types = tuple(type(field.AUTO_TYPE)
for field in self.get_allowed_types()
if hasattr(field, 'AUTO_TYPE'))
if not issubclass(field_type, allowed_field_types):
raise exception.IncorrectArtifactType(
_("%(type)s is not allowed for validator "
"%(val)s. Allowed types are %(allowed)s.") % {
"type": str(field_type),
"val": str(self.__class__),
"allowed": str(self.get_allowed_types())})
def _validate_artifact_type(cls, type_class):
"""Validate artifact type class
Raises an exception if validation will fail.
:param type_class: artifact class
"""
base_classes = [object, base.BaseArtifact, vo_base.VersionedObject]
base_attributes = set()
for b_class in base_classes:
base_attributes.update(set(vars(b_class).keys()))
class_attributes = set(vars(type_class).keys())
common_attrs = class_attributes & base_attributes
allowed_attributes = ('VERSION', 'fields', 'init_db_api',
'get_type_name', 'validate_activate',
'validate_publish', 'validate_upload', '__doc__',
'__module__')
for attr in common_attrs:
if attr not in allowed_attributes:
raise exception.IncorrectArtifactType(
explanation=_("attribute %(attr)s not allowed to be "
"redefined in subclass %(class_name)s") % {
"attr": attr,
"class_name": str(type_class)
})
def __init__(self,
field_class,
mutable=False,
required_on_activate=True,
system=False,
validators=None,
nullable=True,
default=None,
sortable=False,
filter_ops=None,
description=""):
"""Init and validate field.
Each artifact field has several common properties:
:param required_on_activate: boolean value indicating if the field
value should be specified for the artifact
before activation (Default:True).
:param mutable: boolean value indicating if the field value may
be changed after the artifact is activated. (Default: False)
:param system: boolean value indicating if the field
value cannot be edited by user (Default: False).
:param sortable: boolean value indicating if there is a possibility
to sort by this fields's values. (Default: False) Only fields of
4 primitive types may be sortable: integer, string, float and boolean.
:param default: a default value for the field may be specified
(Default: None).
:param validators: a list of objects. When user sets a value to
the field with additional validators Glare checks them before setting
the value and raises ValueError if at least one of the requirements
is not satisfied.
:param filter_ops: a list of available filter operators for the field.
There are seven available operators:
'eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in'.
"""
if not issubclass(field_class, fields.AutoTypedField):
raise exc.IncorrectArtifactType(
"Field class %s must be sub-class of AutoTypedField." %
field_class)
self.validators = validators or []
for v in self.validators:
v.check_type_allowed(field_class)
if isinstance(v, val_lib.MaxStrLen):
if v.size > 255 and sortable:
raise exc.IncorrectArtifactType(
"It's forbidden to make field %(field)s "
"sortable if string length can be more than 255 "
"symbols. Maximal allowed length now: %(max)d" % {
"field": str(field_class),
'max': v.size
})
self.field_class = field_class
self.nullable = nullable
self.default = default
self.vo_props = ['nullable', 'default']
self.mutable = mutable
self.required_on_activate = required_on_activate
self.system = system
self.sortable = sortable
try:
default_ops = self.get_default_filter_ops(self.element_type)
allowed_ops = self.get_allowed_filter_ops(self.element_type)
except AttributeError:
default_ops = self.get_default_filter_ops(field_class)
allowed_ops = self.get_allowed_filter_ops(self.field_class)
if filter_ops is None:
self.filter_ops = default_ops
else:
for op in filter_ops:
if op not in allowed_ops:
raise exc.IncorrectArtifactType(
"Incorrect filter operator '%s'. "
"Only %s are allowed" % (op, ', '.join(default_ops)))
self.filter_ops = filter_ops
self.field_props = [
'mutable', 'required_on_activate', 'system', 'sortable',
'filter_ops', 'description'
]
self.description = description
