renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/sf/L4Classifier.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
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.sf;
  10
  11 import java.util.List;
  12 import java.util.Map;
  13
  14 import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
  15 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.GbpAceBuilder;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder;
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.RangeBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValuesBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueInRange;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueInRangeBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValue;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValueBuilder;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 import com.google.common.collect.ImmutableList;
  35
  36 /**
  37  * Match against TCP or UDP, and source and/or destination ports
  38  */
  39 public class L4Classifier extends Classifier {
  40
  41     private static final Logger LOG = LoggerFactory.getLogger(L4Classifier.class);
  42
  43     static final String EXC_MSG_PARAM_VALUE_NOT_SPECIFIED = "Value of parameter not specified: ";
  44     static final String EXC_MSG_MUT_EXCLUSIVE_PARAMS = "Mutually exclusive parameters: ";
  45     static final String EXC_MSG_RANGE_VALUE_MISMATCH = "Range value mismatch: ";
  46
  47     public L4Classifier(Classifier parent) {
  48         super(parent);
  49     }
  50
  51     @Override
  52     public ClassifierDefinitionId getId() {
  53         return L4ClassifierDefinition.ID;
  54     }
  55
  56     @Override
  57     public ClassifierDefinition getClassifierDefinition() {
  58         return L4ClassifierDefinition.DEFINITION;
  59     }
  60
  61     @Override
  62     public List<SupportedParameterValues> getSupportedParameterValues() {
  63         List<SupportedIntValueInRange> allPossiblePortsIntInRange =
  64                 ImmutableList.of(new SupportedIntValueInRangeBuilder().setMin(1L).setMax(65535L).build());
  65         List<SupportedRangeValue> allPossiblePortsRange =
  66                 ImmutableList.of(new SupportedRangeValueBuilder().setMin(1L).setMax(65535L).build());
  67
  68         SupportedParameterValues srcPorts = new SupportedParameterValuesBuilder()
  69             .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM))
  70             .setParameterType(new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build())
  71             .build();
  72         SupportedParameterValues dstPorts = new SupportedParameterValuesBuilder()
  73             .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM))
  74             .setParameterType(new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build())
  75             .build();
  76
  77         SupportedParameterValues srcPortsRange = new SupportedParameterValuesBuilder()
  78             .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM))
  79             .setParameterType(new RangeBuilder().setSupportedRangeValue(allPossiblePortsRange).build())
  80             .build();
  81         SupportedParameterValues dstPortsRange = new SupportedParameterValuesBuilder()
  82             .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))
  83             .setParameterType(new RangeBuilder().setSupportedRangeValue(allPossiblePortsRange).build())
  84             .build();
  85
  86         return ImmutableList.of(srcPorts, dstPorts, srcPortsRange, dstPortsRange);
  87     }
  88
  89     @Override
  90     protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
  91         validatePortParam(params, L4ClassifierDefinition.SRC_PORT_PARAM, L4ClassifierDefinition.SRC_PORT_RANGE_PARAM);
  92         validatePortParam(params, L4ClassifierDefinition.DST_PORT_PARAM, L4ClassifierDefinition.DST_PORT_RANGE_PARAM);
  93         validateRange(params, L4ClassifierDefinition.SRC_PORT_RANGE_PARAM);
  94         validateRange(params, L4ClassifierDefinition.DST_PORT_RANGE_PARAM);
  95     }
  96
  97     private void validatePortParam(Map<String, ParameterValue> params, String portParam, String portRangeParam) {
  98         if (params.get(portParam) != null) {
  99             StringBuilder paramLog = new StringBuilder();
 100             if (params.get(portParam).getIntValue() == null) {
 101                 paramLog.append(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED).append(portParam);
 102                 throw new IllegalArgumentException(paramLog.toString());
 103             }
 104             if (params.get(portRangeParam) != null) {
 105                 paramLog.append(EXC_MSG_MUT_EXCLUSIVE_PARAMS).append(portParam).append(" and ").append(portRangeParam);
 106                 throw new IllegalArgumentException(paramLog.toString());
 107             }
 108         }
 109     }
 110
 111     private void validateRange(Map<String, ParameterValue> params, String portRangeParam) {
 112         if (params.get(portRangeParam) != null) {
 113             if (params.get(portRangeParam).getRangeValue() == null) {
 114                 throw new IllegalArgumentException(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED + portRangeParam);
 115             }
 116             Long min = params.get(portRangeParam).getRangeValue().getMin();
 117             Long max = params.get(portRangeParam).getRangeValue().getMax();
 118             if (min > max) {
 119                 throw new IllegalArgumentException(EXC_MSG_RANGE_VALUE_MISMATCH + min + ">" + max);
 120             }
 121         }
 122     }
 123
 124     @Override
 125     GbpAceBuilder update(GbpAceBuilder ruleBuilder, Map<String, ParameterValue> params) {
 126         ruleBuilder.setSourcePortRange(resolveSourcePortRange(params, L4ClassifierDefinition.SRC_PORT_PARAM,
 127                 L4ClassifierDefinition.SRC_PORT_RANGE_PARAM));
 128         ruleBuilder.setDestinationPortRange(resolveDestinationPortRange(params, L4ClassifierDefinition.DST_PORT_PARAM,
 129                 L4ClassifierDefinition.DST_PORT_RANGE_PARAM));
 130         return ruleBuilder;
 131     }
 132
 133     private SourcePortRangeBuilder resolveSourcePortRange(Map<String, ParameterValue> params, String portParam,
 134         String portRangeParam) {
 135         SourcePortRangeBuilder srcRange = new SourcePortRangeBuilder();
 136         if (params.get(portParam) != null) {
 137             PortNumber portNumber = new PortNumber(params.get(portParam).getIntValue().intValue());
 138             srcRange.setLowerPort(portNumber).setUpperPort(portNumber);
 139         }
 140         if (params.get(portRangeParam) != null) {
 141             srcRange.setLowerPort(new PortNumber(params.get(portParam).getRangeValue().getMin().intValue()));
 142             srcRange.setUpperPort(new PortNumber(params.get(portParam).getRangeValue().getMax().intValue()));
 143         }
 144         return srcRange;
 145     }
 146
 147     private DestinationPortRangeBuilder resolveDestinationPortRange(Map<String, ParameterValue> params,
 148         String portParam, String portRangeParam) {
 149         DestinationPortRangeBuilder dstRange = new DestinationPortRangeBuilder();
 150         if (params.get(portParam) != null) {
 151             PortNumber portNumber = new PortNumber(params.get(portParam).getIntValue().intValue());
 152             dstRange.setLowerPort(portNumber).setUpperPort(portNumber);
 153         }
 154         if (params.get(portRangeParam) != null) {
 155             dstRange.setLowerPort(new PortNumber(params.get(portParam).getRangeValue().getMin().intValue()));
 156             dstRange.setUpperPort(new PortNumber(params.get(portParam).getRangeValue().getMax().intValue()));
 157         }
 158         return dstRange;
 159     }
 160
 161     @Override
 162     void checkPrereqs(GbpAceBuilder matchBuilders) {
 163         // TODO check whether mandatory fields are set in builder
 164     }
 165
 166 }