// TODO missing impl for case when classifier is changed or removed
}
- private Map<InstanceIdentifier<Classifier>, Classifier> resolveClassifiers(ResolvedPolicy resolvedPolicy,
+ // TODO move to some util class
+ public static Map<InstanceIdentifier<Classifier>, Classifier> resolveClassifiers(ResolvedPolicy resolvedPolicy,
InstanceIdentifier<ResolvedPolicy> resolvedPolicyIid) {
List<PolicyRuleGroupWithEndpointConstraints> policyRgWithEcs =
resolvedPolicy.getPolicyRuleGroupWithEndpointConstraints();
private static final Pattern REPLACE_PATTERN = Pattern.compile("^\\w+:(\\w+):.*");
static final String API_FLOW = "/flow/";
static final String SUFFIX_JSON = "/json";
+ static final String KEYS_SPLIT_REGEX = ",";
private transient Direction direction;
private String name;
private String[] keyNames;
private int keyNum;
- private FlowCache() {
- }
+ private FlowCache() {}
private FlowCache(FlowCacheBuilder builder) {
this.name = builder.getName();
this.definition = builder.getDefinition();
this.direction = builder.getDirection();
- this.keyNames = this.definition.getKeys().split(",");
+ this.keyNames = this.definition.getKeys().split(KEYS_SPLIT_REGEX);
this.keyNum = this.keyNames.length;
for (int i = 0; i < this.keyNum; i++) {
keyNames[i] = parseNullableKeyName(keyNames[i]);
public static class FlowCacheDefinitionBuilder {
- private String value;
+ private String value = "";
private boolean log = false;
private final FlowCacheKeysBuilder keysBuilder = new FlowCacheKeysBuilder();
private final FlowCacheFilterBuilder filterBuilder = new FlowCacheFilterBuilder();
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;
import java.util.List;
+import java.util.Objects;
import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
public static FlowCache createFlowCache(InstanceIdentifier<Classifier> classifierIid, Classifier classifier,
FlowCacheCons.Value value) {
- FlowCacheDefinition flowCacheDefinition = creteFlowCacheDefinition(classifier, value);
+ FlowCacheDefinition flowCacheDefinition = createFlowCacheDefinition(classifier, value);
if (flowCacheDefinition == null) {
LOG.info("Cannot create flow cache for statistics of classifier {}\n{}", classifierIid, classifier);
return null;
.build();
}
- public static FlowCacheDefinition creteFlowCacheDefinition(Classifier classifier, FlowCacheCons.Value value) {
+ public static FlowCacheDefinition createFlowCacheDefinition(Classifier classifier,
+ FlowCacheCons.Value value) {
FlowCacheDefinitionBuilder fcdBuilder = new FlowCacheDefinitionBuilder();
if (L4ClassifierDefinition.ID.equals(classifier.getClassifierDefinitionId())) {
addEthTypeInfoToFlowCache(classifier, fcdBuilder);
private static boolean addTcpUdpPortKeys(Long ipProto, Long port, boolean isDstPort,
FlowCacheDefinitionBuilder fcdBuilder) {
if (isDstPort) {
- if (ipProto == IpProtoClassifierDefinition.TCP_VALUE) {
+ if (Objects.equals(ipProto, IpProtoClassifierDefinition.TCP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.TCP_DST_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.TCP_DST_PORT.get() + FlowCacheCons.EQ + port);
- } else if (ipProto == IpProtoClassifierDefinition.UDP_VALUE) {
+ } else if (Objects.equals(ipProto, IpProtoClassifierDefinition.UDP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.UDP_DST_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.UDP_DST_PORT.get() + FlowCacheCons.EQ + port);
} else {
return false;
}
} else {
- if (ipProto == IpProtoClassifierDefinition.TCP_VALUE) {
+ if (Objects.equals(ipProto, IpProtoClassifierDefinition.TCP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.TCP_SRC_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.TCP_SRC_PORT.get() + FlowCacheCons.EQ + port);
- } else if (ipProto == IpProtoClassifierDefinition.UDP_VALUE) {
+ } else if (Objects.equals(ipProto, IpProtoClassifierDefinition.UDP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.UDP_SRC_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.UDP_SRC_PORT.get() + FlowCacheCons.EQ + port);
} else {
return values;
}
+ /**
+ * Sets FlowCache's "key" values by copying {@code String}s from {@code values},
+ * to avoid immutable list put as a parameter.
+ * {@code null}s are omitted.
+ *
+ * @param values List of String
+ * @return FlowCacheKeysBuilder
+ */
public FlowCacheKeysBuilder setValues(List<String> values) {
- this.values = Preconditions.checkNotNull(values);
+ Preconditions.checkNotNull(values);
+ for (String value : values) {
+ if (value != null) {
+ this.values.add(value);
+ }
+ }
return this;
}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Mockito.mock;\r
+\r
+import java.util.concurrent.ScheduledExecutorService;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+\r
+public class OFStatisticsManagerTest {\r
+\r
+ ScheduledExecutorService executor;\r
+ StatisticsManager statisticsManager;\r
+\r
+ @Before\r
+ public void init() {\r
+ executor = mock(ScheduledExecutorService.class);\r
+ statisticsManager = mock(StatisticsManager.class);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() throws Exception {\r
+ new OFStatisticsManager(executor, statisticsManager);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.anyMap;\r
+import static org.mockito.Matchers.anySet;\r
+import static org.mockito.Matchers.anyString;\r
+import static org.mockito.Mockito.doNothing;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import javax.ws.rs.core.MultivaluedMap;\r
+\r
+import java.util.concurrent.ExecutorService;\r
+import java.util.concurrent.ScheduledExecutorService;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+\r
+public class ReadGbpFlowCacheTaskTest {\r
+\r
+ ReadGbpFlowCacheTask task;\r
+\r
+ @Before\r
+ public void init() {\r
+ StatisticsManager statisticsManager = mock(StatisticsManager.class);\r
+ ScheduledExecutorService executor = mock(ScheduledExecutorService.class);\r
+ JsonRestClientResponse response = mock(JsonRestClientResponse.class);\r
+ when(response.getJsonResponse()).thenReturn("[{\"one\":1, \"two\":2, \"three\":3}]");\r
+ when(response.getStatusCode()).thenReturn(200);\r
+ SFlowRTConnection connection = mock(SFlowRTConnection.class);\r
+ when(connection.get(anyString(), any(MultivaluedMap.class))).thenReturn(response);\r
+ when(connection.getExecutor()).thenReturn(executor);\r
+ doNothing().when(executor).execute(any(Runnable.class));\r
+\r
+ task = new ReadGbpFlowCacheTask("cache1", connection, statisticsManager, 100, 0.1, "sum");\r
+ }\r
+\r
+ @Test\r
+ public void testRun() {\r
+\r
+ task.run();\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;\r
+\r
+public class FlowCacheBuilderTest {\r
+\r
+ private static final String NAME_1 = "name_1";\r
+ private static final Direction direction = Direction.Bidirectional;\r
+ private static final String VALUE_1 = "value_1";\r
+ private FlowCacheDefinition flowCacheDefinition;\r
+ private FlowCache.FlowCacheBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCache.FlowCacheBuilder();\r
+ flowCacheDefinition = FlowCacheDefinition.builder().setValue(VALUE_1).build();\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCache.FlowCacheBuilder b = null;\r
+ try {\r
+ b = new FlowCache.FlowCacheBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ }\r
+\r
+ @Test\r
+ public void testSetName() {\r
+ builder.setName(NAME_1);\r
+\r
+ assertEquals(NAME_1, builder.getName());\r
+ }\r
+\r
+ @Test\r
+ public void testSetDefinition() {\r
+ builder.setDefinition(flowCacheDefinition);\r
+\r
+ assertEquals(VALUE_1, builder.getDefinition().getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testSetDirection() {\r
+ builder.setDirection(direction);\r
+\r
+ assertEquals(direction, builder.getDirection());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ FlowCache cache = builder.setName(NAME_1)\r
+ .setDefinition(flowCacheDefinition)\r
+ .setDirection(direction)\r
+ .build();\r
+\r
+ assertNotNull(cache);\r
+ assertEquals(NAME_1, cache.getName());\r
+ assertEquals(flowCacheDefinition, cache.getDefinition());\r
+ assertEquals(direction, cache.getDirection());\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class FlowCacheDefinitionBuilderTest {\r
+\r
+ private static final String VALUE = "value-1";\r
+\r
+ private FlowCacheDefinition.FlowCacheDefinitionBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCacheDefinition.FlowCacheDefinitionBuilder();\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCacheDefinition.FlowCacheDefinitionBuilder b = null;\r
+ try {\r
+ b = new FlowCacheDefinition.FlowCacheDefinitionBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ assertFalse(b.isLog());\r
+ assertNotNull(b.getFilterBuilder());\r
+ assertNotNull(b.getKeysBuilder());\r
+ assertNotNull(b.getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testSetValue() {\r
+ builder.setValue(VALUE);\r
+ assertEquals(VALUE, builder.getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testSetLog() {\r
+ builder.setLog(true);\r
+ assertTrue(builder.isLog());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ builder.setValue(VALUE).setLog(true);\r
+ FlowCacheDefinition definition = builder.build();\r
+\r
+ assertEquals(VALUE, definition.getValue());\r
+ assertTrue(definition.getLog());\r
+ assertNotNull(definition.getKeys());\r
+ assertNotNull(definition.getFilter());\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Test;\r
+\r
+public class FlowCacheDefinitionTest {\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCacheDefinition.FlowCacheDefinitionBuilder builder = null;\r
+ try {\r
+ builder = FlowCacheDefinition.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import java.util.ArrayList;\r
+import java.util.Arrays;\r
+import java.util.List;\r
+\r
+import com.google.common.collect.ImmutableList;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.ResolvedPolicyClassifierListener;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.FlowCacheCons;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.IidSflowNameUtil;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class FlowCacheFactoryTest {\r
+\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = ClassifierName.getDefaultInstance("classifier1");\r
+ private final SubjectName subjectName = SubjectName.getDefaultInstance("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+\r
+ private InstanceIdentifier<ResolvedPolicy> rpIid;\r
+ private String expectedName;\r
+\r
+ @Before\r
+ public void init() {\r
+ rpIid = InstanceIdentifier.create(ResolvedPolicy.class);\r
+ expectedName = tenantId.getValue() + IidSflowNameUtil.KEY_DELIMETER + contractId.getValue()\r
+ + IidSflowNameUtil.KEY_DELIMETER + subjectName.getValue() + IidSflowNameUtil.DELIMETER\r
+ + ruleName.getValue() + IidSflowNameUtil.DELIMETER + classifierName.getValue()\r
+ + IidSflowNameUtil.DELIMETER + FlowCacheCons.Value.BYTES.get();\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_EtherTypeClassifier_IPv4() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE);\r
+\r
+ Classifier classifier = newEtherTypeClassifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_IpProtoClassifier_TCP_IPv4() {\r
+\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE);\r
+\r
+ Classifier classifier = newIpProtoClassifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys =\r
+ ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(), FlowCacheCons.Key.IP_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_IpProtoClassifier_UDP_noEthertype() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addProto(IpProtoClassifierDefinition.UDP_VALUE);\r
+\r
+ Classifier classifier = newIpProtoClassifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys =\r
+ ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(), FlowCacheCons.Key.IP_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_L4Classifier_dstPort() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE)\r
+ .addDstPort((long) 80);\r
+ Classifier classifier = newL4Classifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.TCP_DST_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+\r
+ ParameterValueList parameterValuesUDP = new ParameterValueList();\r
+ parameterValuesUDP.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.UDP_VALUE)\r
+ .addDstPort((long) 80);\r
+ Classifier classifierUDP = newL4Classifier(parameterValuesUDP);\r
+ ResolvedPolicy rpUDP = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifierUDP);\r
+\r
+ FlowCache flowCacheUDP = callCreateFlowCache(rpUDP, classifierUDP);\r
+\r
+ assertNotNull(flowCacheUDP);\r
+\r
+ List<String> keysUDP = Arrays.asList(flowCacheUDP.getKeyNames());\r
+ List<String> expectedKeysUDP = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.UDP_DST_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCacheUDP.getName());\r
+ assertEquals(expectedKeysUDP.size(), keysUDP.size());\r
+ assertTrue(keysUDP.containsAll(expectedKeysUDP));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_L4Classifier_srcPort() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE)\r
+ .addSrcPort((long) 80);\r
+ Classifier classifier = newL4Classifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.TCP_SRC_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+\r
+ ParameterValueList parameterValuesUDP = new ParameterValueList();\r
+ parameterValuesUDP.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.UDP_VALUE)\r
+ .addSrcPort((long) 80);\r
+ Classifier classifierUDP = newL4Classifier(parameterValuesUDP);\r
+ ResolvedPolicy rpUDP = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifierUDP);\r
+\r
+ FlowCache flowCacheUDP = callCreateFlowCache(rpUDP, classifierUDP);\r
+\r
+ assertNotNull(flowCacheUDP);\r
+\r
+ List<String> keysUDP = Arrays.asList(flowCacheUDP.getKeyNames());\r
+ List<String> expectedKeysUDP = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.UDP_SRC_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCacheUDP.getName());\r
+ assertEquals(expectedKeysUDP.size(), keysUDP.size());\r
+ assertTrue(keysUDP.containsAll(expectedKeysUDP));\r
+ }\r
+\r
+ private Classifier newClassifier(ClassifierDefinitionId classifierDefinitionId,\r
+ ParameterValueList parameterValues) {\r
+ return new ClassifierBuilder().setName(classifierName)\r
+ .setClassifierDefinitionId(classifierDefinitionId)\r
+ .setParameterValue(parameterValues)\r
+ .build();\r
+ }\r
+\r
+ private Classifier newEtherTypeClassifier(ParameterValueList parameterValues) {\r
+ return newClassifier(EtherTypeClassifierDefinition.ID, parameterValues);\r
+ }\r
+\r
+ private Classifier newIpProtoClassifier(ParameterValueList parameterValues) {\r
+ return newClassifier(IpProtoClassifierDefinition.ID, parameterValues);\r
+ }\r
+\r
+ private Classifier newL4Classifier(ParameterValueList parameterValues) {\r
+ return newClassifier(L4ClassifierDefinition.ID, parameterValues);\r
+ }\r
+\r
+ private FlowCache callCreateFlowCache(ResolvedPolicy rp, Classifier classifier) {\r
+ return FlowCacheFactory.createFlowCache(\r
+ TestUtils.getClassifierIid(ResolvedPolicyClassifierListener.resolveClassifiers(rp, rpIid)), classifier,\r
+ FlowCacheCons.Value.BYTES);\r
+ }\r
+\r
+ @SuppressWarnings("serial")\r
+ private class ParameterValueList extends ArrayList<ParameterValue> {\r
+\r
+ ParameterValueList() {\r
+ super();\r
+ }\r
+\r
+ private ParameterValueList addEthertype(Long value) {\r
+ this.add(newParameterValue(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, value));\r
+ return this;\r
+ }\r
+\r
+ private ParameterValueList addProto(Long value) {\r
+ this.add(newParameterValue(IpProtoClassifierDefinition.PROTO_PARAM, value));\r
+ return this;\r
+ }\r
+\r
+ private ParameterValueList addDstPort(Long value) {\r
+ this.add(newParameterValue(L4ClassifierDefinition.DST_PORT_PARAM, value));\r
+ return this;\r
+ }\r
+\r
+ private ParameterValueList addSrcPort(Long value) {\r
+ this.add(newParameterValue(L4ClassifierDefinition.SRC_PORT_PARAM, value));\r
+ return this;\r
+ }\r
+\r
+ private ParameterValue newParameterValue(String parameterName, Long intValue) {\r
+ return new ParameterValueBuilder().setName(new ParameterName(parameterName)).setIntValue(intValue).build();\r
+ }\r
+\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class FlowCacheFilterBuilderTest {\r
+\r
+ private static final String VALUE_1 = "value_1";\r
+ private static final String VALUE_2 = "value_2";\r
+ private static final String VALUE_3 = "value_3";\r
+ private static final List<String> LIST = new ArrayList<>();\r
+\r
+ private FlowCacheFilter.FlowCacheFilterBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCacheFilter.FlowCacheFilterBuilder();\r
+ LIST.add(VALUE_1);\r
+ LIST.add(VALUE_2);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCacheFilter.FlowCacheFilterBuilder b = null;\r
+ try {\r
+ b = new FlowCacheFilter.FlowCacheFilterBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ assertNotNull(b.getValues());\r
+ assertTrue(b.getValues().isEmpty());\r
+ }\r
+\r
+ @Test\r
+ public void testSetValues() {\r
+ builder.setValues(LIST);\r
+\r
+ assertFalse(builder.getValues().isEmpty());\r
+ assertEquals(LIST.size(), builder.getValues().size());\r
+ assertEquals(LIST.get(0), builder.getValues().get(0));\r
+ }\r
+\r
+ @Test\r
+ public void testAddValue() {\r
+ builder.setValues(LIST);\r
+ int expectedSize = LIST.size() + 1;\r
+\r
+ builder.addValue(VALUE_3);\r
+\r
+ assertEquals(expectedSize, builder.getValues().size());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ builder.setValues(LIST);\r
+\r
+ FlowCacheFilter filter = builder.build();\r
+\r
+ assertTrue(filter.getValue().contains(VALUE_1));\r
+ assertTrue(filter.getValue().contains(VALUE_2));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Test;\r
+\r
+public class FlowCacheFilterTest {\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCacheFilter.FlowCacheFilterBuilder builder = null;\r
+ try {\r
+ builder = FlowCacheFilter.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class FlowCacheKeysBuilderTest {\r
+\r
+ private static final String VALUE_1 = "value_1";\r
+ private static final String VALUE_2 = "value_2";\r
+ private static final String VALUE_3 = "value_3";\r
+ private static final List<String> LIST = new ArrayList<>();\r
+\r
+ private FlowCacheKeys.FlowCacheKeysBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCacheKeys.FlowCacheKeysBuilder();\r
+ LIST.add(VALUE_1);\r
+ LIST.add(VALUE_2);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCacheKeys.FlowCacheKeysBuilder b = null;\r
+ try {\r
+ b = new FlowCacheKeys.FlowCacheKeysBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ assertNotNull(b.getValues());\r
+ assertTrue(b.getValues().isEmpty());\r
+ }\r
+\r
+ @Test\r
+ public void testSetValues() {\r
+ builder.setValues(LIST);\r
+\r
+ assertFalse(builder.getValues().isEmpty());\r
+ assertEquals(LIST.size(), builder.getValues().size());\r
+ assertEquals(LIST.get(0), builder.getValues().get(0));\r
+ }\r
+\r
+ @Test\r
+ public void testAddValue() {\r
+ builder.setValues(LIST);\r
+ int expectedSize = LIST.size() + 1;\r
+\r
+ builder.addValue(VALUE_3);\r
+\r
+ assertEquals(expectedSize, builder.getValues().size());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ builder.setValues(LIST);\r
+\r
+ FlowCacheKeys keys = builder.build();\r
+\r
+ assertTrue(keys.getValue().contains(VALUE_1));\r
+ assertTrue(keys.getValue().contains(VALUE_2));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Test;\r
+\r
+public class FlowCacheKeysTest {\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCacheKeys.FlowCacheKeysBuilder builder = null;\r
+ try {\r
+ builder = FlowCacheKeys.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection;\r
+\r
+public class FlowCacheTest {\r
+\r
+ private static final String KEY_1 = "key_1";\r
+ private static final String KEY_2 = "key_2";\r
+ private static final String NAME_1 = "name_1";\r
+ private static final HasDirection.Direction direction = HasDirection.Direction.Bidirectional;\r
+ private static final String VALUE_1 = "value_1";\r
+ private static FlowCacheDefinition flowCacheDefinition;\r
+ private List<String> keysValues;\r
+ private String json;\r
+\r
+ @Before\r
+ public void init() {\r
+ keysValues = new ArrayList<>();\r
+ keysValues.add(KEY_1);\r
+ keysValues.add(KEY_2);\r
+\r
+ FlowCacheDefinition.FlowCacheDefinitionBuilder flowCacheDefinitionBuilder = FlowCacheDefinition.builder();\r
+ flowCacheDefinitionBuilder.getKeysBuilder().setValues(keysValues);\r
+ flowCacheDefinition = flowCacheDefinitionBuilder.setValue(VALUE_1).setLog(true).build();\r
+\r
+ json = "{\"keys\":\"" + KEY_1 + "," + KEY_2 + "\"," + "\"value\":\"" + VALUE_1 + "\","\r
+ + "\"filter\":\"\",\"log\":true}";\r
+ }\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCache.FlowCacheBuilder builder = null;\r
+ try {\r
+ builder = FlowCache.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor_Implicitely() {\r
+ FlowCache flowCache =\r
+ FlowCache.builder().setDefinition(flowCacheDefinition).setDirection(direction).setName(NAME_1).build();\r
+\r
+ assertEquals(keysValues.size(), flowCache.getKeyNum());\r
+ assertEquals(keysValues.get(0), flowCache.getKeyNames()[0]);\r
+ assertEquals(keysValues.get(1), flowCache.getKeyNames()[1]);\r
+ assertEquals(FlowCache.API_FLOW + NAME_1 + FlowCache.SUFFIX_JSON, flowCache.getPath());\r
+ assertEquals(json, flowCache.getJsonDefinition());\r
+\r
+ }\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.ResolvedPolicyClassifierListener;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class IidSflowNameUtilTest {\r
+\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = ClassifierName.getDefaultInstance("classifier1");\r
+ private final SubjectName subjectName = SubjectName.getDefaultInstance("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+ private InstanceIdentifier<ResolvedPolicy> rpIid;\r
+ private String testName;\r
+ private ResolvedPolicy resolvedPolicy;\r
+\r
+ @Before\r
+ public void init() {\r
+ Classifier classifier = mock(Classifier.class);\r
+ when(classifier.getKey()).thenReturn(new ClassifierKey(classifierName));\r
+\r
+ resolvedPolicy = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName,\r
+ consumerEpgId, providerEpgId, classifier);\r
+\r
+ rpIid = InstanceIdentifier.create(ResolvedPolicy.class);\r
+ testName =\r
+ tenantId.getValue() + IidSflowNameUtil.KEY_DELIMETER + contractId.getValue() + IidSflowNameUtil.KEY_DELIMETER + subjectName\r
+ .getValue() + IidSflowNameUtil.DELIMETER + ruleName.getValue() + IidSflowNameUtil.DELIMETER + classifierName\r
+ .getValue() + IidSflowNameUtil.DELIMETER + FlowCacheCons.Value.BYTES.get();\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCacheName() {\r
+ InstanceIdentifier<Classifier> classifierIid = TestUtils.getClassifierIid(\r
+ ResolvedPolicyClassifierListener.resolveClassifiers(resolvedPolicy, rpIid));\r
+\r
+ assertEquals(testName,\r
+ IidSflowNameUtil.createFlowCacheName(classifierIid, FlowCacheCons.Value.BYTES));\r
+ }\r
+\r
+ @Test\r
+ public void testResolveContractIdFromFlowCacheName() {\r
+ assertEquals(contractId.getValue(),\r
+ IidSflowNameUtil.resolveContractIdFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveSubjectNameFromFlowCacheName() {\r
+ assertEquals(subjectName.getValue(),\r
+ IidSflowNameUtil.resolveSubjectNameFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveRuleNameFromFlowCacheName() {\r
+ assertEquals(ruleName.getValue(),\r
+ IidSflowNameUtil.resolveRuleNameFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveClassifierNameFromFlowCacheName() {\r
+ assertEquals(classifierName.getValue(),\r
+ IidSflowNameUtil.resolveClassifierNameFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveFlowCacheValue() {\r
+ assertEquals(FlowCacheCons.Value.BYTES.get(),\r
+ IidSflowNameUtil.resolveFlowCacheValue(testName));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class TestUtils {
+
+ // taken from org.opendaylight.groupbasedpolicy.renderer.faas.FaasPolicyManagerTest
+ // by Khaldoon Al-zoubi; modified as necessary
+ public static ResolvedPolicy newResolvedPolicy(TenantId tenantId, ContractId contractId, SubjectName subjectName,
+ RuleName ruleName, EndpointGroupId consumerEpgId, EndpointGroupId providerEpgId, Classifier classifier) {
+ ResolvedPolicyBuilder builder = new ResolvedPolicyBuilder();
+ builder.setConsumerEpgId(consumerEpgId);
+ builder.setConsumerTenantId(tenantId);
+ builder.setProviderEpgId(providerEpgId);
+ builder.setProviderTenantId(tenantId);
+ List<PolicyRuleGroupWithEndpointConstraints> pRulesGrpsWEp = new ArrayList<>();
+ PolicyRuleGroupWithEndpointConstraintsBuilder pRulesGrpWEp =
+ new PolicyRuleGroupWithEndpointConstraintsBuilder();
+ List<PolicyRuleGroup> pRulesGrps = new ArrayList<>();
+ PolicyRuleGroupBuilder pRulesGrp = new PolicyRuleGroupBuilder();
+ pRulesGrp.setContractId(contractId);
+ pRulesGrp.setTenantId(tenantId);
+ pRulesGrp.setSubjectName(subjectName);
+ pRulesGrp.setResolvedRule(ImmutableList
+ .of(new ResolvedRuleBuilder().setName(ruleName).setClassifier(ImmutableList.of(classifier)).build()));
+ pRulesGrps.add(pRulesGrp.build());
+ pRulesGrpWEp.setPolicyRuleGroup(pRulesGrps);
+ pRulesGrpsWEp.add(pRulesGrpWEp.build());
+ builder.setPolicyRuleGroupWithEndpointConstraints(pRulesGrpsWEp);
+ return builder.build();
+ }
+
+ public static InstanceIdentifier<Classifier> getClassifierIid(
+ Map<InstanceIdentifier<Classifier>, Classifier> resolvedClassifiers) {
+ Map.Entry<InstanceIdentifier<Classifier>, Classifier> firstEntry =
+ resolvedClassifiers.entrySet().iterator().next();
+ return firstEntry.getKey();
+ }
+}