class NotificationBase(base.IronicObject):
"""Base class for versioned notifications.
Subclasses must define the "payload" field, which must be a subclass of
NotificationPayloadBase.
"""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'level': fields.NotificationLevelField(),
'event_type': fields.ObjectField('EventType'),
'publisher': fields.ObjectField('NotificationPublisher')
}
# NOTE(mariojv) This may be a candidate for something oslo.messaging
# implements instead of in ironic.
def _should_notify(self):
"""Determine whether the notification should be sent.
A notification is sent when the level of the notification is
greater than or equal to the level specified in the
configuration, in the increasing order of DEBUG, INFO, WARNING,
ERROR, CRITICAL.
:return: True if notification should be sent, False otherwise.
"""
if CONF.notification_level is None:
return False
return (NOTIFY_LEVELS[self.level] >=
NOTIFY_LEVELS[CONF.notification_level])
def emit(self, context):
"""Send the notification.
:raises NotificationPayloadError
:raises oslo_versionedobjects.exceptions.MessageDeliveryFailure
"""
if not self._should_notify():
return
if not self.payload.populated:
raise exception.NotificationPayloadError(
class_name=self.__class__.__name__)
# NOTE(mariojv) By default, oslo_versionedobjects includes a list
# of "changed fields" for the object in the output of
# obj_to_primitive. This is unneeded since every field of the
# object will look changed, since each payload is a newly created
# object, so we drop the changes.
self.payload.obj_reset_changes()
event_type = self.event_type.to_event_type_field()
publisher_id = '%s.%s' % (self.publisher.service, self.publisher.host)
payload = self.payload.obj_to_primitive()
notifier = rpc.get_versioned_notifier(publisher_id)
notify = getattr(notifier, self.level)
notify(context, event_type=event_type, payload=payload)
class NodeConsoleNotification(notification.NotificationBase):
"""Notification emitted when node console state changed."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('NodePayload')
}
class PortgroupCRUDNotification(notification.NotificationBase):
"""Notification when ironic creates, updates or deletes a portgroup."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('PortgroupCRUDPayload')
}
class NodeSetProvisionStateNotification(notification.NotificationBase):
"""Notification emitted when ironic changes a node provision state."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('NodeSetProvisionStatePayload')
}
class NodeMaintenanceNotification(notification.NotificationBase):
"""Notification emitted when maintenance state changed via API."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('NodePayload')
}
class NodeCRUDNotification(notification.NotificationBase):
"""Notification emitted when ironic creates, updates or deletes a node."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('NodeCRUDPayload')
}
class VolumeConnectorCRUDNotification(notification.NotificationBase):
"""Notification emitted at CRUD of a volume connector."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('VolumeConnectorCRUDPayload')
}
class DeployTemplateCRUDNotification(notification.NotificationBase):
"""Notification emitted on deploy template API operations."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('DeployTemplateCRUDPayload')
}
class NodeCorrectedPowerStateNotification(notification.NotificationBase):
"""Notification for when a node's power state is corrected in the database.
This notification is emitted when ironic detects that the actual power
state on a bare metal hardware is different from the power state on an
ironic node (DB). This notification is emitted after the database is
updated to reflect this correction.
"""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'payload': object_fields.ObjectField('NodeCorrectedPowerStatePayload')
}
class TestObj(base.IronicObject,
object_base.VersionedObjectDictCompat):
fields = {'my_obj': fields.ObjectField('MyObj')}
class Node(base.IronicObject, object_base.VersionedObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: Added instance_info
# Version 1.2: Add get() and get_by_id() and make get_by_uuid()
# only work with a uuid
# Version 1.3: Add create() and destroy()
# Version 1.4: Add get_by_instance_uuid()
# Version 1.5: Add list()
# Version 1.6: Add reserve() and release()
# Version 1.7: Add conductor_affinity
# Version 1.8: Add maintenance_reason
# Version 1.9: Add driver_internal_info
# Version 1.10: Add name and get_by_name()
# Version 1.11: Add clean_step
# Version 1.12: Add raid_config and target_raid_config
# Version 1.13: Add touch_provisioning()
# Version 1.14: Add _validate_property_values() and make create()
# and save() validate the input of property values.
# Version 1.15: Add get_by_port_addresses
# Version 1.16: Add network_interface field
# Version 1.17: Add resource_class field
# Version 1.18: Add default setting for network_interface
# Version 1.19: Add fields: boot_interface, console_interface,
# deploy_interface, inspect_interface, management_interface,
# power_interface, raid_interface, vendor_interface
# Version 1.20: Type of network_interface changed to just nullable string
# Version 1.21: Add storage_interface field
# Version 1.22: Add rescue_interface field
# Version 1.23: Add traits field
# Version 1.24: Add bios_interface field
# Version 1.25: Add fault field
# Version 1.26: Add deploy_step field
# Version 1.27: Add conductor_group field
# Version 1.28: Add automated_clean field
# Version 1.29: Add protected and protected_reason fields
VERSION = '1.29'
dbapi = db_api.get_instance()
fields = {
'id': object_fields.IntegerField(),
'uuid': object_fields.UUIDField(nullable=True),
'name': object_fields.StringField(nullable=True),
'chassis_id': object_fields.IntegerField(nullable=True),
'instance_uuid': object_fields.UUIDField(nullable=True),
'driver': object_fields.StringField(nullable=True),
'driver_info': object_fields.FlexibleDictField(nullable=True),
'driver_internal_info': object_fields.FlexibleDictField(nullable=True),
# A clean step dictionary, indicating the current clean step
# being executed, or None, indicating cleaning is not in progress
# or has not yet started.
'clean_step': object_fields.FlexibleDictField(nullable=True),
# A deploy step dictionary, indicating the current step
# being executed, or None, indicating deployment is not in progress
# or has not yet started.
'deploy_step': object_fields.FlexibleDictField(nullable=True),
'raid_config': object_fields.FlexibleDictField(nullable=True),
'target_raid_config': object_fields.FlexibleDictField(nullable=True),
'instance_info': object_fields.FlexibleDictField(nullable=True),
'properties': object_fields.FlexibleDictField(nullable=True),
'reservation': object_fields.StringField(nullable=True),
# a reference to the id of the conductor service, not its hostname,
# that has most recently performed some action which could require
# local state to be maintained (eg, built a PXE config)
'conductor_affinity': object_fields.IntegerField(nullable=True),
'conductor_group': object_fields.StringField(nullable=True),
# One of states.POWER_ON|POWER_OFF|NOSTATE|ERROR
'power_state': object_fields.StringField(nullable=True),
# Set to one of states.POWER_ON|POWER_OFF when a power operation
# starts, and set to NOSTATE when the operation finishes
# (successfully or unsuccessfully).
'target_power_state': object_fields.StringField(nullable=True),
'provision_state': object_fields.StringField(nullable=True),
'provision_updated_at': object_fields.DateTimeField(nullable=True),
'target_provision_state': object_fields.StringField(nullable=True),
'maintenance': object_fields.BooleanField(),
'maintenance_reason': object_fields.StringField(nullable=True),
'fault': object_fields.StringField(nullable=True),
'console_enabled': object_fields.BooleanField(),
# Any error from the most recent (last) asynchronous transaction
# that started but failed to finish.
'last_error': object_fields.StringField(nullable=True),
# Used by nova to relate the node to a flavor
'resource_class': object_fields.StringField(nullable=True),
'inspection_finished_at': object_fields.DateTimeField(nullable=True),
'inspection_started_at': object_fields.DateTimeField(nullable=True),
'extra': object_fields.FlexibleDictField(nullable=True),
'automated_clean': objects.fields.BooleanField(nullable=True),
'protected': objects.fields.BooleanField(),
'protected_reason': object_fields.StringField(nullable=True),
'bios_interface': object_fields.StringField(nullable=True),
'boot_interface': object_fields.StringField(nullable=True),
'console_interface': object_fields.StringField(nullable=True),
'deploy_interface': object_fields.StringField(nullable=True),
'inspect_interface': object_fields.StringField(nullable=True),
'management_interface': object_fields.StringField(nullable=True),
'network_interface': object_fields.StringField(nullable=True),
'power_interface': object_fields.StringField(nullable=True),
'raid_interface': object_fields.StringField(nullable=True),
'rescue_interface': object_fields.StringField(nullable=True),
'storage_interface': object_fields.StringField(nullable=True),
'vendor_interface': object_fields.StringField(nullable=True),
'traits': object_fields.ObjectField('TraitList', nullable=True),
}
def as_dict(self, secure=False):
d = super(Node, self).as_dict()
if secure:
d['driver_info'] = strutils.mask_dict_password(
d.get('driver_info', {}), "******")
d['instance_info'] = strutils.mask_dict_password(
d.get('instance_info', {}), "******")
return d
def _validate_property_values(self, properties):
"""Check if the input of local_gb, cpus and memory_mb are valid.
:param properties: a dict contains the node's information.
"""
if not properties:
return
invalid_msgs_list = []
for param in REQUIRED_INT_PROPERTIES:
value = properties.get(param)
if value is None:
continue
try:
int_value = int(value)
if int_value < 0:
raise ValueError("Value must be non-negative")
except (ValueError, TypeError):
msg = (('%(param)s=%(value)s') % {
'param': param,
'value': value
})
invalid_msgs_list.append(msg)
if invalid_msgs_list:
msg = (_('The following properties for node %(node)s '
'should be non-negative integers, '
'but provided values are: %(msgs)s') % {
'node': self.uuid,
'msgs': ', '.join(invalid_msgs_list)
})
raise exception.InvalidParameterValue(msg)
def _set_from_db_object(self, context, db_object, fields=None):
fields = set(fields or self.fields) - {'traits'}
super(Node, self)._set_from_db_object(context, db_object, fields)
self.traits = object_base.obj_make_list(context,
objects.TraitList(context),
objects.Trait,
db_object['traits'])
self.traits.obj_reset_changes()
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def get(cls, context, node_id):
"""Find a node based on its id or uuid and return a Node object.
:param context: Security context
:param node_id: the id *or* uuid of a node.
:returns: a :class:`Node` object.
"""
if strutils.is_int_like(node_id):
return cls.get_by_id(context, node_id)
elif uuidutils.is_uuid_like(node_id):
return cls.get_by_uuid(context, node_id)
else:
raise exception.InvalidIdentity(identity=node_id)
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def get_by_id(cls, context, node_id):
"""Find a node based on its integer ID and return a Node object.
:param cls: the :class:`Node`
:param context: Security context
:param node_id: the ID of a node.
:returns: a :class:`Node` object.
"""
db_node = cls.dbapi.get_node_by_id(node_id)
node = cls._from_db_object(context, cls(), db_node)
return node
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def get_by_uuid(cls, context, uuid):
"""Find a node based on UUID and return a Node object.
:param cls: the :class:`Node`
:param context: Security context
:param uuid: the UUID of a node.
:returns: a :class:`Node` object.
"""
db_node = cls.dbapi.get_node_by_uuid(uuid)
node = cls._from_db_object(context, cls(), db_node)
return node
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def get_by_name(cls, context, name):
"""Find a node based on name and return a Node object.
:param cls: the :class:`Node`
:param context: Security context
:param name: the logical name of a node.
:returns: a :class:`Node` object.
"""
db_node = cls.dbapi.get_node_by_name(name)
node = cls._from_db_object(context, cls(), db_node)
return node
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
"""Find a node based on the instance UUID and return a Node object.
:param cls: the :class:`Node`
:param context: Security context
:param uuid: the UUID of the instance.
:returns: a :class:`Node` object.
"""
db_node = cls.dbapi.get_node_by_instance(instance_uuid)
node = cls._from_db_object(context, cls(), db_node)
return node
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def list(cls,
context,
limit=None,
marker=None,
sort_key=None,
sort_dir=None,
filters=None):
"""Return a list of Node objects.
:param cls: the :class:`Node`
:param context: Security context.
:param limit: maximum number of resources to return in a single result.
:param marker: pagination marker for large data sets.
:param sort_key: column to sort results by.
:param sort_dir: direction to sort. "asc" or "desc".
:param filters: Filters to apply.
:returns: a list of :class:`Node` object.
"""
db_nodes = cls.dbapi.get_node_list(filters=filters,
limit=limit,
marker=marker,
sort_key=sort_key,
sort_dir=sort_dir)
return cls._from_db_object_list(context, db_nodes)
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def reserve(cls, context, tag, node_id):
"""Get and reserve a node.
To prevent other ManagerServices from manipulating the given
Node while a Task is performed, mark it reserved by this host.
:param cls: the :class:`Node`
:param context: Security context.
:param tag: A string uniquely identifying the reservation holder.
:param node_id: A node ID or UUID.
:raises: NodeNotFound if the node is not found.
:returns: a :class:`Node` object.
"""
db_node = cls.dbapi.reserve_node(tag, node_id)
node = cls._from_db_object(context, cls(), db_node)
return node
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable_classmethod
@classmethod
def release(cls, context, tag, node_id):
"""Release the reservation on a node.
:param context: Security context.
:param tag: A string uniquely identifying the reservation holder.
:param node_id: A node id or uuid.
:raises: NodeNotFound if the node is not found.
"""
cls.dbapi.release_node(tag, node_id)
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable
def create(self, context=None):
"""Create a Node record in the DB.
Column-wise updates will be made based on the result of
self.what_changed(). If target_power_state is provided,
it will be checked against the in-database copy of the
node before updates are made.
:param context: Security context. NOTE: This should only
be used internally by the indirection_api.
Unfortunately, RPC requires context as the first
argument, even though we don't use it.
A context should be set when instantiating the
object, e.g.: Node(context)
:raises: InvalidParameterValue if some property values are invalid.
"""
values = self.do_version_changes_for_db()
self._validate_property_values(values.get('properties'))
self._validate_and_remove_traits(values)
self._validate_and_format_conductor_group(values)
db_node = self.dbapi.create_node(values)
self._from_db_object(self._context, self, db_node)
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable
def destroy(self, context=None):
"""Delete the Node from the DB.
:param context: Security context. NOTE: This should only
be used internally by the indirection_api.
Unfortunately, RPC requires context as the first
argument, even though we don't use it.
A context should be set when instantiating the
object, e.g.: Node(context)
"""
self.dbapi.destroy_node(self.uuid)
self.obj_reset_changes()
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable
def save(self, context=None):
"""Save updates to this Node.
Column-wise updates will be made based on the result of
self.what_changed(). If target_power_state is provided,
it will be checked against the in-database copy of the
node before updates are made.
:param context: Security context. NOTE: This should only
be used internally by the indirection_api.
Unfortunately, RPC requires context as the first
argument, even though we don't use it.
A context should be set when instantiating the
object, e.g.: Node(context)
:raises: InvalidParameterValue if some property values are invalid.
"""
updates = self.do_version_changes_for_db()
self._validate_property_values(updates.get('properties'))
if 'driver' in updates and 'driver_internal_info' not in updates:
# Clean driver_internal_info when changes driver
self.driver_internal_info = {}
updates = self.do_version_changes_for_db()
self._validate_and_remove_traits(updates)
self._validate_and_format_conductor_group(updates)
db_node = self.dbapi.update_node(self.uuid, updates)
self._from_db_object(self._context, self, db_node)
@staticmethod
def _validate_and_remove_traits(fields):
"""Validate traits in fields for create or update, remove if present.
:param fields: a dict of Node fields for create or update.
:raises: BadRequest if fields contains a traits that are not None.
"""
if 'traits' in fields:
# NOTE(mgoddard): Traits should be updated via the node
# object's traits field, which is itself an object. We shouldn't
# get here with changes to traits, as this should be handled by the
# API. When services are pinned to Pike, we can get here with
# traits set to None in updates, due to changes made to the object
# in _convert_to_version.
if fields['traits']:
# NOTE(mgoddard): We shouldn't get here as this should be
# handled by the API.
raise exception.BadRequest()
fields.pop('traits')
def _validate_and_format_conductor_group(self, fields):
"""Validate conductor_group and format it for our use.
Currently formatting is just lowercasing it.
:param fields: a dict of Node fields for create or update.
:raises: InvalidConductorGroup if validation fails.
"""
if 'conductor_group' in fields:
utils.validate_conductor_group(fields['conductor_group'])
fields['conductor_group'] = fields['conductor_group'].lower()
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable
def refresh(self, context=None):
"""Refresh the object by re-fetching from the DB.
:param context: Security context. NOTE: This should only
be used internally by the indirection_api.
Unfortunately, RPC requires context as the first
argument, even though we don't use it.
A context should be set when instantiating the
object, e.g.: Node(context)
"""
current = self.get_by_uuid(self._context, self.uuid)
self.obj_refresh(current)
self.obj_reset_changes()
# NOTE(xek): We don't want to enable RPC on this call just yet. Remotable
# methods can be used in the future to replace current explicit RPC calls.
# Implications of calling new remote procedures should be thought through.
# @object_base.remotable
def touch_provisioning(self, context=None):
"""Touch the database record to mark the provisioning as alive."""
self.dbapi.touch_node_provisioning(self.id)
@classmethod
def get_by_port_addresses(cls, context, addresses):
"""Get a node by associated port addresses.
:param cls: the :class:`Node`
:param context: Security context.
:param addresses: A list of port addresses.
:raises: NodeNotFound if the node is not found.
:returns: a :class:`Node` object.
"""
db_node = cls.dbapi.get_node_by_port_addresses(addresses)
node = cls._from_db_object(context, cls(), db_node)
return node
def _convert_fault_field(self,
target_version,
remove_unavailable_fields=True):
fault_is_set = self.obj_attr_is_set('fault')
if target_version >= (1, 25):
if not fault_is_set:
self.fault = None
elif fault_is_set:
if remove_unavailable_fields:
delattr(self, 'fault')
elif self.fault is not None:
self.fault = None
def _convert_deploy_step_field(self,
target_version,
remove_unavailable_fields=True):
# NOTE(rloo): Typically we set the value to None. However,
# deploy_step is a FlexibleDictField. Setting it to None
# causes it to be set to {} under-the-hood. So I am being
# explicit about that here.
step_is_set = self.obj_attr_is_set('deploy_step')
if target_version >= (1, 26):
if not step_is_set:
self.deploy_step = {}
elif step_is_set:
if remove_unavailable_fields:
delattr(self, 'deploy_step')
elif self.deploy_step:
self.deploy_step = {}
def _convert_conductor_group_field(self,
target_version,
remove_unavailable_fields=True):
# NOTE(jroll): The default conductor_group is "", not None
is_set = self.obj_attr_is_set('conductor_group')
if target_version >= (1, 27):
if not is_set:
self.conductor_group = ''
elif is_set:
if remove_unavailable_fields:
delattr(self, 'conductor_group')
elif self.conductor_group:
self.conductor_group = ''
# NOTE (yolanda): new method created to avoid repeating code in
# _convert_to_version, and to avoid pep8 too complex error
def _adjust_field_to_version(self, field_name, field_default_value,
target_version, major, minor,
remove_unavailable_fields):
field_is_set = self.obj_attr_is_set(field_name)
if target_version >= (major, minor):
# target version supports the major/minor specified
if not field_is_set:
# set it to its default value if it is not set
setattr(self, field_name, field_default_value)
elif field_is_set:
# target version does not support the field, and it is set
if remove_unavailable_fields:
# (De)serialising: remove unavailable fields
delattr(self, field_name)
elif getattr(self, field_name) is not field_default_value:
# DB: set unavailable field to the default value
setattr(self, field_name, field_default_value)
def _convert_to_version(self,
target_version,
remove_unavailable_fields=True):
"""Convert to the target version.
Convert the object to the target version. The target version may be
the same, older, or newer than the version of the object. This is
used for DB interactions as well as for serialization/deserialization.
Version 1.22: rescue_interface field was added. Its default value is
None. For versions prior to this, it should be set to None (or
removed).
Version 1.23: traits field was added. Its default value is
None. For versions prior to this, it should be set to None (or
removed).
Version 1.24: bios_interface field was added. Its default value is
None. For versions prior to this, it should be set to None (or
removed).
Version 1.25: fault field was added. For versions prior to
this, it should be removed.
Version 1.26: deploy_step field was added. For versions prior to
this, it should be removed.
Version 1.27: conductor_group field was added. For versions prior to
this, it should be removed.
Version 1.28: automated_clean was added. For versions prior to this, it
should be set to None (or removed).
Version 1.29: protected was added. For versions prior to this, it
should be set to False (or removed).
:param target_version: the desired version of the object
:param remove_unavailable_fields: True to remove fields that are
unavailable in the target version; set this to True when
(de)serializing. False to set the unavailable fields to appropriate
values; set this to False for DB interactions.
"""
target_version = versionutils.convert_version_to_tuple(target_version)
# Convert the different fields depending on version
fields = [('rescue_interface', 22), ('traits', 23),
('bios_interface', 24), ('automated_clean', 28),
('protected_reason', 29)]
for name, minor in fields:
self._adjust_field_to_version(name, None, target_version, 1, minor,
remove_unavailable_fields)
# NOTE(dtantsur): the default is False for protected
self._adjust_field_to_version('protected', False, target_version, 1,
29, remove_unavailable_fields)
self._convert_fault_field(target_version, remove_unavailable_fields)
self._convert_deploy_step_field(target_version,
remove_unavailable_fields)
self._convert_conductor_group_field(target_version,
remove_unavailable_fields)
class TestNotificationEmptySchema(notification.NotificationBase):
VERSION = '1.0'
fields = {
'payload': fields.ObjectField('TestNotificationPayloadEmptySchema')
}