Fixed issues with registration point for renderers

- missing keys in instance-identifiers
- wrong params in supported classifier defs
- added action definition and action capabilities

Change-Id: I2878d92ec6f17777fe6438825fac60e14e204fc4
Signed-off-by: Martin Sunal <msunal@cisco.com>

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/impl/GroupbasedpolicyModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/impl/GroupbasedpolicyModule.java
index fa99d569d89540d69aebf2568cd9f46ea07de909..adc2ec9210dd32c2bdb866c3cc371be21de5852f 100755 (executable)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/impl/GroupbasedpolicyModule.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/impl/GroupbasedpolicyModule.java
@@ -13,6 +13,8 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
 import org.opendaylight.groupbasedpolicy.endpoint.EndpointRpcRegistry;
 import org.opendaylight.groupbasedpolicy.sf.SubjectFeatureDefinitionProvider;
+import org.opendaylight.groupbasedpolicy.sf.SupportedActionDefinitionListener;
+import org.opendaylight.groupbasedpolicy.sf.SupportedClassifierDefinitionListener;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -59,11 +61,17 @@ public class GroupbasedpolicyModule extends
 
                 SubjectFeatureDefinitionProvider sfdp = new SubjectFeatureDefinitionProvider(dataProvider);
                 EndpointRpcRegistry epRpcRegistry = new EndpointRpcRegistry(dataProvider, rpcRegistry);
