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 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 MeteringLabelRule(base.NeutronDbObject):
# Version 1.0: Initial version
# Version 2.0: Source and destination field for the metering label rule
VERSION = '2.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),
'source_ip_prefix': common_types.IPNetworkField(nullable=True),
'destination_ip_prefix': common_types.IPNetworkField(nullable=True),
'metering_label_id': common_types.UUIDField(),
'excluded': obj_fields.BooleanField(default=False),
}
fields_no_update = ['metering_label_id']
@classmethod
def modify_fields_from_db(cls, db_obj):
result = super(MeteringLabelRule, cls).modify_fields_from_db(db_obj)
cls.ip_field_from_db(result, "remote_ip_prefix")
cls.ip_field_from_db(result, "source_ip_prefix")
cls.ip_field_from_db(result, "destination_ip_prefix")
return result
@classmethod
def ip_field_from_db(cls, result, attribute_name):
if attribute_name in result:
result[attribute_name] = net_utils.AuthenticIPNetwork(
result[attribute_name])
@classmethod
def modify_fields_to_db(cls, fields):
result = super(MeteringLabelRule, cls).modify_fields_to_db(fields)
cls.ip_field_to_db(result, "remote_ip_prefix")
cls.ip_field_to_db(result, "source_ip_prefix")
cls.ip_field_to_db(result, "destination_ip_prefix")
return result
@classmethod
def ip_field_to_db(cls, result, attribute_name):
if attribute_name in result:
result[attribute_name] = cls.filter_to_str(result[attribute_name])
class QosPolicyNetworkBinding(base.NeutronDbObject, _QosPolicyBindingMixin):
# 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']
_bound_model_id = db_model.network_id
class QosPolicyRouterGatewayIPBinding(base.NeutronDbObject):
LOG.info('%s(): caller(): %s', log_utils.get_fname(1), log_utils.get_fname(2))
# 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 SecurityGroupPortBinding(base.NeutronDbObject):
LOG.info('%s(): caller(): %s', log_utils.get_fname(1), log_utils.get_fname(2))
# 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 QosPolicyRouterGatewayIPBinding(base.NeutronDbObject,
_QosPolicyBindingMixin):
# 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']
_bound_model_id = db_model.router_id
class BaGPipePortHops(base.NeutronObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'port_id':
common_types.UUIDField(),
'ingress_hops':
obj_fields.ListOfObjectsField('BaGPipeChainHop', nullable=True),
'egress_hops':
obj_fields.ListOfObjectsField('BaGPipeChainHop', nullable=True),
'service_function_parameters':
obj_fields.DictOfStringsField(nullable=True)
}
synthetic_fields = {'ingress_hops', 'egress_hops'}
@classmethod
def get_object(cls, context, **kwargs):
port_id = kwargs['port_id']
ingress_hops = (BaGPipeChainHop.get_chain_hops_for_port_by_side(
context, port_id, constants.INGRESS))
egress_hops = (BaGPipeChainHop.get_chain_hops_for_port_by_side(
context, port_id, constants.EGRESS))
return cls(port_id=port_id,
ingress_hops=ingress_hops,
egress_hops=egress_hops)
@classmethod
def get_objects(cls, context, **kwargs):
raise NotImplementedError()
class AddressScope(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.AddressScope
fields = {
'id': common_types.UUIDField(),
'project_id': obj_fields.StringField(nullable=True),
'name': obj_fields.StringField(),
'shared': obj_fields.BooleanField(),
'ip_version': common_types.IPVersionEnumField(),
}
@classmethod
def get_network_address_scope(cls, context, network_id, ip_version):
query = context.session.query(cls.db_model)
query = query.join(
models_v2.SubnetPool,
models_v2.SubnetPool.address_scope_id == cls.db_model.id)
query = query.filter(
cls.db_model.ip_version == ip_version,
models_v2.Subnet.subnetpool_id == models_v2.SubnetPool.id,
models_v2.Subnet.network_id == network_id)
scope_model_obj = query.one_or_none()
if scope_model_obj:
return cls._load_object(context, scope_model_obj)
return None
class IpamAllocation(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = db_models.IpamAllocation
primary_keys = ['ip_address', 'ipam_subnet_id']
fields = {
'ip_address': obj_fields.IPAddressField(),
'status': common_types.IpamAllocationStatusEnumField(nullable=True),
'ipam_subnet_id': common_types.UUIDField()
}
@classmethod
def modify_fields_from_db(cls, db_obj):
result = super(IpamAllocation, cls).modify_fields_from_db(db_obj)
if 'ip_address' in result:
result['ip_address'] = netaddr.IPAddress(result['ip_address'])
return result
@classmethod
def modify_fields_to_db(cls, fields):
result = super(IpamAllocation, cls).modify_fields_to_db(fields)
if 'ip_address' in result:
result['ip_address'] = cls.filter_to_str(result['ip_address'])
return result
class ConntrackHelper(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.ConntrackHelper
fields = {
'id': common_types.UUIDField(),
'router_id': common_types.UUIDField(),
'protocol': common_types.IpProtocolEnumField(),
'port': common_types.PortRangeField(),
'helper': obj_fields.StringField(),
}
primary_keys = ['id']
foreign_keys = {'Routers': {'router_id': 'id'}}
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 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'] = net_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
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.ACTIVE),
}
primary_keys = ['port_id', 'host']
@classmethod
def get_port_id_and_host(cls, context, vif_type, vnic_type, status):
"""Returns only the port_id and the host of matching registers
This method returns only the primary keys of a "PortBinding" register,
reducing the query complexity and increasing the retrieval speed.
This query does not check the "PortBinding" owner or RBACs.
"""
with cls.db_context_reader(context):
query = context.session.query(cls.db_model.port_id,
cls.db_model.host)
query = query.filter(and_(
cls.db_model.vif_type == vif_type,
cls.db_model.vnic_type == vnic_type,
cls.db_model.status == status))
return query.all()
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 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 AddressAssociation(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.AddressAssociation
fields = {
'address': common_types.IPNetworkField(nullable=False),
'address_group_id': common_types.UUIDField(nullable=False)
}
primary_keys = ['address', 'address_group_id']
foreign_keys = {'AddressGroup': {'address_group_id': 'id'}}
@classmethod
def modify_fields_to_db(cls, fields):
result = super(AddressAssociation, cls).modify_fields_to_db(fields)
if 'address' in result:
result['address'] = cls.filter_to_str(result['address'])
return result
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(AddressAssociation, cls).modify_fields_from_db(db_obj)
if 'address' in fields:
fields['address'] = netaddr.IPNetwork(fields['address'])
return fields
class FakeResource2(BaseFakeResource):
VERSION = TEST_VERSION
fields = {
'id': common_types.UUIDField(),
'field': obj_fields.StringField()
}
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 PortBindingLevel(base.NeutronDbObject):
# Version 1.0: Initial version
# Version 1.1: Added segment_id
VERSION = '1.1'
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),
# arguably redundant but allows us to define foreign key for 'segment'
# synthetic field inside NetworkSegment definition
'segment_id': common_types.UUIDField(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)
def obj_make_compatible(self, primitive, target_version):
_target_version = versionutils.convert_version_to_tuple(target_version)
if _target_version < (1, 1):
primitive.pop('segment_id', None)
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 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()
def to_dict(self):
_dict = super(Trunk, self).to_dict()
resource_extend.apply_funcs(trunk_def.TRUNKS, _dict, self.db_obj)
return _dict
class LocalIP(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = lip_db.LocalIP
fields = {
'id': common_types.UUIDField(),
'name': obj_fields.StringField(nullable=True),
'description': obj_fields.StringField(nullable=True),
'project_id': obj_fields.StringField(nullable=True),
'local_port_id': common_types.UUIDField(),
'network_id': common_types.UUIDField(),
'local_ip_address': obj_fields.IPAddressField(),
'ip_mode': obj_fields.StringField(),
}
foreign_keys = {
'Port': {
'local_port_id': 'id'
},
'LocalIPAssociation': {
'id': 'local_ip_id'
}
}
fields_no_update = [
'project_id', 'local_ip_address', 'network_id', 'local_port_id'
]
synthetic_fields = []
@classmethod
def modify_fields_to_db(cls, fields):
result = super(LocalIP, cls).modify_fields_to_db(fields)
if 'local_ip_address' in result:
result['local_ip_address'] = cls.filter_to_str(
result['local_ip_address'])
return result
@classmethod
def modify_fields_from_db(cls, db_obj):
fields = super(LocalIP, cls).modify_fields_from_db(db_obj)
if 'local_ip_address' in fields:
fields['local_ip_address'] = netaddr.IPAddress(
fields['local_ip_address'])
return fields
class RouterL3AgentBinding(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = l3agent.RouterL3AgentBinding
primary_keys = ['router_id', 'l3_agent_id']
fields = {
'router_id':
common_types.UUIDField(),
'l3_agent_id':
common_types.UUIDField(),
'binding_index':
obj_fields.IntegerField(default=l3agent.LOWEST_BINDING_INDEX),
}
# TODO(ihrachys) return OVO objects not models
# TODO(ihrachys) move under Agent object class
@classmethod
@db_api.CONTEXT_READER
def get_l3_agents_by_router_ids(cls, context, router_ids):
query = context.session.query(l3agent.RouterL3AgentBinding)
query = query.options(joinedload('l3_agent')).filter(
l3agent.RouterL3AgentBinding.router_id.in_(router_ids))
return [db_obj.l3_agent for db_obj in query.all()]
@classmethod
@db_api.CONTEXT_READER
def get_down_router_bindings(cls, context, cutoff):
query = (context.session.query(l3agent.RouterL3AgentBinding).join(
agent_model.Agent).filter(
agent_model.Agent.heartbeat_timestamp < cutoff,
agent_model.Agent.admin_state_up).outerjoin(
l3_attrs.RouterExtraAttributes,
l3_attrs.RouterExtraAttributes.router_id ==
l3agent.RouterL3AgentBinding.router_id).filter(
sa.or_(
l3_attrs.RouterExtraAttributes.ha == sql.false(),
l3_attrs.RouterExtraAttributes.ha == sql.null())))
bindings = [
cls._load_object(context, db_obj) for db_obj in query.all()
]
return bindings
class Router(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = l3.Router
fields = {
'id':
common_types.UUIDField(),
'project_id':
obj_fields.StringField(nullable=True),
'name':
obj_fields.StringField(nullable=True),
'status':
common_types.RouterStatusEnumField(nullable=True),
'admin_state_up':
obj_fields.BooleanField(nullable=True),
'gw_port_id':
common_types.UUIDField(nullable=True),
'enable_snat':
obj_fields.BooleanField(default=True),
'flavor_id':
common_types.UUIDField(nullable=True),
'extra_attributes':
obj_fields.ObjectField('RouterExtraAttributes', nullable=True),
}
synthetic_fields = ['extra_attributes']
fields_no_update = ['project_id']
@classmethod
def check_routers_not_owned_by_projects(cls, context, gw_ports, projects):
"""This method is to check whether routers that aren't owned by
existing projects or not
"""
# TODO(hungpv) We may want to implement NOT semantic in get_object(s)
query = context.session.query(l3.Router).filter(
l3.Router.gw_port_id.in_(gw_ports))
query = query.filter(~l3.Router.project_id.in_(projects))
return bool(query.count())
class Log(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = log_db.Log
fields = {
'id': common_types.UUIDField(),
'project_id': obj_fields.StringField(nullable=True),
'name': obj_fields.StringField(nullable=True),
'resource_type': obj_fields.StringField(),
'resource_id': common_types.UUIDField(nullable=True, default=None),
'target_id': common_types.UUIDField(nullable=True, default=None),
'event': event_types.SecurityEventField(default=log_const.ALL_EVENT),
'enabled': obj_fields.BooleanField(default=True),
}
fields_no_update = ['project_id', 'resource_type', 'resource_id',
'target_id', 'event']
class ExtraDhcpOpt(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = models.ExtraDhcpOpt
fields = {
'id': common_types.UUIDField(),
'port_id': common_types.UUIDField(),
'opt_name': obj_fields.StringField(),
'opt_value': obj_fields.StringField(),
'ip_version': obj_fields.IntegerField(),
}
fields_no_update = ['port_id']
foreign_keys = {
'Port': {'port_id': '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': common_types.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'] = net_utils.AuthenticIPNetwork(
fields['ip_address'])
if 'mac_address' in fields:
# retain string format as stored in the database
fields['mac_address'] = net_utils.AuthenticEUI(
fields['mac_address'])
return fields
@classmethod
def get_allowed_address_pairs_for_ports(cls, context, port_ids):
with db_api.CONTEXT_READER.using(context):
query = context.session.query(models.AllowedAddressPair).filter(
models.AllowedAddressPair.port_id.in_(port_ids))
pairs = [
cls._load_object(context, db_obj) for db_obj in query.all()
]
return pairs
class SecurityGroupRule(base.NeutronDbObject):
# Version 1.0: Initial version
VERSION = '1.0'
db_model = sg_models.SecurityGroupRule
fields = {
'id': common_types.UUIDField(),
'project_id': obj_fields.StringField(nullable=True),
'security_group_id': common_types.UUIDField(),
'remote_group_id': common_types.UUIDField(nullable=True),
'direction': common_types.FlowDirectionEnumField(nullable=True),
'ethertype': common_types.EtherTypeEnumField(nullable=True),
'protocol': common_types.IpProtocolEnumField(nullable=True),
'port_range_min': common_types.PortRangeWith0Field(nullable=True),
'port_range_max': common_types.PortRangeWith0Field(nullable=True),
'remote_ip_prefix': common_types.IPNetworkField(nullable=True),
}
foreign_keys = {'SecurityGroup': {'security_group_id': 'id'}}
fields_no_update = ['project_id', 'security_group_id', 'remote_group_id']
# TODO(sayalilunkad): get rid of it once we switch the db model to using
# custom types.
@classmethod
def modify_fields_to_db(cls, fields):
result = super(SecurityGroupRule, cls).modify_fields_to_db(fields)
remote_ip_prefix = result.get('remote_ip_prefix')
if remote_ip_prefix:
result['remote_ip_prefix'] = cls.filter_to_str(remote_ip_prefix)
return result
# TODO(sayalilunkad): 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(SecurityGroupRule, cls).modify_fields_from_db(db_obj)
if 'remote_ip_prefix' in fields:
fields['remote_ip_prefix'] = (
net_utils.AuthenticIPNetwork(fields['remote_ip_prefix']))
return fields
class _PortSecurity(base.NeutronDbObject):
fields = {
'id': common_types.UUIDField(),
'port_security_enabled': obj_fields.BooleanField(
default=port_security.DEFAULT_PORT_SECURITY),
}
foreign_keys = {
'Port': {'id': 'id'},
'Network': {'id': 'id'},
}
