</dependency>
<!-- GBP configuration -->
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>ofoverlay-renderer</artifactId>
<version>${project.version}</version>
<type>xml</type>
<classifier>config</classifier>
- </dependency>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>iovisor-renderer</artifactId>
<version>${project.version}</version>
<type>xml</type>
<classifier>config</classifier>
- </dependency>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>netconf-renderer</artifactId>
</dependency>
<!-- GBP configuration -->
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>ofoverlay-renderer</artifactId>
<feature version='${mdsal.version}'>odl-mdsal-binding-base</feature>
<feature version='${mdsal.model.version}'>odl-mdsal-models</feature>
<bundle>mvn:org.opendaylight.groupbasedpolicy/groupbasedpolicy/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-groupbasedpolicy-base.xml">mvn:org.opendaylight.groupbasedpolicy/groupbasedpolicy/{{VERSION}}/xml/config</configfile>
</feature>
<!--
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>groupbasedpolicy</artifactId>
- <version>0.3.0-SNAPSHOT</version>
+ <version>0.3.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>groupbasedpolicy-base</name>
org.opendaylight.controller.config.yang.config.endpoint_provider,
org.opendaylight.groupbasedpolicy.endpoint,
org.opendaylight.groupbasedpolicy.resolver.*,
+ org.opendaylight.groupbasedpolicy.sf.actions.*,
+ org.opendaylight.groupbasedpolicy.sf.classifiers.*,
org.opendaylight.groupbasedpolicy.util,
</Export-Package>
</instructions>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2015 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
+-->
+<snapshot>
+ <configuration>
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:groupbasedpolicy="urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy:impl">
+ groupbasedpolicy:groupbasedpolicy-impl
+ </type>
+ <name>groupbasedpolicy-impl</name>
+
+ <data-broker>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-async-data-broker</type>
+ <name>binding-data-broker</name>
+ </data-broker>
+
+ </module>
+ </modules>
+ </data>
+
+ </configuration>
+
+ <required-capabilities>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy:impl?module=groupbasedpolicy-impl&revision=2015-11-06</capability>
+ </required-capabilities>
+
+</snapshot>
--- /dev/null
+/*
+ * Copyright (c) 2015 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.controller.config.yang.config.groupbasedpolicy.impl;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.sf.SubjectFeatureDefinitionProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class GroupbasedpolicyModule extends
+ org.opendaylight.controller.config.yang.config.groupbasedpolicy.impl.AbstractGroupbasedpolicyModule {
+
+ private static final Logger LOG = LoggerFactory.getLogger(GroupbasedpolicyModule.class);
+
+ public GroupbasedpolicyModule(
+ org.opendaylight.controller.config.api.ModuleIdentifier identifier,
+ org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public GroupbasedpolicyModule(
+ org.opendaylight.controller.config.api.ModuleIdentifier identifier,
+ org.opendaylight.controller.config.api.DependencyResolver dependencyResolver,
+ org.opendaylight.controller.config.yang.config.groupbasedpolicy.impl.GroupbasedpolicyModule oldModule,
+ java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void customValidation() {
+ // add custom validation form module attributes here.
+ }
+
+ /**
+ * On module start, creates SubjectFeatureDefinitionProvider instance, in order to put known Subject Feature Definitions to operational Datastore
+ *
+ * @return SubjectFeatureDefinitionProvider
+ */
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ DataBroker dataProvider = Preconditions.checkNotNull(getDataBrokerDependency());
+
+ try {
+ return new SubjectFeatureDefinitionProvider(dataProvider);
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("Error creating instance of SubjectFeatureDefinitionProvider; Subject Feature Definitions were not put to Datastore");
+ throw new RuntimeException(e);
+ }
+ }
+}
--- /dev/null
+/*
+* Generated file
+*
+* Generated from: yang module name: groupbasedpolicy-impl yang module local name: groupbasedpolicy-impl
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Fri Nov 06 13:54:27 CET 2015
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.config.groupbasedpolicy.impl;
+public class GroupbasedpolicyModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.impl.AbstractGroupbasedpolicyModuleFactory {
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.sf;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.sf.actions.AllowActionDefinition;
+import org.opendaylight.groupbasedpolicy.sf.actions.ChainActionDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * On creation, puts known Subject Feature Definitions to operational datastore; deletes them on #close()
+ */
+public class SubjectFeatureDefinitionProvider implements AutoCloseable {
+ private static final Logger LOG =
+ LoggerFactory.getLogger(SubjectFeatureDefinitionProvider.class);
+
+ private final DataBroker dataProvider;
+
+ /**
+ * Puts known Subject Feature Definitions to operational datastore
+ *
+ * @param dataProvider DataBroker
+ * @throws TransactionCommitFailedException
+ */
+ public SubjectFeatureDefinitionProvider(DataBroker dataProvider)
+ throws TransactionCommitFailedException {
+ this.dataProvider = dataProvider;
+
+ putSubjectFeatureDefinitions();
+ }
+
+ @Override
+ public void close() throws Exception {
+ deleteSubjectFeatureDefinitions();
+ }
+
+ private void putSubjectFeatureDefinitions() throws TransactionCommitFailedException {
+ WriteTransaction wt = this.dataProvider.newWriteOnlyTransaction();
+
+ wt.put(LogicalDatastoreType.OPERATIONAL, EtherTypeClassifierDefinition.IID,
+ EtherTypeClassifierDefinition.DEFINITION);
+ wt.put(LogicalDatastoreType.OPERATIONAL, IpProtoClassifierDefinition.IID,
+ IpProtoClassifierDefinition.DEFINITION);
+ wt.put(LogicalDatastoreType.OPERATIONAL, L4ClassifierDefinition.IID,
+ L4ClassifierDefinition.DEFINITION);
+
+ wt.put(LogicalDatastoreType.OPERATIONAL, AllowActionDefinition.IID,
+ AllowActionDefinition.DEFINITION);
+ wt.put(LogicalDatastoreType.OPERATIONAL, ChainActionDefinition.IID,
+ ChainActionDefinition.DEFINITION);
+
+ wt.submit().checkedGet();
+ }
+
+ private void deleteSubjectFeatureDefinitions() throws TransactionCommitFailedException {
+ WriteTransaction wt = this.dataProvider.newWriteOnlyTransaction();
+
+ wt.delete(LogicalDatastoreType.OPERATIONAL, EtherTypeClassifierDefinition.IID);
+ wt.delete(LogicalDatastoreType.OPERATIONAL, IpProtoClassifierDefinition.IID);
+ wt.delete(LogicalDatastoreType.OPERATIONAL, L4ClassifierDefinition.IID);
+
+ wt.delete(LogicalDatastoreType.OPERATIONAL, AllowActionDefinition.IID);
+ wt.delete(LogicalDatastoreType.OPERATIONAL, ChainActionDefinition.IID);
+
+ wt.submit().checkedGet();
+ }
+
+}
--- /dev/null
+/*
+ * 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.sf.actions;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Allow action
+ */
+public class AllowActionDefinition {
+
+ public static final ActionDefinitionId ID = new ActionDefinitionId("f942e8fd-e957-42b7-bd18-f73d11266d17");
+ /**
+ * Access control - allow action-definition
+ */
+ public static final ActionDefinition DEFINITION = new ActionDefinitionBuilder().setId(ID)
+ .setName(new ActionName("allow"))
+ .setDescription(new Description("Allow the specified traffic to pass"))
+ .build();
+
+ public static final InstanceIdentifier IID =
+ InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
+ .child(ActionDefinition.class, DEFINITION.getKey())
+ .build();
+
+}
--- /dev/null
+/*
+ * 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.sf.actions;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.IsRequired;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class ChainActionDefinition {
+
+ public static final ActionDefinitionId ID = new ActionDefinitionId("3d886be7-059f-4c4f-bbef-0356bea40933");
+
+ public static final Integer CHAIN_CONDITION_GROUP = 0xfffffe;
+
+ //protected static final String TYPE = "type";
+
+ // the chain action
+ public static final String SFC_CHAIN_ACTION = "chain";
+
+ // the parameter used for storing the chain name
+ public static final String SFC_CHAIN_NAME = "sfc-chain-name";
+
+ public static final ActionDefinition DEFINITION = new ActionDefinitionBuilder().setId(ID)
+ .setName(new ActionName(SFC_CHAIN_ACTION))
+ .setDescription(new Description("Send the traffic through a Service Function Chain"))
+ .setParameter(
+ (ImmutableList.of(new ParameterBuilder().setName(new ParameterName(SFC_CHAIN_NAME))
+ .setDescription(new Description("The named chain to match against"))
+ .setIsRequired(IsRequired.Required)
+ .setType(Type.String)
+ .build())))
+ .build();
+
+ public static final InstanceIdentifier IID =
+ InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
+ .child(ActionDefinition.class, DEFINITION.getKey())
+ .build();
+
+}
--- /dev/null
+/*
+ * 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.sf.classifiers;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.IsRequired;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
+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.definitions.ClassifierDefinitionBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Match on the ether type of the traffic
+ */
+public class EtherTypeClassifierDefinition {
+
+ /**
+ * Ethertype parameter name
+ */
+ public static final String ETHERTYPE_PARAM = "ethertype";
+ /**
+ * ARP ethertype value
+ */
+ public static final Long ARP_VALUE = Long.valueOf(0x0806);
+ /**
+ * IPv4 ethertype value
+ */
+ public static final Long IPv4_VALUE = Long.valueOf(0x0800);
+ /**
+ * IPv6 ethertype value
+ */
+ public static final Long IPv6_VALUE = Long.valueOf(0x86DD);
+
+ public static final ClassifierDefinitionId ID = new ClassifierDefinitionId(
+ "6a48ab45-a462-429d-b18c-3a575b2c8bef");
+ /**
+ * Ethertype classifier-definition
+ */
+ public static final ClassifierDefinition DEFINITION = new ClassifierDefinitionBuilder().setId(ID)
+ .setName(new ClassifierName("ether_type"))
+ .setDescription(new Description("Match on the ether type of the traffic"))
+ .setParameter(
+ ImmutableList.of(new ParameterBuilder().setName(new ParameterName(ETHERTYPE_PARAM))
+ .setDescription(new Description("The ethertype to match against"))
+ .setIsRequired(IsRequired.Required)
+ .setType(Type.Int)
+ .build()))
+ .build();
+
+ public static final InstanceIdentifier IID =
+ InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
+ .child(ClassifierDefinition.class, DEFINITION.getKey())
+ .build();
+
+}
--- /dev/null
+/*
+ * 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.sf.classifiers;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.IsRequired;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
+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.definitions.ClassifierDefinitionBuilder;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Match on the IP protocol of IP traffic
+ */
+public class IpProtoClassifierDefinition {
+
+ /**
+ * Protocol parameter name
+ */
+ public static final String PROTO_PARAM = "proto";
+ /**
+ * TCP protocol value
+ */
+ public static final Long TCP_VALUE = Long.valueOf(6);
+ /**
+ * UDP protocol value
+ */
+ public static final Long UDP_VALUE = Long.valueOf(17);
+ /**
+ * ICMP protocol value
+ */
+ public static final Long ICMP_VALUE = Long.valueOf(1);
+ /**
+ * SCTP protocol value
+ */
+ public static final Long SCTP_VALUE = Long.valueOf(132);
+
+ public static final ClassifierDefinitionId ID =
+ new ClassifierDefinitionId("79c6fdb2-1e1a-4832-af57-c65baf5c2335");
+ /**
+ * Protocol classifier-definition
+ */
+ public static final ClassifierDefinition DEFINITION =
+ new ClassifierDefinitionBuilder().setId(ID)
+ .setName(new ClassifierName("ip_proto"))
+ .setDescription(new Description("Match on the IP protocol of IP traffic"))
+ .setParameter(ImmutableList.of(
+ new ParameterBuilder().setName(new ParameterName(PROTO_PARAM))
+ .setDescription(new Description(
+ "The IP protocol to match against"))
+ .setIsRequired(IsRequired.Required)
+ .setType(Type.Int)
+ .build()))
+ .build();
+
+ public static final InstanceIdentifier IID =
+ InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
+ .child(ClassifierDefinition.class, DEFINITION.getKey())
+ .build();
+
+}
--- /dev/null
+/*
+ * 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.sf.classifiers;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
+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.definitions.ClassifierDefinitionBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Match against TCP or UDP, and source and/or destination ports
+ */
+public class L4ClassifierDefinition {
+
+ /**
+ * Source port parameter name
+ */
+ public static final String SRC_PORT_PARAM = "sourceport";
+ /**
+ * Source port range parameter name
+ */
+ public static final String SRC_PORT_RANGE_PARAM = "sourceport_range";
+ /**
+ * Destination port parameter name
+ */
+ public static final String DST_PORT_PARAM = "destport";
+ /**
+ * Destination port range parameter name
+ */
+ public static final String DST_PORT_RANGE_PARAM = "destport_range";
+
+ public static final ClassifierDefinitionId ID = new ClassifierDefinitionId(
+ "4250ab32-e8b8-445a-aebb-e1bd2cdd291f");
+ /**
+ * Layer 4 classifier-definition
+ */
+ public static final ClassifierDefinition DEFINITION = new ClassifierDefinitionBuilder().setId(
+ new ClassifierDefinitionId("4250ab32-e8b8-445a-aebb-e1bd2cdd291f"))
+ .setName(new ClassifierName("l4"))
+ .setDescription(new Description("Match on the port number of UDP or TCP traffic"))
+ .setParameter(
+ ImmutableList.of(
+ new ParameterBuilder().setName(new ParameterName(SRC_PORT_PARAM))
+ .setDescription(new Description("The source port number to match against"))
+ .setType(Type.Int)
+ .build(),
+ new ParameterBuilder().setName(new ParameterName(SRC_PORT_RANGE_PARAM))
+ .setDescription(new Description("The source port range to match against"))
+ .setType(Type.Range)
+ .build(),
+ new ParameterBuilder().setName(new ParameterName(DST_PORT_PARAM))
+ .setDescription(new Description("The destination port number to match against"))
+ .setType(Type.Int)
+ .build(), new ParameterBuilder().setName(new ParameterName(DST_PORT_RANGE_PARAM))
+ .setDescription(new Description("The destination port range to match against"))
+ .setType(Type.Range)
+ .build()))
+ .build();
+
+ public static final InstanceIdentifier IID =
+ InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
+ .child(ClassifierDefinition.class, DEFINITION.getKey())
+ .build();
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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
+ */
+
+module groupbasedpolicy-impl {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy:impl";
+ prefix "groupbasedpolicy-impl";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
+
+ description
+ "This module contains the base YANG definitions for
+ groupbasedpolicy impl implementation.";
+
+ revision "2015-11-06" {
+ description
+ "Initial revision.";
+ }
+
+ identity groupbasedpolicy-impl {
+ base "config:module-type";
+
+ config:java-name-prefix Groupbasedpolicy;
+ }
+
+ // Augments the 'configuration' choice node under modules/module.
+ augment "/config:modules/config:module/config:configuration" {
+ case groupbasedpolicy-impl {
+ when "/config:modules/config:module/config:type = 'groupbasedpolicy-impl'";
+
+ //wires in the data-broker service
+ container data-broker {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-async-data-broker;
+ }
+ }
+ }
+ }
+ }
+}
"A user-visible name for the classifier definition";
type gbp-common:classifier-name;
}
-
- leaf parent {
- description
- "Parent classifier definition from which we inherit";
- type leafref {
- path "/subject-feature-definitions/classifier-definition/id";
- }
- }
}
list action-definition {
description "A user-visible name for the action";
type gbp-common:action-name;
}
-
- leaf parent {
- description
- "Parent action definition from which we inherit";
- type leafref {
- path "/subject-feature-definitions/action-definition/id";
- }
- }
}
}
}
list gateways {
description
- "External gateways for subnets we serve,
+ "External gateways for subnets we serve,
includes prefixes for static routing";
key "gateway";
leaf gateway {
type inet:ip-prefix;
}
}
-
+
}
}
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.EtherTypeClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.IpProtoClassifier;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.L4Classifier;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
// ###################### DHCP
private static ClassifierInstance createDhcpIpv4ClientServer() {
return new ClassifierInstanceBuilder().setName(DHCP_IPV4_CLIENT_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.UDP_VALUE,
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.UDP_VALUE,
DHCP_IPV4_CLIENT_PORT, DHCP_IPV4_SERVER_PORT))
.build();
}
private static ClassifierInstance createDhcpIpv4ServerClient() {
return new ClassifierInstanceBuilder().setName(DHCP_IPV4_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.UDP_VALUE,
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.UDP_VALUE,
DHCP_IPV4_SERVER_PORT, DHCP_IPV4_CLIENT_PORT))
.build();
}
private static ClassifierInstance createDhcpIpv6ClientServer() {
return new ClassifierInstanceBuilder().setName(DHCP_IPV6_CLIENT_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.UDP_VALUE,
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.UDP_VALUE,
DHCP_IPV6_CLIENT_PORT, DHCP_IPV6_SERVER_PORT))
.build();
}
private static ClassifierInstance createDhcpIpv6ServerClient() {
return new ClassifierInstanceBuilder().setName(DHCP_IPV6_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.UDP_VALUE,
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.UDP_VALUE,
DHCP_IPV6_SERVER_PORT, DHCP_IPV6_CLIENT_PORT))
.build();
}
// ###################### DNS UDP
private static ClassifierInstance createDnsUdpIpv4ClientServer() {
return new ClassifierInstanceBuilder().setName(DNS_UDP_IPV4_CLIENT_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.UDP_VALUE, null, DNS_SERVER_PORT))
+ createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.UDP_VALUE, null, DNS_SERVER_PORT))
.build();
}
private static ClassifierInstance createDnsUdpIpv4ServerClient() {
return new ClassifierInstanceBuilder().setName(DNS_UDP_IPV4_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.UDP_VALUE, DNS_SERVER_PORT, null))
+ createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.UDP_VALUE, DNS_SERVER_PORT, null))
.build();
}
private static ClassifierInstance createDnsUdpIpv6ClientServer() {
return new ClassifierInstanceBuilder().setName(DNS_UDP_IPV6_CLIENT_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.UDP_VALUE, null, DNS_SERVER_PORT))
+ createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.UDP_VALUE, null, DNS_SERVER_PORT))
.build();
}
private static ClassifierInstance createDnsUdpIpv6ServerClient() {
return new ClassifierInstanceBuilder().setName(DNS_UDP_IPV6_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.UDP_VALUE, DNS_SERVER_PORT, null))
+ createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.UDP_VALUE, DNS_SERVER_PORT, null))
.build();
}
// ###################### DNS TCP
private static ClassifierInstance createDnsTcpIpv4ClientServer() {
return new ClassifierInstanceBuilder().setName(DNS_TCP_IPV4_CLIENT_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.TCP_VALUE, null, DNS_SERVER_PORT))
+ createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.TCP_VALUE, null, DNS_SERVER_PORT))
.build();
}
private static ClassifierInstance createDnsTcpIpv4ServerClient() {
return new ClassifierInstanceBuilder().setName(DNS_TCP_IPV4_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.TCP_VALUE, DNS_SERVER_PORT, null))
+ createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.TCP_VALUE, DNS_SERVER_PORT, null))
.build();
}
private static ClassifierInstance createDnsTcpIpv6ClientServer() {
return new ClassifierInstanceBuilder().setName(DNS_TCP_IPV6_CLIENT_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.TCP_VALUE, null, DNS_SERVER_PORT))
+ createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.TCP_VALUE, null, DNS_SERVER_PORT))
.build();
}
private static ClassifierInstance createDnsTcpIpv6ServerClient() {
return new ClassifierInstanceBuilder().setName(DNS_TCP_IPV6_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.TCP_VALUE, DNS_SERVER_PORT, null))
+ createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.TCP_VALUE, DNS_SERVER_PORT, null))
.build();
}
// ###################### SSH TCP
private static ClassifierInstance createSshTcpIpv4ClientServer() {
return new ClassifierInstanceBuilder().setName(SSH_IPV4_CLIENT_TO_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.TCP_VALUE, SSH_TCP_PORT, null))
+ createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.TCP_VALUE, SSH_TCP_PORT, null))
.build();
}
private static ClassifierInstance createSshTcpIpv4ServerClient() {
return new ClassifierInstanceBuilder().setName(SSH_IPV4_SERVER_TO_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.TCP_VALUE, null, SSH_TCP_PORT))
+ createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.TCP_VALUE, null, SSH_TCP_PORT))
.build();
}
private static ClassifierInstance createSshTcpIpv6ClientServer() {
return new ClassifierInstanceBuilder().setName(SSH_IPV6_CLIENT_TO_SERVER_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.TCP_VALUE, SSH_TCP_PORT, null))
+ createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.TCP_VALUE, SSH_TCP_PORT, null))
.build();
}
private static ClassifierInstance createSshTcpIpv6ServerClient() {
return new ClassifierInstanceBuilder().setName(SSH_IPV6_SERVER_TO_CLIENT_NAME)
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())
.setParameterValue(
- createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.TCP_VALUE, null, SSH_TCP_PORT))
+ createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.TCP_VALUE, null, SSH_TCP_PORT))
.build();
}
// ###################### ICMP
private static ClassifierInstance createIcmpIpv4() {
return new ClassifierInstanceBuilder().setName(ICMP_IPV4_BETWEEN_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(IpProtoClassifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv4_VALUE, IpProtoClassifier.ICMP_VALUE, null, null))
+ .setClassifierDefinitionId(IpProtoClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv4_VALUE, IpProtoClassifierDefinition.ICMP_VALUE, null, null))
.build();
}
private static ClassifierInstance createIcmpIpv6() {
return new ClassifierInstanceBuilder().setName(ICMP_IPV6_BETWEEN_SERVER_CLIENT_NAME)
- .setClassifierDefinitionId(IpProtoClassifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv6_VALUE, IpProtoClassifier.ICMP_VALUE, null, null))
+ .setClassifierDefinitionId(IpProtoClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv6_VALUE, IpProtoClassifierDefinition.ICMP_VALUE, null, null))
.build();
}
@Nullable Long dstPort) {
List<ParameterValue> params = new ArrayList<>();
if (srcPort != null) {
- params.add(new ParameterValueBuilder().setName(new ParameterName(L4Classifier.SRC_PORT_PARAM))
+ params.add(new ParameterValueBuilder().setName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM))
.setIntValue(srcPort)
.build());
}
if (dstPort != null) {
- params.add(new ParameterValueBuilder().setName(new ParameterName(L4Classifier.DST_PORT_PARAM))
+ params.add(new ParameterValueBuilder().setName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM))
.setIntValue(dstPort)
.build());
}
- params.add(new ParameterValueBuilder().setName(new ParameterName(IpProtoClassifier.PROTO_PARAM))
+ params.add(new ParameterValueBuilder().setName(new ParameterName(IpProtoClassifierDefinition.PROTO_PARAM))
.setIntValue(proto)
.build());
- params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifier.ETHERTYPE_PARAM))
+ params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM))
.setIntValue(etherType)
.build());
return params;
}
-
}
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.EtherTypeClassifier;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
private static ClassifierInstance createIpv4() {
return new ClassifierInstanceBuilder().setName(IPV4_NAME)
- .setClassifierDefinitionId(EtherTypeClassifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv4_VALUE))
+ .setClassifierDefinitionId(EtherTypeClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv4_VALUE))
.build();
}
private static ClassifierInstance createIpv6() {
return new ClassifierInstanceBuilder().setName(IPV6_NAME)
- .setClassifierDefinitionId(EtherTypeClassifier.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifier.IPv6_VALUE))
+ .setClassifierDefinitionId(EtherTypeClassifierDefinition.DEFINITION.getId())
+ .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv6_VALUE))
.build();
}
private static List<ParameterValue> createParams(long etherType) {
List<ParameterValue> params = new ArrayList<>();
- params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifier.ETHERTYPE_PARAM))
+ params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM))
.setIntValue(etherType)
.build());
return params;
}
-
}
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronUtils;\r
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.EtherTypeClassifier;\r
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.IpProtoClassifier;\r
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.L4Classifier;\r
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;\r
import org.opendaylight.neutron.spi.NeutronSecurityRule;\r
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
Integer portMin = secRule.getSecurityRulePortMin();\r
Integer portMax = secRule.getSecurityRulePortMax();\r
if (portMin != null && portMax != null) {\r
- classifierBuilder.setClassifierDefinitionId(L4Classifier.DEFINITION.getId());\r
+ classifierBuilder.setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId());\r
if (portMin.equals(portMax)) {\r
- params.add(new ParameterValueBuilder().setName(new ParameterName(L4Classifier.DST_PORT_PARAM))\r
+ params.add(new ParameterValueBuilder().setName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM))\r
.setIntValue(portMin.longValue())\r
.build());\r
} else {\r
- params.add(new ParameterValueBuilder().setName(new ParameterName(L4Classifier.DST_PORT_RANGE_PARAM))\r
+ params.add(new ParameterValueBuilder().setName(new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
.setRangeValue(\r
new RangeValueBuilder().setMin(portMin.longValue()).setMax(portMax.longValue()).build())\r
.build());\r
Long protocol = getProtocol(secRule);\r
if (protocol != null) {\r
if (classifierBuilder.getClassifierDefinitionId() == null) {\r
- classifierBuilder.setClassifierDefinitionId(IpProtoClassifier.DEFINITION.getId());\r
+ classifierBuilder.setClassifierDefinitionId(IpProtoClassifierDefinition.DEFINITION.getId());\r
}\r
- params.add(new ParameterValueBuilder().setName(new ParameterName(IpProtoClassifier.PROTO_PARAM))\r
+ params.add(new ParameterValueBuilder().setName(new ParameterName(IpProtoClassifierDefinition.PROTO_PARAM))\r
.setIntValue(protocol)\r
.build());\r
}\r
Long ethertype = getEtherType(secRule);\r
if (ethertype != null) {\r
if (classifierBuilder.getClassifierDefinitionId() == null) {\r
- classifierBuilder.setClassifierDefinitionId(EtherTypeClassifier.DEFINITION.getId());\r
+ classifierBuilder.setClassifierDefinitionId(EtherTypeClassifierDefinition.DEFINITION.getId());\r
}\r
- params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifier.ETHERTYPE_PARAM))\r
+ params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM))\r
.setIntValue(ethertype)\r
.build());\r
}\r
/**\r
* @param secRule\r
* @return {@code null} if {@link NeutronSecurityRule#getSecurityRuleEthertype()} is null or\r
- * empty; value of {@link EtherTypeClassifier#IPv4_VALUE} or\r
- * {@link EtherTypeClassifier#IPv6_VALUE}\r
+ * empty; value of {@link EtherTypeClassifierDefinition#IPv4_VALUE} or\r
+ * {@link EtherTypeClassifierDefinition#IPv6_VALUE}\r
* @throws IllegalArgumentException if return value of\r
* {@link NeutronSecurityRule#getSecurityRuleEthertype()} is not empty/null and is other\r
* than "IPv4" or "IPv6"\r
return null;\r
}\r
if (NeutronUtils.IPv4.equals(ethertype)) {\r
- return EtherTypeClassifier.IPv4_VALUE;\r
+ return EtherTypeClassifierDefinition.IPv4_VALUE;\r
}\r
if (NeutronUtils.IPv6.equals(ethertype)) {\r
- return EtherTypeClassifier.IPv6_VALUE;\r
+ return EtherTypeClassifierDefinition.IPv6_VALUE;\r
}\r
throw new IllegalArgumentException("Ethertype " + ethertype + " is not supported.");\r
}\r
return null;\r
}\r
if (NeutronUtils.TCP.equals(protocol)) {\r
- return IpProtoClassifier.TCP_VALUE;\r
+ return IpProtoClassifierDefinition.TCP_VALUE;\r
}\r
if (NeutronUtils.UDP.equals(protocol)) {\r
- return IpProtoClassifier.UDP_VALUE;\r
+ return IpProtoClassifierDefinition.UDP_VALUE;\r
}\r
if (NeutronUtils.ICMP.equals(protocol)) {\r
- return IpProtoClassifier.ICMP_VALUE;\r
+ return IpProtoClassifierDefinition.ICMP_VALUE;\r
}\r
throw new IllegalArgumentException("Protocol " + protocol + " is not supported.");\r
}\r
-\r
}\r
package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.EtherTypeClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.IpProtoClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.L4Classifier;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClauseName;
Integer portMin = secRule.getSecurityRulePortMin();
Integer portMax = secRule.getSecurityRulePortMax();
if (portMin != null && portMax != null) {
- keyBuilder.append(L4Classifier.DEFINITION.getName().getValue());
+ keyBuilder.append(L4ClassifierDefinition.DEFINITION.getName().getValue());
if (portMin.equals(portMax)) {
keyBuilder.append(MappingUtils.NAME_DELIMETER)
- .append(L4Classifier.DST_PORT_PARAM)
+ .append(L4ClassifierDefinition.DST_PORT_PARAM)
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(portMin.longValue());
} else {
keyBuilder.append(MappingUtils.NAME_DELIMETER)
- .append(L4Classifier.DST_PORT_RANGE_PARAM)
+ .append(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)
.append(MIN_PORT)
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(portMin.longValue())
if (keyBuilder.length() > 0) {
keyBuilder.append(MappingUtils.NAME_DOUBLE_DELIMETER);
}
- keyBuilder.append(IpProtoClassifier.DEFINITION.getName().getValue())
+ keyBuilder.append(IpProtoClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(protocol);
}
if (keyBuilder.length() > 0) {
keyBuilder.append(MappingUtils.NAME_DOUBLE_DELIMETER);
}
- keyBuilder.append(EtherTypeClassifier.DEFINITION.getName().getValue())
+ keyBuilder.append(EtherTypeClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(ethertype);
}
import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronPortAware;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.AllowAction;
+import org.opendaylight.groupbasedpolicy.sf.actions.AllowActionDefinition;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.neutron.spi.Neutron_IPs;
public static final String NEUTRON_GROUP = "neutron_group-";
public static final ActionInstance ACTION_ALLOW = new ActionInstanceBuilder().setName(
new ActionName("Allow"))
- .setActionDefinitionId(AllowAction.DEFINITION.getId())
+ .setActionDefinitionId(AllowActionDefinition.DEFINITION.getId())
.build();
public static final List<ActionRef> ACTION_REF_ALLOW =
ImmutableList.of(new ActionRefBuilder().setName(ACTION_ALLOW.getName()).setOrder(0).build());
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.SecRuleEntityDecoder;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.SecRuleNameDecoder;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronUtils;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.EtherTypeClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.IpProtoClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.L4Classifier;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
public final void testGetClassifierInstance_onlyEthertype() {
secRule.setSecurityRuleEthertype(NeutronUtils.IPv4);
ClassifierInstance ci = SecRuleEntityDecoder.getClassifierInstance(secRule);
- Assert.assertEquals(EtherTypeClassifier.DEFINITION.getId(), ci.getClassifierDefinitionId());
+ Assert.assertEquals(EtherTypeClassifierDefinition.DEFINITION.getId(), ci.getClassifierDefinitionId());
// name is ether_type_IPv4
- String expectedName = new StringBuilder().append(EtherTypeClassifier.DEFINITION.getName().getValue())
+ String expectedName = new StringBuilder().append(EtherTypeClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.IPv4)
.toString();
Assert.assertNotNull(parameterValues);
Assert.assertEquals(1, parameterValues.size());
ParameterValue parameter = parameterValues.get(0);
- Assert.assertEquals(EtherTypeClassifier.ETHERTYPE_PARAM, parameter.getName().getValue());
- assertClassifierParameterValue(parameter, EtherTypeClassifier.IPv4_VALUE, null, null);
+ Assert.assertEquals(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, parameter.getName().getValue());
+ assertClassifierParameterValue(parameter, EtherTypeClassifierDefinition.IPv4_VALUE, null, null);
}
@Test
secRule.setSecurityRuleEthertype(NeutronUtils.IPv4);
secRule.setSecurityRuleProtocol(NeutronUtils.TCP);
ClassifierInstance ci = SecRuleEntityDecoder.getClassifierInstance(secRule);
- Assert.assertEquals(IpProtoClassifier.DEFINITION.getId(), ci.getClassifierDefinitionId());
+ Assert.assertEquals(IpProtoClassifierDefinition.DEFINITION.getId(), ci.getClassifierDefinitionId());
// name is ip_proto_tcp__ether_type_IPv4
- String expectedName = new StringBuilder().append(IpProtoClassifier.DEFINITION.getName().getValue())
+ String expectedName = new StringBuilder().append(IpProtoClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.TCP)
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(EtherTypeClassifier.DEFINITION.getName().getValue())
+ .append(EtherTypeClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.IPv4)
.toString();
for (ParameterValue parameter : parameterValues) {
ParameterName parameterName = parameter.getName();
Assert.assertNotNull(parameterName);
- if (EtherTypeClassifier.ETHERTYPE_PARAM.equals(parameterName.getValue())) {
+ if (EtherTypeClassifierDefinition.ETHERTYPE_PARAM.equals(parameterName.getValue())) {
containsEthertypeParam = true;
- assertClassifierParameterValue(parameter, EtherTypeClassifier.IPv4_VALUE, null, null);
- } else if (IpProtoClassifier.PROTO_PARAM.equals(parameterName.getValue())) {
+ assertClassifierParameterValue(parameter, EtherTypeClassifierDefinition.IPv4_VALUE, null, null);
+ } else if (IpProtoClassifierDefinition.PROTO_PARAM.equals(parameterName.getValue())) {
containsProtoParam = true;
- assertClassifierParameterValue(parameter, IpProtoClassifier.TCP_VALUE, null, null);
+ assertClassifierParameterValue(parameter, IpProtoClassifierDefinition.TCP_VALUE, null, null);
} else {
fail("This parameter is not expected: " + parameter);
}
secRule.setSecurityRulePortMin(5);
secRule.setSecurityRulePortMax(5);
ClassifierInstance ci = SecRuleEntityDecoder.getClassifierInstance(secRule);
- Assert.assertEquals(L4Classifier.DEFINITION.getId(), ci.getClassifierDefinitionId());
+ Assert.assertEquals(L4ClassifierDefinition.DEFINITION.getId(), ci.getClassifierDefinitionId());
// name is l4_destport-5__ip_proto-tcp__ether_type-IPv4
- String expectedName = new StringBuilder().append(L4Classifier.DEFINITION.getName().getValue())
+ String expectedName = new StringBuilder().append(L4ClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_DELIMETER)
- .append(L4Classifier.DST_PORT_PARAM)
+ .append(L4ClassifierDefinition.DST_PORT_PARAM)
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(secRule.getSecurityRulePortMin())
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(IpProtoClassifier.DEFINITION.getName().getValue())
+ .append(IpProtoClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.TCP)
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(EtherTypeClassifier.DEFINITION.getName().getValue())
+ .append(EtherTypeClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.IPv4)
.toString();
for (ParameterValue parameter : parameterValues) {
ParameterName parameterName = parameter.getName();
Assert.assertNotNull(parameterName);
- if (EtherTypeClassifier.ETHERTYPE_PARAM.equals(parameterName.getValue())) {
+ if (EtherTypeClassifierDefinition.ETHERTYPE_PARAM.equals(parameterName.getValue())) {
containsEthertypeParam = true;
- assertClassifierParameterValue(parameter, EtherTypeClassifier.IPv4_VALUE, null, null);
- } else if (IpProtoClassifier.PROTO_PARAM.equals(parameterName.getValue())) {
+ assertClassifierParameterValue(parameter, EtherTypeClassifierDefinition.IPv4_VALUE, null, null);
+ } else if (IpProtoClassifierDefinition.PROTO_PARAM.equals(parameterName.getValue())) {
containsProtoParam = true;
- assertClassifierParameterValue(parameter, IpProtoClassifier.TCP_VALUE, null, null);
- } else if (L4Classifier.DST_PORT_PARAM.equals(parameterName.getValue())) {
+ assertClassifierParameterValue(parameter, IpProtoClassifierDefinition.TCP_VALUE, null, null);
+ } else if (L4ClassifierDefinition.DST_PORT_PARAM.equals(parameterName.getValue())) {
containsDstPortParam = true;
assertClassifierParameterValue(parameter, 5L, null, null);
} else {
secRule.setSecurityRulePortMin(5);
secRule.setSecurityRulePortMax(10);
ClassifierInstance ci = SecRuleEntityDecoder.getClassifierInstance(secRule);
- Assert.assertEquals(L4Classifier.DEFINITION.getId(), ci.getClassifierDefinitionId());
+ Assert.assertEquals(L4ClassifierDefinition.DEFINITION.getId(), ci.getClassifierDefinitionId());
// name is l4_destport_range_min-5_max-10__ip_proto-tcp__ether_type-IPv4
- String expectedName = new StringBuilder().append(L4Classifier.DEFINITION.getName().getValue())
+ String expectedName = new StringBuilder().append(L4ClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_DELIMETER)
- .append(L4Classifier.DST_PORT_RANGE_PARAM)
+ .append(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)
.append(SecRuleNameDecoder.MIN_PORT)
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(secRule.getSecurityRulePortMin())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(secRule.getSecurityRulePortMax())
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(IpProtoClassifier.DEFINITION.getName().getValue())
+ .append(IpProtoClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.TCP)
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(EtherTypeClassifier.DEFINITION.getName().getValue())
+ .append(EtherTypeClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append(NeutronUtils.IPv4)
.toString();
@Test
public final void testGetEtherType_ethertypeIPv4() {
secRule.setSecurityRuleEthertype("IPv4");
- Assert.assertEquals(EtherTypeClassifier.IPv4_VALUE, SecRuleEntityDecoder.getEtherType(secRule));
+ Assert.assertEquals(EtherTypeClassifierDefinition.IPv4_VALUE, SecRuleEntityDecoder.getEtherType(secRule));
}
@Test
public final void testGetEtherType_ethertypeIPv6() {
secRule.setSecurityRuleEthertype("IPv6");
- Assert.assertEquals(EtherTypeClassifier.IPv6_VALUE, SecRuleEntityDecoder.getEtherType(secRule));
+ Assert.assertEquals(EtherTypeClassifierDefinition.IPv6_VALUE, SecRuleEntityDecoder.getEtherType(secRule));
}
@Test
@Test
public final void testGetProtocol_protoTcp() {
secRule.setSecurityRuleProtocol("tcp");
- Assert.assertEquals(IpProtoClassifier.TCP_VALUE, SecRuleEntityDecoder.getProtocol(secRule));
+ Assert.assertEquals(IpProtoClassifierDefinition.TCP_VALUE, SecRuleEntityDecoder.getProtocol(secRule));
}
@Test
public final void testGetProtocol_protoUdp() {
secRule.setSecurityRuleProtocol("udp");
- Assert.assertEquals(IpProtoClassifier.UDP_VALUE, SecRuleEntityDecoder.getProtocol(secRule));
+ Assert.assertEquals(IpProtoClassifierDefinition.UDP_VALUE, SecRuleEntityDecoder.getProtocol(secRule));
}
@Test
public final void testGetProtocol_protoIcmp() {
secRule.setSecurityRuleProtocol("icmp");
- Assert.assertEquals(IpProtoClassifier.ICMP_VALUE, SecRuleEntityDecoder.getProtocol(secRule));
+ Assert.assertEquals(IpProtoClassifierDefinition.ICMP_VALUE, SecRuleEntityDecoder.getProtocol(secRule));
}
@Test
import org.junit.Before;
import org.junit.Test;
-
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronUtils;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.EtherTypeClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.IpProtoClassifier;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.L4Classifier;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClauseName;
secRule.setSecurityRulePortMin(8010);
secRule.setSecurityRulePortMax(8020);
StringBuilder frmtBuilder = new StringBuilder();
- frmtBuilder.append(L4Classifier.DEFINITION.getName().getValue())
+ frmtBuilder.append(L4ClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_DELIMETER)
- .append(L4Classifier.DST_PORT_RANGE_PARAM)
+ .append(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)
.append(SecRuleNameDecoder.MIN_PORT)
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append("%d")
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append("%d")
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(IpProtoClassifier.DEFINITION.getName().getValue())
+ .append(IpProtoClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append("%s")
.append(MappingUtils.NAME_DOUBLE_DELIMETER)
- .append(EtherTypeClassifier.DEFINITION.getName().getValue())
+ .append(EtherTypeClassifierDefinition.DEFINITION.getName().getValue())
.append(MappingUtils.NAME_VALUE_DELIMETER)
.append("%s");
String frmtClsfName = String.format(frmtBuilder.toString(), 8010, 8020, secRule.getSecurityRuleProtocol(),
+ "Max. table ID would be out of range. Check config-subsystem.\n{}", e);
}
- if (dataBroker != null) {
- WriteTransaction t = dataBroker.newWriteOnlyTransaction();
- t.put(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier
- .builder(SubjectFeatureDefinitions.class)
- .build(),
- SubjectFeatures.OF_OVERLAY_FEATURES);
- t.submit();
- }
+ // TODO this will be writing to capabilities in DS
+// if (dataBroker != null) {
+// WriteTransaction t = dataBroker.newWriteOnlyTransaction();
+// t.put(LogicalDatastoreType.OPERATIONAL,
+// InstanceIdentifier
+// .builder(SubjectFeatureDefinitions.class)
+// .build(),
+// SubjectFeatures.OF_OVERLAY_FEATURES);
+// t.submit();
+// }
for(Entry<ActionDefinitionId, Action> entry : SubjectFeatures.getActions().entrySet()) {
policyResolver.registerActionDefinitions(entry.getKey(), entry.getValue());
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ChainAction;
import org.opendaylight.groupbasedpolicy.resolver.PolicyResolver;
+import org.opendaylight.groupbasedpolicy.sf.actions.ChainActionDefinition;
import org.opendaylight.sfc.provider.SfcProviderRpc;
import org.opendaylight.sfc.provider.api.SfcProviderServiceChainAPI;
import org.opendaylight.sfc.provider.api.SfcProviderServicePathAPI;
if (!dao.isPresent()) return;
ActionDefinition ad = dao.get();
- if (ad.getId().getValue().equals(ChainAction.ID.getValue())) {
+ if (ad.getId().getValue().equals(ChainActionDefinition.ID.getValue())) {
/*
* We have the state we need:
* 1) it's a "CHAIN" action
import javax.annotation.concurrent.Immutable;
+import org.opendaylight.groupbasedpolicy.sf.actions.AllowActionDefinition;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils.RegMatch;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.OrdinalFactory.EndpointFwdCtxOrdinals;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.Action;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.AllowAction;
+//import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.AllowAction;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ClassificationResult;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.Classifier;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ParamDerivator;
public PolicyEnforcer(OfContext ctx, short tableId) {
super(ctx);
- this.TABLE_ID = tableId;
- this.gotoEgressNatInstruction = gotoTableIns(ctx.getPolicyManager().getTABLEID_EGRESS_NAT());
- this.gotoExternalInstruction = gotoTableIns(ctx.getPolicyManager().getTABLEID_EXTERNAL_MAPPER());
+ PolicyEnforcer.TABLE_ID = tableId;
+ PolicyEnforcer.gotoEgressNatInstruction = gotoTableIns(ctx.getPolicyManager().getTABLEID_EGRESS_NAT());
+ PolicyEnforcer.gotoExternalInstruction = gotoTableIns(ctx.getPolicyManager().getTABLEID_EXTERNAL_MAPPER());
}
@Override
/*
* Convert the GBP Action to one or more OpenFlow Actions
*/
- if (!(actionRefList.indexOf(actionRule) == (actionRefList.size() - 1) && action.equals(SubjectFeatures.getAction(AllowAction.DEFINITION.getId())))) {
+ if (!(actionRefList.indexOf(actionRule) == (actionRefList.size() - 1) && action.equals(SubjectFeatures.getAction(AllowActionDefinition.DEFINITION.getId())))) {
actionBuilderList = action.updateAction(actionBuilderList, params, actionRule.getOrder(), netElements, policyPair,
ofWriter, ctx, direction);
}
import java.util.List;
import java.util.Map;
+import org.opendaylight.groupbasedpolicy.sf.actions.AllowActionDefinition;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.PolicyEnforcer.NetworkElements;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.PolicyEnforcer.PolicyPair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.subject.feature.instances.ActionInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxReg7;
-
/**
* Allow action
*/
public class AllowAction extends Action {
- protected static final ActionDefinitionId ID = new ActionDefinitionId("f942e8fd-e957-42b7-bd18-f73d11266d17");
- /**
- * Access control - allow action-definition
- */
- public static final ActionDefinition DEFINITION = new ActionDefinitionBuilder().setId(ID)
- .setName(new ActionName("allow"))
- .setDescription(new Description("Allow the specified traffic to pass"))
- .build();
-
// How allow is implemented in the PolicyEnforcer table
private final org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action allow = nxOutputRegAction(NxmNxReg7.class);
@Override
public ActionDefinitionId getId() {
- return ID;
+ return AllowActionDefinition.ID;
}
@Override
public ActionDefinition getActionDef() {
- return DEFINITION;
+ return AllowActionDefinition.DEFINITION;
}
@Override
public boolean isValid(ActionInstance actionInstance) {
return true;
}
-
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;
-/*
- * 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
- */
-
import static org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.ChainActionFlows.createChainTunnelFlows;
import static org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils.nxSetNsiAction;
import static org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils.nxSetNspAction;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.sf.actions.ChainActionDefinition;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.PolicyEnforcer.NetworkElements;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.IsRequired;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;
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.tenants.tenant.subject.feature.instances.ActionInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
/**
private static final Logger LOG = LoggerFactory.getLogger(ChainAction.class);
- public static final ActionDefinitionId ID = new ActionDefinitionId("3d886be7-059f-4c4f-bbef-0356bea40933");
-
- public static final Integer CHAIN_CONDITION_GROUP = 0xfffffe;
-
- protected static final String TYPE = "type";
-
- // the chain action
- public static final String SFC_CHAIN_ACTION = "chain";
- // the parameter used for storing the chain name
- public static final String SFC_CHAIN_NAME = "sfc-chain-name";
-
- protected static final ActionDefinition DEF = new ActionDefinitionBuilder().setId(ID)
- .setName(new ActionName(SFC_CHAIN_ACTION))
- .setDescription(new Description("Send the traffic through a Service Function Chain"))
- .setParameter(
- (ImmutableList.of(new ParameterBuilder().setName(new ParameterName(SFC_CHAIN_NAME))
- .setDescription(new Description("The named chain to match against"))
- .setIsRequired(IsRequired.Required)
- .setType(Type.String)
- .build())))
- .build();
-
@Override
public ActionDefinitionId getId() {
- return ID;
+ return ChainActionDefinition.ID;
}
@Override
public ActionDefinition getActionDef() {
- return DEF;
+ return ChainActionDefinition.DEFINITION;
}
@Override
LOG.debug("updateAction: Searching for named chain");
for (String name : params.keySet()) {
if (name instanceof String) {
- if (name.equals(SFC_CHAIN_NAME)) {
+ if (name.equals(ChainActionDefinition.SFC_CHAIN_NAME)) {
chainName = (String) params.get(name);
if (chainName == null) {
LOG.error("updateAction: Chain name was null");
if (paramValueList == null)
return null;
for (ParameterValue pv : paramValueList) {
- if (pv.getName().getValue().equals(SFC_CHAIN_NAME)) {
+ if (pv.getName().getValue().equals(ChainActionDefinition.SFC_CHAIN_NAME)) {
return pv;
}
}
import java.util.List;
import java.util.Map;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
-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.definition.Parameter.IsRequired;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
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.definitions.ClassifierDefinitionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
-import com.google.common.collect.ImmutableList;
-
/**
* Match on the ether type of the traffic
*/
public class EtherTypeClassifier extends Classifier {
- /**
- * Ethertype parameter name
- */
- public static final String ETHERTYPE_PARAM = "ethertype";
- /**
- * ARP ethertype value
- */
- public static final Long ARP_VALUE = Long.valueOf(0x0806);
- /**
- * IPv4 ethertype value
- */
- public static final Long IPv4_VALUE = Long.valueOf(0x0800);
- /**
- * IPv6 ethertype value
- */
- public static final Long IPv6_VALUE = Long.valueOf(0x86DD);
-
- protected static final ClassifierDefinitionId ID = new ClassifierDefinitionId(
- "6a48ab45-a462-429d-b18c-3a575b2c8bef");
- /**
- * Ethertype classifier-definition
- */
- public static final ClassifierDefinition DEFINITION = new ClassifierDefinitionBuilder().setId(ID)
- .setName(new ClassifierName("ether_type"))
- .setDescription(new Description("Match on the ether type of the traffic"))
- .setParameter(
- ImmutableList.of(new ParameterBuilder().setName(new ParameterName(ETHERTYPE_PARAM))
- .setDescription(new Description("The ethertype to match against"))
- .setIsRequired(IsRequired.Required)
- .setType(Type.Int)
- .build()))
- .build();
-
protected EtherTypeClassifier(Classifier parent) {
super(parent);
}
@Override
public ClassifierDefinitionId getId() {
- return ID;
+ return EtherTypeClassifierDefinition.ID;
}
@Override
public ClassifierDefinition getClassDef() {
- return DEFINITION;
+ return EtherTypeClassifierDefinition.DEFINITION;
}
@Override
protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
- if (params.get(ETHERTYPE_PARAM) == null) {
- throw new IllegalArgumentException("Parameter " + ETHERTYPE_PARAM + " not specified.");
+ if (params.get(EtherTypeClassifierDefinition.ETHERTYPE_PARAM) == null) {
+ throw new IllegalArgumentException("Parameter " + EtherTypeClassifierDefinition.ETHERTYPE_PARAM
+ + " not specified.");
}
- if (params.get(ETHERTYPE_PARAM).getIntValue() == null) {
- throw new IllegalArgumentException("Value of " + ETHERTYPE_PARAM + " parameter is not present.");
+ if (params.get(EtherTypeClassifierDefinition.ETHERTYPE_PARAM).getIntValue() == null) {
+ throw new IllegalArgumentException("Value of " + EtherTypeClassifierDefinition.ETHERTYPE_PARAM
+ + " parameter is not present.");
}
}
@Override
protected List<MatchBuilder> update(List<MatchBuilder> matches, Map<String, ParameterValue> params) {
- Long type = params.get(ETHERTYPE_PARAM).getIntValue();
+ Long type = params.get(EtherTypeClassifierDefinition.ETHERTYPE_PARAM).getIntValue();
for (MatchBuilder match : matches) {
EthernetMatchBuilder em;
if (match.getEthernetMatch() != null) {
private void equalOrNotSetValidation(EthernetType ethTypeInMatch, long paramValue) {
if (ethTypeInMatch != null) {
if (paramValue != ethTypeInMatch.getType().getValue().longValue()) {
- throw new IllegalArgumentException("Classification conflict detected at " + ETHERTYPE_PARAM
- + " parameter for values " + ethTypeInMatch.getType().getValue() + " and " + paramValue
- + ". It is not allowed "
+ throw new IllegalArgumentException("Classification conflict detected at "
+ + EtherTypeClassifierDefinition.ETHERTYPE_PARAM + " parameter for values "
+ + ethTypeInMatch.getType().getValue() + " and " + paramValue + ". It is not allowed "
+ "to assign different values to the same parameter among all the classifiers within one rule.");
}
}
import java.util.List;
import java.util.Map;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
-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.definition.Parameter.IsRequired;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter.Type;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
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.definitions.ClassifierDefinitionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatchBuilder;
-import com.google.common.collect.ImmutableList;
-
/**
* Match on the IP protocol of IP traffic
*/
public class IpProtoClassifier extends Classifier {
- /**
- * Protocol parameter name
- */
- public static final String PROTO_PARAM = "proto";
- /**
- * TCP protocol value
- */
- public static final Long TCP_VALUE = Long.valueOf(6);
- /**
- * UDP protocol value
- */
- public static final Long UDP_VALUE = Long.valueOf(17);
- /**
- * ICMP protocol value
- */
- public static final Long ICMP_VALUE = Long.valueOf(1);
- /**
- * SCTP protocol value
- */
- public static final Long SCTP_VALUE = Long.valueOf(132);
-
- protected static final ClassifierDefinitionId ID = new ClassifierDefinitionId(
- "79c6fdb2-1e1a-4832-af57-c65baf5c2335");
- /**
- * Protocol classifier-definition
- */
- public static final ClassifierDefinition DEFINITION = new ClassifierDefinitionBuilder().setId(ID)
- .setParent(EtherTypeClassifier.ID)
- .setName(new ClassifierName("ip_proto"))
- .setDescription(new Description("Match on the IP protocol of IP traffic"))
- .setParameter(
- ImmutableList.of(new ParameterBuilder().setName(new ParameterName(PROTO_PARAM))
- .setDescription(new Description("The IP protocol to match against"))
- .setIsRequired(IsRequired.Required)
- .setType(Type.Int)
- .build()))
- .build();
-
protected IpProtoClassifier(Classifier parent) {
super(parent);
}
@Override
public ClassifierDefinitionId getId() {
- return ID;
+ return IpProtoClassifierDefinition.ID;
}
@Override
public ClassifierDefinition getClassDef() {
- return DEFINITION;
+ return IpProtoClassifierDefinition.DEFINITION;
}
@Override
protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
- if (params.get(PROTO_PARAM) == null) {
- throw new IllegalArgumentException("Parameter " + PROTO_PARAM + " not specified.");
+ if (params.get(IpProtoClassifierDefinition.PROTO_PARAM) == null) {
+ throw new IllegalArgumentException("Parameter " + IpProtoClassifierDefinition.PROTO_PARAM
+ + " not specified.");
}
- if (params.get(PROTO_PARAM).getIntValue() == null) {
- throw new IllegalArgumentException("Value of " + PROTO_PARAM + " parameter is not present.");
+ if (params.get(IpProtoClassifierDefinition.PROTO_PARAM).getIntValue() == null) {
+ throw new IllegalArgumentException("Value of " + IpProtoClassifierDefinition.PROTO_PARAM
+ + " parameter is not present.");
}
}
@Override
protected List<MatchBuilder> update(List<MatchBuilder> matches, Map<String, ParameterValue> params) {
- Long proto = params.get(PROTO_PARAM).getIntValue();
+ Long proto = params.get(IpProtoClassifierDefinition.PROTO_PARAM).getIntValue();
for (MatchBuilder match : matches) {
IpMatchBuilder imb;
if (match.getIpMatch() != null) {
private void equalOrNotSetValidation(Short protoInMatch, long paramValue) {
if (protoInMatch != null) {
if (paramValue != protoInMatch.longValue()) {
- throw new IllegalArgumentException("Classification conflict detected at " + PROTO_PARAM
+ throw new IllegalArgumentException("Classification conflict detected at " + IpProtoClassifierDefinition.PROTO_PARAM
+ " parameter for values " + protoInMatch.shortValue() + " and " + paramValue
+ ". It is not allowed "
+ "to assign different values to the same parameter among all the classifiers within one rule.");
try {
readEthType = match.getEthernetMatch().getEthernetType().getType().getValue();
} catch (NullPointerException e) {
- throw new IllegalArgumentException("Parameter " + EtherTypeClassifier.ETHERTYPE_PARAM + " is missing.");
+ throw new IllegalArgumentException("Parameter " + EtherTypeClassifierDefinition.ETHERTYPE_PARAM
+ + " is missing.");
}
if (!FlowUtils.IPv4.equals(readEthType) && !FlowUtils.IPv6.equals(readEthType)) {
- throw new IllegalArgumentException("Parameter " + EtherTypeClassifier.ETHERTYPE_PARAM + " must have value "
- + FlowUtils.IPv4 + " or " + FlowUtils.IPv6 + ".");
+ throw new IllegalArgumentException("Parameter " + EtherTypeClassifierDefinition.ETHERTYPE_PARAM
+ + " must have value " + FlowUtils.IPv4 + " or " + FlowUtils.IPv6 + ".");
}
}
}
if (params == null) {
return null;
}
- if (params.get(PROTO_PARAM) == null) {
+ if (params.get(IpProtoClassifierDefinition.PROTO_PARAM) == null) {
return null;
}
- Long proto = params.get(PROTO_PARAM).getIntValue();
+ Long proto = params.get(IpProtoClassifierDefinition.PROTO_PARAM).getIntValue();
if (proto != null) {
return proto;
}
import java.util.Map;
import java.util.Set;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
-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.definition.Parameter.Type;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.ParameterBuilder;
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.definitions.ClassifierDefinitionBuilder;
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.parameter.value.RangeValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatchBuilder;
-import com.google.common.collect.ImmutableList;
-
/**
* Match against TCP or UDP, and source and/or destination ports
*/
public class L4Classifier extends Classifier {
- /**
- * Source port parameter name
- */
- public static final String SRC_PORT_PARAM = "sourceport";
- /**
- * Source port range parameter name
- */
- public static final String SRC_PORT_RANGE_PARAM = "sourceport_range";
- /**
- * Destination port parameter name
- */
- public static final String DST_PORT_PARAM = "destport";
- /**
- * Destination port range parameter name
- */
- public static final String DST_PORT_RANGE_PARAM = "destport_range";
-
- protected static final ClassifierDefinitionId ID = new ClassifierDefinitionId(
- "4250ab32-e8b8-445a-aebb-e1bd2cdd291f");
- /**
- * Layer 4 classifier-definition
- */
- public static final ClassifierDefinition DEFINITION = new ClassifierDefinitionBuilder().setId(
- new ClassifierDefinitionId("4250ab32-e8b8-445a-aebb-e1bd2cdd291f"))
- .setParent(IpProtoClassifier.ID)
- .setName(new ClassifierName("l4"))
- .setDescription(new Description("Match on the port number of UDP or TCP traffic"))
- .setParameter(
- ImmutableList.of(
- new ParameterBuilder().setName(new ParameterName(SRC_PORT_PARAM))
- .setDescription(new Description("The source port number to match against"))
- .setType(Type.Int)
- .build(),
- new ParameterBuilder().setName(new ParameterName(SRC_PORT_RANGE_PARAM))
- .setDescription(new Description("The source port range to match against"))
- .setType(Type.Range)
- .build(),
- new ParameterBuilder().setName(new ParameterName(DST_PORT_PARAM))
- .setDescription(new Description("The destination port number to match against"))
- .setType(Type.Int)
- .build(), new ParameterBuilder().setName(new ParameterName(DST_PORT_RANGE_PARAM))
- .setDescription(new Description("The destination port range to match against"))
- .setType(Type.Range)
- .build()))
- .build();
-
protected L4Classifier(Classifier parent) {
super(parent);
}
@Override
public ClassifierDefinitionId getId() {
- return ID;
+ return L4ClassifierDefinition.ID;
}
@Override
public ClassifierDefinition getClassDef() {
- return DEFINITION;
+ return L4ClassifierDefinition.DEFINITION;
}
@Override
protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
- validatePortParam(params, SRC_PORT_PARAM, SRC_PORT_RANGE_PARAM);
- validatePortParam(params, DST_PORT_PARAM, DST_PORT_RANGE_PARAM);
- validateRange(params, SRC_PORT_RANGE_PARAM);
- validateRange(params, DST_PORT_RANGE_PARAM);
+ 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) {
public List<MatchBuilder> update(List<MatchBuilder> matches, Map<String, ParameterValue> params) {
Set<Long> sPorts = new HashSet<>();
Set<Long> dPorts = new HashSet<>();
- addToPortSet(params, SRC_PORT_PARAM, SRC_PORT_RANGE_PARAM, sPorts);
- addToPortSet(params, DST_PORT_PARAM, DST_PORT_RANGE_PARAM, dPorts);
+ addToPortSet(params, L4ClassifierDefinition.SRC_PORT_PARAM, L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, sPorts);
+ addToPortSet(params, L4ClassifierDefinition.DST_PORT_PARAM, L4ClassifierDefinition.DST_PORT_RANGE_PARAM, dPorts);
List<MatchBuilder> newMatches = new ArrayList<>();
for (MatchBuilder matchBuilder : matches) {
Layer4Match l4Match = matchBuilder.getLayer4Match();
private Layer4Match resolveL4Match(Map<String, ParameterValue> params) {
Long ipProto = IpProtoClassifier.getIpProtoValue(params);
if (ipProto == null) {
- throw new IllegalArgumentException("Parameter " + IpProtoClassifier.PROTO_PARAM + " is missing.");
+ throw new IllegalArgumentException("Parameter " + IpProtoClassifierDefinition.PROTO_PARAM + " is missing.");
}
- if (IpProtoClassifier.UDP_VALUE.equals(ipProto)) {
+ if (IpProtoClassifierDefinition.UDP_VALUE.equals(ipProto)) {
return new UdpMatchBuilder().build();
- } else if (IpProtoClassifier.TCP_VALUE.equals(ipProto)) {
+ } else if (IpProtoClassifierDefinition.TCP_VALUE.equals(ipProto)) {
return new TcpMatchBuilder().build();
- } else if (IpProtoClassifier.SCTP_VALUE.equals(ipProto)) {
+ } else if (IpProtoClassifierDefinition.SCTP_VALUE.equals(ipProto)) {
return new SctpMatchBuilder().build();
}
- throw new IllegalArgumentException("Parameter " + IpProtoClassifier.PROTO_PARAM + ": value " + ipProto
+ throw new IllegalArgumentException("Parameter " + IpProtoClassifierDefinition.PROTO_PARAM + ": value " + ipProto
+ " is not supported.");
}
try {
proto = Long.valueOf(match.getIpMatch().getIpProtocol().longValue());
} catch (NullPointerException e) {
- throw new IllegalArgumentException("Parameter " + IpProtoClassifier.PROTO_PARAM + " is missing.");
+ throw new IllegalArgumentException("Parameter " + IpProtoClassifierDefinition.PROTO_PARAM + " is missing.");
}
- if (!IpProtoClassifier.TCP_VALUE.equals(proto) && !IpProtoClassifier.UDP_VALUE.equals(proto)
- && !IpProtoClassifier.SCTP_VALUE.equals(proto)) {
- throw new IllegalArgumentException("Value of parameter " + IpProtoClassifier.PROTO_PARAM
+ if (!IpProtoClassifierDefinition.TCP_VALUE.equals(proto) && !IpProtoClassifierDefinition.UDP_VALUE.equals(proto)
+ && !IpProtoClassifierDefinition.SCTP_VALUE.equals(proto)) {
+ throw new IllegalArgumentException("Value of parameter " + IpProtoClassifierDefinition.PROTO_PARAM
+ " is not supported.");
}
}
/*
* 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
import java.util.Map;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
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;
@Override
public List<Map<String, ParameterValue>> deriveParameter(Map<String, ParameterValue> params) {
- if (!params.containsKey(EtherTypeClassifier.ETHERTYPE_PARAM)) {
+ if (!params.containsKey(EtherTypeClassifierDefinition.ETHERTYPE_PARAM)) {
Map<String, ParameterValue> ipv4Params = new HashMap<>(params);
Map<String, ParameterValue> ipv6Params = new HashMap<>(params);
- ipv4Params.put(EtherTypeClassifier.ETHERTYPE_PARAM, new ParameterValueBuilder().setIntValue(FlowUtils.IPv4)
+ ipv4Params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, new ParameterValueBuilder().setIntValue(FlowUtils.IPv4)
.build());
- ipv6Params.put(EtherTypeClassifier.ETHERTYPE_PARAM, new ParameterValueBuilder().setIntValue(FlowUtils.IPv6)
+ ipv6Params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, new ParameterValueBuilder().setIntValue(FlowUtils.IPv6)
.build());
List<Map<String, ParameterValue>> derivedParams = new ArrayList<>();
derivedParams.add(ipv4Params);
import java.util.List;
import java.util.Map;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.actions.AllowActionDefinition;
+import org.opendaylight.groupbasedpolicy.sf.actions.ChainActionDefinition;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
public class SubjectFeatures {
private static final Map<ClassifierDefinitionId, Classifier> classifiers =
ImmutableMap.<ClassifierDefinitionId, Classifier>
- of(EtherTypeClassifier.ID, Classifier.ETHER_TYPE_CL,
- IpProtoClassifier.ID, Classifier.IP_PROTO_CL,
- L4Classifier.ID, Classifier.L4_CL);
+ of(EtherTypeClassifierDefinition.ID, Classifier.ETHER_TYPE_CL,
+ IpProtoClassifierDefinition.ID, Classifier.IP_PROTO_CL,
+ L4ClassifierDefinition.ID, Classifier.L4_CL);
private static final List<ClassifierDefinition> classifierDefs =
ImmutableList.copyOf(Collections2.transform(classifiers.values(),
private static final Map<ActionDefinitionId, Action> actions =
ImmutableMap.<ActionDefinitionId, Action>
- of(AllowAction.ID, new AllowAction(),
- ChainAction.ID, new ChainAction());
+ of(AllowActionDefinition.ID, new AllowAction(),
+ ChainActionDefinition.ID, new ChainAction());
private static final List<ActionDefinition> actionDefs =
ImmutableList.copyOf(Collections2.transform(actions.values(),
WriteTransaction ctorWriteTransaction = mock(WriteTransaction.class);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(ctorWriteTransaction);
PolicyResolver ctorPolicyResolver = mock(PolicyResolver.class);
- doNothing().when(ctorWriteTransaction).put(any(LogicalDatastoreType.class),
- any(InstanceIdentifier.class), any(SubjectFeatureDefinitions.class));
PolicyManager ctorPolicyManager = new PolicyManager(dataBroker, ctorPolicyResolver,
switchManager, endpointManager, rpcRegistry, executor, tableOffset);
verify(ctorPolicyResolver, atLeastOnce()).registerActionDefinitions(any(ActionDefinitionId.class),
any(ActionInstanceValidator.class));
- verify(ctorWriteTransaction).put(any(LogicalDatastoreType.class),
- any(InstanceIdentifier.class), any(SubjectFeatureDefinitions.class));
- verify(ctorWriteTransaction).submit();
}
@SuppressWarnings("unchecked")
import java.util.List;\r
import java.util.Map;\r
\r
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.MockEndpointManager;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.MockPolicyManager;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.MockEndpointManager;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.MockSwitchManager;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.AllowAction;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.Classifier;\r
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.L4Classifier;\r
import org.opendaylight.groupbasedpolicy.resolver.MockPolicyResolver;\r
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;\r
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;\r
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;\r
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;\r
.setSubjectFeatureInstances(new SubjectFeatureInstancesBuilder()\r
.setClassifierInstance(ImmutableList.of(new ClassifierInstanceBuilder()\r
.setName(new ClassifierName("tcp_dst_80"))\r
- .setClassifierDefinitionId(L4Classifier.DEFINITION.getId())\r
+ .setClassifierDefinitionId(L4ClassifierDefinition.DEFINITION.getId())\r
.setParameterValue(ImmutableList.of(new ParameterValueBuilder()\r
.setName(new ParameterName("destport"))\r
.setIntValue(Long.valueOf(80))\r
/*
* Copyright (c) 2015 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
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.OrdinalFactory.EndpointFwdCtxOrdinals;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.PolicyEnforcer.NetworkElements;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.PolicyEnforcer.PolicyPair;
import org.opendaylight.groupbasedpolicy.resolver.EgKey;
+import org.opendaylight.groupbasedpolicy.sf.actions.ChainActionDefinition;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfcName;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfpName;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.RenderedServicePath;
List<ActionBuilder> actions = Arrays.asList(actionBuilder);
Map<String, Object> params = new HashMap<String, Object>();
String chainName = "chainName";
- params.put(ChainAction.SFC_CHAIN_NAME, chainName);
+ params.put(ChainActionDefinition.SFC_CHAIN_NAME, chainName);
Integer order = Integer.valueOf(0);
OfWriter ofWriter = mock(OfWriter.class);
ActionBuilder actionBuilder = mock(ActionBuilder.class);
List<ActionBuilder> actions = Arrays.asList(actionBuilder);
Map<String, Object> params = new HashMap<String, Object>();
- params.put(ChainAction.SFC_CHAIN_NAME, null);
+ params.put(ChainActionDefinition.SFC_CHAIN_NAME, null);
Integer order = Integer.valueOf(0);
NetworkElements netElements = mock(NetworkElements.class);
PolicyPair policyPair = mock(PolicyPair.class);
List<ActionBuilder> actions = Arrays.asList(actionBuilder);
Map<String, Object> params = new HashMap<String, Object>();
String chainName = "chainName";
- params.put(ChainAction.SFC_CHAIN_NAME, chainName);
+ params.put(ChainActionDefinition.SFC_CHAIN_NAME, chainName);
Integer order = Integer.valueOf(0);
OfWriter ofWriter = mock(OfWriter.class);
/*
* 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.ofoverlay.sf;
-import static org.junit.Assert.*;
-
-import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatch;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder;
+import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatch;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder;
public class ClassifierTest {
@Test
public void updateMatchTest() {
-
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifier.ETHERTYPE_PARAM, FlowUtils.IPv4));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.SRC_PORT_PARAM, 80));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifierDefinition.ETHERTYPE_PARAM,
+ FlowUtils.IPv4));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.SRC_PORT_PARAM, 80));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
ClassificationResult result = Classifier.L4_CL.updateMatch(matches, params);
assertEquals(true, result.isSuccessfull());
assertEquals(3, result.getMatchBuilders().size());
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.HashMap;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
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;
@Test
public void setValueTest() {
- matches.add(new MatchBuilder()
- .setIpMatch(ClassifierTestUtils.createIpMatch(ClassifierTestUtils.TCP.shortValue())));
- params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifier.ETHERTYPE_PARAM, FlowUtils.IPv4));
+ matches.add(new MatchBuilder().setIpMatch(ClassifierTestUtils.createIpMatch(ClassifierTestUtils.TCP.shortValue())));
+ params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifierDefinition.ETHERTYPE_PARAM,
+ FlowUtils.IPv4));
matches = Classifier.ETHER_TYPE_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
assertEquals(true, ClassifierTestUtils.TCP.equals(matches.get(0).getIpMatch().getIpProtocol().longValue()));
}
@Test
public void overrideByTheSameValueTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE))
- .setIpMatch(ClassifierTestUtils.createIpMatch(ClassifierTestUtils.UDP.shortValue())));
- params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifier.ETHERTYPE_PARAM, FlowUtils.IPv6));
+ matches.add(new MatchBuilder().setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)).setIpMatch(
+ ClassifierTestUtils.createIpMatch(ClassifierTestUtils.UDP.shortValue())));
+ params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifierDefinition.ETHERTYPE_PARAM,
+ FlowUtils.IPv6));
matches = Classifier.ETHER_TYPE_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
assertEquals(true, ClassifierTestUtils.UDP.equals(matches.get(0).getIpMatch().getIpProtocol().longValue()));
}
@Test
public void overrideByDifferentValueTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE))
- .setIpMatch(ClassifierTestUtils.createIpMatch(ClassifierTestUtils.SCTP.shortValue())));
- params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifier.ETHERTYPE_PARAM, FlowUtils.IPv6));
+ matches.add(new MatchBuilder().setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)).setIpMatch(
+ ClassifierTestUtils.createIpMatch(ClassifierTestUtils.SCTP.shortValue())));
+ params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifierDefinition.ETHERTYPE_PARAM,
+ FlowUtils.IPv6));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Classification conflict detected");
matches = Classifier.ETHER_TYPE_CL.update(matches, params);
@Test
public void checkPresenceOfRequiredParameters1Test() {
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not specified.");
Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params);
@Test
public void checkPresenceOfRequiredParameters2Test() {
- params.putAll(ImmutableMap.<String, ParameterValue> of(EtherTypeClassifier.ETHERTYPE_PARAM,
+ params.putAll(ImmutableMap.<String, ParameterValue>of(EtherTypeClassifierDefinition.ETHERTYPE_PARAM,
new ParameterValueBuilder().build()));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Value of ethertype parameter is not present");
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.HashMap;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
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;
@Test
public void setValueTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
+ matches.add(new MatchBuilder().setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
matches = Classifier.IP_PROTO_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
assertEquals(true, ClassifierTestUtils.TCP.equals(matches.get(0).getIpMatch().getIpProtocol().longValue()));
}
@Test
public void overrideByTheSameValueTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE))
- .setIpMatch(ClassifierTestUtils.createIpMatch(ClassifierTestUtils.UDP.shortValue())));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.UDP));
+ matches.add(new MatchBuilder().setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)).setIpMatch(
+ ClassifierTestUtils.createIpMatch(ClassifierTestUtils.UDP.shortValue())));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.UDP));
matches = Classifier.IP_PROTO_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
assertEquals(true, ClassifierTestUtils.UDP.equals(matches.get(0).getIpMatch().getIpProtocol().longValue()));
}
@Test
public void overrideByDifferentValueTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE))
- .setIpMatch(ClassifierTestUtils.createIpMatch(ClassifierTestUtils.SCTP.shortValue())));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
+ matches.add(new MatchBuilder().setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)).setIpMatch(
+ ClassifierTestUtils.createIpMatch(ClassifierTestUtils.SCTP.shortValue())));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Classification conflict detected");
matches = Classifier.IP_PROTO_CL.update(matches, params);
@Test
public void checkPresenceOfRequiredParameters1Test() {
- params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifier.ETHERTYPE_PARAM, FlowUtils.IPv4));
+ params.putAll(ClassifierTestUtils.createIntValueParam(EtherTypeClassifierDefinition.ETHERTYPE_PARAM,
+ FlowUtils.IPv4));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not specified");
Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params);
@Test
public void checkPresenceOfRequiredParameters2Test() {
- params.putAll(ImmutableMap.<String, ParameterValue> of(IpProtoClassifier.PROTO_PARAM,
+ params.putAll(ImmutableMap.<String, ParameterValue>of(IpProtoClassifierDefinition.PROTO_PARAM,
new ParameterValueBuilder().build()));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Value of proto parameter is not present");
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.HashMap;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.sf.classifiers.L4ClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
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;
public class L4ClassifierTest {
List<MatchBuilder> matches;
+
Map<String, ParameterValue> params;
@Rule
@Test
public void setTcpSrcPortTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ matches.add(new MatchBuilder().setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
Long sPort = Long.valueOf(80);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.SRC_PORT_PARAM, sPort));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.SRC_PORT_PARAM, sPort));
matches = Classifier.L4_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
TcpMatch match = new TcpMatchBuilder((TcpMatch) matches.get(0).getLayer4Match()).build();
assertEquals(true, sPort.equals(match.getTcpSourcePort().getValue().longValue()));
assertEquals(true, match.getTcpDestinationPort() == null);
@Test
public void setTcpDstPortTest() {
Long dPort = Long.valueOf(80);
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.DST_PORT_PARAM, dPort));
+ matches.add(new MatchBuilder().setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.DST_PORT_PARAM, dPort));
matches = Classifier.L4_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
TcpMatch match = new TcpMatchBuilder((TcpMatch) matches.get(0).getLayer4Match()).build();
assertEquals(true, dPort.equals(match.getTcpDestinationPort().getValue().longValue()));
assertEquals(true, match.getTcpSourcePort() == null);
@Test
public void setTcpSrcPortDstPortRangeTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ matches.add(new MatchBuilder().setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
Long srcPort = Long.valueOf(80);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.SRC_PORT_PARAM, srcPort));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.SRC_PORT_PARAM, srcPort));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
matches = Classifier.L4_CL.update(matches, params);
Set<Long> dstPorts = new HashSet<>();
assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(match.getEthernetMatch().getEthernetType()));
assertEquals(true,
Long.valueOf(new TcpMatchBuilder((TcpMatch) match.getLayer4Match()).getTcpSourcePort().getValue())
- .equals(srcPort));
- dstPorts.add(new TcpMatchBuilder((TcpMatch) match.getLayer4Match()).getTcpDestinationPort().getValue()
- .longValue());
+ .equals(srcPort));
+ dstPorts.add(new TcpMatchBuilder((TcpMatch) match.getLayer4Match()).getTcpDestinationPort()
+ .getValue()
+ .longValue());
}
for (Long i = dstRangeStart; i <= dstRangeEnd; i++) {
assertEquals(true, dstPorts.contains((i)));
@Test
public void overrideDstPortWithTheSameValueTest() {
Long dPort = Long.valueOf(80);
- matches.add(new MatchBuilder()
- .setLayer4Match(ClassifierTestUtils.createUdpDstPort(80))
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.UDP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.DST_PORT_PARAM, dPort));
+ matches.add(new MatchBuilder().setLayer4Match(ClassifierTestUtils.createUdpDstPort(80)).setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.UDP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.DST_PORT_PARAM, dPort));
matches = Classifier.L4_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV6_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
UdpMatch match = new UdpMatchBuilder((UdpMatch) matches.get(0).getLayer4Match()).build();
assertEquals(true, dPort.equals(match.getUdpDestinationPort().getValue().longValue()));
assertEquals(true, match.getUdpSourcePort() == null);
@Test
public void addUdpSrcPortRangeTest() {
- matches.add(new MatchBuilder()
- .setLayer4Match(ClassifierTestUtils.createUdpDstPort(80))
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ matches.add(new MatchBuilder().setLayer4Match(ClassifierTestUtils.createUdpDstPort(80)).setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
Long srcRangeStart = Long.valueOf(8079);
Long srcRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.UDP));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.SRC_PORT_RANGE_PARAM, srcRangeStart, srcRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.UDP));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM,
+ srcRangeStart, srcRangeEnd));
matches = Classifier.L4_CL.update(matches, params);
Set<Long> srcPorts = new HashSet<>();
for (MatchBuilder match : matches) {
assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(match.getEthernetMatch().getEthernetType()));
assertEquals(true, new UdpMatchBuilder((UdpMatch) match.getLayer4Match()).getUdpDestinationPort()
- .getValue().intValue() == 80);
+ .getValue()
+ .intValue() == 80);
assertEquals(true, new UdpMatchBuilder((UdpMatch) match.getLayer4Match()).getUdpDestinationPort()
- .getValue()
- .longValue() == 80);
- srcPorts.add(new UdpMatchBuilder((UdpMatch) match.getLayer4Match()).getUdpSourcePort().getValue()
- .longValue());
+ .getValue()
+ .longValue() == 80);
+ srcPorts.add(new UdpMatchBuilder((UdpMatch) match.getLayer4Match()).getUdpSourcePort()
+ .getValue()
+ .longValue());
}
for (Long i = srcRangeStart; i <= srcRangeEnd; i++) {
assertEquals(true, srcPorts.contains((i)));
@Test
public void setUdpSrcPortRangeDstPortTest() {
- matches.add(new MatchBuilder()
- .setLayer4Match(ClassifierTestUtils.createUdpDstPort(80))
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)));
+ matches.add(new MatchBuilder().setLayer4Match(ClassifierTestUtils.createUdpDstPort(80)).setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV6_ETH_TYPE)));
Long dPort = Long.valueOf(80);
Long srcRangeStart = Long.valueOf(8079);
Long srcRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.UDP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.DST_PORT_PARAM, dPort));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.SRC_PORT_RANGE_PARAM, srcRangeStart, srcRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.UDP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.DST_PORT_PARAM, dPort));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM,
+ srcRangeStart, srcRangeEnd));
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
matches = Classifier.L4_CL.update(matches, params);
Set<Long> srcPorts = new HashSet<>();
assertEquals(
true,
dPort.equals(new UdpMatchBuilder((UdpMatch) match.getLayer4Match()).getUdpDestinationPort()
- .getValue().longValue()));
+ .getValue()
+ .longValue()));
srcPorts.add(Long.valueOf(new UdpMatchBuilder((UdpMatch) match.getLayer4Match()).getUdpSourcePort()
- .getValue().longValue()));
+ .getValue()
+ .longValue()));
}
for (Long i = srcRangeStart; i <= srcRangeEnd; i++) {
assertEquals(true, srcPorts.contains((i)));
@Test
public void overrideSrcPortWithTheSameValueTest() {
Long sPort = Long.valueOf(80);
- matches.add(new MatchBuilder()
- .setLayer4Match(ClassifierTestUtils.createSctpSrcPort(sPort.intValue()))
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.SCTP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.SRC_PORT_PARAM, sPort));
+ matches.add(new MatchBuilder().setLayer4Match(ClassifierTestUtils.createSctpSrcPort(sPort.intValue()))
+ .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.SCTP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.SRC_PORT_PARAM, sPort));
matches = Classifier.L4_CL.update(matches, params);
- assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
+ assertEquals(true,
+ ClassifierTestUtils.IPV4_ETH_TYPE.equals(matches.get(0).getEthernetMatch().getEthernetType()));
SctpMatch match = new SctpMatchBuilder((SctpMatch) matches.get(0).getLayer4Match()).build();
assertEquals(true, sPort.equals(match.getSctpSourcePort().getValue().longValue()));
assertEquals(true, match.getSctpDestinationPort() == null);
@Test
public void addSctpDstPortRangeTest() {
- matches.add(new MatchBuilder()
- .setLayer4Match(ClassifierTestUtils.createSctpSrcPort(80))
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ matches.add(new MatchBuilder().setLayer4Match(ClassifierTestUtils.createSctpSrcPort(80)).setEthernetMatch(
+ ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.SCTP));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.SCTP));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
matches = Classifier.L4_CL.update(matches, params);
Set<Long> dstPorts = new HashSet<>();
for (MatchBuilder match : matches) {
assertEquals(true, ClassifierTestUtils.IPV4_ETH_TYPE.equals(match.getEthernetMatch().getEthernetType()));
- assertEquals(true, new SctpMatchBuilder((SctpMatch) match.getLayer4Match()).getSctpSourcePort().getValue()
- .intValue() == 80);
+ assertEquals(true, new SctpMatchBuilder((SctpMatch) match.getLayer4Match()).getSctpSourcePort()
+ .getValue()
+ .intValue() == 80);
dstPorts.add(Long.valueOf(new SctpMatchBuilder((SctpMatch) match.getLayer4Match()).getSctpDestinationPort()
- .getValue().longValue()));
+ .getValue()
+ .longValue()));
}
for (Long i = dstRangeStart; i <= dstRangeEnd; i++) {
assertEquals(true, dstPorts.contains((i)));
@Test
public void setSctpSrcPortRangeDstPortRangeTest() {
- matches.add(new MatchBuilder()
- .setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
+ matches.add(new MatchBuilder().setEthernetMatch(ClassifierTestUtils.createEthernetMatch(ClassifierTestUtils.IPV4_ETH_TYPE)));
Long srcRangeStart = Long.valueOf(79);
Long srcRangeEnd = Long.valueOf(81);
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.SCTP));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.SRC_PORT_RANGE_PARAM, srcRangeStart, srcRangeEnd));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.SCTP));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM,
+ srcRangeStart, srcRangeEnd));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
matches = Classifier.L4_CL.update(matches, params);
Set<Pair<Long, Long>> set = new HashSet<>();
for (MatchBuilder match : matches) {
Long srcPort = Long.valueOf(new SctpMatchBuilder((SctpMatch) match.getLayer4Match()).getSctpSourcePort()
- .getValue().longValue());
- Long dstPort = Long.valueOf(new SctpMatchBuilder((SctpMatch) match.getLayer4Match())
- .getSctpDestinationPort().getValue().longValue());
+ .getValue()
+ .longValue());
+ Long dstPort = Long.valueOf(new SctpMatchBuilder((SctpMatch) match.getLayer4Match()).getSctpDestinationPort()
+ .getValue()
+ .longValue());
set.add(Pair.of(srcPort, dstPort));
}
for (Long i = srcRangeStart; i <= srcRangeEnd; i++) {
Long srcRangeStart = Long.valueOf(8079);
Long srcRangeEnd = Long.valueOf(8081);
Long srcPort = Long.valueOf(80);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.SCTP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.SRC_PORT_PARAM, srcPort));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.SRC_PORT_RANGE_PARAM, srcRangeStart, srcRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.SCTP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.SRC_PORT_PARAM, srcPort));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM,
+ srcRangeStart, srcRangeEnd));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("mutually exclusive");
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
Long dstPort = Long.valueOf(80);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.UDP));
- params.putAll(ClassifierTestUtils.createIntValueParam(L4Classifier.DST_PORT_PARAM, dstPort));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.UDP));
+ params.putAll(ClassifierTestUtils.createIntValueParam(L4ClassifierDefinition.DST_PORT_PARAM, dstPort));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("mutually exclusive");
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
matches.add(new MatchBuilder());
Long dstRangeStart = Long.valueOf(8081);
Long dstRangeEnd = Long.valueOf(8079);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.TCP));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.TCP));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Range value mismatch");
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
matches.add(new MatchBuilder());
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, 136));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM, 136));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not supported");
matches = Classifier.L4_CL.update(matches, params);
@Test
public void classificationConflictTest() {
- matches.add(new MatchBuilder()
- .setLayer4Match(ClassifierTestUtils.createSctpDstPort(80)));
+ matches.add(new MatchBuilder().setLayer4Match(ClassifierTestUtils.createSctpDstPort(80)));
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifier.PROTO_PARAM, ClassifierTestUtils.UDP));
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createIntValueParam(IpProtoClassifierDefinition.PROTO_PARAM,
+ ClassifierTestUtils.UDP));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Classification conflict");
matches = Classifier.L4_CL.update(matches, params);
matches.add(new MatchBuilder());
Long dstRangeStart = Long.valueOf(8079);
Long dstRangeEnd = Long.valueOf(8081);
- params.putAll(ClassifierTestUtils.createRangeValueParam(L4Classifier.DST_PORT_RANGE_PARAM, dstRangeStart, dstRangeEnd));
+ params.putAll(ClassifierTestUtils.createRangeValueParam(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
+ dstRangeStart, dstRangeEnd));
thrown.expect(IllegalArgumentException.class);
- thrown.expectMessage(IpProtoClassifier.PROTO_PARAM + " is missing");
+ thrown.expectMessage(IpProtoClassifierDefinition.PROTO_PARAM + " is missing");
matches = Classifier.L4_CL.update(matches, params);
}
@Test
public void checkPresenceOfRequiredParameters1Test() {
- params.putAll(ImmutableMap.<String, ParameterValue> of(L4Classifier.SRC_PORT_PARAM,
+ params.putAll(ImmutableMap.<String, ParameterValue>of(L4ClassifierDefinition.SRC_PORT_PARAM,
new ParameterValueBuilder().build()));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not specified");
@Test
public void checkPresenceOfRequiredParameters2Test() {
- params.putAll(ImmutableMap.<String, ParameterValue> of(L4Classifier.DST_PORT_PARAM,
+ params.putAll(ImmutableMap.<String, ParameterValue>of(L4ClassifierDefinition.DST_PORT_PARAM,
new ParameterValueBuilder().build()));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not specified");
@Test
public void checkPresenceOfRequiredParameters3Test() {
- params.putAll(ImmutableMap.<String, ParameterValue> of(L4Classifier.SRC_PORT_RANGE_PARAM,
+ params.putAll(ImmutableMap.<String, ParameterValue>of(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM,
new ParameterValueBuilder().build()));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not present");
@Test
public void checkPresenceOfRequiredParameters4Test() {
- params.putAll(ImmutableMap.<String, ParameterValue> of(L4Classifier.DST_PORT_RANGE_PARAM,
+ params.putAll(ImmutableMap.<String, ParameterValue>of(L4ClassifierDefinition.DST_PORT_RANGE_PARAM,
new ParameterValueBuilder().build()));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not present");
Classifier.L4_CL.checkPresenceOfRequiredParams(params);
}
-
}
Code Review / groupbasedpolicy.git / commitdiff