class StackTag(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.IntegerField(),
'tag': fields.StringField(nullable=True),
'stack_id': fields.StringField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, tag, db_tag):
"""Method to help with migration to objects.
Converts a database entity to a formal object.
"""
if db_tag is None:
return None
for field in tag.fields:
tag[field] = db_tag[field]
tag.obj_reset_changes()
return tag
@classmethod
def get_obj(cls, context, tag):
return cls._from_db_object(cls(context), tag)
class StaffelnPersistentObject(ovoo_base.VersionedObject):
fields = {
"created_at": ovoo_fields.DateTimeField(nullable=True),
# "deleted_at": ovoo_fields.DateTimeField(nullable=True),
"updated_at": ovoo_fields.DateTimeField(nullable=True),
}
object_fields = {}
def obj_refresh(self, loaded_object):
fields = (field for field in self.fields
if field not in self.object_fields)
for field in fields:
if self.obj_attr_is_set(
field) and self[field] != loaded_object[field]:
self[field] = loaded_object[field]
@staticmethod
def _from_db_object(obj, db_object, eager=False):
obj_class = type(obj)
object_fields = obj_class.object_fields
for field in obj.fields:
if field not in object_fields:
obj[field] = db_object[field]
obj.obj_reset_changes()
return obj
class VolumeAttachment(base.CinderPersistentObject, base.CinderObject,
base.CinderObjectDictCompat,
base.CinderComparableObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.UUIDField(),
'volume_id': fields.UUIDField(),
'instance_uuid': fields.UUIDField(nullable=True),
'attached_host': fields.StringField(nullable=True),
'mountpoint': fields.StringField(nullable=True),
'attach_time': fields.DateTimeField(nullable=True),
'detach_time': fields.DateTimeField(nullable=True),
'attach_status': c_fields.VolumeAttachStatusField(nullable=True),
'attach_mode': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(context, attachment, db_attachment):
for name, field in attachment.fields.items():
value = db_attachment.get(name)
if isinstance(field, fields.IntegerField):
value = value or 0
attachment[name] = value
attachment._context = context
attachment.obj_reset_changes()
return attachment
def save(self):
updates = self.cinder_obj_get_changes()
if updates:
db.volume_attachment_update(self._context, self.id, updates)
self.obj_reset_changes()
class StackLock(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'engine_id': fields.StringField(nullable=True),
'stack_id': fields.StringField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@classmethod
def create(cls, stack_id, engine_id):
return db_api.stack_lock_create(stack_id, engine_id)
@classmethod
def steal(cls, stack_id, old_engine_id, new_engine_id):
return db_api.stack_lock_steal(stack_id, old_engine_id, new_engine_id)
@classmethod
def release(cls, stack_id, engine_id):
return db_api.stack_lock_release(stack_id, engine_id)
@classmethod
def get_engine_id(cls, stack_id):
return db_api.stack_lock_get_engine_id(stack_id)
class CinderPersistentObject(object):
"""Mixin class for Persistent objects.
This adds the fields that we use in common for all persistent objects.
"""
fields = {
'created_at': fields.DateTimeField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
'deleted_at': fields.DateTimeField(nullable=True),
'deleted': fields.BooleanField(default=False),
}
@contextlib.contextmanager
def obj_as_admin(self):
"""Context manager to make an object call as an admin.
This temporarily modifies the context embedded in an object to
be elevated() and restores it after the call completes. Example
usage:
with obj.obj_as_admin():
obj.save()
"""
if self._context is None:
raise exception.OrphanedObjectError(method='obj_as_admin',
objtype=self.obj_name())
original_context = self._context
self._context = self._context.elevated()
try:
yield
finally:
self._context = original_context
class SoftwareDeployment(base.VersionedObject, base.VersionedObjectDictCompat,
base.ComparableVersionedObject):
fields = {
'id': fields.StringField(),
'config_id': fields.StringField(),
'server_id': fields.StringField(),
'input_values': heat_fields.JsonField(nullable=True),
'output_values': heat_fields.JsonField(nullable=True),
'tenant': fields.StringField(),
'stack_user_project_id': fields.StringField(nullable=True),
'action': fields.StringField(nullable=True),
'status': fields.StringField(nullable=True),
'status_reason': fields.StringField(nullable=True),
'config': fields.ObjectField('SoftwareConfig'),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, deployment, db_deployment):
for field in deployment.fields:
if field == 'config':
deployment[field] = (
software_config.SoftwareConfig._from_db_object(
context, software_config.SoftwareConfig(),
db_deployment['config']))
else:
deployment[field] = db_deployment[field]
deployment._context = context
deployment.obj_reset_changes()
return deployment
@classmethod
def create(cls, context, values):
return cls._from_db_object(
context, cls(), db_api.software_deployment_create(context, values))
@classmethod
def get_by_id(cls, context, deployment_id):
return cls._from_db_object(
context, cls(),
db_api.software_deployment_get(context, deployment_id))
@classmethod
def get_all(cls, context, server_id=None):
return [
cls._from_db_object(context, cls(), db_deployment)
for db_deployment in db_api.software_deployment_get_all(
context, server_id)
]
@classmethod
def update_by_id(cls, context, deployment_id, values):
return cls._from_db_object(
context, cls(),
db_api.software_deployment_update(context, deployment_id, values))
@classmethod
def delete(cls, context, deployment_id):
db_api.software_deployment_delete(context, deployment_id)
class EonObject(object_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 = 'eon_object'
OBJ_PROJECT_NAMESPACE = 'eon'
fields = {
'created_at': fields.DateTimeField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
}
def as_dict(self):
return dict((k, getattr(self, k))
for k in self.fields if hasattr(self, k))
def obj_refresh(self, loaded_object):
"""Applies updates for objects that inherit from base.IronicObject.
Checks for updated attributes in an object. Updates are applied from
the loaded object column by column in comparison with the current
object.
"""
for field in self.fields:
if (self.obj_attr_is_set(field) and
self[field] != loaded_object[field]):
self[field] = loaded_object[field]
class Event(base.VersionedObject, base.VersionedObjectDictCompat):
fields = {
'id': fields.IntegerField(),
'stack_id': fields.StringField(),
'uuid': fields.StringField(),
'resource_action': fields.StringField(nullable=True),
'resource_status': fields.StringField(nullable=True),
'resource_name': fields.StringField(nullable=True),
'physical_resource_id': fields.StringField(nullable=True),
'resource_status_reason': fields.StringField(nullable=True),
'resource_type': fields.StringField(nullable=True),
'resource_properties': heat_fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, event, db_event):
for field in event.fields:
event[field] = db_event[field]
event._context = context
event.obj_reset_changes()
return event
@classmethod
def get_by_id(cls, context, event_id):
db_event = db_api.event_get(context, event_id)
return cls._from_db_object(context, cls(context), db_event)
@classmethod
def get_all(cls, context):
return [
cls._from_db_object(context, cls(), db_event)
for db_event in db_api.event_get_all(context)
]
@classmethod
def get_all_by_tenant(cls, context, **kwargs):
return [
cls._from_db_object(context, cls(), db_event)
for db_event in db_api.event_get_all_by_tenant(context, **kwargs)
]
@classmethod
def get_all_by_stack(cls, context, stack_id, **kwargs):
return [
cls._from_db_object(context, cls(), db_event)
for db_event in db_api.event_get_all_by_stack(
context, stack_id, **kwargs)
]
@classmethod
def count_all_by_stack(cls, context, stack_id):
return db_api.event_count_all_by_stack(context, stack_id)
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(),
db_api.event_create(context, values))
class Receiver(senlin_base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin receiver object."""
fields = {
'id': fields.UUIDField(),
'name': fields.StringField(),
'type': fields.StringField(),
'cluster_id': fields.UUIDField(),
'actor': fields.DictOfStringsField(nullable=True),
'action': fields.StringField(),
'params': fields.DictOfStringsField(nullable=True),
'channel': fields.DictOfStringsField(nullable=True),
'created_at': fields.DateTimeField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
'user': fields.StringField(),
'project': fields.StringField(),
'domain': fields.StringField(),
}
@staticmethod
def _from_db_object(context, receiver, db_obj):
if db_obj is None:
return None
for field in receiver.fields:
receiver[field] = db_obj[field]
receiver._context = context
receiver.obj_reset_changes()
return receiver
@classmethod
def create(cls, context, values):
obj = db_api.receiver_create(context, values)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, receiver_id, **kwargs):
obj = db_api.receiver_get(context, receiver_id, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_name(cls, context, name, **kwargs):
obj = db_api.receiver_get_by_name(context, name, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_short_id(cls, context, short_id, **kwargs):
obj = db_api.receiver_get_by_short_id(context, short_id, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_all(cls, context, **kwargs):
return db_api.receiver_get_all(context, **kwargs)
@classmethod
def delete(cls, context, receiver_id):
db_api.receiver_delete(context, receiver_id)
class ScheduledOperationLog(base.KarborPersistentObject, base.KarborObject,
base.KarborObjectDictCompat,
base.KarborComparableObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.IntegerField(),
'operation_id': fields.UUIDField(),
'expect_start_time': fields.DateTimeField(nullable=True),
'triggered_time': fields.DateTimeField(nullable=True),
'actual_start_time': fields.DateTimeField(nullable=True),
'end_time': fields.DateTimeField(nullable=True),
'state': fields.StringField(),
'extend_info': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(context, log, db_log):
for name, field in log.fields.items():
log[name] = db_log.get(name)
log._context = context
log.obj_reset_changes()
return log
@base.remotable_classmethod
def get_by_id(cls, context, id):
db_log = db.scheduled_operation_log_get(context, id)
if db_log:
return cls._from_db_object(context, cls(), db_log)
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason=_('already created'))
updates = self.karbor_obj_get_changes()
db_log = db.scheduled_operation_log_create(self._context, updates)
self._from_db_object(self._context, self, db_log)
@base.remotable
def save(self):
updates = self.karbor_obj_get_changes()
if updates and self.id is not None:
db.scheduled_operation_log_update(self._context, self.id, updates)
self.obj_reset_changes()
@base.remotable
def destroy(self):
if self.id is not None:
db.scheduled_operation_log_delete(self._context, self.id)
@base.remotable_classmethod
def destroy_oldest(cls, context, operation_id,
retained_num, excepted_states=[]):
db.scheduled_operation_log_delete_oldest(
context, operation_id, retained_num, excepted_states)
class MagnumPersistentObject(object):
"""Mixin class for Persistent objects.
This adds the fields that we use in common for all persistent objects.
"""
fields = {
'created_at': ovoo_fields.DateTimeField(nullable=True),
'updated_at': ovoo_fields.DateTimeField(nullable=True),
}
class Service(base.VersionedObject, base.VersionedObjectDictCompat,
base.ComparableVersionedObject):
fields = {
'id': fields.StringField(),
'engine_id': fields.StringField(),
'host': fields.StringField(),
'hostname': fields.StringField(),
'binary': fields.StringField(),
'topic': fields.StringField(),
'report_interval': fields.IntegerField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
'deleted_at': fields.DateTimeField(nullable=True)
}
@staticmethod
def _from_db_object(context, service, db_service):
for field in service.fields:
service[field] = db_service[field]
service._context = context
service.obj_reset_changes()
return service
@classmethod
def _from_db_objects(cls, context, list_obj):
return [
cls._from_db_object(context, cls(context), obj) for obj in list_obj
]
@classmethod
def get_by_id(cls, context, service_id):
service_db = db_api.service_get(context, service_id)
service = cls._from_db_object(context, cls(), service_db)
return service
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(),
db_api.service_create(context, values))
@classmethod
def update_by_id(cls, context, service_id, values):
return cls._from_db_object(
context, cls(), db_api.service_update(context, service_id, values))
@classmethod
def delete(cls, context, service_id, soft_delete=True):
db_api.service_delete(context, service_id, soft_delete)
@classmethod
def get_all(cls, context):
return cls._from_db_objects(context, db_api.service_get_all(context))
@classmethod
def get_all_by_args(cls, context, host, binary, hostname):
return cls._from_db_objects(
context,
db_api.service_get_all_by_args(context, host, binary, hostname))
class FmObject(object_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 = 'fm_object'
OBJ_PROJECT_NAMESPACE = 'fm'
fields = {
'created_at': object_fields.DateTimeField(nullable=True),
'updated_at': object_fields.DateTimeField(nullable=True),
}
def __getitem__(self, name):
return getattr(self, name)
def __setitem__(self, name, value):
setattr(self, name, value)
def as_dict(self):
return dict(
(k, getattr(self, k)) for k in self.fields if hasattr(self, k))
def obj_refresh(self, loaded_object):
"""Applies updates for objects that inherit from base.FmObject.
Checks for updated attributes in an object. Updates are applied from
the loaded object column by column in comparison with the current
object.
"""
for field in self.fields:
if (self.obj_attr_is_set(field)
and self[field] != loaded_object[field]):
self[field] = loaded_object[field]
@staticmethod
def _from_db_object(obj, db_object):
"""Converts a database entity to a formal object.
:param obj: An object of the class.
:param db_object: A DB model of the object
:return: The object of the class with the database entity added
"""
for field in obj.fields:
obj[field] = db_object[field]
obj.obj_reset_changes()
return obj
@classmethod
def from_db_object(cls, db_obj):
return cls._from_db_object(cls(), db_obj)
class ResourcePropertiesData(
base.VersionedObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.IntegerField(),
'data': heat_fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(rpd, context, db_rpd, data_unencrypted=None):
# The data_unencrypted field allows us to avoid an extra
# decrypt operation, e.g. when called from create().
for field in rpd.fields:
rpd[field] = db_rpd[field]
if data_unencrypted: # save a little (decryption) processing
rpd['data'] = data_unencrypted
elif db_rpd['encrypted'] and rpd['data'] is not None:
rpd['data'] = crypt.decrypted_dict(rpd['data'])
# TODO(cwolfe) setting the context here should go away, that
# should have been done with the initialisation of the rpd
# object. For now, maintaining consistency with other
# _from_db_object methods.
rpd._context = context
rpd.obj_reset_changes()
return rpd
@classmethod
def create(cls, context, data):
properties_data_encrypted, properties_data = \
ResourcePropertiesData.encrypt_properties_data(data)
values = {
'encrypted': properties_data_encrypted,
'data': properties_data
}
db_obj = db_api.resource_prop_data_create(context, values)
return cls._from_db_object(cls(), context, db_obj, data)
@staticmethod
def encrypt_properties_data(data):
if cfg.CONF.encrypt_parameters_and_properties and data:
result = {}
for prop_name, prop_value in data.items():
prop_string = jsonutils.dumps(prop_value)
encrypted_value = crypt.encrypt(prop_string)
result[prop_name] = encrypted_value
return (True, result)
return (False, data)
@staticmethod
def get_by_id(context, id):
db_ref = db_api.resource_prop_data_get(context, id)
return ResourcePropertiesData._from_db_object(
ResourcePropertiesData(context=context), context, db_ref)
class VolumeAttachment(base.CinderPersistentObject, base.CinderObject,
base.CinderObjectDictCompat,
base.CinderComparableObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.UUIDField(),
'volume_id': fields.UUIDField(),
'instance_uuid': fields.UUIDField(nullable=True),
'attached_host': fields.StringField(nullable=True),
'mountpoint': fields.StringField(nullable=True),
'attach_time': fields.DateTimeField(nullable=True),
'detach_time': fields.DateTimeField(nullable=True),
'attach_status': c_fields.VolumeAttachStatusField(nullable=True),
'attach_mode': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(context, attachment, db_attachment):
for name, field in attachment.fields.items():
value = db_attachment.get(name)
if isinstance(field, fields.IntegerField):
value = value or 0
attachment[name] = value
attachment._context = context
attachment.obj_reset_changes()
return attachment
def save(self):
updates = self.cinder_obj_get_changes()
if updates:
db.volume_attachment_update(self._context, self.id, updates)
self.obj_reset_changes()
def finish_attach(self,
instance_uuid,
host_name,
mount_point,
attach_mode='rw'):
with self.obj_as_admin():
db_volume, updated_values = db.volume_attached(
self._context, self.id, instance_uuid, host_name, mount_point,
attach_mode)
self.update(updated_values)
self.obj_reset_changes(updated_values.keys())
return objects.Volume._from_db_object(self._context, objects.Volume(),
db_volume)
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason=_('already created'))
updates = self.cinder_obj_get_changes()
with self.obj_as_admin():
db_attachment = db.volume_attach(self._context, updates)
self._from_db_object(self._context, self, db_attachment)
class Agent(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = agent_model.Agent
fields = {
'id': obj_fields.UUIDField(),
'agent_type': obj_fields.StringField(),
'binary': obj_fields.StringField(),
'topic': obj_fields.StringField(),
'host': obj_fields.StringField(),
'availability_zone': obj_fields.StringField(nullable=True),
'admin_state_up': obj_fields.BooleanField(default=True),
'started_at': obj_fields.DateTimeField(tzinfo_aware=False),
'created_at': obj_fields.DateTimeField(tzinfo_aware=False),
'heartbeat_timestamp': obj_fields.DateTimeField(tzinfo_aware=False),
'description': obj_fields.StringField(nullable=True),
'configurations': obj_fields.DictOfStringsField(),
'resource_versions': obj_fields.DictOfStringsField(nullable=True),
'load': obj_fields.IntegerField(default=0),
}
@classmethod
def modify_fields_to_db(cls, fields):
result = super(Agent, cls).modify_fields_to_db(fields)
if 'configurations' in result:
result['configurations'] = (cls.filter_to_json_str(
result['configurations']))
if 'resource_versions' in result:
if result['resource_versions']:
result['resource_versions'] = (cls.filter_to_json_str(
result['resource_versions']))
if not fields['resource_versions']:
result['resource_versions'] = None
return result
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(Agent, cls).modify_fields_from_db(db_obj)
if 'configurations' in fields:
if fields['configurations']:
fields['configurations'] = jsonutils.loads(
fields['configurations'])
if not fields['configurations']:
fields['configurations'] = {}
if 'resource_versions' in fields:
if fields['resource_versions']:
fields['resource_versions'] = jsonutils.loads(
fields['resource_versions'])
if not fields['resource_versions']:
fields['resource_versions'] = None
return fields
@property
def is_active(self):
return not utils.is_agent_down(self.heartbeat_timestamp)
class ResourceData(
base.VersionedObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.IntegerField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
'key': fields.StringField(nullable=True),
'value': fields.StringField(nullable=True),
'redact': fields.BooleanField(nullable=True),
'resource_id': fields.IntegerField(),
'decrypt_method': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(sdata, db_sdata):
if db_sdata is None:
return None
for field in sdata.fields:
sdata[field] = db_sdata[field]
sdata.obj_reset_changes()
return sdata
@classmethod
def get_all(cls, resource, *args, **kwargs):
# this method only returns dict, so we won't use objects mechanism here
return db_api.resource_data_get_all(resource, *args, **kwargs)
@classmethod
def get_obj(cls, resource, key):
raise exception.NotSupported(feature='ResourceData.get_obj')
@classmethod
def get_val(cls, resource, key):
return db_api.resource_data_get(resource, key)
@classmethod
def set(cls, resource, key, value, *args, **kwargs):
db_data = db_api.resource_data_set(
resource,
key,
value,
*args,
**kwargs
)
return db_data
@classmethod
def get_by_key(cls, context, resource_id, key):
db_rdata = db_api.resource_data_get_by_key(context, resource_id, key)
return cls._from_db_object(cls(context), db_rdata)
@classmethod
def delete(cls, resource, key):
db_api.resource_data_delete(resource, key)
class OperationLog(base.KarborPersistentObject, base.KarborObject,
base.KarborObjectDictCompat,
base.KarborComparableObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.UUIDField(),
'project_id': fields.UUIDField(),
'operation_type': fields.StringField(),
'checkpoint_id': fields.UUIDField(nullable=True),
'plan_id': fields.UUIDField(nullable=True),
'provider_id': fields.UUIDField(nullable=True),
'restore_id': fields.UUIDField(nullable=True),
'scheduled_operation_id': fields.UUIDField(nullable=True),
'status': fields.StringField(nullable=True),
'started_at': fields.DateTimeField(nullable=True),
'ended_at': fields.DateTimeField(nullable=True),
'error_info': fields.StringField(nullable=True),
'extra_info': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(context, operation_log, db_operation_log):
for name, field in operation_log.fields.items():
value = db_operation_log.get(name)
if isinstance(field, fields.IntegerField):
value = value or 0
elif isinstance(field, fields.DateTimeField):
value = value or None
operation_log[name] = value
operation_log._context = context
operation_log.obj_reset_changes()
return operation_log
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason=_('already created'))
updates = self.karbor_obj_get_changes()
db_operation_log = db.operation_log_create(self._context, updates)
self._from_db_object(self._context, self, db_operation_log)
@base.remotable
def save(self):
updates = self.karbor_obj_get_changes()
if updates:
db.operation_log_update(self._context, self.id, updates)
self.obj_reset_changes()
@base.remotable
def destroy(self):
with self.obj_as_admin():
db.operation_log_destroy(self._context, self.id)
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 Snapshot(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'name': fields.StringField(nullable=True),
'stack_id': fields.StringField(),
'data': heat_fields.JsonField(nullable=True),
'tenant': fields.StringField(),
'status': fields.StringField(nullable=True),
'status_reason': fields.StringField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, snapshot, db_snapshot):
for field in snapshot.fields:
snapshot[field] = db_snapshot[field]
snapshot._context = context
snapshot.obj_reset_changes()
return snapshot
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(),
db_api.snapshot_create(context, values))
@classmethod
def get_snapshot_by_stack(cls, context, snapshot_id, stack):
return cls._from_db_object(
context, cls(),
db_api.snapshot_get_by_stack(context, snapshot_id, stack))
@classmethod
def update(cls, context, snapshot_id, values):
db_snapshot = db_api.snapshot_update(context, snapshot_id, values)
return cls._from_db_object(context, cls(), db_snapshot)
@classmethod
def delete(cls, context, snapshot_id):
db_api.snapshot_delete(context, snapshot_id)
@classmethod
def get_all(cls, context, stack_id):
return [
cls._from_db_object(context, cls(), db_snapshot)
for db_snapshot in db_api.snapshot_get_all(context, stack_id)
]
class Agent(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = agent_model.Agent
fields = {
'id': common_types.UUIDField(),
'agent_type': obj_fields.StringField(),
'binary': obj_fields.StringField(),
'topic': obj_fields.StringField(),
'host': obj_fields.StringField(),
'availability_zone': obj_fields.StringField(nullable=True),
'admin_state_up': obj_fields.BooleanField(default=True),
'started_at': obj_fields.DateTimeField(tzinfo_aware=False),
'created_at': obj_fields.DateTimeField(tzinfo_aware=False),
'heartbeat_timestamp': obj_fields.DateTimeField(tzinfo_aware=False),
'description': obj_fields.StringField(nullable=True),
'configurations': common_types.DictOfMiscValuesField(),
'resource_versions': common_types.DictOfMiscValuesField(nullable=True),
'load': obj_fields.IntegerField(default=0),
}
@classmethod
def modify_fields_to_db(cls, fields):
result = super(Agent, cls).modify_fields_to_db(fields)
if 'configurations' in result:
# dump configuration into string, set '' if empty '{}'
result['configurations'] = (cls.filter_to_json_str(
result['configurations'], default=''))
if 'resource_versions' in result:
# dump resource version into string, set None if empty '{}' or None
result['resource_versions'] = (cls.filter_to_json_str(
result['resource_versions']))
return result
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(Agent, cls).modify_fields_from_db(db_obj)
if 'configurations' in fields:
# load string from DB, set {} if configuration is ''
fields['configurations'] = (cls.load_json_from_str(
fields['configurations'], default={}))
if 'resource_versions' in fields:
# load string from DB, set None if resource_version is None or ''
fields['resource_versions'] = (cls.load_json_from_str(
fields['resource_versions']))
return fields
@property
def is_active(self):
return not utils.is_agent_down(self.heartbeat_timestamp)
class Service(senlin_base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin service object."""
fields = {
'id': fields.UUIDField(),
'host': fields.StringField(),
'binary': fields.StringField(),
'topic': fields.StringField(),
'disabled': fields.BooleanField(),
'disabled_reason': fields.StringField(),
'created_at': fields.DateTimeField(),
'updated_at': fields.DateTimeField(),
}
@staticmethod
def _from_db_object(context, service, db_obj):
if db_obj is None:
return None
for field in service.fields:
service[field] = db_obj[field]
service._context = context
service.obj_reset_changes()
return service
@classmethod
def create(cls, context, service_id, host=None, binary=None, topic=None):
obj = db_api.service_create(context, service_id=service_id, host=host,
binary=binary, topic=topic)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, service_id):
obj = db_api.service_get(context, service_id)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_all(cls, context):
objs = db_api.service_get_all(context)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def update(cls, context, obj_id, values=None):
obj = db_api.service_update(context, obj_id, values=values)
return cls._from_db_object(context, cls(), obj)
@classmethod
def delete(cls, context, obj_id):
db_api.service_delete(context, obj_id)
class SyncPoint(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'entity_id': fields.StringField(),
'traversal_id': fields.StringField(),
'is_update': fields.BooleanField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
'atomic_key': fields.IntegerField(),
'stack_id': fields.StringField(),
'input_data': heat_fields.JsonField(nullable=True),
}
@staticmethod
def _from_db_object(context, sdata, db_sdata):
if db_sdata is None:
return None
for field in sdata.fields:
sdata[field] = db_sdata[field]
sdata._context = context
sdata.obj_reset_changes()
return sdata
@classmethod
def get_by_key(cls, context, entity_id, traversal_id, is_update):
sync_point_db = db_api.sync_point_get(context, entity_id, traversal_id,
is_update)
return cls._from_db_object(context, cls(), sync_point_db)
@classmethod
def create(cls, context, values):
sync_point_db = db_api.sync_point_create(context, values)
return cls._from_db_object(context, cls(), sync_point_db)
@classmethod
def update_input_data(cls, context, entity_id, traversal_id, is_update,
atomic_key, input_data):
return db_api.sync_point_update_input_data(context, entity_id,
traversal_id, is_update,
atomic_key, input_data)
@classmethod
def delete_all_by_stack_and_traversal(cls, context, stack_id,
traversal_id):
return db_api.sync_point_delete_all_by_stack_and_traversal(
context, stack_id, traversal_id)
class UserCreds(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
'username': fields.StringField(nullable=True),
'password': fields.StringField(nullable=True),
'tenant': fields.StringField(nullable=True),
'tenant_id': fields.StringField(nullable=True),
'trustor_user_id': fields.StringField(nullable=True),
'trust_id': fields.StringField(nullable=True),
'region_name': fields.StringField(nullable=True),
'auth_url': fields.StringField(nullable=True),
'decrypt_method': fields.StringField(nullable=True)
}
@staticmethod
def _from_db_object(ucreds, db_ucreds, context=None):
if db_ucreds is None:
return db_ucreds
ucreds._context = context
for field in ucreds.fields:
# TODO(Shao HE Feng), now the db layer delete the decrypt_method
# field, just skip it here. and will add an encrypted_field later.
if field == "decrypt_method":
continue
ucreds[field] = db_ucreds[field]
ucreds.obj_reset_changes()
return ucreds
@classmethod
def create(cls, context):
user_creds_db = db_api.user_creds_create(context)
return cls._from_db_object(cls(), user_creds_db)
@classmethod
def delete(cls, context, user_creds_id):
db_api.user_creds_delete(context, user_creds_id)
@classmethod
def get_by_id(cls, context_id):
user_creds_db = db_api.user_creds_get(context_id)
user_creds = cls._from_db_object(cls(), user_creds_db)
return user_creds
class CleanupRequest(base.CinderObject, base.ClusteredObject):
"""Versioned Object to send cleanup requests."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'service_id': fields.IntegerField(nullable=True),
'cluster_name': fields.StringField(nullable=True),
'host': fields.StringField(nullable=True),
'binary': fields.StringField(nullable=True),
'is_up': fields.BooleanField(default=False, nullable=True),
'disabled': fields.BooleanField(nullable=True),
'resource_id': fields.UUIDField(nullable=True),
'resource_type': fields.StringField(nullable=True),
'until': fields.DateTimeField(nullable=True),
}
def __init__(self, context=None, **kwargs):
super(CleanupRequest, self).__init__(**kwargs)
# Set non initialized fields with default or None values
for field_name in self.fields:
if not self.obj_attr_is_set(field_name):
field = self.fields[field_name]
if field.default != fields.UnspecifiedDefault:
setattr(self, field_name, field.default)
elif field.nullable:
setattr(self, field_name, None)
class DrydockPersistentObject(base.VersionedObject):
fields = {
'created_at': obj_fields.DateTimeField(nullable=False),
'created_by': obj_fields.StringField(nullable=False),
'updated_at': obj_fields.DateTimeField(nullable=True),
'updated_by': obj_fields.StringField(nullable=True),
}
def set_create_fields(self, context):
self.created_at = datetime.datetime.now()
self.created_by = context.user
def set_update_fields(self, context):
self.updated_at = datetime.datetime.now()
self.updated_by = context.user
class ResourcePropertiesData(
base.VersionedObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.IntegerField(),
'data': heat_fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(rpd, context, db_rpd, data_unencrypted=None):
# The data_unencrypted field allows us to avoid an extra
# decrypt operation, e.g. when called from create().
for field in rpd.fields:
rpd[field] = db_rpd[field]
if data_unencrypted: # save a little (decryption) processing
rpd['data'] = data_unencrypted
elif db_rpd['encrypted'] and rpd['data'] is not None:
rpd['data'] = crypt.decrypted_dict(rpd['data'])
rpd.obj_reset_changes()
return rpd
@classmethod
def create(cls, context, data):
properties_data_encrypted, properties_data = \
ResourcePropertiesData.encrypt_properties_data(data)
values = {
'encrypted': properties_data_encrypted,
'data': properties_data
}
db_obj = db_api.resource_prop_data_create(context, values)
return cls._from_db_object(cls(), context, db_obj, data)
@staticmethod
def encrypt_properties_data(data):
if cfg.CONF.encrypt_parameters_and_properties and data:
result = {}
for prop_name, prop_value in data.items():
prop_string = jsonutils.dumps(prop_value)
encrypted_value = crypt.encrypt(prop_string)
result[prop_name] = encrypted_value
return (True, result)
return (False, data)
class Event(senlin_base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin event object."""
fields = {
'id': fields.UUIDField(),
'timestamp': fields.DateTimeField(),
'obj_id': fields.UUIDField(),
'obj_name': fields.StringField(),
'obj_type': fields.StringField(),
'cluster_id': fields.UUIDField(nullable=True),
'level': fields.StringField(),
'user': fields.StringField(),
'project': fields.StringField(),
'action': fields.StringField(nullable=True),
'status': fields.StringField(),
'status_reason': fields.StringField(),
'metadata': fields.DictOfStringsField(nullable=True),
}
@staticmethod
def _from_db_object(context, event, db_obj):
if db_obj is None:
return None
for field in event.fields:
if field == 'metadata':
event['metadata'] = db_obj['meta_data']
else:
event[field] = db_obj[field]
event._context = context
event.obj_reset_changes()
return event
@classmethod
def create(cls, context, values):
obj = db_api.event_create(context, values)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, event_id, **kwargs):
return db_api.event_get(context, event_id, **kwargs)
@classmethod
def get_by_short_id(cls, context, short_id, **kwargs):
return db_api.event_get_by_short_id(context, short_id, **kwargs)
@classmethod
def get_all(cls, context, **kwargs):
return db_api.event_get_all(context, **kwargs)
@classmethod
def count_by_cluster(cls, context, cluster_id, **kwargs):
return db_api.event_count_by_cluster(context, cluster_id, **kwargs)
@classmethod
def get_all_by_cluster(cls, context, cluster_id, **kwargs):
objs = db_api.event_get_all_by_cluster(context, cluster_id, **kwargs)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
class SoftwareConfig(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'name': fields.StringField(nullable=True),
'group': fields.StringField(nullable=True),
'tenant': fields.StringField(nullable=True),
'config': heat_fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, config, db_config):
# SoftwareDeployment._from_db_object may attempt to load a None config
if db_config is None:
return None
for field in config.fields:
config[field] = db_config[field]
config._context = context
config.obj_reset_changes()
return config
@classmethod
def create(cls, context, values):
return cls._from_db_object(
context, cls(), db_api.software_config_create(context, values))
@classmethod
def get_by_id(cls, context, config_id):
return cls._from_db_object(
context, cls(), db_api.software_config_get(context, config_id))
@classmethod
def get_all(cls, context, **kwargs):
scs = db_api.software_config_get_all(context, **kwargs)
return [cls._from_db_object(context, cls(), sc) for sc in scs]
@classmethod
def delete(cls, context, config_id):
db_api.software_config_delete(context, config_id)
