renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManagerTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, 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.groupbasedpolicy.renderer.vpp.policy;
   9
  10 import java.util.Arrays;
  11 import java.util.Collection;
  12
  13 import org.junit.Assert;
  14 import org.junit.Before;
  15 import org.junit.Test;
  16 import org.junit.runner.RunWith;
  17 import org.mockito.Matchers;
  18 import org.mockito.Mock;
  19 import org.mockito.Mockito;
  20 import org.mockito.runners.MockitoJUnitRunner;
  21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.groupbasedpolicy.renderer.vpp.DtoFactory;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.dhcp.DhcpRelayHandler;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
  29 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.loopback.LoopbackManager;
  30 import org.opendaylight.groupbasedpolicy.renderer.vpp.nat.NatManager;
  31 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AccessListWrapper;
  32 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AclManager;
  33 import org.opendaylight.groupbasedpolicy.renderer.vpp.routing.RoutingManager;
  34 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
  35 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.NetworkTypeBase;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VxlanVni;
  50 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  51 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  52
  53 import com.google.common.base.Optional;
  54 import com.google.common.collect.ImmutableSetMultimap;
  55 import com.google.common.collect.SetMultimap;
  56 import com.google.common.util.concurrent.Futures;
  57
  58 @RunWith(MockitoJUnitRunner.class)
  59 public class ForwardingManagerTest extends CustomDataBrokerTest {
  60
  61     private static final String BD_1 = "bd1";
  62     private static final NodeId NODE_1 = new NodeId("node1");
  63     private static final VlanId VLAN_1 = new VlanId(1);
  64     private static final boolean IS_BVI = false;
  65     @Mock
  66     private InterfaceManager ifaceManager;
  67     @Mock
  68     private AclManager aclManager;
  69     @Mock
  70     private BridgeDomainManager bdManager;
  71     @Mock
  72     private NatManager natManager;
  73     @Mock
  74     private RoutingManager routingManager;
  75     @Mock
  76     private LispStateManager lispStateManager;
  77     @Mock
  78     private FlatOverlayManager flatOverlayManager;
  79     @Mock
  80     private LoopbackManager loopbackManager;
  81     @Mock
  82     private DhcpRelayHandler dhcpRelayHandler;
  83
  84     private ForwardingManager fwdManager;
  85
  86     @Before
  87     public void init() {
  88         fwdManager =
  89             new ForwardingManager(ifaceManager, aclManager, natManager, routingManager, bdManager, lispStateManager,
  90                     loopbackManager, flatOverlayManager, dhcpRelayHandler, getDataBroker());
  91         Mockito.when(aclManager.resolveAclsOnInterface(Mockito.any(RendererEndpointKey.class),
  92                 Mockito.any(PolicyContext.class)))
  93             .thenReturn(Futures.immediateFuture(null));
  94     }
  95
  96     @Override
  97     public Collection<Class<?>> getClassesFromModules() {
  98         return Arrays.asList(GbpBridgeDomain.class);
  99     }
 100
 101     @Test
 102     public void testReadBridgeDomainConfig() throws Exception {
 103         GbpBridgeDomain bd = new GbpBridgeDomainBuilder().setId(BD_1).setType(NetworkTypeBase.class).build();
 104         InstanceIdentifier<GbpBridgeDomain> bdIid =
 105                 InstanceIdentifier.builder(Config.class).child(GbpBridgeDomain.class, bd.getKey()).build();
 106         Optional<GbpBridgeDomain> bdOptional = fwdManager.readGbpBridgeDomainConfig(bd.getId());
 107         Assert.assertFalse(bdOptional.isPresent());
 108
 109         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 110         wTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, bd);
 111         wTx.submit().get();
 112
 113         bdOptional = fwdManager.readGbpBridgeDomainConfig(bd.getId());
 114         Assert.assertTrue(bdOptional.isPresent());
 115         Assert.assertEquals(bd, bdOptional.get());
 116     }
 117
 118     @Test
 119     public void testCreateBridgeDomainOnNodes_vxlan() throws Exception {
 120         Mockito.when(bdManager.createVxlanBridgeDomainOnVppNode(Mockito.eq(BD_1), Mockito.any(VxlanVni.class),
 121                 Mockito.eq(NODE_1)))
 122             .thenReturn(Futures.immediateFuture(null));
 123         SetMultimap<String, NodeId> vppNodesByBd = ImmutableSetMultimap.of(BD_1, NODE_1);
 124
 125         fwdManager.createBridgeDomainOnNodes(vppNodesByBd);
 126         Mockito.verify(bdManager).createVxlanBridgeDomainOnVppNode(Matchers.eq(BD_1), Matchers.any(VxlanVni.class),
 127                 Matchers.eq(NODE_1));
 128     }
 129
 130     @Test
 131     public void testCreateBridgeDomainOnNodes_vlan() throws Exception {
 132         Mockito.when(bdManager.createVlanBridgeDomainOnVppNode(Mockito.eq(BD_1), Mockito.any(VlanId.class),
 133                 Mockito.eq(NODE_1)))
 134             .thenReturn(Futures.immediateFuture(null));
 135         GbpBridgeDomain bd =
 136             new GbpBridgeDomainBuilder().setId(BD_1).setType(VlanNetwork.class).setVlan(VLAN_1).build();
 137         InstanceIdentifier<GbpBridgeDomain> bdIid =
 138                 InstanceIdentifier.builder(Config.class).child(GbpBridgeDomain.class, bd.getKey()).build();
 139         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 140         wTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, bd);
 141         wTx.submit().get();
 142         SetMultimap<String, NodeId> vppNodesByBd = ImmutableSetMultimap.of(BD_1, NODE_1);
 143
 144         fwdManager.createBridgeDomainOnNodes(vppNodesByBd);
 145         Mockito.verify(bdManager).createVlanBridgeDomainOnVppNode(Matchers.eq(BD_1), Matchers.eq(VLAN_1),
 146                 Matchers.eq(NODE_1));
 147     }
 148
 149     @Test
 150     public void testRemoveBridgeDomainOnNodes() throws Exception {
 151         Mockito.when(bdManager.removeBridgeDomainFromVppNode(Mockito.eq(BD_1), Mockito.eq(NODE_1)))
 152             .thenReturn(Futures.immediateFuture(null));
 153         bdManager.removeBridgeDomainFromVppNode(BD_1, NODE_1);
 154         Mockito.verify(bdManager).removeBridgeDomainFromVppNode(Matchers.eq(BD_1), Matchers.eq(NODE_1));
 155     }
 156
 157     @Test
 158     public void testCreateForwardingForEndpoint() throws Exception {
 159         String clientIp = "1.1.1.1";
 160         String clientIfaceName = "client1";
 161         AbsoluteLocation clientLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, clientIfaceName);
 162         AddressEndpointWithLocation clientEp =
 163                 DtoFactory.createEndpoint(clientIp, DtoFactory.L2FD_CTX.getValue(), clientLocation);
 164         String webIp = "2.2.2.2";
 165         String webIfaceName = "web1";
 166         AbsoluteLocation webLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, webIfaceName);
 167         AddressEndpointWithLocation webEp =
 168                 DtoFactory.createEndpoint(webIp, DtoFactory.L2FD_CTX.getValue(), webLocation);
 169         Configuration configuration = DtoFactory.createConfiguration(Arrays.asList(clientEp), Arrays.asList(webEp));
 170         RendererPolicy rendererPolicy =
 171                 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
 172         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
 173         RendererEndpoint firstRendererEp = configuration.getRendererEndpoints().getRendererEndpoint().get(0);
 174         AddressEndpointWithLocation firstAddrEpWithLoc =
 175                 policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(firstRendererEp.getKey()));
 176         Mockito.when(ifaceManager.addBridgeDomainToInterface(Mockito.eq(DtoFactory.L2FD_CTX.getValue()),
 177                 Mockito.eq(firstAddrEpWithLoc), Mockito.anyListOf(AccessListWrapper.class),Mockito.eq(IS_BVI)))
 178             .thenReturn(Futures.immediateFuture(null));
 179         fwdManager.createForwardingForEndpoint(firstRendererEp.getKey(), policyCtx);
 180         Mockito.verify(ifaceManager).addBridgeDomainToInterface(Matchers.eq(DtoFactory.L2FD_CTX.getValue()),
 181                 Matchers.eq(firstAddrEpWithLoc), Mockito.anyListOf(AccessListWrapper.class), Mockito.eq(IS_BVI));
 182     }
 183
 184     @Test
 185     public void testRemoveForwardingForEndpoint() throws Exception {
 186         String clientIp = "1.1.1.1";
 187         String clientIfaceName = "client1";
 188         String bdNameOnVpp = "bdRed";
 189         AbsoluteLocation clientLocation =
 190             DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, bdNameOnVpp, clientIfaceName);
 191         AddressEndpointWithLocation clientEp =
 192                 DtoFactory.createEndpoint(clientIp, DtoFactory.L2FD_CTX.getValue(), clientLocation);
 193         String webIp = "2.2.2.2";
 194         String webIfaceName = "web1";
 195         AbsoluteLocation webLocation =
 196             DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, bdNameOnVpp, webIfaceName);
 197         AddressEndpointWithLocation webEp =
 198                 DtoFactory.createEndpoint(webIp, DtoFactory.L2FD_CTX.getValue(), webLocation);
 199         Configuration configuration = DtoFactory.createConfiguration(Arrays.asList(clientEp), Arrays.asList(webEp));
 200         RendererPolicy rendererPolicy =
 201                 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
 202         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
 203         RendererEndpoint firstRendererEp = configuration.getRendererEndpoints().getRendererEndpoint().get(0);
 204         AddressEndpointWithLocation firstAddrEpWithLoc =
 205                 policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(firstRendererEp.getKey()));
 206         Mockito.when(ifaceManager.deleteBridgeDomainFromInterface(
 207                 Mockito.eq(firstAddrEpWithLoc)))
 208             .thenReturn(Futures.immediateFuture(null));
 209
 210         fwdManager.removeForwardingForEndpoint(firstRendererEp.getKey(), policyCtx);
 211         Mockito.verify(ifaceManager).deleteBridgeDomainFromInterface(Matchers.eq(firstAddrEpWithLoc));
 212     }
 213
 214 }