import com.google.common.base.Function;
import com.google.common.collect.Lists;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
*/
public class L2GatewayDevice {
- /** The device name. */
String deviceName;
-
- /** The hwvtep node id. */
String hwvtepNodeId;
-
- /** The tunnel ips. */
Set<IpAddress> tunnelIps = new HashSet<>();
-
- /** The l2 gateway ids. */
Set<Uuid> l2GatewayIds = new HashSet<>();
-
- /** The ucast local macs. */
List<LocalUcastMacs> ucastLocalMacs = Collections.synchronizedList(new ArrayList<>());
-
- /** the status of this device connectin */
AtomicBoolean connected = new AtomicBoolean(false);
-
- /** Connection Id to Devices */
Map<Uuid,List<Devices>> l2gwConnectionIdToDevices = new HashMap<>();
/**
package org.opendaylight.netvirt.neutronvpn.api.l2gw.utils;
import java.util.concurrent.ConcurrentMap;
-
-import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.genius.utils.cache.CacheUtil;
+import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
public class L2GatewayCacheUtils {
public static final String L2GATEWAY_CACHE_NAME = "L2GW";
package org.opendaylight.netvirt.neutronvpn.interfaces;
+import java.util.Collection;
+import java.util.List;
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
-import java.util.Collection;
-import java.util.List;
-
public interface INeutronVpnManager {
void addSubnetToVpn(Uuid vpnId, Uuid subnet);
Port getNeutronPort(String name);
- Subnet getNeutronSubnet(Uuid subnetId);
-
Port getNeutronPort(Uuid portId);
+ Subnet getNeutronSubnet(Uuid subnetId);
+
IpAddress getNeutronSubnetGateway(Uuid subnetId);
String getVifPortName(Port port);
</distributionManagement>
<build>
<plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
+ </configuration>
+ </plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterfaceStateToTransportZoneListener extends AsyncDataTreeChangeListenerBase<Interface, InterfaceStateToTransportZoneListener> implements ClusteredDataTreeChangeListener<Interface>, AutoCloseable{
+public class InterfaceStateToTransportZoneListener
+ extends AsyncDataTreeChangeListenerBase<Interface, InterfaceStateToTransportZoneListener>
+ implements ClusteredDataTreeChangeListener<Interface>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceStateToTransportZoneListener.class);
private TransportZoneNotificationUtil ism;
private final IdManagerService idManager;
private final String adminRDValue;
- public NeutronBgpvpnChangeListener(final DataBroker dataBroker, final NeutronvpnManager nVpnMgr,
+ public NeutronBgpvpnChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
final IdManagerService idManager) {
super(Bgpvpn.class, NeutronBgpvpnChangeListener.class);
this.dataBroker = dataBroker;
- nvpnManager = nVpnMgr;
+ nvpnManager = neutronvpnManager;
this.idManager = idManager;
- BundleContext bundleContext=FrameworkUtil.getBundle(NeutronBgpvpnChangeListener.class).getBundleContext();
+ BundleContext bundleContext = FrameworkUtil.getBundle(NeutronBgpvpnChangeListener.class).getBundleContext();
adminRDValue = bundleContext.getProperty(NeutronConstants.RD_PROPERTY_KEY);
}
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void add(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
LOG.trace("Adding Bgpvpn : key: {}, value={}", identifier, input);
if (isBgpvpnTypeL3(input.getType())) {
// handle route-target(s)
- List<String> importRouteTargets = new ArrayList<String>();
- List<String> exportRouteTargets = new ArrayList<String>();
List<String> inputRouteList = input.getRouteTargets();
List<String> inputImportRouteList = input.getImportTargets();
List<String> inputExportRouteList = input.getExportTargets();
inputExportRouteSet.addAll(inputExportRouteList);
}
+ List<String> importRouteTargets = new ArrayList<String>();
+ List<String> exportRouteTargets = new ArrayList<String>();
importRouteTargets.addAll(inputImportRouteSet);
exportRouteTargets.addAll(inputExportRouteSet);
}
if (rd != null) {
try {
- nvpnManager.createL3Vpn(input.getUuid(), input.getName(), input.getTenantId(), rd, importRouteTargets,
- exportRouteTargets, router, input.getNetworks());
+ nvpnManager.createL3Vpn(input.getUuid(), input.getName(), input.getTenantId(), rd,
+ importRouteTargets, exportRouteTargets, router, input.getNetworks());
} catch (Exception e) {
LOG.error("Creation of BGPVPN {} failed with error message {}. ", input.getUuid(),
e.getMessage(), e);
if (oldRouters.size() > 1 || newRouters.size() > 1) {
VpnMap vpnMap = NeutronvpnUtils.getVpnMap(dataBroker, vpnId);
if (vpnMap.getRouterId() != null) {
- LOG.warn("Only Single Router association to a given bgpvpn is allowed .Kindly de-associate " +
- "router " + vpnMap.getRouterId().getValue() + " from vpn " + vpnId + " before " +
- "proceeding with associate");
+ LOG.warn("Only Single Router association to a given bgpvpn is allowed. Kindly de-associate"
+ + " router " + vpnMap.getRouterId().getValue()
+ + " from vpn " + vpnId + " before proceeding with associate");
}
- return;
}
} else if (validateRouteInfo(newRouters.get(0))) {
nvpnManager.associateRouterToVpn(vpnId, newRouters.get(0));
}
-
} else if (oldRouters != null && !oldRouters.isEmpty()) {
/* dissociate old router */
Uuid oldRouter = oldRouters.get(0);
*/
package org.opendaylight.netvirt.neutronvpn;
+import static org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier;
+
import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import static org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier;
-
public class NeutronFloatingToFixedIpMappingChangeListener extends AsyncDataTreeChangeListenerBase<Floatingip,
NeutronFloatingToFixedIpMappingChangeListener> implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(NeutronFloatingToFixedIpMappingChangeListener.class);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void addToFloatingIpInfo(String routerName, Uuid extNetworkId, String fixedNeutronPortName, String
fixedIpAddress, String floatingIpAddress, Uuid floatingIpId) {
RouterPortsBuilder routerPortsBuilder;
Optional<RouterPorts> optionalRouterPorts = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
.CONFIGURATION, routerPortsIdentifier);
if (optionalRouterPorts.isPresent()) {
- LOG.debug("Updating routerPorts node {} in floatingIpInfo DS for floating IP () on fixed " +
- "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
+ LOG.debug("Updating routerPorts node {} in floatingIpInfo DS for floating IP () on fixed "
+ + "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
routerPortsBuilder = new RouterPortsBuilder(optionalRouterPorts.get());
} else {
- LOG.debug("Creating new routerPorts node {} in floatingIpInfo DS for floating IP () on fixed " +
- "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
- routerPortsBuilder = new RouterPortsBuilder().setKey(new RouterPortsKey(routerName)).setRouterId
- (routerName);
+ LOG.debug("Creating new routerPorts node {} in floatingIpInfo DS for floating IP () on fixed "
+ + "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
+ routerPortsBuilder =
+ new RouterPortsBuilder().setKey(new RouterPortsKey(routerName)).setRouterId(routerName);
}
if (extNetworkId != null) {
routerPortsBuilder.setExternalNetworkId(extNetworkId);
routerPortsBuilder.setPorts(portsList);
}
isLockAcquired = NeutronvpnUtils.lock(routerName);
- LOG.debug("Creating/Updating routerPorts node {} in floatingIpInfo DS for floating IP () on fixed " +
- "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifier, routerPortsBuilder
- .build());
+ LOG.debug("Creating/Updating routerPorts node {} in floatingIpInfo DS for floating IP () on fixed "
+ + "neutron port {} : ", routerName, floatingIpAddress, fixedNeutronPortName);
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifier,
+ routerPortsBuilder.build());
LOG.debug("FloatingIpInfo DS updated for floating IP {} ", floatingIpAddress);
} catch (Exception e) {
LOG.error("addToFloatingIpInfo failed for floating IP: {} ", floatingIpAddress);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void clearFromFloatingIpInfo(String routerName, String fixedNeutronPortName, String fixedIpAddress) {
boolean isLockAcquired = false;
InstanceIdentifier.InstanceIdentifierBuilder<RouterPorts> routerPortsIdentifierBuilder = InstanceIdentifier
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void dissociatefixedIPFromFloatingIP(String fixedNeutronPortName) {
boolean isLockAcquired = false;
InstanceIdentifier.InstanceIdentifierBuilder<FloatingIpInfo> floatingIpInfoIdentifierBuilder =
if (ports.getPortName().equals(fixedNeutronPortName)) {
String routerName = routerPorts.getRouterId();
InstanceIdentifier.InstanceIdentifierBuilder<RouterPorts>
- routerPortsIdentifierBuilder = floatingIpInfoIdentifierBuilder.child
- (RouterPorts.class, new RouterPortsKey(routerName));
+ routerPortsIdentifierBuilder = floatingIpInfoIdentifierBuilder
+ .child(RouterPorts.class, new RouterPortsKey(routerName));
removeRouterPortsOrPortsNode(routerName, routerPortsIdentifierBuilder, portsList,
fixedNeutronPortName, isLockAcquired);
LOG.debug("Deletion from FloatingIpInfo DS successful for fixedIP neutron port {} ",
LOG.debug("No router present containing fixed to floating IP association(s)");
}
} else {
- LOG.debug("FloatingIPInfo DS empty. Hence, no router present containing fixed to floating IP " +
- "association(s)");
+ LOG.debug("FloatingIPInfo DS empty. Hence, no router present containing fixed to floating IP "
+ + "association(s)");
}
} catch (Exception e) {
LOG.error("Failed to dissociate fixedIP from FloatingIpInfo DS for neutron port {}", fixedNeutronPortName);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void removeRouterPortsOrPortsNode(String routerName, InstanceIdentifier
.InstanceIdentifierBuilder<RouterPorts> routerPortsIdentifierBuilder, List<Ports> portsList,
String fixedNeutronPortName, boolean isLockAcquired) {
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, routerPortsIdentifierBuilder
.build());
} else {
- InstanceIdentifier.InstanceIdentifierBuilder<Ports> portsIdentifierBuilder =
- routerPortsIdentifierBuilder.child(Ports.class, new PortsKey(fixedNeutronPortName));
// remove entire ports node under this routerPorts node
lockName = fixedNeutronPortName;
isLockAcquired = NeutronvpnUtils.lock(lockName);
LOG.debug("removing ports node {} under routerPorts node {}", fixedNeutronPortName, routerName);
+ InstanceIdentifier.InstanceIdentifierBuilder<Ports> portsIdentifierBuilder =
+ routerPortsIdentifierBuilder.child(Ports.class, new PortsKey(fixedNeutronPortName));
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, portsIdentifierBuilder.build());
}
} catch (Exception e) {
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
// updates FloatingIPPortInfo to have isFloatingIPDeleted set to true on a floating IP delete
private void updateFloatingIpPortInfo(Uuid floatingIpId, Uuid floatingIpPortId) {
InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
try {
FloatingIpIdToPortMappingBuilder floatingIpIdToPortMappingBuilder = new
FloatingIpIdToPortMappingBuilder().setFloatingIpId(floatingIpId).setFloatingIpDeleted(true);
- LOG.debug("Updating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP" +
- " Port Info Config DS to set isFloatingIpDeleted flag as true", floatingIpId.getValue(),
- floatingIpPortId.getValue());
+ LOG.debug("Updating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP"
+ + " Port Info Config DS to set isFloatingIpDeleted flag as true",
+ floatingIpId.getValue(), floatingIpPortId.getValue());
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, id,
floatingIpIdToPortMappingBuilder.build());
} catch (Exception e) {
- LOG.error("Updating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP" +
- " Port Info Config DS to set isFloatingIpDeleted flag as true failed with exception {}",
- floatingIpId.getValue(), floatingIpPortId.getValue(), e);
+ LOG.error("Updating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP"
+ + " Port Info Config DS to set isFloatingIpDeleted flag as true failed with exception {}",
+ floatingIpId.getValue(), floatingIpPortId.getValue(), e);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void removeFromFloatingIpPortInfo(Uuid floatingIpId) {
InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
try {
- LOG.debug("Deleting floating IP UUID {} to Floating IP neutron port mapping from Floating " +
- "IP Port Info Config DS", floatingIpId.getValue());
+ LOG.debug("Deleting floating IP UUID {} to Floating IP neutron port mapping from Floating "
+ + "IP Port Info Config DS", floatingIpId.getValue());
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
} catch (Exception e) {
- LOG.error("Deleting floating IP UUID {} to Floating IP neutron port mapping from Floating " +
- "IP Port Info Config DS failed with exception {}", floatingIpId.getValue(), e);
+ LOG.error("Deleting floating IP UUID {} to Floating IP neutron port mapping from Floating "
+ + "IP Port Info Config DS failed with exception {}", floatingIpId.getValue(), e);
}
}
}
DELETE
}
- public NeutronHostConfigChangeListener(final DataBroker dataBroker){
+ public NeutronHostConfigChangeListener(final DataBroker dataBroker) {
super(Node.class,NeutronHostConfigChangeListener.class);
this.dataBroker = dataBroker;
this.mdsalUtils = new MdsalUtils(dataBroker);
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath(){
+ protected InstanceIdentifier<Node> getWildCardPath() {
return InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class,new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
@Override
- protected void remove(InstanceIdentifier<Node>identifier, Node del){
+ protected void remove(InstanceIdentifier<Node> identifier, Node del) {
updateHostConfig(del, Action.DELETE);
}
@Override
- protected void update(InstanceIdentifier<Node>identifier, Node original, Node update){
+ protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
updateHostConfig(update, Action.UPDATE);
}
@Override
- protected void add(InstanceIdentifier<Node>identifier, Node add){
+ protected void add(InstanceIdentifier<Node> identifier, Node add) {
updateHostConfig(add, Action.ADD);
}
private void updateHostConfig(Node node, Action action) {
String hostId = getExternalId(node, OS_HOST_CONFIG_HOST_ID_KEY);
- if (hostId == null){
+ if (hostId == null) {
return;
}
- for(Map.Entry<String,String> entry : extractHostConfig(node).entrySet()) {
+ for (Map.Entry<String,String> entry : extractHostConfig(node).entrySet()) {
updateMdsal(buildHostConfigInfo(hostId, entry.getKey(), entry.getValue()), action);
}
}
hostType = hostType.substring(0, HOST_TYPE_STR_LEN);
}
hostType = "ODL " + hostType.toUpperCase();
- if (null != openvswitchExternalIds.getExternalIdValue())
+ if (null != openvswitchExternalIds.getExternalIdValue()) {
config.put(hostType, openvswitchExternalIds.getExternalIdValue());
+ }
}
}
}
result = mdsalUtils.delete(LogicalDatastoreType.OPERATIONAL, hostConfigId);
LOG.trace("Delete Node: result: {}", result);
break;
+ default:
+ LOG.warn("Invalid action: %s", action);
+ break;
}
}
return null;
}
- private OvsdbNodeAugmentation getOvsdbNodeAugmentation(Node node)
- {
+ private OvsdbNodeAugmentation getOvsdbNodeAugmentation(Node node) {
OvsdbNodeAugmentation ovsdbNode = southboundUtils.extractOvsdbNode(node);
if (ovsdbNode == null) {
Node nodeFromReadOvsdbNode = southboundUtils.readOvsdbNode(node);
*/
package org.opendaylight.netvirt.neutronvpn;
-import java.util.Objects;
-
import com.google.common.base.Optional;
+import java.util.Objects;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
private final IElanService elanService;
private OdlInterfaceRpcService odlInterfaceRpcService;
- public NeutronNetworkChangeListener(final DataBroker dataBroker, final NeutronvpnManager nVpnMgr,
- final NeutronvpnNatManager nVpnNatMgr, final IElanService elanService,
+ public NeutronNetworkChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
+ final NeutronvpnNatManager neutronvpnNatManager,
+ final IElanService elanService,
OdlInterfaceRpcService odlInterfaceRpcService) {
super(Network.class, NeutronNetworkChangeListener.class);
this.dataBroker = dataBroker;
- nvpnManager = nVpnMgr;
- nvpnNatManager = nVpnNatMgr;
+ nvpnManager = neutronvpnManager;
+ nvpnNatManager = neutronvpnNatManager;
this.elanService = elanService;
this.odlInterfaceRpcService = odlInterfaceRpcService;
}
protected void add(InstanceIdentifier<Network> identifier, Network input) {
LOG.trace("Adding Network : key: {}, value={}", identifier, input);
if (!NeutronvpnUtils.isNetworkTypeSupported(input)) {
- LOG.error("Neutronvpn doesn't support this network provider type for this network {} and uuid {}.", input.getName(), input.getUuid());
+ LOG.error("Neutronvpn doesn't support this network provider type for this network {} and uuid {}.",
+ input.getName(), input.getUuid());
return;
}
Class<? extends SegmentTypeBase> segmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(input);
String segmentationId = NeutronUtils.getSegmentationIdFromNeutronNetwork(input);
String physicalNetworkName = NeutronvpnUtils.getPhysicalNetworkName(input);
- ElanInstance elanInstance = createElanInstance(elanInstanceName, segmentType, segmentationId, physicalNetworkName);
+ ElanInstance elanInstance = createElanInstance(elanInstanceName, segmentType, segmentationId,
+ physicalNetworkName);
InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
- Optional<ElanInstance> existingElanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<ElanInstance> existingElanInstance =
+ MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
if (existingElanInstance.isPresent()) {
return existingElanInstance.get();
}
return elanInstance;
}
+ private ElanInstance createElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
+ String segmentationId, String physicalNetworkName) {
+ ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName);
+ if (segmentType != null) {
+ elanInstanceBuilder.setSegmentType(segmentType);
+ if (segmentationId != null) {
+ elanInstanceBuilder.setSegmentationId(Long.valueOf(segmentationId));
+ }
+ if (physicalNetworkName != null) {
+ elanInstanceBuilder.setPhysicalNetworkName(physicalNetworkName);
+ }
+ }
+ elanInstanceBuilder.setKey(new ElanInstanceKey(elanInstanceName));
+ return elanInstanceBuilder.build();
+ }
+
private void deleteElanInstance(String elanInstanceName) {
InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
private ElanInstance updateElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
String segmentationId, String physicalNetworkName) {
- ElanInstance elanInstance = createElanInstance(elanInstanceName, segmentType, segmentationId, physicalNetworkName);
+ ElanInstance elanInstance =
+ createElanInstance(elanInstanceName, segmentType, segmentationId, physicalNetworkName);
InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, id, elanInstance);
return elanInstance;
.child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
return id;
}
-
- private ElanInstance createElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
- String segmentationId, String physicalNetworkName) {
- ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName);
- if (segmentType != null) {
- elanInstanceBuilder.setSegmentType(segmentType);
- if (segmentationId != null) {
- elanInstanceBuilder.setSegmentationId(Long.valueOf(segmentationId));
- }
- if (physicalNetworkName != null) {
- elanInstanceBuilder.setPhysicalNetworkName(physicalNetworkName);
- }
- }
- elanInstanceBuilder.setKey(new ElanInstanceKey(elanInstanceName));
- return elanInstanceBuilder.build();
- }
-
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAcl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAclBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.port.info.FloatingIpIdToPortMappingBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.port.info.FloatingIpIdToPortMappingKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.PortAddedToSubnetBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.PortRemovedFromSubnetBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
private final IElanService elanService;
public NeutronPortChangeListener(final DataBroker dataBroker,
- final NeutronvpnManager nVpnMgr, final NeutronvpnNatManager nVpnNatMgr,
+ final NeutronvpnManager neutronvpnManager,
+ final NeutronvpnNatManager neutronvpnNatManager,
final NotificationPublishService notiPublishService,
final NeutronSubnetGwMacResolver gwMacResolver,
final OdlInterfaceRpcService odlInterfaceRpcService,
final IElanService elanService) {
super(Port.class, NeutronPortChangeListener.class);
this.dataBroker = dataBroker;
- nvpnManager = nVpnMgr;
- nvpnNatManager = nVpnNatMgr;
+ nvpnManager = neutronvpnManager;
+ nvpnNatManager = neutronvpnNatManager;
notificationPublishService = notiPublishService;
this.gwMacResolver = gwMacResolver;
this.odlInterfaceRpcService = odlInterfaceRpcService;
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, input.getNetworkId());
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
//FIXME: This should be removed when support for VLAN and GRE network types is added
- LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of " +
- "network {}.", portName, network);
+ LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of "
+ + "network {}.", portName, network);
return;
}
NeutronvpnUtils.addToPortCache(input);
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, input.getNetworkId());
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
//FIXME: This should be removed when support for VLAN and GRE network types is added
- LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of " +
- "network {}.", input.getUuid().getValue(), network);
+ LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of "
+ + "network {}.", input.getUuid().getValue(), network);
return;
}
NeutronvpnUtils.removeFromPortCache(input);
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
final String portName = update.getUuid().getValue();
LOG.trace("Updating Port : key: {}, original value={}, update value={}", identifier, original, update);
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, update.getNetworkId());
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
- LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of " +
- "network {}. Skipping the processing of Port update DCN", portName, network);
+ LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of "
+ + "network {}. Skipping the processing of Port update DCN", portName, network);
return;
}
NeutronvpnUtils.addToPortCache(update);
if (optionalInf.isPresent()) {
InterfaceBuilder interfaceBuilder = new InterfaceBuilder(optionalInf.get());
if (isPortVifTypeUpdated && getParentRefsBuilder(update) != null) {
- interfaceBuilder.addAugmentation(ParentRefs.class, getParentRefsBuilder(update).build
- ());
+ interfaceBuilder.addAugmentation(ParentRefs.class,
+ getParentRefsBuilder(update).build());
}
if (origSecurityEnabled || updatedSecurityEnabled) {
InterfaceAcl infAcl = handlePortSecurityUpdated(original, update,
nvpnManager.createVpnInterface(vpnId, routerId, routerPort, null);
}
} else {
- LOG.error("Neutron network {} corresponding to router interface port {} for neutron router {} already" +
- " associated to VPN {}", infNetworkId.getValue(), routerPort.getUuid().getValue(), routerId
- .getValue(), existingVpnId.getValue());
+ LOG.error("Neutron network {} corresponding to router interface port {} for neutron router {} already"
+ + " associated to VPN {}", infNetworkId.getValue(), routerPort.getUuid().getValue(),
+ routerId.getValue(), existingVpnId.getValue());
}
}
}
NwConstants.DEL_FLOW);
for (FixedIps portIP : routerPort.getFixedIps()) {
Uuid vpnId = NeutronvpnUtils.getVpnForRouter(dataBroker, routerId, true);
- if(vpnId == null) {
+ if (vpnId == null) {
vpnId = routerId;
}
// NOTE: Please donot change the order of calls to removeSubnetFromVpn and
}
final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
- portDataStoreCoordinator.enqueueJob("PORT- " + portupdate.getUuid().getValue(), new
- Callable<List<ListenableFuture<Void>>>() {
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
- List<ListenableFuture<Void>> futures = new ArrayList<>();
-
- Uuid vpnIdNew = null;
- final Uuid subnetIdOr = portupdate.getFixedIps().get(0).getSubnetId();
- final Uuid subnetIdUp = portupdate.getFixedIps().get(0).getSubnetId();
- // check if subnet UUID has changed upon change in fixedIP
- final Boolean subnetUpdated = subnetIdUp.equals(subnetIdOr) ? false : true;
-
- if (subnetUpdated) {
- Subnetmap subnetMapOld = nvpnManager.removePortsFromSubnetmapNode(subnetIdOr, portoriginal
- .getUuid(), null);
- Uuid vpnIdOld = (subnetMapOld != null) ? subnetMapOld.getVpnId() : null;
- Subnetmap subnetMapNew = nvpnManager.updateSubnetmapNodeWithPorts(subnetIdUp, portupdate
- .getUuid(), null);
- vpnIdNew = (subnetMapNew != null) ? subnetMapNew.getVpnId() : null;
- }
- if (!subnetUpdated) {
- Subnetmap subnetmap = NeutronvpnUtils.getSubnetmap(dataBroker, subnetIdUp);
- vpnIdNew = subnetmap.getVpnId();
- }
- if (vpnIdNew != null) {
- // remove vpn-interface for this neutron port
- LOG.debug("removing VPN Interface for port {}", portupdate.getUuid().getValue());
- nvpnManager.deleteVpnInterface(vpnIdNew, null, portupdate, wrtConfigTxn);
- // create vpn-interface on this neutron port
- LOG.debug("Adding VPN Interface for port {}", portupdate.getUuid().getValue());
- nvpnManager.createVpnInterface(vpnIdNew, null, portupdate, wrtConfigTxn);
- }
- futures.add(wrtConfigTxn.submit());
- return futures;
- }
- });
+ portDataStoreCoordinator.enqueueJob("PORT- " + portupdate.getUuid().getValue(), () -> {
+ WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
+ Uuid vpnIdNew = null;
+ final Uuid subnetIdOr = portupdate.getFixedIps().get(0).getSubnetId();
+ final Uuid subnetIdUp = portupdate.getFixedIps().get(0).getSubnetId();
+ // check if subnet UUID has changed upon change in fixedIP
+ final Boolean subnetUpdated = subnetIdUp.equals(subnetIdOr) ? false : true;
+
+ if (subnetUpdated) {
+ Subnetmap subnetMapOld = nvpnManager.removePortsFromSubnetmapNode(subnetIdOr, portoriginal
+ .getUuid(), null);
+ Uuid vpnIdOld = (subnetMapOld != null) ? subnetMapOld.getVpnId() : null;
+ Subnetmap subnetMapNew = nvpnManager.updateSubnetmapNodeWithPorts(subnetIdUp, portupdate
+ .getUuid(), null);
+ vpnIdNew = (subnetMapNew != null) ? subnetMapNew.getVpnId() : null;
+ }
+ if (!subnetUpdated) {
+ Subnetmap subnetmap = NeutronvpnUtils.getSubnetmap(dataBroker, subnetIdUp);
+ vpnIdNew = subnetmap != null ? subnetmap.getVpnId() : null;
+ }
+ if (vpnIdNew != null) {
+ // remove vpn-interface for this neutron port
+ LOG.debug("removing VPN Interface for port {}", portupdate.getUuid().getValue());
+ nvpnManager.deleteVpnInterface(vpnIdNew, null, portupdate, wrtConfigTxn);
+ // create vpn-interface on this neutron port
+ LOG.debug("Adding VPN Interface for port {}", portupdate.getUuid().getValue());
+ nvpnManager.createVpnInterface(vpnIdNew, null, portupdate, wrtConfigTxn);
+ }
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ futures.add(wrtConfigTxn.submit());
+ return futures;
+ });
}
private static InterfaceAclBuilder handlePortSecurityUpdated(Port portOriginal, Port portUpdated, boolean
return interfaceAclBuilder;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private String createOfPortInterface(Port port, WriteTransaction wrtConfigTxn) {
Interface inf = createInterface(port);
String infName = inf.getName();
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, port.getNetworkId());
ifL2vlanBuilder.setL2vlanMode(l2VlanMode);
- if(parentRefName != null) {
+ if (parentRefName != null) {
ParentRefsBuilder parentRefsBuilder = new ParentRefsBuilder().setParentInterface(parentRefName);
interfaceBuilder.addAugmentation(ParentRefs.class, parentRefsBuilder.build());
}
return interfaceBuilder.build();
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void deleteOfPortInterface(Port port, WriteTransaction wrtConfigTxn) {
String name = port.getUuid().getValue();
LOG.debug("Removing OFPort Interface {}", name);
LOG.debug("Creating new ELan Interface {}", elanInterface);
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void addToFloatingIpPortInfo(Uuid floatingIpId, Uuid floatingIpPortId, Uuid floatingIpPortSubnetId, String
floatingIpPortMacAddress) {
InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
try {
FloatingIpIdToPortMappingBuilder floatingipIdToPortMacMappingBuilder = new
- FloatingIpIdToPortMappingBuilder().setKey(new FloatingIpIdToPortMappingKey(floatingIpId))
- .setFloatingIpId(floatingIpId).setFloatingIpPortId(floatingIpPortId).setFloatingIpPortSubnetId
- (floatingIpPortSubnetId).setFloatingIpPortMacAddress(floatingIpPortMacAddress);
- LOG.debug("Creating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP" +
- " Port Info Config DS", floatingIpId.getValue(), floatingIpPortId.getValue());
+ FloatingIpIdToPortMappingBuilder().setKey(new FloatingIpIdToPortMappingKey(floatingIpId))
+ .setFloatingIpId(floatingIpId).setFloatingIpPortId(floatingIpPortId)
+ .setFloatingIpPortSubnetId(floatingIpPortSubnetId)
+ .setFloatingIpPortMacAddress(floatingIpPortMacAddress);
+ LOG.debug("Creating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP"
+ + " Port Info Config DS", floatingIpId.getValue(), floatingIpPortId.getValue());
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id,
- floatingipIdToPortMacMappingBuilder.build());
+ floatingipIdToPortMacMappingBuilder.build());
} catch (Exception e) {
- LOG.error("Creating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP" +
- " Port Info Config DS failed with exception {}", floatingIpId.getValue(), floatingIpPortId
- .getValue(), e);
+ LOG.error("Creating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP"
+ + " Port Info Config DS failed with exception {}",
+ floatingIpId.getValue(), floatingIpPortId.getValue(), e);
}
}
}
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void close() throws Exception {
if (listenerRegistration != null) {
try {
return bridgeEntryIdBuilder.build();
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, DataBroker broker) {
private final NeutronvpnNatManager nvpnNatManager;
private final NeutronSubnetGwMacResolver gwMacResolver;
- public NeutronRouterChangeListener(final DataBroker dataBroker, final NeutronvpnManager nVpnMgr,
- final NeutronvpnNatManager nVpnNatMgr, NeutronSubnetGwMacResolver gwMacResolver) {
+ public NeutronRouterChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
+ final NeutronvpnNatManager neutronvpnNatManager,
+ NeutronSubnetGwMacResolver gwMacResolver) {
super(Router.class, NeutronRouterChangeListener.class);
this.dataBroker = dataBroker;
- nvpnManager = nVpnMgr;
- nvpnNatManager = nVpnNatMgr;
+ nvpnManager = neutronvpnManager;
+ nvpnNatManager = neutronvpnNatManager;
this.gwMacResolver = gwMacResolver;
}
if ( interVpnLink.isPresent() ) {
Optional<InterVpnLinkState> interVpnLinkState =
NeutronvpnUtils.getInterVpnLinkState(dataBroker, interVpnLink.get().getName());
- if ( interVpnLinkState.isPresent() && interVpnLinkState.get().getState() == InterVpnLinkState.State.Active) {
+ if ( interVpnLinkState.isPresent()
+ && interVpnLinkState.get().getState() == InterVpnLinkState.State.Active) {
interVpnLinkRoutes.add(route);
nexthopsXinterVpnLinks.put(nextHop, interVpnLink.get());
} else {
extends AsyncDataTreeChangeListenerBase<SecurityRule, NeutronSecurityRuleListener> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityRuleListener.class);
private final DataBroker dataBroker;
- private static final ImmutableBiMap<Class<? extends DirectionBase>, Class<? extends org.opendaylight.yang.gen.
- v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionBase>> DIRECTION_MAP = ImmutableBiMap.of(
+ private static final ImmutableBiMap<Class<? extends DirectionBase>,
+ Class<?extends org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionBase>>
+ DIRECTION_MAP = ImmutableBiMap.of(
DirectionEgress.class, NeutronSecurityRuleConstants.DIRECTION_EGRESS,
DirectionIngress.class, NeutronSecurityRuleConstants.DIRECTION_INGRESS);
private static final ImmutableBiMap<Class<? extends ProtocolBase>, Short> PROTOCOL_MAP = ImmutableBiMap.of(
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void add(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule securityRule) {
LOG.trace("added securityRule: {}", securityRule);
try {
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void remove(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule securityRule) {
LOG.trace("removed securityRule: {}", securityRule);
try {
}
@Override
- protected void update(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule oldSecurityRule, SecurityRule updatedSecurityRule) {
+ protected void update(InstanceIdentifier<SecurityRule> instanceIdentifier,
+ SecurityRule oldSecurityRule, SecurityRule updatedSecurityRule) {
// security rule updation is not supported from openstack, so no need to handle update.
LOG.trace("updates on security rules not supported.");
}
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
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.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
private final DataBroker dataBroker;
private final NeutronvpnManager nvpnManager;
- public NeutronSubnetChangeListener(final DataBroker dataBroker, final NeutronvpnManager nVpnMgr) {
+ public NeutronSubnetChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager) {
super(Subnet.class, NeutronSubnetChangeListener.class);
this.dataBroker = dataBroker;
- nvpnManager = nVpnMgr;
+ nvpnManager = neutronvpnManager;
}
public void start() {
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, networkId);
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
//FIXME: This should be removed when support for VLAN and GRE network types is added
- LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of network {}."
- + " Skipping the processing of Subnet add DCN", input.getName(), network);
+ LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} "
+ + "which is part of network {}."
+ + " Skipping the processing of Subnet add DCN", input.getName(), network);
return;
}
handleNeutronSubnetCreated(input.getUuid(), String.valueOf(input.getCidr().getValue()), networkId,
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, networkId);
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
//FIXME: This should be removed when support for GRE network types is added
- LOG.error("neutron vpn doesn't support gre network provider type for the port {} which is part of network {}."
- + " Skipping the processing of Subnet remove DCN", input.getName(), network);
+ LOG.error("neutron vpn doesn't support gre network provider type for the port {} "
+ + "which is part of network {}."
+ + " Skipping the processing of Subnet remove DCN", input.getName(), network);
return;
}
handleNeutronSubnetDeleted(input.getUuid(), networkId, null);
Uuid networkId = update.getNetworkId();
Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, networkId);
if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
- LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} which is part of network {}."
- + " Skipping the processing of Subnet update DCN", update.getName(), network);
+ LOG.error("neutron vpn doesn't support vlan/gre network provider type for the port {} "
+ + "which is part of network {}."
+ + " Skipping the processing of Subnet update DCN", update.getName(), network);
return;
}
handleNeutronSubnetUpdated(update.getUuid(), networkId, update.getTenantId());
nvpnManager.updateSubnetNode(subnetId, null, tenantId, networkId, null/*routerID*/, null/*vpnID*/);
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void createSubnetToNetworkMapping(Uuid subnetId, Uuid networkId) {
try {
InstanceIdentifier networkMapIdentifier = NeutronvpnUtils.buildNetworkMapIdentifier(networkId);
- Optional<NetworkMap> optionalNetworkMap = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- networkMapIdentifier);
+ Optional<NetworkMap> optionalNetworkMap =
+ NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier);
NetworkMapBuilder nwMapBuilder = null;
if (optionalNetworkMap.isPresent()) {
nwMapBuilder = new NetworkMapBuilder(optionalNetworkMap.get());
}
subnetIdList.add(subnetId);
nwMapBuilder.setSubnetIdList(subnetIdList);
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier, nwMapBuilder.build());
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ networkMapIdentifier, nwMapBuilder.build());
LOG.debug("Created subnet-network mapping for subnet {} network {}", subnetId.getValue(),
networkId.getValue());
} catch (Exception e) {
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void deleteSubnetToNetworkMapping(Uuid subnetId, Uuid networkId) {
try {
InstanceIdentifier networkMapIdentifier = NeutronvpnUtils.buildNetworkMapIdentifier(networkId);
- Optional<NetworkMap> optionalNetworkMap = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- networkMapIdentifier);
+ Optional<NetworkMap> optionalNetworkMap =
+ NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, networkMapIdentifier);
if (optionalNetworkMap.isPresent()) {
NetworkMapBuilder nwMapBuilder = new NetworkMapBuilder(optionalNetworkMap.get());
List<Uuid> subnetIdList = nwMapBuilder.getSubnetIdList();
package org.opendaylight.netvirt.neutronvpn;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.vpnmanager.api.ICentralizedSwitchProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
public class NeutronSubnetGwMacResolver {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSubnetGwMacResolver.class);
private static final long L3_INSTALL_DELAY_MILLIS = 5000;
this.cswitchProvider = cswitchProvider;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void start() {
LOG.info("{} start", getClass().getSimpleName());
}, L3_INSTALL_DELAY_MILLIS, TimeUnit.MILLISECONDS);
}
+ private void sendArpRequestsToExtGateways() {
+ LOG.trace("Sending ARP requests to exteral gateways");
+ for (Router router : NeutronvpnUtils.routerMap.values()) {
+ sendArpRequestsToExtGateways(router);
+ }
+ }
+
private void sendArpRequestsToExtGatewayTask(Router router) {
LOG.trace("Send ARP requests to external GW for router {}", router);
Port extPort = getRouterExtGatewayPort(router);
}
- private void sendArpRequestsToExtGateways() {
- LOG.trace("Sending ARP requests to exteral gateways");
- for (Router router : NeutronvpnUtils.routerMap.values()) {
- sendArpRequestsToExtGateways(router);
- }
- }
-
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void sendArpRequest(IpAddress srcIpAddress, IpAddress dstIpAddress, MacAddress srcMacAddress,
String interfaceName) {
if (srcIpAddress == null || dstIpAddress == null) {
*/
package org.opendaylight.netvirt.neutronvpn;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.getl3vpn.output.L3vpnInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.getl3vpn.output.L3vpnInstancesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfacesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfacesKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.SettableFuture;
-
public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, EventListener {
private static final Logger LOG = LoggerFactory.getLogger(NeutronvpnManager.class);
private final DataBroker dataBroker;
private final NeutronvpnConfig neutronvpnConfig;
private final IMdsalApiManager mdsalUtil;
private final IElanService elanService;
- Boolean isExternalVpn;
- /**
- * @param dataBroker DataBroker reference
- * @param mdsalManager MDSAL Util API access
- * @param notiPublishService notificationPublishService
- * @param vpnNatMgr VPN NAT manager service
- * @param vpnRpcSrv VPN RPC service
- * @param elanService ELAN service
- * @param neutronFloatingToFixedIpMappingChangeListener FIP to FixedIP listener
- * @param neutronvpnConfig Neutronvpn configuration service
- */
public NeutronvpnManager(
final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final NotificationPublishService notiPublishService, final NeutronvpnNatManager vpnNatMgr,
return neutronvpnConfig;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void updateSubnetNodeWithFixedIps(Uuid subnetId, Uuid routerId,
Uuid routerInterfaceName, String fixedIp,
String routerIntfMacAddress) {
Subnetmap subnetmap = null;
SubnetmapBuilder builder = null;
- InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
- child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
+ InstanceIdentifier<Subnetmap> id =
+ InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
try {
synchronized (subnetId.getValue().intern()) {
Optional<Subnetmap> sn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
if (sn.isPresent()) {
builder = new SubnetmapBuilder(sn.get());
- LOG.debug("WithRouterFixedIPs: Updating existing subnetmap node for subnet ID {}", subnetId.getValue());
+ LOG.debug("WithRouterFixedIPs: Updating existing subnetmap node for subnet ID {}",
+ subnetId.getValue());
} else {
builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
- LOG.debug("WithRouterFixedIPs: creating new subnetmap node for subnet ID {}", subnetId.getValue());
+ LOG.debug("WithRouterFixedIPs: creating new subnetmap node for subnet ID {}",
+ subnetId.getValue());
}
builder.setRouterId(routerId);
builder.setRouterInterfaceFixedIps(null);
}
subnetmap = builder.build();
- LOG.debug("WithRouterFixedIPs Creating/Updating subnetMap node for Router FixedIps: {} ", subnetId.getValue());
+ LOG.debug("WithRouterFixedIPs Creating/Updating subnetMap node for Router FixedIps: {} ",
+ subnetId.getValue());
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
}
} catch (Exception e) {
- LOG.error("WithRouterFixedIPs: Updation of subnetMap for Router FixedIps failed for node: {}", subnetId.getValue());
+ LOG.error("WithRouterFixedIPs: Updation of subnetMap for Router FixedIps failed for node: {}",
+ subnetId.getValue());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected Subnetmap updateSubnetNode(Uuid subnetId, String subnetIp, Uuid tenantId, Uuid networkId, Uuid routerId,
Uuid vpnId) {
Subnetmap subnetmap = null;
return subnetmap;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected Subnetmap removeFromSubnetNode(Uuid subnetId, Uuid networkId, Uuid routerId, Uuid vpnId, Uuid portId) {
Subnetmap subnetmap = null;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
return subnetmap;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected Subnetmap updateSubnetmapNodeWithPorts(Uuid subnetId, Uuid portId, Uuid directPortId) {
Subnetmap subnetmap = null;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
return subnetmap;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected Subnetmap removePortsFromSubnetmapNode(Uuid subnetId, Uuid portId, Uuid directPortId) {
Subnetmap subnetmap = null;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
return subnetmap;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void deleteSubnetMapNode(Uuid subnetId) {
InstanceIdentifier<Subnetmap> subnetMapIdentifier =
InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,new SubnetmapKey(subnetId)).build();
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void updateVpnInstanceNode(String vpnName, List<String> rd, List<String> irt, List<String> ert) {
VpnInstanceBuilder builder = null;
List<VpnTarget> vpnTargetList = new ArrayList<>();
boolean isLockAcquired = false;
- InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).child
- (VpnInstance.class, new VpnInstanceKey(vpnName)).build();
+ InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class)
+ .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
try {
Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnIdentifier);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void deleteVpnMapsNode(Uuid vpnid) {
boolean isLockAcquired = false;
InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void updateVpnMaps(Uuid vpnId, String name, Uuid router, Uuid tenantId, List<Uuid> networks) {
VpnMapBuilder builder;
boolean isLockAcquired = false;
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void clearFromVpnMaps(Uuid vpnId, Uuid routerId, List<Uuid> networkIds) {
boolean isLockAcquired = false;
InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
LOG.debug("Clear from VPNMaps DS successful for VPN {} ", vpnId.getValue());
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void deleteVpnInstance(Uuid vpnId) {
boolean isLockAcquired = false;
InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class)
WriteTransaction wrtConfigTxn) {
String infName = port.getUuid().getValue();
List<Adjacency> adjList = new ArrayList<>();
- List<FixedIps> ips = port.getFixedIps();
Boolean isRouterInterface = false;
if (port.getDeviceOwner() != null) {
isRouterInterface = port.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF);
if (routerId != null) {
rtr = NeutronvpnUtils.getNeutronRouter(dataBroker, routerId);
}
+ List<FixedIps> ips = port.getFixedIps();
// create adjacency list
for (FixedIps ip : ips) {
// create vm adjacency
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void deleteVpnInterface(Uuid vpnId, Uuid routerId, Port port, WriteTransaction wrtConfigTxn) {
Boolean wrtConfigTxnPresent = true;
if (wrtConfigTxn == null) {
}
}
- protected void updateVpnInterface(Uuid vpnId, Uuid oldVpnId, Port port, boolean isBeingAssociated, boolean isSubnetIp) {
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ protected void updateVpnInterface(Uuid vpnId, Uuid oldVpnId, Port port, boolean isBeingAssociated,
+ boolean isSubnetIp) {
if (vpnId == null || port == null) {
return;
}
while (adjacencyIter.hasNext()) {
Adjacency adjacency = adjacencyIter.next();
String mipToQuery = adjacency.getIpAddress().split("/")[0];
- InstanceIdentifier<LearntVpnVipToPort> id = NeutronvpnUtils.buildLearntVpnVipToPortIdentifier
- (oldVpnId.getValue(), mipToQuery);
- Optional<LearntVpnVipToPort> optionalVpnVipToPort = NeutronvpnUtils.read(dataBroker,
- LogicalDatastoreType
- .OPERATIONAL, id);
+ InstanceIdentifier<LearntVpnVipToPort> id =
+ NeutronvpnUtils.buildLearntVpnVipToPortIdentifier(oldVpnId.getValue(), mipToQuery);
+ Optional<LearntVpnVipToPort> optionalVpnVipToPort =
+ NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if (optionalVpnVipToPort.isPresent()) {
- LOG.trace("Removing adjacencies from vpninterface {} upon dissociation of router {} " +
- "from VPN " + "{}", infName, vpnId, oldVpnId);
+ LOG.trace("Removing adjacencies from vpninterface {} upon dissociation of router {} "
+ + "from VPN " + "{}", infName, vpnId, oldVpnId);
adjacencyIter.remove();
NeutronvpnUtils.removeLearntVpnVipToPort(dataBroker, oldVpnId.getValue(), mipToQuery);
- LOG.trace("Entry for fixedIP {} for port {} on VPN removed from " +
- "VpnPortFixedIPToPortData", mipToQuery, infName, vpnId.getValue());
+ LOG.trace("Entry for fixedIP {} for port {} on VPN removed from "
+ + "VpnPortFixedIPToPortData", mipToQuery, infName, vpnId.getValue());
}
}
Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(adjacencyList).build();
// preserved upon reboot.
// For a non-reboot case #associateRouterToInternalVPN already takes care of adding to
// RouterInterfacesMap via #createVPNInterface call.
- LOG.info("Associating router to Internal VPN skipped for VPN {} due to router {} already associated " +
- "to external VPN {}", vpn.getValue(), router.getValue(), existingVpn.getValue());
+ LOG.info("Associating router to Internal VPN skipped for VPN {} due to router {} already associated "
+ + "to external VPN {}", vpn.getValue(), router.getValue(), existingVpn.getValue());
return;
}
associateRouterToInternalVpn(vpn, router);
/**
* Performs the creation of a Neutron L3VPN, associating the new VPN to the
- * specified Neutron Networks and Routers
+ * specified Neutron Networks and Routers.
*
* @param vpn Uuid of the VPN tp be created
* @param name Representative name of the new VPN
}
/**
- * It handles the invocations to the createL3VPN RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService#createL3VPN
- * (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateL3VPNInput)
+ * It handles the invocations to the createL3VPN RPC method.
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
CreateL3VPNOutputBuilder opBuilder = new CreateL3VPNOutputBuilder();
continue;
}
if (existingRDs.contains(vpn.getRouteDistinguisher().get(0))) {
- msg = String.format("Creation of L3VPN failed for VPN %s as another VPN with the same RD %s is already configured",
- vpn.getId().getValue(), vpn.getRouteDistinguisher().get(0));
+ msg = String.format("Creation of L3VPN failed for VPN %s as another VPN with the same RD %s "
+ + "is already configured",
+ vpn.getId().getValue(), vpn.getRouteDistinguisher().get(0));
LOG.warn(msg);
error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
errorList.add(error);
// if at least one succeeds; result is success
// if none succeeds; result is failure
if (failurecount + warningcount == vpns.size()) {
- result.set(RpcResultBuilder.<CreateL3VPNOutput> failed().withRpcErrors(errorList).build());
+ result.set(RpcResultBuilder.<CreateL3VPNOutput>failed().withRpcErrors(errorList).build());
} else {
List<String> errorResponseList = new ArrayList<>();
if (!errorList.isEmpty()) {
errorResponseList.add("Operation successful with no errors");
}
opBuilder.setResponse(errorResponseList);
- result.set(RpcResultBuilder.<CreateL3VPNOutput> success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.<CreateL3VPNOutput>success().withResult(opBuilder.build()).build());
}
return result;
}
/**
- * It handles the invocations to the neutronvpn:getL3VPN RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService#getL3VPN
- * (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetL3VPNInput)
+ * It handles the invocations to the neutronvpn:getL3VPN RPC method.
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
GetL3VPNOutputBuilder opBuilder = new GetL3VPNOutputBuilder();
}
} else {
// No VPN present
- result.set(RpcResultBuilder.<GetL3VPNOutput> success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
return result;
}
} else {
}
opBuilder.setL3vpnInstances(l3vpnList);
- result.set(RpcResultBuilder.<GetL3VPNOutput> success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
} catch (Exception ex) {
String message = String.format("GetL3VPN failed due to %s", ex.getMessage());
LOG.error(message, ex);
- result.set(RpcResultBuilder.<GetL3VPNOutput> failed().withError(ErrorType.APPLICATION, message).build());
+ result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, message).build());
}
return result;
}
/**
- * It handles the invocations to the neutronvpn:deleteL3VPN RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService#deleteL3VPN
- * (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteL3VPNInput)
+ * It handles the invocations to the neutronvpn:deleteL3VPN RPC method.
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<DeleteL3VPNOutput>> deleteL3VPN(DeleteL3VPNInput input) {
DeleteL3VPNOutputBuilder opBuilder = new DeleteL3VPNOutputBuilder();
String msg;
try {
InstanceIdentifier<VpnInstance> vpnIdentifier =
- InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey
- (vpn.getValue())).build();
+ InstanceIdentifier.builder(VpnInstances.class)
+ .child(VpnInstance.class, new VpnInstanceKey(vpn.getValue())).build();
Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
.CONFIGURATION, vpnIdentifier);
if (optionalVpn.isPresent()) {
// if at least one succeeds; result is success
// if none succeeds; result is failure
if (failurecount + warningcount == vpns.size()) {
- result.set(RpcResultBuilder.<DeleteL3VPNOutput> failed().withRpcErrors(errorList).build());
+ result.set(RpcResultBuilder.<DeleteL3VPNOutput>failed().withRpcErrors(errorList).build());
} else {
List<String> errorResponseList = new ArrayList<>();
if (!errorList.isEmpty()) {
errorResponseList.add("Operation successful with no errors");
}
opBuilder.setResponse(errorResponseList);
- result.set(RpcResultBuilder.<DeleteL3VPNOutput> success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.<DeleteL3VPNOutput>success().withResult(opBuilder.build()).build());
}
return result;
}
LOG.debug("Updating VPN {} for subnet {}", vpnId.getValue(), subnet.getValue());
// Read the subnet first to see if its already associated to a VPN
Uuid oldVpnId = null;
- InstanceIdentifier<Subnetmap> snId = InstanceIdentifier.builder(Subnetmaps.class).
- child(Subnetmap.class, new SubnetmapKey(subnet)).build();
+ InstanceIdentifier<Subnetmap> snId = InstanceIdentifier.builder(Subnetmaps.class)
+ .child(Subnetmap.class, new SubnetmapKey(subnet)).build();
Subnetmap sn = null;
Optional<Subnetmap> optSn = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, snId);
if (optSn.isPresent()) {
List<String> ips = sn.getRouterInterfaceFixedIps();
for (String ipValue : ips) {
// Update the association of router-interface to external vpn
- String PortName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, oldVpnId.getValue(), ipValue);
- updateVpnInterface(vpnId, oldVpnId, NeutronvpnUtils.getNeutronPort(dataBroker, new Uuid(PortName)),
+ String portName =
+ NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, oldVpnId.getValue(), ipValue);
+ if (portName != null) {
+ updateVpnInterface(vpnId, oldVpnId,
+ NeutronvpnUtils.getNeutronPort(dataBroker, new Uuid(portName)),
isBeingAssociated, true);
+ }
}
}
sn = updateSubnetNode(subnet, null, null, null, null, vpnId);
List<Uuid> portList = sn.getPortList();
if (portList != null) {
for (Uuid port : sn.getPortList()) {
- LOG.debug("Updating vpn-interface for port {} isBeingAssociated {}", port.getValue(), isBeingAssociated);
+ LOG.debug("Updating vpn-interface for port {} isBeingAssociated {}",
+ port.getValue(), isBeingAssociated);
updateVpnInterface(vpnId, oldVpnId, NeutronvpnUtils.getNeutronPort(dataBroker, port),
isBeingAssociated, false);
}
InstanceIdentifier<RouterInterfaces> routerInterfacesId = getRouterInterfacesId(routerId);
Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
.CONFIGURATION, routerInterfacesId);
- Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId
- (interfaceName).build();
+ Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName))
+ .setInterfaceId(interfaceName).build();
if (optRouterInterfaces.isPresent()) {
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces
.class, new InterfacesKey(interfaceName)), routerInterface);
InstanceIdentifier<RouterInterfaces> routerInterfacesId = getRouterInterfacesId(routerId);
Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
.CONFIGURATION, routerInterfacesId);
- Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId
- (interfaceName).build();
+ Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName))
+ .setInterfaceId(interfaceName).build();
if (optRouterInterfaces.isPresent()) {
RouterInterfaces routerInterfaces = optRouterInterfaces.get();
List<Interfaces> interfaces = routerInterfaces.getInterfaces();
}
for (String destination : adjMap.keySet()) {
- Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIpList(adjMap.get
- (destination)).setKey(new AdjacencyKey(destination)).build();
+ Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination)
+ .setNextHopIpList(adjMap.get(destination)).setKey(new AdjacencyKey(destination)).build();
adjList.add(erAdj);
}
return adjList;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void updateVpnInterfaceWithExtraRouteAdjacency(Uuid vpnId, List<Routes> routeList) {
for (Routes route : routeList) {
if (route == null || route.getNexthop() == null || route.getDestination() == null) {
String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(),
nextHop);
if (infName != null) {
- LOG.trace("Updating extra route for destination {} onto vpn {} with nexthop {} and infName {}", destination,
- vpnId.getValue(), nextHop, infName);
+ LOG.trace("Updating extra route for destination {} onto vpn {} with nexthop {} and infName {}",
+ destination, vpnId.getValue(), nextHop, infName);
boolean isLockAcquired = false;
try {
InstanceIdentifier<VpnInterface> identifier = InstanceIdentifier.builder(VpnInterfaces.class)
.child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
- InstanceIdentifier<Adjacency> path = identifier.augmentation(Adjacencies.class).
- child(Adjacency.class, new AdjacencyKey(destination));
- Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIpList(Arrays.asList(nextHop)).
- setKey(new AdjacencyKey(destination)).build();
+ InstanceIdentifier<Adjacency> path = identifier.augmentation(Adjacencies.class)
+ .child(Adjacency.class, new AdjacencyKey(destination));
+ Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination)
+ .setNextHopIpList(Arrays.asList(nextHop)).setKey(new AdjacencyKey(destination)).build();
isLockAcquired = NeutronvpnUtils.lock(infName);
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, path, erAdj);
} catch (Exception e) {
- LOG.error("exception in adding extra route with destination: {}, next hop: {}", destination, nextHop, e);
+ LOG.error("exception in adding extra route with destination: {}, next hop: {}",
+ destination, nextHop, e);
} finally {
if (isLockAcquired) {
NeutronvpnUtils.unlock(infName);
}
}
} else {
- LOG.debug("Unable to find VPN NextHop interface to apply extra-route destination {} on VPN {} " +
- "with nexthop {}", destination, vpnId.getValue(), nextHop);
+ LOG.debug("Unable to find VPN NextHop interface to apply extra-route destination {} on VPN {} "
+ + "with nexthop {}", destination, vpnId.getValue(), nextHop);
}
}
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void removeAdjacencyforExtraRoute(Uuid vpnId, List<Routes> routeList) {
for (Routes route : routeList) {
if (route != null && route.getNexthop() != null && route.getDestination() != null) {
String infName = NeutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(dataBroker, vpnId.getValue(),
nextHop);
if (infName == null) {
- LOG.error("Unable to find VPN NextHop interface to remove extra-route destination {} on VPN {} " +
- "with nexthop {}",
- destination, vpnId.getValue(), nextHop);
+ LOG.error("Unable to find VPN NextHop interface to remove extra-route destination {} on VPN {} "
+ + "with nexthop {}", destination, vpnId.getValue(), nextHop);
// Proceed to remove the next extra-route
continue;
}
if (port != null) {
deleteVpnInterface(vpnId, routerId, port, wrtConfigTxn);
} else {
- LOG.error("Cannot proceed with deleteVpnInterface for port {} in subnet {} since port is " +
- "absent in Neutron config DS", portId.getValue(), subnet.getValue());
+ LOG.error("Cannot proceed with deleteVpnInterface for port {} in subnet {} since port is "
+ + "absent in Neutron config DS", portId.getValue(), subnet.getValue());
}
futures.add(wrtConfigTxn.submit());
return futures;
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void associateRouterToVpn(Uuid vpnId, Uuid routerId) {
updateVpnMaps(vpnId, null, routerId, null, null);
LOG.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void dissociateRouterFromVpn(Uuid vpnId, Uuid routerId) {
List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(dataBroker, routerId);
addSubnetToVpn(vpn, subnet);
passedNwList.add(nw);
} else {
- failedNwList.add(String.format("subnet %s already added as router interface bound to " +
- "internal/external VPN %s", subnet.getValue (), subnetVpnId.getValue()));
+ failedNwList.add(String.format("subnet %s already added as router interface bound to "
+ + "internal/external VPN %s", subnet.getValue(), subnetVpnId.getValue()));
}
}
}
failedNwList.add(String.format("input network %s not associated to any vpn yet", nw
.getValue()));
} else {
- failedNwList.add(String.format("input network %s associated to a another vpn %s instead " +
- "of the one given as input", nw.getValue(), vpnId.getValue()));
+ failedNwList.add(String.format("input network %s associated to a another vpn %s instead "
+ + "of the one given as input", nw.getValue(), vpnId.getValue()));
}
}
if (NeutronvpnUtils.getIsExternal(network)) {
}
/**
- * It handles the invocations to the neutronvpn:associateNetworks RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService#associateNetworks
- * (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksInput)
+ * It handles the invocations to the neutronvpn:associateNetworks RPC method.
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<AssociateNetworksOutput>> associateNetworks(AssociateNetworksInput input) {
AssociateNetworksOutputBuilder opBuilder = new AssociateNetworksOutputBuilder();
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: %s",
message);
opBuilder.setResponse(errorResponse);
- result.set(RpcResultBuilder.<AssociateNetworksOutput> success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.<AssociateNetworksOutput>success().withResult(opBuilder.build()).build());
} else {
- result.set(RpcResultBuilder.<AssociateNetworksOutput> success().build());
+ result.set(RpcResultBuilder.<AssociateNetworksOutput>success().build());
}
} catch (Exception ex) {
String message = String.format("associate Networks to vpn %s failed due to %s",
input.getVpnId().getValue(), ex.getMessage());
LOG.error(message, ex);
- result.set(RpcResultBuilder.<AssociateNetworksOutput> failed().withError(ErrorType.APPLICATION, message)
+ result.set(RpcResultBuilder.<AssociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
.build());
}
LOG.debug("associateNetworks returns..");
}
/**
- * It handles the invocations to the neutronvpn:associateRouter RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService#associateRouter
- * (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateRouterInput)
+ * It handles the invocations to the neutronvpn:associateRouter RPC method.
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<Void>> associateRouter(AssociateRouterInput input) {
SettableFuture<RpcResult<Void>> result = SettableFuture.create();
returnMsg.append("vpn ").append(vpnId.getValue()).append(" already associated to router ")
.append(vpnMap.getRouterId().getValue());
} else if (extVpnId != null) {
- returnMsg.append("router ").append(routerId.getValue()).append(" already associated to " +
- "another VPN ").append(extVpnId.getValue());
+ returnMsg.append("router ").append(routerId.getValue()).append(" already associated to "
+ + "another VPN ").append(extVpnId.getValue());
} else {
associateRouterToVpn(vpnId, routerId);
}
String message = String.format("associate router to vpn %s failed due to %s", routerId.getValue(),
returnMsg);
LOG.error(message);
- result.set(RpcResultBuilder.<Void> failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
+ result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
.build());
} else {
- result.set(RpcResultBuilder.<Void> success().build());
+ result.set(RpcResultBuilder.<Void>success().build());
}
} catch (Exception ex) {
String message = String.format("associate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), ex.getMessage());
LOG.error(message, ex);
- result.set(RpcResultBuilder.<Void> failed().withError(ErrorType.APPLICATION, message).build());
+ result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
}
LOG.debug("associateRouter returns..");
return result;
}
- /** It handles the invocations to the neutronvpn:getFixedIPsForNeutronPort RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService#getFixedIPsForNeutronPort
- * (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetFixedIPsForNeutronPortInput)
+ /** It handles the invocations to the neutronvpn:getFixedIPsForNeutronPort RPC method.
*/
@Override
- public Future<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(GetFixedIPsForNeutronPortInput input) {
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public Future<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(
+ GetFixedIPsForNeutronPortInput input) {
GetFixedIPsForNeutronPortOutputBuilder opBuilder = new GetFixedIPsForNeutronPortOutputBuilder();
SettableFuture<RpcResult<GetFixedIPsForNeutronPortOutput>> result = SettableFuture.create();
Uuid portId = input.getPortId();
if (returnMsg.length() != 0) {
String message = String.format("Retrieval of FixedIPList for neutron port failed due to %s", returnMsg);
LOG.error(message);
- result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput> failed()
+ result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed()
.withWarning(ErrorType.PROTOCOL, "invalid-value", message).build());
} else {
opBuilder.setFixedIPs(fixedIPList);
- result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput> success().withResult(opBuilder.build())
+ result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().withResult(opBuilder.build())
.build());
- result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput> success().build());
+ result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().build());
}
} catch (Exception ex) {
String message = String.format("Retrieval of FixedIPList for neutron port %s failed due to %s",
portId.getValue(), ex.getMessage());
LOG.error(message, ex);
- result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput> failed()
+ result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed()
.withError(ErrorType.APPLICATION, message).build());
}
return result;
}
/**
- * It handles the invocations to the neutronvpn:dissociateNetworks RPC method
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn
- * .rev150602.NeutronvpnService#dissociateNetworks(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt
- * .neutronvpn.rev150602.DissociateNetworksInput)
+ * It handles the invocations to the neutronvpn:dissociateNetworks RPC method.
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<DissociateNetworksOutput>> dissociateNetworks(DissociateNetworksInput input) {
DissociateNetworksOutputBuilder opBuilder = new DissociateNetworksOutputBuilder();
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: "
+ message);
opBuilder.setResponse(errorResponse);
- result.set(RpcResultBuilder.<DissociateNetworksOutput> success().withResult(opBuilder.build()).build());
+ result.set(RpcResultBuilder.<DissociateNetworksOutput>success().withResult(opBuilder.build()).build());
} else {
- result.set(RpcResultBuilder.<DissociateNetworksOutput> success().build());
+ result.set(RpcResultBuilder.<DissociateNetworksOutput>success().build());
}
} catch (Exception ex) {
String message = String.format("dissociate Networks to vpn %s failed due to %s",
input.getVpnId().getValue(), ex.getMessage());
LOG.error(message, ex);
- result.set(RpcResultBuilder.<DissociateNetworksOutput> failed().withError(ErrorType.APPLICATION, message)
+ result.set(RpcResultBuilder.<DissociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
.build());
}
LOG.debug("dissociateNetworks returns..");
/**
* It handles the invocations to the neutronvpn:dissociateRouter RPC method.
- *
- * @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn
- * .rev150602.NeutronvpnService#dissociateRouter(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn
- * .rev150602.DissociateRouterInput)
*/
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Future<RpcResult<Void>> dissociateRouter(DissociateRouterInput input) {
SettableFuture<RpcResult<Void>> result = SettableFuture.create();
dissociateRouterFromVpn(vpnId, routerId);
} else {
if (routerVpnId == null) {
- returnMsg.append("input router ").append(routerId.getValue()).append(" not associated" +
- " to any vpn yet");
+ returnMsg.append("input router ").append(routerId.getValue())
+ .append(" not associated to any vpn yet");
} else {
- returnMsg.append("input router ").append(routerId.getValue()).append(" associated to " +
- "vpn ").append(routerVpnId.getValue()).append("instead of the vpn given as " +
- "input");
+ returnMsg.append("input router ").append(routerId.getValue())
+ .append(" associated to vpn ")
+ .append(routerVpnId.getValue()).append("instead of the vpn given as input");
}
}
} else {
LOG.error(message);
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: "
+ message);
- result.set(RpcResultBuilder.<Void> failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
+ result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
.build());
} else {
- result.set(RpcResultBuilder.<Void> success().build());
+ result.set(RpcResultBuilder.<Void>success().build());
}
} catch (Exception ex) {
String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), ex.getMessage());
LOG.error(message, ex);
- result.set(RpcResultBuilder.<Void> failed().withError(ErrorType.APPLICATION, message).build());
+ result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
}
LOG.debug("dissociateRouter returns..");
deleteVpnInstance(routerId);
}
- protected Subnet getNeutronSubnet(Uuid subnetId){
+ protected Subnet getNeutronSubnet(Uuid subnetId) {
return NeutronvpnUtils.getNeutronSubnet(dataBroker, subnetId);
}
}
/**
- * Implementation of the "vpnservice:neutron-ports-show" Karaf CLI command
+ * Implementation of the "vpnservice:neutron-ports-show" Karaf CLI command.
*
* @return a List of String to be printed on screen
*/
+ // TODO Clean up the exception handling and the console output
+ @SuppressWarnings({"checkstyle:IllegalCatch", "checkstyle:RegexpSinglelineJava"})
public List<String> showNeutronPortsCLI() {
List<String> result = new ArrayList<>();
- result.add(String.format(" %-36s %-19s %-13s %-20s ", "Port ID", "Mac Address", "Prefix Length", "IP " +
- "Address"));
+ result.add(String.format(" %-36s %-19s %-13s %-20s ", "Port ID", "Mac Address", "Prefix Length",
+ "IP Address"));
result.add("-------------------------------------------------------------------------------------------");
InstanceIdentifier<Ports> portidentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
try {
- Optional<Ports> ports = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, portidentifier);
+ Optional<Ports> ports =
+ NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, portidentifier);
if (ports.isPresent() && ports.get().getPort() != null) {
for (Port port : ports.get().getPort()) {
List<FixedIps> fixedIPs = port.getFixedIps();
}
/**
- * Implementation of the "vpnservice:l3vpn-config-show" karaf CLI command
+ * Implementation of the "vpnservice:l3vpn-config-show" karaf CLI command.
*
* @param vpnuuid Uuid of the VPN whose config must be shown
* @return formatted output list
*/
+ @SuppressWarnings("checkstyle:RegexpSinglelineJava")
public List<String> showVpnConfigCLI(Uuid vpnuuid) {
List<String> result = new ArrayList<>();
if (vpnuuid == null) {
result.add("");
result.add("------------------------------------------------------------------------------------");
result.add("");
- List<L3vpnInstances> VpnList = rpcResult.getResult().getL3vpnInstances();
- for (L3vpnInstance Vpn : VpnList) {
- String tenantId = Vpn.getTenantId() != null ? Vpn.getTenantId().getValue()
+ List<L3vpnInstances> vpnList = rpcResult.getResult().getL3vpnInstances();
+ for (L3vpnInstance vpn : vpnList) {
+ String tenantId = vpn.getTenantId() != null ? vpn.getTenantId().getValue()
: "\" " + " \"";
- result.add(String.format(" %-37s %-37s %-7s ", Vpn.getId().getValue(), tenantId,
- Vpn.getRouteDistinguisher()));
+ result.add(String.format(" %-37s %-37s %-7s ", vpn.getId().getValue(), tenantId,
+ vpn.getRouteDistinguisher()));
result.add("");
- result.add(String.format(" %-80s ", Vpn.getImportRT()));
+ result.add(String.format(" %-80s ", vpn.getImportRT()));
result.add("");
- result.add(String.format(" %-80s ", Vpn.getExportRT()));
+ result.add(String.format(" %-80s ", vpn.getExportRT()));
result.add("");
- Uuid vpnid = Vpn.getId();
+ Uuid vpnid = vpn.getId();
List<Uuid> subnetList = getSubnetsforVpn(vpnid);
if (!subnetList.isEmpty()) {
for (Uuid subnetuuid : subnetList) {
wrtConfigTxn.submit();
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected void removeExternalVpnInterfaces(Uuid extNetId) {
Collection<String> extElanInterfaces = elanService.getExternalElanInterfaces(extNetId.getValue());
if (extElanInterfaces == null || extElanInterfaces.isEmpty()) {
writeVpnInterfaceToDs(vpnId, infName, null, false /* not a router iface */, wrtConfigTxn);
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void writeVpnInterfaceToDs(Uuid vpnId, String infName, Adjacencies adjacencies,
Boolean isRouterInterface, WriteTransaction wrtConfigTxn) {
if (vpnId == null || infName == null) {
private void checkAndPublishRouterDisassociatedFromVpnNotification(Uuid routerId, Uuid vpnId) throws
InterruptedException {
- RouterDisassociatedFromVpn routerDisassociatedFromVpn = new RouterDisassociatedFromVpnBuilder().setRouterId
- (routerId).setVpnId(vpnId).build();
+ RouterDisassociatedFromVpn routerDisassociatedFromVpn =
+ new RouterDisassociatedFromVpnBuilder().setRouterId(routerId).setVpnId(vpnId).build();
LOG.info("publishing notification upon disassociation of router from VPN");
notificationPublishService.putNotification(routerDisassociatedFromVpn);
}
*/
package org.opendaylight.netvirt.neutronvpn;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
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.netvirt.natservice.rev160111.ExternalNetworks;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.ExternalGatewayInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class NeutronvpnNatManager implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(NeutronvpnNatManager.class);
private final DataBroker dataBroker;
private static final int EXTERNAL_REMOVED = 2;
private static final int EXTERNAL_CHANGED = 3;
- /**
- * @param dataBroker - dataBroker reference
- */
public NeutronvpnNatManager(final DataBroker dataBroker) {
this.dataBroker = dataBroker;
}
Uuid updExtNetId = null;
LOG.trace("handleExternalNetwork for router " + routerId);
- int ext_net_changed = externalNetworkChanged(original, update);
- if (ext_net_changed != EXTERNAL_NO_CHANGE) {
- if (ext_net_changed == EXTERNAL_ADDED) {
+ int extNetChanged = externalNetworkChanged(original, update);
+ if (extNetChanged != EXTERNAL_NO_CHANGE) {
+ if (extNetChanged == EXTERNAL_ADDED) {
updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
- LOG.trace("External Network " + updExtNetId.getValue() +
- " addition detected for router " + routerId.getValue());
+ LOG.trace("External Network " + updExtNetId.getValue()
+ + " addition detected for router " + routerId.getValue());
addExternalNetworkToRouter(update);
return;
}
- if (ext_net_changed == EXTERNAL_REMOVED) {
+ if (extNetChanged == EXTERNAL_REMOVED) {
origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
- LOG.trace("External Network removal detected " +
- "for router " + routerId.getValue());
+ LOG.trace("External Network removal detected for router {}", routerId.getValue());
removeExternalNetworkFromRouter(origExtNetId, update);
//gateway mac unset handled as part of gateway clear deleting top-level routers node
return;
}
origExtNetId = original.getExternalGatewayInfo().getExternalNetworkId();
updExtNetId = update.getExternalGatewayInfo().getExternalNetworkId();
- LOG.trace("External Network changed from "+ origExtNetId.getValue() + " to "
- + updExtNetId.getValue() + " for router " + routerId.getValue());
+ LOG.trace("External Network changed from {} to {} for router {}",
+ origExtNetId.getValue(), updExtNetId.getValue(), routerId.getValue());
removeExternalNetworkFromRouter(origExtNetId, update);
addExternalNetworkToRouter(update);
return;
}
if (snatSettingChanged(original, update)) {
- LOG.trace("SNAT settings on gateway changed " +
- "for router " + routerId.getValue());
+ LOG.trace("SNAT settings on gateway changed for router {}", routerId.getValue());
handleSnatSettingChangeForRouter(update, dataBroker);
}
if (externalFixedIpsChanged(original, update)) {
- LOG.trace("External Fixed IPs changed " +
- "for router " + routerId.getValue());
+ LOG.trace("External Fixed IPs changed for router {}", routerId.getValue());
handleExternalFixedIpsForRouter(update, dataBroker);
}
}
private int externalNetworkChanged(Router original, Router update) {
- String orig_ext_net = null;
- String new_ext_net = null;
+ String origExtNet = null;
+ String newExtNet = null;
if (original != null && original.getExternalGatewayInfo() != null) {
- orig_ext_net = original.getExternalGatewayInfo().getExternalNetworkId().getValue();
+ origExtNet = original.getExternalGatewayInfo().getExternalNetworkId().getValue();
}
if (update != null && update.getExternalGatewayInfo() != null) {
- new_ext_net = update.getExternalGatewayInfo().getExternalNetworkId().getValue();
+ newExtNet = update.getExternalGatewayInfo().getExternalNetworkId().getValue();
}
- if (orig_ext_net == null) {
- if (new_ext_net == null) {
+ if (origExtNet == null) {
+ if (newExtNet == null) {
return EXTERNAL_NO_CHANGE;
}
return EXTERNAL_ADDED;
} else {
- if (new_ext_net == null) {
+ if (newExtNet == null) {
return EXTERNAL_REMOVED;
}
- if (!orig_ext_net.equals(new_ext_net)) {
+ if (!origExtNet.equals(newExtNet)) {
return EXTERNAL_CHANGED;
}
return EXTERNAL_NO_CHANGE;
}
private boolean snatSettingChanged(Router orig, Router update) {
- ExternalGatewayInfo orig_ext_gw = null;
- ExternalGatewayInfo new_ext_gw = null;
+ ExternalGatewayInfo origExtGw = null;
+ ExternalGatewayInfo newExtGw = null;
if (orig != null && orig.getExternalGatewayInfo() != null) {
- orig_ext_gw = orig.getExternalGatewayInfo();
+ origExtGw = orig.getExternalGatewayInfo();
}
if (update != null && update.getExternalGatewayInfo() != null) {
- new_ext_gw = update.getExternalGatewayInfo();
+ newExtGw = update.getExternalGatewayInfo();
}
- if (orig_ext_gw == null) {
- if (new_ext_gw != null) {
+ if (origExtGw == null) {
+ if (newExtGw != null) {
return true;
}
- } else if (new_ext_gw == null || orig_ext_gw.isEnableSnat() != new_ext_gw.isEnableSnat()) {
+ } else if (newExtGw == null || origExtGw.isEnableSnat() != newExtGw.isEnableSnat()) {
return true;
}
return false;
}
private boolean externalFixedIpsChanged(Router orig, Router update) {
- ExternalGatewayInfo orig_ext_gw = null;
- ExternalGatewayInfo new_ext_gw = null;
+ ExternalGatewayInfo origExtGw = null;
+ ExternalGatewayInfo newExtGw = null;
if (orig != null && orig.getExternalGatewayInfo() != null) {
- orig_ext_gw = orig.getExternalGatewayInfo();
+ origExtGw = orig.getExternalGatewayInfo();
}
if (update != null && update.getExternalGatewayInfo() != null) {
- new_ext_gw = update.getExternalGatewayInfo();
+ newExtGw = update.getExternalGatewayInfo();
}
- if (orig_ext_gw == null && new_ext_gw != null && new_ext_gw.getExternalFixedIps() != null && !new_ext_gw
+ if (origExtGw == null && newExtGw != null && newExtGw.getExternalFixedIps() != null && !newExtGw
.getExternalFixedIps().isEmpty()) {
return true;
}
- if (new_ext_gw == null && orig_ext_gw != null && orig_ext_gw.getExternalFixedIps() != null && !orig_ext_gw
+ if (newExtGw == null && origExtGw != null && origExtGw.getExternalFixedIps() != null && !origExtGw
.getExternalFixedIps().isEmpty()) {
return true;
}
- if (orig_ext_gw != null && new_ext_gw != null) {
- if (orig_ext_gw.getExternalFixedIps() != null) {
- if (!orig_ext_gw.getExternalFixedIps().isEmpty()) {
- if (new_ext_gw.getExternalFixedIps() != null && !new_ext_gw.getExternalFixedIps().isEmpty()) {
- List<ExternalFixedIps> orig_ext_fixed_ips = orig_ext_gw.getExternalFixedIps();
- HashSet<String> orig_fixed_ip_set = new HashSet<String>();
- for (ExternalFixedIps fixed_ip : orig_ext_fixed_ips) {
- orig_fixed_ip_set.add(fixed_ip.getIpAddress().getIpv4Address().getValue());
+ if (origExtGw != null && newExtGw != null) {
+ if (origExtGw.getExternalFixedIps() != null) {
+ if (!origExtGw.getExternalFixedIps().isEmpty()) {
+ if (newExtGw.getExternalFixedIps() != null && !newExtGw.getExternalFixedIps().isEmpty()) {
+ List<ExternalFixedIps> origExtFixedIps = origExtGw.getExternalFixedIps();
+ HashSet<String> origFixedIpSet = new HashSet<String>();
+ for (ExternalFixedIps fixedIps : origExtFixedIps) {
+ origFixedIpSet.add(fixedIps.getIpAddress().getIpv4Address().getValue());
}
- List<ExternalFixedIps> new_ext_fixed_ips = new_ext_gw.getExternalFixedIps();
- HashSet<String> upd_fixed_ip_set = new HashSet<String>();
- for (ExternalFixedIps fixed_ip : new_ext_fixed_ips) {
- upd_fixed_ip_set.add(fixed_ip.getIpAddress().getIpv4Address().getValue());
+ List<ExternalFixedIps> newExtFixedIps = newExtGw.getExternalFixedIps();
+ HashSet<String> updFixedIpSet = new HashSet<String>();
+ for (ExternalFixedIps fixedIps : newExtFixedIps) {
+ updFixedIpSet.add(fixedIps.getIpAddress().getIpv4Address().getValue());
}
// returns true if external subnets have changed
- return (!orig_fixed_ip_set.equals(upd_fixed_ip_set)) ? true : false;
+ return (!origFixedIpSet.equals(updFixedIpSet)) ? true : false;
}
return true;
- } else if (new_ext_gw.getExternalFixedIps() != null && !new_ext_gw.getExternalFixedIps().isEmpty()){
+ } else if (newExtGw.getExternalFixedIps() != null && !newExtGw.getExternalFixedIps().isEmpty()) {
return true;
}
- } else if (new_ext_gw.getExternalFixedIps() != null && !new_ext_gw.getExternalFixedIps().isEmpty()) {
+ } else if (newExtGw.getExternalFixedIps() != null && !newExtGw.getExternalFixedIps().isEmpty()) {
return true;
}
}
return false;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void addExternalNetwork(Network net) {
Uuid extNetId = net.getUuid();
// Create and add Networks object for this External Network to the ExternalNetworks list
- InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
- child(Networks.class, new NetworksKey(extNetId)).build();
+ InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
+ .child(Networks.class, new NetworksKey(extNetId)).build();
try {
LOG.trace(" Creating/Updating a new Networks node: " + extNetId.getValue());
LogicalDatastoreType.CONFIGURATION,
netsIdentifier);
if (optionalNets.isPresent()) {
- LOG.error("External Network " + extNetId.getValue() +
- " already detected to be present");
+ LOG.error("External Network {} already detected to be present", extNetId.getValue());
return;
}
ProviderTypes provType = NeutronvpnUtils.getProviderNetworkType(net);
- if (provType == null){
- LOG.error("Unable to get Network Provider Type for network {}",net.getUuid());
+ if (provType == null) {
+ LOG.error("Unable to get Network Provider Type for network {}", net.getUuid());
return;
}
NetworksBuilder builder = null;
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
LOG.trace("Wrote externalnetwork successfully to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Creation of External Network " +
- extNetId.getValue() + " failed " + ex.getMessage());
+ LOG.error("Creation of External Network {} failed: {}", extNetId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void removeExternalNetwork(Network net) {
Uuid extNetId = net.getUuid();
// Create and add Networks object for this External Network to the ExternalNetworks list
- InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
- child(Networks.class, new NetworksKey(extNetId)).build();
+ InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
+ .child(Networks.class, new NetworksKey(extNetId)).build();
try {
Optional<Networks> optionalNets = NeutronvpnUtils.read(dataBroker,
netsIdentifier);
LOG.trace("Removing Networks node: " + extNetId.getValue());
if (!optionalNets.isPresent()) {
- LOG.info("External Network " + extNetId.getValue() +
- " not available in the datastore");
+ LOG.info("External Network {} not available in the datastore", extNetId.getValue());
return;
}
// Delete Networks object from the ExternalNetworks list
LOG.trace("Deleting External Network " + extNetId.getValue());
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
- LOG.trace("Deleted External Network " + extNetId.getValue() +
- " successfully from CONFIG Datastore");
+ LOG.trace("Deleted External Network {} successfully from CONFIG Datastore", extNetId.getValue());
} catch (Exception ex) {
- LOG.error("Deletion of External Network " + extNetId.getValue() +
- " failed" + ex.getMessage());
+ LOG.error("Deletion of External Network {} failed: {}", extNetId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void addExternalNetworkToRouter(Router update) {
Uuid routerId = update.getUuid();
Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
Network input = NeutronvpnUtils.getNeutronNetwork(dataBroker, extNetId);
ProviderTypes providerNwType = NeutronvpnUtils.getProviderNetworkType(input);
if (providerNwType == null) {
- LOG.error("Unable to get Network Provider Type for network {} and uuid {}", input.getName(), input.getUuid());
+ LOG.error("Unable to get Network Provider Type for network {} and uuid {}",
+ input.getName(), input.getUuid());
return;
}
// Add this router to the ExtRouters list
addExternalRouter(update, dataBroker);
// Create and add Networks object for this External Network to the ExternalNetworks list
- InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
- child(Networks.class, new NetworksKey(extNetId)).build();
+ InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
+ .child(Networks.class, new NetworksKey(extNetId)).build();
Optional<Networks> optionalNets = NeutronvpnUtils.read(dataBroker,
LogicalDatastoreType.CONFIGURATION,
if (optionalNets.isPresent()) {
builder = new NetworksBuilder(optionalNets.get());
} else {
- LOG.error("External Network " + extNetId.getValue() +
- " not present in the NVPN datamodel");
+ LOG.error("External Network {} not present in the NVPN datamodel", extNetId.getValue());
return;
}
List<Uuid> rtrList = builder.getRouterIds();
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
LOG.trace("Updated externalnetworks successfully to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Creation of externalnetworks failed for " + extNetId.getValue() +
- " with exception " + ex.getMessage());
+ LOG.error("Creation of externalnetworks failed for {} with exception {}",
+ extNetId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void removeExternalNetworkFromRouter(Uuid origExtNetId, Router update) {
Uuid routerId = update.getUuid();
removeExternalRouter(origExtNetId, update, dataBroker);
// Remove the router from the ExternalNetworks list
- InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
- child(Networks.class, new NetworksKey(origExtNetId)).build();
+ InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
+ .child(Networks.class, new NetworksKey(origExtNetId)).build();
try {
Optional<Networks> optionalNets = NeutronvpnUtils.read(dataBroker,
LogicalDatastoreType.CONFIGURATION,
netsIdentifier);
- LOG.trace("Removing a router from External Networks node: " +
- origExtNetId.getValue());
+ LOG.trace("Removing a router from External Networks node: {}", origExtNetId.getValue());
if (optionalNets.isPresent()) {
NetworksBuilder builder = new NetworksBuilder(optionalNets.get());
List<Uuid> rtrList = builder.getRouterIds();
builder.setRouterIds(rtrList);
Networks networkss = builder.build();
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier, networkss);
- LOG.trace("Removed router " + routerId + " from externalnetworks " + origExtNetId.getValue());
+ LOG.trace("Removed router {} from externalnetworks {}", routerId, origExtNetId.getValue());
}
}
} catch (Exception ex) {
- LOG.error("Removing externalnetwork " + origExtNetId.getValue() +
- " from router " + routerId + " failed " + ex.getMessage());
+ LOG.error("Removing externalnetwork {} from router {} failed {}",
+ origExtNetId.getValue(), routerId, ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void addExternalNetworkToVpn(Network network, Uuid vpnId) {
Uuid extNetId = network.getUuid();
// Create and add Networks object for this External Network to the ExternalNetworks list
- InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
- child(Networks.class, new NetworksKey(extNetId)).build();
+ InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
+ .child(Networks.class, new NetworksKey(extNetId)).build();
try {
Optional<Networks> optionalNets = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
if (optionalNets.isPresent()) {
builder = new NetworksBuilder(optionalNets.get());
} else {
- LOG.error("External Network " + extNetId.getValue() +
- " not present in the NVPN datamodel");
+ LOG.error("External Network {} not present in the NVPN datamodel", extNetId.getValue());
return;
}
builder.setVpnid(vpnId);
LOG.trace("Wrote with VPN-ID successfully to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Attaching VPN-ID to externalnetwork " + extNetId.getValue() +
- " failed with " + ex.getMessage());
+ LOG.error("Attaching VPN-ID to externalnetwork {} failed with {}", extNetId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void removeExternalNetworkFromVpn(Network network) {
Uuid extNetId = network.getUuid();
// Create and add Networks object for this External Network to the ExternalNetworks list
- InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class).
- child(Networks.class, new NetworksKey(extNetId)).build();
+ InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
+ .child(Networks.class, new NetworksKey(extNetId)).build();
try {
Optional<Networks> optionalNets = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
LOG.trace("Updated extnetworks successfully to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Removing VPN-ID from externalnetworks " + extNetId.getValue() +
- " failed with " + ex.getMessage());
+ LOG.error("Removing VPN-ID from externalnetworks {} failed with {}", extNetId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void addExternalRouter(Router update, DataBroker broker) {
Uuid routerId = update.getUuid();
Uuid extNetId = update.getExternalGatewayInfo().getExternalNetworkId();
Network input = NeutronvpnUtils.getNeutronNetwork(dataBroker, extNetId);
ProviderTypes providerNwType = NeutronvpnUtils.getProviderNetworkType(input);
if (providerNwType == null) {
- LOG.error("Unable to get Network Provider Type for network {} and uuid{}", input.getName(), input.getUuid());
+ LOG.error("Unable to get Network Provider Type for network {} and uuid{}",
+ input.getName(), input.getUuid());
return;
}
Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
builder.setNetworkId(extNetId);
builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
- ArrayList<String> ext_fixed_ips = new ArrayList<String>();
- for (ExternalFixedIps fixed_ips : update.getExternalGatewayInfo().getExternalFixedIps()) {
- ext_fixed_ips.add(fixed_ips.getIpAddress().getIpv4Address().getValue());
+ ArrayList<String> extFixedIps = new ArrayList<String>();
+ for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().getExternalFixedIps()) {
+ extFixedIps.add(fixedIps.getIpAddress().getIpv4Address().getValue());
}
- builder.setExternalIps(ext_fixed_ips);
+ builder.setExternalIps(extFixedIps);
if (gatewayPortId != null) {
LOG.trace("Setting/Updating gateway Mac for router {}", routerId.getValue());
LOG.trace("Wrote successfully Routers to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Creation of extrouters failed for router " + routerId.getValue() +
- " failed with " + ex.getMessage());
+ LOG.error("Creation of extrouters failed for router {} failed with {}",
+ routerId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void removeExternalRouter(Uuid extNetId, Router update, DataBroker broker) {
Uuid routerId = update.getUuid();
LOG.trace("Removed router " + routerId.getValue() + " from extrouters ");
}
} catch (Exception ex) {
- LOG.error("Removing extrouter " + routerId.getValue() + " from extrouters " +
- " failed with " + ex.getMessage());
+ LOG.error("Removing extrouter {} from extrouters failed with {}", routerId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void handleExternalFixedIpsForRouter(Router update, DataBroker broker) {
Uuid routerId = update.getUuid();
if (optionalRouters.isPresent()) {
RoutersBuilder builder = new RoutersBuilder(optionalRouters.get());
if (builder != null) {
- ArrayList<String> ext_fixed_ips = new ArrayList<String>();
- for (ExternalFixedIps fixed_ips : update.getExternalGatewayInfo().getExternalFixedIps()) {
- ext_fixed_ips.add(fixed_ips.getIpAddress().getIpv4Address().getValue());
+ ArrayList<String> extFixedIps = new ArrayList<String>();
+ for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().getExternalFixedIps()) {
+ extFixedIps.add(fixedIps.getIpAddress().getIpv4Address().getValue());
}
- builder.setExternalIps(ext_fixed_ips);
+ builder.setExternalIps(extFixedIps);
}
Routers routerss = builder.build();
- LOG.trace("Updating external fixed ips for router " +
- routerId.getValue() + " with value " + routerss);
+ LOG.trace("Updating external fixed ips for router {} with value {}", routerId.getValue(), routerss);
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routersIdentifier, routerss);
LOG.trace("Added External Fixed IPs successfully for Routers to CONFIG Datastore");
}
} catch (Exception ex) {
- LOG.error("Updating extfixedips for " + routerId.getValue() +
- " in extrouters failed with " + ex.getMessage());
+ LOG.error("Updating extfixedips for {} in extrouters failed with {}", routerId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void handleSubnetsForExternalRouter(Uuid routerId, DataBroker broker) {
InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
LogicalDatastoreType.CONFIGURATION,
routersIdentifier);
- LOG.trace("Updating Internal subnets for Routers node: " +
- routerId.getValue());
+ LOG.trace("Updating Internal subnets for Routers node: {}", routerId.getValue());
RoutersBuilder builder = null;
if (optionalRouters.isPresent()) {
builder = new RoutersBuilder(optionalRouters.get());
LOG.trace("Updated successfully Routers to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Updation of internal subnets for extrouters " +
- "failed for router " + routerId.getValue() + " with " + ex.getMessage());
+ LOG.error("Updation of internal subnets for extrouters failed for router {} with {}",
+ routerId.getValue(), ex.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void handleSnatSettingChangeForRouter(Router update, DataBroker broker) {
Uuid routerId = update.getUuid();
Optional<Routers> optionalRouters = NeutronvpnUtils.read(broker,
LogicalDatastoreType.CONFIGURATION,
routersIdentifier);
- LOG.trace("Updating Internal subnets for Routers node: " +
- routerId.getValue());
+ LOG.trace("Updating Internal subnets for Routers node: {}", routerId.getValue());
RoutersBuilder builder = null;
if (optionalRouters.isPresent()) {
builder = new RoutersBuilder(optionalRouters.get());
LOG.trace("Updated successfully Routers to CONFIG Datastore");
} catch (Exception ex) {
- LOG.error("Updation of snat for extrouters failed for router " + routerId.getValue() +
- " with " + ex.getMessage());
+ LOG.error("Updation of snat for extrouters failed for router {} with {}",
+ routerId.getValue(), ex.getMessage());
}
}
}
package org.opendaylight.netvirt.neutronvpn;
import com.google.common.base.Optional;
-import java.util.Iterator;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.Sets;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.Sets;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.FloatingIpPortInfo;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
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.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+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.genius.idmanager.rev160406.AllocateIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAclBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.IpPrefixOrAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeFlat;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVxlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.NeutronRouterDpns;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.router.dpn.list.DpnVpninterfacesList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.NeutronRouterDpns;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.RouterDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.router.dpn.list.DpnVpninterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.FloatingIpPortInfo;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.port.info.FloatingIpIdToPortMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.port.info.FloatingIpIdToPortMappingKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkStates;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkStateKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.IpPrefixOrAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAclBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairsBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
public class NeutronvpnUtils {
- private static final Logger logger = LoggerFactory.getLogger(NeutronvpnUtils.class);
- private static final ImmutableBiMap<Class<? extends NetworkTypeBase>, Class<? extends SegmentTypeBase>> NETWORK_MAP =
- new ImmutableBiMap.Builder<Class<? extends NetworkTypeBase>, Class<? extends SegmentTypeBase>>()
+ private static final Logger LOG = LoggerFactory.getLogger(NeutronvpnUtils.class);
+ private static final ImmutableBiMap<Class<? extends NetworkTypeBase>, Class<? extends SegmentTypeBase>>
+ NETWORK_MAP =
+ new ImmutableBiMap.Builder<Class<? extends NetworkTypeBase>, Class<? extends SegmentTypeBase>>()
.put(NetworkTypeFlat.class, SegmentTypeFlat.class)
.put(NetworkTypeGre.class, SegmentTypeGre.class)
.put(NetworkTypeVlan.class, SegmentTypeVlan.class)
public static ConcurrentHashMap<Uuid, QosPolicy> qosPolicyMap = new ConcurrentHashMap<>();
public static ConcurrentHashMap<Uuid, HashMap<Uuid, Port>> qosPortsMap = new ConcurrentHashMap<>();
public static ConcurrentHashMap<Uuid, HashMap<Uuid, Network>> qosNetworksMap = new ConcurrentHashMap<>();
- private static final Set<Class<? extends NetworkTypeBase>> supportedNetworkTypes = Sets.newConcurrentHashSet();
+ private static final Set<Class<? extends NetworkTypeBase>> SUPPORTED_NETWORK_TYPES = Sets.newConcurrentHashSet();
private static long LOCK_WAIT_TIME = 10L;
private static TimeUnit secUnit = TimeUnit.SECONDS;
static ConcurrentHashMap<String, ImmutablePair<ReadWriteLock,AtomicInteger>> locks = new ConcurrentHashMap<>();
public static void registerSuppoprtedNetworkType(Class<? extends NetworkTypeBase> netType) {
- supportedNetworkTypes.add(netType);
+ SUPPORTED_NETWORK_TYPES.add(netType);
}
public static void unregisterSuppoprtedNetworkType(Class<? extends NetworkTypeBase> netType) {
- supportedNetworkTypes.remove(netType);
+ SUPPORTED_NETWORK_TYPES.remove(netType);
}
protected static Subnetmap getSubnetmap(DataBroker broker, Uuid subnetId) {
if (optionalVpnMap.isPresent()) {
return optionalVpnMap.get();
}
- logger.error("getVpnMap failed, VPN {} not present", id.getValue());
+ LOG.error("getVpnMap failed, VPN {} not present", id.getValue());
return null;
}
if (network != null) {
return network;
}
- logger.debug("getNeutronNetwork for {}", networkId.getValue());
- InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class).child(Networks.class).child
- (Network.class, new NetworkKey(networkId));
+ LOG.debug("getNeutronNetwork for {}", networkId.getValue());
+ InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class).child(Networks.class)
+ .child(Network.class, new NetworkKey(networkId));
Optional<Network> net = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
if (net.isPresent()) {
network = net.get();
if (prt != null) {
return prt;
}
- logger.debug("getNeutronPort for {}", portId.getValue());
+ LOG.debug("getNeutronPort for {}", portId.getValue());
InstanceIdentifier<Port> inst = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class,
new PortKey(portId));
Optional<Port> port = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
* @return the allowed address pairs delta
*/
protected static List<AllowedAddressPairs> getAllowedAddressPairsDelta(
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> port1AllowedAddressPairs,
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> port2AllowedAddressPairs) {
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> port1AllowedAddressPairs,
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> port2AllowedAddressPairs) {
if (port1AllowedAddressPairs == null) {
return null;
}
return getAllowedAddressPairsForAclService(port1AllowedAddressPairs);
}
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> list1 =
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> list1 =
new ArrayList<>(port1AllowedAddressPairs);
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> list2 =
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> list2 =
new ArrayList<>(port2AllowedAddressPairs);
- for (Iterator<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> iterator =
+ for (Iterator<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> iterator =
list1.iterator(); iterator.hasNext();) {
- org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs allowedAddressPair1 =
- iterator.next();
- for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs allowedAddressPair2 : list2) {
+ org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs allowedAddressPair1 = iterator.next();
+ for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs allowedAddressPair2 : list2) {
if (allowedAddressPair1.getKey().equals(allowedAddressPair2.getKey())) {
iterator.remove();
break;
return aclAllowedAddressPairs;
}
- /**
- * Gets the IPv6 Link Local Address corresponding to the MAC Address.
- *
- * @param macAddress the mac address
- * @return the allowed address pairs for acl service which includes the MAC + IPv6LLA
- */
- protected static AllowedAddressPairs updateIPv6LinkLocalAddressForAclService(MacAddress macAddress) {
- IpAddress ipv6LinkLocalAddress = getIpv6LinkLocalAddressFromMac(macAddress);
- return getAclAllowedAddressPairs(macAddress,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.types.rev160517.IpPrefixOrAddress(
- ipv6LinkLocalAddress.getValue()));
- }
-
/**
* Gets the allowed address pairs for acl service.
*
* @return the allowed address pairs for acl service
*/
protected static List<AllowedAddressPairs> getAllowedAddressPairsForAclService(
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
- .AllowedAddressPairs> portAllowedAddressPairs) {
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> portAllowedAddressPairs) {
List<AllowedAddressPairs> aclAllowedAddressPairs = new ArrayList<>();
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs
- portAllowedAddressPair : portAllowedAddressPairs) {
+ portAllowedAddressPair : portAllowedAddressPairs) {
aclAllowedAddressPairs.add(getAclAllowedAddressPairs(portAllowedAddressPair.getMacAddress(),
- portAllowedAddressPair.getIpAddress()));
+ portAllowedAddressPair.getIpAddress()));
}
return aclAllowedAddressPairs;
}
+ /**
+ * Gets the IPv6 Link Local Address corresponding to the MAC Address.
+ *
+ * @param macAddress the mac address
+ * @return the allowed address pairs for acl service which includes the MAC + IPv6LLA
+ */
+ protected static AllowedAddressPairs updateIPv6LinkLocalAddressForAclService(MacAddress macAddress) {
+ IpAddress ipv6LinkLocalAddress = getIpv6LinkLocalAddressFromMac(macAddress);
+ return getAclAllowedAddressPairs(macAddress,
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.types.rev160517.IpPrefixOrAddress(
+ ipv6LinkLocalAddress.getValue()));
+ }
+
/**
* Gets the updated security groups.
*
List<FixedIps> origFixedIps, List<FixedIps> newFixedIps) {
List<FixedIps> addedFixedIps = getFixedIpsDelta(newFixedIps, origFixedIps);
List<FixedIps> deletedFixedIps = getFixedIpsDelta(origFixedIps, newFixedIps);
- List<AllowedAddressPairs> updatedAllowedAddressPairs = aclInterfaceAllowedAddressPairs != null ?
- new ArrayList<>(aclInterfaceAllowedAddressPairs) : new ArrayList<>();
+ List<AllowedAddressPairs> updatedAllowedAddressPairs =
+ aclInterfaceAllowedAddressPairs != null
+ ? new ArrayList<>(aclInterfaceAllowedAddressPairs) : new ArrayList<>();
if (deletedFixedIps != null) {
updatedAllowedAddressPairs.removeAll(getAllowedAddressPairsForAclService(portMacAddress, deletedFixedIps));
}
*/
protected static List<AllowedAddressPairs> getUpdatedAllowedAddressPairs(
List<AllowedAddressPairs> aclInterfaceAllowedAddressPairs,
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> origAllowedAddressPairs,
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs> newAllowedAddressPairs) {
- List<AllowedAddressPairs> addedAllowedAddressPairs = getAllowedAddressPairsDelta(newAllowedAddressPairs,
- origAllowedAddressPairs);
- List<AllowedAddressPairs> deletedAllowedAddressPairs = getAllowedAddressPairsDelta(origAllowedAddressPairs,
- newAllowedAddressPairs);
- List<AllowedAddressPairs> updatedAllowedAddressPairs = aclInterfaceAllowedAddressPairs != null ?
- new ArrayList<>(aclInterfaceAllowedAddressPairs) : new ArrayList<>();
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> origAllowedAddressPairs,
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes
+ .AllowedAddressPairs> newAllowedAddressPairs) {
+ List<AllowedAddressPairs> addedAllowedAddressPairs =
+ getAllowedAddressPairsDelta(newAllowedAddressPairs,origAllowedAddressPairs);
+ List<AllowedAddressPairs> deletedAllowedAddressPairs =
+ getAllowedAddressPairsDelta(origAllowedAddressPairs, newAllowedAddressPairs);
+ List<AllowedAddressPairs> updatedAllowedAddressPairs =
+ aclInterfaceAllowedAddressPairs != null
+ ? new ArrayList<>(aclInterfaceAllowedAddressPairs) : new ArrayList<>();
if (addedAllowedAddressPairs != null) {
updatedAllowedAddressPairs.addAll(addedAllowedAddressPairs);
}
// Handle security group enabled
List<Uuid> securityGroups = port.getSecurityGroups();
if (securityGroups != null) {
- interfaceAclBuilder.setSecurityGroups(securityGroups);
+ interfaceAclBuilder.setSecurityGroups(securityGroups);
}
List<AllowedAddressPairs> aclAllowedAddressPairs = NeutronvpnUtils.getAllowedAddressPairsForAclService(
port.getMacAddress(), port.getFixedIps());
}
protected static List<Uuid> getNeutronRouterSubnetIds(DataBroker broker, Uuid routerId) {
- logger.debug("getNeutronRouterSubnetIds for {}", routerId.getValue());
+ LOG.debug("getNeutronRouterSubnetIds for {}", routerId.getValue());
List<Uuid> subnetIdList = new ArrayList<>();
- Optional<Subnetmaps> subnetMaps = read(broker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder
- (Subnetmaps.class).build());
+ Optional<Subnetmaps> subnetMaps = read(broker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.builder(Subnetmaps.class).build());
if (subnetMaps.isPresent() && subnetMaps.get().getSubnetmap() != null) {
for (Subnetmap subnetmap : subnetMaps.get().getSubnetmap()) {
if (routerId.equals(subnetmap.getRouterId())) {
}
}
}
- logger.debug("returning from getNeutronRouterSubnetIds for {}", routerId.getValue());
+ LOG.debug("returning from getNeutronRouterSubnetIds for {}", routerId.getValue());
return subnetIdList;
}
protected static String getVifPortName(Port port) {
if (port == null || port.getUuid() == null) {
- logger.warn("Invalid Neutron port {}", port);
+ LOG.warn("Invalid Neutron port {}", port);
return null;
}
String tapId = port.getUuid().getValue().substring(0, 11);
if (portNamePrefix != null) {
return new StringBuilder().append(portNamePrefix).append(tapId).toString();
}
- logger.debug("Failed to get prefix for port {}", port.getUuid());
+ LOG.debug("Failed to get prefix for port {}", port.getUuid());
return null;
}
return getPortNamePrefix(original) == null && getPortNamePrefix(updated) != null;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected static boolean lock(String lockName) {
if (locks.get(lockName) != null) {
synchronized (locks) {
}
} catch (InterruptedException e) {
locks.get(lockName).getRight().decrementAndGet();
- logger.error("Unable to acquire lock for {}", lockName);
+ LOG.error("Unable to acquire lock for {}", lockName);
throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e.getCause());
}
} else {
locks.get(lockName).getLeft().writeLock().tryLock(LOCK_WAIT_TIME, secUnit);
} catch (Exception e) {
locks.get(lockName).getRight().decrementAndGet();
- logger.error("Unable to acquire lock for {}", lockName);
+ LOG.error("Unable to acquire lock for {}", lockName);
throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e.getCause());
}
}
return true;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected static boolean unlock(String lockName) {
if (locks.get(lockName) != null) {
try {
locks.get(lockName).getLeft().writeLock().unlock();
} catch (Exception e) {
- logger.error("Unable to un-lock for " + lockName, e);
+ LOG.error("Unable to un-lock for " + lockName, e);
return false;
}
if (0 == locks.get(lockName).getRight().decrementAndGet()) {
return true;
}
+ // TODO Clean up the exception handling and the console output
+ @SuppressWarnings({"checkstyle:IllegalCatch", "checkstyle:RegexpSinglelineJava"})
protected static Short getIPPrefixFromPort(DataBroker broker, Port port) {
Short prefix = new Short((short) 0);
String cidr = "";
prefix = Short.valueOf(parts[1]);
return prefix;
} else {
- logger.trace("Could not retrieve prefix from subnet CIDR");
+ LOG.trace("Could not retrieve prefix from subnet CIDR");
System.out.println("Could not retrieve prefix from subnet CIDR");
}
} else {
- logger.trace("Unable to read on subnet datastore");
+ LOG.trace("Unable to read on subnet datastore");
}
} catch (Exception e) {
- logger.error("Failed to retrieve IP prefix from port : ", e);
+ LOG.error("Failed to retrieve IP prefix from port : ", e);
System.out.println("Failed to retrieve IP prefix from port : " + e.getMessage());
}
return null;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected static void createVpnPortFixedIpToPort(DataBroker broker,String vpnName, String fixedIp,
String portName, String macAddress, boolean isSubnetIp,
WriteTransaction writeConfigTxn) {
InstanceIdentifier<VpnPortipToPort> id = NeutronvpnUtils.buildVpnPortipToPortIdentifier(vpnName, fixedIp);
- VpnPortipToPortBuilder builder = new VpnPortipToPortBuilder().setKey(new VpnPortipToPortKey(fixedIp, vpnName)
- ).setVpnName(vpnName).setPortFixedip(fixedIp).setPortName(portName).setMacAddress(macAddress).setSubnetIp
- (isSubnetIp);
+ VpnPortipToPortBuilder builder = new VpnPortipToPortBuilder()
+ .setKey(new VpnPortipToPortKey(fixedIp, vpnName))
+ .setVpnName(vpnName).setPortFixedip(fixedIp)
+ .setPortName(portName).setMacAddress(macAddress).setSubnetIp(isSubnetIp);
try {
if (writeConfigTxn != null) {
writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, builder.build());
} else {
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, builder.build());
}
- logger.trace("Neutron port with fixedIp: {}, vpn {}, interface {}, mac {}, isSubnetIp {} added to " +
- "VpnPortipToPort DS", fixedIp, vpnName, portName, macAddress, isSubnetIp);
+ LOG.trace("Neutron port with fixedIp: {}, vpn {}, interface {}, mac {}, isSubnetIp {} added to "
+ + "VpnPortipToPort DS", fixedIp, vpnName, portName, macAddress, isSubnetIp);
} catch (Exception e) {
- logger.error("Failure while creating VPNPortFixedIpToPort map for vpn {} - fixedIP {}", vpnName, fixedIp,
+ LOG.error("Failure while creating VPNPortFixedIpToPort map for vpn {} - fixedIP {}", vpnName, fixedIp,
e);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName,
String fixedIp, WriteTransaction writeConfigTxn) {
InstanceIdentifier<VpnPortipToPort> id = NeutronvpnUtils.buildVpnPortipToPortIdentifier(vpnName, fixedIp);
} else {
MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, id);
}
- logger.trace("Neutron router port with fixedIp: {}, vpn {} removed from LearntVpnPortipToPort DS", fixedIp,
+ LOG.trace("Neutron router port with fixedIp: {}, vpn {} removed from LearntVpnPortipToPort DS", fixedIp,
vpnName);
} catch (Exception e) {
- logger.error("Failure while removing VPNPortFixedIpToPort map for vpn {} - fixedIP {}", vpnName, fixedIp,
+ LOG.error("Failure while removing VPNPortFixedIpToPort map for vpn {} - fixedIP {}", vpnName, fixedIp,
e);
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected static void removeLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp) {
InstanceIdentifier<LearntVpnVipToPort> id = NeutronvpnUtils.buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
try {
synchronized ((vpnName + fixedIp).intern()) {
MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, id);
}
- logger.trace("Neutron router port with fixedIp: {}, vpn {} removed from LearntVpnPortipToPort DS", fixedIp,
+ LOG.trace("Neutron router port with fixedIp: {}, vpn {} removed from LearntVpnPortipToPort DS", fixedIp,
vpnName);
} catch (Exception e) {
- logger.error("Failure while removing LearntVpnPortFixedIpToPort map for vpn {} - fixedIP {}", vpnName, fixedIp,
- e);
+ LOG.error("Failure while removing LearntVpnPortFixedIpToPort map for vpn {} - fixedIP {}",
+ vpnName, fixedIp, e);
}
}
}
static InstanceIdentifier<VpnPortipToPort> buildVpnPortipToPortIdentifier(String vpnName, String fixedIp) {
- InstanceIdentifier<VpnPortipToPort> id = InstanceIdentifier.builder(NeutronVpnPortipPortData.class).child
- (VpnPortipToPort.class, new VpnPortipToPortKey(fixedIp, vpnName)).build();
+ InstanceIdentifier<VpnPortipToPort> id =
+ InstanceIdentifier.builder(NeutronVpnPortipPortData.class)
+ .child(VpnPortipToPort.class, new VpnPortipToPortKey(fixedIp, vpnName)).build();
return id;
}
static InstanceIdentifier<LearntVpnVipToPort> buildLearntVpnVipToPortIdentifier(String vpnName, String fixedIp) {
- InstanceIdentifier<LearntVpnVipToPort> id = InstanceIdentifier.builder(LearntVpnVipToPortData.class).child
- (LearntVpnVipToPort.class, new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
+ InstanceIdentifier<LearntVpnVipToPort> id =
+ InstanceIdentifier.builder(LearntVpnVipToPortData.class)
+ .child(LearntVpnVipToPort.class, new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
return id;
}
return id;
}
- static InstanceIdentifier<FloatingIpIdToPortMapping> buildfloatingIpIdToPortMappingIdentifier (Uuid floatingIpId) {
+ static InstanceIdentifier<FloatingIpIdToPortMapping> buildfloatingIpIdToPortMappingIdentifier(Uuid floatingIpId) {
return InstanceIdentifier.builder(FloatingIpPortInfo.class).child(FloatingIpIdToPortMapping.class, new
FloatingIpIdToPortMappingKey(floatingIpId)).build();
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
static boolean isNetworkTypeSupported(Network network) {
NetworkProviderExtension npe = network.getAugmentation(NetworkProviderExtension.class);
- return npe != null && npe.getNetworkType() != null && supportedNetworkTypes.contains(npe.getNetworkType());
+ return npe != null && npe.getNetworkType() != null && SUPPORTED_NETWORK_TYPES.contains(npe.getNetworkType());
}
static ProviderTypes getProviderNetworkType(Network network) {
if (network == null) {
- logger.error("Error in getting provider network type since network is null");
+ LOG.error("Error in getting provider network type since network is null");
return null;
}
NetworkProviderExtension npe = network.getAugmentation(NetworkProviderExtension.class);
if (npe != null) {
Class<? extends NetworkTypeBase> networkTypeBase = npe.getNetworkType();
if (networkTypeBase != null) {
- if(networkTypeBase.isAssignableFrom(NetworkTypeFlat.class)) {
- return ProviderTypes.FLAT;
- } else if (networkTypeBase.isAssignableFrom(NetworkTypeVlan.class)) {
- return ProviderTypes.VLAN;
- } else if (networkTypeBase.isAssignableFrom(NetworkTypeVxlan.class)) {
- return ProviderTypes.VXLAN;
- } else if (networkTypeBase.isAssignableFrom(NetworkTypeGre.class)) {
- return ProviderTypes.GRE;
- }
+ if (networkTypeBase.isAssignableFrom(NetworkTypeFlat.class)) {
+ return ProviderTypes.FLAT;
+ } else if (networkTypeBase.isAssignableFrom(NetworkTypeVlan.class)) {
+ return ProviderTypes.VLAN;
+ } else if (networkTypeBase.isAssignableFrom(NetworkTypeVxlan.class)) {
+ return ProviderTypes.VXLAN;
+ } else if (networkTypeBase.isAssignableFrom(NetworkTypeGre.class)) {
+ return ProviderTypes.GRE;
+ }
}
}
return null;
}
/**
- * Get inter-VPN link state
+ * Get inter-VPN link state.
*
* @param broker data broker
* @param vpnLinkName VPN link name
/**
* Returns an InterVpnLink by searching by one of its endpoint's IP.
*
- * @param broker
+ * @param broker The Databroker
* @param endpointIp IP to search for
- * @return
+ * @return a InterVpnLink
*/
public static Optional<InterVpnLink> getInterVpnLinkByEndpointIp(DataBroker broker, String endpointIp) {
InstanceIdentifier<InterVpnLinks> interVpnLinksIid = InstanceIdentifier.builder(InterVpnLinks.class).build();
Set<RouterDpnList> ret = new HashSet<>();
InstanceIdentifier<NeutronRouterDpns> routerDpnId =
InstanceIdentifier.create(NeutronRouterDpns.class);
- Optional<NeutronRouterDpns> neutronRouterDpnsOpt = MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, routerDpnId);
+ Optional<NeutronRouterDpns> neutronRouterDpnsOpt =
+ MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, routerDpnId);
if (neutronRouterDpnsOpt.isPresent()) {
NeutronRouterDpns neutronRouterDpns = neutronRouterDpnsOpt.get();
List<RouterDpnList> routerDpnLists = neutronRouterDpns.getRouterDpnList();
if (rpcResult.isSuccessful()) {
return rpcResult.getResult().getIdValue().intValue();
} else {
- logger.debug("RPC Call to Get Unique Id returned with Errors", rpcResult.getErrors());
+ LOG.debug("RPC Call to Get Unique Id returned with Errors", rpcResult.getErrors());
}
} catch (InterruptedException | ExecutionException e) {
- logger.debug("Exception when getting Unique Id", e);
+ LOG.debug("Exception when getting Unique Id", e);
}
return null;
}
Future<RpcResult<Void>> result = idManager.releaseId(idInput);
RpcResult<Void> rpcResult = result.get();
if (!rpcResult.isSuccessful()) {
- logger.debug("RPC Call to Get Unique Id returned with Errors", rpcResult.getErrors());
+ LOG.debug("RPC Call to Get Unique Id returned with Errors", rpcResult.getErrors());
} else {
- logger.info("ID for RD " + idKey + " released successfully");
+ LOG.info("ID for RD " + idKey + " released successfully");
}
} catch (InterruptedException | ExecutionException e) {
- logger.debug("Exception when trying to release ID into the pool", idKey, e);
+ LOG.debug("Exception when trying to release ID into the pool", idKey, e);
}
}
static List<String> getExistingRDs(DataBroker broker) {
List<String> existingRDs = new ArrayList<>();
InstanceIdentifier<VpnInstances> path = InstanceIdentifier.builder(VpnInstances.class).build();
- Optional<VpnInstances> vpnInstancesOptional = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, path);
+ Optional<VpnInstances> vpnInstancesOptional =
+ NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, path);
if (vpnInstancesOptional.isPresent() && vpnInstancesOptional.get().getVpnInstance() != null) {
for (VpnInstance vpnInstance : vpnInstancesOptional.get().getVpnInstance()) {
existingRDs.add(vpnInstance.getIpv4Family().getRouteDistinguisher());
package org.opendaylight.netvirt.neutronvpn;
import com.google.common.base.Optional;
+import java.util.ArrayList;
+import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.List;
-
public class SubnetmapListener extends AsyncDataTreeChangeListenerBase<Subnetmap, SubnetmapListener> {
private static final Logger LOG = LoggerFactory.getLogger(SubnetmapListener.class);
return InstanceIdentifier.create(Subnetmaps.class).child(Subnetmap.class);
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private void registerListener(final DataBroker db) {
try {
registerListener(LogicalDatastoreType.CONFIGURATION, db);
}
@Override
- protected void update(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmapOriginal, Subnetmap subnetmapUpdate) {
- LOG.trace("SubnetmapListener update subnetmap method - key: " + identifier + ", original=" + subnetmapOriginal + ", update=" + subnetmapUpdate);
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ protected void update(InstanceIdentifier<Subnetmap> identifier,
+ Subnetmap subnetmapOriginal, Subnetmap subnetmapUpdate) {
+ LOG.trace("SubnetmapListener update subnetmap method - key: {}, original: {}, update: {}",
+ identifier, subnetmapOriginal, subnetmapUpdate);
Uuid vpnIdNew = subnetmapUpdate.getVpnId();
Uuid vpnIdOld = subnetmapOriginal.getVpnId();
Uuid subnetId = subnetmapUpdate.getId();
String subnetIp = subnetmapUpdate.getSubnetIp();
Long elanTag = getElanTag(elanInstanceName);
if (elanTag.equals(0L)) {
- LOG.debug("Unable to fetch elantag from ElanInstance {} and hence not proceeding with subnetmapListener update" +
- " for subnet {}", elanInstanceName, subnetId);
+ LOG.debug("Unable to fetch elantag from ElanInstance {} and hence not proceeding with "
+ + "subnetmapListener update for subnet {}", elanInstanceName, subnetId);
return;
}
//////////////////////////SubnetAddedToVpn////////////////////////////////////////////////////
if (vpnIdNew != null && vpnIdOld == null) {
- boolean isExternalVpn = vpnIdNew.equals(subnetmapUpdate.getRouterId()) ? false : true;
+ boolean isExternalVpn = !vpnIdNew.equals(subnetmapUpdate.getRouterId());
try {
checkAndPublishSubnetAddedToVpnNotification(subnetId, subnetIp, vpnIdNew.getValue(),
isExternalVpn, elanTag);
vpnIdOld.getValue(), isExternalVpn, elanTag);
LOG.debug("Subnet removed from VPN notification sent for subnet {} on VPN {}", subnetId.getValue(),
vpnIdOld.getValue());
- } catch (Exception e){
+ } catch (Exception e) {
LOG.error("Subnet removed from VPN notification failed for subnet {} on VPN {}", subnetId.getValue(),
vpnIdOld.getValue(), e);
}
subnetmapUpdate.getVpnId().getValue(), isBeingAssociated, elanTag);
LOG.debug("VPN updated for subnet notification sent for subnet {} on VPN {}", subnetId.getValue(),
vpnIdNew.getValue());
- } catch (Exception e){
+ } catch (Exception e) {
LOG.error("VPN updated for subnet notification failed for subnet {} on VPN {}", subnetId.getValue(),
vpnIdNew.getValue(), e);
}
checkAndPublishPortAddedToSubnetNotification(subnetIp, subnetId, port, elanTag);
LOG.debug("Port added to subnet notification sent for port {} in subnet {}", port.getValue(),
subnetId.getValue());
- }catch (Exception e){
- LOG.error("Port added to subnet notification failed for port {} in subnet {}", port.getValue(),
- subnetId.getValue(), e);
+ } catch (Exception e) {
+ LOG.error("Port added to subnet notification failed for port {} in subnet {}",
+ port.getValue(), subnetId.getValue(), e);
}
return;
}
if (! newPortList.contains(port)) {
try {
checkAndPublishPortRemovedFromSubnetNotification(subnetIp, subnetId, port, elanTag);
- LOG.debug("Port removed from subnet notification sent for port {} in subnet {}", port.getValue(),
- subnetId.getValue());
- }catch (Exception e){
- LOG.error("Port removed from subnet notification failed for port {} in subnet {}", port.getValue(),
- subnetId.getValue(), e);
+ LOG.debug("Port removed from subnet notification sent for port {} in subnet {}",
+ port.getValue(), subnetId.getValue());
+ } catch (Exception e) {
+ LOG.error("Port removed from subnet notification failed for port {} in subnet {}",
+ port.getValue(), subnetId.getValue(), e);
}
return;
}
return this;
}
- protected long getElanTag (String elanInstanceName) {
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ protected long getElanTag(String elanInstanceName) {
InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class)
.child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
long elanTag = 0L;
LOG.error("Notification failed because of failure in reading ELANInstance {}", elanInstanceName);
}
} catch (Exception e) {
- LOG.error("Notification failed because of failure in fetching elanTag from ElanInstance {} config DS", elanInstanceName, e);
+ LOG.error("Notification failed because of failure in fetching elanTag from ElanInstance {} config DS",
+ elanInstanceName, e);
}
return elanTag;
}
private void checkAndPublishSubnetAddedToVpnNotification(Uuid subnetId, String subnetIp, String vpnName,
- Boolean isExternalvpn, Long elanTag) throws InterruptedException {
+ Boolean isExternalvpn, Long elanTag)
+ throws InterruptedException {
SubnetAddedToVpnBuilder builder = new SubnetAddedToVpnBuilder();
LOG.trace("publish notification called from SubnetAddedToVpnNotification");
}
private void checkAndPublishSubnetDeletedFromVpnNotification(Uuid subnetId, String subnetIp, String vpnName,
- Boolean isExternalvpn, Long elanTag) throws InterruptedException {
+ Boolean isExternalvpn, Long elanTag)
+ throws InterruptedException {
SubnetDeletedFromVpnBuilder builder = new SubnetDeletedFromVpnBuilder();
LOG.trace("publish notification called SubnetDeletedFromVpnNotification");
}
private void checkAndPublishSubnetUpdatedInVpnNotification(Uuid subnetId, String subnetIp, String vpnName,
- Boolean isExternalvpn, Long elanTag) throws InterruptedException {
+ Boolean isExternalvpn, Long elanTag)
+ throws InterruptedException {
SubnetUpdatedInVpnBuilder builder = new SubnetUpdatedInVpnBuilder();
LOG.trace("publish notification called SubnetUpdatedInVpnNotification");
notificationPublishService.putNotification(builder.build());
}
- private void checkAndPublishPortAddedToSubnetNotification(String subnetIp, Uuid subnetId, Uuid portId, Long elanTag) throws
- InterruptedException {
+ private void checkAndPublishPortAddedToSubnetNotification(String subnetIp, Uuid subnetId,
+ Uuid portId, Long elanTag)
+ throws InterruptedException {
PortAddedToSubnetBuilder builder = new PortAddedToSubnetBuilder();
LOG.trace("publish notification called PortAddedToSubnetNotification");
builder.setSubnetIp(subnetIp);
notificationPublishService.putNotification(builder.build());
}
- private void checkAndPublishPortRemovedFromSubnetNotification(String subnetIp, Uuid subnetId, Uuid portId, Long elanTag)
+ private void checkAndPublishPortRemovedFromSubnetNotification(String subnetIp, Uuid subnetId, Uuid portId,
+ Long elanTag)
throws InterruptedException {
PortRemovedFromSubnetBuilder builder = new PortRemovedFromSubnetBuilder();
LOG.trace("publish notification called PortRemovedFromSubnetNotification");
* If the TEP of the port's node exists in the TZ, it will not be added.
* @param inter - the interface to update
*/
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void updateTrasportZone(Interface inter) {
List<Port> ports = getPortsFromInterface(inter);
//supports VPN aware VMs (multiple ports for one interface)
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void updateTrasportZone(RouterDpnList routerDpnList) {
- try{
- InstanceIdentifier<TransportZone> inst = InstanceIdentifier.create(TransportZones.class).
- child(TransportZone.class, new TransportZoneKey(routerDpnList.getRouterId()));
+ try {
+ InstanceIdentifier<TransportZone> inst = InstanceIdentifier.create(TransportZones.class)
+ .child(TransportZone.class, new TransportZoneKey(routerDpnList.getRouterId()));
TransportZone zone = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, inst);
String subnetIp = ALL_SUBNETS;
// take all interfaces with parent-interface with physPortId name
for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
- .Interface inter : inters) {
+ .Interface inter : inters) {
ParentRefs parent = inter.getAugmentation(ParentRefs.class);
if (parent == null || !physPortId.equals(parent.getParentInterface())) {
continue;
Subnets subnets = findSubnets(zone.getSubnets(), subnetIp);
- for(Vteps existingVtep : subnets.getVteps()){
+ for (Vteps existingVtep : subnets.getVteps()) {
if (existingVtep.getDpnId().equals(dpnId)) {
return 0;
}
}
@SuppressWarnings("unchecked")
- private Node getPortsNode(BigInteger dpnId) throws Exception{
- InstanceIdentifier<BridgeRefEntry> bridgeRefInfoPath = InstanceIdentifier.
- create(BridgeRefInfo.class).child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId));
+ private Node getPortsNode(BigInteger dpnId) throws Exception {
+ InstanceIdentifier<BridgeRefEntry> bridgeRefInfoPath =
+ InstanceIdentifier.create(BridgeRefInfo.class).child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId));
BridgeRefEntry bridgeRefEntry = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
if (bridgeRefEntry == null) {
throw new Exception("no bridge ref entry found for dpnId: " + dpnId);
/*
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ * Copyright (c) 2016 - 2017 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,
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.utils.L2GatewayCacheUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
*/
public class AddL2GwDevicesToTransportZoneJob implements Callable<List<ListenableFuture<Void>>> {
- /** The Constant LOG. */
private static final Logger LOG = LoggerFactory.getLogger(AddL2GwDevicesToTransportZoneJob.class);
-
- /** The data broker. */
- private DataBroker dataBroker;
-
- /** The itm rpc service. */
- private ItmRpcService itmRpcService;
-
- /** The transport zone. */
- private TransportZone transportZone;
+ private final ItmRpcService itmRpcService;
+ private final TransportZone transportZone;
/**
* Instantiates a new adds the l2 gw devices to transport zone job.
*
- * @param dataBroker the data broker
* @param itmRpcService the itm rpc service
* @param transportZone the transport zone
*/
- public AddL2GwDevicesToTransportZoneJob(DataBroker dataBroker, ItmRpcService itmRpcService,
+ public AddL2GwDevicesToTransportZoneJob(ItmRpcService itmRpcService,
TransportZone transportZone) {
- this.dataBroker = dataBroker;
this.itmRpcService = itmRpcService;
this.transportZone = transportZone;
LOG.debug("created AddL2GwDevicesToTransportZone Job for tZone {}", transportZone.getZoneName());
* @see java.util.concurrent.Callable#call()
*/
@Override
+ @SuppressWarnings("checkstyle:IllegalCatch")
public List<ListenableFuture<Void>> call() throws Exception {
LOG.debug("Running AddL2GwDevicesToTransportZone job for {}", this.transportZone.getZoneName());
try {
/*
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ * Copyright (c) 2016 - 2017 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,
import java.util.Set;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.clustering.ClusteringUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Delete ITM tunnels if it's last Gateway deleted and device is connected
// Also, do not delete device from cache if it's connected
if (L2GatewayUtils.isLastL2GatewayBeingDeleted(l2GwDevice)) {
- if(l2GwDevice.isConnected()){
+ if (l2GwDevice.isConnected()) {
l2GwDevice.removeL2GatewayId(input.getUuid());
// Delete ITM tunnels
final String hwvtepId = l2GwDevice.getHwvtepNodeId();
// Cleaning up the config DS
NodeId nodeId = new NodeId(l2GwDevice.getHwvtepNodeId());
NodeId psNodeId = HwvtepSouthboundUtils.createManagedNodeId(nodeId, l2DeviceName);
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, HwvtepSouthboundUtils.createInstanceIdentifier(nodeId));
- MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, HwvtepSouthboundUtils.createInstanceIdentifier(psNodeId));
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ HwvtepSouthboundUtils.createInstanceIdentifier(nodeId));
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ HwvtepSouthboundUtils.createInstanceIdentifier(psNodeId));
}
} else {
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
-import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
+import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInputBuilder;
if (tzNew.getTunnelType().equals(TunnelTypeVxlan.class)) {
DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
AddL2GwDevicesToTransportZoneJob job =
- new AddL2GwDevicesToTransportZoneJob(dataBroker, itmRpcService, tzNew);
+ new AddL2GwDevicesToTransportZoneJob(itmRpcService, tzNew);
coordinator.enqueueJob(job.getJobKey(), job);
}
}
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-
@RunWith(MockitoJUnitRunner.class)
public class NeutronPortChangeListenerTest {
@Mock
DataBroker dataBroker;
@Mock
- NeutronvpnManager nVpnMgr;
+ NeutronvpnManager neutronvpnManager;
@Mock
- NeutronvpnNatManager nVpnNatMgr;
+ NeutronvpnNatManager neutronvpnNatManager;
@Mock
NotificationPublishService notiPublishService;
@Mock
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
- when(mockReadTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNetwork)));
- neutronPortChangeListener = new NeutronPortChangeListener(dataBroker, nVpnMgr, nVpnNatMgr,
+ when(mockReadTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNetwork)));
+ neutronPortChangeListener = new NeutronPortChangeListener(dataBroker, neutronvpnManager, neutronvpnNatManager,
notiPublishService, gwMacResolver, odlInterfaceRpcService, elanService);
InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class)
.child(ElanInstance.class,
new ElanInstanceKey(new Uuid("12345678-1234-1234-1234-123456789012").getValue())).build();
- when(mockReadTx.read(any(LogicalDatastoreType.class), eq(elanIdentifierId))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(elanInstance)));
+ when(mockReadTx.read(any(LogicalDatastoreType.class), eq(elanIdentifierId)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(elanInstance)));
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
-
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-
@RunWith(MockitoJUnitRunner.class)
public class ToTransportZoneTest {
private static final String PHYS_PORT_NAME = "tap12345-67";
-
private static final Long DPN_ID = 1234567890L;
-
private static final BigInteger DPN_ID_2 = BigInteger.valueOf(1234567891L);
-
private static final String PORT_NAME = "12345678-1234-1234-1234-123456789012";
-
private static final String PORT_IP = "1.1.1.1";
-
private static final String NETWORK_ID = "12345678-1234-1234-1234-123456789012";
-
private static final String SUBNET = "0.0.0.0/0";
-
private static final String OVS_IP = "10.0.0.1";
-
private static final IpAddress OVS_IP_2 = new IpAddress("10.0.0.2".toCharArray());
-
private static final String VTEP_PORT = "tunnel_port";
-
- private static final String ROUTER_ID = "10345678-1234-1234-1234-123456789012";
+ private static final String ROUTER_ID = "10345678-1234-1234-1234-123456789012";
@Mock
private DataBroker dataBroker;
@Mock
- private NeutronvpnManager nVpnMgr;
+ private NeutronvpnManager neutronvpnManager;
@Mock
private ListenerRegistration<DataChangeListener> dataChangeListenerRegistration;
@Mock
private ReadOnlyTransaction mockReadTx;
@Mock
private Node node;
-
private Interfaces interf;
-
private Port port;
-
private List<Vteps> expectedVteps = new ArrayList<>();
-
InterfaceStateToTransportZoneListener interfaceStateToTransportZoneChangeListener;
-
NeutronRouterDpnsToTransportZoneListener neutronRouterDpnsToTransportZoneListener;
-
private Network network;
@Before
public void setUp() {
when(dataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), //
- any(InstanceIdentifier.class), //
- any(DataChangeListener.class), //
- any(AsyncDataBroker.DataChangeScope.class))). //
- thenReturn(dataChangeListenerRegistration);
+ any(InstanceIdentifier.class), //
+ any(DataChangeListener.class), //
+ any(AsyncDataBroker.DataChangeScope.class))). //
+ thenReturn(dataChangeListenerRegistration);
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
doAnswer(new Answer<Void>() {
@Override
}).when(mockWriteTx).put(any(), any(), any(), any(Boolean.class));
doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
-
+
Subnetmap subnetMap = new SubnetmapBuilder().setSubnetIp(SUBNET).build();
-
- when(nVpnMgr.updateSubnetmapNodeWithPorts(any(Uuid.class), any(Uuid.class), any(Uuid.class)))
- .thenReturn(subnetMap);
-
- when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
- interfaceStateToTransportZoneChangeListener = new InterfaceStateToTransportZoneListener(dataBroker, nVpnMgr);
- neutronRouterDpnsToTransportZoneListener = new NeutronRouterDpnsToTransportZoneListener(dataBroker, nVpnMgr);
+
+ when(neutronvpnManager.updateSubnetmapNodeWithPorts(any(Uuid.class), any(Uuid.class), any(Uuid.class)))
+ .thenReturn(subnetMap);
+
+ when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ interfaceStateToTransportZoneChangeListener =
+ new InterfaceStateToTransportZoneListener(dataBroker, neutronvpnManager);
+ neutronRouterDpnsToTransportZoneListener =
+ new NeutronRouterDpnsToTransportZoneListener(dataBroker, neutronvpnManager);
}
-
+
@After
- public void afterTestCleanup(){
+ public void afterTestCleanup() {
expectedVteps.clear();
}
-
-
@Test
public void addInterfaceState_FirstTZ() throws Exception {
- List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface> interfaces = new ArrayList<>();
- interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder().setName(PORT_NAME)
- .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build()).build());
+ List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
+ .Interface> interfaces = new ArrayList<>();
+ interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
+ .interfaces.InterfaceBuilder().setName(PORT_NAME)
+ .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build())
+ .build());
interf = new InterfacesBuilder().setInterface(interfaces).build();
port = buildPort(PORT_IP);
buildNode();
- when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(interf))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(port))).
- thenReturn(Futures.immediateCheckedFuture(Optional.absent())).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(getBridgeRefForNode()))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(node))).
- thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(interf)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(port)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.absent()))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(getBridgeRefForNode())))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(node)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
InterfaceBuilder intBuilder = new InterfaceBuilder();
intBuilder.setName(PHYS_PORT_NAME);
- intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:"+DPN_ID})));//NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
+ intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:" + DPN_ID})));
+ //NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
expectedVteps.add(buildVtep(BigInteger.valueOf(DPN_ID), new IpAddress(OVS_IP.toCharArray()), VTEP_PORT));
interfaceStateToTransportZoneChangeListener.add(InstanceIdentifier.create(Interface.class), intBuilder.build());
}
-
+
@Test
public void addInterfaceState_ExistingTZ() throws Exception {
- List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface> interfaces = new ArrayList<>();
- interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder().setName(PORT_NAME)
- .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build()).build());
+ List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
+ .Interface> interfaces = new ArrayList<>();
+ interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
+ .interfaces.InterfaceBuilder().setName(PORT_NAME)
+ .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build())
+ .build());
interf = new InterfacesBuilder().setInterface(interfaces).build();
port = buildPort(PORT_IP);
network = buildNetwork(NetworkTypeVxlan.class);
- TransportZone tz = new TransportZoneBuilder().setZoneName(NETWORK_ID).setTunnelType(TunnelTypeVxlan.class).setSubnets(new ArrayList<>()).build();
+ TransportZone tz = new TransportZoneBuilder().setZoneName(NETWORK_ID)
+ .setTunnelType(TunnelTypeVxlan.class).setSubnets(new ArrayList<>()).build();
buildNode();
- when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(interf))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(port))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(network))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(tz))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(getBridgeRefForNode()))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(node))).
- thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(interf)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(port)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(network)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(tz)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(getBridgeRefForNode())))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(node)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
InterfaceBuilder intBuilder = new InterfaceBuilder();
intBuilder.setName(PHYS_PORT_NAME);
- intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:"+DPN_ID})));//NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
+ intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:" + DPN_ID})));
+ //NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
expectedVteps.add(buildVtep(BigInteger.valueOf(DPN_ID), new IpAddress(OVS_IP.toCharArray()), VTEP_PORT));
- interfaceStateToTransportZoneChangeListener.add(InstanceIdentifier.create(Interface.class), intBuilder.build());
+ interfaceStateToTransportZoneChangeListener.add(InstanceIdentifier.create(Interface.class),
+ intBuilder.build());
}
-
+
@Test
public void addInterfaceState_MultipleVtepsInTZ() throws Exception {
- List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface> interfaces = new ArrayList<>();
- interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder().setName(PORT_NAME)
- .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build()).build());
+ List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
+ .Interface> interfaces = new ArrayList<>();
+ interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
+ .interfaces.InterfaceBuilder().setName(PORT_NAME)
+ .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build())
+ .build());
interf = new InterfacesBuilder().setInterface(interfaces).build();
port = buildPort(PORT_IP);
network = buildNetwork(NetworkTypeVxlan.class);
- TransportZone tz = new TransportZoneBuilder().setZoneName(NETWORK_ID).setTunnelType(TunnelTypeVxlan.class).setSubnets(new ArrayList<>()).build();
+ TransportZone tz = new TransportZoneBuilder().setZoneName(NETWORK_ID)
+ .setTunnelType(TunnelTypeVxlan.class).setSubnets(new ArrayList<>()).build();
buildNode();
- when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(interf))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(port))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(network))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(tz))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(getBridgeRefForNode()))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(node))).
- thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(interf)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(port)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(network)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(tz)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(getBridgeRefForNode())))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(node)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
InterfaceBuilder intBuilder = new InterfaceBuilder();
intBuilder.setName(PHYS_PORT_NAME);
- intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:"+DPN_ID})));//NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
+ intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:" + DPN_ID})));
+ //NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
expectedVteps.add(buildVtep(BigInteger.valueOf(DPN_ID), new IpAddress(OVS_IP.toCharArray()), VTEP_PORT));
- interfaceStateToTransportZoneChangeListener.add(InstanceIdentifier.create(Interface.class), intBuilder.build());
+ interfaceStateToTransportZoneChangeListener.add(InstanceIdentifier.create(Interface.class),
+ intBuilder.build());
}
@Test
public void addInterfaceState_VLAN_Network() throws Exception {
- List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface> interfaces = new ArrayList<>();
- interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder().setName(PORT_NAME)
- .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build()).build());
+ List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
+ .Interface> interfaces = new ArrayList<>();
+ interfaces.add(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
+ .interfaces.InterfaceBuilder().setName(PORT_NAME)
+ .addAugmentation(ParentRefs.class, new ParentRefsBuilder().setParentInterface(PHYS_PORT_NAME).build())
+ .build());
interf = new InterfacesBuilder().setInterface(interfaces).build();
port = buildPort(PORT_IP);
network = buildNetwork(NetworkTypeVlan.class);
- TransportZone tz = new TransportZoneBuilder().setZoneName(NETWORK_ID).setTunnelType(TunnelTypeVxlan.class).setSubnets(buildSubnets()).build();
+ TransportZone tz = new TransportZoneBuilder().setZoneName(NETWORK_ID)
+ .setTunnelType(TunnelTypeVxlan.class).setSubnets(buildSubnets()).build();
buildNode();
- when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(interf))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(port))).
- thenReturn(Futures.immediateCheckedFuture(Optional.of(network)));
+ when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(interf)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(port)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.of(network)));
InterfaceBuilder intBuilder = new InterfaceBuilder();
intBuilder.setName(PHYS_PORT_NAME);
- intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:"+DPN_ID})));//NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
+ intBuilder.setLowerLayerIf(new ArrayList<>(Arrays.asList(new String[] {"int:" + DPN_ID})));
+ //NetworkId(new Uuid("12345678-1234-1234-1234-123456789012"));
interfaceStateToTransportZoneChangeListener.add(InstanceIdentifier.create(Interface.class), intBuilder.build());
}
-
+
@Test
public void addRouter() throws Exception {
- when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).
- thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ when(mockReadTx.<DataObject>read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
RouterDpnListBuilder intBuilder = new RouterDpnListBuilder();
RouterDpnList routerDpnList = buildRouterDpnList();
expectedVteps.add(buildVtep(BigInteger.valueOf(DPN_ID), new IpAddress(OVS_IP.toCharArray()), VTEP_PORT));
expectedVteps.add(buildVtep(DPN_ID_2, OVS_IP_2, VTEP_PORT));
neutronRouterDpnsToTransportZoneListener.add(InstanceIdentifier.create(RouterDpnList.class), routerDpnList);
}
-
+
private RouterDpnList buildRouterDpnList() {
RouterDpnListBuilder routerDpnBuilder = new RouterDpnListBuilder();
routerDpnBuilder.setRouterId(ROUTER_ID);
}
private List<Subnets> buildSubnets() {
- List<Subnets> subnets = new ArrayList<>();
SubnetsBuilder subnetsBuilder = new SubnetsBuilder();
List<Vteps> vteps = new ArrayList<Vteps>();
-
+
vteps.add(buildVtep(DPN_ID_2, OVS_IP_2, VTEP_PORT));
subnetsBuilder.setVteps(vteps);
subnetsBuilder.setPrefix(new IpPrefix(SUBNET.toCharArray()));
-
+ List<Subnets> subnets = new ArrayList<>();
subnets.add(subnetsBuilder.build());
return subnets;
}
-
-
private Vteps buildVtep(BigInteger dpnId, IpAddress portIp, String portName) {
VtepsBuilder vtepBuilder = new VtepsBuilder();
vtepBuilder.setDpnId(dpnId);
}
-
private BridgeRefEntry getBridgeRefForNode() {
BridgeRefEntryBuilder breb = new BridgeRefEntryBuilder();
- InstanceIdentifier<OvsdbBridgeAugmentation> path = InstanceIdentifier.create(Node.class).augmentation(OvsdbBridgeAugmentation.class);
+ InstanceIdentifier<OvsdbBridgeAugmentation> path =
+ InstanceIdentifier.create(Node.class).augmentation(OvsdbBridgeAugmentation.class);
breb.setBridgeReference(new OvsdbBridgeRef(path));
return breb.build();
}
private void buildNode() {
List<OpenvswitchOtherConfigs> list = new ArrayList<>();
- list.add(new OpenvswitchOtherConfigsBuilder().setOtherConfigKey("local_ip").setOtherConfigValue(OVS_IP).build());
+ list.add(new OpenvswitchOtherConfigsBuilder().setOtherConfigKey("local_ip")
+ .setOtherConfigValue(OVS_IP).build());
OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder().setOpenvswitchOtherConfigs(list).build();
- when(node.getAugmentation(OvsdbNodeAugmentation.class)).
- thenReturn(ovsdbNode);
+ when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
}
private Port buildPort(String portIp) {
PortBuilder portBuilder = new PortBuilder();
- portBuilder.setFixedIps(new ArrayList<>(Arrays.asList(new FixedIps[] {new FixedIpsBuilder().setIpAddress(new IpAddress(portIp.toCharArray())).build()})));
+ portBuilder.setFixedIps(new ArrayList<>(Arrays.asList(new FixedIps[]
+ {new FixedIpsBuilder().setIpAddress(new IpAddress(portIp.toCharArray())).build()})));
portBuilder.setNetworkId(new Uuid(NETWORK_ID));
return portBuilder.build();
}
-
+
protected void testTZ(InvocationOnMock invocation) {
TransportZones tzs = (TransportZones) invocation.getArguments()[2];
assertNotNull(tzs);
}
-
private void assertZoneName(String zoneName) {
assertEquals(NETWORK_ID, zoneName);
}
-
private void assertTunnelType(Class<? extends TunnelTypeBase> tunnelType) {
assertEquals(TunnelTypeVxlan.class, tunnelType);
}
-
private void assertSubnets(List<Subnets> subnets) {
assertNotNull(subnets);
assertEquals(1, subnets.size());
}
-
private void assertSubnet(Subnets subnets) {
assertEquals(new IpPrefix(SUBNET.toCharArray()), subnets.getPrefix());
assertNotNull(subnets.getVteps());
-
assertVtep(expectedVteps, subnets.getVteps());
-
}
-
-
private void assertVtep(List<Vteps> expectedVteps, List<Vteps> vteps) {
assertNotNull(vteps);
assertEquals(expectedVteps.size(), vteps.size());
- outer_loop: for(Vteps expectedVtep : expectedVteps){
- for(Vteps vtep : vteps){
+ outer_loop:
+ for (Vteps expectedVtep : expectedVteps) {
+ for (Vteps vtep : vteps) {
boolean flag = true;
flag &= expectedVtep.getDpnId().equals(vtep.getDpnId());
flag &= expectedVtep.getIpAddress().equals(vtep.getIpAddress());
flag &= expectedVtep.getPortname().equals(vtep.getPortname());
- if(flag){
+ if (flag) {
continue outer_loop;
}
}
fail();
}
}
-
}
package org.opendaylight.netvirt.neutronvpn.shell;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
@Command(scope = "vpnservice", name = "configure-l3vpn", description = "Create/Delete Neutron L3VPN")
public class ConfigureL3VpnCommand extends OsgiCommandSupport {
- final Logger Logger = LoggerFactory.getLogger(ConfigureL3VpnCommand.class);
-
+ private static final Logger LOG = LoggerFactory.getLogger(ConfigureL3VpnCommand.class);
private INeutronVpnManager neutronVpnManager;
private RpcProviderRegistry rpcProviderRegistry;
private NeutronvpnService neutronvpnService;
return null;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void createL3VpnCLI() {
if (vid == null) {
}
List<L3vpn> l3vpns = new ArrayList<>();
- L3vpn l3vpn = new L3vpnBuilder().setId(vuuid).setName(name).setRouteDistinguisher(rdList).setImportRT
- (irtList)
- .setExportRT(ertList).setTenantId(tuuid).build();
+ L3vpn l3vpn = new L3vpnBuilder().setId(vuuid).setName(name).setRouteDistinguisher(rdList)
+ .setImportRT(irtList).setExportRT(ertList).setTenantId(tuuid).build();
l3vpns.add(l3vpn);
Future<RpcResult<CreateL3VPNOutput>> result =
neutronvpnService.createL3VPN(new CreateL3VPNInputBuilder().setL3vpn(l3vpns).build());
RpcResult<CreateL3VPNOutput> rpcResult = result.get();
if (rpcResult.isSuccessful()) {
session.getConsole().println("L3VPN created successfully");
- Logger.trace("createl3vpn: {}", result);
+ LOG.trace("createl3vpn: {}", result);
} else {
session.getConsole().println("error populating createL3VPN : " + result.get().getErrors());
session.getConsole().println(getHelp("create"));
}
} catch (InterruptedException | ExecutionException e) {
- Logger.error("error populating createL3VPN", e);
+ LOG.error("error populating createL3VPN", e);
session.getConsole().println("error populating createL3VPN : " + e.getMessage());
session.getConsole().println(getHelp("create"));
}
}
} catch (Exception e) {
- Logger.error("error in adding subnet to VPN", e);
+ LOG.error("error in adding subnet to VPN", e);
session.getConsole().println("error in adding subnet to VPN : " + e.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void deleteL3VpnCLI() {
if (vid == null) {
}
}
} catch (Exception e) {
- Logger.error("error in deleting subnet from VPN", e);
+ LOG.error("error in deleting subnet from VPN", e);
session.getConsole().println("error in deleting subnet from VPN : " + e.getMessage());
}
RpcResult<DeleteL3VPNOutput> rpcResult = result.get();
if (rpcResult.isSuccessful()) {
session.getConsole().println("L3VPN deleted successfully");
- Logger.trace("deletel3vpn: {}", result);
+ LOG.trace("deletel3vpn: {}", result);
} else {
session.getConsole().println("error populating deleteL3VPN : " + result.get().getErrors());
session.getConsole().println(getHelp("delete"));
}
} catch (InterruptedException | ExecutionException e) {
- Logger.error("error populating deleteL3VPN", e);
+ LOG.error("error populating deleteL3VPN", e);
session.getConsole().println("error populating deleteL3VPN : " + e.getMessage());
session.getConsole().println(getHelp("delete"));
}
help.append("-rd/--rd <rd> -irt/--import-rts <irt1,irt2,..> -ert/--export-rts <ert1,ert2,..>\n");
help.append("[-sid/--subnet-uuid <subnet1,subnet2,..>]\n");
help.append("exec configure-vpn -op/--operation delete-l3-vpn -vid/--vpnid <id> \n");
+ break;
+ default:
+ break;
}
return help.toString();
}
package org.opendaylight.netvirt.neutronvpn.shell;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-
@Command(scope = "vpnservice", name = "dhcp-configure", description = "configuring parameters for DHCP Service")
public class DhcpConfigureCommand extends OsgiCommandSupport {
- final Logger Logger = LoggerFactory.getLogger(DhcpConfigureCommand.class);
+ private static final Logger LOG = LoggerFactory.getLogger(DhcpConfigureCommand.class);
- @Option(name = "-ld", aliases = {"--leaseDuration"}, description = "Lease Duration", required = false, multiValued = false)
+ @Option(name = "-ld", aliases = {"--leaseDuration"}, description = "Lease Duration", required = false,
+ multiValued = false)
Integer leaseDuration;
- @Option(name = "-dd", aliases = {"--defaultDomain"}, description = "Default Domain", required = false, multiValued = false)
+ @Option(name = "-dd", aliases = {"--defaultDomain"}, description = "Default Domain", required = false,
+ multiValued = false)
String defaultDomain;
private DataBroker dataBroker;
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected Object doExecute() throws Exception {
try {
if ((defaultDomain == null) && (leaseDuration == null)) {
}
Integer currLeaseDuration = defLeaseDuration;
String currDefDomain = defDomain;
- DhcpConfigBuilder dcBuilder = new DhcpConfigBuilder();
ConfigsBuilder dccBuilder = new ConfigsBuilder();
InstanceIdentifier<DhcpConfig> iid = InstanceIdentifier.create(DhcpConfig.class);
DhcpConfig currentConfig = read(iid);
- if (currentConfig != null && currentConfig.getConfigs() != null &&
- !currentConfig.getConfigs().isEmpty()) {
+ if (currentConfig != null && currentConfig.getConfigs() != null
+ && !currentConfig.getConfigs().isEmpty()) {
Configs dhcpConfig = currentConfig.getConfigs().get(0);
if (dhcpConfig.getLeaseDuration() != null) {
currLeaseDuration = dhcpConfig.getLeaseDuration();
dccBuilder.setDefaultDomain((defaultDomain == null) ? currDefDomain : defaultDomain);
List<Configs> configList = Arrays.asList(dccBuilder.build());
+ DhcpConfigBuilder dcBuilder = new DhcpConfigBuilder();
dcBuilder.setConfigs(configList);
write(iid, dcBuilder.build());
} catch (Exception e) {
session.getConsole().println("Failed to configure. Try again");
- Logger.error ("Failed to configure DHCP parameters",e);
+ LOG.error("Failed to configure DHCP parameters", e);
}
return null;
}
try {
futures.get();
} catch (InterruptedException | ExecutionException e) {
- Logger.error("Error writing to datastore (path, data) : ({}, {})", iid, dhcpConfig);
+ LOG.error("Error writing to datastore (path, data) : ({}, {})", iid, dhcpConfig);
throw new RuntimeException(e.getMessage());
}
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private DhcpConfig read(InstanceIdentifier<DhcpConfig> iid) {
ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
try {
result = tx.read(LogicalDatastoreType.CONFIGURATION, iid).get();
} catch (Exception e) {
- Logger.debug("DhcpConfig not present");
+ LOG.debug("DhcpConfig not present");
return null;
}
if (result.isPresent()) {
package org.opendaylight.netvirt.neutronvpn.shell;
+import com.google.common.base.Optional;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
@Command(scope = "vpnservice", name = "dhcp-show", description = "showing parameters for DHCP Service")
public class DhcpShowCommand extends OsgiCommandSupport {
- final Logger Logger = LoggerFactory.getLogger(DhcpShowCommand.class);
-
-
+ private static final Logger LOG = LoggerFactory.getLogger(DhcpShowCommand.class);
private DataBroker dataBroker;
Integer leaseDuration = null;
String defDomain = null;
}
@Override
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
protected Object doExecute() throws Exception {
try {
InstanceIdentifier<DhcpConfig> iid = InstanceIdentifier.create(DhcpConfig.class);
leaseDuration = dhcpConfig.getConfigs().get(0).getLeaseDuration();
defDomain = dhcpConfig.getConfigs().get(0).getDefaultDomain();
}
- session.getConsole().println("Lease Duration: " + ((leaseDuration != null) ? leaseDuration:86400));
- session.getConsole().println("Default Domain: " + ((defDomain != null) ? defDomain:"openstacklocal"));
+ session.getConsole().println("Lease Duration: " + ((leaseDuration != null) ? leaseDuration : 86400));
+ session.getConsole().println("Default Domain: " + ((defDomain != null) ? defDomain : "openstacklocal"));
} catch (Exception e) {
session.getConsole().println("Failed to fetch configuration parameters. Try again");
- Logger.error("Failed to fetch DHCP parameters",e);
+ LOG.error("Failed to fetch DHCP parameters",e);
}
return null;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private DhcpConfig read(InstanceIdentifier<DhcpConfig> iid) {
ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
package org.opendaylight.netvirt.neutronvpn.shell;
import com.google.common.base.Optional;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
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.netvirt.neutronvpn.rev150602.Subnetmaps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@Command(scope = "vpnservice", name = "subnet-show", description = "Comparison of data present in subnetMap and subnetOpDataEntry")
+@Command(scope = "vpnservice", name = "subnet-show",
+ description = "Comparison of data present in subnetMap and subnetOpDataEntry")
public class ShowSubnet extends OsgiCommandSupport {
- @Option(name = "--subnetmap", aliases = {"--subnetmap"}, description = "Display subnetMap details for given subnetId",
- required = false, multiValued = false)
+ @Option(name = "--subnetmap", aliases = {"--subnetmap"},
+ description = "Display subnetMap details for given subnetId", required = false, multiValued = false)
String subnetmap;
- @Option(name = "--subnetopdata", aliases = {"--subnetopdata"}, description = "Display subnetOpData details for given subnetId",
- required = false, multiValued = false)
+ @Option(name = "--subnetopdata", aliases = {"--subnetopdata"},
+ description = "Display subnetOpData details for given subnetId", required = false, multiValued = false)
String subnetopdata;
- final Logger LOG = LoggerFactory.getLogger(ShowSubnet.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ShowSubnet.class);
private DataBroker dataBroker;
List<Subnetmap> subnetmapList = new ArrayList<>();
Map<Uuid, SubnetOpDataEntry> subnetOpDataEntryMap = new HashMap<>();
}
@Override
- protected Object doExecute() throws Exception{
-
- try{
+ // TODO Clean up the console output
+ @SuppressWarnings({"checkstyle:IllegalCatch", "checkstyle:RegexpSinglelineJava"})
+ protected Object doExecute() throws Exception {
+ try {
if ((subnetmap == null) && (subnetopdata == null)) {
getSubnet();
System.out.println("Following subnetId is present in both subnetMap and subnetOpDataEntry\n");
- for (Subnetmap subnetmap : subnetmapList){
+ for (Subnetmap subnetmap : subnetmapList) {
SubnetOpDataEntry data = subnetOpDataEntryMap.get(subnetmap.getId());
if (data != null) {
System.out.println(subnetmap.getId().toString() + "\n");
}
}
getshowVpnCLIHelp();
- }else if (subnetmap == null && subnetopdata != null) {
- InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).
- child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(new Uuid(subnetopdata))).build();
+ } else if (subnetmap == null && subnetopdata != null) {
+ InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class)
+ .child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(new Uuid(subnetopdata))).build();
Optional<SubnetOpDataEntry> optionalSubs = read(LogicalDatastoreType.OPERATIONAL, subOpIdentifier);
SubnetOpDataEntry data = optionalSubs.get();
System.out.println("Fetching subnetmap for given subnetId\n");
System.out.println("------------------------------------------------------------------------------");
- System.out.println("Key: " + data.getKey() + "\n" + "VrfId: " + data.getVrfId() + "\n" + "ElanTag: " +
- "" + data.getElanTag() +"\n" + "NhDpnId: " + data.getNhDpnId() + "\n" + "RouteAdvState: " +
- data.getRouteAdvState() + "\n" + "SubnetCidr: " + data.getSubnetCidr() + "\n" +
- "SubnetToDpnList: " + data.getSubnetToDpn() + "\n" + "VpnName: " + data.getVpnName() + "\n");
+ System.out.println("Key: " + data.getKey() + "\n" + "VrfId: " + data.getVrfId() + "\n" + "ElanTag: "
+ + "" + data.getElanTag() + "\n" + "NhDpnId: " + data.getNhDpnId() + "\n" + "RouteAdvState: "
+ + data.getRouteAdvState() + "\n" + "SubnetCidr: " + data.getSubnetCidr() + "\n"
+ + "SubnetToDpnList: " + data.getSubnetToDpn() + "\n" + "VpnName: " + data.getVpnName() + "\n");
System.out.println("------------------------------------------------------------------------------");
- }else if (subnetmap != null && subnetopdata == null) {
+ } else if (subnetmap != null && subnetopdata == null) {
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(new Uuid(subnetmap))).build();
Optional<Subnetmap> sn = read(LogicalDatastoreType.CONFIGURATION, id);
Subnetmap data = sn.get();
System.out.println("Fetching subnetopdataentry for given subnetId\n");
System.out.println("------------------------------------------------------------------------------");
- System.out.println("Key: " + data.getKey() + "\n" + "VpnId: " + data.getVpnId() + "\n" +
- "DirectPortList: " + data.getDirectPortList() + "\n" + "NetworkId: " + data.getNetworkId()
- + "\n" + "PortList: " + data.getPortList() + "\n" + "RouterInterfaceFixedIps: " + data
- .getRouterInterfaceFixedIps() + "\n" + "RouterInterfaceName: " + data.getRouterInterfaceName
- () + "\n" + "RouterIntfMacAddress: " + data.getRouterIntfMacAddress() + "\n" + "SubnetIp: "
- + data.getSubnetIp() + "\n" + "TenantId: " + data.getTenantId() + "\n");
+ System.out.println("Key: " + data.getKey() + "\n" + "VpnId: " + data.getVpnId() + "\n"
+ + "DirectPortList: " + data.getDirectPortList() + "\n" + "NetworkId: " + data.getNetworkId()
+ + "\n" + "PortList: " + data.getPortList() + "\n" + "RouterInterfaceFixedIps: "
+ + data.getRouterInterfaceFixedIps() + "\n" + "RouterInterfaceName: "
+ + data.getRouterInterfaceName() + "\n" + "RouterIntfMacAddress: " + data.getRouterIntfMacAddress()
+ + "\n" + "SubnetIp: "
+ + data.getSubnetIp() + "\n" + "TenantId: " + data.getTenantId() + "\n");
System.out.println("------------------------------------------------------------------------------");
}
- }catch (Exception e) {
+ } catch (Exception e) {
System.out.println("Error fetching data for given subnetId ");
LOG.error("Error Fetching Data",e);
}
return null;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
return result;
}
- private void getSubnet(){
-
+ // TODO Clean up the console output
+ @SuppressWarnings("checkstyle:RegexpSinglelineJava")
+ private void getSubnet() {
List<SubnetOpDataEntry> subnetOpDataEntryList = new ArrayList<>();
InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
InstanceIdentifier<SubnetOpData> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).build();
Optional<Subnetmaps> optionalSubnetmaps = read(LogicalDatastoreType.CONFIGURATION, subnetmapsid);
if (!optionalSubnetmaps.isPresent()) {
System.out.println("No Subnetmaps configured.");
- }else{
+ } else {
subnetmapList = optionalSubnetmaps.get().getSubnetmap();
}
Optional<SubnetOpData> optionalSubnetOpData = read(LogicalDatastoreType.OPERATIONAL, subOpIdentifier);
if (!optionalSubnetOpData.isPresent()) {
System.out.println("No SubnetOpData configured.");
- }else{
+ } else {
subnetOpDataEntryList = optionalSubnetOpData.get().getSubnetOpDataEntry();
}
}
}
+ // TODO Clean up the console output
+ @SuppressWarnings("checkstyle:RegexpSinglelineJava")
private void getshowVpnCLIHelp() {
- System.out.println("\nUsage 1: " + "To display subnetMaps for a given subnetId subnet-show --subnetmap [<subnetId>]\n");
- System.out.println("Usage 2: " + "To display subnetOpDataEntry for a given subnetId subnet-show --subnetopdata [<subnetId>]");
+ System.out.println("\n Usage 1: "
+ + "To display subnetMaps for a given subnetId subnet-show --subnetmap [<subnetId>]");
+ System.out.println("\nUsage 2: "
+ + "To display subnetOpDataEntry for a given subnetId subnet-show --subnetopdata [<subnetId>]");
}
-
}
package org.opendaylight.netvirt.neutronvpn.shell;
import com.google.common.base.Optional;
+import java.util.ArrayList;
+import java.util.List;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.List;
-
-@Command(scope = "vpnservice", name = "vpn-ipaddress-to-port-show", description = "Displays the IPAddresses and Ports on which they are configured (or) discovered for VPN Instance(s)")
+@Command(scope = "vpnservice", name = "vpn-ipaddress-to-port-show",
+ description = "Displays the IPAddresses and Ports on which they are configured (or) discovered for "
+ + "VPN Instance(s)")
public class ShowVpnIpToPort extends OsgiCommandSupport {
- @Argument(index = 0, name = "--vpn-name", description = "Name of the Vpn Instance", required = false, multiValued = false)
+ @Argument(index = 0, name = "--vpn-name", description = "Name of the Vpn Instance", required = false,
+ multiValued = false)
private String vpnName;
- @Argument(index = 1, name = "--ip-address", description = "Ip address to search for in the Vpn Instance", required = false, multiValued = false)
+ @Argument(index = 1, name = "--ip-address", description = "Ip address to search for in the Vpn Instance",
+ required = false, multiValued = false)
private String portFixedIp;
- final Logger LOG = LoggerFactory.getLogger(ShowVpnIpToPort.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ShowVpnIpToPort.class);
private DataBroker dataBroker;
List<VpnPortipToPort> vpnPortipToPortList = new ArrayList<>();
List<LearntVpnVipToPort> vpnVipToPortList = new ArrayList<>();
public void setDataBroker(DataBroker broker) {
this.dataBroker = broker;
}
- @Override
- protected Object doExecute() throws Exception{
- try{
+ @Override
+ // TODO Clean up the exception handling and the console output
+ @SuppressWarnings({"checkstyle:IllegalCatch", "checkstyle:RegexpSinglelineJava"})
+ protected Object doExecute() throws Exception {
+ try {
if (vpnName == null && portFixedIp == null) {
getNeutronVpnPort();
getLearntVpnVipPort();
System.out.println(vpnPortipToPortList.size() + " Entries are present: ");
System.out.println("-----------------------------------------------------------------------");
- System.out.println(String.format(" %s %24s %20s %32s", "VpnName", "IPAddress", "MacAddress", "Port"));
+ System.out.println(String.format(" %s %24s %20s %32s", "VpnName", "IPAddress",
+ "MacAddress", "Port"));
System.out.println("-----------------------------------------------------------------------");
- for (VpnPortipToPort vpnPortipToPort : vpnPortipToPortList){
+ for (VpnPortipToPort vpnPortipToPort : vpnPortipToPortList) {
System.out.println(String.format(" %-32s %-16s %-16s %-32s", vpnPortipToPort.getVpnName(),
vpnPortipToPort.getPortFixedip(),
vpnPortipToPort.getMacAddress(),
vpnPortipToPort.getPortName()));
}
- for (LearntVpnVipToPort learntVpnVipToPort : vpnVipToPortList){
+ for (LearntVpnVipToPort learntVpnVipToPort : vpnVipToPortList) {
System.out.println(String.format("* %-32s %-16s %-16s %-32s", learntVpnVipToPort.getVpnName(),
learntVpnVipToPort.getPortFixedip(),
learntVpnVipToPort.getMacAddress(),
}
System.out.println("\n * prefixed entries are Learned.");
System.out.println("\n" + getshowVpnCLIHelp());
- }else if (portFixedIp == null || vpnName == null) {
- System.out.println("Insufficient arguments" + "\nCorrect Usage : neutronvpn-port-show [<vpnName> <portFixedIp>]");
- }else{
- InstanceIdentifier<VpnPortipToPort> id = InstanceIdentifier.builder(NeutronVpnPortipPortData.class).child
- (VpnPortipToPort.class, new VpnPortipToPortKey(portFixedIp, vpnName)).build();
+ } else if (portFixedIp == null || vpnName == null) {
+ System.out.println("Insufficient arguments"
+ + "\nCorrect Usage : neutronvpn-port-show [<vpnName> <portFixedIp>]");
+ } else {
+ InstanceIdentifier<VpnPortipToPort> id =
+ InstanceIdentifier.builder(NeutronVpnPortipPortData.class)
+ .child(VpnPortipToPort.class, new VpnPortipToPortKey(portFixedIp, vpnName)).build();
Optional<VpnPortipToPort> vpnPortipToPortData = read(LogicalDatastoreType.CONFIGURATION, id);
if (vpnPortipToPortData.isPresent()) {
VpnPortipToPort data = vpnPortipToPortData.get();
- System.out.println("\n-------------------------------------------------------------------------------------------");
- System.out.println("VpnName: " + data.getVpnName() + "\nIPAddress: " + data.getPortFixedip() + "\nMacAddress: " +
- data.getMacAddress() + "\nPort: " + data.getPortName());
- System.out.println("-------------------------------------------------------------------------------------------");
+ System.out.println("\n----------"
+ + "---------------------------------------------------------------------------------");
+ System.out.println("VpnName: " + data.getVpnName() + "\nIPAddress: " + data.getPortFixedip()
+ + "\nMacAddress: " + data.getMacAddress() + "\nPort: " + data.getPortName());
+ System.out.println("\n----------"
+ + "---------------------------------------------------------------------------------");
} else {
- InstanceIdentifier<LearntVpnVipToPort> learntId = InstanceIdentifier.builder(LearntVpnVipToPortData.class).child
- (LearntVpnVipToPort.class, new LearntVpnVipToPortKey(portFixedIp, vpnName)).build();
- Optional<LearntVpnVipToPort> learntVpnVipToPortData = read(LogicalDatastoreType.OPERATIONAL, learntId);
+ InstanceIdentifier<LearntVpnVipToPort> learntId =
+ InstanceIdentifier.builder(LearntVpnVipToPortData.class)
+ .child(LearntVpnVipToPort.class, new LearntVpnVipToPortKey(portFixedIp, vpnName)).build();
+ Optional<LearntVpnVipToPort> learntVpnVipToPortData =
+ read(LogicalDatastoreType.OPERATIONAL, learntId);
if (!learntVpnVipToPortData.isPresent()) {
System.out.println("Data not available");
return null;
}
LearntVpnVipToPort data = learntVpnVipToPortData.get();
- System.out.println("\n-------------------------------------------------------------------------------------------");
- System.out.println("VpnName: * " + data.getVpnName() + "\nIPAddress: " + data.getPortFixedip() + "\nMacAddress: " +
- data.getMacAddress() + "\nPort: " + data.getPortName());
- System.out.println("-------------------------------------------------------------------------------------------");
+ System.out.println("\n----------"
+ + "---------------------------------------------------------------------------------");
+ System.out.println("VpnName: * " + data.getVpnName() + "\nIPAddress: " + data.getPortFixedip()
+ + "\nMacAddress: " + data.getMacAddress() + "\nPort: " + data.getPortName());
+ System.out.println("\n----------"
+ + "---------------------------------------------------------------------------------");
}
System.out.println("\n" + getshowVpnCLIHelp());
}
} catch (Exception e) {
- System.out.println("Error fetching vpnToPortData for [vpnName=" + vpnName + ", portFixedip=" + portFixedIp + "]");
- LOG.error("Error Fetching Data ",e);
+ System.out.println("Error fetching vpnToPortData for [vpnName=" + vpnName + ", portFixedip="
+ + portFixedIp + "]");
+ LOG.error("Error Fetching Data ", e);
}
return null;
}
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
return result;
}
- private void getNeutronVpnPort(){
+ // TODO Clean up the console output
+ @SuppressWarnings("checkstyle:RegexpSinglelineJava")
+ private void getNeutronVpnPort() {
InstanceIdentifier<NeutronVpnPortipPortData> neutronVpnPortipPortDataIdentifier = InstanceIdentifier
.builder(NeutronVpnPortipPortData.class).build();
Optional<NeutronVpnPortipPortData> optionalNeutronVpnPort = read(LogicalDatastoreType.CONFIGURATION,
}
}
- private void getLearntVpnVipPort(){
-
+ // TODO Clean up the console output
+ @SuppressWarnings("checkstyle:RegexpSinglelineJava")
+ private void getLearntVpnVipPort() {
InstanceIdentifier<LearntVpnVipToPortData> learntVpnVipPortDataIdentifier = InstanceIdentifier
.builder(LearntVpnVipToPortData.class).build();
Optional<LearntVpnVipToPortData> optionalLearntVpnPort = read(LogicalDatastoreType.OPERATIONAL,
private String getshowVpnCLIHelp() {
StringBuilder help = new StringBuilder("Usage:");
- help.append("To display ports and their associated vpn instances neutronvpn-port-show [<vpnName> <portFixedIp>].\n");
+ help.append("To display ports and their associated vpn instances "
+ + "neutronvpn-port-show [<vpnName> <portFixedIp>].\n");
return help.toString();
}
}
Code Review / netvirt.git / commitdiff