LOG.error("getEgressActionsForInterface: RPC Call to Get egress actions for interface {} "
+ "returned with Errors {}", ifName, result.getErrors());
} else {
- listActions = ((GetEgressActionsForTunnelOutput) result.getResult()).getAction();
+ listActions = ((GetEgressActionsForTunnelOutput) result.getResult()).nonnullAction();
}
return new ArrayList<Action>(listActions.values());
} catch (InterruptedException | ExecutionException e) {
ElanDpnInterfacesList existingElanDpnInterfaces = SingleTransactionDataBroker.syncRead(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (existingElanDpnInterfaces != null) {
- return new ArrayList<DpnInterfaces>(existingElanDpnInterfaces.getDpnInterfaces().values()).stream()
+ return new ArrayList<DpnInterfaces>(existingElanDpnInterfaces.nonnullDpnInterfaces().values()).stream()
.flatMap(v -> v.getInterfaces().stream()).collect(Collectors.toList());
}
} catch (ExpectedDataObjectNotFoundException e) {
InstanceIdentifier.builder(ElanInstances.class).build()).get();
if (elanInstancesOptional.isPresent() && elanInstancesOptional.get().getElanInstance() != null) {
- for (ElanInstance elanInstance : elanInstancesOptional.get().getElanInstance().values()) {
+ for (ElanInstance elanInstance : elanInstancesOptional.get().nonnullElanInstance().values()) {
elanInstanceMap.put(elanInstance.getElanInstanceName(), elanInstance);
}
}
private static boolean containsLogicalSwitch(Node node) {
if (node == null || node.augmentation(HwvtepGlobalAugmentation.class) == null
|| HwvtepHAUtil.isEmptyList(
- new ArrayList(node.augmentation(HwvtepGlobalAugmentation.class).getLogicalSwitches().values()))) {
+ new ArrayList(node.augmentation(HwvtepGlobalAugmentation.class).nonnullLogicalSwitches().values()))) {
return false;
}
return true;
return false;
}
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
- .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.getInterfaces().values()) {
+ .l2gateway.attributes.devices.Interfaces deviceInterface : hwVtepDevice.nonnullInterfaces().values()) {
NodeId switchNodeId = HwvtepSouthboundUtils.createManagedNodeId(nodeId, hwVtepDevice.getDeviceName());
InstanceIdentifier<Node> physicalSwitchNodeIid = topoIid.child(Node.class, new NodeKey(switchNodeId));
HwvtepPhysicalPortAugmentation portAugmentation = configTerminationPoint.augmentation(
HwvtepPhysicalPortAugmentation.class);
if (portAugmentation == null || HwvtepHAUtil.isEmptyList(
- new ArrayList(portAugmentation.getVlanBindings().values()))) {
+ new ArrayList(portAugmentation.nonnullVlanBindings().values()))) {
pw.println("Failed to find the config vlan bindings for port " + deviceInterface.getInterfaceName()
+ " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
+ " nodeid " + nodeId.getValue());
}
portAugmentation = operationalTerminationPoint.augmentation(HwvtepPhysicalPortAugmentation.class);
if (portAugmentation == null || HwvtepHAUtil.isEmptyList(
- new ArrayList(portAugmentation.getVlanBindings().values()))) {
+ new ArrayList(portAugmentation.nonnullVlanBindings().values()))) {
pw.println("Failed to find the operational vlan bindings for port " + deviceInterface.getInterfaceName()
+ " for node " + hwVtepDevice.getDeviceName() + " for logical switch " + logicalSwitchName
+ " nodeid " + nodeId.getValue());
LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(ElanInstances.class).build());
if (elanInstancesOptional.isPresent()) {
- Map<ElanInstanceKey, ElanInstance> elans = elanInstancesOptional.get().getElanInstance();
+ Map<ElanInstanceKey, ElanInstance> elans = elanInstancesOptional.get().nonnullElanInstance();
if (elans != null) {
for (ElanInstance elan : elans.values()) {
networks.add(elan.getElanInstanceName());
return;
}
Map<RemoteUcastMacsKey, RemoteUcastMacs> remoteUcastMacs =
- hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getRemoteUcastMacs();
+ hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).nonnullRemoteUcastMacs();
if (remoteUcastMacs == null || remoteUcastMacs.isEmpty()) {
return;
}
return;
}
Map<LocalUcastMacsKey, LocalUcastMacs> localUcastMacs =
- hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getLocalUcastMacs();
+ hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).nonnullLocalUcastMacs();
if (localUcastMacs == null || localUcastMacs.isEmpty()) {
return;
}
return;
}
Map<LocalMcastMacsKey, LocalMcastMacs> localMcastMacs =
- hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getLocalMcastMacs();
+ hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).nonnullLocalMcastMacs();
if (localMcastMacs == null || localMcastMacs.isEmpty()) {
return;
}
return;
}
Map<RemoteMcastMacsKey, RemoteMcastMacs> remoteMcastMacs =
- hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getRemoteMcastMacs();
+ hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).nonnullRemoteMcastMacs();
if (remoteMcastMacs == null || remoteMcastMacs.isEmpty()) {
return;
}
if (psNode == null) {
return;
}
- Map<TerminationPointKey, TerminationPoint> terminationPoints = psNode.getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> terminationPoints = psNode.nonnullTerminationPoint();
if (terminationPoints == null || terminationPoints.isEmpty()) {
return;
}
Node getPSnode(Node hwvtepNode, LogicalDatastoreType datastoreType) throws ExecutionException,
InterruptedException {
if (hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) != null) {
- Map<SwitchesKey, Switches> switches = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
+ Map<SwitchesKey, Switches> switches = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class)
+ .nonnullSwitches();
if (switches != null) {
return HwvtepUtils.getHwVtepNode(dataBroker, datastoreType,
switches.values().iterator().next().getSwitchRef().getValue().firstKeyOf(Node.class).getNodeId());
if (!vrfTablesOptional.isPresent()) {
return null;
}
- Map<MacVrfEntryKey, MacVrfEntry> keyMacVrfEntryMap = vrfTablesOptional.get().getMacVrfEntry();
+ Map<MacVrfEntryKey, MacVrfEntry> keyMacVrfEntryMap = vrfTablesOptional.get().nonnullMacVrfEntry();
if (keyMacVrfEntryMap == null || keyMacVrfEntryMap.isEmpty()) {
return null;
}
List<DpnInterfaces> dpnInterfaceLists = elanUtils.getElanDPNByName(elanName);
if (checkEvpnAttachedToNet(elanName)) {
//TODO(Riyaz) : Check if accessing first nexthop address is right solution
- String nexthopIP = new ArrayList<RoutePaths>(macVrfEntry.getRoutePaths().values())
+ String nexthopIP = new ArrayList<RoutePaths>(macVrfEntry.nonnullRoutePaths().values())
.get(0).getNexthopAddress();
IpAddress ipAddress = new IpAddress(new Ipv4Address(nexthopIP));
Uint32 elanTag = getElanTagByMacvrfiid(instanceIdentifier);
//if (checkEvpnAttachedToNet(elanName)) {
//TODO(Riyaz) : Check if accessing first nexthop address is right
- String nexthopIP = new ArrayList<RoutePaths>(macVrfEntry.getRoutePaths().values()).get(0).getNexthopAddress();
+ String nexthopIP = new ArrayList<RoutePaths>(macVrfEntry.nonnullRoutePaths().values())
+ .get(0).getNexthopAddress();
IpAddress ipAddress = new IpAddress(new Ipv4Address(nexthopIP));
Uint32 elanTag = getElanTagByMacvrfiid(instanceIdentifier);
if (elanTag == null) {
LOG.debug("RoutePaths is null or empty for macvrfentry {}", macVrfEntry);
return null;
}
- return new ArrayList<RoutePaths>(macVrfEntry.getRoutePaths().values()).get(0).getNexthopAddress();
+ return new ArrayList<RoutePaths>(macVrfEntry.nonnullRoutePaths().values()).get(0).getNexthopAddress();
}
public void removeEvpnDmacFlowOnDetach(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry,
if (bridgeAug != null) {
DatapathId dpId = bridgeAug.getDatapathId();
if (dpId != null) {
- otherConfigs = new ArrayList<>(bridgeAug.getBridgeOtherConfigs().values());
+ otherConfigs = new ArrayList<>(bridgeAug.nonnullBridgeOtherConfigs().values());
if (otherConfigs == null) {
otherConfigs = Lists.newArrayList();
}
LOG.debug("Removing the Interface:{} from elan:{}", interfaceName, elanName);
if (interfaceInfo != null) {
if (existingElanInterfaceMac.isPresent()) {
- Map<MacEntryKey, MacEntry> existingMacEntries = existingElanInterfaceMac.get().getMacEntry();
+ Map<MacEntryKey, MacEntry> existingMacEntries =
+ existingElanInterfaceMac.get().nonnullMacEntry();
if (existingMacEntries != null) {
List<PhysAddress> macAddresses = new ArrayList<>();
for (MacEntry macEntry : existingMacEntries.values()) {
} else if (existingElanInterfaceMac.isPresent()) {
// Interface does not exist in ConfigDS, so lets remove everything
// about that interface related to Elan
- Map<MacEntryKey, MacEntry> macEntries = existingElanInterfaceMac.get().getMacEntry();
+ Map<MacEntryKey, MacEntry> macEntries = existingElanInterfaceMac.get().nonnullMacEntry();
if (macEntries != null) {
for (MacEntry macEntry : macEntries.values()) {
PhysAddress macAddress = macEntry.getMacAddress();
if (macs == null || macs.getMacEntry() == null) {
continue;
}
- for (MacEntry mac : new ArrayList<MacEntry>(macs.getMacEntry().values())) {
+ for (MacEntry mac : new ArrayList<MacEntry>(macs.nonnullMacEntry().values())) {
removeTheMacFlowInTheDPN(dpId, elanTag, mac, confTx);
removeEtreeMacFlowInTheDPN(dpId, elanTag, mac, confTx);
}
EVENT_LOGGER.debug("ELAN-Interface, UPDATE {} Instance {}", original.getName(), elanName);
List<StaticMacEntries> originalStaticMacEntries = new ArrayList<StaticMacEntries>(original
- .getStaticMacEntries().values());
+ .nonnullStaticMacEntries().values());
List<StaticMacEntries> updatedStaticMacEntries = new ArrayList<StaticMacEntries>(update
- .getStaticMacEntries().values());
+ .nonnullStaticMacEntries().values());
List<StaticMacEntries> deletedEntries = ElanUtils.diffOf(originalStaticMacEntries, updatedStaticMacEntries);
List<StaticMacEntries> updatedEntries = ElanUtils.diffOf(updatedStaticMacEntries, originalStaticMacEntries);
.getElanDpnInterfacesList(elanInstance.getElanInstanceName());
List<DpnInterfaces> dpnInterfaceLists = null;
if (elanDpnInterfacesList != null) {
- dpnInterfaceLists = new ArrayList<DpnInterfaces>(elanDpnInterfacesList.getDpnInterfaces().values());
+ dpnInterfaceLists = new ArrayList<DpnInterfaces>(elanDpnInterfacesList.nonnullDpnInterfaces().values());
}
if (dpnInterfaceLists != null && !dpnInterfaceLists.isEmpty()) {
Uint64 dstDpId = interfaceInfo.getDpId();
installEntriesForElanInterface(elanInstance, elanInterface, interfaceInfo,
isFirstInterfaceInDpn, confTx);
- Map<StaticMacEntriesKey, StaticMacEntries> staticMacEntriesList = elanInterface.getStaticMacEntries();
+ Map<StaticMacEntriesKey, StaticMacEntries> staticMacEntriesList =
+ elanInterface.nonnullStaticMacEntries();
List<PhysAddress> staticMacAddresses = Lists.newArrayList();
if (ElanUtils.isNotEmpty(staticMacEntriesList.values())) {
String interfaceName = interfaceInfo.getInterfaceName();
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(interfaceName);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
- Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.getMacEntry();
+ Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.nonnullMacEntry();
return Collections.singletonList(ElanUtils.waitForTransactionToComplete(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
for (MacEntry macEntry : macEntries.values()) {
LOG.debug("Ignoring internal tunnel state event for Flat/Vlan elan {}", elanName);
continue;
}
- Map<DpnInterfacesKey, DpnInterfaces> dpnInterfaces = elanDpns.getDpnInterfaces();
+ Map<DpnInterfacesKey, DpnInterfaces> dpnInterfaces = elanDpns.nonnullDpnInterfaces();
if (dpnInterfaces == null) {
continue;
}
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null
&& elanInterfaceMac.getMacEntry().size() > 0) {
- macAddress.addAll(elanInterfaceMac.getMacEntry().values());
+ macAddress.addAll(elanInterfaceMac.nonnullMacEntry().values());
}
}
}
for (String elanInterface : elanInterfaces) {
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac.getMacEntry() != null && elanInterfaceMac.getMacEntry().size() > 0) {
- Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.getMacEntry();
+ Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.nonnullMacEntry();
for (MacEntry macEntry : macEntries.values()) {
deleteStaticMacAddress(elanInterface, macEntry.getMacAddress().getValue());
}
InstanceIdentifier<ElanInstances> elanInstancesIdentifier = InstanceIdentifier.builder(ElanInstances.class)
.build();
return new ArrayList<>(ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).map(
- ElanInstances::getElanInstance).orElse(emptyMap()).values());
+ ElanInstances::nonnullElanInstance).orElse(emptyMap()).values());
}
@Override
boolean shouldCreateVtep;
if (original.getVpnInterfaces() != null && !original.getVpnInterfaces().isEmpty()) {
shouldCreateVtep = transportZoneNotificationUtil
- .shouldCreateVtep(update.getVpnInterfaces().values().stream()
- .filter(vi -> !original.getVpnInterfaces().values().contains(vi)).collect(Collectors.toList()));
+ .shouldCreateVtep(update.nonnullVpnInterfaces().values().stream()
+ .filter(vi -> !original.nonnullVpnInterfaces().values().contains(vi)).collect(Collectors.toList()));
} else {
shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(
- new ArrayList<>(update.getVpnInterfaces().values()));
+ new ArrayList<>(update.nonnullVpnInterfaces().values()));
}
if (shouldCreateVtep) {
LOG.debug("Vpn dpn {} add detected, updating transport zones", add.getDpnId());
boolean shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(
- new ArrayList<>(add.getVpnInterfaces().values()));
+ new ArrayList<>(add.nonnullVpnInterfaces().values()));
if (shouldCreateVtep) {
String vrfId = identifier.firstKeyOf(VpnInstanceOpDataEntry.class).getVrfId();
transportZoneNotificationUtil.updateTransportZone(vrfId, add.getDpnId());
}
HwvtepGlobalAugmentation globalAugmentation = node.augmentation(HwvtepGlobalAugmentation.class);
if (globalAugmentation != null) {
- List<Managers> managers = new ArrayList<Managers>(globalAugmentation.getManagers().values());
+ List<Managers> managers = new ArrayList<Managers>(globalAugmentation.nonnullManagers().values());
if (managers != null && !managers.isEmpty() && managers.get(0).getManagerOtherConfigs() != null) {
- for (ManagerOtherConfigs configs : managers.get(0).getManagerOtherConfigs().values()) {
+ for (ManagerOtherConfigs configs : managers.get(0).nonnullManagerOtherConfigs().values()) {
if (HA_ID.equals(configs.getOtherConfigKey())) {
return configs.getOtherConfigValue();
}
haGlobalConfigNodeOptional.get().augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getManagers() != null
&& augmentation.getManagers().size() > 0) {
- Managers managers = new ArrayList<Managers>(augmentation.getManagers().values()).get(0);
+ Managers managers = new ArrayList<Managers>(augmentation.nonnullManagers().values()).get(0);
if (null == managers.getManagerOtherConfigs()) {
return childNodeIds;
}
- for (ManagerOtherConfigs otherConfigs : managers.getManagerOtherConfigs().values()) {
+ for (ManagerOtherConfigs otherConfigs : managers.nonnullManagerOtherConfigs().values()) {
if (HA_CHILDREN.equals(otherConfigs.getOtherConfigKey())) {
String nodeIdsVal = otherConfigs.getOtherConfigValue();
if (nodeIdsVal != null) {
if (!switchesAlreadyPresent) {
HwvtepGlobalAugmentation augmentation = childNode.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getSwitches() != null) {
- List<Switches> src = new ArrayList<Switches>(augmentation.getSwitches().values());
+ List<Switches> src = new ArrayList<Switches>(augmentation.nonnullSwitches().values());
if (src != null && src.size() > 0) {
psList.add(new SwitchesCmd().transform(haNodePath, src.get(0)));
}
return;
}
HashMap<InstanceIdentifier<Node>,Boolean> deleted = new HashMap<>();
- Map<SwitchesKey, Switches> switches = globalAugmentation.getSwitches();
+ Map<SwitchesKey, Switches> switches = globalAugmentation.nonnullSwitches();
if (switches != null) {
for (Switches switche : switches.values()) {
InstanceIdentifier<Node> psId = (InstanceIdentifier<Node>)switche.getSwitchRef().getValue();
if (topologyOptional.isPresent()) {
Topology topology = topologyOptional.get();
if (topology.getNode() != null) {
- for (Node psNode : topology.getNode().values()) {
+ for (Node psNode : topology.nonnullNode().values()) {
PhysicalSwitchAugmentation ps = psNode.augmentation(PhysicalSwitchAugmentation.class);
if (ps != null) {
InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>)ps.getManagedBy().getValue();
@Nullable
public List<LocalMcastMacs> getData(HwvtepGlobalAugmentation node) {
if (node != null && node.getLocalMcastMacs() != null) {
- return new ArrayList<LocalMcastMacs>(node.getLocalMcastMacs().values());
+ return new ArrayList<LocalMcastMacs>(node.nonnullLocalMcastMacs().values());
}
return null;
}
@Nullable
public List<LocalUcastMacs> getData(HwvtepGlobalAugmentation node) {
if (node != null && node.getLocalUcastMacs() != null) {
- return new ArrayList<LocalUcastMacs>(node.getLocalUcastMacs().values());
+ return new ArrayList<LocalUcastMacs>(node.nonnullLocalUcastMacs().values());
}
return null;
}
@Nullable
public List<LogicalSwitches> getData(HwvtepGlobalAugmentation node) {
if (node != null && node.getLogicalSwitches() != null) {
- return new ArrayList<LogicalSwitches>(node.getLogicalSwitches().values());
+ return new ArrayList<LogicalSwitches>(node.nonnullLogicalSwitches().values());
}
return null;
}
@Nullable
public List<TerminationPoint> getData(Node node) {
if (node != null && node.getTerminationPoint() != null) {
- return new ArrayList<TerminationPoint>(node.getTerminationPoint().values());
+ return new ArrayList<TerminationPoint>(node.nonnullTerminationPoint().values());
}
return null;
}
@Override
@Nullable
public List<RemoteMcastMacs> getData(HwvtepGlobalAugmentation augmentation) {
- if (augmentation != null && augmentation.getRemoteMcastMacs() != null) {
- return new ArrayList<RemoteMcastMacs>(augmentation.getRemoteMcastMacs().values());
+ if (augmentation != null && augmentation.nonnullRemoteMcastMacs() != null) {
+ return new ArrayList<RemoteMcastMacs>(augmentation.nonnullRemoteMcastMacs().values());
}
return null;
}
@Override
@Nullable
public List<RemoteUcastMacs> getData(HwvtepGlobalAugmentation node) {
- if (node != null && node.getRemoteUcastMacs() != null) {
- return new ArrayList<RemoteUcastMacs>(node.getRemoteUcastMacs().values());
+ if (node != null && node.nonnullRemoteUcastMacs() != null) {
+ return new ArrayList<RemoteUcastMacs>(node.nonnullRemoteUcastMacs().values());
}
return null;
}
@Override
@Nullable
public List<Switches> getData(HwvtepGlobalAugmentation node) {
- if (node != null && node.getSwitches() != null) {
- return new ArrayList<Switches>(node.getSwitches().values());
+ if (node != null && node.nonnullSwitches() != null) {
+ return new ArrayList<Switches>(node.nonnullSwitches().values());
}
return null;
}
@Override
@Nullable
public List<TerminationPoint> getData(Node node) {
- if (node != null && node.getTerminationPoint() != null) {
- return new ArrayList<TerminationPoint>(node.getTerminationPoint().values());
+ if (node != null && node.nonnullTerminationPoint() != null) {
+ return new ArrayList<TerminationPoint>(node.nonnullTerminationPoint().values());
}
return null;
}
new HwvtepPhysicalPortAugmentationBuilder(augmentation);
if (augmentation.getVlanBindings() != null && augmentation.getVlanBindings().size() > 0) {
- tpAugmentationBuilder.setVlanBindings(augmentation.getVlanBindings().values().stream().map(
+ tpAugmentationBuilder.setVlanBindings(augmentation.nonnullVlanBindings().values().stream().map(
vlanBindings -> {
VlanBindingsBuilder vlanBindingsBuilder = new VlanBindingsBuilder(vlanBindings);
vlanBindingsBuilder.setLogicalSwitchRef(
.augmentation(HwvtepPhysicalPortAugmentation.class);
HwvtepPhysicalPortAugmentation origAugmentation = orig.augmentation(HwvtepPhysicalPortAugmentation.class);
- List<VlanBindings> up
- = updatedAugmentation != null ? new ArrayList<>(updatedAugmentation.getVlanBindings().values()) : null;
- List<VlanBindings> or
- = origAugmentation != null ? new ArrayList<>(origAugmentation.getVlanBindings().values()) : null;
+ List<VlanBindings> up = updatedAugmentation != null
+ ? new ArrayList<>(updatedAugmentation.nonnullVlanBindings().values()) : null;
+ List<VlanBindings> or = origAugmentation != null
+ ? new ArrayList<>(origAugmentation.nonnullVlanBindings().values()) : null;
if (!areSameSize(up, or)) {
return false;
}
@Override
@Nullable
public List<Tunnels> getData(PhysicalSwitchAugmentation node) {
- if (node != null && node.getTunnels() != null) {
- return new ArrayList<Tunnels>(node.getTunnels().values());
+ if (node != null && node.nonnullTunnels() != null) {
+ return new ArrayList<Tunnels>(node.nonnullTunnels().values());
}
return null;
}
@Override
@Nullable
public List<TunnelIps> getData(PhysicalSwitchAugmentation node) {
- if (node != null && node.getTunnelIps() != null) {
- return new ArrayList<TunnelIps>(node.getTunnelIps().values());
+ if (node != null && node.nonnullTunnelIps() != null) {
+ return new ArrayList<TunnelIps>(node.nonnullTunnelIps().values());
}
return null;
}
LOG.info("HA ps node not present cleanup child {}" , childNode);
HwvtepGlobalAugmentation augmentation = childNode.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null) {
- Map<SwitchesKey, Switches> switches = augmentation.getSwitches();
+ Map<SwitchesKey, Switches> switches = augmentation.nonnullSwitches();
if (switches != null) {
for (Switches ps : switches.values()) {
HwvtepHAUtil.deleteNodeIfPresent(tx, ps.getSwitchRef().getValue());
return;
}
Map<SwitchesKey, Switches> keySwitchesMap
- = childGlobalNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
+ = childGlobalNode.augmentation(HwvtepGlobalAugmentation.class).nonnullSwitches();
if (keySwitchesMap == null) {
return;
}
String childGlobalNodeId = childNode.getNodeId().getValue();
List<InstanceIdentifier> childPsIids = new ArrayList<>();
HwvtepGlobalAugmentation hwvtepGlobalAugmentation = childNode.augmentation(HwvtepGlobalAugmentation.class);
- if (hwvtepGlobalAugmentation == null || HwvtepHAUtil.isEmpty(hwvtepGlobalAugmentation.getSwitches().values())) {
+ if (hwvtepGlobalAugmentation == null
+ || HwvtepHAUtil.isEmpty(hwvtepGlobalAugmentation.nonnullSwitches().values())) {
haOpClusteredListener.getConnectedNodes()
.stream()
.filter((connectedIid) -> IS_PS_CHILD_TO_GLOBAL_NODE.test(childGlobalNodeId, connectedIid))
.forEach(childPsIids::add);
} else {
- hwvtepGlobalAugmentation.getSwitches().values().forEach(
+ hwvtepGlobalAugmentation.nonnullSwitches().values().forEach(
(switches) -> childPsIids.add(switches.getSwitchRef().getValue()));
}
if (childPsIids.isEmpty()) {
List<Managers> up = null;
List<Managers> be = null;
if (updatedAugmentaion != null) {
- up = new ArrayList<Managers>(updatedAugmentaion.getManagers().values());
+ up = new ArrayList<Managers>(updatedAugmentaion.nonnullManagers().values());
}
if (beforeAugmentaion != null) {
- be = new ArrayList<Managers>(beforeAugmentaion.getManagers().values());
+ be = new ArrayList<Managers>(beforeAugmentaion.nonnullManagers().values());
}
if (up != null) {
InstanceIdentifier<Node> parent = key.firstIdentifierOf(Node.class);
if (managers.key().getTarget().getValue().contains(HwvtepHAUtil.MANAGER_KEY)
&& managers.getManagerOtherConfigs() != null) {
- managers.getManagerOtherConfigs().values().stream()
+ managers.nonnullManagerOtherConfigs().values().stream()
.filter(otherConfig -> otherConfig.key().getOtherConfigKey().contains(HwvtepHAUtil.HA_CHILDREN))
.flatMap(otherConfig -> Arrays.stream(otherConfig.getOtherConfigValue().split(",")))
.map(HwvtepHAUtil::convertToInstanceIdentifier)
elanDpnInterfacesInstanceIdentifier);
if (optional.isPresent() && optional.get().getElanDpnInterfacesList() != null) {
LOG.debug("Found elan dpn interfaces list");
- optional.get().getElanDpnInterfacesList().values().forEach(elanDpnInterfacesList -> {
+ optional.get().nonnullElanDpnInterfacesList().values().forEach(elanDpnInterfacesList -> {
Map<DpnInterfacesKey, DpnInterfaces> dpnInterfaces
- = elanDpnInterfacesList.getDpnInterfaces();
+ = elanDpnInterfacesList.nonnullDpnInterfaces();
InstanceIdentifier<ElanDpnInterfacesList> parentIid = InstanceIdentifier
.builder(ElanDpnInterfaces.class).child(ElanDpnInterfacesList.class,
new ElanDpnInterfacesListKey(elanDpnInterfacesList
globalIid.firstKeyOf(Node.class).getNodeId().getValue());
private static final Predicate<PhysicalSwitchAugmentation> TUNNEL_IP_AVAILABLE =
- phySwitch -> !HwvtepHAUtil.isEmpty(phySwitch.getTunnelIps().values());
+ phySwitch -> !HwvtepHAUtil.isEmpty(phySwitch.nonnullTunnelIps().values());
private static final Predicate<PhysicalSwitchAugmentation> TUNNEL_IP_NOT_AVAILABLE = TUNNEL_IP_AVAILABLE.negate();
l2GwDevice.setConnected(true);
l2GwDevice.setHwvtepNodeId(globalNodeId);
- Map<TunnelIpsKey, TunnelIps> tunnelIps = phySwitchAdded.getTunnelIps();
+ Map<TunnelIpsKey, TunnelIps> tunnelIps = phySwitchAdded.nonnullTunnelIps();
if (tunnelIps != null) {
for (TunnelIps tunnelIp : tunnelIps.values()) {
IpAddress tunnelIpAddr = tunnelIp.getTunnelIpsKey();
private static final Predicate<Node> IS_HA_PARENT_NODE = (node) -> {
HwvtepGlobalAugmentation augmentation = node.augmentation(HwvtepGlobalAugmentation.class);
- if (augmentation != null && augmentation.getManagers() != null) {
- return augmentation.getManagers().values().stream().anyMatch(
+ if (augmentation != null && augmentation.nonnullManagers() != null) {
+ return augmentation.nonnullManagers().values().stream().anyMatch(
manager -> manager.key().getTarget().getValue().equals(HwvtepHAUtil.MANAGER_KEY));
}
return false;
@Override
public void onSuccess(Optional<Topology> topologyOptional) {
if (topologyOptional != null && topologyOptional.isPresent()) {
- loadL2GwDeviceCache(new ArrayList<Node>(topologyOptional.get().getNode().values()));
+ loadL2GwDeviceCache(new ArrayList<Node>(topologyOptional.get().nonnullNode().values()));
}
registerListener();
}
}
if (optional.isPresent() && optional.get().getL2gatewayConnection() != null) {
LOG.trace("Found some connections to fill in l2gw connection cache");
- new ArrayList<>(optional.get().getL2gatewayConnection().values())
+ new ArrayList<>(optional.get().nonnullL2gatewayConnection().values())
.forEach(connection -> {
add(parentIid.child(L2gatewayConnection.class, connection.key()), connection);
});
l2GwDevice.setHwvtepNodeId(globalNode.getNodeId().getValue());
List<TunnelIps> tunnelIps = psNode.augmentation(PhysicalSwitchAugmentation.class) != null
- ? new ArrayList<>(psNode.augmentation(PhysicalSwitchAugmentation.class).getTunnelIps().values()) : null;
+ ? new ArrayList<>(psNode.augmentation(PhysicalSwitchAugmentation.class)
+ .nonnullTunnelIps().values()) : null;
if (tunnelIps != null) {
for (TunnelIps tunnelIp : tunnelIps) {
IpAddress tunnelIpAddr = tunnelIp.getTunnelIpsKey();
jobCoordinator.enqueueJob("l2gw.update", () -> {
ListenableFuture<Void> future = txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
DeviceInterfaces updatedDeviceInterfaces = new DeviceInterfaces(update);
- original.getDevices().values()
+ original.nonnullDevices().values()
.stream()
.filter((originalDevice) -> originalDevice.getInterfaces() != null)
.forEach((originalDevice) -> {
L2GatewayDevice l2GwDevice = l2GatewayCache.get(deviceName);
NodeId physicalSwitchNodeId = HwvtepSouthboundUtils.createManagedNodeId(
new NodeId(l2GwDevice.getHwvtepNodeId()), deviceName);
- originalDevice.getInterfaces().values()
+ originalDevice.nonnullInterfaces().values()
.stream()
.filter((intf) -> !updatedDeviceInterfaces.containsInterface(
deviceName, intf.getInterfaceName()))
Map<String, Map<String, Interfaces>> deviceInterfacesMap = new HashMap<>();
DeviceInterfaces(L2gateway l2gateway) {
- if (l2gateway.getDevices() != null) {
- l2gateway.getDevices().values().forEach((device) -> {
+ if (l2gateway.nonnullDevices() != null) {
+ l2gateway.nonnullDevices().values().forEach((device) -> {
deviceInterfacesMap.putIfAbsent(device.getDeviceName(), new HashMap<>());
- if (device.getInterfaces() != null) {
- device.getInterfaces().values().forEach((intf) ->
+ if (device.nonnullInterfaces() != null) {
+ device.nonnullInterfaces().values().forEach((intf) ->
deviceInterfacesMap.get(device.getDeviceName()).put(intf.getInterfaceName(), intf));
}
});
private static Set<LocalUcastMacs> getMacs(@Nullable Node node) {
if (node != null) {
HwvtepGlobalAugmentation augmentation = node.augmentation(HwvtepGlobalAugmentation.class);
- if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
- return new HashSet<>(augmentation.getLocalUcastMacs().values());
+ if (augmentation != null && augmentation.nonnullLocalUcastMacs() != null) {
+ return new HashSet<>(augmentation.nonnullLocalUcastMacs().values());
}
}
return Collections.emptySet();
if (operElanInstance == null) {
return emptyList();
}
- Map<ExternalTepsKey, ExternalTeps> teps = operElanInstance.getExternalTeps();
+ Map<ExternalTepsKey, ExternalTeps> teps = operElanInstance.nonnullExternalTeps();
if (teps == null || teps.isEmpty()) {
return emptyList();
}
List<PhysAddress> result = new ArrayList<>();
for (String interfaceName : lstElanInterfaceNames) {
ElanInterfaceMac elanInterfaceMac = ElanUtils.getElanInterfaceMacByInterfaceName(broker, interfaceName);
- if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null) {
- for (MacEntry macEntry : new ArrayList<>(elanInterfaceMac.getMacEntry().values())) {
+ if (elanInterfaceMac != null && elanInterfaceMac.nonnullMacEntry() != null) {
+ for (MacEntry macEntry : new ArrayList<>(elanInterfaceMac.nonnullMacEntry().values())) {
result.add(macEntry.getMacAddress());
}
}
if (configNode != null && configNode.isPresent()) {
HwvtepGlobalAugmentation augmentation = configNode.get().augmentation(
HwvtepGlobalAugmentation.class);
- if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
+ if (augmentation != null && augmentation.nonnullLocalUcastMacs() != null) {
macs.addAll(new ArrayList<>(augmentation
- .getLocalUcastMacs().values()).stream()
+ .nonnullLocalUcastMacs().values()).stream()
.filter(mac -> getLogicalSwitchName(mac).equals(elanName))
.map(HwvtepMacTableGenericAttributes::getMacEntryKey)
.collect(Collectors.toSet()));
if (hwvtepNode != null) {
Map<RemoteUcastMacsKey, RemoteUcastMacs> keyRemoteUcastMacsMap
= hwvtepNode.augmentation(HwvtepGlobalAugmentation.class)
- .getRemoteUcastMacs();
+ .nonnullRemoteUcastMacs();
if (keyRemoteUcastMacsMap != null && !keyRemoteUcastMacsMap.isEmpty()) {
// Filtering keyRemoteUcastMacsMap based on the logical switch and
// forming a list of MacAddress
return lstRemoteUcastMacs;
}
- for (MacEntry macEntry : new ArrayList<>(macTable.getMacEntry().values())) {
+ for (MacEntry macEntry : new ArrayList<>(macTable.nonnullMacEntry().values())) {
Uint64 dpnId = getDpidFromInterface(macEntry.getInterface());
if (dpnId == null) {
LOG.error("DPN ID not found for interface {}", macEntry.getInterface());
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
.l2gateway.attributes.devices.Interfaces deviceInterface : new ArrayList<>(hwVtepDevice
- .getInterfaces().values())) {
+ .nonnullInterfaces().values())) {
//Removed the check for checking terminationPoint present in OP or not
//for coniguring vlan bindings
//As we are not any more dependent on it , plugin takes care of this
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712
.l2gateway.attributes.devices.Interfaces deviceInterface : new ArrayList<>(hwVtepDevice
- .getInterfaces().values())) {
+ .nonnullInterfaces().values())) {
String phyPortName = deviceInterface.getInterfaceName();
if (deviceInterface.getSegmentationIds() != null && !deviceInterface.getSegmentationIds().isEmpty()) {
for (Integer vlanId : deviceInterface.getSegmentationIds()) {
String psNodeId = globalNodeId + HwvtepHAUtil.PHYSICALSWITCH + psName;
tzonesoptional.get().nonnullTransportZone().stream()
.filter(zone -> zone.getDeviceVteps() != null)
- .flatMap(zone -> new ArrayList<>(zone.getDeviceVteps().values()).stream())
+ .flatMap(zone -> new ArrayList<>(zone.nonnullDeviceVteps().values()).stream())
.filter(deviceVteps -> Objects.equals(getPsName(deviceVteps), psName)) //get device with same ps name
.filter(deviceVteps -> !Objects.equals(psNodeId, deviceVteps.getNodeId())
|| !Objects.equals(tunnelIp, deviceVteps.getIpAddress()))//node id or tunnel ip is changed
if (configNode.isPresent()) {
HwvtepGlobalAugmentation augmentation = configNode.get().augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
- macs.addAll(augmentation.getLocalUcastMacs().values().stream()
+ macs.addAll(augmentation.nonnullLocalUcastMacs().values().stream()
.filter(mac -> getLogicalSwitchName(mac).equals(elanName))
.map(HwvtepMacTableGenericAttributes::getMacEntryKey)
.collect(Collectors.toSet()));
InstanceIdentifier<L2gateways> inst = InstanceIdentifier.create(Neutron.class).child(L2gateways.class);
try {
return new ArrayList<>((SingleTransactionDataBroker.syncReadOptional(broker,
- LogicalDatastoreType.CONFIGURATION, inst).map(L2gateways::getL2gateway)
+ LogicalDatastoreType.CONFIGURATION, inst).map(L2gateways::nonnullL2gateway)
.orElse(emptyMap())).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS", e);
.child(L2gatewayConnections.class);
try {
return new ArrayList<>((SingleTransactionDataBroker.syncReadOptional(broker,
- LogicalDatastoreType.CONFIGURATION, inst).map(L2gatewayConnections::getL2gatewayConnection)
+ LogicalDatastoreType.CONFIGURATION, inst).map(L2gatewayConnections::nonnullL2gatewayConnection)
.orElse(emptyMap())).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS", e);
if (l2Gateway == null) {
LOG.error("Failed to find the l2gateway for the connection {}", input.getUuid());
return;
- } else if (l2Gateway.getDevices() != null) {
- l2gwDevicesToBeDeleted.addAll(l2Gateway.getDevices().values());
+ } else if (l2Gateway.nonnullDevices() != null) {
+ l2gwDevicesToBeDeleted.addAll(l2Gateway.nonnullDevices().values());
}
}
for (Devices l2Device : l2gwDevicesToBeDeleted) {
String elanName = elanInstance.getElanInstanceName();
Integer defaultVlan = input.getSegmentId();
Uuid l2GwConnId = input.key().getUuid();
- Map<DevicesKey, Devices> l2Devices = l2Gateway.getDevices();
+ Map<DevicesKey, Devices> l2Devices = l2Gateway.nonnullDevices();
LOG.trace("Associating ELAN {} with L2Gw Conn Id {} having below L2Gw devices {}", elanName, l2GwConnId,
l2Devices);
Node node = nodeOptional.get();
if (node.augmentation(HwvtepGlobalAugmentation.class) != null) {
Map<LocalUcastMacsKey, LocalUcastMacs> localUcastMacs =
- node.augmentation(HwvtepGlobalAugmentation.class).getLocalUcastMacs();
+ node.augmentation(HwvtepGlobalAugmentation.class).nonnullLocalUcastMacs();
if (localUcastMacs == null) {
return;
}
private static Map<String, List<InstanceIdentifier<VlanBindings>>> getVlansByLogicalSwitchOnDevice(
final Node configPsNode) {
- Map<TerminationPointKey, TerminationPoint> ports = configPsNode.getTerminationPoint();
+ Map<TerminationPointKey, TerminationPoint> ports = configPsNode.nonnullTerminationPoint();
if (ports == null) {
return Collections.emptyMap();
}
ports.values().stream()
.filter(CONTAINS_VLANBINDINGS)
.forEach((port) -> port.augmentation(HwvtepPhysicalPortAugmentation.class)
- .getVlanBindings().values()
+ .nonnullVlanBindings().values()
.forEach((binding) -> putVlanBindingVsLogicalSwitch(configPsNode, vlans, port, binding)));
return vlans;
}
return Collections.emptyList();
}
return augmentation
- .getLogicalSwitches().values()
+ .nonnullLogicalSwitches().values()
.stream()
.map((ls) -> ls.getHwvtepNodeName().getValue())
.collect(Collectors.toList());
Future<RpcResult<GetEgressActionsForTunnelOutput>> egressActionsOutputItm =
itmRpcService.getEgressActionsForTunnel(getEgressActInputItm);
if (egressActionsOutputItm.get().isSuccessful()) {
- return new ArrayList<Action>(egressActionsOutputItm.get().getResult().getAction().values());
+ return new ArrayList<Action>(egressActionsOutputItm.get().getResult().nonnullAction().values());
}
} else {
GetEgressActionsForInterfaceInput getEgressActInput = new GetEgressActionsForInterfaceInputBuilder()
Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsOutputFuture =
interfaceManagerRpcService.getEgressActionsForInterface(getEgressActInput);
if (egressActionsOutputFuture.get().isSuccessful()) {
- return new ArrayList<Action>(egressActionsOutputFuture.get().getResult().getAction().values());
+ return new ArrayList<Action>(egressActionsOutputFuture.get().getResult().nonnullAction().values());
}
}
} catch (Exception e) {
InstanceIdentifier<ElanDpnInterfacesList> elanIdentifier = getElanDpnOperationDataPath(elanInstanceName);
try {
return new ArrayList<DpnInterfaces>((SingleTransactionDataBroker.syncReadOptional(broker,
- LogicalDatastoreType.OPERATIONAL, elanIdentifier).map(ElanDpnInterfacesList::getDpnInterfaces)
+ LogicalDatastoreType.OPERATIONAL, elanIdentifier).map(ElanDpnInterfacesList::nonnullDpnInterfaces)
.orElse(emptyMap())).values());
} catch (ExecutionException | InterruptedException e) {
LOG.error("getElanDPNByName: Exception while reading elanDpnInterfaceList DS for the elan "
public List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
return new ArrayList<ExternalTunnel>(read(broker, datastoreType, iid).map(ExternalTunnelList
- ::getExternalTunnel).orElse(Collections.emptyMap()).values());
+ ::nonnullExternalTunnel).orElse(Collections.emptyMap()).values());
}
public static List<MatchInfo> buildMatchesForElanTagShFlagAndDstMac(long elanTag, boolean shFlag, String macAddr) {
private static boolean isVxlanSegment(@Nullable ElanInstance elanInstance) {
if (elanInstance != null) {
- Map<ElanSegmentsKey, ElanSegments> elanSegments = elanInstance.getElanSegments();
+ Map<ElanSegmentsKey, ElanSegments> elanSegments = elanInstance.nonnullElanSegments();
if (elanSegments != null) {
for (ElanSegments segment : elanSegments.values()) {
if (segment != null && segment.getSegmentType().isAssignableFrom(SegmentTypeVxlan.class)
&& elanInstance.getSegmentationId() != null && elanInstance.getSegmentationId().longValue() != 0) {
segmentationId = elanInstance.getSegmentationId();
} else {
- for (ElanSegments segment: elanInstance.getElanSegments().values()) {
+ for (ElanSegments segment: elanInstance.nonnullElanSegments().values()) {
if (segment != null && segment.getSegmentType().isAssignableFrom(SegmentTypeVxlan.class)
&& segment.getSegmentationId() != null
&& segment.getSegmentationId().longValue() != 0) {
if (macTable == null) {
return emptyList();
}
- return new ArrayList<MacEntry>(macTable.getMacEntry().values());
+ return new ArrayList<MacEntry>(macTable.nonnullMacEntry().values());
}
public boolean isTunnelInLogicalGroup(String interfaceName) {
Optional<Subnetmaps> subnetMapsData =
read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
- List<Subnetmap> subnetMapList = new ArrayList<>(subnetMapsData.get().getSubnetmap().values());
+ List<Subnetmap> subnetMapList = new ArrayList<>(subnetMapsData.get().nonnullSubnetmap().values());
if (subnetMapList != null && !subnetMapList.isEmpty()) {
for (Subnetmap subnet : subnetMapList) {
if (subnet.getNetworkId().getValue().equals(elanInstanceName)) {
LOG.debug("Buckets are not sent for group {}. Skipping merge operation", groupIdInfo);
return;
}
- List<Bucket> newBuckets = new ArrayList<Bucket>(newGroup.getBuckets().getBucket().values());
- List<Bucket> existingBuckets = new ArrayList<Bucket>(existingGroup.getBucket().values());
+ List<Bucket> newBuckets = new ArrayList<Bucket>(newGroup.getBuckets().nonnullBucket().values());
+ List<Bucket> existingBuckets = new ArrayList<Bucket>(existingGroup.nonnullBucket().values());
Set<Bucket> toMergeBucketsWithoutId = new LinkedHashSet<>();
existingBuckets.stream()
}
private List<String> getTepTransportZoneNames(TunnelEndPoints tep) {
- List<TzMembership> tzMembershipList = new ArrayList<TzMembership>(tep.getTzMembership().values());
+ List<TzMembership> tzMembershipList = new ArrayList<TzMembership>(tep.nonnullTzMembership().values());
if (tzMembershipList == null) {
LOG.debug("No TZ membership exist for TEP ip {}", tep.getIpAddress().stringValue());
return Collections.emptyList();
}
public static void verifySwitches(Node globalOpNode, Node psOpNode) {
- for (Switches switches : globalOpNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches().values()) {
+ for (Switches switches : globalOpNode.augmentation(HwvtepGlobalAugmentation.class)
+ .nonnullSwitches().values()) {
String switchValue = switches.getSwitchRef().getValue().firstKeyOf(Node.class).getNodeId().getValue();
assertEquals("Switch Name should be equal", switchValue, psOpNode.getNodeId().getValue());
}
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<LogicalSwitches> d1Values =
- d1Aug.getLogicalSwitches() != null ? new ArrayList<LogicalSwitches>(d1Aug.getLogicalSwitches().values())
- : new ArrayList<>();
+ d1Aug.getLogicalSwitches() != null
+ ? new ArrayList<LogicalSwitches>(d1Aug.nonnullLogicalSwitches().values()) : new ArrayList<>();
List<LogicalSwitches> result1 = cmd.transform(nodePath, d1Values);
List<LogicalSwitches> result2 = cmd.transform(nodePath,
- new ArrayList<LogicalSwitches>(haAug.getLogicalSwitches().values()));
+ new ArrayList<LogicalSwitches>(haAug.nonnullLogicalSwitches().values()));
Set<LogicalSwitches> set1 = Sets.newHashSet(result1);
Set<LogicalSwitches> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<LogicalSwitches> d1Values =
- d1Aug.getLogicalSwitches() != null ? new ArrayList<LogicalSwitches>(d1Aug.getLogicalSwitches().values())
- : new ArrayList<>();
+ d1Aug.getLogicalSwitches() != null
+ ? new ArrayList<LogicalSwitches>(d1Aug.nonnullLogicalSwitches().values()) : new ArrayList<>();
List<LogicalSwitches> result1 = cmd.transform(nodePath, d1Values);
List<LogicalSwitches> d2Values =
- d2Aug.getLogicalSwitches() != null ? new ArrayList<LogicalSwitches>(d2Aug.getLogicalSwitches().values())
- : new ArrayList<>();
+ d2Aug.getLogicalSwitches() != null
+ ? new ArrayList<LogicalSwitches>(d2Aug.nonnullLogicalSwitches().values()) : new ArrayList<>();
List<LogicalSwitches> result2 = cmd.transform(nodePath, d2Values);
//Merge data of both d1 and d2 logical switch info should be same as ha
Set<LogicalSwitches> set1 = new HashSet<>();
set1.addAll(result1);
set1.addAll(result2);
List<LogicalSwitches> result = cmd.transform(nodePath,
- new ArrayList<LogicalSwitches>(haAug.getLogicalSwitches().values()));
+ new ArrayList<LogicalSwitches>(haAug.nonnullLogicalSwitches().values()));
Set<LogicalSwitches> set2 = Sets.newHashSet(result);
assertEquals("should have equal logical switches", 0, Sets.symmetricDifference(set1, set2).size());
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteUcastMacs> d1Values =
- d1Aug.getRemoteUcastMacs() != null ? new ArrayList<RemoteUcastMacs>(d1Aug.getRemoteUcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getRemoteUcastMacs() != null
+ ? new ArrayList<RemoteUcastMacs>(d1Aug.nonnullRemoteUcastMacs().values()) : new ArrayList<>();
List<RemoteUcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<RemoteUcastMacs> result2 = cmd.transform(nodePath,
- new ArrayList<RemoteUcastMacs>(haAug.getRemoteUcastMacs().values()));
+ new ArrayList<RemoteUcastMacs>(haAug.nonnullRemoteUcastMacs().values()));
RemoteUcastMacs mac1 = result1.get(0);
RemoteUcastMacs mac2 = result2.get(0);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteUcastMacs> d1Values =
- d1Aug.getRemoteUcastMacs() != null ? new ArrayList<RemoteUcastMacs>(d1Aug.getRemoteUcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getRemoteUcastMacs() != null
+ ? new ArrayList<RemoteUcastMacs>(d1Aug.nonnullRemoteUcastMacs().values()) : new ArrayList<>();
List<RemoteUcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<RemoteUcastMacs> d2Values =
- d2Aug.getRemoteUcastMacs() != null ? new ArrayList<RemoteUcastMacs>(d2Aug.getRemoteUcastMacs().values())
- : new ArrayList<>();
+ d2Aug.getRemoteUcastMacs() != null
+ ? new ArrayList<RemoteUcastMacs>(d2Aug.nonnullRemoteUcastMacs().values()) : new ArrayList<>();
List<RemoteUcastMacs> result2 = cmd.transform(nodePath, d2Values);
List<RemoteUcastMacs> ruMacList = new ArrayList<>();
ruMacList.addAll(result1);
ruMacList.addAll(result2);
List<RemoteUcastMacs> result = cmd.transform(nodePath,
- new ArrayList<RemoteUcastMacs>(haAug.getRemoteUcastMacs().values()));
+ new ArrayList<RemoteUcastMacs>(haAug.nonnullRemoteUcastMacs().values()));
Set<RemoteUcastMacs> set1 = Sets.newHashSet(ruMacList);
Set<RemoteUcastMacs> set2 = Sets.newHashSet(result);
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteMcastMacs> d1Values =
- d1Aug.getRemoteMcastMacs() != null ? new ArrayList<RemoteMcastMacs>(d1Aug.getRemoteMcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getRemoteMcastMacs() != null
+ ? new ArrayList<RemoteMcastMacs>(d1Aug.nonnullRemoteMcastMacs().values()) : new ArrayList<>();
List<RemoteMcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<RemoteMcastMacs> result2 = cmd.transform(nodePath,
- new ArrayList<RemoteMcastMacs>(haAug.getRemoteMcastMacs().values()));
+ new ArrayList<RemoteMcastMacs>(haAug.nonnullRemoteMcastMacs().values()));
Set<RemoteMcastMacs> set1 = Sets.newHashSet(result1);
Set<RemoteMcastMacs> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<RemoteMcastMacs> d1Values =
- d1Aug.getRemoteMcastMacs() != null ? new ArrayList<RemoteMcastMacs>(d1Aug.getRemoteMcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getRemoteMcastMacs() != null
+ ? new ArrayList<RemoteMcastMacs>(d1Aug.nonnullRemoteMcastMacs().values()) : new ArrayList<>();
List<RemoteMcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<RemoteMcastMacs> d2Values =
- d2Aug.getRemoteMcastMacs() != null ? new ArrayList<RemoteMcastMacs>(d2Aug.getRemoteMcastMacs().values())
- : new ArrayList<>();
+ d2Aug.getRemoteMcastMacs() != null
+ ? new ArrayList<RemoteMcastMacs>(d2Aug.nonnullRemoteMcastMacs().values()) : new ArrayList<>();
List<RemoteMcastMacs> result2 = cmd.transform(nodePath, d2Values);
List<RemoteMcastMacs> rmMacList = new ArrayList<>();
rmMacList.addAll(result1);
rmMacList.addAll(result2);
List<RemoteMcastMacs> result = cmd.transform(nodePath,
- new ArrayList<RemoteMcastMacs>(haAug.getRemoteMcastMacs().values()));
+ new ArrayList<RemoteMcastMacs>(haAug.nonnullRemoteMcastMacs().values()));
Set<RemoteMcastMacs> set1 = Sets.newHashSet(rmMacList);
Set<RemoteMcastMacs> set2 = Sets.newHashSet(result);
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<LocalUcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalUcastMacs>(d1Aug.getLocalUcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null
+ ? new ArrayList<LocalUcastMacs>(d1Aug.nonnullLocalUcastMacs().values()) : new ArrayList<>();
List<LocalUcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<LocalUcastMacs> result2 = cmd.transform(nodePath,
- new ArrayList<LocalUcastMacs>(haAug.getLocalUcastMacs().values()));
+ new ArrayList<LocalUcastMacs>(haAug.nonnullLocalUcastMacs().values()));
Set<LocalUcastMacs> set1 = Sets.newHashSet(result1);
Set<LocalUcastMacs> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<LocalUcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalUcastMacs>(d1Aug.getLocalUcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null
+ ? new ArrayList<LocalUcastMacs>(d1Aug.nonnullLocalUcastMacs().values()) : new ArrayList<>();
List<LocalUcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<LocalUcastMacs> d2Values =
- d2Aug.getLocalUcastMacs() != null ? new ArrayList<LocalUcastMacs>(d2Aug.getLocalUcastMacs().values())
- : new ArrayList<>();
+ d2Aug.getLocalUcastMacs() != null
+ ? new ArrayList<LocalUcastMacs>(d2Aug.nonnullLocalUcastMacs().values()) : new ArrayList<>();
List<LocalUcastMacs> result2 = cmd.transform(nodePath, d2Values);
List<LocalUcastMacs> result = cmd.transform(nodePath,
- new ArrayList<LocalUcastMacs>(haAug.getLocalUcastMacs().values()));
+ new ArrayList<LocalUcastMacs>(haAug.nonnullLocalUcastMacs().values()));
List<LocalUcastMacs> luMacList = new ArrayList<>();
luMacList.addAll(result1);
HwvtepGlobalAugmentation d1Aug = src.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = dst.augmentation(HwvtepGlobalAugmentation.class);
List<LocalMcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalMcastMacs>(d1Aug.getLocalMcastMacs().values())
- : new ArrayList<>();
+ d1Aug.getLocalUcastMacs() != null
+ ? new ArrayList<LocalMcastMacs>(d1Aug.nonnullLocalMcastMacs().values()) : new ArrayList<>();
List<LocalMcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<LocalMcastMacs> result2 = cmd.transform(nodePath,
- new ArrayList<LocalMcastMacs>(haAug.getLocalMcastMacs().values()));
+ new ArrayList<LocalMcastMacs>(haAug.nonnullLocalMcastMacs().values()));
Set<LocalMcastMacs> set1 = Sets.newHashSet(result1);
Set<LocalMcastMacs> set2 = Sets.newHashSet(result2);
HwvtepGlobalAugmentation d2Aug = d2.augmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation haAug = ha.augmentation(HwvtepGlobalAugmentation.class);
List<LocalMcastMacs> d1Values =
- d1Aug.getLocalUcastMacs() != null ? new ArrayList<LocalMcastMacs>(d1Aug.getLocalMcastMacs().values())
- : new ArrayList<>();
+ d1Aug.nonnullLocalMcastMacs() != null
+ ? new ArrayList<LocalMcastMacs>(d1Aug.nonnullLocalMcastMacs().values()) : new ArrayList<>();
List<LocalMcastMacs> result1 = cmd.transform(nodePath, d1Values);
List<LocalMcastMacs> d2Values =
- d2Aug.getLocalUcastMacs() != null ? new ArrayList<LocalMcastMacs>(d2Aug.getLocalMcastMacs().values())
- : new ArrayList<>();
+ d2Aug.nonnullLocalMcastMacs() != null
+ ? new ArrayList<LocalMcastMacs>(d2Aug.nonnullLocalMcastMacs().values()) : new ArrayList<>();
List<LocalMcastMacs> result2 = cmd.transform(nodePath, d2Values);
List<LocalMcastMacs> result = cmd.transform(nodePath,
- new ArrayList<LocalMcastMacs>(haAug.getLocalMcastMacs().values()));
+ new ArrayList<LocalMcastMacs>(haAug.nonnullLocalMcastMacs().values()));
List<LocalMcastMacs> lmMacList = new ArrayList<>();
lmMacList.addAll(result1);
managerhaPs.getValue().firstKeyOf(Node.class).getNodeId().getValue() + "/physicalswitch/" + switchName);
assertEquals("Should have equal number TunnelIps",
- d1PsAug.getTunnelIps().size(), haPsAug.getTunnelIps().size());
+ d1PsAug.nonnullTunnelIps().size(), haPsAug.nonnullTunnelIps().size());
assertEquals("Should have equal number TunnelIps",
- d2PsAug.getTunnelIps().size(), haPsAug.getTunnelIps().size());
- if (d1PsAug.getTunnelIps().size() == haPsAug.getTunnelIps().size()
- && d2PsAug.getTunnelIps().size() == haPsAug.getTunnelIps().size()) {
- assertTrue(d1PsAug.getTunnelIps().values().containsAll(
- new ArrayList<TunnelIps>(haPsAug.getTunnelIps().values())));
- assertTrue(d2PsAug.getTunnelIps().values().containsAll(
- new ArrayList<TunnelIps>(haPsAug.getTunnelIps().values())));
+ d2PsAug.nonnullTunnelIps().size(), haPsAug.nonnullTunnelIps().size());
+ if (d1PsAug.nonnullTunnelIps().size() == haPsAug.nonnullTunnelIps().size()
+ && d2PsAug.nonnullTunnelIps().size() == haPsAug.nonnullTunnelIps().size()) {
+ assertTrue(d1PsAug.nonnullTunnelIps().values().containsAll(
+ new ArrayList<TunnelIps>(haPsAug.nonnullTunnelIps().values())));
+ assertTrue(d2PsAug.nonnullTunnelIps().values().containsAll(
+ new ArrayList<TunnelIps>(haPsAug.nonnullTunnelIps().values())));
}
//Compare Termination point
assertEquals("Managers should be equal for ha ", haps.getNodeId().getValue(),
managerhaPs.getValue().firstKeyOf(Node.class).getNodeId().getValue() + "/physicalswitch/" + switchName);
- assertEquals("Should have equal number TunnelIps", d1PsAug.getTunnelIps().size(),
- haPsAug.getTunnelIps().size());
- if (d1PsAug.getTunnelIps().size() == haPsAug.getTunnelIps().size()) {
- assertTrue(d1PsAug.getTunnelIps().values().containsAll(
- new ArrayList<TunnelIps>(haPsAug.getTunnelIps().values())));
+ assertEquals("Should have equal number TunnelIps", d1PsAug.nonnullTunnelIps().size(),
+ haPsAug.nonnullTunnelIps().size());
+ if (d1PsAug.nonnullTunnelIps().size() == haPsAug.nonnullTunnelIps().size()) {
+ assertTrue(d1PsAug.nonnullTunnelIps().values().containsAll(
+ new ArrayList<TunnelIps>(haPsAug.nonnullTunnelIps().values())));
}
//Compare Termination point
hwvtepPhysicalPortAugmentationHa.getHwvtepNodeName());
List<VlanBindings> vlanBindingsesD
- = new ArrayList<VlanBindings>(hwvtepPhysicalPortAugmentationD.getVlanBindings().values());
+ = new ArrayList<VlanBindings>(hwvtepPhysicalPortAugmentationD.nonnullVlanBindings().values());
List<VlanBindings> vlanBindingsesHa
- = new ArrayList<VlanBindings>(hwvtepPhysicalPortAugmentationHa.getVlanBindings().values());
+ = new ArrayList<VlanBindings>(hwvtepPhysicalPortAugmentationHa.nonnullVlanBindings().values());
assertEquals("Size of VlanBindings should be same", vlanBindingsesD.size(), vlanBindingsesHa.size());
List<Integer> vlanKeysD = new ArrayList<>();
static void verifyHAconfigNode(Node haConfig, Node d1Node) {
String haid = new ArrayList<ManagerOtherConfigs>(new ArrayList<Managers>(haConfig
- .augmentation(HwvtepGlobalAugmentation.class).getManagers().values())
- .get(0).getManagerOtherConfigs().values()).get(0).getOtherConfigValue();
+ .augmentation(HwvtepGlobalAugmentation.class).nonnullManagers().values())
+ .get(0).nonnullManagerOtherConfigs().values()).get(0).getOtherConfigValue();
String d1id = d1Node.getNodeId().getValue();
assertEquals("Other config should contain D1 as child manager", haid, d1id);
}
Instructions instructions = flowBuilder.getInstructions();
InstructionsBuilder builder = new InstructionsBuilder();
InstructionBuilder instructionBuilder = new InstructionBuilder(
- new ArrayList<Instruction>(instructions.getInstruction().values()).get(0));
+ new ArrayList<Instruction>(instructions.nonnullInstruction().values()).get(0));
instructionBuilder.setInstruction(sortActions(instructionBuilder.getInstruction()));
builder.setInstruction(Lists.newArrayList(instructionBuilder.build()));
return flowBuilder.setInstructions(builder.build()).build();
sortActions(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction input) {
if (input instanceof ApplyActionsCase) {
List<Action> action = new ArrayList<Action>(((ApplyActionsCase)input)
- .getApplyActions().getAction().values());
+ .getApplyActions().nonnullAction().values());
action.sort(Comparator.comparing(Ordered::getOrder));
ApplyActions actions = new ApplyActionsBuilder().setAction(action).build();
}
}
boolean remoteMcastFoundFlag = false;
- for (RemoteMcastMacs remoteMcastMacs : augmentation.getRemoteMcastMacs().values()) {
+ for (RemoteMcastMacs remoteMcastMacs : augmentation.nonnullRemoteMcastMacs().values()) {
for (LocatorSet locatorSet : remoteMcastMacs.getLocatorSet()) {
TpId tpId = locatorSet.getLocatorRef().getValue().firstKeyOf(TerminationPoint.class).getTpId();
if (tpId.getValue().contains(tepIp)) {
}
}
boolean remoteUcastFoundFlag = false;
- for (RemoteUcastMacs remoteUcastMacs : augmentation.getRemoteUcastMacs().values()) {
+ for (RemoteUcastMacs remoteUcastMacs : augmentation.nonnullRemoteUcastMacs().values()) {
String mac = remoteUcastMacs.getMacEntryKey().getValue();
if (mac.equals(dpnMac)) {
remoteUcastFoundFlag = true;
.setTunnelKey(elanInfo.getElanTag().longValue() + ElanConstants.ELAN_TAG_ADDEND).build();
List<Action> actionsList =
new ArrayList<Action>(odlInterfaceRpcService.getEgressActionsForInterface(getEgressActInput)
- .get().getResult().getAction().values());
+ .get().getResult().nonnullAction().values());
listBucketInfo.add(MDSALUtil.buildBucket(actionsList, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
.setTunnelKey(elanInfo.getSegmentationId()).build();
List<Action> actionsList =
new ArrayList<Action>(odlInterfaceRpcService.getEgressActionsForInterface(getEgressActInput)
- .get().getResult().getAction().values());
+ .get().getResult().nonnullAction().values());
listBucketInfo.add(MDSALUtil.buildBucket(actionsList, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
AssertDataObjects.assertEqualBeans(expected, actual);
}
- Set<Bucket> actualBuckets = modifyBucketId(new ArrayList<Bucket>(actual.getBuckets().getBucket().values()));
- Set<Bucket> expectedBuckets = modifyBucketId(new ArrayList<Bucket>(expected.getBuckets().getBucket().values()));
+ Set<Bucket> actualBuckets = modifyBucketId(new ArrayList<Bucket>(actual.getBuckets()
+ .nonnullBucket().values()));
+ Set<Bucket> expectedBuckets = modifyBucketId(new ArrayList<Bucket>(expected.getBuckets()
+ .nonnullBucket().values()));
Set<Bucket> diff = Sets.difference(actualBuckets, expectedBuckets);
if (diff != null && !diff.isEmpty()) {
AssertDataObjects.assertEqualBeans(expected, actual);
Code Review / netvirt.git / commitdiff