soften reaction of listeners on empty sxp-master-DB

    - added simplistic EP registration content (l3address)
    - added SKIP if ep-l3 exists
    - added SKIP if announced ip-sgt binding contains subnet

Change-Id: I61a25fd098d4a740f0987cf0ced4a0c1f1e2f96b
Signed-off-by: Michal Rehak <mirehak@cisco.com>

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java
index 1e6fd913e0d4703e7d4894657e8649fbdd517b1b..712e72dc7a56b64765783704195dcc2676669dfc 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java
@@ -51,7 +51,7 @@ public class SxpMapperProviderImpl implements AutoCloseable {
         this.rpcRegistryDependency = rpcRegistryDependency;
 
         final EndpointService endpointService = rpcRegistryDependency.getRpcService(EndpointService.class);
-        sxpMapperReactor = new SxpMapperReactorImpl(endpointService);
+        sxpMapperReactor = new SxpMapperReactorImpl(endpointService, dataBroker);
 
         final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao = new SimpleCachedDaoImpl<>();
         final SimpleCachedDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateCachedDao =

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java
index 8ed0329b82044c987f33d3ba49200b4f329d9b54..861c1aa5bd2eeac5c9734c97c066b0fc15328339 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java
@@ -8,48 +8,119 @@
 
 package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
 
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.JdkFutureAdapters;
 import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collections;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+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.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+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.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3AddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Purpose: exclusively processes sxp master database changes and EGP templates changes
  */
 public class SxpMapperReactorImpl implements SxpMapperReactor {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SxpMapperReactorImpl.class);
+
     private final EndpointService l3EndpointService;
+    private final DataBroker dataBroker;
 
-    public SxpMapperReactorImpl(final EndpointService l3EndpointService) {
-        this.l3EndpointService = l3EndpointService;
+    public SxpMapperReactorImpl(final EndpointService l3EndpointService, final DataBroker dataBroker) {
+        this.l3EndpointService = Preconditions.checkNotNull(l3EndpointService, "l3Endpoint service missing");
+        this.dataBroker = Preconditions.checkNotNull(dataBroker, "dataBroker missing");
     }
 
     @Override
-    public ListenableFuture<RpcResult<Void>> processPolicyAndSxpMasterDB(final EndpointPolicyTemplateBySgt template, final MasterDatabaseBinding masterDatabaseBinding) {
+    public ListenableFuture<RpcResult<Void>> processPolicyAndSxpMasterDB(final EndpointPolicyTemplateBySgt template, final MasterDatabaseBinding masterDBBinding) {
+        LOG.debug("processing ep-policy-template + sxpMasterDB entry: {} - {}",
+                masterDBBinding.getSecurityGroupTag(), masterDBBinding.getIpPrefix());
         // apply sxpMasterDB to policy template
-        final RegisterEndpointInput input = new RegisterEndpointInputBuilder()
+        final L3Address l3Address = buildL3Address(masterDBBinding.getIpPrefix());
+        final RegisterEndpointInput epInput = new RegisterEndpointInputBuilder()
                 .setCondition(template.getConditions())
                 .setTenant(template.getTenant())
                 .setEndpointGroups(template.getEndpointGroups())
+                .setL3Address(Collections.singletonList(l3Address))
                 .build();
 
-        // invoke service
-        return JdkFutureAdapters.listenInPoolThread(l3EndpointService.registerEndpoint(input));
+        return chainL3EPServiceIfEpAbsent(l3Address, epInput);
     }
 
     @Override
-    public ListenableFuture<RpcResult<Void>> processForwardingAndSxpMasterDB(final EndpointForwardingTemplateBySubnet template, final MasterDatabaseBinding masterDatabaseBinding) {
+    public ListenableFuture<RpcResult<Void>> processForwardingAndSxpMasterDB(final EndpointForwardingTemplateBySubnet template, final MasterDatabaseBinding masterDBBinding) {
+        LOG.debug("processing ep-forwarding-template + sxpMasterDB entry: {} - {}",
+                masterDBBinding.getSecurityGroupTag(), masterDBBinding.getIpPrefix());
         // apply sxpMasterDB to policy template
-        final RegisterEndpointInput input = new RegisterEndpointInputBuilder()
+        final L3Address l3Address = buildL3Address(masterDBBinding.getIpPrefix());
+        final RegisterEndpointInput epInput = new RegisterEndpointInputBuilder()
                 .setNetworkContainment(template.getNetworkContainment())
+                .setL3Address(Collections.singletonList(l3Address))
                 .build();
 
-        // invoke service
-        return JdkFutureAdapters.listenInPoolThread(l3EndpointService.registerEndpoint(input));
+        return chainL3EPServiceIfEpAbsent(l3Address, epInput);
+    }
+
+    private L3Address buildL3Address(final IpPrefix ipPrefix) {
+        final String ipv4PrefixValue = ipPrefix.getIpv4Prefix().getValue();
+        final IpAddress ipv4Value = new IpAddress(new Ipv4Address(ipv4PrefixValue.replaceFirst("/.+", "")));
+        return new L3AddressBuilder()
+                .setIpAddress(ipv4Value)
+                .setL3Context(new L3ContextId(ipv4PrefixValue))
+                .build();
+    }
+
+    private CheckedFuture<Optional<EndpointL3>, ReadFailedException> findExistingEndPoint(final L3Address l3Address) {
+        EndpointL3Key epL3key = new EndpointL3Key(l3Address.getIpAddress(), l3Address.getL3Context());
+        final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+        final CheckedFuture<Optional<EndpointL3>, ReadFailedException> read = rTx.read(
+                LogicalDatastoreType.OPERATIONAL, IidFactory.l3EndpointIid(epL3key));
+        Futures.addCallback(read, SxpListenerUtil.createTxCloseCallback(rTx));
+        return read;
+    }
+
+    private ListenableFuture<RpcResult<Void>> chainL3EPServiceIfEpAbsent(final L3Address l3Address, final RegisterEndpointInput epInput) {
+        CheckedFuture<Optional<EndpointL3>, ReadFailedException> existingEndpointFuture = findExistingEndPoint(l3Address);
+
+        return Futures.transform(existingEndpointFuture, new AsyncFunction<Optional<EndpointL3>, RpcResult<Void>>() {
+            @Override
+            public ListenableFuture<RpcResult<Void>> apply(final Optional<EndpointL3> input) throws Exception {
+                final ListenableFuture<RpcResult<Void>> nextResult;
+                if (input == null || !input.isPresent()) {
+                    // invoke service
+                    return JdkFutureAdapters.listenInPoolThread(l3EndpointService.registerEndpoint(epInput));
+                } else {
+                    final String existingL3EpMsg = String.format("L3Endpoint for given key already exists: %s", l3Address);
+                    nextResult = Futures.immediateFailedFuture(new IllegalStateException(existingL3EpMsg));
+                }
+                return nextResult;
+            }
+        });
     }
 }
+

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java
index 65ce34eb912241c60d4a17e4ac029dc31aff9da1..42297bc98d00d7ecb78ce8acad21052fa83969e1 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java
@@ -33,7 +33,7 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  */
 public class EPForwardingTemplateDaoImpl implements DSAsyncDao<IpPrefix, EndpointForwardingTemplateBySubnet> {
 
-    public static final ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent());
+    private static final ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent());
     private final DataBroker dataBroker;
     private final SimpleCachedDao<IpPrefix, EndpointForwardingTemplateBySubnet> cachedDao;
 
@@ -73,7 +73,7 @@ public class EPForwardingTemplateDaoImpl implements DSAsyncDao<IpPrefix, Endpoin
                                 cachedDao.update(template.getIpPrefix(), template);
                             }
                         }
