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