/*
- * Copyright © 2015, 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ * Copyright © 2015, 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
*/
package org.opendaylight.netvirt.neutronvpn;
-import static org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier;
+import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.base.Strings;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
+import javax.annotation.Nullable;
import javax.annotation.PostConstruct;
import javax.inject.Singleton;
+import org.apache.commons.lang3.ObjectUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
+import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.api.enums.IpVersionChoice;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
private final JobCoordinator jobCoordinator;
private final NeutronvpnUtils neutronvpnUtils;
private final HostConfigCache hostConfigCache;
+ private final DataTreeEventCallbackRegistrar eventCallbacks;
public NeutronPortChangeListener(final DataBroker dataBroker,
final NeutronvpnManager neutronvpnManager,
final IElanService elanService,
final JobCoordinator jobCoordinator,
final NeutronvpnUtils neutronvpnUtils,
- final HostConfigCache hostConfigCache) {
+ final HostConfigCache hostConfigCache,
+ final DataTreeEventCallbackRegistrar dataTreeEventCallbackRegistrar) {
super(Port.class, NeutronPortChangeListener.class);
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.jobCoordinator = jobCoordinator;
this.neutronvpnUtils = neutronvpnUtils;
this.hostConfigCache = hostConfigCache;
+ this.eventCallbacks = dataTreeEventCallbackRegistrar;
}
@Override
portName, network);
return;
}
+
neutronvpnUtils.addToPortCache(input);
String portStatus = NeutronUtils.PORT_STATUS_DOWN;
if (!Strings.isNullOrEmpty(input.getDeviceOwner()) && !Strings.isNullOrEmpty(input.getDeviceId())) {
- if (input.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF)) {
+ if (NeutronConstants.DEVICE_OWNER_ROUTER_INF.equals(input.getDeviceOwner())) {
handleRouterInterfaceAdded(input);
NeutronUtils.createPortStatus(input.getUuid().getValue(), NeutronUtils.PORT_STATUS_ACTIVE, dataBroker);
return;
}
if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(input.getDeviceOwner())) {
- handleRouterGatewayUpdated(input);
+ handleRouterGatewayUpdated(input, false);
portStatus = NeutronUtils.PORT_STATUS_ACTIVE;
} else if (NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(input.getDeviceOwner())) {
handleFloatingIpPortUpdated(null, input);
protected void remove(InstanceIdentifier<Port> identifier, Port input) {
LOG.trace("Removing Port : key: {}, value={}", identifier, input);
Network network = neutronvpnUtils.getNeutronNetwork(input.getNetworkId());
- if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
+ // need to proceed with deletion in case network is null for a case where v2 sync happens and a read for
+ // network from NN returns null, but the deletion process for port needs to continue
+ if (network != null && !NeutronvpnUtils.isNetworkTypeSupported(network)) {
String portName = input.getUuid().getValue();
LOG.warn("neutron vpn received a port remove() for a network without a provider extension augmentation "
+ "or with an unsupported network type for the port {} which is part of network {}",
NeutronUtils.deletePortStatus(input.getUuid().getValue(), dataBroker);
if (!Strings.isNullOrEmpty(input.getDeviceOwner()) && !Strings.isNullOrEmpty(input.getDeviceId())) {
- if (input.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF)) {
+ if (NeutronConstants.DEVICE_OWNER_ROUTER_INF.equals(input.getDeviceOwner())) {
handleRouterInterfaceRemoved(input);
/* nothing else to do here */
return;
} else if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(input.getDeviceOwner())
|| NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(input.getDeviceOwner())) {
+ handleRouterGatewayUpdated(input, true);
elanService.removeKnownL3DmacAddress(input.getMacAddress().getValue(), input.getNetworkId().getValue());
}
}
Network network = neutronvpnUtils.getNeutronNetwork(update.getNetworkId());
LOG.info("Update port {} from network {}", portName, update.getNetworkId().toString());
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
- LOG.error("neutron vpn received a port update() for a network without a provider extension augmentation "
+ LOG.warn("neutron vpn received a port update() for a network without a provider extension augmentation "
+ "or with an unsupported network type for the port {} which is part of network {}",
portName, network);
return;
if ((Strings.isNullOrEmpty(original.getDeviceOwner()) || Strings.isNullOrEmpty(original.getDeviceId())
|| NeutronConstants.FLOATING_IP_DEVICE_ID_PENDING.equalsIgnoreCase(original.getDeviceId()))
&& !Strings.isNullOrEmpty(update.getDeviceOwner()) && !Strings.isNullOrEmpty(update.getDeviceId())) {
- if (update.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF)) {
+ if (NeutronConstants.DEVICE_OWNER_ROUTER_INF.equals(update.getDeviceOwner())) {
handleRouterInterfaceAdded(update);
return;
}
if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(update.getDeviceOwner())) {
- handleRouterGatewayUpdated(update);
+ handleRouterGatewayUpdated(update, false);
} else if (NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(update.getDeviceOwner())) {
handleFloatingIpPortUpdated(original, update);
}
if (origSecurityEnabled || updatedSecurityEnabled) {
InstanceIdentifier<Interface> interfaceIdentifier = NeutronvpnUtils.buildVlanInterfaceIdentifier(portName);
- jobCoordinator.enqueueJob("PORT- " + portName, () -> {
- WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
- try {
- Optional<Interface> optionalInf =
- SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
- interfaceIdentifier);
- if (optionalInf.isPresent()) {
- InterfaceBuilder interfaceBuilder = new InterfaceBuilder(optionalInf.get());
- InterfaceAcl infAcl = handlePortSecurityUpdated(dataBroker, original, update,
- origSecurityEnabled, updatedSecurityEnabled, interfaceBuilder).build();
- interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
- LOG.info("update: Of-port-interface updation for port {}", portName);
- // Update OFPort interface for this neutron port
- wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier,
- interfaceBuilder.build());
- } else {
- LOG.warn("update: Interface {} is not present", portName);
- }
- } catch (ReadFailedException e) {
- LOG.error("update: Failed to update interface {}", portName, e);
- }
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- futures.add(wrtConfigTxn.submit());
- return futures;
- });
+ jobCoordinator.enqueueJob("PORT- " + portName,
+ () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
+ confTx -> {
+ Optional<Interface> optionalInf =
+ confTx.read(interfaceIdentifier).get();
+ if (optionalInf.isPresent()) {
+ InterfaceBuilder interfaceBuilder = new InterfaceBuilder(optionalInf.get());
+ InterfaceAcl infAcl = handlePortSecurityUpdated(original, update,
+ origSecurityEnabled, updatedSecurityEnabled, interfaceBuilder).build();
+ interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
+ LOG.info("update: Of-port-interface updation for port {}", portName);
+ // Update OFPort interface for this neutron port
+ confTx.put(interfaceIdentifier, interfaceBuilder.build());
+ } else {
+ LOG.warn("update: Interface {} is not present", portName);
+ }
+ })));
}
}
- private void handleFloatingIpPortUpdated(Port original, Port update) {
- if ((original == null || original.getDeviceId().equals(NeutronConstants.FLOATING_IP_DEVICE_ID_PENDING))
- && !update.getDeviceId().equals(NeutronConstants.FLOATING_IP_DEVICE_ID_PENDING)) {
+ private void handleFloatingIpPortUpdated(@Nullable Port original, Port update) {
+ if ((original == null || NeutronConstants.FLOATING_IP_DEVICE_ID_PENDING.equals(original.getDeviceId()))
+ && !NeutronConstants.FLOATING_IP_DEVICE_ID_PENDING.equals(update.getDeviceId())) {
// populate floating-ip uuid and floating-ip port attributes (uuid, mac and subnet id for the ONLY
// fixed IP) to be used by NAT, depopulated in NATService once mac is retrieved in the removal path
addToFloatingIpPortInfo(new Uuid(update.getDeviceId()), update.getUuid(), update.getFixedIps().get(0)
listVpnIds.add(vpnId);
Uuid internetVpnId = neutronvpnUtils.getInternetvpnUuidBoundToRouterId(routerId);
List<Subnetmap> subnetMapList = new ArrayList<>();
- List<FixedIps> portIps = routerPort.getFixedIps();
boolean portIsIpv6 = false;
- for (FixedIps portIP : portIps) {
+ for (FixedIps portIP : requireNonNullElse(routerPort.getFixedIps(),
+ Collections.<FixedIps>emptyList())) {
// NOTE: Please donot change the order of calls to updateSubnetNodeWithFixedIP
// and addSubnetToVpn here
if (internetVpnId != null
&& portIP.getIpAddress().getIpv6Address() != null) {
portIsIpv6 = true;
}
- String ipValue = String.valueOf(portIP.getIpAddress().getValue());
+ String ipValue = portIP.getIpAddress().stringValue();
Uuid subnetId = portIP.getSubnetId();
nvpnManager.updateSubnetNodeWithFixedIp(subnetId, routerId,
routerPort.getUuid(), ipValue, routerPort.getMacAddress().getValue(), vpnId);
}
if (portIsIpv6) {
listVpnIds.add(internetVpnId);
- if (neutronvpnUtils.shouldVpnHandleIpVersionChoiceChangeToAdd(
- IpVersionChoice.IPV6, internetVpnId)) {
- neutronvpnUtils.updateVpnInstanceWithIpFamily(internetVpnId.getValue(),
- IpVersionChoice.IPV6, true);
- neutronvpnUtils.updateVpnInstanceWithFallback(internetVpnId.getValue(), true);
+ if (neutronvpnUtils.shouldVpnHandleIpVersionChoiceChange(
+ IpVersionChoice.IPV6, routerId, true)) {
+ neutronvpnUtils.updateVpnInstanceWithIpFamily(internetVpnId.getValue(), IpVersionChoice.IPV6,
+ true);
+ neutronvpnUtils.updateVpnInstanceWithFallback(routerId, internetVpnId, true);
}
}
if (! subnetMapList.isEmpty()) {
nvpnManager.createVpnInterface(listVpnIds, routerPort, null);
}
- for (FixedIps portIP : routerPort.getFixedIps()) {
- String ipValue = String.valueOf(portIP.getIpAddress().getValue());
- IpVersionChoice version = neutronvpnUtils.getIpVersionFromString(ipValue);
- if (neutronvpnUtils.shouldVpnHandleIpVersionChoiceChangeToAdd(version, vpnId)) {
- neutronvpnUtils.updateVpnInstanceWithIpFamily(vpnId.getValue(),
- version, true);
- }
- if (version.isIpVersionChosen(IpVersionChoice.IPV4)) {
+ IpVersionChoice ipVersion = IpVersionChoice.UNDEFINED;
+ for (FixedIps portIP : requireNonNullElse(routerPort.getFixedIps(),
+ Collections.<FixedIps>emptyList())) {
+ String ipValue = portIP.getIpAddress().stringValue();
+ ipVersion = NeutronvpnUtils.getIpVersionFromString(ipValue);
+ if (ipVersion.isIpVersionChosen(IpVersionChoice.IPV4)) {
nvpnManager.addSubnetToVpn(vpnId, portIP.getSubnetId(),
null /* internet-vpn-id */);
} else {
ipValue, routerPort.getMacAddress(),
routerPort.getUuid().getValue(), vpnId.getValue());
}
+ if (neutronvpnUtils.shouldVpnHandleIpVersionChoiceChange(ipVersion, routerId, true)) {
+ LOG.debug("vpnInstanceOpDataEntry is getting update with ip address family {} for VPN {}",
+ ipVersion, vpnId.getValue());
+ neutronvpnUtils.updateVpnInstanceWithIpFamily(vpnId.getValue(), ipVersion, true);
+ }
nvpnManager.addToNeutronRouterInterfacesMap(routerId, routerPort.getUuid().getValue());
- nvpnNatManager.handleSubnetsForExternalRouter(routerId);
- WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
- String portInterfaceName = createOfPortInterface(routerPort, wrtConfigTxn);
- createElanInterface(routerPort, portInterfaceName, wrtConfigTxn);
- wrtConfigTxn.submit();
+ jobCoordinator.enqueueJob(routerId.toString(), () -> {
+ nvpnNatManager.handleSubnetsForExternalRouter(routerId);
+ return Collections.emptyList();
+ });
+ ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+ confTx -> {
+ String portInterfaceName = createOfPortInterface(routerPort, confTx);
+ createElanInterface(routerPort, portInterfaceName, confTx);
+ }), LOG, "Error creating ELAN interface for {}", routerPort);
} else {
LOG.error("Neutron network {} corresponding to router interface port {} for neutron router {}"
+ " already associated to VPN {}", infNetworkId.getValue(), routerPort.getUuid().getValue(),
Uuid routerId = new Uuid(routerPort.getDeviceId());
Uuid infNetworkId = routerPort.getNetworkId();
elanService.removeKnownL3DmacAddress(routerPort.getMacAddress().getValue(), infNetworkId.getValue());
- Uuid vpnId = neutronvpnUtils.getVpnForRouter(routerId, true);
- if (vpnId == null) {
- vpnId = routerId;
- }
- List<FixedIps> portIps = routerPort.getFixedIps();
+ Uuid vpnId = ObjectUtils.defaultIfNull(neutronvpnUtils.getVpnForRouter(routerId, true),
+ routerId);
+ List<FixedIps> portIps = requireNonNullElse(routerPort.getFixedIps(), Collections.emptyList());
boolean vpnInstanceInternetIpVersionRemoved = false;
Uuid vpnInstanceInternetUuid = null;
for (FixedIps portIP : portIps) {
* cleanup of router interface flows*/
nvpnManager.deleteVpnInterface(routerPort.getUuid().getValue(),
null /* vpn-id */, null /* wrtConfigTxn*/);
+ final Uuid internetVpnId = vpnInstanceInternetUuid;
// update RouterInterfaces map
- WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
- boolean vpnInstanceIpVersionRemoved = false;
- IpVersionChoice vpnInstanceIpVersionToRemove = IpVersionChoice.UNDEFINED;
- for (FixedIps portIP : portIps) {
- Subnetmap sn = neutronvpnUtils.getSubnetmap(portIP.getSubnetId());
- // router Port have either IPv4 or IPv6, never both
- if (neutronvpnUtils.shouldVpnHandleIpVersionChangeToRemove(sn, vpnId)) {
- vpnInstanceIpVersionRemoved = true;
- vpnInstanceIpVersionToRemove = neutronvpnUtils.getIpVersionFromString(sn.getSubnetIp());
- }
- String ipValue = String.valueOf(portIP.getIpAddress().getValue());
- neutronvpnUtils.removeVpnPortFixedIpToPort(vpnId.getValue(), ipValue, wrtConfigTxn);
- // NOTE: Please donot change the order of calls to removeSubnetFromVpn and
- // and updateSubnetNodeWithFixedIP
- nvpnManager.removeSubnetFromVpn(vpnId, portIP.getSubnetId(), sn != null ? sn.getInternetVpnId() : null);
- nvpnManager.updateSubnetNodeWithFixedIp(portIP.getSubnetId(), null, null, null, null, null);
- }
- nvpnManager.removeFromNeutronRouterInterfacesMap(routerId, routerPort.getUuid().getValue());
- deleteElanInterface(routerPort.getUuid().getValue(), wrtConfigTxn);
- deleteOfPortInterface(routerPort, wrtConfigTxn);
- wrtConfigTxn.submit();
- nvpnNatManager.handleSubnetsForExternalRouter(routerId);
- if (vpnInstanceIpVersionRemoved) {
- neutronvpnUtils.updateVpnInstanceWithIpFamily(vpnId.getValue(), vpnInstanceIpVersionToRemove,
- false);
- }
+ ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+ confTx -> {
+ IpVersionChoice ipVersion = IpVersionChoice.UNDEFINED;
+ for (FixedIps portIP : portIps) {
+ Subnetmap sn = neutronvpnUtils.getSubnetmap(portIP.getSubnetId());
+ // router Port have either IPv4 or IPv6, never both
+ ipVersion = neutronvpnUtils.getIpVersionFromString(sn.getSubnetIp());
+ String ipValue = portIP.getIpAddress().stringValue();
+ neutronvpnUtils.removeVpnPortFixedIpToPort(vpnId.getValue(), ipValue, confTx);
+ // NOTE: Please donot change the order of calls to removeSubnetFromVpn and
+ // and updateSubnetNodeWithFixedIP
+ nvpnManager.removeSubnetFromVpn(vpnId, portIP.getSubnetId(), internetVpnId);
+ nvpnManager.updateSubnetNodeWithFixedIp(portIP.getSubnetId(), null, null,
+ null, null, null);
+ }
+ nvpnManager.removeFromNeutronRouterInterfacesMap(routerId, routerPort.getUuid().getValue());
+ deleteElanInterface(routerPort.getUuid().getValue(), confTx);
+ deleteOfPortInterface(routerPort, confTx);
+ jobCoordinator.enqueueJob(routerId.toString(), () -> {
+ nvpnNatManager.handleSubnetsForExternalRouter(routerId);
+ return Collections.emptyList();
+ });
+ if (neutronvpnUtils.shouldVpnHandleIpVersionChoiceChange(ipVersion, routerId, false)) {
+ LOG.debug("vpnInstanceOpDataEntry is getting update with ip address family {} for VPN {}",
+ ipVersion, vpnId.getValue());
+ neutronvpnUtils.updateVpnInstanceWithIpFamily(vpnId.getValue(), ipVersion, false);
+ }
+ }), LOG, "Error handling interface removal");
if (vpnInstanceInternetIpVersionRemoved) {
neutronvpnUtils.updateVpnInstanceWithIpFamily(vpnInstanceInternetUuid.getValue(),
- IpVersionChoice.IPV6, false);
- neutronvpnUtils.updateVpnInstanceWithFallback(vpnInstanceInternetUuid.getValue(), false);
+ IpVersionChoice.IPV6, false);
+ neutronvpnUtils.updateVpnInstanceWithFallback(routerId, vpnInstanceInternetUuid, false);
}
}
}
- private void handleRouterGatewayUpdated(Port routerGwPort) {
+ private void handleRouterGatewayUpdated(Port routerGwPort, boolean isRtrGwRemoved) {
Uuid routerId = new Uuid(routerGwPort.getDeviceId());
Uuid networkId = routerGwPort.getNetworkId();
Network network = neutronvpnUtils.getNeutronNetwork(networkId);
if (network == null) {
return;
}
- boolean isExternal = neutronvpnUtils.getIsExternal(network);
+ boolean isExternal = NeutronvpnUtils.getIsExternal(network);
if (isExternal) {
Uuid vpnInternetId = neutronvpnUtils.getVpnForNetwork(networkId);
if (vpnInternetId != null) {
+ if (!isRtrGwRemoved) {
+ nvpnManager.updateVpnMaps(vpnInternetId, null, routerId, null, null);
+ }
List<Subnetmap> snList = neutronvpnUtils.getNeutronRouterSubnetMaps(routerId);
for (Subnetmap sn : snList) {
if (sn.getNetworkId() == networkId) {
continue;
}
- if (neutronvpnUtils.getIpVersionFromString(sn.getSubnetIp()) != IpVersionChoice.IPV6) {
+ if (NeutronvpnUtils.getIpVersionFromString(sn.getSubnetIp()) != IpVersionChoice.IPV6) {
continue;
}
- nvpnManager.addSubnetToVpn(null, sn.getId(), vpnInternetId);
+ if (isRtrGwRemoved) {
+ nvpnManager.removeV6PrivateSubnetToExtNetwork(routerId, vpnInternetId, sn);
+ } else {
+ nvpnManager.addV6PrivateSubnetToExtNetwork(routerId, vpnInternetId, sn);
+ }
+ }
+ //Update Internet BGP-VPN
+ if (isRtrGwRemoved) {
+ nvpnManager.updateVpnMaps(vpnInternetId, null, null, null, null);
}
}
}
if (router == null) {
LOG.warn("No router found for router GW port {} for router {}", routerGwPort.getUuid().getValue(),
routerId.getValue());
+ // NETVIRT-1249
+ eventCallbacks.onAddOrUpdate(LogicalDatastoreType.CONFIGURATION,
+ neutronvpnUtils.getNeutronRouterIid(routerId), (unused, newRouter) -> {
+ setupGwMac(newRouter, routerGwPort, routerId);
+ return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
+ }, Duration.ofSeconds(3), iid -> {
+ LOG.error("GwPort {} added without Router", routerGwPort.getUuid().getValue());
+ });
return;
}
- gwMacResolver.sendArpRequestsToExtGateways(router);
+ setupGwMac(router, routerGwPort, routerId);
+ }
- setExternalGwMac(routerGwPort, routerId);
+ private void setupGwMac(Router router, Port routerGwPort, Uuid routerId) {
+ gwMacResolver.sendArpRequestsToExtGateways(router);
+ jobCoordinator.enqueueJob(routerId.toString(), () -> {
+ setExternalGwMac(routerGwPort, routerId);
+ return Collections.emptyList();
+ });
}
private void setExternalGwMac(Port routerGwPort, Uuid routerId) {
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routersId, builder.build());
}
+ @Nullable
private String getPortHostId(final Port port) {
if (port != null) {
- PortBindingExtension portBinding = port.getAugmentation(PortBindingExtension.class);
+ PortBindingExtension portBinding = port.augmentation(PortBindingExtension.class);
if (portBinding != null) {
return portBinding.getHostId();
}
return null;
}
+ @Nullable
private Hostconfig getHostConfig(final Port port) {
String hostId = getPortHostId(port);
if (hostId == null) {
LOG.error("failed to read host config from host {}", hostId, e);
return null;
}
- return hostConfig.isPresent() ? hostConfig.get() : null;
+ return hostConfig.orNull();
}
private boolean isPortBound(final Port port) {
}
private boolean isPortVnicTypeDirect(Port port) {
- PortBindingExtension portBinding = port.getAugmentation(PortBindingExtension.class);
+ PortBindingExtension portBinding = port.augmentation(PortBindingExtension.class);
if (portBinding == null || portBinding.getVnicType() == null) {
// By default, VNIC_TYPE is NORMAL
return false;
return false;
}
+ @Nullable
private Map<String, JsonElement> unmarshal(final String profile) {
if (null == profile) {
return null;
}
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(profile, JsonObject.class);
- Map<String, JsonElement> map = new HashMap();
+ Map<String, JsonElement> map = new HashMap<>();
for (Map.Entry<String, JsonElement> entry : jsonObject.entrySet()) {
map.put(entry.getKey(), entry.getValue());
}
return false;
}
- PortBindingExtension portBinding = port.getAugmentation(PortBindingExtension.class);
+ PortBindingExtension portBinding = port.augmentation(PortBindingExtension.class);
String profile = portBinding.getProfile();
if (profile == null || profile.isEmpty()) {
LOG.debug("Port {} has no binding:profile values", port.getUuid());
private void handleNeutronPortCreated(final Port port) {
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
- final List<FixedIps> portIpAddrsList = port.getFixedIps();
+ final List<FixedIps> portIpAddrsList = requireNonNullElse(port.getFixedIps(), Collections.emptyList());
if (NeutronConstants.IS_ODL_DHCP_PORT.test(port)) {
return;
}
jobCoordinator.enqueueJob("PORT- " + portName, () -> {
// add direct port to subnetMaps config DS
if (!(NeutronUtils.isPortVnicTypeNormal(port)
- || (isPortTypeSwitchdev(port)
- && isSupportedVnicTypeByHost(port, NeutronConstants.VNIC_TYPE_DIRECT)))) {
+ || isPortTypeSwitchdev(port)
+ && isSupportedVnicTypeByHost(port, NeutronConstants.VNIC_TYPE_DIRECT))) {
for (FixedIps ip: portIpAddrsList) {
nvpnManager.updateSubnetmapNodeWithPorts(ip.getSubnetId(), null, portId);
}
- LOG.info("Port {} is not a NORMAL VNIC Type port; OF Port interfaces are not created", portName);
+ LOG.info("Port {} is not a normal and not a direct with switchdev VNIC type ;"
+ + "OF Port interfaces are not created", portName);
return Collections.emptyList();
}
- return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
+ return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
LOG.info("Of-port-interface creation for port {}", portName);
// Create of-port interface for this neutron port
String portInterfaceName = createOfPortInterface(port, tx);
private void handleNeutronPortDeleted(final Port port) {
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
- final List<FixedIps> portIpsList = port.getFixedIps();
- jobCoordinator.enqueueJob("PORT- " + portName, () -> {
- WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- if (!NeutronUtils.isPortVnicTypeNormal(port)) {
- for (FixedIps ip: portIpsList) {
- // remove direct port from subnetMaps config DS
- nvpnManager.removePortsFromSubnetmapNode(ip.getSubnetId(), null, portId);
- }
- LOG.info("Port {} is not a NORMAL VNIC Type port; OF Port interfaces are not created", portName);
- return futures;
- }
- Uuid vpnId = null;
- Set<Uuid> routerIds = new HashSet<>();
- Uuid internetVpnId = null;
- for (FixedIps ip: portIpsList) {
- Subnetmap subnetMap = nvpnManager.removePortsFromSubnetmapNode(ip.getSubnetId(), portId, null);
- if (subnetMap == null) {
- continue;
- }
- if (subnetMap.getVpnId() != null) {
- // can't use NeutronvpnUtils.getVpnForNetwork to optimise here, because it gives BGPVPN id
- // obtained subnetMaps belongs to one network => vpnId must be the same for each port Ip
- vpnId = subnetMap.getVpnId();
+ final List<FixedIps> portIpsList = requireNonNullElse(port.getFixedIps(), Collections.emptyList());
+ jobCoordinator.enqueueJob("PORT- " + portName,
+ () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, confTx -> {
+ if (!(NeutronUtils.isPortVnicTypeNormal(port) || isPortTypeSwitchdev(port))) {
+ for (FixedIps ip : portIpsList) {
+ // remove direct port from subnetMaps config DS
+ nvpnManager.removePortsFromSubnetmapNode(ip.getSubnetId(), null, portId);
+ }
+ LOG.info("Port {} is not a normal and not a direct with switchdev VNIC type ;"
+ + "Skipping OF Port interfaces removal", portName);
+ return;
}
- if (subnetMap.getRouterId() != null) {
- routerIds.add(subnetMap.getRouterId());
+ Uuid vpnId = null;
+ Set<Uuid> routerIds = new HashSet<>();
+ Uuid internetVpnId = null;
+ for (FixedIps ip : portIpsList) {
+ Subnetmap subnetMap = nvpnManager.removePortsFromSubnetmapNode(ip.getSubnetId(), portId, null);
+ if (subnetMap == null) {
+ continue;
+ }
+ if (subnetMap.getVpnId() != null) {
+ // can't use NeutronvpnUtils.getVpnForNetwork to optimise here, because it gives BGPVPN id
+ // obtained subnetMaps belongs to one network => vpnId must be the same for each port Ip
+ vpnId = subnetMap.getVpnId();
+ }
+ if (subnetMap.getRouterId() != null) {
+ routerIds.add(subnetMap.getRouterId());
+ }
+ internetVpnId = subnetMap.getInternetVpnId();
+
+ if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(port.getDeviceOwner())
+ || NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(port.getDeviceOwner())) {
+ String ipAddress = ip.getIpAddress().stringValue();
+ if (vpnId != null) {
+ neutronvpnUtils.removeVpnPortFixedIpToPort(vpnId.getValue(), ipAddress, confTx);
+ }
+ if (internetVpnId != null) {
+ neutronvpnUtils.removeVpnPortFixedIpToPort(internetVpnId.getValue(),
+ ipAddress, confTx);
+ }
+ }
}
- internetVpnId = subnetMap.getInternetVpnId();
- }
- if (vpnId != null || internetVpnId != null) {
- // remove vpn-interface for this neutron port
- LOG.debug("removing VPN Interface for port {}", portName);
- if (!routerIds.isEmpty()) {
- for (Uuid routerId : routerIds) {
- nvpnManager.removeFromNeutronRouterInterfacesMap(routerId, portName);
+ if (vpnId != null || internetVpnId != null) {
+ // remove vpn-interface for this neutron port
+ LOG.debug("removing VPN Interface for port {}", portName);
+ if (!routerIds.isEmpty()) {
+ for (Uuid routerId : routerIds) {
+ nvpnManager.removeFromNeutronRouterInterfacesMap(routerId, portName);
+ }
}
+ nvpnManager.deleteVpnInterface(portName, null /* vpn-id */, confTx);
}
- nvpnManager.deleteVpnInterface(portName, null /* vpn-id */, wrtConfigTxn);
- }
- // Remove of-port interface for this neutron port
- // ELAN interface is also implicitly deleted as part of this operation
- LOG.debug("Of-port-interface removal for port {}", portName);
- deleteOfPortInterface(port, wrtConfigTxn);
- //dissociate fixedIP from floatingIP if associated
- nvpnManager.dissociatefixedIPFromFloatingIP(port.getUuid().getValue());
- futures.add(wrtConfigTxn.submit());
- return futures;
- });
+ // Remove of-port interface for this neutron port
+ // ELAN interface is also implicitly deleted as part of this operation
+ LOG.debug("Of-port-interface removal for port {}", portName);
+ deleteOfPortInterface(port, confTx);
+ //dissociate fixedIP from floatingIP if associated
+ nvpnManager.dissociatefixedIPFromFloatingIP(port.getUuid().getValue());
+ })));
}
+ "during subnet deletion event.", portupdate.getUuid().getValue());
return;
}
+
+ if (NeutronConstants.IS_ODL_DHCP_PORT.test(portupdate)) {
+ return;
+ }
+
jobCoordinator.enqueueJob("PORT- " + portupdate.getUuid().getValue(),
- () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
+ () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, confTx -> {
final List<Uuid> originalSnMapsIds = portoriginalIps.stream().map(FixedIps::getSubnetId)
.collect(Collectors.toList());
final List<Uuid> updateSnMapsIds = portupdateIps.stream().map(FixedIps::getSubnetId)
.collect(Collectors.toList());
Set<Uuid> originalRouterIds = new HashSet<>();
- Set<Uuid> oldVpnIds = new HashSet<Uuid>();
- Uuid oldRouterId = null;
+ Set<Uuid> oldVpnIds = new HashSet<>();
for (Uuid snId: originalSnMapsIds) {
if (!updateSnMapsIds.remove(snId)) {
// snId was present in originalSnMapsIds, but not in updateSnMapsIds
}
}
}
- Set<Uuid> newVpnIds = new HashSet();
+ Set<Uuid> newVpnIds = new HashSet<>();
Set<Uuid> newRouterIds = new HashSet<>();
for (Uuid snId: updateSnMapsIds) {
Subnetmap subnetMapNew = nvpnManager.updateSubnetmapNodeWithPorts(snId, portupdate.getUuid(), null);
}
}
}
- WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
if (!oldVpnIds.isEmpty()) {
LOG.info("removing VPN Interface for port {}", portoriginal.getUuid().getValue());
if (!originalRouterIds.isEmpty()) {
}
}
nvpnManager.deleteVpnInterface(portoriginal.getUuid().getValue(),
- null /* vpn-id */, wrtConfigTxn);
+ null /* vpn-id */, confTx);
}
if (!newVpnIds.isEmpty()) {
LOG.info("Adding VPN Interface for port {}", portupdate.getUuid().getValue());
- nvpnManager.createVpnInterface(newVpnIds, portupdate, wrtConfigTxn);
+ nvpnManager.createVpnInterface(newVpnIds, portupdate, confTx);
if (!newRouterIds.isEmpty()) {
for (Uuid routerId : newRouterIds) {
nvpnManager.addToNeutronRouterInterfacesMap(routerId,portupdate.getUuid().getValue());
})));
}
- private static InterfaceAclBuilder handlePortSecurityUpdated(DataBroker dataBroker, Port portOriginal,
+ @Nullable
+ private InterfaceAclBuilder handlePortSecurityUpdated(Port portOriginal,
Port portUpdated, boolean origSecurityEnabled, boolean updatedSecurityEnabled,
InterfaceBuilder interfaceBuilder) {
InterfaceAclBuilder interfaceAclBuilder = null;
if (updatedSecurityEnabled) {
// Handle security group enabled
NeutronvpnUtils.populateInterfaceAclBuilder(interfaceAclBuilder, portUpdated);
+ neutronvpnUtils.populateSubnetInfo(portUpdated);
} else {
// Handle security group disabled
interfaceAclBuilder.setSecurityGroups(new ArrayList<>());
} else {
if (updatedSecurityEnabled) {
// handle SG add/delete delta
- InterfaceAcl interfaceAcl = interfaceBuilder.getAugmentation(InterfaceAcl.class);
+ InterfaceAcl interfaceAcl = interfaceBuilder.augmentation(InterfaceAcl.class);
interfaceAclBuilder = new InterfaceAclBuilder(interfaceAcl);
interfaceAclBuilder.setSecurityGroups(
NeutronvpnUtils.getUpdatedSecurityGroups(interfaceAcl.getSecurityGroups(),
interfaceAclBuilder.setAllowedAddressPairs(NeutronvpnUtils.getAllowedAddressPairsForFixedIps(
updatedAddressPairs, portOriginal.getMacAddress(), portOriginal.getFixedIps(),
portUpdated.getFixedIps()));
+
+ if (portOriginal.getFixedIps() != null
+ && !portOriginal.getFixedIps().equals(portUpdated.getFixedIps())) {
+ neutronvpnUtils.populateSubnetInfo(portUpdated);
+ }
}
}
return interfaceAclBuilder;
}
- private String createOfPortInterface(Port port, WriteTransaction wrtConfigTxn) {
+ private String createOfPortInterface(Port port, TypedWriteTransaction<Datastore.Configuration> wrtConfigTxn) {
Interface inf = createInterface(port);
String infName = inf.getName();
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
interfaceIdentifier);
if (!optionalInf.isPresent()) {
- wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, inf);
+ wrtConfigTxn.put(interfaceIdentifier, inf);
} else {
LOG.warn("Interface {} is already present", infName);
}
IfL2vlan.L2vlanMode l2VlanMode = IfL2vlan.L2vlanMode.Trunk;
InterfaceBuilder interfaceBuilder = new InterfaceBuilder();
IfL2vlanBuilder ifL2vlanBuilder = new IfL2vlanBuilder();
+
+ Network network = neutronvpnUtils.getNeutronNetwork(port.getNetworkId());
+ Boolean isVlanTransparent = network.isVlanTransparent();
+ if (isVlanTransparent != null && isVlanTransparent) {
+ l2VlanMode = IfL2vlan.L2vlanMode.Transparent;
+ }
+
ifL2vlanBuilder.setL2vlanMode(l2VlanMode);
interfaceBuilder.setEnabled(true).setName(interfaceName).setType(L2vlan.class)
interfaceAclBuilder.setPortSecurityEnabled(true);
NeutronvpnUtils.populateInterfaceAclBuilder(interfaceAclBuilder, port);
interfaceBuilder.addAugmentation(InterfaceAcl.class, interfaceAclBuilder.build());
- neutronvpnUtils.populateSubnetIpPrefixes(port);
+ neutronvpnUtils.populateSubnetInfo(port);
}
return interfaceBuilder.build();
}
- private void deleteOfPortInterface(Port port, WriteTransaction wrtConfigTxn) {
+ private void deleteOfPortInterface(Port port, TypedWriteTransaction<Datastore.Configuration> wrtConfigTxn) {
String name = port.getUuid().getValue();
LOG.debug("Removing OFPort Interface {}", name);
InstanceIdentifier<Interface> interfaceIdentifier = NeutronvpnUtils.buildVlanInterfaceIdentifier(name);
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
interfaceIdentifier);
if (optionalInf.isPresent()) {
- wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier);
+ wrtConfigTxn.delete(interfaceIdentifier);
} else {
LOG.warn("deleteOfPortInterface: Interface {} is not present", name);
}
}
}
- private void createElanInterface(Port port, String name, WriteTransaction wrtConfigTxn) {
+ private void createElanInterface(Port port, String name,
+ TypedWriteTransaction<Datastore.Configuration> wrtConfigTxn) {
String elanInstanceName = port.getNetworkId().getValue();
List<StaticMacEntries> staticMacEntries = NeutronvpnUtils.buildStaticMacEntry(port);
InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
.class, new ElanInterfaceKey(name)).build();
ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
- .setName(name).setStaticMacEntries(staticMacEntries).setKey(new ElanInterfaceKey(name)).build();
- wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, elanInterface);
+ .setName(name).setStaticMacEntries(staticMacEntries).withKey(new ElanInterfaceKey(name)).build();
+ wrtConfigTxn.put(id, elanInterface);
LOG.debug("Creating new ELan Interface {}", elanInterface);
}
- private void deleteElanInterface(String name, WriteTransaction wrtConfigTxn) {
+ private void deleteElanInterface(String name, TypedWriteTransaction<Datastore.Configuration> wrtConfigTxn) {
InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
.class, new ElanInterfaceKey(name)).build();
- wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, id);
+ wrtConfigTxn.delete(id);
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private void addToFloatingIpPortInfo(Uuid floatingIpId, Uuid floatingIpPortId, Uuid floatingIpPortSubnetId, String
floatingIpPortMacAddress) {
- InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
+ InstanceIdentifier id = NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
try {
FloatingIpIdToPortMappingBuilder floatingipIdToPortMacMappingBuilder = new
- FloatingIpIdToPortMappingBuilder().setKey(new FloatingIpIdToPortMappingKey(floatingIpId))
+ FloatingIpIdToPortMappingBuilder().withKey(new FloatingIpIdToPortMappingKey(floatingIpId))
.setFloatingIpId(floatingIpId).setFloatingIpPortId(floatingIpPortId)
.setFloatingIpPortSubnetId(floatingIpPortSubnetId)
.setFloatingIpPortMacAddress(floatingIpPortMacAddress);
Code Review / netvirt.git / blobdiff