-                        return cachedDao.find(key);
+                        return lookup(cachedDao, key);
                     } else {
                         return Optional.absent();
                     }

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java
index de2f60f7044fc38a58a16d0975e52194c76cd3cd..5e20b7e4ef94ea68706510f02c381b445c4c1d26 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java
@@ -19,8 +19,8 @@ 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.sxp.mapper.api.DSAsyncDao;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgtKey;
@@ -32,6 +32,8 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  */
 public class EPPolicyTemplateDaoImpl implements DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt> {
 
+    private static final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent());
+
     private final DataBroker dataBroker;
     private final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> cachedDao;
 
@@ -46,6 +48,8 @@ public class EPPolicyTemplateDaoImpl implements DSAsyncDao<Sgt, EndpointPolicyTe
         final Optional<EndpointPolicyTemplateBySgt> cachedEndpointPolicyTemplateBySgtalue = lookup(cachedDao, key);
         if (cachedEndpointPolicyTemplateBySgtalue.isPresent()) {
             return Futures.immediateFuture(cachedEndpointPolicyTemplateBySgtalue);
+        } else if (!cachedDao.isEmpty()) {
+            return READ_FUTURE_ABSENT;
         } else {
             final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
             final CheckedFuture<Optional<EndpointPolicyTemplateBySgt>, ReadFailedException> read =

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImpl.java
index e2bf49988d3c95147ae430e7257f84ad018f901a..22fcf2df3cfa038501ccfea99299903367797923 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImpl.java
@@ -43,6 +43,7 @@ public class MasterDatabaseBindingDaoImpl implements DSAsyncDao<IpPrefix, Master
         ReadableByKey<Sgt, MasterDatabaseBinding> {
 
     private static final Logger LOG = LoggerFactory.getLogger(MasterDatabaseBindingDaoImpl.class);
+    private static final ListenableFuture<Optional<MasterDatabaseBinding>> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent());
 
     private final DataBroker dataBroker;
     private final SimpleCachedDao<IpPrefix, MasterDatabaseBinding> cachedDao;
@@ -58,6 +59,8 @@ public class MasterDatabaseBindingDaoImpl implements DSAsyncDao<IpPrefix, Master
         final Optional<MasterDatabaseBinding> cachedMasterDatabaseBinding = lookup(cachedDao, key);
         if (cachedMasterDatabaseBinding.isPresent()) {
             return Futures.immediateFuture(cachedMasterDatabaseBinding);
+        } else if (!cachedDao.isEmpty()) {
+            return READ_FUTURE_ABSENT;
         } else {
             final ListenableFuture<Void> cacheUpdatedFt = updateCache();
 

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java
index 83d021acc969340129f30725b234cdc3b1141dd9..0df3b95ee0795177b529882ac618febff9f0078d 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java
@@ -13,9 +13,7 @@ import com.google.common.util.concurrent.AsyncFunction;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
-import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
 import javax.annotation.Nonnull;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
@@ -32,7 +30,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controll
 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -87,15 +87,18 @@ public class EPForwardingTemplateListenerImpl implements EPTemplateListener<Endp
         final ListenableFuture<RpcResult<Void>> allRpcResult = Futures.transform(sxpMasterDbItemFuture, new AsyncFunction<Optional<MasterDatabaseBinding>, RpcResult<Void>>() {
             @Override
             public ListenableFuture<RpcResult<Void>> apply(final Optional<MasterDatabaseBinding> input) throws Exception {
-                if (input == null && input.isPresent()) {
+                final ListenableFuture<RpcResult<Void>> rpcResult;
+                if (input == null || !input.isPresent()) {
                     LOG.debug("no epForwardingTemplate available for sgt: {}", changeKey);
-                    throw new IllegalArgumentException("no epForwardingTemplate available");
+                    rpcResult = RpcResultBuilder.<Void>failed()
+                            .withError(RpcError.ErrorType.APPLICATION,
+                                    "no ip-sgt mapping in sxpMasterDB available for " + changeKey)
+                            .buildFuture();
                 } else {
-                    List<ListenableFuture<RpcResult<Void>>> resultBag = new ArrayList<>();
                     LOG.trace("processing sxpMasterDB event and epForwardingTemplate for sgt: {}", changeKey);
-                    final ListenableFuture<RpcResult<Void>> rpcResult = sxpMapperReactor.processForwardingAndSxpMasterDB(epForwardingTemplate, input.get());
-                    return rpcResult;
+                    rpcResult = sxpMapperReactor.processForwardingAndSxpMasterDB(epForwardingTemplate, input.get());
                 }
+                return rpcResult;
             }
         });
 

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java
index 6bd4a9d9b012b2b0559dfaceda4478ce10e09557..931ed602070676bf139ed6ddb1f7308a712c156d 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java
@@ -14,6 +14,7 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import javax.annotation.Nonnull;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@@ -31,7 +32,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -86,17 +89,24 @@ public class EPPolicyTemplateListenerImpl implements EPTemplateListener<Endpoint
         final ListenableFuture<List<RpcResult<Void>>> rpcResult = Futures.transform(sxpMasterDbItemFuture, new AsyncFunction<Collection<MasterDatabaseBinding>, List<RpcResult<Void>>>() {
             @Override
             public ListenableFuture<List<RpcResult<Void>>> apply(final Collection<MasterDatabaseBinding> input) throws Exception {
+                final ListenableFuture<List<RpcResult<Void>>> result;
                 if (input == null || input.isEmpty()) {
                     LOG.debug("no epPolicyTemplate available from sgt: {}", changeKey);
-                    throw new IllegalArgumentException("no epPolicyTemplate available");
+                    result = Futures.immediateFuture(Collections.singletonList(
+                            RpcResultBuilder.<Void>failed()
+                                    .withError(RpcError.ErrorType.APPLICATION,
+                                            "no ip-sgt mapping in sxpMasterDB available for " + changeKey)
+                                    .build()));
                 } else {
                     LOG.trace("processing sxpMasterDB event and epPolicyTemplate for sgt: {}", changeKey);
                     List<ListenableFuture<RpcResult<Void>>> allResults = new ArrayList<>(input.size());
                     for (MasterDatabaseBinding masterDBItem : input) {
-                            allResults.add(sxpMapperReactor.processPolicyAndSxpMasterDB(epPolicyTemplate, masterDBItem));
+                        allResults.add(sxpMapperReactor.processPolicyAndSxpMasterDB(epPolicyTemplate, masterDBItem));
                     }
-                    return Futures.successfulAsList(allResults);
+                    result = Futures.successfulAsList(allResults);
                 }
+
+                return result;
             }
         });
 

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java
index 7a03b45fd5b25223afa3baa2155fa03f41e5cec9..27a31910bf1f9d1f4965a4692e8c2983092bde5b 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java
@@ -24,6 +24,7 @@ import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSAsyncDao;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.MasterDatabaseBindingListener;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.ForwardingTemplateUtil;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.L3EPServiceUtil;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
@@ -36,7 +37,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.sxp.data
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -102,6 +105,13 @@ public class MasterDatabaseBindingListenerImpl implements MasterDatabaseBindingL
     }
 
     private void processWithEPForwardingTemplate(final IpPrefix changeKey, final MasterDatabaseBinding sxpMasterDBItem) {
+        if (!ForwardingTemplateUtil.isPlain(changeKey)) {
+            // SKIP SUBNET
+            LOG.debug("received ip-sgt binding with subnet ip - SKIPPING: {} - {}",
+                    changeKey, sxpMasterDBItem.getSecurityGroupTag());
+            return;
+        }
+
         final ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> epForwardingTemplateFuture =
                 epForwardingTemplateDao.read(changeKey);
 
@@ -127,13 +137,18 @@ public class MasterDatabaseBindingListenerImpl implements MasterDatabaseBindingL
         final ListenableFuture<RpcResult<Void>> rpcResult = Futures.transform(epPolicyTemplateFuture, new AsyncFunction<Optional<EndpointPolicyTemplateBySgt>, RpcResult<Void>>() {
             @Override
             public ListenableFuture<RpcResult<Void>> apply(final Optional<EndpointPolicyTemplateBySgt> input) throws Exception {
+                final ListenableFuture<RpcResult<Void>> result;
                 if (input == null || !input.isPresent()) {
                     LOG.debug("no epPolicyTemplate available for sgt: {}", changeKey);
-                    throw new IllegalArgumentException("no epPolicyTemplate available");
+                    result = RpcResultBuilder.<Void>failed()
+                                    .withError(RpcError.ErrorType.APPLICATION,
+                                            "no ip-sgt mapping in sxpMasterDB available for " + changeKey)
+                                    .buildFuture();
                 } else {
                     LOG.trace("processing sxpMasterDB event and epPolicyTemplate for sgt: {}", changeKey);
-                    return sxpMapperReactor.processPolicyAndSxpMasterDB(input.get(), sxpMasterDBItem);
+                    result = sxpMapperReactor.processPolicyAndSxpMasterDB(input.get(), sxpMasterDBItem);
                 }
+                return result;
             }
         });
 

diff --git a/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImplTest.java b/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImplTest.java
index 3c7af75e4b890bc4beb0f7e1c268ffd756723444..0ee6f4d1d693f2e294e72ca976be7cbad7288de7 100644 (file)
--- a/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImplTest.java
+++ b/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImplTest.java
@@ -7,6 +7,8 @@
  */
 package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
 
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -15,11 +17,18 @@ import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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.inet.types.rev100924.Ipv4Prefix;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 
 /**
@@ -28,6 +37,8 @@ import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 @RunWith(MockitoJUnitRunner.class)
 public class SxpMapperReactorImplTest {
 
+    private static final IpPrefix IP_PREFIX = new IpPrefix(new Ipv4Prefix("10.11.12.1/32"));
+
     @Mock
     private EndpointService l3EndpointService;
     @Mock
@@ -36,14 +47,22 @@ public class SxpMapperReactorImplTest {
     private MasterDatabaseBinding masterDBBinding;
     @Mock
     private EndpointForwardingTemplateBySubnet epForwardingTemplate;
+    @Mock
+    private DataBroker dataBroker;
+    @Mock
+    private ReadOnlyTransaction rTx;
 
     private SxpMapperReactorImpl sxpMapperReactor;
 
     @Before
     public void setUp() throws Exception {
-        sxpMapperReactor = new SxpMapperReactorImpl(l3EndpointService);
+        sxpMapperReactor = new SxpMapperReactorImpl(l3EndpointService, dataBroker);
         Mockito.when(l3EndpointService.registerEndpoint(Matchers.<RegisterEndpointInput>any()))
                 .thenReturn(RpcResultBuilder.<Void>success().buildFuture());
+        Mockito.when(masterDBBinding.getIpPrefix()).thenReturn(IP_PREFIX);
+        Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
+        Mockito.when(rTx.read(Matchers.same(LogicalDatastoreType.OPERATIONAL),
+                Matchers.<InstanceIdentifier<EndpointL3>>any())).thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
     }
 
     @After

diff --git a/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImplTest.java b/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImplTest.java
index a15a98b3f0e03608c086ffabc7c1098ff2250185..6dc1bb3449ce7ff7a2e8b903bacbde2405318a73 100644 (file)
--- a/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImplTest.java
+++ b/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImplTest.java
@@ -89,6 +89,7 @@ public class EPPolicyTemplateDaoImplTest {
     public void testRead_presentDS() throws Exception {
         Mockito.when(cachedDao.find(Matchers.<Sgt>any())).thenReturn(
                 Optional.<EndpointPolicyTemplateBySgt>absent());
+        Mockito.when(cachedDao.isEmpty()).thenReturn(true);
         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
         Mockito.when(rTx.read(Matchers.eq(LogicalDatastoreType.CONFIGURATION),
                 Matchers.<InstanceIdentifier<EndpointPolicyTemplateBySgt>>any())).thenReturn(

diff --git a/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImplTest.java b/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImplTest.java
index 024e1615d4ab6ea5319de0fd848f08c68fb073fe..f0d4c8df68ab57141f886b0a6e26347d8cd3cf96 100644 (file)
--- a/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImplTest.java
+++ b/sxp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/MasterDatabaseBindingDaoImplTest.java
@@ -118,6 +118,7 @@ public class MasterDatabaseBindingDaoImplTest {
         Mockito.when(cachedDao.find(Matchers.<IpPrefix>any())).thenReturn(
                 Optional.<MasterDatabaseBinding>absent(),
                 Optional.of(MASTER_DB_BINDING_VALUE));
+        Mockito.when(cachedDao.isEmpty()).thenReturn(true);
         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
         Mockito.when(rTx.read(Matchers.eq(LogicalDatastoreType.CONFIGURATION),
                 Matchers.<InstanceIdentifier<Topology>>any())).thenReturn(