vpnservice/aclservice/impl/src/test/java/org/opendaylight/netvirt/aclservice/utils/AclServiceTestUtils.java

   1 /*
   2  * Copyright (c) 2016 Hewlett Packard Enterprise, Co. 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
   9 package org.opendaylight.netvirt.aclservice.utils;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.mockito.Mockito.mock;
  15 import static org.mockito.Mockito.when;
  16
  17 import com.google.common.base.Optional;
  18 import com.google.common.util.concurrent.Futures;
  19 import java.util.ArrayList;
  20 import java.util.List;
  21 import java.util.concurrent.ConcurrentMap;
  22 import java.util.concurrent.Future;
  23 import java.util.stream.Collectors;
  24 import java.util.stream.Stream;
  25 import org.junit.Assert;
  26 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  27 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  28 import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
  29 import org.opendaylight.genius.mdsalutil.ActionInfo;
  30 import org.opendaylight.genius.mdsalutil.FlowEntity;
  31 import org.opendaylight.genius.mdsalutil.InstructionInfo;
  32 import org.opendaylight.genius.mdsalutil.MatchInfoBase;
  33 import org.opendaylight.genius.mdsalutil.NxMatchInfo;
  34 import org.opendaylight.genius.mdsalutil.actions.ActionLearn;
  35 import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
  36 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
  37 import org.opendaylight.genius.mdsalutil.matches.MatchIpProtocol;
  38 import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Destination;
  39 import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Source;
  40 import org.opendaylight.genius.utils.cache.CacheUtil;
  41 import org.opendaylight.netvirt.aclservice.api.utils.AclInterface;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.AccessListEntries;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.Ace;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv4Builder;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.DestinationPortRangeBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.SourcePortRangeBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceBuilder;
  56 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  57
  58 public class AclServiceTestUtils {
  59
  60     public static void verifyGeneralFlows(List<MatchInfoBase> srcFlowMatches, String protocol, String srcIpv4Net,
  61             String dstIpv4Net, String mask) {
  62         assertTrue(srcFlowMatches.contains(MatchEthernetType.IPV4));
  63         assertTrue(srcFlowMatches.contains(new MatchIpProtocol(Short.parseShort(protocol))));
  64         assertTrue(srcFlowMatches.contains(new MatchIpv4Source(srcIpv4Net, mask)));
  65         assertTrue(srcFlowMatches.contains(new MatchIpv4Destination(dstIpv4Net, mask)));
  66     }
  67
  68     public static AceIpBuilder prepareAceIpBuilder(String srcIpv4Net, String dstIpv4Net, String lowerPort,
  69             String upperPort, short protocol) {
  70         AceIpBuilder builder = new AceIpBuilder();
  71         AceIpv4Builder v4builder = new AceIpv4Builder();
  72         if (srcIpv4Net != null) {
  73             v4builder.setSourceIpv4Network(new Ipv4Prefix(srcIpv4Net));
  74         } else {
  75             v4builder.setSourceIpv4Network(null);
  76         }
  77
  78         if (dstIpv4Net != null) {
  79             v4builder.setDestinationIpv4Network(new Ipv4Prefix(dstIpv4Net));
  80         } else {
  81             v4builder.setDestinationIpv4Network(null);
  82         }
  83         builder.setAceIpVersion(v4builder.build());
  84         if (lowerPort != null && upperPort != null) {
  85             SourcePortRangeBuilder srcPortBuilder = new SourcePortRangeBuilder();
  86             srcPortBuilder.setLowerPort(PortNumber.getDefaultInstance(lowerPort));
  87             srcPortBuilder.setUpperPort(PortNumber.getDefaultInstance(upperPort));
  88             builder.setSourcePortRange(srcPortBuilder.build());
  89             DestinationPortRangeBuilder dstPortBuilder = new DestinationPortRangeBuilder();
  90             dstPortBuilder.setLowerPort(PortNumber.getDefaultInstance(lowerPort));
  91             dstPortBuilder.setUpperPort(PortNumber.getDefaultInstance(upperPort));
  92             builder.setDestinationPortRange(dstPortBuilder.build());
  93         }
  94         builder.setProtocol(protocol);
  95         return builder;
  96     }
  97
  98     public static void verifyMatchFieldTypeDontExist(List<MatchInfoBase> flowMatches,
  99             Class<? extends MatchInfoBase> matchType) {
 100         Assert.assertFalse("unexpected match type " + matchType.getSimpleName(), flowMatches.stream().anyMatch(
 101             item -> matchType.isAssignableFrom(item.getClass())));
 102     }
 103
 104     public static void prepareAclDataUtil(AclDataUtil aclDataUtil, AclInterface inter, String... updatedAclNames) {
 105         aclDataUtil.addAclInterfaceMap(prapreaAclIds(updatedAclNames), inter);
 106     }
 107
 108     public static Acl prepareAcl(String aclName, String... aces) {
 109         AccessListEntries aceEntries = mock(AccessListEntries.class);
 110         List<Ace> aceList = prepareAceList(aces);
 111         when(aceEntries.getAce()).thenReturn(aceList);
 112
 113         Acl acl = mock(Acl.class);
 114         when(acl.getAccessListEntries()).thenReturn(aceEntries);
 115         when(acl.getAclName()).thenReturn(aclName);
 116         return acl;
 117     }
 118
 119     public static List<Ace> prepareAceList(String... aces) {
 120         List<Ace> aceList = new ArrayList<>();
 121         for (String aceName : aces) {
 122             Ace aceMock = mock(Ace.class);
 123             when(aceMock.getRuleName()).thenReturn(aceName);
 124             aceList.add(aceMock);
 125         }
 126         return aceList;
 127     }
 128
 129     public static List<Uuid> prapreaAclIds(String... names) {
 130         return Stream.of(names).map(Uuid::new).collect(Collectors.toList());
 131     }
 132
 133     public static void verifyActionTypeExist(InstructionInfo instructionInfo, Class<? extends ActionInfo> actionType) {
 134         if (instructionInfo instanceof InstructionApplyActions) {
 135             verifyActionTypeExist(((InstructionApplyActions) instructionInfo).getActionInfos(), actionType);
 136         }
 137     }
 138
 139     public static void verifyActionTypeExist(List<ActionInfo> flowActions, Class<? extends ActionInfo> actionType) {
 140         assertTrue(flowActions.stream().anyMatch(actionInfo -> actionInfo.getClass().equals(actionType)));
 141     }
 142
 143     public static void verifyActionInfo(InstructionInfo instructionInfo, ActionInfo actionInfo) {
 144         if (instructionInfo instanceof InstructionApplyActions) {
 145             verifyActionInfo(((InstructionApplyActions) instructionInfo).getActionInfos(), actionInfo);
 146         }
 147     }
 148
 149     public static void verifyActionInfo(List<ActionInfo> flowActions, ActionInfo actionInfo) {
 150         assertTrue(flowActions.contains(actionInfo));
 151     }
 152
 153     public static void verifyActionLearn(InstructionInfo instructionInfo, ActionLearn actionLearn) {
 154         if (instructionInfo instanceof InstructionApplyActions) {
 155             verifyActionLearn(((InstructionApplyActions) instructionInfo).getActionInfos(), actionLearn);
 156         }
 157     }
 158
 159     public static void verifyActionLearn(List<ActionInfo> flowActions, ActionLearn actionLearn) {
 160         for (ActionInfo actionInfo : flowActions) {
 161             if (actionInfo instanceof ActionLearn) {
 162                 ActionLearn check = (ActionLearn) actionInfo;
 163                 assertEquals(actionLearn.getCookie(), check.getCookie());
 164                 assertEquals(actionLearn.getFinHardTimeout(), check.getFinHardTimeout());
 165                 assertEquals(actionLearn.getFinIdleTimeout(), check.getFinIdleTimeout());
 166                 assertEquals(actionLearn.getFlags(), check.getFlags());
 167                 assertEquals(actionLearn.getHardTimeout(), check.getHardTimeout());
 168                 assertEquals(actionLearn.getIdleTimeout(), check.getIdleTimeout());
 169                 assertEquals(actionLearn.getTableId(), check.getTableId());
 170             }
 171         }
 172     }
 173
 174     public static void prepareAclClusterUtil(String entityName) {
 175         if (CacheUtil.getCache("entity.owner.cache") == null) {
 176             CacheUtil.createCache("entity.owner.cache");
 177         }
 178         ConcurrentMap entityOwnerCache = CacheUtil.getCache("entity.owner.cache");
 179         if (entityOwnerCache != null) {
 180             entityOwnerCache.put(entityName, true);
 181         }
 182
 183     }
 184
 185     public static void prepareElanTag(ReadOnlyTransaction mockReadTx, Long elanTag) {
 186         InstanceIdentifier<ElanInterface> elanInterfaceKey =
 187                 AclServiceUtils.getElanInterfaceConfigurationDataPathId(null);
 188         ElanInterfaceBuilder elanInterfaceBuilder = new ElanInterfaceBuilder();
 189         when(mockReadTx.read(LogicalDatastoreType.CONFIGURATION, elanInterfaceKey))
 190                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(elanInterfaceBuilder.build())));
 191
 192         InstanceIdentifier<ElanInstance> elanInstanceKey = AclServiceUtils.getElanInstanceConfigurationDataPath(null);
 193         ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder();
 194         elanInstanceBuilder.setElanTag(elanTag);
 195         when(mockReadTx.read(LogicalDatastoreType.CONFIGURATION, elanInstanceKey))
 196                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(elanInstanceBuilder.build())));
 197     }
 198
 199     public static void waitABit(AsyncEventsWaiter asyncEventsWaiter) throws InterruptedException {
 200         Thread.sleep(200);
 201         asyncEventsWaiter.awaitEventsConsumption();
 202     }
 203
 204     public static FlowEntity verifyMatchInfoInSomeFlow(MethodInvocationParamSaver<Future<?>> installFlowValueSaver,
 205             NxMatchInfo match) {
 206         for (int i = 0; i < installFlowValueSaver.getNumOfInvocations(); i++) {
 207             FlowEntity flow = (FlowEntity) installFlowValueSaver.getInvocationParams(i).get(1);
 208             if (flow.getMatchInfoList().contains(match)) {
 209                 return flow;
 210             }
 211         }
 212
 213         fail();
 214         return null;
 215
 216     }
 217
 218 }