L4 classifier for VPP renderer

Change-Id: I40154444098a7fdd5d52bdf91ebba684f7f2babf
Signed-off-by: Michal Cmarada <mcmarada@cisco.com>

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/Classifier.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/Classifier.java
index f6beb860b11f37f5856e9fb4459fba3343b79327..33949003afc9d5008ebe920e0355ef4a307bcc71 100755 (executable)
--- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/Classifier.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/Classifier.java
@@ -25,6 +25,7 @@ public abstract class Classifier {
 
     public static final EtherTypeClassifier ETHER_TYPE_CL = new EtherTypeClassifier(null);
     public static final IpProtoClassifier IP_PROTO_CL = new IpProtoClassifier(ETHER_TYPE_CL);
+    public static final L4Classifier L4_CL = new L4Classifier(IP_PROTO_CL);
 
     protected Classifier(Classifier parent) {
         this.parent = parent;

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4Classifier.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4Classifier.java
new file mode 100644 (file)
index 0000000..c24d257
--- /dev/null
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4Classifier.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer.vpp.sf;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.RangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValuesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueInRange;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueInRangeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValueBuilder;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Match against TCP or UDP, and source and/or destination ports
+ */
+public class L4Classifier extends Classifier {
+
+    static final String EXC_MSG_PARAM_VALUE_NOT_SPECIFIED = "Value of parameter not specified: ";
+    static final String EXC_MSG_MUT_EXCLUSIVE_PARAMS = "Mutually exclusive parameters: ";
+    static final String EXC_MSG_RANGE_VALUE_MISMATCH = "Range value mismatch: ";
+
+    protected L4Classifier(Classifier parent) {
+        super(parent);
+    }
+
+    @Override
+    public ClassifierDefinitionId getId() {
+        return L4ClassifierDefinition.ID;
+    }
+
+    @Override
+    public ClassifierDefinition getClassifierDefinition() {
+        return L4ClassifierDefinition.DEFINITION;
+    }
+
+    @Override
+    public List<SupportedParameterValues> getSupportedParameterValues() {
+        List<SupportedIntValueInRange> allPossiblePortsIntInRange =
+                ImmutableList.of(new SupportedIntValueInRangeBuilder().setMin(1L).setMax(65535L).build());
+        List<SupportedRangeValue> allPossiblePortsRange =
+                ImmutableList.of(new SupportedRangeValueBuilder().setMin(1L).setMax(65535L).build());
+
+        SupportedParameterValues srcPorts = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM))
+            .setParameterType(new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build())
+            .build();
+        SupportedParameterValues dstPorts = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM))
+            .setParameterType(new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build())
+            .build();
+
+        SupportedParameterValues srcPortsRange = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM))
+            .setParameterType(new RangeBuilder().setSupportedRangeValue(allPossiblePortsRange).build())
+            .build();
+        SupportedParameterValues dstPortsRange = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))
+            .setParameterType(new RangeBuilder().setSupportedRangeValue(allPossiblePortsRange).build())
+            .build();
+
+        return ImmutableList.of(srcPorts, dstPorts, srcPortsRange, dstPortsRange);
+    }
+
+    @Override
+    protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
+        validatePortParam(params, L4ClassifierDefinition.SRC_PORT_PARAM, L4ClassifierDefinition.SRC_PORT_RANGE_PARAM);
+        validatePortParam(params, L4ClassifierDefinition.DST_PORT_PARAM, L4ClassifierDefinition.DST_PORT_RANGE_PARAM);
+        validateRange(params, L4ClassifierDefinition.SRC_PORT_RANGE_PARAM);
+        validateRange(params, L4ClassifierDefinition.DST_PORT_RANGE_PARAM);
+    }
+
+    private void validatePortParam(Map<String, ParameterValue> params, String portParam, String portRangeParam) {
+        if (params.get(portParam) != null) {
+            StringBuilder paramLog = new StringBuilder();
+            if (params.get(portParam).getIntValue() == null) {
+                paramLog.append(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED).append(portParam);
+                throw new IllegalArgumentException(paramLog.toString());
+            }
+            if (params.get(portRangeParam) != null) {
+                paramLog.append(EXC_MSG_MUT_EXCLUSIVE_PARAMS).append(portParam).append(" and ").append(portRangeParam);
+                throw new IllegalArgumentException(paramLog.toString());
+            }
+        }
+    }
+
+    private void validateRange(Map<String, ParameterValue> params, String portRangeParam) {
+        if (params.get(portRangeParam) != null) {
+            if (params.get(portRangeParam).getRangeValue() == null) {
+                throw new IllegalArgumentException(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED + portRangeParam);
+            }
+            Long min = params.get(portRangeParam).getRangeValue().getMin();
+            Long max = params.get(portRangeParam).getRangeValue().getMax();
+            if (min > max) {
+                throw new IllegalArgumentException(EXC_MSG_RANGE_VALUE_MISMATCH + min + ">" + max);
+            }
+        }
+    }
+
+}

