commons/testutils/src/main/java/org/opendaylight/genius/testutils/TestInterfaceManager.java

   1 /*
   2  * Copyright (c) 2016 Red Hat, Inc. 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.testutils;
   9
  10 import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
  11
  12 import java.util.Map;
  13 import java.util.Optional;
  14 import java.util.concurrent.ConcurrentHashMap;
  15 import java.util.concurrent.ExecutionException;
  16 import org.mockito.Mockito;
  17 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
  18 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  19 import org.opendaylight.genius.testutils.interfacemanager.InterfaceHelper;
  20 import org.opendaylight.genius.testutils.interfacemanager.InterfaceStateHelper;
  21 import org.opendaylight.genius.testutils.interfacemanager.TunnelInterfaceDetails;
  22 import org.opendaylight.mdsal.binding.api.DataBroker;
  23 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
  24 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  26 import org.opendaylight.yangtools.yang.common.Uint64;
  27
  28 /**
  29  * IInterfaceManager implementation for tests.
  30  *
  31  * @author Michael Vorburger
  32  */
  33 public abstract class TestInterfaceManager implements IInterfaceManager {
  34
  35     private Map<String, InterfaceInfo> interfaceInfos;
  36     private Map<String, Interface> interfaces;
  37     private Map<String, Boolean> externalInterfaces;
  38     private Optional<DataBroker> optDataBroker;
  39
  40     /**
  41      * Deprecated factory method.
  42      * @deprecated Use {@link TestInterfaceManager#newInstance(DataBroker)} instead now.
  43      */
  44     @Deprecated
  45     public static TestInterfaceManager newInstance() {
  46         TestInterfaceManager testInterfaceManager = Mockito.mock(TestInterfaceManager.class, realOrException());
  47         testInterfaceManager.interfaceInfos = new ConcurrentHashMap<>();
  48         testInterfaceManager.interfaces = new ConcurrentHashMap<>();
  49         testInterfaceManager.externalInterfaces = new ConcurrentHashMap<>();
  50         testInterfaceManager.optDataBroker = Optional.empty();
  51         return testInterfaceManager;
  52     }
  53
  54     public static TestInterfaceManager newInstance(DataBroker dataBroker) {
  55         TestInterfaceManager testInterfaceManager = newInstance();
  56         testInterfaceManager.optDataBroker = Optional.of(dataBroker);
  57         return testInterfaceManager;
  58     }
  59
  60     public void addInterfaceInfo(InterfaceInfo interfaceInfo)
  61             throws ExecutionException, InterruptedException {
  62         interfaceInfos.put(interfaceInfo.getInterfaceName(), interfaceInfo);
  63         if (optDataBroker.isPresent()) {
  64             // Can't use ifPresent() here because of checked exception from tx.commit().get();
  65             DataBroker dataBroker = optDataBroker.get();
  66             ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
  67
  68             Interface iface = InterfaceHelper.buildVlanInterfaceFromInfo(interfaceInfo);
  69             //Add the interface to config ds so that if the application reads from configds it finds it there
  70             tx.put(LogicalDatastoreType.CONFIGURATION,
  71                     InterfaceHelper.buildIId(interfaceInfo.getInterfaceName()),
  72                     iface);
  73
  74             //Add the interface to oper ds so that if the application reads from configds it finds it there
  75             tx.put(LogicalDatastoreType.OPERATIONAL,
  76                     InterfaceStateHelper.buildStateInterfaceIid(interfaceInfo.getInterfaceName()),
  77                     InterfaceStateHelper.buildStateFromInterfaceInfo(interfaceInfo));
  78             tx.commit().get();
  79             addInterface(iface);
  80         }
  81     }
  82
  83     public void addInterface(Interface iface) {
  84         interfaces.put(iface.getName(), iface);
  85     }
  86
  87     public void addTunnelInterface(TunnelInterfaceDetails tunnelInterfaceDetails)
  88             throws ExecutionException, InterruptedException {
  89         InterfaceInfo interfaceInfo = tunnelInterfaceDetails.getInterfaceInfo();
  90         interfaceInfos.put(interfaceInfo.getInterfaceName(), interfaceInfo);
  91
  92         if (optDataBroker.isPresent()) {
  93             // Can't use ifPresent() here because of checked exception from tx.commit().get();
  94             DataBroker dataBroker = optDataBroker.get();
  95
  96             Interface iface = InterfaceHelper.buildVxlanTunnelInterfaceFromInfo(tunnelInterfaceDetails);
  97
  98             ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
  99             tx.put(LogicalDatastoreType.CONFIGURATION,
 100                     InterfaceHelper.buildIId(interfaceInfo.getInterfaceName()),
 101                     iface);
 102
 103             tx.put(LogicalDatastoreType.OPERATIONAL,
 104                     InterfaceStateHelper.buildStateInterfaceIid(interfaceInfo.getInterfaceName()),
 105                     InterfaceStateHelper.buildStateFromInterfaceInfo(interfaceInfo));
 106             tx.commit().get();
 107             externalInterfaces.put(interfaceInfo.getInterfaceName(), true);
 108             addInterface(iface);
 109         }
 110     }
 111
 112     @Override
 113     public InterfaceInfo getInterfaceInfo(String interfaceName) {
 114         InterfaceInfo interfaceInfo = interfaceInfos.get(interfaceName);
 115         if (interfaceInfo == null) {
 116             throw new IllegalStateException(
 117                     "must addInterfaceInfo() to TestInterfaceManager before getInterfaceInfo: " + interfaceName);
 118         }
 119         return interfaceInfo;
 120     }
 121
 122     @Override
 123     public InterfaceInfo getInterfaceInfoFromOperationalDataStore(String interfaceName) {
 124         return getInterfaceInfo(interfaceName);
 125     }
 126
 127     @Override
 128     public InterfaceInfo getInterfaceInfoFromOperationalDataStore(
 129             String interfaceName, InterfaceInfo.InterfaceType interfaceType) {
 130         return interfaceInfos.get(interfaceName);
 131     }
 132
 133     @Override
 134     public InterfaceInfo getInterfaceInfoFromOperationalDSCache(String interfaceName) {
 135         return getInterfaceInfo(interfaceName);
 136     }
 137
 138     @Override
 139     public Interface getInterfaceInfoFromConfigDataStore(String interfaceName) {
 140         Interface iface = interfaces.get(interfaceName);
 141         if (iface == null) {
 142             throw new IllegalStateException(
 143                     "must addInterface() to TestInterfaceManager before getInterfaceInfoFromConfigDataStore: "
 144                     + interfaceName);
 145         }
 146         return iface;
 147     }
 148
 149     @Override
 150     public Uint64 getDpnForInterface(String interfaceName) {
 151         return interfaceInfos.get(interfaceName).getDpId();
 152     }
 153
 154     @Override
 155     public Uint64 getDpnForInterface(Interface intrface) {
 156         return interfaceInfos.get(intrface.getName()).getDpId();
 157     }
 158
 159     @Override
 160     public boolean isExternalInterface(String interfaceName) {
 161         return externalInterfaces.containsKey(interfaceName);
 162     }
 163
 164     @Override
 165     public boolean isItmDirectTunnelsEnabled() {
 166         return false;
 167     }
 168 }