296 lines
10 KiB
Python
296 lines
10 KiB
Python
# Copyright 2016 NTT Data.
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
"""Masakari common internal object model"""
|
|
|
|
import datetime
|
|
|
|
from oslo_utils import versionutils
|
|
from oslo_versionedobjects import base as ovoo_base
|
|
from oslo_versionedobjects import fields as obj_fields
|
|
|
|
from masakari import objects
|
|
|
|
|
|
def get_attrname(name):
|
|
"""Return the mangled name of the attribute's underlying storage."""
|
|
return '_obj_' + name
|
|
|
|
|
|
class MasakariObjectRegistry(ovoo_base.VersionedObjectRegistry):
|
|
notification_classes = []
|
|
|
|
def registration_hook(self, cls, index):
|
|
# NOTE(Dinesh_Bhor): This is called when an object is registered,
|
|
# and is responsible for maintaining masakari.objects.$OBJECT
|
|
# as the highest-versioned implementation of a given object.
|
|
version = versionutils.convert_version_to_tuple(cls.VERSION)
|
|
if not hasattr(objects, cls.obj_name()):
|
|
setattr(objects, cls.obj_name(), cls)
|
|
else:
|
|
cur_version = versionutils.convert_version_to_tuple(
|
|
getattr(objects, cls.obj_name()).VERSION)
|
|
if version >= cur_version:
|
|
setattr(objects, cls.obj_name(), cls)
|
|
|
|
@classmethod
|
|
def register_notification(cls, notification_cls):
|
|
"""Register a class as notification.
|
|
|
|
Use only to register concrete notification or payload classes,
|
|
do not register base classes intended for inheritance only.
|
|
"""
|
|
cls.register_if(False)(notification_cls)
|
|
cls.notification_classes.append(notification_cls)
|
|
return notification_cls
|
|
|
|
@classmethod
|
|
def register_notification_objects(cls):
|
|
"""Register previously decorated notification as normal ovos.
|
|
|
|
This is not intended for production use but only for testing and
|
|
document generation purposes.
|
|
"""
|
|
for notification_cls in cls.notification_classes:
|
|
cls.register(notification_cls)
|
|
|
|
|
|
remotable_classmethod = ovoo_base.remotable_classmethod
|
|
remotable = ovoo_base.remotable
|
|
|
|
|
|
class MasakariObject(ovoo_base.VersionedObject):
|
|
"""Base class and object factory.
|
|
|
|
This forms the base of all objects that can be remoted or instantiated
|
|
via RPC. Simply defining a class that inherits from this base class
|
|
will make it remotely instantiatable. Objects should implement the
|
|
necessary "get" classmethod routines as well as "save" object methods
|
|
as appropriate.
|
|
"""
|
|
|
|
OBJ_SERIAL_NAMESPACE = 'masakari_object'
|
|
OBJ_PROJECT_NAMESPACE = 'masakari'
|
|
|
|
def masakari_obj_get_changes(self):
|
|
"""Returns a dict of changed fields with tz unaware datetimes.
|
|
|
|
Any timezone aware datetime field will be converted to UTC timezone
|
|
and returned as timezone unaware datetime.
|
|
|
|
This will allow us to pass these fields directly to a db update
|
|
method as they can't have timezone information.
|
|
"""
|
|
# Get dirtied/changed fields
|
|
changes = self.obj_get_changes()
|
|
|
|
# Look for datetime objects that contain timezone information
|
|
for k, v in changes.items():
|
|
if isinstance(v, datetime.datetime) and v.tzinfo:
|
|
# Remove timezone information and adjust the time according to
|
|
# the timezone information's offset.
|
|
changes[k] = v.replace(tzinfo=None) - v.utcoffset()
|
|
|
|
# Return modified dict
|
|
return changes
|
|
|
|
def obj_reset_changes(self, fields=None, recursive=False):
|
|
"""Reset the list of fields that have been changed.
|
|
|
|
.. note::
|
|
|
|
- This is NOT "revert to previous values"
|
|
- Specifying fields on recursive resets will only be honored at the
|
|
top level. Everything below the top will reset all.
|
|
|
|
:param fields: List of fields to reset, or "all" if None.
|
|
:param recursive: Call obj_reset_changes(recursive=True) on
|
|
any sub-objects within the list of fields
|
|
being reset.
|
|
"""
|
|
if recursive:
|
|
for field in self.obj_get_changes():
|
|
|
|
# Ignore fields not in requested set (if applicable)
|
|
if fields and field not in fields:
|
|
continue
|
|
|
|
# Skip any fields that are unset
|
|
if not self.obj_attr_is_set(field):
|
|
continue
|
|
|
|
value = getattr(self, field)
|
|
|
|
# Don't reset nulled fields
|
|
if value is None:
|
|
continue
|
|
|
|
# Reset straight Object and ListOfObjects fields
|
|
if isinstance(self.fields[field], obj_fields.ObjectField):
|
|
value.obj_reset_changes(recursive=True)
|
|
elif isinstance(self.fields[field],
|
|
obj_fields.ListOfObjectsField):
|
|
for thing in value:
|
|
thing.obj_reset_changes(recursive=True)
|
|
|
|
if fields:
|
|
self._changed_fields -= set(fields)
|
|
else:
|
|
self._changed_fields.clear()
|
|
|
|
|
|
class MasakariObjectDictCompat(ovoo_base.VersionedObjectDictCompat):
|
|
def __iter__(self):
|
|
for name in self.obj_fields:
|
|
if (self.obj_attr_is_set(name) or
|
|
name in self.obj_extra_fields):
|
|
yield name
|
|
|
|
def keys(self):
|
|
return list(self)
|
|
|
|
|
|
class MasakariTimestampObject(object):
|
|
"""Mixin class for db backed objects with timestamp fields.
|
|
|
|
Sqlalchemy models that inherit from the oslo_db TimestampMixin will include
|
|
these fields and the corresponding objects will benefit from this mixin.
|
|
"""
|
|
fields = {
|
|
'created_at': obj_fields.DateTimeField(nullable=True),
|
|
'updated_at': obj_fields.DateTimeField(nullable=True),
|
|
}
|
|
|
|
|
|
class MasakariPersistentObject(object):
|
|
"""Mixin class for Persistent objects.
|
|
|
|
This adds the fields that we use in common for most persistent objects.
|
|
"""
|
|
fields = {
|
|
'created_at': obj_fields.DateTimeField(nullable=True),
|
|
'updated_at': obj_fields.DateTimeField(nullable=True),
|
|
'deleted_at': obj_fields.DateTimeField(nullable=True),
|
|
'deleted': obj_fields.BooleanField(default=False),
|
|
}
|
|
|
|
|
|
class ObjectListBase(ovoo_base.ObjectListBase):
|
|
|
|
@classmethod
|
|
def _obj_primitive_key(cls, field):
|
|
return 'masakari_object.%s' % field
|
|
|
|
@classmethod
|
|
def _obj_primitive_field(cls, primitive, field,
|
|
default=obj_fields.UnspecifiedDefault):
|
|
key = cls._obj_primitive_key(field)
|
|
if default == obj_fields.UnspecifiedDefault:
|
|
return primitive[key]
|
|
else:
|
|
return primitive.get(key, default)
|
|
|
|
|
|
class MasakariObjectSerializer(ovoo_base.VersionedObjectSerializer):
|
|
"""A Masakari Object Serializer.
|
|
|
|
This implements the Oslo Serializer interface and provides
|
|
the ability to serialize and deserialize MasakariObject entities.
|
|
Any service that needs to accept or return MasakariObjects
|
|
as arguments or result values should pass this to its RPCClient
|
|
and RPCServer objects.
|
|
|
|
"""
|
|
OBJ_BASE_CLASS = MasakariObject
|
|
|
|
def __init__(self):
|
|
super(MasakariObjectSerializer, self).__init__()
|
|
|
|
|
|
def obj_make_list(context, list_obj, item_cls, db_list, **extra_args):
|
|
"""Construct an object list from a list of primitives.
|
|
|
|
This calls item_cls._from_db_object() on each item of db_list, and
|
|
adds the resulting object to list_obj.
|
|
|
|
:param:context: Request context
|
|
:param:list_obj: An ObjectListBase object
|
|
:param:item_cls: The MasakariObject class of the objects within the list
|
|
:param:db_list: The list of primitives to convert to objects
|
|
:param:extra_args: Extra arguments to pass to _from_db_object()
|
|
:returns: list_obj
|
|
"""
|
|
list_obj.objects = []
|
|
for db_item in db_list:
|
|
item = item_cls._from_db_object(context, item_cls(), db_item,
|
|
**extra_args)
|
|
list_obj.objects.append(item)
|
|
list_obj._context = context
|
|
list_obj.obj_reset_changes()
|
|
return list_obj
|
|
|
|
|
|
def obj_to_primitive(obj):
|
|
"""Recursively turn an object into a python primitive.
|
|
|
|
A MasakariObject becomes a dict, and anything that implements
|
|
ObjectListBase becomes a list.
|
|
"""
|
|
if isinstance(obj, ObjectListBase):
|
|
return [obj_to_primitive(x) for x in obj]
|
|
elif isinstance(obj, MasakariObject):
|
|
result = {}
|
|
for key in obj.obj_fields:
|
|
if obj.obj_attr_is_set(key) or key in obj.obj_extra_fields:
|
|
result[key] = obj_to_primitive(getattr(obj, key))
|
|
return result
|
|
else:
|
|
return obj
|
|
|
|
|
|
def obj_equal_prims(obj_1, obj_2, ignore=None):
|
|
"""Compare two primitives for equivalence ignoring some keys.
|
|
|
|
This operation tests the primitives of two objects for equivalence.
|
|
Object primitives may contain a list identifying fields that have been
|
|
changed - this is ignored in the comparison. The ignore parameter lists
|
|
any other keys to be ignored.
|
|
|
|
:param:obj1: The first object in the comparison
|
|
:param:obj2: The second object in the comparison
|
|
:param:ignore: A list of fields to ignore
|
|
:returns: True if the primitives are equal ignoring changes
|
|
and specified fields, otherwise False.
|
|
"""
|
|
|
|
def _strip(prim, keys):
|
|
if isinstance(prim, dict):
|
|
for k in keys:
|
|
prim.pop(k, None)
|
|
for v in prim.values():
|
|
_strip(v, keys)
|
|
if isinstance(prim, list):
|
|
for v in prim:
|
|
_strip(v, keys)
|
|
return prim
|
|
|
|
if ignore is not None:
|
|
keys = ['masakari_object.changes'] + ignore
|
|
else:
|
|
keys = ['masakari_object.changes']
|
|
prim_1 = _strip(obj_1.obj_to_primitive(), keys)
|
|
prim_2 = _strip(obj_2.obj_to_primitive(), keys)
|
|
return prim_1 == prim_2
|