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)