class NetworkSegment(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = segment_model.NetworkSegment
fields = {
'id': common_types.UUIDField(),
'network_id': common_types.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 SubnetPool(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.SubnetPool
fields = {
'id': common_types.UUIDField(),
'project_id': obj_fields.StringField(nullable=True),
'name': obj_fields.StringField(nullable=True),
'ip_version': common_types.IPVersionEnumField(),
'default_prefixlen': common_types.IPNetworkPrefixLenField(),
'min_prefixlen': common_types.IPNetworkPrefixLenField(),
'max_prefixlen': common_types.IPNetworkPrefixLenField(),
'shared': obj_fields.BooleanField(),
'is_default': obj_fields.BooleanField(),
'default_quota': obj_fields.IntegerField(nullable=True),
'hash': obj_fields.StringField(nullable=True),
'address_scope_id': common_types.UUIDField(nullable=True),
'prefixes': common_types.ListOfIPNetworksField(nullable=True)
}
fields_no_update = ['id', 'project_id']
synthetic_fields = ['prefixes']
def from_db_object(self, db_obj):
super(SubnetPool, self).from_db_object(db_obj)
self.prefixes = []
self.prefixes = [
prefix.cidr
for prefix in db_obj.get('prefixes', [])
]
self.obj_reset_changes(['prefixes'])
def _attach_prefixes(self, prefixes):
SubnetPoolPrefix.delete_objects(self.obj_context,
subnetpool_id=self.id)
for prefix in prefixes:
SubnetPoolPrefix(self.obj_context, subnetpool_id=self.id,
cidr=prefix).create()
self.prefixes = prefixes
self.obj_reset_changes(['prefixes'])
# TODO(ihrachys): Consider extending base to trigger registered methods
def create(self):
fields = self.obj_get_changes()
with self.db_context_writer(self.obj_context):
prefixes = self.prefixes
super(SubnetPool, self).create()
if 'prefixes' in fields:
self._attach_prefixes(prefixes)
# TODO(ihrachys): Consider extending base to trigger registered methods
def update(self):
fields = self.obj_get_changes()
with self.db_context_writer(self.obj_context):
super(SubnetPool, self).update()
if 'prefixes' in fields:
self._attach_prefixes(fields['prefixes'])
class L3HARouterAgentPortBinding(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = l3ha.L3HARouterAgentPortBinding
fields = {
'port_id':
common_types.UUIDField(),
'router_id':
common_types.UUIDField(),
'l3_agent_id':
common_types.UUIDField(nullable=True),
'state':
common_types.HARouterEnumField(
default=constants.HA_ROUTER_STATE_STANDBY),
}
primary_keys = ['port_id']
fields_no_update = ['router_id', 'port_id', 'l3_agent_id']
@classmethod
def get_l3ha_filter_host_router(cls, context, router_ids, host):
query = context.session.query(l3ha.L3HARouterAgentPortBinding)
if host:
query = query.join(
agent_model.Agent).filter(agent_model.Agent.host == host)
query = query.filter(
l3ha.L3HARouterAgentPortBinding.router_id.in_(router_ids))
return query.all()
class Trunk(base.NeutronDbObject):
# Version 1.0: Initial version
# Version 1.1: Changed tenant_id to project_id
VERSION = '1.1'
db_model = models.Trunk
new_facade = True
fields = {
'admin_state_up': obj_fields.BooleanField(),
'id': common_types.UUIDField(),
'project_id': obj_fields.StringField(),
'name': obj_fields.StringField(),
'port_id': common_types.UUIDField(),
'status': obj_fields.StringField(),
'sub_ports': obj_fields.ListOfObjectsField(SubPort.__name__),
}
fields_no_update = ['project_id', 'port_id']
synthetic_fields = ['sub_ports']
def create(self):
with self.db_context_writer(self.obj_context):
sub_ports = []
if self.obj_attr_is_set('sub_ports'):
sub_ports = self.sub_ports
try:
super(Trunk, self).create()
except o_db_exc.DBReferenceError:
raise n_exc.PortNotFound(port_id=self.port_id)
if sub_ports:
for sub_port in sub_ports:
sub_port.trunk_id = self.id
sub_port.create()
self.sub_ports.append(sub_port)
self.obj_reset_changes(['sub_ports'])
def update(self, **kwargs):
self.update_fields(kwargs)
super(Trunk, self).update()
# TODO(hichihara): For tag mechanism. This will be removed in bug/1704137
def to_dict(self):
_dict = super(Trunk, self).to_dict()
try:
_dict['tags'] = [t.tag for t in self.db_obj.standard_attr.tags]
except AttributeError:
# AttrtibuteError can be raised when accessing self.db_obj
# or self.db_obj.standard_attr
pass
return _dict
def obj_make_compatible(self, primitive, target_version):
_target_version = versionutils.convert_version_to_tuple(target_version)
if _target_version < (1, 1):
primitive['tenant_id'] = primitive.pop('project_id')
class RouterPort(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = l3.RouterPort
primary_keys = ['router_id', 'port_id']
foreign_keys = {'Router': {'router_id': 'id'}}
fields = {
'router_id': common_types.UUIDField(),
'port_id': common_types.UUIDField(),
'port_type': obj_fields.StringField(nullable=True),
}
@classmethod
def get_router_ids_by_subnetpool(cls, context, subnetpool_id):
query = context.session.query(l3.RouterPort.router_id)
query = query.join(models_v2.Port)
query = query.join(
models_v2.Subnet,
models_v2.Subnet.network_id == models_v2.Port.network_id)
query = query.filter(
models_v2.Subnet.subnetpool_id == subnetpool_id,
l3.RouterPort.port_type.in_(n_const.ROUTER_PORT_OWNERS))
query = query.distinct()
return [r[0] for r in query]
class NetworkDhcpAgentBinding(base.NeutronDbObject):
# Version 1.0: Initial version
# Version 1.1: Added 'binding_index'
VERSION = '1.1'
db_model = ndab_models.NetworkDhcpAgentBinding
primary_keys = ['network_id', 'dhcp_agent_id']
fields = {
'network_id': common_types.UUIDField(),
'dhcp_agent_id': common_types.UUIDField(),
'binding_index': obj_fields.IntegerField(),
}
# NOTE(ndahiwade): The join was implemented this way as get_objects
# currently doesn't support operators like '<' or '>'
@classmethod
def get_down_bindings(cls, context, cutoff):
agent_objs = agent_obj.Agent.get_objects(context)
dhcp_agent_ids = [
obj.id for obj in agent_objs if obj.heartbeat_timestamp < cutoff
]
return cls.get_objects(context, dhcp_agent_id=dhcp_agent_ids)
class MeteringLabelRule(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = metering_models.MeteringLabelRule
foreign_keys = {'MeteringLabel': {'metering_label_id': 'id'}}
fields = {
'id': common_types.UUIDField(),
'direction': common_types.FlowDirectionEnumField(nullable=True),
'remote_ip_prefix': common_types.IPNetworkField(nullable=True),
'metering_label_id': common_types.UUIDField(),
'excluded': obj_fields.BooleanField(default=False),
}
@classmethod
def modify_fields_from_db(cls, db_obj):
result = super(MeteringLabelRule, cls).modify_fields_from_db(db_obj)
if 'remote_ip_prefix' in result:
result['remote_ip_prefix'] = utils.AuthenticIPNetwork(
result['remote_ip_prefix'])
return result
@classmethod
def modify_fields_to_db(cls, fields):
result = super(MeteringLabelRule, cls).modify_fields_to_db(fields)
if 'remote_ip_prefix' in result:
result['remote_ip_prefix'] = cls.filter_to_str(
result['remote_ip_prefix'])
return result
class IpamAllocationPool(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = db_models.IpamAllocationPool
foreign_keys = {'IpamSubnet': {'ipam_subnet_id': 'id'}}
fields = {
'id': common_types.UUIDField(),
'ipam_subnet_id': common_types.UUIDField(),
'first_ip': obj_fields.IPAddressField(),
'last_ip': obj_fields.IPAddressField(),
}
fields_no_update = ['ipam_subnet_id']
@classmethod
def modify_fields_from_db(cls, db_obj):
result = super(IpamAllocationPool, cls).modify_fields_from_db(db_obj)
if 'first_ip' in result:
result['first_ip'] = netaddr.IPAddress(result['first_ip'])
if 'last_ip' in result:
result['last_ip'] = netaddr.IPAddress(result['last_ip'])
return result
@classmethod
def modify_fields_to_db(cls, fields):
result = super(IpamAllocationPool, 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 IPAllocation(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models_v2.IPAllocation
fields = {
'port_id': common_types.UUIDField(nullable=True),
'subnet_id': common_types.UUIDField(),
'network_id': common_types.UUIDField(),
'ip_address': obj_fields.IPAddressField(),
}
fields_no_update = fields.keys()
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
@classmethod
def get_alloc_by_subnet_id(cls, context, subnet_id, device_owner,
exclude=True):
# need to join with ports table as IPAllocation's port
# is not joined eagerly and thus producing query which yields
# incorrect results
if exclude:
alloc_db = (context.session.query(models_v2.IPAllocation).
filter_by(subnet_id=subnet_id).join(models_v2.Port).
filter(~models_v2.Port.device_owner.
in_(device_owner)).first())
else:
alloc_db = (context.session.query(models_v2.IPAllocation).
filter_by(subnet_id=subnet_id).join(models_v2.Port).
filter(models_v2.Port.device_owner.
in_(device_owner)).first())
if exclude and alloc_db:
return super(IPAllocation, cls)._load_object(context, alloc_db)
if alloc_db:
return True
class CGToClassificationGroupMapping(base.NeutronDbObject):
VERSION = '1.0'
rbac_db_model = ClassificationGroupRBAC
db_model = models.CGToClassificationGroupMapping
fields = {
'container_cg_id': common_types.UUIDField(),
'stored_cg_id': common_types.UUIDField()
}
class SubPort(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.SubPort
new_facade = True
primary_keys = ['port_id']
foreign_keys = {'Trunk': {'trunk_id': 'id'}}
fields = {
'port_id': common_types.UUIDField(),
'trunk_id': common_types.UUIDField(),
'segmentation_type': obj_fields.StringField(),
'segmentation_id': obj_fields.IntegerField(),
}
fields_no_update = ['segmentation_type', 'segmentation_id', 'trunk_id']
def to_dict(self):
_dict = super(SubPort, self).to_dict()
# trunk_id is redundant in the subport dict.
_dict.pop('trunk_id')
return _dict
def create(self):
try:
with self.db_context_writer(self.obj_context):
super(SubPort, self).create()
except o_db_exc.DBReferenceError as ex:
if ex.key_table is None:
# NOTE(ivc): 'key_table' is provided by 'oslo.db' [1]
# only for a limited set of database backends (i.e.
# MySQL and PostgreSQL). Other database backends
# (including SQLite) would have 'key_table' set to None.
# We emulate the 'key_table' support for such database
# backends.
#
# [1] https://github.com/openstack/oslo.db/blob/3fadd5a
# /oslo_db/sqlalchemy/exc_filters.py#L190-L203
self.obj_context.session.rollback()
with self.db_context_reader(self.obj_context):
if not Trunk.get_object(self.obj_context,
id=self.trunk_id):
ex.key_table = Trunk.db_model.__tablename__
if ex.key_table == Trunk.db_model.__tablename__:
raise t_exc.TrunkNotFound(trunk_id=self.trunk_id)
raise n_exc.PortNotFound(port_id=self.port_id)
except o_exc.NeutronDbObjectDuplicateEntry:
raise t_exc.DuplicateSubPort(
segmentation_type=self.segmentation_type,
segmentation_id=self.segmentation_id,
trunk_id=self.trunk_id)
class QosRule(base.NeutronDbObject):
# Version 1.0: Initial version, only BandwidthLimitRule
# 1.1: Added DscpMarkingRule
# 1.2: Added QosMinimumBandwidthRule
# 1.3: Added direction for BandwidthLimitRule
#
#NOTE(mangelajo): versions need to be handled from the top QosRule object
# because it's the only reference QosPolicy can make
# to them via obj_relationships version map
VERSION = '1.3'
fields = {
'id': common_types.UUIDField(),
'qos_policy_id': common_types.UUIDField()
}
fields_no_update = ['id', 'qos_policy_id']
# should be redefined in subclasses
rule_type = None
def to_dict(self):
dict_ = super(QosRule, self).to_dict()
dict_['type'] = self.rule_type
return dict_
def should_apply_to_port(self, port):
"""Check whether a rule can be applied to a specific port.
This function has the logic to decide whether a rule should
be applied to a port or not, depending on the source of the
policy (network, or port). Eventually rules could override
this method, or we could make it abstract to allow different
rule behaviour.
"""
is_port_policy = self.qos_policy_id == port[qos_consts.QOS_POLICY_ID]
is_network_policy_only = port[qos_consts.QOS_POLICY_ID] is None
is_network_device_port = any(
port['device_owner'].startswith(prefix)
for prefix in constants.DEVICE_OWNER_PREFIXES)
# NOTE(miouge): Network QoS policies should apply to ext routers ports:
# - DEVICE_OWNER_AGENT_GW for DVR routers
# - DEVICE_OWNER_ROUTER_GW for normal neutron routers
is_router_gw = any(port['device_owner'].startswith(prefix)
for prefix in [
constants.DEVICE_OWNER_AGENT_GW,
constants.DEVICE_OWNER_ROUTER_GW
])
# NOTE(ralonsoh): return True if:
# - Is a port QoS policy (not a network QoS policy)
# - Is not an internal network device (e.g. router) and is a network
# QoS policy and there is no port QoS policy
return (is_port_policy or ((is_router_gw or not is_network_device_port)
and is_network_policy_only))
class FlavorServiceProfileBinding(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.FlavorServiceProfileBinding
primary_keys = ['flavor_id', 'service_profile_id']
fields = {
'flavor_id': common_types.UUIDField(),
'service_profile_id': common_types.UUIDField(),
}
class AutoAllocatedTopology(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.AutoAllocatedTopology
primary_keys = ['project_id']
fields = {
'project_id': obj_fields.StringField(),
'network_id': common_types.UUIDField(),
'router_id': common_types.UUIDField(nullable=True),
}
class SecurityGroupPortBinding(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = sg_models.SecurityGroupPortBinding
fields = {
'port_id': common_types.UUIDField(),
'security_group_id': common_types.UUIDField(),
}
primary_keys = ['port_id', 'security_group_id']
class QosPolicyNetworkBinding(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = qos_db_model.QosNetworkPolicyBinding
fields = {
'policy_id': common_types.UUIDField(),
'network_id': common_types.UUIDField()
}
primary_keys = ['network_id']
fields_no_update = ['policy_id', 'network_id']
class QosPolicyRouterGatewayIPBinding(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = qos_db_model.QosRouterGatewayIPPolicyBinding
fields = {
'policy_id': common_types.UUIDField(),
'router_id': common_types.UUIDField()
}
primary_keys = ['policy_id', 'router_id']
fields_no_update = ['policy_id', 'router_id']
class IpamSubnet(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = db_models.IpamSubnet
fields = {
'id': common_types.UUIDField(),
'neutron_subnet_id': common_types.UUIDField(nullable=True),
'allocation_pools': obj_fields.ListOfObjectsField('IpamAllocationPool')
}
synthetic_fields = ['allocation_pools']
class RouterPort(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = l3.RouterPort
primary_keys = ['router_id', 'port_id']
foreign_keys = {'Router': {'router_id': 'id'}}
fields = {
'router_id': common_types.UUIDField(),
'port_id': common_types.UUIDField(),
'port_type': obj_fields.StringField(nullable=True),
}
class Trunk(base.NeutronDbObject):
# Version 1.0: Initial version
# Version 1.1: Changed tenant_id to project_id
VERSION = '1.1'
db_model = models.Trunk
fields = {
'admin_state_up': obj_fields.BooleanField(),
'id': common_types.UUIDField(),
'project_id': obj_fields.StringField(),
'name': obj_fields.StringField(),
'port_id': common_types.UUIDField(),
'status': obj_fields.StringField(),
'sub_ports': obj_fields.ListOfObjectsField(SubPort.__name__),
}
fields_no_update = ['project_id', 'port_id']
synthetic_fields = ['sub_ports']
def create(self):
with db_api.autonested_transaction(self.obj_context.session):
sub_ports = []
if self.obj_attr_is_set('sub_ports'):
sub_ports = self.sub_ports
try:
super(Trunk, self).create()
except o_db_exc.DBReferenceError:
raise n_exc.PortNotFound(port_id=self.port_id)
if sub_ports:
for sub_port in sub_ports:
sub_port.trunk_id = self.id
sub_port.create()
self.sub_ports.append(sub_port)
self.obj_reset_changes(['sub_ports'])
def update(self, **kwargs):
self.update_fields(kwargs)
super(Trunk, self).update()
def obj_make_compatible(self, primitive, target_version):
_target_version = versionutils.convert_version_to_tuple(target_version)
if _target_version < (1, 1):
primitive['tenant_id'] = primitive.pop('project_id')
class PortBinding(PortBindingBase):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = ml2_models.PortBinding
fields = {
'port_id':
common_types.UUIDField(),
'host':
obj_fields.StringField(),
'profile':
common_types.DictOfMiscValuesField(),
'vif_type':
obj_fields.StringField(),
'vif_details':
common_types.DictOfMiscValuesField(nullable=True),
'vnic_type':
obj_fields.StringField(),
'status':
common_types.PortBindingStatusEnumField(
default=constants.PORT_BINDING_STATUS_ACTIVE),
}
primary_keys = ['port_id', 'host']
class PortDNS(base.NeutronDbObject):
# Version 1.0: Initial version
# Version 1.1: Add dns_domain attribute
VERSION = '1.1'
db_model = dns_models.PortDNS
primary_keys = ['port_id']
foreign_keys = {
'Port': {
'port_id': 'id'
},
}
fields = {
'port_id': common_types.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(),
'dns_domain': common_types.DomainNameField(),
}
def obj_make_compatible(self, primitive, target_version):
_target_version = versionutils.convert_version_to_tuple(target_version)
if _target_version < (1, 1):
primitive.pop('dns_domain', None)
class SecurityGroup(rbac_db.NeutronRbacObject):
# Version 1.0: Initial version
# Version 1.1: Add RBAC support
VERSION = '1.1'
# required by RbacNeutronMetaclass
rbac_db_cls = SecurityGroupRBAC
db_model = sg_models.SecurityGroup
fields = {
'id': common_types.UUIDField(),
'name': obj_fields.StringField(nullable=True),
'project_id': obj_fields.StringField(nullable=True),
'shared': obj_fields.BooleanField(default=False),
'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'}
lazy_fields = set(['rules'])
def create(self):
# save is_default before super() resets it to False
is_default = self.is_default
with self.db_context_writer(self.obj_context):
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, db_obj):
super(SecurityGroup, self).from_db_object(db_obj)
if self._load_synthetic_fields:
setattr(self, 'is_default',
bool(db_obj.get('default_security_group')))
self.obj_reset_changes(['is_default'])
def obj_make_compatible(self, primitive, target_version):
_target_version = versionutils.convert_version_to_tuple(target_version)
if _target_version < (1, 1):
primitive.pop('shared')
@classmethod
def get_bound_tenant_ids(cls, context, obj_id):
port_objs = ports.Port.get_objects(context,
security_group_ids=[obj_id])
return {port.tenant_id for port in port_objs}
class FakeObjectWithStandardAttributes(objects_base.NeutronDbObject):
VERSION = '1.0'
db_model = FakeDbModelWithStandardAttributes
fields = {
'id': common_types.UUIDField(),
'item': obj_fields.StringField(),
}
class PortBindingLevel(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = ml2_models.PortBindingLevel
primary_keys = ['port_id', 'host', 'level']
fields = {
'port_id': common_types.UUIDField(),
'host': obj_fields.StringField(),
'level': obj_fields.IntegerField(),
'driver': obj_fields.StringField(nullable=True),
'segment': obj_fields.ObjectField(
'NetworkSegment', nullable=True
),
}
synthetic_fields = ['segment']
foreign_keys = {
'Port': {'port_id': 'id'},
}
@classmethod
def get_objects(cls, context, _pager=None, validate_filters=True,
**kwargs):
if not _pager:
_pager = base.Pager()
if not _pager.sorts:
# (NOTE) True means ASC, False is DESC
_pager.sorts = [('port_id', True), ('level', True)]
return super(PortBindingLevel, cls).get_objects(
context, _pager, validate_filters, **kwargs)
class SubnetPoolPrefix(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.SubnetPoolPrefix
fields = {
'subnetpool_id': common_types.UUIDField(),
'cidr': common_types.IPNetworkField(),
}
primary_keys = ['subnetpool_id', 'cidr']
# TODO(ihrachys): get rid of it once we switch the db model to using CIDR
# custom type
@classmethod
def modify_fields_to_db(cls, fields):
result = super(SubnetPoolPrefix, cls).modify_fields_to_db(fields)
if 'cidr' in result:
result['cidr'] = cls.filter_to_str(result['cidr'])
return result
# TODO(ihrachys): get rid of it once we switch the db model to using CIDR
# custom type
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(SubnetPoolPrefix, cls).modify_fields_from_db(db_obj)
if 'cidr' in fields:
fields['cidr'] = netaddr.IPNetwork(fields['cidr'])
return fields
class SubnetServiceType(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = subnet_service_type.SubnetServiceType
foreign_keys = {'Subnet': {'subnet_id': 'id'}}
primary_keys = ['subnet_id', 'service_type']
fields = {
'subnet_id': common_types.UUIDField(),
'service_type': obj_fields.StringField()
}
@classmethod
def query_filter_service_subnets(cls, query, service_type):
# TODO(tuanvu): find OVO-like solution for handling "join queries"
Subnet = models_v2.Subnet
ServiceType = subnet_service_type.SubnetServiceType
query = query.add_entity(ServiceType)
query = query.outerjoin(ServiceType)
query = query.filter(
or_(
ServiceType.service_type.is_(None),
ServiceType.service_type == service_type,
# Allow DHCP ports to be created on subnets of any
# service type when DHCP is enabled on the subnet.
and_(Subnet.enable_dhcp.is_(True),
service_type == const.DEVICE_OWNER_DHCP)))
return query.from_self(Subnet)
class FakeResource2(BaseFakeResource):
VERSION = TEST_VERSION
fields = {
'id': common_types.UUIDField(),
'field': obj_fields.StringField()
}
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': {'subnet_id': 'id'}}
fields = {
'address': obj_fields.StringField(),
'subnet_id': common_types.UUIDField(),
'order': obj_fields.IntegerField()
}
@classmethod
def get_objects(cls,
context,
_pager=None,
validate_filters=True,
**kwargs):
"""Fetch DNSNameServer objects with default sort by 'order' field.
"""
if not _pager:
_pager = base.Pager()
if not _pager.sorts:
# (NOTE) True means ASC, False is DESC
_pager.sorts = [('order', True)]
return super(DNSNameServer,
cls).get_objects(context, _pager, validate_filters,
**kwargs)
class RouterRoute(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = l3.RouterRoute
fields = {
'router_id': common_types.UUIDField(),
'destination': common_types.IPNetworkField(),
'nexthop': obj_fields.IPAddressField()
}
primary_keys = ['router_id', 'destination', 'nexthop']
foreign_keys = {'Router': {'router_id': 'id'}}
@classmethod
def modify_fields_from_db(cls, db_obj):
result = super(RouterRoute, cls).modify_fields_from_db(db_obj)
if 'destination' in result:
result['destination'] = utils.AuthenticIPNetwork(
result['destination'])
if 'nexthop' in result:
result['nexthop'] = netaddr.IPAddress(result['nexthop'])
return result
@classmethod
def modify_fields_to_db(cls, fields):
result = super(RouterRoute, cls).modify_fields_to_db(fields)
if 'destination' in result:
result['destination'] = cls.filter_to_str(result['destination'])
if 'nexthop' in result:
result['nexthop'] = cls.filter_to_str(result['nexthop'])
return result