+                SupportedClassifierDefinitionListener supportedClassifierDefinitionListener =
+                        new SupportedClassifierDefinitionListener(dataProvider);
+                SupportedActionDefinitionListener supportedActionDefinitionListener =
+                        new SupportedActionDefinitionListener(dataProvider);
 
                 @Override
                 public void close() throws Exception {
                     sfdp.close();
                     epRpcRegistry.close();
+                    supportedClassifierDefinitionListener.close();
+                    supportedActionDefinitionListener.close();
                 }
             };
         } catch (TransactionCommitFailedException e) {

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java
new file mode 100644 (file)
index 0000000..f7806a3
--- /dev/null
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java
@@ -0,0 +1,102 @@
+/*
+ * 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 static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+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.subject.feature.definitions.ActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.Capabilities;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.SetMultimap;
+
+public class SupportedActionDefinitionListener
+        implements DataTreeChangeListener<SupportedActionDefinition>, AutoCloseable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SupportedActionDefinitionListener.class);
+
+    private final DataBroker dataProvider;
+    private final ListenerRegistration<SupportedActionDefinitionListener> registration;
+    @VisibleForTesting
+    final SetMultimap<ClassifierDefinitionId, InstanceIdentifier<SupportedClassifierDefinition>> supportedCdIidByCdId =
+            HashMultimap.create();
+    @VisibleForTesting
+    final Map<InstanceIdentifier<SupportedClassifierDefinition>, ClassifierInstanceValidator> ciValidatorBySupportedCdIid =
+            new HashMap<>();
+
+    public SupportedActionDefinitionListener(DataBroker dataProvider) {
+        this.dataProvider = checkNotNull(dataProvider);
+        registration =
+                dataProvider.registerDataTreeChangeListener(
+                        new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+                                InstanceIdentifier.builder(Renderers.class)
+                                    .child(Renderer.class)
+                                    .child(Capabilities.class)
+                                    .child(SupportedActionDefinition.class)
+                                    .build()),
+                        this);
+    }
+
+    @Override
+    public void onDataTreeChanged(Collection<DataTreeModification<SupportedActionDefinition>> changes) {
+        for (DataTreeModification<SupportedActionDefinition> change : changes) {
+            DataObjectModification<SupportedActionDefinition> rootNode = change.getRootNode();
+            switch (rootNode.getModificationType()) {
+                case WRITE:
+                case SUBTREE_MODIFIED:
+                    ActionDefinitionId actionDefinitionId = rootNode.getDataAfter().getActionDefinitionId();
+                    ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+                    Optional<ActionDefinition> potentialAdFromConfDs = DataStoreHelper.readFromDs(
+                            LogicalDatastoreType.CONFIGURATION, IidFactory.actionDefinitionIid(actionDefinitionId), rwTx);
+                    if (!potentialAdFromConfDs.isPresent()) {
+                        LOG.error("Action-definition with ID {} does not exist in CONF datastore.", actionDefinitionId);
+                        return;
+                    }
+                    // TODO union and validation need to be finished
+                    ActionDefinition ad = potentialAdFromConfDs.get();
+                    rwTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.actionDefinitionIid(actionDefinitionId), ad);
+                    DataStoreHelper.submitToDs(rwTx);
+                    break;
+                case DELETE:
+                    throw new UnsupportedOperationException("Not implemented yet.");
+            }
+        }
+    }
+
+    @Override
+    public void close() throws Exception {
+        registration.close();
+    }
+
+}

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java
index 1602ce2c928e0d425ceb41d2c03c25feb4ac95ce..88be1685db2054d960c26efb5105622703d8d2fb 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java
@@ -11,6 +11,7 @@ package org.opendaylight.groupbasedpolicy.util;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+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.ClassifierDefinitionId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
@@ -36,6 +37,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.Tenants;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRefKey;
+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.ActionDefinitionKey;
 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.ClassifierDefinitionKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
@@ -164,6 +167,12 @@ public class IidFactory {
             .build();
     }
 
+    public static InstanceIdentifier<ActionDefinition> actionDefinitionIid(ActionDefinitionId actionDefinitionId) {
+        return InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
+            .child(ActionDefinition.class, new ActionDefinitionKey(actionDefinitionId))
+            .build();
+    }
+
     public static InstanceIdentifier<ClassifierRef> classifierRefIid(TenantId tenantId, ContractId contractId,
             SubjectName subjectName, RuleName ruleName, ClassifierName classifierRefName) {
         return InstanceIdentifier.builder(Tenants.class)

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java
index 4fc7ceb97ca9ee71e7bd565712981e91a93e366f..deaf2ad9a085aeab9bd605364400f68e17074f74 100644 (file)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java
@@ -30,6 +30,8 @@ import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointMan
 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayAug;
 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayL3NatAug;
 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ActionDefinitionListener;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ClassifierDefinitionListener;
 import org.opendaylight.groupbasedpolicy.resolver.PolicyResolver;
 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig;
@@ -52,12 +54,15 @@ import com.google.common.util.concurrent.ListenableFuture;
 public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
     private static final Logger LOG =
             LoggerFactory.getLogger(OFOverlayRenderer.class);
+    public static final String RENDERER_NAME = "OFOverlay";
 
     private final DataBroker dataBroker;
     private final PolicyResolver policyResolver;
     private final SwitchManager switchManager;
     private final EndpointManager endpointManager;
     private final PolicyManager policyManager;
+    private final ClassifierDefinitionListener classifierDefinitionListener;
+    private ActionDefinitionListener actionDefinitionListener;
     private final OfOverlayAug ofOverlayAug;
     private final OfOverlayL3NatAug ofOverlayL3NatAug;
 
@@ -84,6 +89,9 @@ public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
                                               executor, switchManager);
         policyResolver = new PolicyResolver(dataProvider, executor);
 
+        classifierDefinitionListener = new ClassifierDefinitionListener(dataBroker);
+        actionDefinitionListener = new ActionDefinitionListener(dataProvider);
+
         policyManager = new PolicyManager(dataProvider,
                                           policyResolver,
                                           switchManager,
@@ -116,6 +124,8 @@ public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
         if (policyResolver != null) policyResolver.close();
         if (switchManager != null) switchManager.close();
         if (endpointManager != null) endpointManager.close();
+        if (classifierDefinitionListener != null) classifierDefinitionListener.close();
+        if (actionDefinitionListener != null) actionDefinitionListener.close();
         if (ofOverlayAug != null) ofOverlayAug.close();
         if (ofOverlayL3NatAug != null) ofOverlayL3NatAug.close();
     }

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/PolicyManager.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/PolicyManager.java
index f50f57f47b324f68f2738cd92c26bd4d7a0a9106..2b8169b995186a738ab37d9c440c1daff39f8bce 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/PolicyManager.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/PolicyManager.java
@@ -27,7 +27,6 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
 import org.opendaylight.groupbasedpolicy.endpoint.EpKey;
@@ -55,7 +54,6 @@ import org.opendaylight.groupbasedpolicy.util.SingletonTask;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig.LearningMode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableId;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@@ -122,8 +120,6 @@ public class PolicyManager
                     + "Max. table ID would be out of range. Check config-subsystem.\n{}", e);
         }
 
-        // TODO write capabilities in DS
-
         for(Entry<ActionDefinitionId, Action> entry : SubjectFeatures.getActions().entrySet()) {
             policyResolver.registerActionDefinitions(entry.getKey(), entry.getValue());
         }

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Action.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Action.java
index 677045004d3274f19e9e39cb7f3b067ba948d028..c78f5c36f97fc45a25d267d9e9844d9cae031677 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Action.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Action.java
@@ -20,6 +20,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.acti
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
 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.renderer.rev151103.renderers.renderer.capabilities.supported.action.definition.SupportedParameterValues;
 
 /**
  * Represent an action definition, and provide tools for generating
@@ -39,6 +40,13 @@ public abstract class Action implements ActionInstanceValidator{
      */
     public abstract ActionDefinition getActionDef();
 
+    /**
+     * The result represents supported parameters for the action by renderer
+     * 
+     * @return list of supported parameters by the action
+     */
+    public abstract List<SupportedParameterValues> getSupportedParameterValues();
+
     /**
      * Construct a set of actions that will apply to the traffic.  Augment
      * the existing list of actions or add new actions.  It's important

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ActionDefinitionListener.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ActionDefinitionListener.java
new file mode 100644 (file)
index 0000000..8a2b29f
--- /dev/null
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ActionDefinitionListener.java
@@ -0,0 +1,129 @@
+/*
+ * 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.renderer.ofoverlay.sf;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OFOverlayRenderer;
+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.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.Capabilities;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinitionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinitionKey;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+
+public class ActionDefinitionListener implements DataTreeChangeListener<ActionDefinition>, AutoCloseable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(ActionDefinitionListener.class);
+    private static final InstanceIdentifier<Capabilities> CAPABILITIES_IID = InstanceIdentifier.builder(Renderers.class)
+        .child(Renderer.class, new RendererKey(new RendererName(OFOverlayRenderer.RENDERER_NAME)))
+        .child(Capabilities.class)
+        .build();
+    private static String PUT = "stored";
+    private static String DELETED = "removed";
+
+    private final DataBroker dataProvider;
+    private final ListenerRegistration<ActionDefinitionListener> registration;
+
+    public ActionDefinitionListener(DataBroker dataProvider) {
+        this.dataProvider = checkNotNull(dataProvider);
+        registration = dataProvider
+            .registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+                    InstanceIdentifier.builder(SubjectFeatureDefinitions.class).child(ActionDefinition.class).build()),
+                    this);
+    }
+
+    @Override
+    public void onDataTreeChanged(Collection<DataTreeModification<ActionDefinition>> changes) {
+        for (DataTreeModification<ActionDefinition> change : changes) {
+            DataObjectModification<ActionDefinition> rootNode = change.getRootNode();
+
+            switch (rootNode.getModificationType()) {
+                case WRITE:
+                case SUBTREE_MODIFIED:
+                    ActionDefinition actionDefinitionAfter = checkNotNull(rootNode.getDataAfter());
+                    Action ourAction = SubjectFeatures.getAction(actionDefinitionAfter.getId());
+                    if (ourAction != null) {
+                        SupportedActionDefinition supportedActionDefinition =
+                                createSupportedActionDefinition(ourAction);
+                        WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+                        wTx.put(LogicalDatastoreType.OPERATIONAL, CAPABILITIES_IID
+                            .child(SupportedActionDefinition.class, supportedActionDefinition.getKey()),
+                                supportedActionDefinition, true);
+                        Futures.addCallback(wTx.submit(), logDebugResult(supportedActionDefinition.getKey(), PUT));
+                    }
+                    break;
+
+                case DELETE:
+                    ActionDefinition actionDefinitionBefore = checkNotNull(rootNode.getDataBefore());
+                    ourAction = SubjectFeatures.getAction(actionDefinitionBefore.getId());
+                    if (ourAction != null) {
+                        SupportedActionDefinitionKey supportedActionDefinitionKey =
+                                new SupportedActionDefinitionKey(ourAction.getId());
+                        WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+                        wTx.delete(LogicalDatastoreType.OPERATIONAL,
+                                CAPABILITIES_IID.child(SupportedActionDefinition.class, supportedActionDefinitionKey));
+                        Futures.addCallback(wTx.submit(), logDebugResult(supportedActionDefinitionKey, DELETED));
+                    }
+                    break;
+            }
+
+        }
+    }
+
+    private SupportedActionDefinition createSupportedActionDefinition(Action action) {
+        return new SupportedActionDefinitionBuilder().setActionDefinitionId(action.getId())
+            .setSupportedParameterValues(action.getSupportedParameterValues())
+            .build();
+    }
+
+    private FutureCallback<Void> logDebugResult(final SupportedActionDefinitionKey supportedActionDefinitionKey,
+            final String putOrDeleted) {
+        return new FutureCallback<Void>() {
+
+            @Override
+            public void onSuccess(Void result) {
+                LOG.debug("Capability of renerer {} was {}: {}", OFOverlayRenderer.RENDERER_NAME, putOrDeleted,
+                        supportedActionDefinitionKey);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                LOG.error("Capability of renderer {} was NOT {}: {}", OFOverlayRenderer.RENDERER_NAME, putOrDeleted,
+                        supportedActionDefinitionKey, t);
+            }
+        };
+    }
+
+    @Override
+    public void close() throws Exception {
+        if (registration != null)
+            registration.close();
+    }
+}

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/AllowAction.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/AllowAction.java
index 3ecab01e751d1e44bb7bbe4100609a9f161f4992..4d3196f4b5b4684f6a405d335c3e9cd82f25e9df 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/AllowAction.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/AllowAction.java
@@ -10,6 +10,7 @@ package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;
 
 import static org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.FlowUtils.nxOutputRegAction;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -23,6 +24,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev
 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.tenants.tenant.subject.feature.instances.ActionInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.action.definition.SupportedParameterValues;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxReg7;
 
 /**
@@ -67,4 +69,10 @@ public class AllowAction extends Action {
     public boolean isValid(ActionInstance actionInstance) {
         return true;
     }
+
+    @Override
+    public List<SupportedParameterValues> getSupportedParameterValues() {
+        // allow action definition has no parameter
+        return Collections.emptyList();
+    }
 }

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ChainAction.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ChainAction.java
index f590b44b409cb57a400f7118c2e35cd0724ec3ff..d043f263982facfa561c43d8bd9b862520ff51c2 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ChainAction.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ChainAction.java
@@ -42,16 +42,20 @@ import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev1407
 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.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.definitions.ActionDefinition;
 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.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.action.definition.SupportedParameterValues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.action.definition.SupportedParameterValuesBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlanGpe;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 
 /**
@@ -285,4 +289,11 @@ public class ChainAction extends Action {
         return actions;
     }
 
+    @Override
+    public List<SupportedParameterValues> getSupportedParameterValues() {
+        // supported parameter does not contain parameter type - it means all strings are supported
+        return ImmutableList.<SupportedParameterValues>of(new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(ChainActionDefinition.SFC_CHAIN_NAME)).build());
+    }
+
 }

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Classifier.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Classifier.java
index 331b6840e6c10487c6765066324cf3c172b8da6d..1ff03b2bbc0beaa6415058910ccaaa4316ef8896 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Classifier.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/Classifier.java
@@ -56,6 +56,13 @@ public abstract class Classifier {
         return parent;
     }
 
+    /**
+     * The result represents supported parameters for the classifier by renderer
+     * 
+     * @return list of supported parameters by the classifier
+     */
+    public abstract List<SupportedParameterValues> getSupportedParameterValues();
+
     /**
      * Template method for resolving {@code matches}.
      *
@@ -102,8 +109,6 @@ public abstract class Classifier {
         return new ClassificationResult(matchBuilders);
     }
 
-    public abstract List<SupportedParameterValues> getSupportedParameterValues();
-
     /**
      * Checks presence of required {@code params} in order to decide if classifier can update {@code matches} properly
      * in  method {@link #update(List, Map)}

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ClassifierDefinitionListener.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ClassifierDefinitionListener.java
new file mode 100755 (executable)
index 0000000..f14c6c5
--- /dev/null
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/ClassifierDefinitionListener.java
@@ -0,0 +1,135 @@
+/*
+ * 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.renderer.ofoverlay.sf;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OFOverlayRenderer;
+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.ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.Capabilities;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionKey;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+
+public class ClassifierDefinitionListener implements DataTreeChangeListener<ClassifierDefinition>, AutoCloseable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(ClassifierDefinitionListener.class);
+    private static final InstanceIdentifier<Capabilities> CAPABILITIES_IID = InstanceIdentifier.builder(Renderers.class)
+        .child(Renderer.class, new RendererKey(new RendererName(OFOverlayRenderer.RENDERER_NAME)))
+        .child(Capabilities.class)
+        .build();
+    private static String PUT = "stored";
+    private static String DELETED = "removed";
+
+    private final DataBroker dataProvider;
+    private final ListenerRegistration<ClassifierDefinitionListener> registration;
+
+    public ClassifierDefinitionListener(DataBroker dataProvider) {
+        this.dataProvider = checkNotNull(dataProvider);
+        registration =
+                dataProvider
+                    .registerDataTreeChangeListener(
+                            new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier
+                                .builder(SubjectFeatureDefinitions.class).child(ClassifierDefinition.class).build()),
+                    this);
+    }
+
+    @Override
+    public void onDataTreeChanged(Collection<DataTreeModification<ClassifierDefinition>> changes) {
+        for (DataTreeModification<ClassifierDefinition> change : changes) {
+            DataObjectModification<ClassifierDefinition> rootNode = change.getRootNode();
+
+            switch (rootNode.getModificationType()) {
+                case WRITE:
+                case SUBTREE_MODIFIED:
+                    ClassifierDefinition classifierDefinitionAfter = checkNotNull(rootNode.getDataAfter());
+                    Classifier ourClassifier = SubjectFeatures.getClassifier(classifierDefinitionAfter.getId());
+                    if (ourClassifier != null) {
+                        SupportedClassifierDefinition supportedClassifierDefinition =
+                                createSupportedClassifierDefinition(ourClassifier);
+                        WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+                        wTx.put(LogicalDatastoreType.OPERATIONAL, CAPABILITIES_IID
+                            .child(SupportedClassifierDefinition.class, supportedClassifierDefinition.getKey()),
+                                supportedClassifierDefinition, true);
+                        Futures.addCallback(wTx.submit(), logDebugResult(supportedClassifierDefinition.getKey(), PUT));
+                    }
+                    break;
+
+                case DELETE:
+                    ClassifierDefinition classifierDefinitionBefore = checkNotNull(rootNode.getDataBefore());
+                    ourClassifier = SubjectFeatures.getClassifier(classifierDefinitionBefore.getId());
+                    if (ourClassifier != null) {
+                        SupportedClassifierDefinitionKey supportedClassifierDefinitionKey =
+                                new SupportedClassifierDefinitionKey(ourClassifier.getId());
+                        WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+                        wTx.delete(LogicalDatastoreType.OPERATIONAL, CAPABILITIES_IID
+                            .child(SupportedClassifierDefinition.class, supportedClassifierDefinitionKey));
+                        Futures.addCallback(wTx.submit(), logDebugResult(supportedClassifierDefinitionKey, DELETED));
+                    }
+                    break;
+            }
+
+        }
+    }
+
+    private SupportedClassifierDefinition createSupportedClassifierDefinition(Classifier classifier) {
+        SupportedClassifierDefinitionBuilder scdBuilder =
+                new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(classifier.getId())
+                    .setSupportedParameterValues(classifier.getSupportedParameterValues());
+        if (classifier.getParent() != null) {
+            scdBuilder.setParentClassifierDefinitionId(classifier.getParent().getId());
+        }
+        return scdBuilder.build();
+    }
+
+    private FutureCallback<Void> logDebugResult(final SupportedClassifierDefinitionKey supportedClassifierDefinitionKey,
+            final String putOrDeleted) {
+        return new FutureCallback<Void>() {
+
+            @Override
+            public void onSuccess(Void result) {
+                LOG.debug("Capability of renerer {} was {}: {}", OFOverlayRenderer.RENDERER_NAME, putOrDeleted,
+                        supportedClassifierDefinitionKey);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                LOG.error("Capability of renderer {} was NOT {}: {}", OFOverlayRenderer.RENDERER_NAME, putOrDeleted,
+                        supportedClassifierDefinitionKey, t);
+            }
+        };
+    }
+
+    @Override
+    public void close() throws Exception {
+        if (registration != null)
+            registration.close();
+    }
+}

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/L4Classifier.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/L4Classifier.java
index 832a585029e3a5a374d32f093f6e8705560d3a09..0aea0b76b358fe446a15305bd82fc4d053facd22 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/L4Classifier.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/L4Classifier.java
@@ -25,6 +25,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev
 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.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.RangeBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValuesBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueInRange;
@@ -60,33 +61,30 @@ public class L4Classifier extends Classifier {
 
     @Override
     public List<SupportedParameterValues> getSupportedParameterValues() {
-        List<SupportedIntValueInRange> allPossiblePortsIntInRange = ImmutableList.of(
-                new SupportedIntValueInRangeBuilder().setMin(1L).setMax(65535L).build());
-        List<SupportedRangeValue> allPossiblePortsRange = ImmutableList.of(
-                new SupportedRangeValueBuilder().setMin(1L).setMax(65535L).build());
+        List<SupportedIntValueInRange> allPossiblePortsIntInRange =
+                ImmutableList.of(new SupportedIntValueInRangeBuilder().setMin(1L).setMax(65535L).build());
+        List<SupportedRangeValue> allPossiblePortsRange =
+                ImmutableList.of(new SupportedRangeValueBuilder().setMin(1L).setMax(65535L).build());
 
-        SupportedParameterValuesBuilder srcPorts = new SupportedParameterValuesBuilder();
-        srcPorts.setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM));
-        srcPorts.setParameterType(
-                new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build());
+        SupportedParameterValues srcPorts = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM))
+            .setParameterType(new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build())
+            .build();
+        SupportedParameterValues dstPorts = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM))
+            .setParameterType(new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build())
+            .build();
 
-        SupportedParameterValuesBuilder dstPorts = new SupportedParameterValuesBuilder();
-        dstPorts.setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM));
-        dstPorts.setParameterType(
-                new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build());
+        SupportedParameterValues srcPortsRange = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM))
+            .setParameterType(new RangeBuilder().setSupportedRangeValue(allPossiblePortsRange).build())
+            .build();
+        SupportedParameterValues dstPortsRange = new SupportedParameterValuesBuilder()
+            .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))
+            .setParameterType(new RangeBuilder().setSupportedRangeValue(allPossiblePortsRange).build())
+            .build();
 
-        SupportedParameterValuesBuilder srcPortsRange = new SupportedParameterValuesBuilder();
-        srcPorts.setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM));
-        srcPorts.setParameterType(
-                new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build());
-
-        SupportedParameterValuesBuilder dstPortsRange = new SupportedParameterValuesBuilder();
-        dstPorts.setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM));
-        dstPorts.setParameterType(
-                new IntBuilder().setSupportedIntValueInRange(allPossiblePortsIntInRange).build());
-
-        return ImmutableList.of(srcPorts.build(), dstPorts.build(), srcPortsRange.build(),
-                dstPortsRange.build());
+        return ImmutableList.of(srcPorts, dstPorts, srcPortsRange, dstPortsRange);
     }
 
     @Override

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatureDefinitionsListener.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatureDefinitionsListener.java
deleted file mode 100755 (executable)
index b5d5925..0000000
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatureDefinitionsListener.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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.renderer.ofoverlay.sf;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
-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.ClassifierDefinition;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.Capabilities;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class SubjectFeatureDefinitionsListener
-        implements DataTreeChangeListener<ClassifierDefinition>, AutoCloseable {
-
-    private static final Logger LOG =
-            LoggerFactory.getLogger(SubjectFeatureDefinitionsListener.class);
-
-    private final DataBroker dataProvider;
-    private final ListenerRegistration<SubjectFeatureDefinitionsListener> registration;
-
-    private static final Map<ClassifierDefinitionId, Classifier> OF_CLASSIFIERS =
-            SubjectFeatures.getClassifiers();
-
-    public SubjectFeatureDefinitionsListener(DataBroker dataProvider) {
-        this.dataProvider = checkNotNull(dataProvider);
-        registration = dataProvider.registerDataTreeChangeListener(
-                new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
-                        InstanceIdentifier.builder(SubjectFeatureDefinitions.class)
-                                .child(ClassifierDefinition.class)
-                                .build()), this);
-
-    }
-
-    @Override
-    public void onDataTreeChanged(Collection<DataTreeModification<ClassifierDefinition>> changes) {
-
-        for (DataTreeModification<ClassifierDefinition> change : changes) {
-            DataObjectModification<ClassifierDefinition> rootNode = change.getRootNode();
-
-            List<SupportedClassifierDefinition> supportedClassifierDefinitions = new ArrayList<>();
-
-            switch (rootNode.getModificationType()) {
-                case WRITE:
-                case SUBTREE_MODIFIED:
-                    ClassifierDefinition classifierDefinitionAfter =
-                            checkNotNull(rootNode.getDataAfter());
-                    Classifier ourClassifier =
-                            OF_CLASSIFIERS.get(classifierDefinitionAfter.getId());
-                    if (ourClassifier != null) {
-                        List<SupportedParameterValues> spValues =
-                                ourClassifier.getSupportedParameterValues();
-
-                        SupportedClassifierDefinitionBuilder scdBuilder =
-                                new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(
-                                        ourClassifier.getClassifierDefinition().getId())
-                                        .setSupportedParameterValues(spValues);
-                        if (ourClassifier.getParent() != null) {
-                            scdBuilder.setParentClassifierDefinitionId(
-                                    ourClassifier.getParent().getId());
-                        }
-                        supportedClassifierDefinitions.add(scdBuilder.build());
-                    }
-
-                    if (!supportedClassifierDefinitions.isEmpty()) {
-                        WriteTransaction wt = dataProvider.newWriteOnlyTransaction();
-                        for (SupportedClassifierDefinition def : supportedClassifierDefinitions) {
-                            wt.put(LogicalDatastoreType.OPERATIONAL,
-                                    InstanceIdentifier.builder(Renderers.class)
-                                            .child(Renderer.class)
-                                            .child(Capabilities.class)
-                                            .child(SupportedClassifierDefinition.class)
-                                            .build(), def, true);
-                        }
-                        wt.submit();
-                    }
-                    break;
-
-                case DELETE:
-                    ClassifierDefinition classifierDefinitionBefore =
-                            checkNotNull(rootNode.getDataAfter());
-                    ClassifierDefinitionId id = classifierDefinitionBefore.getId();
-                    WriteTransaction wt = dataProvider.newWriteOnlyTransaction();
-                    wt.delete(LogicalDatastoreType.OPERATIONAL,
-                            InstanceIdentifier.builder(Renderers.class)
-                                    .child(Renderer.class)
-                                    .child(Capabilities.class)
-                                    .child(SupportedClassifierDefinition.class,
-                                            new SupportedClassifierDefinitionKey(id))
-                                    .build());
-                    wt.submit();
-                    break;
-            }
-
-        }
-    }
-
-    @Override
-    public void close() throws Exception {
-        registration.close();
-    }
-}

diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatures.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatures.java
index a490fbc04741d493f354af5da72cf37ac29a6152..e3e6748b1f8fd22b713a1d7ec21d44dca2f6d807 100755 (executable)
--- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatures.java
+++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatures.java
@@ -80,11 +80,6 @@ public class SubjectFeatures {
         return classifiers.get(id);
     }
 
-
-    public static Map<ClassifierDefinitionId, Classifier> getClassifiers() {
-        return classifiers;
-    }
-
     public static Map<ActionDefinitionId, Action> getActions() {
         return actions;
     }

diff --git a/renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatureDefinitionsListenerTest.java b/renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatureDefinitionsListenerTest.java
deleted file mode 100755 (executable)
index 7b48939..0000000
--- a/renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/sf/SubjectFeatureDefinitionsListenerTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * 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.renderer.ofoverlay.sf;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import org.junit.Assert;
-import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.groupbasedpolicy.sf.classifiers.EtherTypeClassifierDefinition;
-import org.opendaylight.groupbasedpolicy.util.IidFactory;
-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;
-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.renderer.rev151103.RendererName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.Capabilities;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class SubjectFeatureDefinitionsListenerTest extends AbstractDataBrokerTest {
-
-    private static final Parameter PARAM_INT =
-            new ParameterBuilder().setName(new ParameterName("paramInt"))
-                    .setType(Parameter.Type.Int)
-                    .build();
-    private static final ClassifierDefinition CD_WITH_PARAM_INT =
-            new ClassifierDefinitionBuilder().setId(
-                    new ClassifierDefinitionId(EtherTypeClassifierDefinition.ID.getValue()))
-                    .setDescription(new Description("some description"))
-                    .setName(new ClassifierName("cd_with_one_param"))
-                    .setParameter(ImmutableList.of(PARAM_INT))
-                    .build();
-
-    @Test
-    public void testPutEtherTypeClassifierDefinition() throws Exception {
-        Renderer renderer1 = new RendererBuilder().setName(new RendererName("renderer1")).build();
-        WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
-        wTx.put(LogicalDatastoreType.OPERATIONAL,
-                InstanceIdentifier.builder(Renderers.class).child(Renderer.class, renderer1.getKey()).build(),
-                renderer1);
-
-        wTx.put(LogicalDatastoreType.CONFIGURATION,
-                IidFactory.classifierDefinitionIid(CD_WITH_PARAM_INT.getId()), CD_WITH_PARAM_INT,
-                true);
-        wTx.submit().get();
-
-        ReadOnlyTransaction rTx = getDataBroker().newReadOnlyTransaction();
-        CheckedFuture<Optional<SupportedClassifierDefinition>, ReadFailedException> f =
-                rTx.read(LogicalDatastoreType.OPERATIONAL,
-                        InstanceIdentifier.builder(Renderers.class)
-                                .child(Renderer.class, renderer1.getKey())
-                                .child(Capabilities.class)
-                                .child(SupportedClassifierDefinition.class,
-                                        new SupportedClassifierDefinitionKey(
-                                                EtherTypeClassifierDefinition.ID))
-                                .build());
-        Futures.addCallback(f, new FutureCallback<Optional<SupportedClassifierDefinition>>() {
-
-            @Override
-            public void onSuccess(Optional<SupportedClassifierDefinition> result) {
-                if (result.isPresent()) {
-                    SupportedClassifierDefinition def = result.get();
-                    Assert.assertEquals(CD_WITH_PARAM_INT.getId(), def.getClassifierDefinitionId());
-                    Assert.assertEquals(SubjectFeatures.getClassifier(CD_WITH_PARAM_INT.getId())
-                            .getSupportedParameterValues(), def.getSupportedParameterValues());
-                }
-            }
-
-            @Override
-            public void onFailure(Throwable t) {
-                throw new RuntimeException(t);
-            }
-        });
-        f.checkedGet();
-    }
-
-}