mdsalutil/mdsalutil-impl/src/main/java/org/opendaylight/genius/utils/hwvtep/internal/HwvtepNodeHACacheImpl.java

   1 /*
   2  * Copyright (c) 2017 Inocybe Technologies and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.utils.hwvtep.internal;
   9
  10 import com.google.common.collect.ImmutableMap;
  11 import java.util.Collections;
  12 import java.util.Map;
  13 import java.util.Set;
  14 import java.util.concurrent.ConcurrentHashMap;
  15 import javax.inject.Singleton;
  16 import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
  17 import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
  18 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  19 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  20
  21 /**
  22  * Implementation of HwvtepNodeHACache.
  23  *
  24  * @author Thomas Pantelis
  25  */
  26 @Singleton
  27 public class HwvtepNodeHACacheImpl implements HwvtepNodeHACache {
  28     private final ConcurrentHashMap<InstanceIdentifier<Node>, Set<InstanceIdentifier<Node>>> parentToChildMap =
  29             new ConcurrentHashMap<>();
  30
  31     private final ConcurrentHashMap<InstanceIdentifier<Node>, InstanceIdentifier<Node>> childToParentMap =
  32             new ConcurrentHashMap<>();
  33
  34     private final Set<String> childNodeIds = ConcurrentHashMap.newKeySet();
  35
  36     private final ConcurrentHashMap<String, Boolean> connectedNodes = new ConcurrentHashMap<>();
  37
  38     @Override
  39     public void addChild(InstanceIdentifier<Node> parentId, InstanceIdentifier<Node> childId) {
  40         if (parentId == null || childId == null) {
  41             return;
  42         }
  43
  44         parentToChildMap.computeIfAbsent(parentId, key -> ConcurrentHashMap.newKeySet()).add(childId);
  45         childToParentMap.put(childId, parentId);
  46         String childNodeId = childId.firstKeyOf(Node.class).getNodeId().getValue();
  47         childNodeIds.add(childNodeId);
  48     }
  49
  50     @Override
  51     public boolean isHAEnabledDevice(InstanceIdentifier<?> iid) {
  52         if (iid == null) {
  53             return false;
  54         }
  55         boolean enabled = childToParentMap.containsKey(iid.firstIdentifierOf(Node.class));
  56         if (!enabled) {
  57             String psNodeId = iid.firstKeyOf(Node.class).getNodeId().getValue();
  58             int idx = psNodeId.indexOf(HwvtepSouthboundConstants.PSWITCH_URI_PREFIX);
  59             if (idx > 0) {
  60                 String globalNodeId = psNodeId.substring(0, idx - 1);
  61                 return childNodeIds.contains(globalNodeId);
  62             }
  63         }
  64         return enabled;
  65     }
  66
  67     @Override
  68     public  boolean isHAParentNode(InstanceIdentifier<Node> nodeId) {
  69         return parentToChildMap.containsKey(nodeId);
  70     }
  71
  72     @Override
  73     public Set<InstanceIdentifier<Node>> getChildrenForHANode(InstanceIdentifier<Node> parentId) {
  74         Set<InstanceIdentifier<Node>> children = parentId != null ? parentToChildMap.get(parentId) : null;
  75         return children != null ? children : Collections.emptySet();
  76     }
  77
  78     @Override
  79     public Set<InstanceIdentifier<Node>> getHAParentNodes() {
  80         return parentToChildMap.keySet();
  81     }
  82
  83     @Override
  84     public Set<InstanceIdentifier<Node>> getHAChildNodes() {
  85         return childToParentMap.keySet();
  86     }
  87
  88     @Override
  89     public InstanceIdentifier<Node> getParent(InstanceIdentifier<Node> childId) {
  90         return childId != null ? childToParentMap.get(childId) : null;
  91     }
  92
  93     @Override
  94     public void removeParent(InstanceIdentifier<Node> parentId) {
  95         if (parentId == null) {
  96             return;
  97         }
  98
  99         if (parentToChildMap.get(parentId) != null) {
 100             Set<InstanceIdentifier<Node>> childs = parentToChildMap.get(parentId);
 101             for (InstanceIdentifier<Node> child : childs) {
 102                 childToParentMap.remove(child);
 103                 String childNodeId = child.firstKeyOf(Node.class).getNodeId().getValue();
 104                 childNodeIds.remove(childNodeId);
 105             }
 106         }
 107         parentToChildMap.remove(parentId);
 108     }
 109
 110     @Override
 111     public void updateConnectedNodeStatus(InstanceIdentifier<Node> iid) {
 112         String nodeId = iid.firstKeyOf(Node.class).getNodeId().getValue();
 113         connectedNodes.put(nodeId, true);
 114     }
 115
 116     @Override
 117     public void updateDisconnectedNodeStatus(InstanceIdentifier<Node> iid) {
 118         String nodeId = iid.firstKeyOf(Node.class).getNodeId().getValue();
 119         connectedNodes.put(nodeId, false);
 120     }
 121
 122     @Override
 123     public Map<String, Boolean> getNodeConnectionStatuses() {
 124         return ImmutableMap.copyOf(connectedNodes);
 125     }
 126 }