Java tutorial
/* * Copyright 2016-present Open Networking Laboratory * * 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.tetopology.management.impl; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.LINK_ADDED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.LINK_REMOVED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.LINK_UPDATED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.NETWORK_ADDED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.NETWORK_REMOVED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.NETWORK_UPDATED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.NODE_ADDED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.NODE_REMOVED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.NODE_UPDATED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_LINK_ADDED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_LINK_REMOVED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_LINK_UPDATED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_NODE_ADDED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_NODE_REMOVED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_NODE_UPDATED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_TOPOLOGY_ADDED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_TOPOLOGY_REMOVED; import static org.onosproject.tetopology.management.api.TeTopologyEvent.Type.TE_TOPOLOGY_UPDATED; import static org.slf4j.LoggerFactory.getLogger; import java.util.BitSet; import java.util.List; import java.util.Map; import java.util.concurrent.BlockingQueue; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; import org.apache.felix.scr.annotations.Activate; import org.apache.felix.scr.annotations.Component; import org.apache.felix.scr.annotations.Deactivate; import org.apache.felix.scr.annotations.Reference; import org.apache.felix.scr.annotations.ReferenceCardinality; import org.apache.felix.scr.annotations.Service; import org.onlab.util.KryoNamespace; import org.onosproject.net.DeviceId; import org.onosproject.store.AbstractStore; import org.onosproject.store.serializers.KryoNamespaces; import org.onosproject.store.service.AtomicCounter; import org.onosproject.store.service.ConsistentMap; import org.onosproject.store.service.MapEvent; import org.onosproject.store.service.MapEventListener; import org.onosproject.store.service.Serializer; import org.onosproject.store.service.StorageService; import org.onosproject.tetopology.management.api.CommonTopologyData; import org.onosproject.tetopology.management.api.DefaultNetwork; import org.onosproject.tetopology.management.api.DefaultTeTopologies; import org.onosproject.tetopology.management.api.DefaultTeTopology; import org.onosproject.tetopology.management.api.EncodingType; import org.onosproject.tetopology.management.api.KeyId; import org.onosproject.tetopology.management.api.LongValue; import org.onosproject.tetopology.management.api.Network; import org.onosproject.tetopology.management.api.OptimizationType; import org.onosproject.tetopology.management.api.ProviderClientId; import org.onosproject.tetopology.management.api.SwitchingType; import org.onosproject.tetopology.management.api.TeConstants; import org.onosproject.tetopology.management.api.TeStatus; import org.onosproject.tetopology.management.api.TeTopologies; import org.onosproject.tetopology.management.api.TeTopology; import org.onosproject.tetopology.management.api.TeTopologyEvent; import org.onosproject.tetopology.management.api.TeTopologyEvent.Type; import org.onosproject.tetopology.management.api.TeTopologyId; import org.onosproject.tetopology.management.api.TeTopologyKey; import org.onosproject.tetopology.management.api.TeUtils; import org.onosproject.tetopology.management.api.link.AsNumber; import org.onosproject.tetopology.management.api.link.CommonLinkData; import org.onosproject.tetopology.management.api.link.DefaultNetworkLink; import org.onosproject.tetopology.management.api.link.DefaultTeLink; import org.onosproject.tetopology.management.api.link.ElementType; import org.onosproject.tetopology.management.api.link.ExternalLink; import org.onosproject.tetopology.management.api.link.Label; import org.onosproject.tetopology.management.api.link.LinkBandwidth; import org.onosproject.tetopology.management.api.link.NetworkLink; import org.onosproject.tetopology.management.api.link.NetworkLinkKey; import org.onosproject.tetopology.management.api.link.OduResource; import org.onosproject.tetopology.management.api.link.PathElement; import org.onosproject.tetopology.management.api.link.TeIpv4; import org.onosproject.tetopology.management.api.link.TeIpv6; import org.onosproject.tetopology.management.api.link.TeLink; import org.onosproject.tetopology.management.api.link.TeLinkTpGlobalKey; import org.onosproject.tetopology.management.api.link.TeLinkTpKey; import org.onosproject.tetopology.management.api.link.TePathAttributes; import org.onosproject.tetopology.management.api.link.TunnelProtectionType; import org.onosproject.tetopology.management.api.link.UnderlayAbstractPath; import org.onosproject.tetopology.management.api.link.UnderlayBackupPath; import org.onosproject.tetopology.management.api.link.UnderlayPath; import org.onosproject.tetopology.management.api.link.UnderlayPrimaryPath; import org.onosproject.tetopology.management.api.link.UnnumberedLink; import org.onosproject.tetopology.management.api.node.CommonNodeData; import org.onosproject.tetopology.management.api.node.ConnectivityMatrix; import org.onosproject.tetopology.management.api.node.ConnectivityMatrixKey; import org.onosproject.tetopology.management.api.node.DefaultNetworkNode; import org.onosproject.tetopology.management.api.node.DefaultTeNode; import org.onosproject.tetopology.management.api.node.DefaultTerminationPoint; import org.onosproject.tetopology.management.api.node.DefaultTunnelTerminationPoint; import org.onosproject.tetopology.management.api.node.LocalLinkConnectivity; import org.onosproject.tetopology.management.api.node.NetworkNode; import org.onosproject.tetopology.management.api.node.NetworkNodeKey; import org.onosproject.tetopology.management.api.node.NodeTpKey; import org.onosproject.tetopology.management.api.node.TeNode; import org.onosproject.tetopology.management.api.node.TeNodeKey; import org.onosproject.tetopology.management.api.node.TerminationPoint; import org.onosproject.tetopology.management.api.node.TerminationPointKey; import org.onosproject.tetopology.management.api.node.TtpKey; import org.onosproject.tetopology.management.api.node.TunnelTerminationPoint; import org.slf4j.Logger; import com.esotericsoftware.kryo.serializers.JavaSerializer; import com.google.common.collect.Lists; import com.google.common.collect.Maps; /** * Implementation of the TE network store. */ @Component(immediate = true) @Service public class DistributedTeTopologyStore extends AbstractStore<TeTopologyEvent, TeTopologyStoreDelegate> implements TeTopologyStore { private static final String STORE_NAME = "TE_NETWORK_TOPOLOGY_STORE"; private static final String TETOPOLOGYKEY_INTERNALTETOPOLOGY = "TeTopologyKey-InternalTeTopology"; private static final String NETWORKID_NETWORK = "NetworkId-Network"; private static final String TENODEKEY_INTERNALTENODE = "TeNodeKey-InternalTeNode"; private static final String CONNMATRIXKEY_CONNECTIVITYMATRIX = "ConnMatrixKey-ConnectivityMatrix"; private static final String NETWORKNODEKEY_INTERNALNETWORKNODE = "NetworkNodeKey-InternalNetworkNode"; private static final String TELINKGLOBALKEY_INTERNALTELINK = "TeLinkGlobalKey-InternalTeLink"; private static final String NETWORKLINKKEY_INTERNALNETWORKLINK = "NetworkLinkKey-InternalNetworkLink"; private static final String TPKEY_INTERNALTERMINATIONPOINT = "tpKey-InternalTerminationPoint"; private static final String TELINKTPGLOBALKEY_TERMINATIONPOINTKEY = "TeLinkGlobalKey-TerminationPointKey"; private static final String TTPKEY_TUNNELTERMINATIONPOINT = "TtpKey-TunnelTerminationPoint"; private final Logger log = getLogger(getClass()); @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) protected StorageService storageService; // Track TE topologies by TE Topology key private ConsistentMap<TeTopologyKey, InternalTeTopology> teTopologyConsistentMap; private Map<TeTopologyKey, InternalTeTopology> teTopologyMap; private AtomicCounter nextTeTopologyId; // Listener for te topology events private final MapEventListener<TeTopologyKey, InternalTeTopology> teTopologyListener = new InternalTeTopologyListener(); // Track networks by network Id private ConsistentMap<KeyId, InternalNetwork> networkConsistentMap; private Map<KeyId, InternalNetwork> networkMap; // Listener for network events private final MapEventListener<KeyId, InternalNetwork> networkListener = new InternalNetworkListener(); // Track TE nodes by TE node key private ConsistentMap<TeNodeKey, InternalTeNode> teNodeConsistentMap; private Map<TeNodeKey, InternalTeNode> teNodeMap; // Track ConnectivityMatrix by its key private ConsistentMap<ConnectivityMatrixKey, ConnectivityMatrix> connMatrixConsistentMap; private Map<ConnectivityMatrixKey, ConnectivityMatrix> connMatrixMap; // Track Tunnel Termination Points by its key private ConsistentMap<TtpKey, TunnelTerminationPoint> ttpConsistentMap; private Map<TtpKey, TunnelTerminationPoint> ttpMap; // Listener for TE node events private final MapEventListener<TeNodeKey, InternalTeNode> teNodeListener = new InternalTeNodeListener(); // Track network nodes by network node key private ConsistentMap<NetworkNodeKey, InternalNetworkNode> networkNodeConsistentMap; private Map<NetworkNodeKey, InternalNetworkNode> networkNodeMap; // Listener for network node events private final MapEventListener<NetworkNodeKey, InternalNetworkNode> networkNodeListener = new InternalNetworkNodeListener(); // Track TE links by its key private ConsistentMap<TeLinkTpGlobalKey, InternalTeLink> teLinkConsistentMap; private Map<TeLinkTpGlobalKey, InternalTeLink> teLinkMap; // Listener for te link events private final MapEventListener<TeLinkTpGlobalKey, InternalTeLink> teLinkListener = new InternalTeLinkListener(); // Track network links by network link key private ConsistentMap<NetworkLinkKey, InternalNetworkLink> networkLinkConsistentMap; private Map<NetworkLinkKey, InternalNetworkLink> networkLinkMap; // Listener for network link events private final MapEventListener<NetworkLinkKey, InternalNetworkLink> networkLinkListener = new InternalNetworkLinkListener(); // Track Termination points by termination point key private ConsistentMap<TerminationPointKey, InternalTerminationPoint> tpConsistentMap; private Map<TerminationPointKey, InternalTerminationPoint> tpMap; // Track termination point keys by TE termination point Key private ConsistentMap<TeLinkTpGlobalKey, TerminationPointKey> tpKeyConsistentMap; private Map<TeLinkTpGlobalKey, TerminationPointKey> tpKeyMap; private BlockingQueue<TeTopologyMapEvent> mapEventQueue; private static final Serializer TETOPOLOGY_SERIALIZER = Serializer.using(new KryoNamespace.Builder() .register(KryoNamespaces.API).register(TeTopologyKey.class).register(ProviderClientId.class) .register(TeNodeKey.class).register(TeLinkTpGlobalKey.class).register(CommonTopologyData.class) .register(KeyId.class).register(OptimizationType.class).register(new JavaSerializer(), BitSet.class) .register(InternalTeTopology.class).register(InternalNetwork.class) .register(InternalTerminationPoint.class).register(InternalTeNode.class) .register(InternalNetworkNode.class).register(CommonNodeData.class) .register(ConnectivityMatrixKey.class).register(ConnectivityMatrix.class).register(TtpKey.class) .register(NetworkNodeKey.class).register(TeStatus.class).register(ElementType.class) .register(TeIpv4.class).register(TeIpv6.class).register(AsNumber.class).register(Label.class) .register(UnnumberedLink.class).register(InternalTeLink.class).register(InternalNetworkLink.class) .register(TeLinkTpKey.class).register(NetworkLinkKey.class).register(NodeTpKey.class) .register(CommonLinkData.class).register(SwitchingType.class).register(EncodingType.class) .register(ExternalLink.class).register(UnderlayPath.class).register(LinkBandwidth.class) .register(OduResource.class).register(PathElement.class).register(UnderlayAbstractPath.class) .register(UnderlayBackupPath.class).register(UnderlayPrimaryPath.class).register(TePathAttributes.class) .register(TerminationPoint.class).register(TunnelTerminationPoint.class) .register(DefaultTunnelTerminationPoint.class).register(TerminationPointKey.class) .register(TunnelProtectionType.class).register(LongValue.class).register(LocalLinkConnectivity.class) .build()); /** * Distributed network store service activate method. */ @Activate public void activate() { teTopologyConsistentMap = storageService.<TeTopologyKey, InternalTeTopology>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(TETOPOLOGYKEY_INTERNALTETOPOLOGY) .withRelaxedReadConsistency().build(); teTopologyConsistentMap.addListener(teTopologyListener); teTopologyMap = teTopologyConsistentMap.asJavaMap(); networkConsistentMap = storageService.<KeyId, InternalNetwork>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(NETWORKID_NETWORK).withRelaxedReadConsistency() .build(); networkConsistentMap.addListener(networkListener); networkMap = networkConsistentMap.asJavaMap(); teNodeConsistentMap = storageService.<TeNodeKey, InternalTeNode>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(TENODEKEY_INTERNALTENODE) .withRelaxedReadConsistency().build(); teNodeConsistentMap.addListener(teNodeListener); teNodeMap = teNodeConsistentMap.asJavaMap(); connMatrixConsistentMap = storageService.<ConnectivityMatrixKey, ConnectivityMatrix>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(CONNMATRIXKEY_CONNECTIVITYMATRIX) .withRelaxedReadConsistency().build(); connMatrixMap = connMatrixConsistentMap.asJavaMap(); networkNodeConsistentMap = storageService.<NetworkNodeKey, InternalNetworkNode>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(NETWORKNODEKEY_INTERNALNETWORKNODE) .withRelaxedReadConsistency().build(); networkNodeConsistentMap.addListener(networkNodeListener); networkNodeMap = networkNodeConsistentMap.asJavaMap(); teLinkConsistentMap = storageService.<TeLinkTpGlobalKey, InternalTeLink>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(TELINKGLOBALKEY_INTERNALTELINK) .withRelaxedReadConsistency().build(); teLinkConsistentMap.addListener(teLinkListener); teLinkMap = teLinkConsistentMap.asJavaMap(); networkLinkConsistentMap = storageService.<NetworkLinkKey, InternalNetworkLink>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(NETWORKLINKKEY_INTERNALNETWORKLINK) .withRelaxedReadConsistency().build(); networkLinkConsistentMap.addListener(networkLinkListener); networkLinkMap = networkLinkConsistentMap.asJavaMap(); tpConsistentMap = storageService.<TerminationPointKey, InternalTerminationPoint>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(TPKEY_INTERNALTERMINATIONPOINT) .withRelaxedReadConsistency().build(); tpMap = tpConsistentMap.asJavaMap(); tpKeyConsistentMap = storageService.<TeLinkTpGlobalKey, TerminationPointKey>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(TELINKTPGLOBALKEY_TERMINATIONPOINTKEY) .withRelaxedReadConsistency().build(); tpKeyMap = tpKeyConsistentMap.asJavaMap(); ttpConsistentMap = storageService.<TtpKey, TunnelTerminationPoint>consistentMapBuilder() .withSerializer(TETOPOLOGY_SERIALIZER).withName(TTPKEY_TUNNELTERMINATIONPOINT) .withRelaxedReadConsistency().build(); ttpMap = ttpConsistentMap.asJavaMap(); nextTeTopologyId = storageService.getAtomicCounter("COUNTER_NAME"); log.info("Started"); } /** * Distributed network store service deactivate method. */ @Deactivate public void deactivate() { teTopologyConsistentMap.removeListener(teTopologyListener); teTopologyConsistentMap.destroy(); teTopologyMap.clear(); networkConsistentMap.removeListener(networkListener); networkConsistentMap.destroy(); networkMap.clear(); teNodeConsistentMap.removeListener(teNodeListener); teNodeConsistentMap.destroy(); teNodeMap.clear(); connMatrixConsistentMap.destroy(); connMatrixMap.clear(); networkNodeConsistentMap.destroy(); networkNodeConsistentMap.removeListener(networkNodeListener); networkNodeMap.clear(); teLinkConsistentMap.removeListener(teLinkListener); teLinkConsistentMap.destroy(); teLinkMap.clear(); networkLinkConsistentMap.destroy(); networkLinkConsistentMap.removeListener(networkLinkListener); networkLinkMap.clear(); tpConsistentMap.destroy(); tpMap.clear(); tpKeyConsistentMap.destroy(); tpKeyMap.clear(); ttpConsistentMap.destroy(); ttpMap.clear(); log.info("Stopped"); } /** * Listener class to map listener map events to the TETOPOLOGY events. */ private class InternalTeTopologyListener implements MapEventListener<TeTopologyKey, InternalTeTopology> { @Override public void event(MapEvent<TeTopologyKey, InternalTeTopology> event) { Type type = null; switch (event.type()) { case INSERT: type = TE_TOPOLOGY_ADDED; break; case UPDATE: if (event.newValue().value().childUpdate()) { // Masked by the child events (e.g. Removal) break; } type = TE_TOPOLOGY_UPDATED; break; case REMOVE: type = TE_TOPOLOGY_REMOVED; break; default: log.error("Unsupported event type: {}", event.type()); } if (type != null) { TeTopologyMapEvent mapEvent = new TeTopologyMapEvent(type); mapEvent.setTeTopologyKey(event.key()); try { mapEventQueue.put(mapEvent); } catch (InterruptedException e) { log.warn("Unable to queue event {} ", mapEvent, e); } } } } /** * Listener class to map listener map events to the network events. */ private class InternalNetworkListener implements MapEventListener<KeyId, InternalNetwork> { @Override public void event(MapEvent<KeyId, InternalNetwork> event) { Type type = null; switch (event.type()) { case INSERT: type = NETWORK_ADDED; break; case UPDATE: if (event.newValue().value().childUpdate()) { // Masked by the child events (e.g. Removal) break; } type = NETWORK_UPDATED; break; case REMOVE: type = NETWORK_REMOVED; break; default: log.error("Unsupported event type: {}", event.type()); } if (type != null) { TeTopologyMapEvent mapEvent = new TeTopologyMapEvent(type); mapEvent.setNetworkKey(event.key()); try { mapEventQueue.put(mapEvent); } catch (InterruptedException e) { log.warn("Unable to queue event {} ", mapEvent, e); } } } } /** * Listener class to map listener map events to the TENODE events. */ private class InternalTeNodeListener implements MapEventListener<TeNodeKey, InternalTeNode> { @Override public void event(MapEvent<TeNodeKey, InternalTeNode> event) { // Event should be ignored when the topology is not there. if (teTopologyMap.get(event.key().teTopologyKey()) == null) { return; } Type type = null; switch (event.type()) { case INSERT: if (event.newValue().value().parentUpdate()) { // Masked by the parent event (e.g. Add) break; } type = TE_NODE_ADDED; break; case UPDATE: if (event.newValue().value().childUpdate() || event.newValue().value().parentUpdate()) { // Masked by the child event (e.g. Removal) or parent event break; } type = TE_NODE_UPDATED; break; case REMOVE: type = TE_NODE_REMOVED; break; default: log.error("Unsupported event type: {}", event.type()); } if (type != null) { TeTopologyMapEvent mapEvent = new TeTopologyMapEvent(type); mapEvent.setTeNodeKey(event.key()); try { mapEventQueue.put(mapEvent); } catch (InterruptedException e) { log.warn("Unable to queue event {} ", mapEvent, e); } } } } /** * Listener class to map listener map events to the NETWORK NODE events. */ private class InternalNetworkNodeListener implements MapEventListener<NetworkNodeKey, InternalNetworkNode> { @Override public void event(MapEvent<NetworkNodeKey, InternalNetworkNode> event) { // Event should be ignored when the network is not there. if (networkMap.get(event.key().networkId()) == null) { return; } Type type = null; switch (event.type()) { case INSERT: if (event.newValue().value().parentUpdate()) { // Masked by the parent event (e.g. Add) break; } type = NODE_ADDED; break; case UPDATE: if (event.newValue().value().childUpdate() || event.newValue().value().parentUpdate()) { // Masked by the child event (e.g. Removal) or parent event break; } type = NODE_UPDATED; break; case REMOVE: type = NODE_REMOVED; break; default: log.error("Unsupported event type: {}", event.type()); } if (type != null) { TeTopologyMapEvent mapEvent = new TeTopologyMapEvent(type); mapEvent.setNetworkNodeKey(event.key()); try { mapEventQueue.put(mapEvent); } catch (InterruptedException e) { log.warn("Unable to queue event {} ", mapEvent, e); } } } } /** * Listener class to map listener map events to the TELINK events. */ private class InternalTeLinkListener implements MapEventListener<TeLinkTpGlobalKey, InternalTeLink> { @Override public void event(MapEvent<TeLinkTpGlobalKey, InternalTeLink> event) { // Event should be ignored when the topology or locol node is not there. if (teTopologyMap.get(event.key().teTopologyKey()) == null || teNodeMap.get(event.key().teNodeKey()) == null) { return; } Type type = null; switch (event.type()) { case INSERT: if (event.newValue().value().parentUpdate()) { // Masked by the parent event (e.g. Add) break; } type = TE_LINK_ADDED; break; case UPDATE: if (event.newValue().value().parentUpdate()) { // Masked by parent event break; } type = TE_LINK_UPDATED; break; case REMOVE: type = TE_LINK_REMOVED; break; default: log.error("Unsupported event type: {}", event.type()); } if (type != null) { TeTopologyMapEvent mapEvent = new TeTopologyMapEvent(type); mapEvent.setTeLinkKey(event.key()); try { mapEventQueue.put(mapEvent); } catch (InterruptedException e) { log.warn("Unable to queue event {} ", mapEvent, e); } } } } /** * Listener class to map listener map events to the NETWORK LINK events. */ private class InternalNetworkLinkListener implements MapEventListener<NetworkLinkKey, InternalNetworkLink> { @Override public void event(MapEvent<NetworkLinkKey, InternalNetworkLink> event) { // Event should be ignored when the network is not there. if (networkMap.get(event.key().networkId()) == null) { return; } Type type = null; switch (event.type()) { case INSERT: if (event.newValue().value().parentUpdate()) { // Masked by the parent event (e.g. Add) break; } type = LINK_ADDED; break; case UPDATE: if (event.newValue().value().parentUpdate()) { // Masked by the child event (e.g. Removal) or parent event break; } type = LINK_UPDATED; break; case REMOVE: type = LINK_REMOVED; break; default: log.error("Unsupported event type: {}", event.type()); } if (type != null) { TeTopologyMapEvent mapEvent = new TeTopologyMapEvent(type); mapEvent.setNetworkLinkKey(event.key()); try { mapEventQueue.put(mapEvent); } catch (InterruptedException e) { log.warn("Unable to queue event {} ", mapEvent, e); } } } } @Override public TeTopologies teTopologies() { Map<TeTopologyKey, TeTopology> teTopologies = Maps.newHashMap(); if (MapUtils.isNotEmpty(teTopologyMap)) { for (TeTopologyKey key : teTopologyMap.keySet()) { teTopologies.put(key, teTopology(key)); } } return new DefaultTeTopologies(STORE_NAME, teTopologies); } private TeTopology teTopology(TeTopologyKey topologyId, InternalTeTopology intTopology) { if (intTopology == null) { return null; } Map<Long, TeNode> teNodes = null; if (CollectionUtils.isNotEmpty(intTopology.teNodeKeys())) { teNodes = Maps.newHashMap(); for (TeNodeKey key : intTopology.teNodeKeys()) { teNodes.put(key.teNodeId(), teNode(key)); } } Map<TeLinkTpKey, TeLink> teLinks = null; if (CollectionUtils.isNotEmpty(intTopology.teLinkKeys())) { teLinks = Maps.newHashMap(); for (TeLinkTpGlobalKey key : intTopology.teLinkKeys()) { teLinks.put(key.teLinkTpKey(), teLink(key)); } } return new DefaultTeTopology(topologyId, teNodes, teLinks, intTopology.teTopologyId(), intTopology.topologyData()); } @Override public TeTopology teTopology(TeTopologyKey topologyId) { InternalTeTopology intTopology = teTopologyMap.get(topologyId); return teTopology(topologyId, intTopology); } private void removeTopologyeMapEntrys(InternalTeTopology curTopology) { // Remove TE nodes if (CollectionUtils.isNotEmpty(curTopology.teNodeKeys())) { for (TeNodeKey key : curTopology.teNodeKeys()) { removeTeNode(key, true); } } // Remove TE Links if (CollectionUtils.isNotEmpty(curTopology.teLinkKeys())) { for (TeLinkTpGlobalKey key : curTopology.teLinkKeys()) { removeTeLink(key, true); } } } @Override public void updateTeTopology(TeTopology teTopology) { InternalTeTopology curTopology = teTopologyMap.get(teTopology.teTopologyId()); // Update TE nodes List<NetworkNodeKey> nodeIds = null; if (MapUtils.isNotEmpty(teTopology.teNodes())) { nodeIds = Lists.newArrayList(); for (Map.Entry<Long, TeNode> entry : teTopology.teNodes().entrySet()) { TeNodeKey teNodeKey = new TeNodeKey(teTopology.teTopologyId(), entry.getKey()); NetworkNodeKey nodeKey = TeMgrUtil.networkNodeKey(teNodeKey); updateTeNode(teNodeKey, entry.getValue(), true, true, nodeKey); nodeIds.add(nodeKey); } } // Update TE links List<NetworkLinkKey> linkIds = null; if (MapUtils.isNotEmpty(teTopology.teLinks())) { linkIds = Lists.newArrayList(); for (Map.Entry<TeLinkTpKey, TeLink> entry : teTopology.teLinks().entrySet()) { TeLinkTpGlobalKey teLinkKey = new TeLinkTpGlobalKey(teTopology.teTopologyId(), entry.getKey()); NetworkLinkKey linkKey = TeMgrUtil.networkLinkKey(teLinkKey); updateTeLink(teLinkKey, entry.getValue(), true, true, linkKey); linkIds.add(linkKey); } } // Finally Update teTopologyMap InternalTeTopology newTopology = new InternalTeTopology(teTopology); teTopologyMap.put(teTopology.teTopologyId(), newTopology); if (curTopology == null) { // New topology, update networkMap InternalNetwork intNetwork = new InternalNetwork(); intNetwork.setServerProvided(false); intNetwork.setTeTopologyKey(teTopology.teTopologyId()); intNetwork.setNodeIds(nodeIds); intNetwork.setLinkIds(linkIds); networkMap.put(teTopology.networkId(), intNetwork); } } @Override public void removeTeTopology(TeTopologyKey topologyId) { // Remove it from teTopologyMap InternalTeTopology topology = teTopologyMap.remove(topologyId); if (topology != null) { removeTopologyeMapEntrys(topology); // Remove it from networkMap; networkMap.remove(topology.topologyData().networkId()); } } @Override public List<Network> networks() { if (MapUtils.isEmpty(networkMap)) { return null; } List<Network> networks = Lists.newArrayList(); for (KeyId networkId : networkMap.keySet()) { networks.add(network(networkId)); } return networks; } private Network network(KeyId networkId, InternalNetwork curNetwork) { if (curNetwork == null) { return null; } List<KeyId> supportingNetworkIds = curNetwork.supportingNetworkIds(); Map<KeyId, NetworkNode> nodes = null; if (CollectionUtils.isNotEmpty(curNetwork.nodeIds())) { nodes = Maps.newHashMap(); for (NetworkNodeKey key : curNetwork.nodeIds()) { nodes.put(key.nodeId(), networkNode(key)); } } Map<KeyId, NetworkLink> links = null; if (CollectionUtils.isNotEmpty(curNetwork.linkIds())) { links = Maps.newHashMap(); for (NetworkLinkKey key : curNetwork.linkIds()) { links.put(key.linkId(), networkLink(key)); } } TeTopologyId topologyId = null; DeviceId ownerId = null; if (curNetwork.teTopologyKey() != null && teTopologyMap.get(curNetwork.teTopologyKey()) != null) { topologyId = new TeTopologyId(curNetwork.teTopologyKey().providerId(), curNetwork.teTopologyKey().clientId(), teTopologyMap.get(curNetwork.teTopologyKey()).teTopologyId()); ownerId = teTopologyMap.get(curNetwork.teTopologyKey()).topologyData().ownerId(); } return new DefaultNetwork(networkId, supportingNetworkIds, nodes, links, topologyId, curNetwork.serverProvided(), ownerId); } @Override public Network network(KeyId networkId) { InternalNetwork curNetwork = networkMap.get(networkId); return network(networkId, curNetwork); } private void removeNetworkMapEntrys(InternalNetwork curNetwork, boolean teRemove) { // Remove TE nodes if (CollectionUtils.isNotEmpty(curNetwork.nodeIds())) { for (NetworkNodeKey key : curNetwork.nodeIds()) { removeNetworkNode(key, teRemove); } } // Remove TE Links if (CollectionUtils.isNotEmpty(curNetwork.linkIds())) { for (NetworkLinkKey key : curNetwork.linkIds()) { removeNetworkLink(key, teRemove); } } } private TeTopologyKey newTeTopologyKey(TeTopologyId teTopologyId) { long idValue; try { idValue = Long.parseLong(teTopologyId.topologyId()); } catch (NumberFormatException e) { // Can't get the long value from the string. // Use an assigned id value from local id pool, // Ideally id should be assigned per provider base. idValue = nextTeTopologyId(); } return new TeTopologyKey(teTopologyId.providerId(), teTopologyId.clientId(), idValue); } @Override public void updateNetwork(Network network) { InternalNetwork curNetwork = networkMap.get(network.networkId()); TeTopologyKey topoKey = null; if (network.teTopologyId() != null) { topoKey = newTeTopologyKey(network.teTopologyId()); } // Update TE nodes List<TeNodeKey> teNodeKeys = null; if (MapUtils.isNotEmpty(network.nodes())) { teNodeKeys = Lists.newArrayList(); for (Map.Entry<KeyId, NetworkNode> entry : network.nodes().entrySet()) { NetworkNodeKey nodeKey = new NetworkNodeKey(network.networkId(), entry.getKey()); TeNodeKey teNodeKey = null; if (topoKey != null && entry.getValue().teNode() != null) { teNodeKey = new TeNodeKey(topoKey, entry.getValue().teNode().teNodeId()); } updateNetworkNode(nodeKey, entry.getValue(), true, false, teNodeKey); teNodeKeys.add(teNodeKey); } } // Update TE links List<TeLinkTpGlobalKey> teLinkKeys = null; if (MapUtils.isNotEmpty(network.links())) { teLinkKeys = Lists.newArrayList(); for (Map.Entry<KeyId, NetworkLink> entry : network.links().entrySet()) { NetworkLinkKey linkKey = new NetworkLinkKey(network.networkId(), entry.getKey()); TeLinkTpGlobalKey teLinkKey = null; if (topoKey != null && entry.getValue().teLink() != null) { teLinkKey = new TeLinkTpGlobalKey(topoKey, entry.getValue().teLink().teLinkKey()); } updateNetworkLink(linkKey, entry.getValue(), true, false, teLinkKey); teLinkKeys.add(teLinkKey); } } // New network, update TE Topology first if (curNetwork == null) { InternalTeTopology intTopo = new InternalTeTopology(network.teTopologyId().topologyId()); intTopo.setTeNodeKeys(teNodeKeys); intTopo.setTeLinkKeys(teLinkKeys); BitSet flags = new BitSet(TeConstants.FLAG_MAX_BITS); flags.set(TeTopology.BIT_LEARNT); if (network.teTopologyId().clientId() == TeTopologyManager.DEFAULT_PROVIDER_ID) { // Hard rule for now flags.set(TeTopology.BIT_CUSTOMIZED); } CommonTopologyData common = new CommonTopologyData(network.networkId(), OptimizationType.NOT_OPTIMIZED, flags, network.ownerId()); intTopo.setTopologydata(common); teTopologyMap.put(topoKey, intTopo); } // Finally Update networkMap InternalNetwork newNetwork = new InternalNetwork(network); newNetwork.setTeTopologyKey(topoKey); networkMap.put(network.networkId(), newNetwork); } @Override public void removeNetwork(KeyId networkId) { // Remove it from networkMap InternalNetwork network = networkMap.remove(networkId); if (network != null && network.teTopologyKey() != null) { removeNetworkMapEntrys(network, false); teTopologyMap.remove(network.teTopologyKey()); } } private TeNode teNode(TeNodeKey nodeKey, InternalTeNode intNode) { if (intNode == null) { return null; } Map<Long, ConnectivityMatrix> connMatrices = null; if (CollectionUtils.isNotEmpty(intNode.connMatrixKeys())) { connMatrices = Maps.newHashMap(); for (ConnectivityMatrixKey key : intNode.connMatrixKeys()) { connMatrices.put(key.entryId(), connMatrixMap.get(key)); } } List<Long> teLinkIds = null; if (CollectionUtils.isNotEmpty(intNode.teLinkTpKeys())) { teLinkIds = Lists.newArrayList(); for (TeLinkTpGlobalKey key : intNode.teLinkTpKeys()) { teLinkIds = TeUtils.addListElement(teLinkIds, key.teLinkTpId()); } } List<Long> tps = null; if (CollectionUtils.isNotEmpty(intNode.teTpKeys())) { tps = Lists.newArrayList(); for (TeLinkTpGlobalKey key : intNode.teTpKeys()) { tps = TeUtils.addListElement(tps, key.teLinkTpId()); } } Map<Long, TunnelTerminationPoint> ttps = null; if (CollectionUtils.isNotEmpty(intNode.ttpKeys())) { ttps = Maps.newHashMap(); for (TtpKey key : intNode.ttpKeys()) { ttps.put(key.ttpId(), ttpMap.get(key)); } } return new DefaultTeNode(nodeKey.teNodeId(), intNode.underlayTopologyKey(), intNode.supportNodeKey(), intNode.sourceTeNodeKey(), intNode.teData(), connMatrices, teLinkIds, ttps, tps); } @Override public TeNode teNode(TeNodeKey nodeKey) { InternalTeNode intNode = teNodeMap.get(nodeKey); return teNode(nodeKey, intNode); } private void removeTeNodeMapEntrys(InternalTeNode intNode) { // Remove connMatrixMap entries for the node if (CollectionUtils.isNotEmpty(intNode.connMatrixKeys())) { for (ConnectivityMatrixKey key : intNode.connMatrixKeys()) { connMatrixMap.remove(key); } } // Remove ttpMap entries for the node if (CollectionUtils.isNotEmpty(intNode.ttpKeys())) { for (TtpKey key : intNode.ttpKeys()) { ttpMap.remove(key); } } } private void updateTeNode(TeNodeKey nodeKey, TeNode node, boolean parentUpdate, boolean teNodeUpdate, NetworkNodeKey networkNodeKey) { InternalTeTopology intTopo = teTopologyMap.get(nodeKey.teTopologyKey()); if (intTopo == null && !parentUpdate) { log.error("TE Topology is not in dataStore for nodeUpdate {}", nodeKey); return; } InternalTeNode curNode = teNodeMap.get(nodeKey); // Update connMatrixMap if (MapUtils.isNotEmpty(node.connectivityMatrices())) { for (Map.Entry<Long, ConnectivityMatrix> entry : node.connectivityMatrices().entrySet()) { connMatrixMap.put(new ConnectivityMatrixKey(nodeKey, entry.getKey()), entry.getValue()); } } // Update ttpMap if (MapUtils.isNotEmpty(node.tunnelTerminationPoints())) { for (Map.Entry<Long, TunnelTerminationPoint> entry : node.tunnelTerminationPoints().entrySet()) { ttpMap.put(new TtpKey(nodeKey, entry.getKey()), entry.getValue()); } } // Update teNodeMap InternalTeNode intNode = new InternalTeNode(nodeKey, node, networkNodeKey, parentUpdate); teNodeMap.put(nodeKey, intNode); if (curNode == null && !parentUpdate && intTopo != null) { // Update InternalTeTopology intTopo.setChildUpdate(true); TeUtils.addListElement(intTopo.teNodeKeys(), nodeKey); } // Update networkNodeMap if (teNodeUpdate) { updateNetworkNode(networkNodeKey, networkNode(node), parentUpdate, teNodeUpdate, nodeKey); } } private NetworkNode networkNode(TeNode node) { KeyId nodeId = KeyId.keyId(Long.toString(node.teNodeId())); List<NetworkNodeKey> supportingNodeIds = null; if (node.supportingTeNodeId() != null) { supportingNodeIds = Lists.newArrayList(); supportingNodeIds .add(new NetworkNodeKey(TeMgrUtil.toNetworkId((node.supportingTeNodeId().teTopologyKey())), KeyId.keyId(Long.toString(node.supportingTeNodeId().teNodeId())))); } Map<KeyId, TerminationPoint> tps = null; if (node.teTerminationPointIds() != null) { tps = Maps.newHashMap(); for (Long teTpId : node.teTerminationPointIds()) { tps.put(KeyId.keyId(Long.toString(teTpId)), new DefaultTerminationPoint(KeyId.keyId(Long.toString(teTpId)), null, teTpId)); } } return new DefaultNetworkNode(nodeId, supportingNodeIds, node, tps); } @Override public void updateTeNode(TeNodeKey nodeKey, TeNode node) { updateTeNode(nodeKey, node, false, true, TeMgrUtil.networkNodeKey(nodeKey)); } private void removeTeNode(TeNodeKey nodeKey, boolean teNodeRemove) { // Remove it from InternalTeTopology first InternalTeTopology intTopo = teTopologyMap.get(nodeKey.teTopologyKey()); if (intTopo != null && CollectionUtils.isNotEmpty(intTopo.teNodeKeys())) { intTopo.setChildUpdate(true); intTopo.teNodeKeys().remove(nodeKey); } // Then remove it from teNodeMap InternalTeNode node = teNodeMap.remove(nodeKey); removeTeNodeMapEntrys(node); // Remove it from networkNodeMap if (teNodeRemove && node != null) { removeNetworkNode(node.networkNodeKey(), teNodeRemove); } } @Override public void removeTeNode(TeNodeKey nodeKey) { removeTeNode(nodeKey, true); } private NetworkNode networkNode(NetworkNodeKey nodeKey, InternalNetworkNode intNode) { if (intNode == null) { return null; } Map<KeyId, TerminationPoint> tps = Maps.newHashMap(); for (KeyId tpId : intNode.tpIds()) { tps.put(tpId, terminationPoint(new TerminationPointKey(nodeKey, tpId))); } return new DefaultNetworkNode(nodeKey.nodeId(), intNode.supportingNodeIds(), teNode(intNode.teNodeKey()), tps); } @Override public NetworkNode networkNode(NetworkNodeKey nodeKey) { InternalNetworkNode intNode = networkNodeMap.get(nodeKey); return networkNode(nodeKey, intNode); } private void updateNetworkNode(NetworkNodeKey nodeKey, NetworkNode node, boolean parentUpdate, boolean teNodeUpdate, TeNodeKey teNodeKey) { InternalNetwork intNework = null; if (!parentUpdate) { intNework = networkMap.get(nodeKey.networkId()); if (intNework == null) { log.error("Network is not in dataStore for nodeUpdate {}", nodeKey); return; } } InternalNetworkNode exNode = networkNodeMap.get(nodeKey); if (exNode != null && CollectionUtils.isNotEmpty(exNode.tpIds())) { // Remove the TerminationPoints first for (KeyId tpId : exNode.tpIds()) { removeTerminationPoint(new TerminationPointKey(nodeKey, tpId)); } } if (MapUtils.isNotEmpty(node.terminationPoints())) { // Update with new TerminationPoints for (Map.Entry<KeyId, TerminationPoint> entry : node.terminationPoints().entrySet()) { updateTerminationPoint(new TerminationPointKey(nodeKey, entry.getKey()), entry.getValue(), parentUpdate, teNodeKey); } } // Update teNodeMap first if (!teNodeUpdate && teNodeKey != null && node.teNode() != null) { updateTeNode(teNodeKey, node.teNode(), parentUpdate, teNodeUpdate, nodeKey); } // Update networkNodeMap InternalNetworkNode intNode = new InternalNetworkNode(node, parentUpdate); intNode.setTeNodeKey(teNodeKey); networkNodeMap.put(nodeKey, intNode); if (exNode == null && !parentUpdate && intNework != null) { // Update the InternalNetwork intNework.setChildUpdate(true); TeUtils.addListElement(intNework.nodeIds(), nodeKey); } } @Override public void updateNetworkNode(NetworkNodeKey nodeKey, NetworkNode node) { TeNodeKey teNodeKey = null; if (node.teNode() != null) { teNodeKey = new TeNodeKey(networkMap.get(nodeKey.networkId()).teTopologyKey(), node.teNode().teNodeId()); } updateNetworkNode(nodeKey, node, false, false, teNodeKey); } private void removeNetworkNode(NetworkNodeKey nodeKey, boolean teNodeRemove) { // Update the InternalNetwork InternalNetwork intNework = networkMap.get(nodeKey.networkId()); if (intNework != null && CollectionUtils.isNotEmpty(intNework.nodeIds())) { intNework.setChildUpdate(true); intNework.nodeIds().remove(nodeKey.nodeId()); } InternalNetworkNode intNode = networkNodeMap.remove(nodeKey); if (intNode != null && CollectionUtils.isNotEmpty(intNode.tpIds())) { // Remove the TerminationPoints first for (KeyId tpId : intNode.tpIds()) { removeTerminationPoint(new TerminationPointKey(nodeKey, tpId)); } } if (!teNodeRemove && intNode != null) { // Now remove it from teNodeMap removeTeNode(intNode.teNodeKey(), teNodeRemove); } } @Override public void removeNetworkNode(NetworkNodeKey nodeKey) { removeNetworkNode(nodeKey, false); } private TeLink teLink(TeLinkTpGlobalKey linkKey, InternalTeLink intLink) { if (intLink == null) { return null; } return new DefaultTeLink(linkKey.teLinkTpKey(), intLink.peerTeLinkKey(), intLink.underlayTopologyKey(), intLink.supportingLinkKey(), intLink.sourceTeLinkKey(), intLink.teData()); } @Override public TeLink teLink(TeLinkTpGlobalKey linkKey) { InternalTeLink intLink = teLinkMap.get(linkKey); return teLink(linkKey, intLink); } private void updateTeLink(TeLinkTpGlobalKey linkKey, TeLink link, boolean parentUpdate, boolean teLinkUpdate, NetworkLinkKey networkLinkKey) { InternalTeTopology intTopo = teTopologyMap.get(linkKey.teTopologyKey()); if (intTopo == null && !parentUpdate) { log.error("TE Topology is not in dataStore for linkUpdate {}", linkKey); return; } InternalTeNode intNode = teNodeMap.get(linkKey.teNodeKey()); if (intNode == null && !parentUpdate) { log.error("TE node is not in dataStore for linkUpdate {}", linkKey); return; } InternalTeLink exLink = teLinkMap.get(linkKey); // Update teLinkMap InternalTeLink intLink = new InternalTeLink(link, parentUpdate); intLink.setNetworkLinkKey(networkLinkKey); teLinkMap.put(linkKey, intLink); if (exLink == null && !parentUpdate) { if (intTopo != null) { // Update the InternalTeTopology intTopo.setChildUpdate(true); intTopo.setTeLinkKeys(TeUtils.addListElement(intTopo.teLinkKeys(), linkKey)); } if (intNode != null) { // Update the InternalNode intNode.setChildUpdate(true); intNode.setTeLinkTpKeys(TeUtils.addListElement(intNode.teLinkTpKeys(), linkKey)); } } // Update networkLinkMap if (teLinkUpdate) { updateNetworkLink(networkLinkKey, networkLink(link), parentUpdate, teLinkUpdate, linkKey); } } private NetworkLink networkLink(TeLink link) { KeyId linkId = TeMgrUtil.toNetworkLinkId(link.teLinkKey()); NodeTpKey source = null; if (link.teLinkKey() != null) { source = new NodeTpKey(KeyId.keyId(Long.toString(link.teLinkKey().teNodeId())), KeyId.keyId(Long.toString(link.teLinkKey().teLinkTpId()))); } NodeTpKey dest = null; if (link.peerTeLinkKey() != null) { dest = new NodeTpKey(KeyId.keyId(Long.toString(link.peerTeLinkKey().teNodeId())), KeyId.keyId(Long.toString(link.peerTeLinkKey().teLinkTpId()))); } List<NetworkLinkKey> supportingLinkIds = null; if (link.supportingTeLinkId() != null) { supportingLinkIds = Lists.newArrayList(); supportingLinkIds .add(new NetworkLinkKey(TeMgrUtil.toNetworkId(link.supportingTeLinkId().teTopologyKey()), TeMgrUtil.toNetworkLinkId(link.supportingTeLinkId().teLinkTpKey()))); } return new DefaultNetworkLink(linkId, source, dest, supportingLinkIds, link); } @Override public void updateTeLink(TeLinkTpGlobalKey linkKey, TeLink link) { updateTeLink(linkKey, link, false, true, TeMgrUtil.networkLinkKey(linkKey)); } private void removeTeLink(TeLinkTpGlobalKey linkKey, boolean teLinkRemove) { // Remove it from InternalTeTopology first InternalTeTopology intTopo = teTopologyMap.get(linkKey.teTopologyKey()); if (intTopo != null && CollectionUtils.isNotEmpty(intTopo.teLinkKeys())) { intTopo.setChildUpdate(true); intTopo.teLinkKeys().remove(linkKey); } // Remove it from InternalTeNode InternalTeNode intNode = teNodeMap.get(linkKey.teNodeKey()); if (intNode != null && CollectionUtils.isNotEmpty(intNode.teLinkTpKeys())) { intNode.setChildUpdate(true); intNode.teLinkTpKeys().remove(linkKey); } // Then remove it from teLinkMap InternalTeLink link = teLinkMap.remove(linkKey); if (teLinkRemove && link != null) { // Remove it from networkLinkMap removeNetworkLink(link.networkLinkKey(), teLinkRemove); } } @Override public void removeTeLink(TeLinkTpGlobalKey linkKey) { removeTeLink(linkKey, true); } private NetworkLink networkLink(NetworkLinkKey linkKey, InternalNetworkLink intLink) { if (intLink == null) { return null; } return new DefaultNetworkLink(linkKey.linkId(), intLink.source(), intLink.destination(), intLink.supportingLinkIds(), teLink(intLink.teLinkKey())); } @Override public NetworkLink networkLink(NetworkLinkKey linkKey) { InternalNetworkLink intLink = networkLinkMap.get(linkKey); return networkLink(linkKey, intLink); } private void updateNetworkLink(NetworkLinkKey linkKey, NetworkLink link, boolean parentUpdate, boolean teLinkUpdate, TeLinkTpGlobalKey teLinkKey) { InternalNetwork intNework = null; if (!parentUpdate) { intNework = networkMap.get(linkKey.networkId()); if (intNework == null) { log.error("Network is not in dataStore for linkUpdate {}", linkKey); return; } } InternalNetworkLink exLink = networkLinkMap.get(linkKey); // Now update teLinkMap first if (!teLinkUpdate && teLinkKey != null) { updateTeLink(teLinkKey, link.teLink(), parentUpdate, teLinkUpdate, linkKey); } // Update networkLinkMap InternalNetworkLink intLink = new InternalNetworkLink(link, parentUpdate); intLink.setTeLinkKey(teLinkKey); networkLinkMap.put(linkKey, intLink); if (exLink == null && !parentUpdate && intNework != null) { // Update the InternalNetwork intNework.setChildUpdate(true); TeUtils.addListElement(intNework.linkIds(), linkKey); } } @Override public void updateNetworkLink(NetworkLinkKey linkKey, NetworkLink link) { TeLinkTpGlobalKey teLinkKey = null; if (link.teLink() != null) { teLinkKey = new TeLinkTpGlobalKey(networkMap.get(linkKey.networkId()).teTopologyKey(), link.teLink().teLinkKey()); } updateNetworkLink(linkKey, link, false, false, teLinkKey); } private void removeNetworkLink(NetworkLinkKey linkKey, boolean teLinkRemove) { // Update the InternalNetwork InternalNetwork intNework = networkMap.get(linkKey.networkId()); if (intNework != null && CollectionUtils.isNotEmpty(intNework.linkIds())) { intNework.setChildUpdate(true); intNework.linkIds().remove(linkKey.linkId()); } // Remove it from networkLinkMap InternalNetworkLink intLink = networkLinkMap.remove(linkKey); if (!teLinkRemove && intLink != null && intLink.teLinkKey() != null) { // Now remove it from teLinkMap removeTeLink(intLink.teLinkKey(), teLinkRemove); } } @Override public void removeNetworkLink(NetworkLinkKey linkKey) { removeNetworkLink(linkKey, false); } private TerminationPoint terminationPoint(TerminationPointKey tpKey) { InternalTerminationPoint intTp = tpMap.get(tpKey); if (intTp == null) { return null; } return new DefaultTerminationPoint(tpKey.tpId(), intTp.supportingTpIds(), intTp.teTpKey().teLinkTpId()); } private void updateTerminationPoint(TerminationPointKey tpKey, TerminationPoint tp, boolean parentUpdate, TeNodeKey teNodeKey) { TeNodeKey myTeNodeKey; InternalNetworkNode intNode = null; if (!parentUpdate) { intNode = networkNodeMap.get(tpKey.nodeId()); if (intNode == null) { log.error(" node is not in dataStore for tp update {}", tpKey); return; } myTeNodeKey = intNode.teNodeKey(); } else { myTeNodeKey = teNodeKey; } TeLinkTpGlobalKey teTpKey = new TeLinkTpGlobalKey(myTeNodeKey, tp.teTpId()); boolean newTp = tpMap.get(tpKey) == null; InternalTerminationPoint intTp = new InternalTerminationPoint(tp); intTp.setTeTpKey(teTpKey); tpMap.put(tpKey, intTp); if (newTp) { // Update tpKeyMap tpKeyMap.put(teTpKey, tpKey); if (!parentUpdate && intNode != null) { // Update InternalNetworkNode intNode.setChildUpdate(true); intNode.setTpIds(TeUtils.addListElement(intNode.tpIds(), tpKey.tpId())); } } } @Override public void updateTerminationPoint(TerminationPointKey tpKey, TerminationPoint tp) { updateTerminationPoint(tpKey, tp, false, null); } @Override public void removeTerminationPoint(TerminationPointKey tpKey) { // Update InternalNetworkNode InternalNetworkNode intNode = networkNodeMap.get(tpKey.nodeId()); if (intNode != null && CollectionUtils.isNotEmpty(intNode.tpIds())) { intNode.setChildUpdate(true); intNode.tpIds().remove(tpKey.tpId()); } // Remove it from tpMap InternalTerminationPoint tp = tpMap.remove(tpKey); // Remove it from tpKeyMap if (tp != null) { tpKeyMap.remove(tp.teTpKey()); } } @Override public TunnelTerminationPoint tunnelTerminationPoint(TtpKey ttpId) { return ttpMap.get(ttpId); } @Override public long nextTeTopologyId() { return nextTeTopologyId.getAndIncrement(); } @Override public long nextTeNodeId(TeTopologyKey topoKey) { return teTopologyMap.get(topoKey).nextTeNodeId(); } @Override public void setNextTeNodeId(TeTopologyKey topoKey, long nextNodeId) { teTopologyMap.get(topoKey).setNextTeNodeId(nextNodeId); } @Override public KeyId networkId(TeTopologyKey teTopologyKey) { return teTopologyMap.get(teTopologyKey).topologyData().networkId(); } @Override public NetworkNodeKey nodeKey(TeNodeKey teNodeKey) { return teNodeMap.get(teNodeKey).networkNodeKey(); } @Override public NetworkLinkKey linkKey(TeLinkTpGlobalKey teLinkKey) { return teLinkMap.get(teLinkKey).networkLinkKey(); } @Override public TerminationPointKey terminationPointKey(TeLinkTpGlobalKey teTpKey) { return tpKeyMap.get(teTpKey); } @Override public void setMapEventQueue(BlockingQueue<TeTopologyMapEvent> queue) { mapEventQueue = queue; } }