diff --git a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4ClassifierTest.java b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4ClassifierTest.java
new file mode 100644 (file)
index 0000000..dd0281a
--- /dev/null
+++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4ClassifierTest.java
@@ -0,0 +1,170 @@
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp.sf;\r
+\r
+import org.junit.Before;\r
+import org.junit.Rule;\r
+import org.junit.Test;\r
+import org.junit.rules.ExpectedException;\r
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;\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.policy.rev140421.subject.feature.instance.parameter.value.RangeValueBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;\r
+\r
+import java.util.HashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+\r
+import static org.junit.Assert.*;\r
+\r
+public class L4ClassifierTest {\r
+\r
+    private ParameterValue pvSrcPort80;\r
+    private ParameterValue pvDstPort80;\r
+    private ParameterValue pvDstPort_null;\r
+    private ParameterValue pvSrcRange81_82;\r
+    private ParameterValue pvDstRange81_82;\r
+    private ParameterValue pvDstRange82_81;\r
+    private ParameterValue pvDstRange_null;\r
+\r
+    @Rule\r
+    public ExpectedException thrown = ExpectedException.none();\r
+\r
+    @Before\r
+    public void init() {\r
+        pvSrcPort80 = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)).setIntValue(80L).build();\r
+        pvDstPort80 = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).setIntValue(80L).build();\r
+        pvDstPort_null = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build();\r
+        pvSrcRange81_82 = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM))\r
+                .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build())\r
+                .build();\r
+        pvDstRange81_82 = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
+                .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build())\r
+                .build();\r
+        pvDstRange82_81 = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
+                .setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build())\r
+                .build();\r
+        pvDstRange_null = new ParameterValueBuilder().setName(\r
+                new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
+                //.setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build())\r
+                .build();\r
+    }\r
+\r
+    @Test\r
+    public void testGetId() {\r
+        assertEquals(L4ClassifierDefinition.ID, Classifier.L4_CL.getId());\r
+    }\r
+\r
+    @Test\r
+    public void testGetClassifierDefinition() {\r
+        assertEquals(L4ClassifierDefinition.DEFINITION, Classifier.L4_CL.getClassifierDefinition());\r
+    }\r
+\r
+    @Test\r
+    public void testGetSupportedParameterValues() {\r
+        List<SupportedParameterValues> valuesList = Classifier.L4_CL.getSupportedParameterValues();\r
+        assertEquals(4, valuesList.size());\r
+\r
+        SupportedParameterValues values = valuesList.get(0);\r
+        assertNotNull(values);\r
+        assertEquals(L4ClassifierDefinition.SRC_PORT_PARAM, values.getParameterName().getValue());\r
+        ParameterType pt = values.getParameterType();\r
+        assertTrue(pt instanceof Int);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_Empty() throws Exception {\r
+        // TODO check: sending empty map is ok?\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap<String, ParameterValue>());\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_SinglePorts() throws Exception {\r
+        Map<String, ParameterValue> params = new HashMap<>();\r
+        params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+        params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort80);\r
+\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_PortRanges() throws Exception {\r
+        Map<String, ParameterValue> params = new HashMap<>();\r
+        params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82);\r
+        params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange81_82);\r
+\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_DstPortNull() throws IllegalArgumentException {\r
+        Map<String, ParameterValue> params = new HashMap<>();\r
+        params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+        params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort_null);\r
+\r
+        thrown.expect(IllegalArgumentException.class);\r
+        thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED);\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_DstRangeNull() throws IllegalArgumentException {\r
+        Map<String, ParameterValue> params = new HashMap<>();\r
+        params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+        params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange_null);\r
+\r
+        thrown.expect(IllegalArgumentException.class);\r
+        thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED);\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_ParamConflict() throws IllegalArgumentException {\r
+        Map<String, ParameterValue> params = new HashMap<>();\r
+        params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+        params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82);\r
+\r
+        thrown.expect(IllegalArgumentException.class);\r
+        thrown.expectMessage(L4Classifier.EXC_MSG_MUT_EXCLUSIVE_PARAMS);\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_RangeInverted() throws IllegalArgumentException {\r
+        Map<String, ParameterValue> params = new HashMap<>();\r
+        params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+        params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange82_81);\r
+\r
+        thrown.expect(IllegalArgumentException.class);\r
+        thrown.expectMessage(L4Classifier.EXC_MSG_RANGE_VALUE_MISMATCH);\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+    }\r
+\r
+    @Test\r
+    public void testCheckPresenceOfRequiredParams_emptyParams() {\r
+\r
+        Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap<String, ParameterValue>());\r
+    }\r
+\r
+    @Test\r
+    public void testGetParent() {\r
+        assertEquals(Classifier.L4_CL.getParent(), Classifier.IP_PROTO_CL);\r
+    }\r
+\r
+}\r