From 4b62a12b5b3d64d8a1ec66b485814f9d0b6f2532 Mon Sep 17 00:00:00 2001 From: Michal Rehak Date: Tue, 26 Apr 2016 16:30:42 +0200 Subject: [PATCH] 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 --- .../mapper/impl/SxpMapperProviderImpl.java | 2 +- .../sxp/mapper/impl/SxpMapperReactorImpl.java | 91 +++++++++++++++++-- .../impl/dao/EPForwardingTemplateDaoImpl.java | 4 +- .../impl/dao/EPPolicyTemplateDaoImpl.java | 6 +- .../dao/MasterDatabaseBindingDaoImpl.java | 3 + .../EPForwardingTemplateListenerImpl.java | 17 ++-- .../listen/EPPolicyTemplateListenerImpl.java | 16 +++- .../MasterDatabaseBindingListenerImpl.java | 19 +++- .../mapper/impl/SxpMapperReactorImplTest.java | 21 ++++- .../impl/dao/EPPolicyTemplateDaoImplTest.java | 1 + .../dao/MasterDatabaseBindingDaoImplTest.java | 1 + 11 files changed, 154 insertions(+), 27 deletions(-) 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 1e6fd913e..712e72dc7 100644 --- 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 epPolicyTemplateCachedDao = new SimpleCachedDaoImpl<>(); final SimpleCachedDao 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 8ed0329b8..861c1aa5b 100644 --- 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> processPolicyAndSxpMasterDB(final EndpointPolicyTemplateBySgt template, final MasterDatabaseBinding masterDatabaseBinding) { + public ListenableFuture> 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> processForwardingAndSxpMasterDB(final EndpointForwardingTemplateBySubnet template, final MasterDatabaseBinding masterDatabaseBinding) { + public ListenableFuture> 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, ReadFailedException> findExistingEndPoint(final L3Address l3Address) { + EndpointL3Key epL3key = new EndpointL3Key(l3Address.getIpAddress(), l3Address.getL3Context()); + final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); + final CheckedFuture, ReadFailedException> read = rTx.read( + LogicalDatastoreType.OPERATIONAL, IidFactory.l3EndpointIid(epL3key)); + Futures.addCallback(read, SxpListenerUtil.createTxCloseCallback(rTx)); + return read; + } + + private ListenableFuture> chainL3EPServiceIfEpAbsent(final L3Address l3Address, final RegisterEndpointInput epInput) { + CheckedFuture, ReadFailedException> existingEndpointFuture = findExistingEndPoint(l3Address); + + return Futures.transform(existingEndpointFuture, new AsyncFunction, RpcResult>() { + @Override + public ListenableFuture> apply(final Optional input) throws Exception { + final ListenableFuture> 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 65ce34eb9..42297bc98 100644 --- 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 { - public static final ListenableFuture> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent()); + private static final ListenableFuture> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent()); private final DataBroker dataBroker; private final SimpleCachedDao cachedDao; @@ -73,7 +73,7 @@ public class EPForwardingTemplateDaoImpl implements DSAsyncDao { + private static final ListenableFuture> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent()); + private final DataBroker dataBroker; private final SimpleCachedDao cachedDao; @@ -46,6 +48,8 @@ public class EPPolicyTemplateDaoImpl implements DSAsyncDao 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, 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 e2bf49988..22fcf2df3 100644 --- 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 { private static final Logger LOG = LoggerFactory.getLogger(MasterDatabaseBindingDaoImpl.class); + private static final ListenableFuture> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent()); private final DataBroker dataBroker; private final SimpleCachedDao cachedDao; @@ -58,6 +59,8 @@ public class MasterDatabaseBindingDaoImpl implements DSAsyncDao cachedMasterDatabaseBinding = lookup(cachedDao, key); if (cachedMasterDatabaseBinding.isPresent()) { return Futures.immediateFuture(cachedMasterDatabaseBinding); + } else if (!cachedDao.isEmpty()) { + return READ_FUTURE_ABSENT; } else { final ListenableFuture 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 83d021acc..0df3b95ee 100644 --- 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> allRpcResult = Futures.transform(sxpMasterDbItemFuture, new AsyncFunction, RpcResult>() { @Override public ListenableFuture> apply(final Optional input) throws Exception { - if (input == null && input.isPresent()) { + final ListenableFuture> rpcResult; + if (input == null || !input.isPresent()) { LOG.debug("no epForwardingTemplate available for sgt: {}", changeKey); - throw new IllegalArgumentException("no epForwardingTemplate available"); + rpcResult = RpcResultBuilder.failed() + .withError(RpcError.ErrorType.APPLICATION, + "no ip-sgt mapping in sxpMasterDB available for " + changeKey) + .buildFuture(); } else { - List>> resultBag = new ArrayList<>(); LOG.trace("processing sxpMasterDB event and epForwardingTemplate for sgt: {}", changeKey); - final ListenableFuture> 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 6bd4a9d9b..931ed6020 100644 --- 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>> rpcResult = Futures.transform(sxpMasterDbItemFuture, new AsyncFunction, List>>() { @Override public ListenableFuture>> apply(final Collection input) throws Exception { + final ListenableFuture>> 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.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>> 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 7a03b45fd..27a31910b 100644 --- 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> epForwardingTemplateFuture = epForwardingTemplateDao.read(changeKey); @@ -127,13 +137,18 @@ public class MasterDatabaseBindingListenerImpl implements MasterDatabaseBindingL final ListenableFuture> rpcResult = Futures.transform(epPolicyTemplateFuture, new AsyncFunction, RpcResult>() { @Override public ListenableFuture> apply(final Optional input) throws Exception { + final ListenableFuture> result; if (input == null || !input.isPresent()) { LOG.debug("no epPolicyTemplate available for sgt: {}", changeKey); - throw new IllegalArgumentException("no epPolicyTemplate available"); + result = RpcResultBuilder.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 3c7af75e4..0ee6f4d1d 100644 --- 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.any())) .thenReturn(RpcResultBuilder.success().buildFuture()); + Mockito.when(masterDBBinding.getIpPrefix()).thenReturn(IP_PREFIX); + Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx); + Mockito.when(rTx.read(Matchers.same(LogicalDatastoreType.OPERATIONAL), + Matchers.>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 a15a98b3f..6dc1bb344 100644 --- 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.any())).thenReturn( Optional.absent()); + Mockito.when(cachedDao.isEmpty()).thenReturn(true); Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx); Mockito.when(rTx.read(Matchers.eq(LogicalDatastoreType.CONFIGURATION), Matchers.>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 024e1615d..f0d4c8df6 100644 --- 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.any())).thenReturn( Optional.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.>any())).thenReturn( -- 2.36.6