class FloatingIPDNS(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.FloatingIPDNS
primary_keys = ['floatingip_id']
fields = {
'floatingip_id': obj_fields.UUIDField(),
'dns_name': common_types.DomainNameField(),
'dns_domain': common_types.DomainNameField(),
'published_dns_name': common_types.DomainNameField(),
'published_dns_domain': common_types.DomainNameField(),
}
class FakeNeutronObject(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = FakeModel
fields = {
'id': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'field2': obj_fields.StringField()
}
fields_no_update = ['id']
synthetic_fields = ['field2']
class IPAllocation(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models_v2.IPAllocation
fields = {
'port_id': obj_fields.UUIDField(nullable=True),
'subnet_id': obj_fields.UUIDField(),
'network_id': obj_fields.UUIDField(),
'ip_address': obj_fields.IPAddressField(),
}
primary_keys = ['subnet_id', 'network_id', 'ip_address']
foreign_keys = {
'Port': {'port_id': 'id'},
}
# TODO(rossella_s): get rid of it once we switch the db model to using
# custom types.
@classmethod
def modify_fields_to_db(cls, fields):
result = super(IPAllocation, cls).modify_fields_to_db(fields)
if 'ip_address' in result:
result['ip_address'] = cls.filter_to_str(result['ip_address'])
return result
# TODO(rossella_s): get rid of it once we switch the db model to using
# custom types.
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(IPAllocation, cls).modify_fields_from_db(db_obj)
if 'ip_address' in fields:
fields['ip_address'] = netaddr.IPAddress(fields['ip_address'])
return fields
class FakeNeutronObjectNonStandardPrimaryKey(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = FakeModel
primary_key = 'weird_key'
fields = {
'weird_key': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'field2': obj_fields.StringField()
}
synthetic_fields = ['field2']
class DNSNameServer(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models_v2.DNSNameServer
primary_keys = ['address', 'subnet_id']
foreign_keys = {'subnet_id': 'id'}
fields = {
'address': obj_fields.StringField(),
'subnet_id': obj_fields.UUIDField(),
'order': obj_fields.IntegerField()
}
class FakeNeutronObject(base.NeutronObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': obj_fields.UUIDField(),
'project_id': obj_fields.StringField(),
'field2': obj_fields.UUIDField(),
}
@classmethod
def get_object(cls, context, **kwargs):
if not hasattr(cls, '_obj'):
cls._obj = FakeNeutronObject(id=uuidutils.generate_uuid(),
project_id='fake-id',
field2=uuidutils.generate_uuid())
return cls._obj
@classmethod
def get_objects(cls, context, _pager=None, count=1, **kwargs):
return [
cls.get_object(context, **kwargs)
for i in range(count)
]
class IPAllocationPool(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models_v2.IPAllocationPool
foreign_keys = {'Subnet': {'subnet_id': 'id'}}
fields_need_translation = {'start': 'first_ip', 'end': 'last_ip'}
fields = {
'id': obj_fields.UUIDField(),
'subnet_id': obj_fields.UUIDField(),
'start': obj_fields.IPAddressField(),
'end': obj_fields.IPAddressField()
}
@classmethod
def modify_fields_from_db(cls, db_obj):
# TODO(korzen) remove this method when IP and CIDR decorator ready
result = super(IPAllocationPool, cls).modify_fields_from_db(db_obj)
if 'start' in result:
result['start'] = netaddr.IPAddress(result['start'])
if 'end' in result:
result['end'] = netaddr.IPAddress(result['end'])
return result
@classmethod
def modify_fields_to_db(cls, fields):
# TODO(korzen) remove this method when IP and CIDR decorator ready
result = super(IPAllocationPool, cls).modify_fields_to_db(fields)
if 'first_ip' in result:
result['first_ip'] = cls.filter_to_str(result['first_ip'])
if 'last_ip' in result:
result['last_ip'] = cls.filter_to_str(result['last_ip'])
return result
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': fields.StringField(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
@base.remotable
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 NetworkSegment(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = segment_model.NetworkSegment
fields = {
'id': obj_fields.UUIDField(),
'network_id': obj_fields.UUIDField(),
'name': obj_fields.StringField(),
'network_type': obj_fields.StringField(),
'physical_network': obj_fields.StringField(nullable=True),
'segmentation_id': obj_fields.IntegerField(nullable=True),
'is_dynamic': obj_fields.BooleanField(default=False),
'segment_index': obj_fields.IntegerField(default=0)
}
foreign_keys = {
'Network': {
'network_id': 'id'
},
'PortBindingLevel': {
'id': 'segment_id'
},
}
@classmethod
def get_objects(cls, context, _pager=None, **kwargs):
if not _pager:
_pager = base.Pager()
if not _pager.sorts:
# (NOTE) True means ASC, False is DESC
_pager.sorts = [(field, True)
for field in ('network_id', 'segment_index')]
return super(NetworkSegment, cls).get_objects(context, _pager,
**kwargs)
class FakeNeutronObjectCompositePrimaryKeyWithId(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = FakeModel
primary_keys = ['id', 'field1']
fields = {
'id': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'obj_field': obj_fields.ListOfObjectsField('FakeSmallNeutronObject')
}
synthetic_fields = ['obj_field']
class PortBinding(PortBindingBase):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = ml2_models.PortBinding
fields = {
'port_id': obj_fields.UUIDField(),
'host': obj_fields.StringField(),
'profile': obj_fields.StringField(),
'vif_type': obj_fields.StringField(),
'vif_details': obj_fields.DictOfStringsField(nullable=True),
'vnic_type': obj_fields.StringField(),
}
primary_keys = ['port_id']
class FakeParent(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = ObjectFieldsModel
primary_keys = ['field1', 'field2']
fields = {
'id': obj_fields.UUIDField(),
'children': obj_fields.ListOfObjectsField(
'FakeSmallNeutronObjectWithMultipleParents',
nullable=True)
}
synthetic_fields = ['children']
class CheckpointRecord(base.KarborPersistentObject, base.KarborObject,
base.KarborObjectDictCompat,
base.KarborComparableObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.UUIDField(),
'project_id': fields.UUIDField(),
'checkpoint_id': fields.UUIDField(),
'checkpoint_status': fields.StringField(),
'provider_id': fields.UUIDField(),
'plan_id': fields.UUIDField(),
'operation_id': fields.UUIDField(nullable=True),
'create_by': fields.StringField(nullable=True),
'extend_info': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(context, checkpoint_record, db_checkpoint_record):
for name, field in checkpoint_record.fields.items():
checkpoint_record[name] = db_checkpoint_record.get(name)
checkpoint_record._context = context
checkpoint_record.obj_reset_changes()
return checkpoint_record
@base.remotable_classmethod
def get_by_id(cls, context, id):
db_checkpoint_record = db.checkpoint_record_get(context, id)
if db_checkpoint_record:
return cls._from_db_object(context, cls(), db_checkpoint_record)
@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_checkpoint_record = db.checkpoint_record_create(self._context,
updates)
self._from_db_object(self._context, self, db_checkpoint_record)
@base.remotable
def save(self):
updates = self.karbor_obj_get_changes()
if updates and self.id:
db.checkpoint_record_update(self._context, self.id, updates)
self.obj_reset_changes()
@base.remotable
def destroy(self):
if self.id:
db.checkpoint_record_destroy(self._context, self.id)
class FakeNeutronObjectCompositePrimaryKeyWithId(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = FakeModel
primary_keys = ['id', 'field1']
fields = {
'id': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'field2': obj_fields.StringField()
}
synthetic_fields = ['field2']
fields_no_update = ['id']
class FakeWeirdKeySmallNeutronObject(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = ObjectFieldsModel
primary_keys = ['field1']
foreign_keys = {
'FakeNeutronObjectNonStandardPrimaryKey': {'field1': 'weird_key'},
'FakeNeutronObjectCompositePrimaryKey': {'field2': 'weird_key'},
}
fields = {
'field1': obj_fields.UUIDField(),
'field2': obj_fields.StringField(),
}
class FakeSmallNeutronObjectWithMultipleParents(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = ObjectFieldsModel
primary_keys = ['field1', 'field2']
foreign_keys = {
'FakeParent': {'field1': 'id'},
'FakeParent2': {'field2': 'id'},
}
fields = {
'field1': obj_fields.UUIDField(),
'field2': obj_fields.StringField(),
}
class FakeNeutronObjectNonStandardPrimaryKey(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = FakeModel
primary_keys = ['weird_key']
fields = {
'weird_key': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'obj_field': obj_fields.ListOfObjectsField(
'FakeWeirdKeySmallNeutronObject'),
'field2': obj_fields.StringField()
}
synthetic_fields = ['obj_field', 'field2']
class SecurityGroup(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = sg_models.SecurityGroup
fields = {
'id': obj_fields.UUIDField(),
'name': obj_fields.StringField(nullable=True),
'project_id': obj_fields.StringField(nullable=True),
'is_default': obj_fields.BooleanField(default=False),
'rules': obj_fields.ListOfObjectsField('SecurityGroupRule',
nullable=True),
# NOTE(ihrachys): we don't include source_rules that is present in the
# model until we realize it's actually needed
}
fields_no_update = ['project_id', 'is_default']
synthetic_fields = ['is_default', 'rules']
extra_filter_names = {'is_default'}
def create(self):
# save is_default before super() resets it to False
is_default = self.is_default
with db_api.autonested_transaction(self.obj_context.session):
super(SecurityGroup, self).create()
if is_default:
default_group = _DefaultSecurityGroup(
self.obj_context,
project_id=self.project_id,
security_group_id=self.id)
default_group.create()
self.is_default = True
self.obj_reset_changes(['is_default'])
def from_db_object(self, *objs):
super(SecurityGroup, self).from_db_object(*objs)
for obj in objs:
self._load_is_default(obj)
def _load_is_default(self, db_obj):
setattr(self, 'is_default', bool(db_obj.get('default_security_group')))
self.obj_reset_changes(['is_default'])
class FakeNeutronDbObject(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = FakeModel
fields = {
'id': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'obj_field': obj_fields.ObjectField('FakeSmallNeutronObject',
nullable=True)
}
primary_keys = ['id']
fields_no_update = ['field1']
synthetic_fields = ['obj_field']
class VolumeProperties(base.CinderObject, base.CinderObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: Added group_id and group_type_id
VERSION = '1.1'
# TODO(dulek): We should add this to initially move volume_properites to
# ovo, but this should be removed as soon as possible. Most of the data
# here is already in request_spec and volume there. Outstanding ones would
# be reservation, and qos_specs. First one may be moved to request_spec and
# second added as relationship in volume_type field and whole
# volume_properties (and resource_properties) in request_spec won't be
# needed.
fields = {
'attach_status': fields.StringField(nullable=True),
'availability_zone': fields.StringField(nullable=True),
'cgsnapshot_id': fields.UUIDField(nullable=True),
'consistencygroup_id': fields.UUIDField(nullable=True),
'group_id': fields.UUIDField(nullable=True),
'display_description': fields.StringField(nullable=True),
'display_name': fields.StringField(nullable=True),
'encryption_key_id': fields.UUIDField(nullable=True),
'metadata': fields.DictOfStringsField(nullable=True),
'multiattach': fields.BooleanField(nullable=True),
'project_id': fields.StringField(nullable=True),
'qos_specs': fields.DictOfStringsField(nullable=True),
'replication_status': fields.StringField(nullable=True),
'reservations': fields.ListOfStringsField(nullable=True),
'size': fields.IntegerField(nullable=True),
'snapshot_id': fields.UUIDField(nullable=True),
'source_replicaid': fields.UUIDField(nullable=True),
'source_volid': fields.UUIDField(nullable=True),
'status': fields.StringField(nullable=True),
'user_id': fields.StringField(nullable=True),
'volume_type_id': fields.UUIDField(nullable=True),
'group_type_id': fields.UUIDField(nullable=True),
}
class Service(base.OrchestratorObject, base.VersionedObjectDictCompat):
"""DC Orchestrator service object."""
fields = {
'id': fields.UUIDField(),
'host': fields.StringField(),
'binary': fields.StringField(),
'topic': fields.StringField(),
'disabled': fields.BooleanField(),
'disabled_reason': fields.StringField(nullable=True),
'created_at': fields.DateTimeField(),
'updated_at': fields.DateTimeField(),
'deleted_at': fields.DateTimeField(nullable=True),
'deleted': fields.IntegerField(nullable=True),
}
@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 AllowedAddressPair(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.AllowedAddressPair
primary_keys = ['port_id', 'mac_address', 'ip_address']
fields = {
'port_id': obj_fields.UUIDField(),
'mac_address': common_types.MACAddressField(),
'ip_address': common_types.IPNetworkField(),
}
foreign_keys = {
'Port': {'port_id': 'id'},
}
# TODO(mhickey): get rid of it once we switch the db model to using
# custom types.
@classmethod
def modify_fields_to_db(cls, fields):
result = super(AllowedAddressPair, cls).modify_fields_to_db(fields)
if 'ip_address' in result:
result['ip_address'] = cls.filter_to_str(result['ip_address'])
if 'mac_address' in result:
result['mac_address'] = cls.filter_to_str(result['mac_address'])
return result
# TODO(mhickey): get rid of it once we switch the db model to using
# custom types.
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(AllowedAddressPair, cls).modify_fields_from_db(db_obj)
if 'ip_address' in fields:
# retain string format as stored in the database
fields['ip_address'] = utils.AuthenticIPNetwork(
fields['ip_address'])
if 'mac_address' in fields:
# retain string format as stored in the database
fields['mac_address'] = utils.AuthenticEUI(
fields['mac_address'])
return fields
class VIFPortProfileOpenVSwitch(VIFPortProfileBase):
# Port profile info for OpenVSwitch networks
# Version 1.0: Initial release
# Version 1.1: Added 'datapath_type'
VERSION = '1.1'
fields = {
'interface_id': fields.UUIDField(),
'profile_id': fields.StringField(),
# Datapath type of the bridge
'datapath_type': fields.StringField(nullable=True),
}
def obj_make_compatible(self, primitive, target_version):
super(VIFPortProfileOpenVSwitch,
self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1) and 'datapath_type' in primitive:
del primitive['datapath_type']
class ConsistencyGroup(base.CinderPersistentObject, base.CinderObject,
base.CinderObjectDictCompat):
VERSION = '1.0'
fields = {
'id': fields.UUIDField(),
'user_id': fields.UUIDField(),
'project_id': fields.UUIDField(),
'host': fields.StringField(nullable=True),
'availability_zone': fields.StringField(nullable=True),
'name': fields.StringField(nullable=True),
'description': fields.StringField(nullable=True),
'volume_type_id': fields.UUIDField(nullable=True),
'status': fields.StringField(nullable=True),
'cgsnapshot_id': fields.UUIDField(nullable=True),
'source_cgid': fields.UUIDField(nullable=True),
}
@staticmethod
def _from_db_object(context, consistencygroup, db_consistencygroup):
for name, field in consistencygroup.fields.items():
value = db_consistencygroup.get(name)
setattr(consistencygroup, name, value)
consistencygroup._context = context
consistencygroup.obj_reset_changes()
return consistencygroup
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason=_('already_created'))
updates = self.cinder_obj_get_changes()
db_consistencygroups = db.consistencygroup_create(
self._context, updates)
self._from_db_object(self._context, self, db_consistencygroups)
@base.remotable
def save(self):
updates = self.cinder_obj_get_changes()
if updates:
db.consistencygroup_update(self._context, self.id, updates)
self.obj_reset_changes()
@base.remotable
def destroy(self):
with self.obj_as_admin():
db.consistencygroup_destroy(self._context, self.id)
class FakeNeutronDbObject(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
rbac_db_model = FakeRbacModel
db_model = FakeDbModel
fields = {
'id': obj_fields.UUIDField(),
'field1': obj_fields.StringField(),
'field2': obj_fields.StringField(),
'shared': obj_fields.BooleanField(default=False),
}
fields_no_update = ['id']
synthetic_fields = ['field2']
def get_bound_tenant_ids(cls, context, policy_id):
pass
class NetworkDNSDomain(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = dns_models.NetworkDNSDomain
primary_keys = ['network_id']
fields = {
'network_id': obj_fields.UUIDField(),
'dns_domain': common_types.DomainNameField(),
}
@classmethod
def get_net_dns_from_port(cls, context, port_id):
net_dns = context.session.query(cls.db_model).join(
models_v2.Port, cls.db_model.network_id ==
models_v2.Port.network_id).filter_by(
id=port_id).one_or_none()
return super(NetworkDNSDomain, cls)._load_object(context, net_dns)
class ClusterLock(senlin_base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin cluster lock object."""
fields = {
'cluster_id': fields.UUIDField(),
'action_ids': fields.ListOfStringsField(),
'semaphore': fields.IntegerField(),
}
@classmethod
def acquire(cls, cluster_id, action_id, scope):
return db_api.cluster_lock_acquire(cluster_id, action_id, scope)
@classmethod
def release(cls, cluster_id, action_id, scope):
return db_api.cluster_lock_release(cluster_id, action_id, scope)
@classmethod
def steal(cls, cluster_id, action_id):
return db_api.cluster_lock_steal(cluster_id, action_id)
class InstanceInfo(base.VersionedObject):
"""Represents important information about a Nova instance."""
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
# UUID of the instance
'uuid': fields.UUIDField(),
# The instance name, directly from the Nova instance field of the
# same name
'name': fields.StringField(),
# The project/tenant ID that owns the instance
'project_id': fields.StringField(),
}
@classmethod
def from_nova_instance(cls, instance):
return cls(uuid=instance.uuid,
name=instance.name,
project_id=instance.project_id)
class PortDNS(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = dns_models.PortDNS
primary_keys = ['port_id']
foreign_keys = {
'Port': {'port_id': 'id'},
}
fields = {
'port_id': obj_fields.UUIDField(),
'current_dns_name': common_types.DomainNameField(),
'current_dns_domain': common_types.DomainNameField(),
'previous_dns_name': common_types.DomainNameField(),
'previous_dns_domain': common_types.DomainNameField(),
'dns_name': common_types.DomainNameField(),
}
class VIFPortProfile8021Qbg(VIFPortProfileBase):
"""Port profile info for VEPA 802.1qbg networks.
This profile provides the metadata required to associate a VIF with a VEPA
host device supporting the :term:`802.1Qbg` spec.
"""
# Version 1.0: Initial release
# Version 1.1: VIFPortProfileBase updated to 1.1 from 1.0
VERSION = '1.1'
fields = {
# TODO(stephenfin): Apparently the value 0 is reserved for manager_id,
# so should we set 'minimum=1'?
# https://libvirt.org/formatdomain.html#elementsNICS
#: The VSI Manager ID identifies the database containing the VSI type
#: and instance definitions.
'manager_id': fields.IntegerField(),
#: The VSI Type ID identifies a VSI type characterizing the network
#: access. VSI types are typically managed by network administrator.
'type_id': fields.IntegerField(),
#: The VSI Type Version allows multiple versions of a VSI Type.
'type_id_version': fields.IntegerField(),
#: The VSI Instance ID Identifier is generated when a VSI instance
#: (i.e. a virtual interface of a virtual machine) is created. This is
#: a globally unique identifier.
'instance_id': fields.UUIDField(),
}
def obj_make_compatible(self, primitive, target_version):
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1):
super(VIFPortProfile8021Qbg,
self).obj_make_compatible(primitive, '1.0')
else:
super(VIFPortProfile8021Qbg,
self).obj_make_compatible(primitive, '1.1')
