import static com.google.common.base.Preconditions.checkNotNull;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.util.L2L3IidFactory;
import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.EndpointRegistrator;
+import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.MetadataService;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkClient;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkService;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.SubnetUtils;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L2Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L3Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.MacAddressType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
public class NeutronPortAware implements NeutronAware<Port> {
InstanceIdentifier.builder(Neutron.class).child(Ports.class).child(Port.class).build();
private final DataBroker dataProvider;
private final EndpointRegistrator epRegistrator;
+ private final IpPrefix metadataIpPrefix;
- public NeutronPortAware(DataBroker dataProvider, EndpointRegistrator epRegistrator) {
+ public NeutronPortAware(DataBroker dataProvider, EndpointRegistrator epRegistrator,
+ @Nullable IpPrefix metadataIpPrefix) {
this.dataProvider = checkNotNull(dataProvider);
this.epRegistrator = checkNotNull(epRegistrator);
+ this.metadataIpPrefix = checkNotNull(metadataIpPrefix);
}
- @Override
- public void onCreated(Port port, Neutron neutron) {
+ @Override public void onCreated(Port createdItem, Neutron neutron) {
+ onCreated(createdItem, neutron, true);
+ }
+
+ public void onCreated(Port port, Neutron neutron, boolean addBaseEpMapping) {
LOG.trace("created port - {}", port);
if (PortUtils.isRouterInterfacePort(port)) {
LOG.trace("Port is router interface port: {}", port.getUuid().getValue());
}
FixedIps portIpWithSubnet = potentialPortIpWithSubnet.get();
ContextId routerL3Context = new ContextId(port.getDeviceId());
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+ AddressEndpointKey addrEpKey = new AddressEndpointKey(port.getMacAddress().getValue(),
+ MacAddressType.class, new ContextId(port.getNetworkId().getValue()), MappingUtils.L2_BRDIGE_DOMAIN);
+ UniqueId portId = new UniqueId(port.getUuid().getValue());
+ addBaseEndpointMappings(addrEpKey, portId, rwTx);
+ // Add Qrouter and VPProuter port as Endpoint
+ if (port.getAugmentation(PortBindingExtension.class) != null &&
+ PortUtils.DEVICE_VIF_TYPE.equals(port.getAugmentation(PortBindingExtension.class).getVifType())) {
+ LOG.trace("Port is QRouter port: {}", port.getUuid().getValue());
+ Optional<FixedIps> firstFixedIps = PortUtils.resolveFirstFixedIps(port);
+ if (!firstFixedIps.isPresent()) {
+ LOG.warn("QRouter port does not have an IP address. {}", port);
+ return;
+ }
+ FixedIps ipWithSubnet = firstFixedIps.get();
+ NetworkDomainId networkContainment = new NetworkDomainId(ipWithSubnet.getSubnetId().getValue());
+ List<EndpointGroupId> epgsFromSecGroups = resolveEpgIdsFromSecGroups(port.getSecurityGroups());
+ epgsFromSecGroups.add(NetworkService.EPG_ID);
+ // BUILD BASE ENDPOINT
+ AddressEndpointRegBuilder l2BaseEp = createBasicMacAddrEpInputBuilder(port, networkContainment,
+ epgsFromSecGroups);
+ AddressEndpointRegBuilder l3BaseEp = createBasicL3AddrEpInputBuilder(port, networkContainment,
+ epgsFromSecGroups, neutron);
+ setParentChildRelationshipForEndpoints(l3BaseEp, l2BaseEp);
+ // BUILD ENDPOINT
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInputBuilder
+ epInBuilder =
+ createEndpointRegFromPort(
+ port, ipWithSubnet, networkContainment, epgsFromSecGroups, neutron);
+ registerBaseEndpointAndStoreMapping(
+ ImmutableList.of(l2BaseEp.build(), l3BaseEp.build()), port, rwTx, addBaseEpMapping);
+ registerEndpointAndStoreMapping(epInBuilder.build(), port, rwTx);
+ }
// change L3Context for all EPs with same subnet as router port
changeL3ContextForEpsInSubnet(portIpWithSubnet.getSubnetId(), neutron);
// set L3Context as parent for bridge domain which is parent of subnet
return;
}
Subnet routerPortSubnet = potentialRouterPortSubnet.get();
- ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
ContextId l2BdId = new ContextId(routerPortSubnet.getNetworkId().getValue());
ForwardingContext l2Bd = new ForwardingContextBuilder().setContextId(l2BdId)
.setContextType(MappingUtils.L2_BRDIGE_DOMAIN)
.build();
rwTx.merge(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l2BridgeDomainIid(tenantId, l2BdId), l2Bd, true);
// set virtual router IP for subnet
- NetworkDomain subnetDomain = NeutronSubnetAware.createSubnet(
- routerPortSubnet, portIpWithSubnet.getIpAddress());
+ NetworkDomain subnetDomain = NeutronSubnetAware.createSubnet(routerPortSubnet, neutron, null);
rwTx.merge(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()), subnetDomain);
// does the same for tenant forwarding domains
NetworkDomainId networkContainment = new NetworkDomainId(ipWithSubnet.getSubnetId().getValue());
List<EndpointGroupId> epgsFromSecGroups = resolveEpgIdsFromSecGroups(port.getSecurityGroups());
epgsFromSecGroups.add(NetworkService.EPG_ID);
-
- // BUILD BASE ENDPOINT
AddressEndpointRegBuilder l2BaseEp = createBasicMacAddrEpInputBuilder(port, networkContainment,
- epgsFromSecGroups);
+ Collections.emptyList());
AddressEndpointRegBuilder l3BaseEp = createBasicL3AddrEpInputBuilder(port, networkContainment,
epgsFromSecGroups, neutron);
- setParentChildRelationshipForEndpoints(l3BaseEp, l2BaseEp);
- // BUILD ENDPOINT
+ setParentChildRelationshipForEndpoints(l3BaseEp, l2BaseEp);
org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInputBuilder epInBuilder = createEndpointRegFromPort(
port, ipWithSubnet, networkContainment, epgsFromSecGroups, neutron);
-
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
registerBaseEndpointAndStoreMapping(
- ImmutableList.of(l2BaseEp.build(), l3BaseEp.build()), port, rwTx);
+ ImmutableList.of(l3BaseEp.build(), l2BaseEp.build()), port, rwTx, addBaseEpMapping);
+ registerMetadataServiceForDhcpPort(port, neutron, l2BaseEp, rwTx, true);
registerEndpointAndStoreMapping(epInBuilder.build(), port, rwTx);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isNormalPort(port)) {
baseEpRegs.add(l3BaseEp.build());
}
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
- registerBaseEndpointAndStoreMapping(baseEpRegs, port, rwTx);
+ registerBaseEndpointAndStoreMapping(baseEpRegs, port, rwTx, addBaseEpMapping);
registerEndpointAndStoreMapping(epInBuilder.build(), port, rwTx);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isRouterGatewayPort(port)) {
}
}
+ private Port cloneMetadataPortFromDhcpPort(Port port, IpPrefix metadataPrefix) {
+ IpAddress metadataIp = MappingUtils.ipPrefixToIpAddress(metadataPrefix);
+ List<FixedIps> metadataIps = port.getFixedIps().stream().map(fi -> {
+ FixedIpsKey key = new FixedIpsKey(metadataIp, fi.getKey().getSubnetId());
+ return new FixedIpsBuilder(fi).setKey(key).setIpAddress(metadataIp).build();
+ }).collect(Collectors.toList());
+ return new PortBuilder(port).setFixedIps(metadataIps).build();
+ }
+
+ private void registerMetadataServiceForDhcpPort(Port port, Neutron neutron, AddressEndpointRegBuilder childEpToAdd,
+ ReadWriteTransaction rwTx, boolean registerMapping) {
+ Optional<NetworkDomainId> resolveNetworkContainment = PortUtils.resolveNetworkContainment(port);
+ if (!resolveNetworkContainment.isPresent()) {
+ LOG.warn("DHCP port does not have an IP address. {}", port);
+ return;
+ }
+ AddressEndpointRegBuilder metadataEp =
+ createBasicL3AddrEpInputBuilder(cloneMetadataPortFromDhcpPort(port, metadataIpPrefix),
+ resolveNetworkContainment.get(), Lists.newArrayList(MetadataService.EPG_ID), neutron);
+ AddressEndpointKey aek = new AddressEndpointKey(metadataEp.getAddress(), metadataEp.getAddressType(),
+ metadataEp.getContextId(), metadataEp.getContextType());
+ Optional<AddressEndpoint> optMetadataEp =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(aek), rwTx);
+ if (!optMetadataEp.isPresent()) {
+ setParentChildRelationshipForEndpoints(metadataEp, childEpToAdd);
+ } else {
+ List<ChildEndpoint> childs = optMetadataEp.get().getChildEndpoint();
+ childs.add(createChildEndpoint(childEpToAdd));
+ metadataEp.setChildEndpoint(childs);
+ }
+ registerBaseEndpointAndStoreMapping(ImmutableList.of(metadataEp.build()), port, rwTx, registerMapping);
+ }
+
private void setParentChildRelationshipForEndpoints(AddressEndpointRegBuilder parentEp,
AddressEndpointRegBuilder childEp) {
childEp.setParentEndpointChoice(new ParentEndpointCaseBuilder().setParentEndpoint(
}
private void changeL3ContextForEpsInSubnet(Uuid subnetUuid, Neutron neutron) {
+ if (neutron == null) {
+ LOG.debug("No new data are written, there is no L3 context in subnet {} to update", subnetUuid);
+ return;
+ }
+ java.util.Optional<Subnet> optSubnet = neutron.getSubnets()
+ .getSubnet()
+ .stream()
+ .filter(subnet -> subnet.getNetworkId() != null && subnet.getUuid().getValue().equals(subnetUuid.getValue()))
+ .findAny();
+ if (!optSubnet.isPresent()) {
+ LOG.error("Failed to update metadata endpoint in subnet {}. Could not resolve Network ID", subnetUuid);
+ } else {
+ AddressEndpointUnreg metadataEpUnreg =
+ new AddressEndpointUnregBuilder().setAddress(String.valueOf(metadataIpPrefix.getValue()))
+ .setAddressType(IpPrefixType.class)
+ .setContextId(new ContextId(optSubnet.get().getNetworkId().getValue()))
+ .setContextType(MappingUtils.L3_CONTEXT)
+ .build();
+ epRegistrator.unregisterEndpoint(metadataEpUnreg);
+ }
Set<Port> portsInSameSubnet = PortUtils.findPortsBySubnet(subnetUuid, neutron.getPorts());
for (Port portInSameSubnet : portsInSameSubnet) {
- if (PortUtils.isNormalPort(portInSameSubnet) || PortUtils.isDhcpPort(portInSameSubnet)) {
+ if (PortUtils.isNormalPort(portInSameSubnet) || PortUtils.isDhcpPort(portInSameSubnet)
+ || PortUtils.isQrouterOrVppRouterPort(portInSameSubnet)) {
// endpoints are created only from neutron normal port or DHCP port
Optional<FixedIps> firstFixedIps = PortUtils.resolveFirstFixedIps(portInSameSubnet);
if (firstFixedIps.isPresent()) {
// endpoint has only one network containment therefore only first IP is used
FixedIps ipWithSubnet = firstFixedIps.get();
List<EndpointGroupId> endpointGroupIds = new ArrayList<>();
- if (PortUtils.isDhcpPort(portInSameSubnet)) {
+ if (PortUtils.isDhcpPort(portInSameSubnet) || PortUtils.isQrouterOrVppRouterPort(portInSameSubnet)) {
endpointGroupIds.add(NetworkService.EPG_ID);
} else if (PortUtils.isNormalPort(portInSameSubnet)) {
endpointGroupIds.add(NetworkClient.EPG_ID);
.setContextType(l3BaseEp.getContextType())
.build();
epRegistrator.unregisterEndpoint(addrEpUnreg);
- epRegistrator.registerEndpoint(l3BaseEp.build());
-
+ RegisterEndpointInput regBaseEpInput = new RegisterEndpointInputBuilder()
+ .setAddressEndpointReg(ImmutableList.of(l2BaseEp.build(), l3BaseEp.build())).build();
+ epRegistrator.registerEndpoint(regBaseEpInput);
+ if(PortUtils.isDhcpPort(portInSameSubnet)) {
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+ registerMetadataServiceForDhcpPort(portInSameSubnet, neutron, l2BaseEp, rwTx, false);
+ try {
+ rwTx.submit().get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to update metadata endpoint for DHCP port {}. {}", portInSameSubnet, e);
+ }
+ }
modifyL3ContextForEndpoints(portInSameSubnet, ipWithSubnet, l3BaseEp.getContextId());
}
}
Port port, ReadWriteTransaction rwTx) {
boolean isRegisteredEndpoint = epRegistrator.registerEndpoint(regEpInput);
if (!isRegisteredEndpoint) {
- LOG.error("Failed to register an endpoint: {}", regEpInput);
+ LOG.error("Failed to register endpoint: {}", regEpInput);
return;
}
UniqueId portId = new UniqueId(port.getUuid().getValue());
}
private void registerBaseEndpointAndStoreMapping(List<AddressEndpointReg> addrEpRegs, Port port,
- ReadWriteTransaction rwTx) {
+ WriteTransaction wTx, boolean addBaseEpMappings) {
RegisterEndpointInput regBaseEpInput = new RegisterEndpointInputBuilder().setAddressEndpointReg(addrEpRegs)
.build();
boolean isRegisteredBaseEndpoint = epRegistrator.registerEndpoint(regBaseEpInput);
if (!isRegisteredBaseEndpoint) {
- LOG.error("Failed to register an address endpoint: {}", addrEpRegs);
+ LOG.error("Failed to register address endpoint: {}", addrEpRegs);
return;
}
for (AddressEndpointReg addrEpReg : addrEpRegs) {
- if (MappingUtils.L2_BRDIGE_DOMAIN.equals(addrEpReg.getContextType())) {
+ if (MappingUtils.L2_BRDIGE_DOMAIN.equals(addrEpReg.getContextType()) && addBaseEpMappings) {
UniqueId portId = new UniqueId(port.getUuid().getValue());
LOG.trace("Adding Port-BaseEndpoint mapping for port {} (device owner {}) and endpoint {}",
port.getUuid());
AddressEndpointKey addrEpKey = new AddressEndpointKey(addrEpReg.getAddress(),
addrEpReg.getAddressType(), addrEpReg.getContextId(), addrEpReg.getContextType());
- BaseEndpointByPort baseEndpointByPort = MappingFactory.createBaseEndpointByPort(addrEpKey, portId);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.baseEndpointByPortIid(portId),
- baseEndpointByPort, true);
- PortByBaseEndpoint portByBaseEndpoint = MappingFactory.createPortByBaseEndpoint(portId, addrEpKey);
- rwTx.put(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.portByBaseEndpointIid(new PortByBaseEndpointKey(
- portByBaseEndpoint.getKey())), portByBaseEndpoint, true);
+ addBaseEndpointMappings(addrEpKey, portId, wTx);
}
}
}
+ private void addBaseEndpointMappings(AddressEndpointKey addrEpKey, UniqueId portId, WriteTransaction wTx) {
+ BaseEndpointByPort baseEndpointByPort = MappingFactory.createBaseEndpointByPort(addrEpKey, portId);
+ wTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.baseEndpointByPortIid(portId),
+ baseEndpointByPort, true);
+ PortByBaseEndpoint portByBaseEndpoint = MappingFactory.createPortByBaseEndpoint(portId, addrEpKey);
+ wTx.put(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.portByBaseEndpointIid(new PortByBaseEndpointKey(
+ portByBaseEndpoint.getKey())), portByBaseEndpoint, true);
+ }
+
private void unregisterEndpointAndRemoveMapping(UnregisterEndpointInput baseEpUnreg, Port port,
- ReadWriteTransaction rwTx) {
+ ReadWriteTransaction rwTx, boolean removeBaseEpMappings) {
boolean isUnregisteredBaseEndpoint = epRegistrator.unregisterEndpoint(baseEpUnreg);
if (isUnregisteredBaseEndpoint) {
UniqueId portId = new UniqueId(port.getUuid().getValue());
- EndpointKey epKey = new EndpointKey(new L2BridgeDomainId(port.getNetworkId().getValue()), new MacAddress(
- port.getMacAddress().getValue()));
- LOG.trace("Removing Port-BaseEndpoint mapping for port {} (device owner {}) and endpoint {}",
- port.getUuid().getValue(), port.getDeviceOwner(), epKey);
PortByBaseEndpointKey portByBaseEndpointKey = new PortByBaseEndpointKey(port.getMacAddress().getValue(),
MacAddressType.class, new ContextId(port.getNetworkId().getValue()), MappingUtils.L2_BRDIGE_DOMAIN);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.baseEndpointByPortIid(portId), rwTx);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.portByBaseEndpointIid(portByBaseEndpointKey), rwTx);
+ LOG.trace("Removing Port-BaseEndpoint mapping for port {} (device owner {}) and endpoint {}",
+ port.getUuid().getValue(), port.getDeviceOwner(), portByBaseEndpointKey);
+ if (removeBaseEpMappings) {
+ removeBaseEndpointMappings(portByBaseEndpointKey, portId, rwTx);
+ }
}
}
+ private void removeBaseEndpointMappings(PortByBaseEndpointKey portByBaseEndpointKey, UniqueId portId, ReadWriteTransaction rwTx) {
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.baseEndpointByPortIid(portId), rwTx);
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.portByBaseEndpointIid(portByBaseEndpointKey), rwTx);
+ }
+
@Override
public void onUpdated(Port oldPort, Port newPort, Neutron oldNeutron, Neutron newNeutron) {
LOG.trace("updated port - OLD: {}\nNEW: {}", oldPort, newPort);
- onDeleted(oldPort, oldNeutron, newNeutron);
- onCreated(newPort, newNeutron);
+ onDeleted(oldPort, oldNeutron, newNeutron, false);
+ onCreated(newPort, newNeutron, false);
}
- @Override
- public void onDeleted(Port port, Neutron oldNeutron, Neutron newNeutron) {
+ @Override public void onDeleted(Port deletedItem, Neutron oldNeutron, Neutron newNeutron) {
+ onDeleted(deletedItem, oldNeutron, newNeutron, true);
+ }
+
+ public void onDeleted(Port port, Neutron oldNeutron, Neutron newNeutron, boolean removeBaseEpMapping) {
LOG.trace("deleted port - {}", port);
if (PortUtils.isRouterInterfacePort(port)) {
LOG.trace("Port is router interface port: {}", port.getUuid().getValue());
}
FixedIps portIpWithSubnet = potentialPortIpWithSubnet.get();
L3ContextId l3Context = new L3ContextId(port.getNetworkId().getValue());
- // change L3Context for all EPs with same subnet as router port
- changeL3ContextForEpsInSubnet(portIpWithSubnet.getSubnetId(), oldNeutron);
+ // change L3Context for all new EPs with same subnet as router port
+ changeL3ContextForEpsInSubnet(portIpWithSubnet.getSubnetId(), newNeutron);
// set L3Context as parent for bridge domain which is parent of subnet
TenantId tenantId = new TenantId(port.getTenantId().getValue());
Optional<Subnet> potentialRouterPortSubnet = SubnetUtils.findSubnet(portIpWithSubnet.getSubnetId(),
.build();
rwTx.merge(LogicalDatastoreType.CONFIGURATION,
L2L3IidFactory.l2BridgeDomainIid(tenantId, fwdCtx.getContextId()), fwdCtx);
- NetworkDomain subnet = NeutronSubnetAware.createSubnet(routerPortSubnet, null);
+ NetworkDomain subnet = NeutronSubnetAware.createSubnet(routerPortSubnet, newNeutron, null);
rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnet.getNetworkDomainId()),
subnet);
+ unregisterEndpointAndRemoveMapping(createUnregisterEndpointInput(port, oldNeutron), port, rwTx);
+ unregisterEndpointAndRemoveMapping(createUnregisterBaseEndpointInput(port, oldNeutron), port, rwTx, removeBaseEpMapping);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isDhcpPort(port)) {
LOG.trace("Port is DHCP port: {}", port.getUuid().getValue());
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
unregisterEndpointAndRemoveMapping(createUnregisterEndpointInput(port, oldNeutron), port, rwTx);
- unregisterEndpointAndRemoveMapping(createUnregisterBaseEndpointInput(port, oldNeutron), port, rwTx);
+ unregisterEndpointAndRemoveMapping(createUnregisterBaseEndpointInput(port, oldNeutron), port, rwTx, removeBaseEpMapping);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isNormalPort(port)) {
LOG.trace("Port is normal port: {}", port.getUuid().getValue());
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
unregisterEndpointAndRemoveMapping(createUnregisterEndpointInput(port, oldNeutron), port, rwTx);
- unregisterEndpointAndRemoveMapping(createUnregisterBaseEndpointInput(port, oldNeutron), port, rwTx);
+ unregisterEndpointAndRemoveMapping(createUnregisterBaseEndpointInput(port, oldNeutron), port, rwTx, removeBaseEpMapping);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isRouterGatewayPort(port)) {
// do nothing because actual trigger is detaching of port from router
Code Review / groupbasedpolicy.git / blobdiff