From: Michal Cmarada Date: Thu, 13 Oct 2016 09:46:56 +0000 (+0200) Subject: L4 classifier for VPP renderer X-Git-Tag: release/carbon~87 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;ds=sidebyside;h=8274cc1cfe7e2e454fe57fa6616afaba4b7e4453;p=groupbasedpolicy.git L4 classifier for VPP renderer Change-Id: I40154444098a7fdd5d52bdf91ebba684f7f2babf Signed-off-by: Michal Cmarada --- 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 f6beb860b..33949003a 100755 --- 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 index 000000000..c24d2579f --- /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 getSupportedParameterValues() { + List allPossiblePortsIntInRange = + ImmutableList.of(new SupportedIntValueInRangeBuilder().setMin(1L).setMax(65535L).build()); + List 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 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 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 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 index 000000000..dd0281a4d --- /dev/null +++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4ClassifierTest.java @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2016 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 org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition; +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.instance.ParameterValue; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.parameter.value.RangeValueBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.Assert.*; + +public class L4ClassifierTest { + + private ParameterValue pvSrcPort80; + private ParameterValue pvDstPort80; + private ParameterValue pvDstPort_null; + private ParameterValue pvSrcRange81_82; + private ParameterValue pvDstRange81_82; + private ParameterValue pvDstRange82_81; + private ParameterValue pvDstRange_null; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Before + public void init() { + pvSrcPort80 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)).setIntValue(80L).build(); + pvDstPort80 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).setIntValue(80L).build(); + pvDstPort_null = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build(); + pvSrcRange81_82 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM)) + .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build()) + .build(); + pvDstRange81_82 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)) + .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build()) + .build(); + pvDstRange82_81 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)) + .setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build()) + .build(); + pvDstRange_null = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)) + //.setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build()) + .build(); + } + + @Test + public void testGetId() { + assertEquals(L4ClassifierDefinition.ID, Classifier.L4_CL.getId()); + } + + @Test + public void testGetClassifierDefinition() { + assertEquals(L4ClassifierDefinition.DEFINITION, Classifier.L4_CL.getClassifierDefinition()); + } + + @Test + public void testGetSupportedParameterValues() { + List valuesList = Classifier.L4_CL.getSupportedParameterValues(); + assertEquals(4, valuesList.size()); + + SupportedParameterValues values = valuesList.get(0); + assertNotNull(values); + assertEquals(L4ClassifierDefinition.SRC_PORT_PARAM, values.getParameterName().getValue()); + ParameterType pt = values.getParameterType(); + assertTrue(pt instanceof Int); + } + + @Test + public void testCheckPresenceOfRequiredParams_Empty() throws Exception { + // TODO check: sending empty map is ok? + Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap()); + } + + @Test + public void testCheckPresenceOfRequiredParams_SinglePorts() throws Exception { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort80); + + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_PortRanges() throws Exception { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82); + params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange81_82); + + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_DstPortNull() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort_null); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_DstRangeNull() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange_null); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_ParamConflict() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_MUT_EXCLUSIVE_PARAMS); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_RangeInverted() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange82_81); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_RANGE_VALUE_MISMATCH); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_emptyParams() { + + Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap()); + } + + @Test + public void testGetParent() { + assertEquals(Classifier.L4_CL.getParent(), Classifier.IP_PROTO_CL); + } + +}