def delete_segment(self, context, uuid, for_net_delete=False):
"""Delete an existing segment."""
segment_dict = self.get_segment(context, uuid)
# Do some preliminary operations before deleting the segment
registry.publish(resources.SEGMENT,
events.BEFORE_DELETE,
self.delete_segment,
payload=events.DBEventPayload(
context,
metadata={'for_net_delete': for_net_delete},
states=(segment_dict, ),
resource_id=uuid))
# Delete segment in DB
with db_api.CONTEXT_WRITER.using(context):
if not network.NetworkSegment.delete_objects(context, id=uuid):
raise exceptions.SegmentNotFound(segment_id=uuid)
# Do some preliminary operations before deleting segment in db
registry.notify(resources.SEGMENT,
events.PRECOMMIT_DELETE,
self.delete_segment,
context=context,
segment=segment_dict)
registry.publish(resources.SEGMENT,
events.AFTER_DELETE,
self.delete_segment,
payload=events.DBEventPayload(context,
states=(segment_dict, ),
resource_id=uuid))
def delete_segment(self, context, uuid):
"""Delete an existing segment."""
segment = self.get_segment(context, uuid)
# Do some preliminary operations before deleting the segment
registry.notify(resources.SEGMENT,
events.BEFORE_DELETE,
self.delete_segment,
context=context,
segment=segment)
# Delete segment in DB
with context.session.begin(subtransactions=True):
query = self._model_query(context, segment_model.NetworkSegment)
query = query.filter(segment_model.NetworkSegment.id == uuid)
if 0 == query.delete():
raise exceptions.SegmentNotFound(segment_id=uuid)
# Do some preliminary operations before deleting segment in db
registry.notify(resources.SEGMENT,
events.PRECOMMIT_DELETE,
self.delete_segment,
context=context,
segment=segment)
registry.notify(resources.SEGMENT,
events.AFTER_DELETE,
self.delete_segment,
context=context,
segment=segment)
def delete_segment(self, context, uuid):
"""Delete an existing segment."""
with context.session.begin(subtransactions=True):
query = self._model_query(context, db.NetworkSegment)
query = query.filter(db.NetworkSegment.id == uuid)
if 0 == query.delete():
raise exceptions.SegmentNotFound(segment_id=uuid)
def delete_segment(self, context, uuid, for_net_delete=False):
"""Delete an existing segment."""
segment_dict = self.get_segment(context, uuid)
# Do some preliminary operations before deleting the segment
registry.notify(resources.SEGMENT,
events.BEFORE_DELETE,
self.delete_segment,
context=context,
segment=segment_dict,
for_net_delete=for_net_delete)
# Delete segment in DB
with db_api.context_manager.writer.using(context):
if not network.NetworkSegment.delete_objects(context, id=uuid):
raise exceptions.SegmentNotFound(segment_id=uuid)
# Do some preliminary operations before deleting segment in db
registry.notify(resources.SEGMENT,
events.PRECOMMIT_DELETE,
self.delete_segment,
context=context,
segment=segment_dict)
registry.notify(resources.SEGMENT,
events.AFTER_DELETE,
self.delete_segment,
context=context,
segment=segment_dict)
def _save_subnet(self, context, network, subnet_args, dns_nameservers,
host_routes, subnet_request):
network_scope = addr_scope_obj.AddressScope.get_network_address_scope(
context, network.id, subnet_args['ip_version'])
# 'subnetpool' is not necessarily an object
subnetpool = subnet_args.get('subnetpool_id')
if subnetpool and subnetpool != const.IPV6_PD_POOL_ID:
subnetpool = self._get_subnetpool(context, subnetpool)
self._validate_subnet_cidr(context, network, subnet_args['cidr'])
self._validate_network_subnetpools(network, subnet_args['ip_version'],
subnetpool, network_scope)
service_types = subnet_args.pop('service_types', [])
segment_id = subnet_args.get('segment_id')
if segment_id:
# TODO(slaweq): integrate check if segment exists in
# self._validate_segment() method
if not network_obj.NetworkSegment.get_object(context,
id=segment_id):
raise segment_exc.SegmentNotFound(segment_id=segment_id)
subnet = subnet_obj.Subnet(context, **subnet_args)
subnet.create()
# TODO(slaweq): when check is segment exists will be integrated in
# self._validate_segment() method, it should be moved to be done before
# subnet object is created
self._validate_segment(context, network['id'], segment_id)
# NOTE(changzhi) Store DNS nameservers with order into DB one
# by one when create subnet with DNS nameservers
if validators.is_attr_set(dns_nameservers):
for order, server in enumerate(dns_nameservers):
dns = subnet_obj.DNSNameServer(context,
address=server,
order=order,
subnet_id=subnet.id)
dns.create()
if validators.is_attr_set(host_routes):
for rt in host_routes:
route = subnet_obj.Route(
context,
subnet_id=subnet.id,
destination=net_utils.AuthenticIPNetwork(
rt['destination']),
nexthop=netaddr.IPAddress(rt['nexthop']))
route.create()
if validators.is_attr_set(service_types):
for service_type in service_types:
service_type_obj = subnet_obj.SubnetServiceType(
context, subnet_id=subnet.id, service_type=service_type)
service_type_obj.create()
self.save_allocation_pools(context, subnet,
subnet_request.allocation_pools)
return subnet_obj.Subnet.get_object(context, id=subnet.id)
def _save_subnet(self, context,
network,
subnet_args,
dns_nameservers,
host_routes,
subnet_request):
self._validate_subnet_cidr(context, network, subnet_args['cidr'])
self._validate_network_subnetpools(network,
subnet_args['subnetpool_id'],
subnet_args['ip_version'])
service_types = subnet_args.pop('service_types', [])
subnet = models_v2.Subnet(**subnet_args)
segment_id = subnet_args.get('segment_id')
try:
context.session.add(subnet)
context.session.flush()
except db_exc.DBReferenceError:
raise segment_exc.SegmentNotFound(segment_id=segment_id)
self._validate_segment(context, network['id'], segment_id)
# NOTE(changzhi) Store DNS nameservers with order into DB one
# by one when create subnet with DNS nameservers
if validators.is_attr_set(dns_nameservers):
for order, server in enumerate(dns_nameservers):
dns = subnet_obj.DNSNameServer(context,
address=server,
order=order,
subnet_id=subnet.id)
dns.create()
if validators.is_attr_set(host_routes):
for rt in host_routes:
route = subnet_obj.Route(
context,
subnet_id=subnet.id,
destination=common_utils.AuthenticIPNetwork(
rt['destination']),
nexthop=netaddr.IPAddress(rt['nexthop']))
route.create()
if validators.is_attr_set(service_types):
for service_type in service_types:
service_type_entry = sst_model.SubnetServiceType(
subnet_id=subnet.id,
service_type=service_type)
context.session.add(service_type_entry)
self.save_allocation_pools(context, subnet,
subnet_request.allocation_pools)
return subnet
def update_network_segment(context, segment_id, segmentation_id):
with db_api.CONTEXT_WRITER.using(context):
netseg_obj = network_obj.NetworkSegment.get_object(context,
id=segment_id)
if not netseg_obj:
raise segments_exceptions.SegmentNotFound(segment_id=segment_id)
netseg_obj[ml2_api.SEGMENTATION_ID] = segmentation_id
netseg_obj.update()
LOG.info("Updated segment %(id)s, segmentation_id: %(segmentation_id)s)", {
'id': segment_id,
'segmentation_id': segmentation_id
})
def _save_subnet(self, context, network, subnet_args, dns_nameservers,
host_routes, subnet_request):
self._validate_subnet_cidr(context, network, subnet_args['cidr'])
self._validate_network_subnetpools(network,
subnet_args['subnetpool_id'],
subnet_args['ip_version'])
subnet = models_v2.Subnet(**subnet_args)
segment_id = subnet_args.get('segment_id')
try:
context.session.add(subnet)
context.session.flush()
except db_exc.DBReferenceError:
raise segment_exc.SegmentNotFound(segment_id=segment_id)
self._validate_segment(context, network['id'], segment_id)
# NOTE(changzhi) Store DNS nameservers with order into DB one
# by one when create subnet with DNS nameservers
if validators.is_attr_set(dns_nameservers):
for order, server in enumerate(dns_nameservers):
dns = models_v2.DNSNameServer(address=server,
order=order,
subnet_id=subnet.id)
context.session.add(dns)
if validators.is_attr_set(host_routes):
for rt in host_routes:
route = models_v2.SubnetRoute(subnet_id=subnet.id,
destination=rt['destination'],
nexthop=rt['nexthop'])
context.session.add(route)
self.save_allocation_pools(context, subnet,
subnet_request.allocation_pools)
return subnet
def _get_segment(self, context, segment_id):
try:
return self._get_by_id(context, segment_model.NetworkSegment,
segment_id)
except exc.NoResultFound:
raise exceptions.SegmentNotFound(segment_id=segment_id)
def _get_segment(self, context, segment_id):
segment = network.NetworkSegment.get_object(context, id=segment_id)
if not segment:
raise exceptions.SegmentNotFound(segment_id=segment_id)
return segment
