<artifactId>mockito-all</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-log4j12</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
/**
* apply sgt/ip binding on policy template and delegate to appropriate GBP service
- * @param epPolicyTemplate template
+ * @param epPolicyTemplate policy template
+ * @param epForwardingTemplate forwarding template
* @param masterDatabaseBinding sxpMasterDB item
*/
- ListenableFuture<RpcResult<Void>> processPolicyAndSxpMasterDB(EndpointPolicyTemplateBySgt epPolicyTemplate, MasterDatabaseBinding masterDatabaseBinding);
-
- /**
- * apply sgt/ip binding on forwarding template and delegate to appropriate GBP service
- * @param epForwardingTemplate template
- * @param masterDatabaseBinding sxpMasterDB item
- */
- ListenableFuture<RpcResult<Void>> processForwardingAndSxpMasterDB(EndpointForwardingTemplateBySubnet epForwardingTemplate, MasterDatabaseBinding masterDatabaseBinding);
+ ListenableFuture<RpcResult<Void>> processTemplatesAndSxpMasterDB(EndpointPolicyTemplateBySgt epPolicyTemplate,
+ EndpointForwardingTemplateBySubnet epForwardingTemplate,
+ MasterDatabaseBinding masterDatabaseBinding);
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
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.api.SxpMapperReactor;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.SimpleCachedDaoEPForwardingTemplateImpl;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.SimpleCachedDaoImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EPForwardingTemplateDaoImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EPPolicyTemplateDaoImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.MasterDatabaseBindingDaoImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.SimpleCachedDaoEPForwardingTemplateImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.SimpleCachedDaoImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen.EPForwardingTemplateListenerImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen.EPPolicyTemplateListenerImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen.MasterDatabaseBindingListenerImpl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.BaseEndpointService;
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.Sgt;
this.dataBrokerDependency = dataBroker;
this.rpcRegistryDependency = rpcRegistryDependency;
- final EndpointService endpointService = rpcRegistryDependency.getRpcService(EndpointService.class);
+ final BaseEndpointService endpointService = rpcRegistryDependency.getRpcService(BaseEndpointService.class);
sxpMapperReactor = new SxpMapperReactorImpl(endpointService, dataBroker);
final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao = new SimpleCachedDaoImpl<>();
sxpDatabaseListener = new MasterDatabaseBindingListenerImpl(dataBroker, sxpMapperReactor, masterDBBindingCachedDao,
epPolicyTemplateDao, epForwardingTemplateDao);
epPolicyTemplateListener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao,
- masterDBBindingDao);
+ masterDBBindingDao, epForwardingTemplateDao);
epForwardingTemplateListener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapperReactor, epForwardingTemplateCachedDao,
- masterDBBindingDao);
+ masterDBBindingDao, epPolicyTemplateDao);
LOG.info("started SxmMapper");
}
- // register listeners to ip/sgt and EP-templates (by SGT, by subnet) -> 3x
- // exclusively write L3-EP to DS upon DataChangeEvent
-
@Override
public void close() throws Exception {
//TODO: stub
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.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.BaseEndpointService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.RegisterEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.RegisterEndpointInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.endpoints.AddressEndpointsByContainment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.endpoints.AddressEndpointsByContainmentKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.endpoints.address.endpoints.by.containment.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.endpoints.address.endpoints.by.containment.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.register.endpoint.input.AddressEndpointBuilder;
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.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(SxpMapperReactorImpl.class);
- private final EndpointService l3EndpointService;
+ private final BaseEndpointService l3EndpointService;
private final DataBroker dataBroker;
- public SxpMapperReactorImpl(final EndpointService l3EndpointService, final DataBroker dataBroker) {
+ public SxpMapperReactorImpl(final BaseEndpointService 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 masterDBBinding) {
- LOG.debug("processing ep-policy-template + sxpMasterDB entry: {} - {}",
+ public ListenableFuture<RpcResult<Void>> processTemplatesAndSxpMasterDB(
+ final EndpointPolicyTemplateBySgt epPolicyTemplate,
+ final EndpointForwardingTemplateBySubnet epForwardingTemplate,
+ final MasterDatabaseBinding masterDBBinding) {
+ LOG.debug("processing ep-templates + sxpMasterDB entry: {} - {}",
masterDBBinding.getSecurityGroupTag(), masterDBBinding.getIpPrefix());
// apply sxpMasterDB to policy template
- final L3Address l3Address = buildL3Address(masterDBBinding.getIpPrefix());
+ final Ipv4Prefix address = new Ipv4Prefix(epForwardingTemplate.getIpPrefix().getIpv4Prefix().getValue());
final RegisterEndpointInput epInput = new RegisterEndpointInputBuilder()
- .setCondition(template.getConditions())
- .setTenant(template.getTenant())
- .setEndpointGroups(template.getEndpointGroups())
- .setL3Address(Collections.singletonList(l3Address))
+ .setAddressEndpoint(Collections.singletonList(new AddressEndpointBuilder()
+ .setNetworkContainment(epForwardingTemplate.getNetworkContainment())
+ .setCondition(epPolicyTemplate.getConditions())
+ .setTenant(epPolicyTemplate.getTenant())
+ .setContainment(epForwardingTemplate.getL3Context())
+ .setEndpointGroup(epPolicyTemplate.getEndpointGroups())
+ .setAddress(address)
+ .build()))
.build();
+ epForwardingTemplate.getL3Context();
- return chainL3EPServiceIfEpAbsent(l3Address, epInput);
+ return chainL3EPServiceIfEpAbsent(epInput);
}
- @Override
- 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 L3Address l3Address = buildL3Address(masterDBBinding.getIpPrefix());
- final RegisterEndpointInput epInput = new RegisterEndpointInputBuilder()
- .setNetworkContainment(template.getNetworkContainment())
- .setL3Address(Collections.singletonList(l3Address))
- .build();
-
- 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());
+ private CheckedFuture<Optional<AddressEndpoint>, ReadFailedException> findExistingEndPoint(final ContextId containment,
+ final Address address) {
+ KeyedInstanceIdentifier<AddressEndpoint, AddressEndpointKey> addressEndpointPath =
+ InstanceIdentifier.create(Endpoints.class)
+ .child(AddressEndpointsByContainment.class, new AddressEndpointsByContainmentKey(containment))
+ .child(AddressEndpoint.class, new AddressEndpointKey(address));
final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
- final CheckedFuture<Optional<EndpointL3>, ReadFailedException> read = rTx.read(
- LogicalDatastoreType.OPERATIONAL, IidFactory.l3EndpointIid(epL3key));
+ final CheckedFuture<Optional<AddressEndpoint>, ReadFailedException> read = rTx.read(
+ LogicalDatastoreType.OPERATIONAL, addressEndpointPath);
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);
+ private ListenableFuture<RpcResult<Void>> chainL3EPServiceIfEpAbsent(final RegisterEndpointInput epInput) {
+ final org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.register.endpoint.input.AddressEndpoint addressEndpoint = epInput.getAddressEndpoint().get(0);
+ CheckedFuture<Optional<AddressEndpoint>, ReadFailedException> existingEndpointFuture =
+ findExistingEndPoint(addressEndpoint.getContainment(), addressEndpoint.getAddress());
- return Futures.transform(existingEndpointFuture, new AsyncFunction<Optional<EndpointL3>, RpcResult<Void>>() {
+ return Futures.transform(existingEndpointFuture, new AsyncFunction<Optional<AddressEndpoint>, RpcResult<Void>>() {
@Override
- public ListenableFuture<RpcResult<Void>> apply(final Optional<EndpointL3> input) throws Exception {
+ public ListenableFuture<RpcResult<Void>> apply(final Optional<AddressEndpoint> 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);
+ final String existingL3EpMsg = String.format("address-endpoint for given key already exists: %s | %s",
+ addressEndpoint.getContainment(), addressEndpoint.getAddress() );
nextResult = Futures.immediateFailedFuture(new IllegalStateException(existingL3EpMsg));
}
return nextResult;
}
});
}
+
}
import javax.annotation.Nullable;
import org.apache.commons.net.util.SubnetUtils;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.ForwardingTemplateUtil;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.EPTemplateUtil;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SubnetInfoKeyDecorator;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
@Override
public EndpointForwardingTemplateBySubnet update(@Nonnull final IpPrefix key, @Nullable final EndpointForwardingTemplateBySubnet value) {
final EndpointForwardingTemplateBySubnet previousValue;
- if (ForwardingTemplateUtil.isPlain(key)) {
+ if (EPTemplateUtil.isPlain(key)) {
previousValue = updatePlainCache(key, value);
} else {
previousValue = updateSubnetCache(key, value);
private EndpointForwardingTemplateBySubnet updateSubnetCache(final IpPrefix key, final EndpointForwardingTemplateBySubnet value) {
final EndpointForwardingTemplateBySubnet previousValue;
- final SubnetInfoKeyDecorator subnetKey = ForwardingTemplateUtil.buildSubnetInfoKey(key);
+ final SubnetInfoKeyDecorator subnetKey = EPTemplateUtil.buildSubnetInfoKey(key);
if (value != null) {
previousValue = subnetCache.put(subnetKey, value);
} else {
@Override
public Optional<EndpointForwardingTemplateBySubnet> find(@Nonnull final IpPrefix key) {
final Optional<EndpointForwardingTemplateBySubnet> template;
- if (ForwardingTemplateUtil.isPlain(key)) {
+ if (EPTemplateUtil.isPlain(key)) {
final Optional<EndpointForwardingTemplateBySubnet> fastPlain = Optional.fromNullable(plainCache.get(key));
if (fastPlain.isPresent()) {
template = fastPlain;
template = lookupSlowSubnet(key.getIpv4Prefix().getValue());
}
} else {
- final SubnetInfoKeyDecorator keyDecorator = ForwardingTemplateUtil.buildSubnetInfoKey(key);
+ final SubnetInfoKeyDecorator keyDecorator = EPTemplateUtil.buildSubnetInfoKey(key);
final Optional<EndpointForwardingTemplateBySubnet> fastSubnet =
Optional.fromNullable(subnetCache.get(keyDecorator));
if (fastSubnet.isPresent()) {
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import javax.annotation.Nonnull;
+import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.EPTemplateUtil;
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;
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.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;
private final DSAsyncDao<IpPrefix, MasterDatabaseBinding> masterDBBindingDao;
private final ListenerRegistration<? extends EPTemplateListener> listenerRegistration;
private final InstanceIdentifier<EndpointForwardingTemplateBySubnet> templatePath;
+ private final DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao;
public EPForwardingTemplateListenerImpl(final DataBroker dataBroker,
final SxpMapperReactor sxpMapperReactor,
final SimpleCachedDao<IpPrefix, EndpointForwardingTemplateBySubnet> templateCachedDao,
- final DSAsyncDao<IpPrefix, MasterDatabaseBinding> masterDBBindingDao) {
+ final DSAsyncDao<IpPrefix, MasterDatabaseBinding> masterDBBindingDao,
+ final DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao) {
this.sxpMapperReactor = Preconditions.checkNotNull(sxpMapperReactor);
this.templateCachedDao = Preconditions.checkNotNull(templateCachedDao);
this.masterDBBindingDao = Preconditions.checkNotNull(masterDBBindingDao);
+ this.epPolicyTemplateDao = Preconditions.checkNotNull(epPolicyTemplateDao);
templatePath = EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH.child(EndpointForwardingTemplateBySubnet.class);
final DataTreeIdentifier<EndpointForwardingTemplateBySubnet> dataTreeIdentifier = new DataTreeIdentifier<>(
SxpListenerUtil.updateCachedDao(templateCachedDao, changeKey, change);
final EndpointForwardingTemplateBySubnet epForwardingTemplate = change.getRootNode().getDataAfter();
- processWithSxpMasterDB(changeKey, epForwardingTemplate);
+ processWithEPTemplates(epForwardingTemplate);
}
}
- private void processWithSxpMasterDB(final IpPrefix changeKey, final EndpointForwardingTemplateBySubnet epForwardingTemplate) {
- final ListenableFuture<Optional<MasterDatabaseBinding>> sxpMasterDbItemFuture = masterDBBindingDao.read(changeKey);
+ private void processWithEPTemplates(final EndpointForwardingTemplateBySubnet epForwardingTemplate) {
+ final ListenableFuture<Optional<MasterDatabaseBinding>> sxpMasterDbItemRead =
+ masterDBBindingDao.read(epForwardingTemplate.getIpPrefix());
- final ListenableFuture<RpcResult<Void>> allRpcResult = Futures.transform(sxpMasterDbItemFuture, new AsyncFunction<Optional<MasterDatabaseBinding>, RpcResult<Void>>() {
+ // find all available epForwardingTemplates and pair those to sxpMasterDBBinding
+ final ListenableFuture<Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>>> searchResult =
+ Futures.transform(sxpMasterDbItemRead, createReadAndPairTemplateToBindingFunction(epForwardingTemplate));
+
+ // invoke sxpMapperReactor.process for every valid combination of sxpMasterDBBinding, epPolicyTemplate, epForwardingTemplate
+ final ListenableFuture<RpcResult<Void>> rpcResult =
+ Futures.transform(searchResult, createProcessAllFunction(epForwardingTemplate));
+
+ Futures.addCallback(rpcResult, ANY_RPC_FUTURE_CALLBACK);
+ }
+
+ private AsyncFunction<Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>>, RpcResult<Void>>
+ createProcessAllFunction(final EndpointForwardingTemplateBySubnet epForwardingTemplate) {
+ return new AsyncFunction<Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>>, RpcResult<Void>>() {
@Override
- public ListenableFuture<RpcResult<Void>> apply(final Optional<MasterDatabaseBinding> input) throws Exception {
- final ListenableFuture<RpcResult<Void>> rpcResult;
+ public ListenableFuture<RpcResult<Void>>
+ apply(final Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>> input) throws Exception {
+ final ListenableFuture<RpcResult<Void>> result;
if (input == null || !input.isPresent()) {
- LOG.debug("no epForwardingTemplate available for sgt: {}", changeKey);
- rpcResult = RpcResultBuilder.<Void>failed()
- .withError(RpcError.ErrorType.APPLICATION,
- "no ip-sgt mapping in sxpMasterDB available for " + changeKey)
- .buildFuture();
+ LOG.debug("no epPolicyTemplate available for ip-prefix: {}", epForwardingTemplate.getIpPrefix());
+ result = Futures.immediateFuture(
+ RpcResultBuilder.<Void>failed()
+ .withError(RpcError.ErrorType.APPLICATION,
+ "no epForwardingTemplate available for ip-prefix " + epForwardingTemplate.getIpPrefix())
+ .build());
} else {
- LOG.trace("processing sxpMasterDB event and epForwardingTemplate for sgt: {}", changeKey);
- rpcResult = sxpMapperReactor.processForwardingAndSxpMasterDB(epForwardingTemplate, input.get());
+ LOG.trace("processing epForwardingTemplate event for ip-prefix: {}", epForwardingTemplate.getIpPrefix());
+ final Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt> pair = input.get();
+ final MasterDatabaseBinding sxpMasterDBBinding = pair.getLeft();
+ final EndpointPolicyTemplateBySgt epPolicyTemplate = pair.getRight();
+ LOG.trace("processing epForwardingTemplate event with resolved sxpMasterDb entry and " +
+ "epPolicyTemplate for sgt/ip-prefix: {}/{}",
+ sxpMasterDBBinding.getSecurityGroupTag(), sxpMasterDBBinding.getImplementedInterface());
+ result = sxpMapperReactor.processTemplatesAndSxpMasterDB(epPolicyTemplate, epForwardingTemplate, sxpMasterDBBinding);
}
- return rpcResult;
+
+ return result;
}
- });
+ };
+ }
- Futures.addCallback(allRpcResult, ANY_RPC_FUTURE_CALLBACK);
+ private AsyncFunction<Optional<MasterDatabaseBinding>, Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>>>
+ createReadAndPairTemplateToBindingFunction(final EndpointForwardingTemplateBySubnet epFowardingTemplate) {
+ return new AsyncFunction<Optional<MasterDatabaseBinding>, Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>>>() {
+ @Override
+ public ListenableFuture<Optional<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>>>
+ apply(final Optional<MasterDatabaseBinding> input) throws Exception {
+ final ListenableFuture<Pair<MasterDatabaseBinding, EndpointPolicyTemplateBySgt>> result;
+ if (input == null || !input.isPresent()) {
+ LOG.debug("no sxpMasterDB entry available for ip-prefix: {}", epFowardingTemplate.getIpPrefix());
+ result = Futures.immediateFuture(null);
+ } else {
+ LOG.trace("processing sxpMasterDB entry for ip-prefix: {}", epFowardingTemplate.getIpPrefix());
+ final MasterDatabaseBinding masterDBItem = input.get();
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> epPolicyTemplateRead =
+ epPolicyTemplateDao.read(masterDBItem.getSecurityGroupTag());
+ result = EPTemplateUtil.wrapToPair(masterDBItem, epPolicyTemplateRead);
+ }
+
+ return EPTemplateUtil.wrapToOptional(result);
+ }
+ };
}
+
@Override
public void close() throws Exception {
LOG.debug("closing listener registration to {}", templatePath);
*/
package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen;
+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.FutureCallback;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
+import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSAsyncDao;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableByKey;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.EPTemplateUtil;
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;
+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.Sgt;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
private final SxpMapperReactor sxpMapperReactor;
private final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> templateCachedDao;
private final ReadableByKey<Sgt, MasterDatabaseBinding> masterDBBindingDao;
+ private final DSAsyncDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao;
public EPPolicyTemplateListenerImpl(final DataBroker dataBroker,
final SxpMapperReactor sxpMapperReactor,
final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> templateCachedDao,
- final ReadableByKey<Sgt, MasterDatabaseBinding> masterDBBindingDao) {
+ final ReadableByKey<Sgt, MasterDatabaseBinding> masterDBBindingDao,
+ final DSAsyncDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao) {
this.sxpMapperReactor = Preconditions.checkNotNull(sxpMapperReactor);
this.templateCachedDao = Preconditions.checkNotNull(templateCachedDao);
this.masterDBBindingDao = Preconditions.checkNotNull(masterDBBindingDao);
+ this.epForwardingTemplateDao = Preconditions.checkNotNull(epForwardingTemplateDao);
templatePath = EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH.child(EndpointPolicyTemplateBySgt.class);
final DataTreeIdentifier<EndpointPolicyTemplateBySgt> dataTreeIdentifier = new DataTreeIdentifier<>(
SxpListenerUtil.updateCachedDao(templateCachedDao, changeKey, change);
final EndpointPolicyTemplateBySgt epPolicyTemplate = change.getRootNode().getDataAfter();
- processWithSxpMasterDB(changeKey, epPolicyTemplate);
+ processWithEPTemplates(epPolicyTemplate);
}
}
- private void processWithSxpMasterDB(final Sgt changeKey, final EndpointPolicyTemplateBySgt epPolicyTemplate) {
- final ListenableFuture<Collection<MasterDatabaseBinding>> sxpMasterDbItemFuture = masterDBBindingDao.readBy(changeKey);
- final ListenableFuture<List<RpcResult<Void>>> rpcResult = Futures.transform(sxpMasterDbItemFuture, new AsyncFunction<Collection<MasterDatabaseBinding>, List<RpcResult<Void>>>() {
+ private void processWithEPTemplates(final EndpointPolicyTemplateBySgt epPolicyTemplate) {
+ final ListenableFuture<Collection<MasterDatabaseBinding>> sxpMasterDbItemsRead =
+ masterDBBindingDao.readBy(epPolicyTemplate.getSgt());
+
+ // find all available epForwardingTemplates and pair those to sxpMasterDBBinding
+ final ListenableFuture<List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>> epForwardingTemplatesRead =
+ Futures.transform(sxpMasterDbItemsRead, createReadAndPairTemplateToBindingFunction(epPolicyTemplate));
+
+ // invoke sxpMapperReactor.process for every valid combination of sxpMasterDBBinding, epPolicyTemplate, epForwardingTemplate
+ final ListenableFuture<List<RpcResult<Void>>> rpcResult =
+ Futures.transform(epForwardingTemplatesRead, createProcessAllFunction(epPolicyTemplate));
+
+ Futures.addCallback(rpcResult, RPC_RESULT_FUTURE_CALLBACK);
+ }
+
+ private AsyncFunction<List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>, List<RpcResult<Void>>>
+ createProcessAllFunction(final EndpointPolicyTemplateBySgt epPolicyTemplate) {
+ return new AsyncFunction<List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>, List<RpcResult<Void>>>() {
@Override
- public ListenableFuture<List<RpcResult<Void>>> apply(final Collection<MasterDatabaseBinding> input) throws Exception {
+ public ListenableFuture<List<RpcResult<Void>>>
+ apply(final List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>> input) throws Exception {
final ListenableFuture<List<RpcResult<Void>>> result;
if (input == null || input.isEmpty()) {
- LOG.debug("no epPolicyTemplate available from sgt: {}", changeKey);
+ LOG.debug("no epForwardingTemplate available for sgt: {}", epPolicyTemplate.getSgt());
result = Futures.immediateFuture(Collections.singletonList(
RpcResultBuilder.<Void>failed()
.withError(RpcError.ErrorType.APPLICATION,
- "no ip-sgt mapping in sxpMasterDB available for " + changeKey)
+ "no epForwardingTemplate available for sgt " + epPolicyTemplate.getSgt())
.build()));
} else {
- LOG.trace("processing sxpMasterDB event and epPolicyTemplate for sgt: {}", changeKey);
+ LOG.trace("processing epPolicyTemplate event for sgt: {}", epPolicyTemplate.getSgt());
List<ListenableFuture<RpcResult<Void>>> allResults = new ArrayList<>(input.size());
- for (MasterDatabaseBinding masterDBItem : input) {
- allResults.add(sxpMapperReactor.processPolicyAndSxpMasterDB(epPolicyTemplate, masterDBItem));
+ for (Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet> pair : input) {
+ final MasterDatabaseBinding sxpMasterDBBinding = pair.getLeft();
+ final EndpointForwardingTemplateBySubnet epForwardingTemplate = pair.getRight();
+ if (epForwardingTemplate != null) {
+ LOG.trace("processing epPolicyTemplate event with resolved sxpMasterDb entry and " +
+ "epForwardingTemplate for sgt/ip-prefix: {}/{}",
+ sxpMasterDBBinding.getSecurityGroupTag(), sxpMasterDBBinding.getImplementedInterface());
+ allResults.add(sxpMapperReactor.processTemplatesAndSxpMasterDB(
+ epPolicyTemplate, epForwardingTemplate, sxpMasterDBBinding));
+ }
}
result = Futures.successfulAsList(allResults);
}
return result;
}
- });
+};
+ }
- Futures.addCallback(rpcResult, RPC_RESULT_FUTURE_CALLBACK);
+ private AsyncFunction<Collection<MasterDatabaseBinding>, List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>>
+ createReadAndPairTemplateToBindingFunction(final EndpointPolicyTemplateBySgt epPolicyTemplate) {
+ return new AsyncFunction<Collection<MasterDatabaseBinding>, List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>>() {
+ @Override
+ public ListenableFuture<List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>>
+ apply(final Collection<MasterDatabaseBinding> input) throws Exception {
+ final ListenableFuture<List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>> result;
+ if (input == null || input.isEmpty()) {
+ LOG.debug("no sxpMasterDB entry available for sgt: {}", epPolicyTemplate.getSgt());
+ result = Futures.immediateFuture(Collections.emptyList());
+ } else {
+ LOG.trace("processing sxpMasterDB entries for sgt: {}", epPolicyTemplate.getSgt());
+ List<ListenableFuture<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>> allResults =
+ new ArrayList<>(input.size());
+ for (MasterDatabaseBinding masterDBItem : input) {
+ final ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> epForwardingTemplateRead =
+ epForwardingTemplateDao.read(masterDBItem.getIpPrefix());
+ allResults.add(EPTemplateUtil.wrapToPair(masterDBItem, epForwardingTemplateRead));
+ }
+ result = Futures.successfulAsList(allResults);
+ }
+
+ return result;
+ }
+ };
}
@Override
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.EPTemplateUtil;
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;
final MasterDatabaseBinding sxpMasterDBItem = change.getRootNode().getDataAfter();
if (sxpMasterDBItem == null) {
//TODO: cover sgt-ip mapping removal
+ LOG.debug("ip-sgt mapping was removed - NOOP: {}",
+ change.getRootPath().getRootIdentifier().firstKeyOf(MasterDatabaseBinding.class));
} else {
- final Sgt sgtKey = sxpMasterDBItem.getSecurityGroupTag();
final IpPrefix ipPrefixKey = sxpMasterDBItem.getIpPrefix();
SxpListenerUtil.updateCachedDao(masterDBBindingDaoCached, ipPrefixKey, change);
-
- processWithEPPolicyTemplate(sgtKey, sxpMasterDBItem);
- processWithEPForwardingTemplate(ipPrefixKey, sxpMasterDBItem);
+ processWithEPTemplates(sxpMasterDBItem);
}
}
}
- 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;
- }
+ private void processWithEPTemplates(final MasterDatabaseBinding sxpMasterDBItem) {
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> epPolicyTemplateFuture =
+ epPolicyTemplateDao.read(sxpMasterDBItem.getSecurityGroupTag());
final ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> epForwardingTemplateFuture =
- epForwardingTemplateDao.read(changeKey);
-
- final ListenableFuture<RpcResult<Void>> rpcResult = Futures.transform(epForwardingTemplateFuture, new AsyncFunction<Optional<EndpointForwardingTemplateBySubnet>, RpcResult<Void>>() {
- @Override
- public ListenableFuture<RpcResult<Void>> apply(final Optional<EndpointForwardingTemplateBySubnet> input) throws Exception {
- if (input == null || !input.isPresent()) {
- LOG.debug("no epForwardingTemplate available for ipPrefix: {}", changeKey);
- throw new IllegalArgumentException("no epForwardingTemplate available");
- } else {
- LOG.trace("processing sxpMasterDB event and epForwardingTemplate for ip-prefix: {}", changeKey);
- return sxpMapperReactor.processForwardingAndSxpMasterDB(input.get(), sxpMasterDBItem);
- }
- }
- });
- Futures.addCallback(rpcResult, RPC_FW_RESULT_FUTURE_CALLBACK);
- }
+ epForwardingTemplateDao.read(sxpMasterDBItem.getIpPrefix());
+
+ final ListenableFuture<EPTemplateUtil.OptionalMutablePair<EndpointPolicyTemplateBySgt, EndpointForwardingTemplateBySubnet>> compositeRead
+ = EPTemplateUtil.compositeRead(epPolicyTemplateFuture, epForwardingTemplateFuture);
+
+ final ListenableFuture<RpcResult<Void>> rpcResult = Futures.transform(compositeRead,
+ new AsyncFunction<EPTemplateUtil.OptionalMutablePair<EndpointPolicyTemplateBySgt, EndpointForwardingTemplateBySubnet>, RpcResult<Void>>() {
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(final EPTemplateUtil.OptionalMutablePair<EndpointPolicyTemplateBySgt, EndpointForwardingTemplateBySubnet> input) throws Exception {
+ final ListenableFuture<RpcResult<Void>> result;
+ if (input == null) {
+ LOG.debug("no ep*Templates available for sgt/ip-prefix: {}/{}",
+ sxpMasterDBItem.getSecurityGroupTag(),
+ sxpMasterDBItem.getIpPrefix());
+ result = RpcResultBuilder.<Void>failed()
+ .withError(RpcError.ErrorType.APPLICATION,
+ "no ep-templates available for" + sxpMasterDBItem)
+ .buildFuture();
- private void processWithEPPolicyTemplate(final Sgt changeKey, final MasterDatabaseBinding sxpMasterDBItem) {
- final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> epPolicyTemplateFuture =
- epPolicyTemplateDao.read(changeKey);
-
- 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);
- result = RpcResultBuilder.<Void>failed()
+ } else if (!input.getLeft().isPresent()) {
+ LOG.debug("no epPolicyTemplate available for sgt: {}", sxpMasterDBItem.getSecurityGroupTag());
+ result = RpcResultBuilder.<Void>failed()
+ .withError(RpcError.ErrorType.APPLICATION,
+ "no epPolicyTemplate available for " + sxpMasterDBItem)
+ .buildFuture();
+ } else if (!input.getRight().isPresent()) {
+ LOG.debug("no epForwardingTemplate available for ip-prefix: {}",
+ sxpMasterDBItem.getIpPrefix());
+ result = RpcResultBuilder.<Void>failed()
.withError(RpcError.ErrorType.APPLICATION,
- "no ip-sgt mapping in sxpMasterDB available for " + changeKey)
+ "no epForwardingTemplate available for " + sxpMasterDBItem)
.buildFuture();
- } else {
- LOG.trace("processing sxpMasterDB event and epPolicyTemplate for sgt: {}", changeKey);
- result = sxpMapperReactor.processPolicyAndSxpMasterDB(input.get(), sxpMasterDBItem);
+ } else {
+ LOG.trace("processing sxpMasterDB event and epPolicyTemplate for sgt/ip-prefix: {}/{}",
+ sxpMasterDBItem.getSecurityGroupTag(),
+ sxpMasterDBItem.getIpPrefix());
+ result = sxpMapperReactor.processTemplatesAndSxpMasterDB(input.getLeft().get(),
+ input.getRight().get(), sxpMasterDBItem);
}
return result;
}
--- /dev/null
+/**
+ * Copyright (c) 2016 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.sxp.mapper.impl.util;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.apache.commons.lang3.tuple.MutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.net.util.SubnetUtils;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.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;
+
+/**
+ * Purpose: util methods for {@link EndpointForwardingTemplateBySubnet} and {@link EndpointPolicyTemplateBySgt}
+ */
+public final class EPTemplateUtil {
+
+ public static final String FULL_IPV4_MASK_SUFFIX = "/32";
+
+ private EPTemplateUtil() {
+ throw new IllegalAccessError("constructing util class");
+ }
+
+ public static boolean isPlain(final IpPrefix key) {
+ return key.getIpv4Prefix().getValue().endsWith(FULL_IPV4_MASK_SUFFIX);
+ }
+
+ public static SubnetInfoKeyDecorator buildSubnetInfoKey(@Nonnull final IpPrefix value) {
+ return new SubnetInfoKeyDecorator(new SubnetUtils(value.getIpv4Prefix().getValue()).getInfo());
+ }
+
+ public static <L, R> ListenableFuture<OptionalMutablePair<L, R>> compositeRead(
+ final ListenableFuture<Optional<L>> leftRead, final ListenableFuture<Optional<R>> rightRead) {
+
+ final OptionalMutablePair<L, R> compositeResult = new OptionalMutablePair<>();
+ final List<ListenableFuture<?>> results = new ArrayList<>(2);
+
+ results.add(Futures.transform(leftRead, new Function<Optional<L>, OptionalMutablePair<L, R>>() {
+ @Nullable
+ @Override
+ public OptionalMutablePair<L, R> apply(@Nullable final Optional<L> input) {
+ compositeResult.setLeft(input);
+ return compositeResult;
+ }
+ }));
+
+ results.add(Futures.transform(rightRead, new Function<Optional<R>, OptionalMutablePair<L, R>>() {
+ @Nullable
+ @Override
+ public OptionalMutablePair<L, R> apply(@Nullable final Optional<R> input) {
+ compositeResult.setRight(input);
+ return compositeResult;
+ }
+ }));
+
+ return Futures.transform(Futures.successfulAsList(results),
+ new Function<List<?>, OptionalMutablePair<L, R>>() {
+ @Nullable
+ @Override
+ public OptionalMutablePair<L, R> apply(@Nullable final List<?> input) {
+ return compositeResult;
+ }
+ });
+ }
+
+ public static <K, V> ListenableFuture<Pair<K, V>> wrapToPair(
+ final K keyItem,
+ final ListenableFuture<Optional<V>> valueFromRead) {
+ return Futures.transform(valueFromRead, new Function<Optional<V>, Pair<K, V>>() {
+ @Nullable
+ @Override
+ public Pair<K, V> apply(@Nullable final Optional<V> input) {
+ final MutablePair<K, V> pair = new MutablePair<>(keyItem, null);
+ if (input != null && input.isPresent()) {
+ pair.setRight(input.get());
+ }
+ return pair;
+ }
+ });
+ }
+
+ public static <V> ListenableFuture<Optional<V>> wrapToOptional(final ListenableFuture<V> value) {
+ return Futures.transform(value, new Function<V, Optional<V>>() {
+ @Nullable
+ @Override
+ public Optional<V> apply(@Nullable final V input) {
+ return Optional.fromNullable(input);
+ }
+ });
+ }
+
+ public static class OptionalMutablePair<L, R> extends MutablePair<Optional<L>, Optional<R>> {
+ public OptionalMutablePair() {
+ super(Optional.absent(), Optional.absent());
+ }
+ }
+}
+++ /dev/null
-/**
- * Copyright (c) 2016 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.sxp.mapper.impl.util;
-
-import javax.annotation.Nonnull;
-import org.apache.commons.net.util.SubnetUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
-
-/**
- * Purpose: util methods for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet}
- */
-public final class ForwardingTemplateUtil {
-
- public static final String FULL_IPV4_MASK_SUFFIX = "/32";
-
- private ForwardingTemplateUtil() {
- throw new IllegalAccessError("constructing util class");
- }
-
- public static boolean isPlain(final IpPrefix key) {
- return key.getIpv4Prefix().getValue().endsWith(FULL_IPV4_MASK_SUFFIX);
- }
-
- public static SubnetInfoKeyDecorator buildSubnetInfoKey(@Nonnull final IpPrefix value) {
- return new SubnetInfoKeyDecorator(new SubnetUtils(value.getIpv4Prefix().getValue()).getInfo());
- }
-}
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.groupbasedpolicy.endpoints.rev160427.BaseEndpointService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.RegisterEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoints.rev160427.endpoints.address.endpoints.by.containment.AddressEndpoint;
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;
private static final IpPrefix IP_PREFIX = new IpPrefix(new Ipv4Prefix("10.11.12.1/32"));
@Mock
- private EndpointService l3EndpointService;
+ private BaseEndpointService l3EndpointService;
@Mock
private EndpointPolicyTemplateBySgt epPolicyTemplate;
@Mock
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()));
+ Matchers.<InstanceIdentifier<AddressEndpoint>>any())).thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
}
@After
}
@Test
- public void testProcessPolicyAndSxpMasterDB() throws Exception {
- sxpMapperReactor.processPolicyAndSxpMasterDB(epPolicyTemplate, masterDBBinding);
- Mockito.verify(l3EndpointService).registerEndpoint(Matchers.<RegisterEndpointInput>any());
- }
-
- @Test
- public void testProcessForwardingAndSxpMasterDB() throws Exception {
- sxpMapperReactor.processForwardingAndSxpMasterDB(epForwardingTemplate, masterDBBinding);
+ public void testProcessTemplatesAndSxpMasterDB() throws Exception {
+ Mockito.when(epForwardingTemplate.getIpPrefix()).thenReturn(IP_PREFIX);
+ sxpMapperReactor.processTemplatesAndSxpMasterDB(epPolicyTemplate, epForwardingTemplate, masterDBBinding);
Mockito.verify(l3EndpointService).registerEndpoint(Matchers.<RegisterEndpointInput>any());
}
}
\ No newline at end of file
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.EndpointForwardingTemplateBySubnetBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnetKey;
+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.EndpointPolicyTemplateBySgtBuilder;
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.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBindingBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
* Test for {@link EPForwardingTemplateListenerImpl}.
@Mock
private DSAsyncDao<IpPrefix, MasterDatabaseBinding> masterDBBindingDao;
@Mock
+ private DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao;
+ @Mock
private ListenerRegistration<? extends EPTemplateListener> listenerRegistration;
@Mock
private DataTreeModification<EndpointForwardingTemplateBySubnet> dataTreeModification;
private DataObjectModification<EndpointForwardingTemplateBySubnet> dataObjectModification;
private EPForwardingTemplateListenerImpl listener;
+ public static final Sgt SGT = new Sgt(1);
+ public static final EndpointPolicyTemplateBySgt EP_POLICY_TEMPLATE = new EndpointPolicyTemplateBySgtBuilder()
+ .setSgt(SGT)
+ .build();
public EPForwardingTemplateListenerImplTest() {
EP_FW_TEMPLATE_VALUE = new EndpointForwardingTemplateBySubnetBuilder()
public void setUp() throws Exception {
Mockito.when(dataBroker.registerDataTreeChangeListener(Matchers.<DataTreeIdentifier>any(),
Matchers.<DataTreeChangeListener>any())).thenReturn(listenerRegistration);
- listener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapper, simpleCachedDao, masterDBBindingDao);
+ listener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapper, simpleCachedDao, masterDBBindingDao, epPolicyTemplateDao);
}
@Test
Mockito.when(dataTreeModification.getRootPath()).thenReturn(TEMPLATE_TREE_PATH);
Mockito.when(dataObjectModification.getDataAfter()).thenReturn(EP_FW_TEMPLATE_VALUE);
- final Sgt sgt = new Sgt(1);
final IpPrefix ipPrefix = buildIpPrefix("1.2.3.4/32");
- final MasterDatabaseBinding prefixGroup = new MasterDatabaseBindingBuilder()
- .setSecurityGroupTag(sgt)
+ final MasterDatabaseBinding masterDBBinding = new MasterDatabaseBindingBuilder()
+ .setSecurityGroupTag(SGT)
.setIpPrefix(ipPrefix)
.build();
Mockito.when(masterDBBindingDao.read(Matchers.<IpPrefix>any())).thenReturn(
- Futures.immediateFuture(Optional.of(prefixGroup)));
+ Futures.immediateFuture(Optional.of(masterDBBinding)));
+ Mockito.when(epPolicyTemplateDao.read(Matchers.<Sgt>any())).thenReturn(
+ Futures.immediateFuture(Optional.of(EP_POLICY_TEMPLATE)));
+ Mockito.when(sxpMapper.processTemplatesAndSxpMasterDB(Matchers.<EndpointPolicyTemplateBySgt>any(),
+ Matchers.<EndpointForwardingTemplateBySubnet>any(),Matchers.<MasterDatabaseBinding>any())).thenReturn(
+ RpcResultBuilder.success((Void) null).buildFuture());
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- final InOrder inOrder = Mockito.inOrder(masterDBBindingDao, simpleCachedDao, sxpMapper);
+ final InOrder inOrder = Mockito.inOrder(masterDBBindingDao, simpleCachedDao, epPolicyTemplateDao, sxpMapper);
inOrder.verify(simpleCachedDao).update(IP_PREFIX_TMPL, EP_FW_TEMPLATE_VALUE);
inOrder.verify(masterDBBindingDao).read(IP_PREFIX_TMPL);
- inOrder.verify(sxpMapper).processForwardingAndSxpMasterDB(EP_FW_TEMPLATE_VALUE, prefixGroup);
+ inOrder.verify(epPolicyTemplateDao).read(SGT);
+ inOrder.verify(sxpMapper).processTemplatesAndSxpMasterDB(EP_POLICY_TEMPLATE, EP_FW_TEMPLATE_VALUE, masterDBBinding);
inOrder.verifyNoMoreInteractions();
}
*/
package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen;
+import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSAsyncDao;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableByKey;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+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.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.EndpointForwardingTemplateBySubnetBuilder;
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.EndpointPolicyTemplateBySgtBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgtKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBindingBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
* Test for {@link EPPolicyTemplateListenerImpl}.
.child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(SGT_1));
private static final DataTreeIdentifier<EndpointPolicyTemplateBySgt> TEMPLATE_TREE_PATH =
new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, EP_PL_TEMPLATE_PATH);
+ private static final IpPrefix IP_PREFIX_1 = new IpPrefix(new Ipv4Prefix("1.2.3.4/32"));
+ private static final IpPrefix IP_PREFIX_2 = new IpPrefix(new Ipv4Prefix("1.2.3.5/32"));
private final EndpointPolicyTemplateBySgt EP_PL_TEMPLATE_VALUE;
@Mock
@Mock
private SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> simpleCachedDao;
@Mock
+ private DSAsyncDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao;
+ @Mock
private ReadableByKey<Sgt, MasterDatabaseBinding> masterDBDao;
@Mock
private ListenerRegistration<? extends EPTemplateListener> listenerRegistration;
public void setUp() throws Exception {
Mockito.when(dataBroker.registerDataTreeChangeListener(Matchers.<DataTreeIdentifier>any(),
Matchers.<DataTreeChangeListener>any())).thenReturn(listenerRegistration);
- listener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapper, simpleCachedDao, masterDBDao);
+ listener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapper, simpleCachedDao, masterDBDao, epForwardingTemplateDao);
}
@Test
Mockito.when(dataTreeModification.getRootPath()).thenReturn(TEMPLATE_TREE_PATH);
Mockito.when(dataObjectModification.getDataAfter()).thenReturn(EP_PL_TEMPLATE_VALUE);
- final MasterDatabaseBinding masterDBBinding = new MasterDatabaseBindingBuilder()
+ final MasterDatabaseBinding masterDBBinding1 = new MasterDatabaseBindingBuilder()
+ .setSecurityGroupTag(SGT_1)
+ .setIpPrefix(IP_PREFIX_1)
+ .build();
+ final MasterDatabaseBinding masterDBBinding2 = new MasterDatabaseBindingBuilder()
.setSecurityGroupTag(SGT_1)
+ .setIpPrefix(IP_PREFIX_2)
.build();
+
+ final EndpointForwardingTemplateBySubnet epForwardingTemplate1 = new EndpointForwardingTemplateBySubnetBuilder()
+ .setIpPrefix(IP_PREFIX_1)
+ .build();
+ final EndpointForwardingTemplateBySubnet epForwardingTemplate2 = new EndpointForwardingTemplateBySubnetBuilder()
+ .setIpPrefix(IP_PREFIX_2)
+ .build();
+
Mockito.when(masterDBDao.readBy(Matchers.<Sgt>any())).thenReturn(
- Futures.immediateFuture(Lists.newArrayList(masterDBBinding)));
+ Futures.immediateFuture(Lists.newArrayList(masterDBBinding1, masterDBBinding2)));
+ Mockito.when(epForwardingTemplateDao.read(Matchers.<IpPrefix>any())).thenReturn(
+ Futures.immediateFuture(Optional.of(epForwardingTemplate1)),
+ Futures.immediateFuture(Optional.of(epForwardingTemplate2)));
+ Mockito.when(sxpMapper.processTemplatesAndSxpMasterDB(Matchers.<EndpointPolicyTemplateBySgt>any(),
+ Matchers.<EndpointForwardingTemplateBySubnet>any(), Matchers.<MasterDatabaseBinding>any())).thenReturn(
+ RpcResultBuilder.success((Void) null).buildFuture());
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- final InOrder inOrder = Mockito.inOrder(masterDBDao, simpleCachedDao, sxpMapper);
+ final InOrder inOrder = Mockito.inOrder(masterDBDao, simpleCachedDao, epForwardingTemplateDao, sxpMapper);
inOrder.verify(simpleCachedDao).update(SGT_1, EP_PL_TEMPLATE_VALUE);
inOrder.verify(masterDBDao).readBy(SGT_1);
- inOrder.verify(sxpMapper).processPolicyAndSxpMasterDB(EP_PL_TEMPLATE_VALUE, masterDBBinding);
+ inOrder.verify(epForwardingTemplateDao).read(IP_PREFIX_1);
+ inOrder.verify(epForwardingTemplateDao).read(IP_PREFIX_2);
+ inOrder.verify(sxpMapper).processTemplatesAndSxpMasterDB(EP_PL_TEMPLATE_VALUE, epForwardingTemplate1, masterDBBinding1);
+ inOrder.verify(sxpMapper).processTemplatesAndSxpMasterDB(EP_PL_TEMPLATE_VALUE, epForwardingTemplate2, masterDBBinding2);
inOrder.verifyNoMoreInteractions();
}
final InOrder inOrder = Mockito.inOrder(cachedDao, epPolicyTemplateDao, epForwardingTemplateDao, sxpMapper);
inOrder.verify(cachedDao).update(IP_PREFIX, MASTER_DB_BINDING_VALUE);
inOrder.verify(epPolicyTemplateDao).read(SGT_1);
- inOrder.verify(sxpMapper).processPolicyAndSxpMasterDB(epPolicyTemplate, MASTER_DB_BINDING_VALUE);
inOrder.verify(epForwardingTemplateDao).read(IP_PREFIX);
- inOrder.verify(sxpMapper).processForwardingAndSxpMasterDB(epForwardingTemplate, MASTER_DB_BINDING_VALUE);
+ inOrder.verify(sxpMapper).processTemplatesAndSxpMasterDB(epPolicyTemplate, epForwardingTemplate, MASTER_DB_BINDING_VALUE);
inOrder.verifyNoMoreInteractions();
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
/**
- * Test for {@link ForwardingTemplateUtil}.
+ * Test for {@link EPTemplateUtil}.
*/
-public class ForwardingTemplateUtilTest {
+public class EPTemplateUtilTest {
public static final IpPrefix IP_PREFIX_24 = new IpPrefix(new Ipv4Prefix("1.2.3.0/24"));
public static final IpPrefix IP_PREFIX_32 = new IpPrefix(new Ipv4Prefix("1.2.3.4/32"));
@Test
public void testIsPlain() throws Exception {
- Assert.assertFalse(ForwardingTemplateUtil.isPlain(IP_PREFIX_24));
- Assert.assertTrue(ForwardingTemplateUtil.isPlain(IP_PREFIX_32));
+ Assert.assertFalse(EPTemplateUtil.isPlain(IP_PREFIX_24));
+ Assert.assertTrue(EPTemplateUtil.isPlain(IP_PREFIX_32));
}
@Test
}
private void checkSubnetInfoBuilder(final IpPrefix ipPrefix, final String expectedLow, final String expectedHigh, final int expectedCount) {
- final SubnetInfoKeyDecorator subnetInfoKey = ForwardingTemplateUtil.buildSubnetInfoKey(ipPrefix);
+ final SubnetInfoKeyDecorator subnetInfoKey = EPTemplateUtil.buildSubnetInfoKey(ipPrefix);
final SubnetUtils.SubnetInfo subnetInfo = subnetInfoKey.getDelegate();
Assert.assertEquals(expectedLow, subnetInfo.getLowAddress());
Assert.assertEquals(expectedHigh, subnetInfo.getHighAddress());
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">\r
+<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">\r
+\r
+ <appender name="console" class="org.apache.log4j.ConsoleAppender">\r
+ <layout class="org.apache.log4j.PatternLayout">\r
+ <param name="ConversionPattern" value="%-6p %d{HH:mm:ss.SSS} [%10.10t] %30.30c %x - %m%n"/>\r
+ </layout>\r
+ <!-- <param name="Threshold" value="DEBUG" /> -->\r
+ </appender>\r
+\r
+ <logger name="org.opendaylight.groupbasedpolicy.sxp.mapper" additivity="false">\r
+ <level value="DEBUG"/>\r
+ <appender-ref ref="console"/>\r
+ </logger>\r
+\r
+ <logger name="org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao" additivity="false">\r
+ <level value="TRACE"/>\r
+ <appender-ref ref="console"/>\r
+ </logger>\r
+\r
+ <root>\r
+ <priority value="INFO"/>\r
+ <appender-ref ref="console"/>\r
+ </root>\r
+</log4j:configuration>\r
Code Review / groupbasedpolicy.git / commitdiff