renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/LoopbackHostSpecificInfoMapper.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems. 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
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers;
  10
  11 import com.google.common.collect.ArrayListMultimap;
  12 import com.google.common.collect.Multimap;
  13 import org.apache.commons.lang3.mutable.MutableInt;
  14 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.loopback.SubnetHostInfo;
  15
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.stream.Collectors;
  19
  20 /**
  21  * Created by Shakib Ahmed on 4/26/17.
  22  */
  23 public class LoopbackHostSpecificInfoMapper {
  24     private HashMap<String, HashMap<String, SubnetHostInfo>> hostIdToSubnetMapper;
  25     private Multimap<String, String> subnetUuidToHostIdListMapper;
  26     private HashMap<String, MutableInt> hostIdToLoopbackCountMapper;
  27
  28     public LoopbackHostSpecificInfoMapper() {
  29         hostIdToSubnetMapper = new HashMap<>();
  30         subnetUuidToHostIdListMapper = ArrayListMultimap.create();
  31         hostIdToLoopbackCountMapper = new HashMap<>();
  32     }
  33
  34     private HashMap<String, SubnetHostInfo> getSubnetsOfHost(String hostName) {
  35         return hostIdToSubnetMapper.get(hostName);
  36     }
  37
  38     public boolean loopbackAlreadyExists(String hostName, String subnetUuid) {
  39         return hostIdToSubnetMapper.containsKey(hostName) &&
  40                 hostIdToSubnetMapper.get(hostName).containsKey(subnetUuid);
  41     }
  42
  43     public void addLoopbackForHost(String hostName, String subnetUuid, String interfaceName, long vrf) {
  44         putSubnetInfoOfAHost(hostName, subnetUuid, interfaceName, vrf);
  45         subnetUuidToHostIdListMapper.put(subnetUuid, hostName);
  46     }
  47
  48     private void putSubnetInfoOfAHost(String hostId, String subnetUuid, String interfaceName, long vrf) {
  49         HashMap<String, SubnetHostInfo> subnetsOfAHost = getSubnetsOfHost(hostId);
  50         MutableInt loopbackCount = getMutableIntAfterInitIfNecessary(hostId);
  51
  52         loopbackCount.add(1);
  53
  54         if (subnetsOfAHost == null) {
  55             subnetsOfAHost = new HashMap<>();
  56             hostIdToSubnetMapper.put(hostId, subnetsOfAHost);
  57         }
  58
  59         SubnetHostInfo subnetHostInfo = new SubnetHostInfo(interfaceName);
  60         subnetsOfAHost.put(subnetUuid, subnetHostInfo);
  61     }
  62
  63     private MutableInt getMutableIntAfterInitIfNecessary(String hostId) {
  64         MutableInt loopbackCount = hostIdToLoopbackCountMapper.get(hostId);
  65
  66         if (loopbackCount == null) {
  67             loopbackCount = new MutableInt();
  68             loopbackCount.setValue(0);
  69             hostIdToLoopbackCountMapper.put(hostId, loopbackCount);
  70         }
  71         return loopbackCount;
  72     }
  73
  74     public int getLoopbackCount(String hostName) {
  75         MutableInt loopbackCount = getMutableIntAfterInitIfNecessary(hostName);
  76         return loopbackCount.getValue();
  77     }
  78
  79     public void clearSubnet(String subnetUuid) {
  80         subnetUuidToHostIdListMapper.get(subnetUuid).forEach(hostId -> {
  81             deleteParticularSubnetFromHost(hostId, subnetUuid);
  82         });
  83         subnetUuidToHostIdListMapper.get(subnetUuid).clear();
  84     }
  85
  86     private void deleteParticularSubnetFromHost(String hostId, String subnetUuid) {
  87         hostIdToSubnetMapper.get(hostId).remove(subnetUuid);
  88     }
  89
  90     private void deleteHostFromSubnetMap(String subnetUuid, String hostId) {
  91         subnetUuidToHostIdListMapper.get(subnetUuid).remove(hostId);
  92     }
  93
  94     public List<String> getHostsWithSubnet(String subnetUuid) {
  95         return subnetUuidToHostIdListMapper.get(subnetUuid).stream().collect(Collectors.toList());
  96     }
  97
  98     public String getInterfaceNameForLoopbackInHost(String hostId, String subnetUuid) {
  99         if (hostIdToSubnetMapper.get(hostId) != null) {
 100             return hostIdToSubnetMapper.get(hostId).get(subnetUuid).getInterfaceName();
 101         } else {
 102             return null;
 103         }
 104     }
 105
 106     public int getPortCount(String hostId, String subnetUuid) {
 107         if (hostIdToSubnetMapper.containsKey(hostId)) {
 108             if (hostIdToSubnetMapper.get(hostId).containsKey(subnetUuid)) {
 109                 return hostIdToSubnetMapper.get(hostId).get(subnetUuid).getPortCount();
 110             } else {
 111                 return 0;
 112             }
 113         } else {
 114             return 0;
 115         }
 116     }
 117
 118     public void addNewPortInHostSubnet(String hostId, String subnetUuid) {
 119         getSubnetsOfHost(hostId).get(subnetUuid).incrementPortCount();
 120     }
 121
 122     public boolean deletePortFromHostSubnetAndTriggerLoopbackDelete(String hostId, String subnetUuid) {
 123         if (getSubnetsOfHost(hostId).containsKey(subnetUuid)) {
 124             int count = getSubnetsOfHost(hostId).get(subnetUuid).decrementAndGetPortCount();
 125
 126             if (count == 0) {
 127                 deleteParticularSubnetFromHost(hostId, subnetUuid);
 128             }
 129
 130             return count == 0;
 131         } else {
 132             return false;
 133         }
 134     }
 135 }