| /* |
| * Copyright 2016-present Open Networking Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.onosproject.ospf.controller.impl; |
| |
| import org.onlab.packet.Ip4Address; |
| import org.onlab.util.Bandwidth; |
| import org.onosproject.ospf.controller.DeviceInformation; |
| import org.onosproject.ospf.controller.LinkInformation; |
| import org.onosproject.ospf.controller.OspfArea; |
| import org.onosproject.ospf.controller.OspfInterface; |
| import org.onosproject.ospf.controller.OspfLinkTed; |
| import org.onosproject.ospf.controller.OspfLsa; |
| import org.onosproject.ospf.controller.OspfLsaType; |
| import org.onosproject.ospf.controller.TopologyForDeviceAndLink; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.LinkSubType; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.LocalInterfaceIpAddress; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.MaximumBandwidth; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.MaximumReservableBandwidth; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.RemoteInterfaceIpAddress; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.TrafficEngineeringMetric; |
| import org.onosproject.ospf.protocol.lsa.linksubtype.UnreservedBandwidth; |
| import org.onosproject.ospf.protocol.lsa.subtypes.OspfLsaLink; |
| import org.onosproject.ospf.protocol.lsa.tlvtypes.LinkTlv; |
| import org.onosproject.ospf.protocol.lsa.types.NetworkLsa; |
| import org.onosproject.ospf.protocol.lsa.types.OpaqueLsa10; |
| import org.onosproject.ospf.protocol.lsa.types.RouterLsa; |
| import org.onosproject.ospf.protocol.lsa.types.TopLevelTlv; |
| import org.onosproject.ospf.protocol.util.OspfUtil; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeSet; |
| |
| /** |
| * Represents device and link topology information. |
| */ |
| public class TopologyForDeviceAndLinkImpl implements TopologyForDeviceAndLink { |
| |
| private static final Logger log = LoggerFactory.getLogger(TopologyForDeviceAndLinkImpl.class); |
| Set<Ip4Address> routerSet = new TreeSet<Ip4Address>(); |
| Ip4Address firstValue = Ip4Address.valueOf("0.0.0.0"); |
| private Map<String, DeviceInformation> deviceInformationMap = new LinkedHashMap(); |
| private Map<Ip4Address, List<Ip4Address>> networkLsaMap = new LinkedHashMap(); |
| private Map<String, DeviceInformation> deviceInformationMapForPointToPoint = new LinkedHashMap(); |
| private Map<String, DeviceInformation> deviceInformationMapToDelete = new LinkedHashMap(); |
| private HashMap<String, Set<OspfLsaLink>> deviceAndLinkInformation = new HashMap(); |
| private HashMap<String, OspfLinkTed> ospfLinkTedHashMap = new LinkedHashMap(); |
| private Ip4Address drRouter = Ip4Address.valueOf("0.0.0.0"); |
| private Ip4Address drRouterOld = Ip4Address.valueOf("0.0.0.0"); |
| private Ip4Address adRouterId = Ip4Address.valueOf("0.0.0.0"); |
| private Map<String, LinkInformation> linkInformationMap = new LinkedHashMap(); |
| private Map<String, LinkInformation> linkInformationMapForPointToPoint = new LinkedHashMap(); |
| private List<String> toRemove = new ArrayList<>(); |
| |
| /** |
| * Gets device information. |
| * |
| * @return device information |
| */ |
| public Map<String, DeviceInformation> deviceInformationMap() { |
| return deviceInformationMap; |
| } |
| |
| /** |
| * Sets device information. |
| * |
| * @param key key used to add in map |
| * @param deviceInformationMap device information instance |
| */ |
| public void setDeviceInformationMap(String key, DeviceInformation deviceInformationMap) { |
| if (deviceInformationMap != null) { |
| this.deviceInformationMap.put(key, deviceInformationMap); |
| } |
| |
| } |
| |
| /** |
| * Gets deviceInformation as map for Point-To-Point. |
| * |
| * @return deviceInformationMap |
| */ |
| public Map<String, DeviceInformation> deviceInformationMapForPointToPoint() { |
| return deviceInformationMapForPointToPoint; |
| } |
| |
| /** |
| * Sets deviceInformation as map for Point-To-Point.. |
| * |
| * @param key key to store device information |
| * @param deviceInformationMap device information instance |
| */ |
| public void setDeviceInformationMapForPointToPoint(String key, DeviceInformation deviceInformationMap) { |
| if (deviceInformationMap != null) { |
| this.deviceInformationMapForPointToPoint.put(key, deviceInformationMap); |
| } |
| |
| } |
| |
| /** |
| * Gets deviceInformation as map. |
| * |
| * @return deviceInformationMap to delete from core |
| */ |
| public Map<String, DeviceInformation> deviceInformationMapToDelete() { |
| return deviceInformationMapToDelete; |
| } |
| |
| /** |
| * Sets device information for removal. |
| * |
| * @param key ket used to add in map |
| * @param deviceInformationMapToDelete map from device information to remove |
| */ |
| public void setDeviceInformationMapToDelete(String key, DeviceInformation deviceInformationMapToDelete) { |
| if (deviceInformationMapToDelete != null) { |
| this.deviceInformationMapToDelete.put(key, deviceInformationMapToDelete); |
| } |
| } |
| |
| /** |
| * Removes Device Information. |
| * |
| * @param key ket used to remove from map |
| */ |
| public void removeDeviceInformationMapFromDeleteMap(String key) { |
| removeDeviceInformationMap(key); |
| if (this.deviceInformationMapToDelete.containsKey(key)) { |
| this.deviceInformationMapToDelete.remove(key); |
| } |
| } |
| |
| /** |
| * Gets Device Information. |
| * |
| * @param key key to store in map |
| * @return Device Information |
| */ |
| public DeviceInformation deviceInformation(String key) { |
| DeviceInformation deviceInformation = this.deviceInformationMap.get(key); |
| return deviceInformation; |
| } |
| |
| /** |
| * Removes Device Information from map. |
| * |
| * @param key key used to remove from map |
| */ |
| public void removeDeviceInformationMap(String key) { |
| if (this.deviceInformationMap.containsKey(key)) { |
| this.deviceInformationMap.remove(key); |
| } |
| } |
| |
| /** |
| * Gets link information as map. |
| * |
| * @return link information as map |
| */ |
| public Map<String, LinkInformation> linkInformationMap() { |
| return linkInformationMap; |
| } |
| |
| private LinkInformation getLinkInformation(String key) { |
| LinkInformation linkInformation = this.linkInformationMap.get(key); |
| return linkInformation; |
| } |
| |
| /** |
| * Sets link information in map. |
| * |
| * @param key key used to add in map |
| * @param linkInformationMap link information instance |
| */ |
| public void setLinkInformationMap(String key, LinkInformation linkInformationMap) { |
| if (!this.linkInformationMap.containsKey(key)) { |
| this.linkInformationMap.put(key, linkInformationMap); |
| } |
| } |
| |
| /** |
| * Gets linkInformation as map for PointToPoint. |
| * |
| * @return linkInformationMap |
| */ |
| public Map<String, LinkInformation> linkInformationMapForPointToPoint() { |
| return linkInformationMap; |
| } |
| |
| /** |
| * Sets linkInformation as map for PointToPoint. |
| * |
| * @param key key to store link information |
| * @param linkInformationMap link information instance |
| */ |
| public void setLinkInformationMapForPointToPoint(String key, LinkInformation linkInformationMap) { |
| if (!this.linkInformationMap.containsKey(key)) { |
| this.linkInformationMap.put(key, linkInformationMap); |
| } |
| } |
| |
| /** |
| * Removes Link Information from linkInformationMap. |
| * |
| * @param key key to remove link information |
| */ |
| public void removeLinkInformationMap(String key) { |
| if (this.linkInformationMap.containsKey(key)) { |
| this.linkInformationMap.remove(key); |
| } |
| } |
| |
| |
| /** |
| * Gets OSPF Link TED details from the map. |
| * |
| * @param key key used to retrieve from map |
| * @return OSPF link ted instance |
| */ |
| public OspfLinkTed getOspfLinkTedHashMap(String key) { |
| OspfLinkTed ospfLinkTed = ospfLinkTedHashMap.get(key); |
| return ospfLinkTed; |
| } |
| |
| /** |
| * Adds device information to map. |
| * |
| * @param ospfLsa OSPF LSA instance |
| * @param ospfInterface OSPF interface instance |
| * @param ospfArea OSPF area instance |
| */ |
| public void addLocalDevice(OspfLsa ospfLsa, OspfInterface ospfInterface, OspfArea ospfArea) { |
| if (ospfLsa.getOspfLsaType().equals(OspfLsaType.ROUTER)) { |
| createDeviceAndLinkFromRouterLsa(ospfLsa, ospfArea); |
| } else if (ospfLsa.getOspfLsaType().equals(OspfLsaType.NETWORK)) { |
| createDeviceAndLinkFromNetworkLsa(ospfLsa, ospfArea); |
| } else if (ospfLsa.getOspfLsaType().equals(OspfLsaType.AREA_LOCAL_OPAQUE_LSA)) { |
| createDeviceAndLinkFromOpaqueLsa(ospfLsa, ospfArea); |
| } |
| } |
| |
| /** |
| * Creates device object from parameters. |
| * |
| * @param alreadyCreated device already created or not |
| * @param deviceId device id |
| * @param neighborId neighbor's id |
| * @param routerId router's id |
| * @param interfaceId interface id |
| * @param areaId area id |
| * @param isDr true if router is DR else false |
| */ |
| private DeviceInformation createDeviceInformation(boolean alreadyCreated, Ip4Address deviceId, |
| Ip4Address neighborId, Ip4Address routerId, |
| Ip4Address interfaceId, Ip4Address areaId, |
| boolean isDr) { |
| DeviceInformation deviceInformation = new DeviceInformationImpl(); |
| deviceInformation.setAlreadyCreated(alreadyCreated); |
| deviceInformation.setDeviceId(deviceId); |
| deviceInformation.setNeighborId(neighborId); |
| deviceInformation.setRouterId(routerId); |
| deviceInformation.addInterfaceId(interfaceId); |
| deviceInformation.setAreaId(areaId); |
| deviceInformation.setDr(isDr); |
| return deviceInformation; |
| } |
| |
| /** |
| * Creates Device and Link instance from the RouterLsa parameters. |
| * |
| * @param ospfLsa OSPF LSA instance |
| * @param ospfArea OSPF area |
| */ |
| private void createDeviceAndLinkFromRouterLsa(OspfLsa ospfLsa, OspfArea ospfArea) { |
| RouterLsa routerLsa = (RouterLsa) ospfLsa; |
| List<OspfLsaLink> ospfLsaLinkList = routerLsa.routerLink(); |
| Iterator iterator = ospfLsaLinkList.iterator(); |
| Ip4Address advertisingRouterId = routerLsa.advertisingRouter(); |
| while (iterator.hasNext()) { |
| OspfLsaLink ospfLsaLink = (OspfLsaLink) iterator.next(); |
| Ip4Address linkId = Ip4Address.valueOf(ospfLsaLink.linkId()); |
| Ip4Address linkData = Ip4Address.valueOf(ospfLsaLink.linkData()); |
| if (ospfLsaLink.linkType() == 1) { |
| if ((advertisingRouterId.equals(ospfArea.routerId())) || (linkId.equals(ospfArea.routerId()))) { |
| if (!advertisingRouterId.equals(ospfArea.routerId())) { |
| DeviceInformation deviceInformationPointToPoint = |
| createDeviceInformation(false, linkId, linkId, advertisingRouterId, linkData, |
| ospfArea.areaId(), false); |
| String key = "device:" + advertisingRouterId; |
| setDeviceInformationMapForPointToPoint(key, deviceInformationPointToPoint); |
| } |
| } else { |
| DeviceInformation deviceInformationPointToPoint = |
| createDeviceInformation(false, linkId, linkId, advertisingRouterId, |
| linkData, ospfArea.areaId(), false); |
| String key = "device:" + advertisingRouterId; |
| setDeviceInformationMapForPointToPoint(key, deviceInformationPointToPoint); |
| String linkIdKey = "linkId:" + advertisingRouterId + "-" + linkId; |
| addLocalLinkForPointToPoint(linkIdKey, linkData, advertisingRouterId, linkId, true, false); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates device and link instance from the network LSA parameters. |
| * |
| * @param ospfLsa OSPF LSA instance |
| * @param ospfArea OSPF area instance |
| */ |
| private void createDeviceAndLinkFromNetworkLsa(OspfLsa ospfLsa, OspfArea ospfArea) { |
| NetworkLsa networkLsa = (NetworkLsa) ospfLsa; |
| Ip4Address linkStateId = Ip4Address.valueOf(networkLsa.linkStateId()); |
| Set<Ip4Address> drList = networkLsaMap.keySet(); |
| try { |
| Ip4Address drToReplace = null; |
| for (Ip4Address drIp : drList) { |
| if (!drIp.equals(linkStateId)) { |
| if (OspfUtil.sameNetwork(drIp, linkStateId, networkLsa.networkMask())) { |
| drToReplace = drIp; |
| String key = "device:" + drToReplace; |
| DeviceInformation deleteDr = deviceInformation(key); |
| if (deleteDr != null) { |
| deleteDr.setAlreadyCreated(true); |
| setDeviceInformationMapToDelete(key, deleteDr); |
| } |
| |
| networkLsaMap.remove(drToReplace); |
| break; |
| } |
| } |
| } |
| networkLsaMap.put(linkStateId, networkLsa.attachedRouters()); |
| |
| } catch (Exception e) { |
| log.debug("Error::TopologyForDeviceAndLinkImpl:: {}", e.getMessage()); |
| } |
| constructDeviceForBroadCastTopology(ospfArea); |
| disp(); |
| |
| } |
| |
| private void constructDeviceForBroadCastTopology(OspfArea ospfArea) { |
| |
| for (Map.Entry<Ip4Address, List<Ip4Address>> entry : networkLsaMap.entrySet()) { |
| Ip4Address key = entry.getKey(); |
| DeviceInformation deviceInformationForDr = createDeviceInformation(false, key, key, key, |
| key, ospfArea.areaId(), true); |
| String dr = "device:" + key; |
| setDeviceInformationMap(dr, deviceInformationForDr); |
| List<Ip4Address> value = entry.getValue(); |
| for (Ip4Address connectedRouter : value) { |
| if (!connectedRouter.equals(ospfArea.routerId())) { |
| DeviceInformation deviceInformationAttachedRouters = |
| createDeviceInformation(false, connectedRouter, key, connectedRouter, |
| key, ospfArea.areaId(), false); |
| String attachedRouters = "device:" + connectedRouter; |
| setDeviceInformationMap(attachedRouters, deviceInformationAttachedRouters); |
| String linkIdKey = "linkId:" + key + "-" + connectedRouter; |
| addLocalLink(linkIdKey, key, key, connectedRouter, true, false); |
| } |
| } |
| } |
| |
| } |
| |
| private void disp() { |
| for (String key : deviceInformationMap.keySet()) { |
| DeviceInformation deviceInformation = deviceInformationMap.get(key); |
| log.debug("************************************************************************"); |
| log.debug("DeviceInfoList RouterId is : {} and neighbour is {} and linkdata {}", |
| deviceInformation.routerId(), deviceInformation.neighborId(), deviceInformation.interfaceId()); |
| } |
| |
| for (Map.Entry<String, LinkInformation> entry : linkInformationMap.entrySet()) { |
| String linkDetail = entry.getKey(); |
| log.debug("Link From and to is " + linkDetail); |
| } |
| log.debug("Devices Needs to delete from Core are : " + deviceInformationMapToDelete.size()); |
| for (String key : deviceInformationMapToDelete.keySet()) { |
| DeviceInformation value = deviceInformationMapToDelete.get(key); |
| if (value.isAlreadyCreated()) { |
| log.debug("Device is deleted from list " + value.routerId()); |
| } |
| } |
| } |
| |
| private void getLinksToDelete(Set<Ip4Address> list, Ip4Address value, OspfArea ospfArea) { |
| |
| Iterator iterator = list.iterator(); |
| |
| while (iterator.hasNext()) { |
| Ip4Address secondValue = (Ip4Address) iterator.next(); |
| if (!value.toString().equals("0.0.0.0")) { |
| if ((!value.equals(secondValue))) { |
| if ((!secondValue.equals(ospfArea.routerId()))) { |
| String key = "link:" + value.toString() + "-" + secondValue.toString(); |
| String key1 = "link:" + secondValue.toString() + "-" + value.toString(); |
| LinkInformation linkDetails = getLinkInformation(key); |
| LinkInformation linkDetailsOther = getLinkInformation(key1); |
| linkInformationMapForPointToPoint.put(key, linkDetails); |
| linkInformationMapForPointToPoint.put(key1, linkDetailsOther); |
| } |
| } |
| } |
| |
| } |
| |
| } |
| |
| /** |
| * Creates Device and Link instance from the OpaqueLsa parameters. |
| * |
| * @param ospfLsa OSPF LSA instance |
| * @param ospfArea OSPF area instance |
| */ |
| private void createDeviceAndLinkFromOpaqueLsa(OspfLsa ospfLsa, OspfArea ospfArea) { |
| OspfLinkTed ospfLinkTed = new OspfLinkTedImpl(); |
| OpaqueLsa10 opaqueLsa10 = (OpaqueLsa10) ospfLsa; |
| List<TopLevelTlv> topLevelTlvList = opaqueLsa10.topLevelValues(); |
| for (TopLevelTlv topLevelTlv : topLevelTlvList) { |
| if (topLevelTlv instanceof LinkTlv) { |
| LinkTlv linkTlv = (LinkTlv) topLevelTlv; |
| List<LinkSubType> subTypes = linkTlv.subTlvList(); |
| for (LinkSubType type : subTypes) { |
| if (type instanceof UnreservedBandwidth) { |
| UnreservedBandwidth unreservedBandwidth = (UnreservedBandwidth) type; |
| List<Float> bandwidthFloatValues = unreservedBandwidth.getUnReservedBandwidthValue(); |
| List<Bandwidth> bandwidthList = new ArrayList<>(); |
| for (Float value : bandwidthFloatValues) { |
| Bandwidth bandwidth = Bandwidth.bps((double) value); |
| ospfLinkTed.setMaxUnResBandwidth(bandwidth); |
| bandwidthList.add(bandwidth); |
| } |
| } |
| if (type instanceof MaximumBandwidth) { |
| MaximumBandwidth maximumBandwidth = (MaximumBandwidth) type; |
| float maxBandValue = maximumBandwidth.getMaximumBandwidthValue(); |
| Bandwidth bandwidth = Bandwidth.bps((double) maxBandValue); |
| ospfLinkTed.setMaximumLink(bandwidth); |
| } |
| if (type instanceof MaximumReservableBandwidth) { |
| MaximumReservableBandwidth maximumReservableBandwidth = (MaximumReservableBandwidth) type; |
| float maxResBandValue = maximumReservableBandwidth.getMaximumBandwidthValue(); |
| Bandwidth bandwidth = Bandwidth.bps((double) maxResBandValue); |
| ospfLinkTed.setMaxReserved(bandwidth); |
| } |
| if (type instanceof TrafficEngineeringMetric) { |
| TrafficEngineeringMetric trafficEngineeringMetric = (TrafficEngineeringMetric) type; |
| long teMetric = trafficEngineeringMetric.getTrafficEngineeringMetricValue(); |
| ospfLinkTed.setTeMetric((Integer) (int) teMetric); |
| } |
| if (type instanceof LocalInterfaceIpAddress) { |
| LocalInterfaceIpAddress localInterfaceIpAddress = (LocalInterfaceIpAddress) type; |
| List<String> stringValue = localInterfaceIpAddress.getLocalInterfaceIPAddress(); |
| List<Ip4Address> localIp4Address = new ArrayList<>(); |
| for (String value : stringValue) { |
| Ip4Address ip4Address = Ip4Address.valueOf(value); |
| localIp4Address.add(ip4Address); |
| } |
| ospfLinkTed.setIpv4LocRouterId(localIp4Address); |
| } |
| if (type instanceof RemoteInterfaceIpAddress) { |
| RemoteInterfaceIpAddress remoteInterfaceIpAddress = (RemoteInterfaceIpAddress) type; |
| List<String> stringValue = remoteInterfaceIpAddress.getRemoteInterfaceAddress(); |
| List<Ip4Address> remoteIp4Address = new ArrayList<>(); |
| for (String value : stringValue) { |
| Ip4Address ip4Address = Ip4Address.valueOf(value); |
| remoteIp4Address.add(ip4Address); |
| } |
| ospfLinkTed.setIpv4RemRouterId(remoteIp4Address); |
| } |
| } |
| } |
| |
| } |
| ospfLinkTedHashMap.put(adRouterId.toString(), ospfLinkTed); |
| } |
| |
| |
| /** |
| * Adds link information to LinkInformationMap. |
| * |
| * @param advertisingRouter advertising router |
| * @param linkData link data address |
| * @param linkSrc link source address |
| * @param linkDest link destination address |
| * @param opaqueEnabled opaque enabled or not |
| * @param linkSrcIdNotRouterId link source id or not |
| */ |
| public void addLocalLink(String advertisingRouter, Ip4Address linkData, Ip4Address linkSrc, Ip4Address linkDest, |
| boolean opaqueEnabled, boolean linkSrcIdNotRouterId) { |
| String linkKey = "link:"; |
| LinkInformation linkInformation = new LinkInformationImpl(); |
| linkInformation.setLinkId(advertisingRouter); |
| linkInformation.setLinkSourceId(linkSrc); |
| linkInformation.setLinkDestinationId(linkDest); |
| linkInformation.setAlreadyCreated(false); |
| linkInformation.setLinkSrcIdNotRouterId(linkSrcIdNotRouterId); |
| linkInformation.setInterfaceIp(linkData); |
| if (linkDest != null) { |
| linkInformation.setLinkSrcIdNotRouterId(false); |
| } |
| linkKey = linkKey + "-" + linkSrc + "-" + linkDest; |
| setLinkInformationMap(linkKey, linkInformation); |
| } |
| |
| /** |
| * Adds link information to LinkInformationMap for PointToPoint. |
| * |
| * @param advertisingRouter advertising router |
| * @param linkData link data |
| * @param linkSrc link source |
| * @param linkDest link destination |
| * @param opaqueEnabled whether opaque is enabled or not |
| * @param linkSrcIdNotRouterId whether link is source id or router id |
| */ |
| public void addLocalLinkForPointToPoint(String advertisingRouter, Ip4Address linkData, Ip4Address linkSrc, |
| Ip4Address linkDest, boolean opaqueEnabled, boolean linkSrcIdNotRouterId) { |
| String linkKey = "link:"; |
| LinkInformation linkInformation = new LinkInformationImpl(); |
| linkInformation.setLinkId(advertisingRouter); |
| linkInformation.setLinkSourceId(linkSrc); |
| linkInformation.setLinkDestinationId(linkDest); |
| linkInformation.setAlreadyCreated(false); |
| linkInformation.setLinkSrcIdNotRouterId(linkSrcIdNotRouterId); |
| linkInformation.setInterfaceIp(linkData); |
| if (linkDest != null) { |
| linkInformation.setLinkSrcIdNotRouterId(false); |
| } |
| linkKey = linkKey + "-" + linkSrc + "-" + linkDest; |
| setLinkInformationMapForPointToPoint(linkKey, linkInformation); |
| } |
| |
| /** |
| * Removes links from LinkInformationMap. |
| * |
| * @param routerId router id |
| */ |
| public void removeLinks(Ip4Address routerId) { |
| Map<String, LinkInformation> linkInformationMapLocal = linkInformationMap; |
| if (linkInformationMapLocal != null) { |
| for (Map.Entry<String, LinkInformation> entry : linkInformationMap.entrySet()) { |
| String key = entry.getKey(); |
| boolean check = key.contains(routerId.toString()); |
| LinkInformation linkInformation = linkInformationMap.get(key); |
| boolean check1 = (linkInformation.linkDestinationId() == routerId) ? true : false; |
| if (check || check1) { |
| toRemove.add(key); |
| } |
| } |
| removeLinkFromMap(); |
| } |
| } |
| |
| /** |
| * Removes Device from DeviceInformationMap. |
| * |
| * @param routerId router id |
| */ |
| public void removeDevice(Ip4Address routerId) { |
| String key = "device:" + routerId; |
| this.deviceInformationMap.remove(key); |
| } |
| |
| /** |
| * Removes link information from Map. |
| */ |
| private void removeLinkFromMap() { |
| Iterator iterator = toRemove.iterator(); |
| while (iterator.hasNext()) { |
| String key = (String) iterator.next(); |
| removeLinkInformationMap(key); |
| } |
| } |
| |
| /** |
| * Updates the deviceAndLinkInformation list for received OSPF LSA. |
| * |
| * @param ospfLsa OSPF LSA instance |
| * @param ospfArea OSPF area instance |
| */ |
| public void updateLinkInformation(OspfLsa ospfLsa, OspfArea ospfArea) { |
| if (ospfLsa.getOspfLsaType().equals(OspfLsaType.ROUTER)) { |
| RouterLsa routerLsa = (RouterLsa) ospfLsa; |
| routerLsa.lsType(); |
| List<OspfLsaLink> ospfLsaLinkList = routerLsa.routerLink(); |
| for (OspfLsaLink link : ospfLsaLinkList) { |
| if (link.linkType() == 1 || link.linkType() == 2) { |
| if ((routerLsa.advertisingRouter().equals(ospfArea.routerId())) || |
| (link.equals(ospfArea.routerId()))) { |
| log.debug("OspfInterface information will not display in web "); |
| } else { |
| String key = routerLsa.advertisingRouter() + "-" + link.linkData(); |
| Set<OspfLsaLink> linkInformations = new HashSet<>(); |
| if (deviceAndLinkInformation.containsKey(key)) { |
| linkInformations = deviceAndLinkInformation.get(key); |
| linkInformations.add(link); |
| deviceAndLinkInformation.put(key, linkInformations); |
| } else { |
| linkInformations.add(link); |
| deviceAndLinkInformation.put(key, linkInformations); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Gets all the router information which needs to delete from deviceList. |
| * |
| * @param ospfLsa OSPF LSA instance |
| * @param ospfArea OSPF area instance |
| * @return list of deleted router information |
| */ |
| public List<String> getDeleteRouterInformation(OspfLsa ospfLsa, OspfArea ospfArea) { |
| List<String> removedLinkList = new ArrayList<>(); |
| if (ospfLsa.getOspfLsaType().equals(OspfLsaType.ROUTER)) { |
| |
| RouterLsa routerLsa = (RouterLsa) ospfLsa; |
| List<OspfLsaLink> ospfLsaLinkList = routerLsa.routerLink(); |
| for (OspfLsaLink link : ospfLsaLinkList) { |
| if (link.linkType() == 1 || link.linkType() == 2) { |
| if ((routerLsa.advertisingRouter().equals(ospfArea.routerId())) || |
| (link.equals(ospfArea.routerId()))) { |
| log.debug("OspfInterface information will not display in web "); |
| } else { |
| String key = routerLsa.advertisingRouter() + "-" + link.linkData(); |
| Set<OspfLsaLink> linkInformations = deviceAndLinkInformation.get(key); |
| if (linkInformations.contains(link)) { |
| linkInformations.remove(link); |
| deviceAndLinkInformation.put(key, linkInformations); |
| } |
| } |
| } |
| Set<String> keys = deviceAndLinkInformation.keySet(); |
| for (String key : keys) { |
| Set<OspfLsaLink> linkInformations = deviceAndLinkInformation.get(key); |
| for (OspfLsaLink link1 : linkInformations) { |
| String removedLink = link1.linkId(); |
| removedLinkList.add(removedLink); |
| } |
| } |
| } |
| } |
| return removedLinkList; |
| } |
| } |