--- /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.api;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+
+/**
+ * Purpose: simple asynchronous search interface allowing for custom key and returning list of values
+ *
+ * @param <X> special key type
+ * @param <V> value type
+ */
+public interface ReadableAsyncByKey<X, V> {
+
+ /**
+ * @param specialKey custom key to search by
+ * @return list of found values
+ */
+ ListenableFuture<Collection<V>> readBy(@Nonnull X specialKey);
+}
* 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.api;
-import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import javax.annotation.Nonnull;
/**
- * Purpose: simple asynchronous search interface allowing for custom key and returning list of values
+ * Purpose: simple search interface allowing for custom key and returning list of values
*
* @param <X> special key type
* @param <V> value type
* @param specialKey custom key to search by
* @return list of found values
*/
- ListenableFuture<Collection<V>> readBy(@Nonnull X specialKey);
+ Collection<V> readBy(@Nonnull X specialKey);
}
package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
import java.util.AbstractMap;
+import java.util.Collection;
import java.util.Map.Entry;
-
import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableByKey;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EpPolicyTemplateValueKey;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EpPolicyTemplateValueKeyFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointAug;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointAugBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointRegAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointWithLocationAug;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointWithLocationAugBuilder;
+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.yangtools.yang.binding.Augmentation;
public class SxpEndpointAugmentorImpl implements EndpointAugmentor {
+ private final ReadableByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> epPolicyTemplateDao;
+ private final EpPolicyTemplateValueKeyFactory epPolicyTemplateKeyFactory;
+
+ public SxpEndpointAugmentorImpl(final ReadableByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> epPolicyTemplateDao,
+ final EpPolicyTemplateValueKeyFactory epPolicyTemplateKeyFactory) {
+ this.epPolicyTemplateKeyFactory = Preconditions.checkNotNull(epPolicyTemplateKeyFactory, "epPolicyTemplateKeyFactory can not be null");
+ this.epPolicyTemplateDao = Preconditions.checkNotNull(epPolicyTemplateDao, "epPolicyTemplateDao can not be null");
+ }
+
@Override
public Entry<Class<? extends Augmentation<AddressEndpoint>>, Augmentation<AddressEndpoint>> buildAddressEndpointAugmentation(
AddressEndpointReg input) {
- AddressEndpointRegAug addressEndpointRegAug = input.getAugmentation(AddressEndpointRegAug.class);
- if (addressEndpointRegAug == null) {
- return null;
- }
- AddressEndpointAug addressEndpointAug = new AddressEndpointAugBuilder(addressEndpointRegAug).build();
- Entry<Class<? extends Augmentation<AddressEndpoint>>, Augmentation<AddressEndpoint>> entry =
- new AbstractMap.SimpleEntry<>(AddressEndpointAug.class, addressEndpointAug);
- return entry;
+ return null;
}
@Override
@Override
public Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>> buildAddressEndpointWithLocationAugmentation(
AddressEndpoint input) {
- AddressEndpointAug addressEndpointAug = input.getAugmentation(AddressEndpointAug.class);
- if (addressEndpointAug == null) {
- return null;
+ final EpPolicyTemplateValueKey templateValueKey = epPolicyTemplateKeyFactory.createKey(
+ input.getTenant(), input.getEndpointGroup(), input.getCondition());
+
+ final Collection<EndpointPolicyTemplateBySgt> epPolicyTemplates = epPolicyTemplateDao.readBy(templateValueKey);
+ final Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>> entry;
+
+ if (epPolicyTemplates.isEmpty()) {
+ entry = null;
+ } else {
+ //TODO: cover case when multiple templates found
+ final Augmentation<AddressEndpointWithLocation> addressEndpointWithLocationAug =
+ new AddressEndpointWithLocationAugBuilder()
+ .setSgt(Iterables.getFirst(epPolicyTemplates, null).getSgt())
+ .build();
+ entry = new AbstractMap.SimpleEntry<>(AddressEndpointWithLocationAug.class, addressEndpointWithLocationAug);
}
- AddressEndpointWithLocationAug addressEndpointWithLocationAug =
- new AddressEndpointWithLocationAugBuilder(addressEndpointAug).build();
- Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>> entry =
- new AbstractMap.SimpleEntry<>(AddressEndpointWithLocationAug.class, addressEndpointWithLocationAug);
+
return entry;
}
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSAsyncDao;
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.EPForwardingTemplateDaoImpl;
import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EPPolicyTemplateDaoImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EpPolicyTemplateValueKeyFactory;
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.groupbasedpolicy.sxp.mapper.impl.util.EPTemplateUtil;
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.base_endpoint.rev160427.BaseEndpointService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
new SimpleCachedDaoEPForwardingTemplateImpl();
final SimpleCachedDao<IpPrefix, MasterDatabaseBinding> masterDBBindingCachedDao = new SimpleCachedDaoImpl<>();
- final DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao = new EPPolicyTemplateDaoImpl(dataBroker, epPolicyTemplateCachedDao);
+ final EpPolicyTemplateValueKeyFactory epPolicyTemplateKeyFactory = new EpPolicyTemplateValueKeyFactory(
+ EPTemplateUtil.createEndpointGroupIdOrdering(), EPTemplateUtil.createConditionNameOrdering());
+ final EPPolicyTemplateDaoImpl epPolicyTemplateDao = new EPPolicyTemplateDaoImpl(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory);
final EPForwardingTemplateDaoImpl epForwardingTemplateDao = new EPForwardingTemplateDaoImpl(dataBroker,
epForwardingTemplateCachedDao);
final MasterDatabaseBindingDaoImpl masterDBBindingDao = new MasterDatabaseBindingDaoImpl(dataBroker, masterDBBindingCachedDao);
masterDBBindingDao, epForwardingTemplateDao);
epForwardingTemplateListener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapperReactor, epForwardingTemplateCachedDao,
masterDBBindingDao, epPolicyTemplateDao);
- sxpEndpointAugmentor = new SxpEndpointAugmentorImpl();
+ sxpEndpointAugmentor = new SxpEndpointAugmentorImpl(epPolicyTemplateDao, epPolicyTemplateKeyFactory);
domainSpecificRegistry.getEndpointAugmentorRegistry().register(sxpEndpointAugmentor);
LOG.info("started SxmMapper");
}
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.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointRegAug;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointRegAugBuilder;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
-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;
-
/**
* Purpose: exclusively processes sxp master database changes and EGP templates changes
*/
.setNetworkDomainId(epForwardingTemplate.getNetworkContainment().getNetworkDomainId())
.build())
.build();
- AddressEndpointRegAug sgtAugmentation =
- new AddressEndpointRegAugBuilder().setSgt(masterDBBinding.getSecurityGroupTag()).build();
final RegisterEndpointInput epInput = new RegisterEndpointInputBuilder().setAddressEndpointReg(
Collections.singletonList(new AddressEndpointRegBuilder().setAddressType(IpPrefixType.class)
.setAddress(address.getValue())
.setCondition(epPolicyTemplate.getConditions())
.setTenant(epPolicyTemplate.getTenant())
.setEndpointGroup(epPolicyTemplate.getEndpointGroups())
- .addAugmentation(AddressEndpointRegAug.class, sgtAugmentation)
.build()))
.build();
epForwardingTemplate.getL3Context();
import com.google.common.base.Function;
import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
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.EPTemplateListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableByKey;
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;
/**
* Purpose: general dao for EndPoint templates
*/
-public class EPPolicyTemplateDaoImpl implements DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt> {
+public class EPPolicyTemplateDaoImpl implements DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt>,
+ ReadableByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> {
private static final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent());
private final DataBroker dataBroker;
private final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> cachedDao;
+ private final EpPolicyTemplateValueKeyFactory keyFactory;
public EPPolicyTemplateDaoImpl(final DataBroker dataBroker,
- final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> cachedDao) {
+ final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> cachedDao,
+ final EpPolicyTemplateValueKeyFactory keyFactory) {
this.dataBroker = dataBroker;
this.cachedDao = cachedDao;
+ this.keyFactory = keyFactory;
}
@Override
@Override
public Optional<EndpointPolicyTemplateBySgt> apply(@Nullable final Optional<EndpointPolicyTemplateBySgt> input) {
if (input.isPresent()) {
- cachedDao.update(key, input.get());
+ cachedDao.update(key, keyFactory.sortValueKeyLists(input.get()));
}
return input;
}
return cachedDao.find(key);
}
+ @Override
+ public Collection<EndpointPolicyTemplateBySgt> readBy(@Nonnull final EpPolicyTemplateValueKey specialKey) {
+ final Predicate<EpPolicyTemplateValueKey> templateValuePredicate = Predicates.equalTo(specialKey);
+ final Collection<EndpointPolicyTemplateBySgt> foundTemplates = new ArrayList<>();
+
+ for (EndpointPolicyTemplateBySgt epPolicyTemplate : cachedDao.values()) {
+ final EpPolicyTemplateValueKey templateValueKey = keyFactory.createKeyWithDefaultOrdering(epPolicyTemplate);
+ if (templateValuePredicate.apply(templateValueKey)) {
+ foundTemplates.add(epPolicyTemplate);
+ }
+ }
+
+ return foundTemplates;
+ }
}
--- /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.dao;
+
+import java.util.List;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
+
+/**
+ * Purpose: composite key holcer for {@link EndpointPolicyTemplateBySgt}
+ */
+public class EpPolicyTemplateValueKey {
+
+ private final TenantId tenantId;
+ private final List<EndpointGroupId> epgId;
+ private final List<ConditionName> conditionName;
+
+ public EpPolicyTemplateValueKey(final TenantId tenantId, final List<EndpointGroupId> epgId, final List<ConditionName> conditionName) {
+ this.tenantId = tenantId;
+ this.epgId = epgId;
+ this.conditionName = conditionName;
+ }
+
+ public EpPolicyTemplateValueKey(AddressEndpointWithLocation endpoint) {
+ this(endpoint.getTenant(), endpoint.getEndpointGroup(), endpoint.getCondition());
+ }
+
+ public TenantId getTenantId() {
+ return tenantId;
+ }
+
+ public List<EndpointGroupId> getEpgId() {
+ return epgId;
+ }
+
+ public List<ConditionName> getConditionName() {
+ return conditionName;
+ }
+
+ @Override
+ public boolean equals(final Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ final EpPolicyTemplateValueKey that = (EpPolicyTemplateValueKey) o;
+
+ if (tenantId != null ? !tenantId.equals(that.tenantId) : that.tenantId != null) return false;
+ if (epgId != null ? !epgId.equals(that.epgId) : that.epgId != null) return false;
+ return conditionName != null ? conditionName.equals(that.conditionName) : that.conditionName == null;
+
+ }
+
+ @Override
+ public int hashCode() {
+ return tenantId != null ? tenantId.hashCode() : 0;
+ }
+}
--- /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.dao;
+
+import com.google.common.collect.Ordering;
+import java.util.Collections;
+import java.util.List;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
+
+/**
+ * Purpose: create cache keys with ordered lists inside
+ */
+public class EpPolicyTemplateValueKeyFactory {
+ private final Ordering<EndpointGroupId> epgIdOrdering;
+ private final Ordering<ConditionName> conditionOrdering;
+
+ public EpPolicyTemplateValueKeyFactory(final Ordering<EndpointGroupId> epgIdOrdering,
+ final Ordering<ConditionName> conditionOrdering) {
+ this.epgIdOrdering = epgIdOrdering;
+ this.conditionOrdering = conditionOrdering;
+ }
+
+ public EndpointPolicyTemplateBySgt sortValueKeyLists(final EndpointPolicyTemplateBySgt template) {
+ if (template.getEndpointGroups() != null) {
+ Collections.sort(template.getEndpointGroups(), epgIdOrdering);
+ }
+ if (template.getConditions() != null) {
+ Collections.sort(template.getConditions(), conditionOrdering);
+ }
+ return template;
+ }
+
+ public EpPolicyTemplateValueKey createKeyWithDefaultOrdering(final EndpointPolicyTemplateBySgt newSource) {
+ return new EpPolicyTemplateValueKey(
+ newSource.getTenant(), newSource.getEndpointGroups(), newSource.getConditions());
+ }
+
+ public EpPolicyTemplateValueKey sortValueKeyLists(final EpPolicyTemplateValueKey existingKey) {
+ Collections.sort(existingKey.getEpgId(), epgIdOrdering);
+ Collections.sort(existingKey.getConditionName(), conditionOrdering);
+ return existingKey;
+ }
+
+ public EpPolicyTemplateValueKey createKey(final TenantId tenant, final List<EndpointGroupId> endpointGroup,
+ final List<ConditionName> condition) {
+ return sortValueKeyLists(new EpPolicyTemplateValueKey(tenant, endpointGroup, condition));
+ }
+}
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.MasterDatabaseBindingListener;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableByKey;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableAsyncByKey;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
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;
* Purpose: general dao for EndPoint templates
*/
public class MasterDatabaseBindingDaoImpl implements DSAsyncDao<IpPrefix, MasterDatabaseBinding>,
- ReadableByKey<Sgt, MasterDatabaseBinding> {
+ ReadableAsyncByKey<Sgt, MasterDatabaseBinding> {
private static final Logger LOG = LoggerFactory.getLogger(MasterDatabaseBindingDaoImpl.class);
private static final ListenableFuture<Optional<MasterDatabaseBinding>> READ_FUTURE_ABSENT = Futures.immediateFuture(Optional.absent());
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.ReadableAsyncByKey;
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;
private final InstanceIdentifier<EndpointPolicyTemplateBySgt> templatePath;
private final SxpMapperReactor sxpMapperReactor;
private final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> templateCachedDao;
- private final ReadableByKey<Sgt, MasterDatabaseBinding> masterDBBindingDao;
+ private final ReadableAsyncByKey<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 ReadableAsyncByKey<Sgt, MasterDatabaseBinding> masterDBBindingDao,
final DSAsyncDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao) {
this.sxpMapperReactor = Preconditions.checkNotNull(sxpMapperReactor);
this.templateCachedDao = Preconditions.checkNotNull(templateCachedDao);
package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util;
import com.google.common.base.Function;
+import com.google.common.base.MoreObjects;
import com.google.common.base.Optional;
+import com.google.common.collect.Ordering;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
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.groupbasedpolicy.common.rev140421.ConditionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
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;
public final class EPTemplateUtil {
public static final String FULL_IPV4_MASK_SUFFIX = "/32";
+ private static final Comparable EMPTY_COMPARABLE = "";
private EPTemplateUtil() {
throw new IllegalAccessError("constructing util class");
});
}
+ public static Ordering<EndpointGroupId> createEndpointGroupIdOrdering() {
+ return Ordering.natural().onResultOf(new Function<EndpointGroupId, Comparable>() {
+ @Nullable
+ @Override
+ public Comparable apply(@Nullable final EndpointGroupId input) {
+ if (input == null) {
+ return EMPTY_COMPARABLE;
+ }
+ return MoreObjects.firstNonNull(input.getValue(), EMPTY_COMPARABLE);
+ }
+ });
+ }
+
+ public static Ordering<ConditionName> createConditionNameOrdering() {
+ return Ordering.natural().onResultOf(new Function<ConditionName, Comparable>() {
+ @Nullable
+ @Override
+ public Comparable apply(@Nullable final ConditionName input) {
+ if (input == null) {
+ return EMPTY_COMPARABLE;
+ }
+ return MoreObjects.firstNonNull(input.getValue(), EMPTY_COMPARABLE);
+ }
+ });
+ }
+
public static class OptionalMutablePair<L, R> extends MutablePair<Optional<L>, Optional<R>> {
public OptionalMutablePair() {
super(Optional.absent(), Optional.absent());
}
}
- augment "/base-endpoint:register-endpoint/base-endpoint:input/base-endpoint:address-endpoint-reg" {
- ext:augment-identifier "address-endpoint-reg-aug";
- uses sxp-sgt;
- }
-
- augment "/base-endpoint:endpoints/base-endpoint:address-endpoints/base-endpoint:address-endpoint" {
- ext:augment-identifier "address-endpoint-aug";
- uses sxp-sgt;
- }
-
augment "renderer:renderers/renderer:renderer/renderer:renderer-policy/renderer:configuration/renderer:endpoints/renderer:address-endpoint-with-location" {
ext:augment-identifier "address-endpoint-with-location-aug";
uses sxp-sgt;
--- /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;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.ReadableByKey;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EpPolicyTemplateValueKey;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EpPolicyTemplateValueKeyFactory;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.EPTemplateUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.AddressEndpointWithLocationAug;
+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.yangtools.yang.binding.Augmentation;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+
+/**
+ * Test for {@link SxpEndpointAugmentorImpl}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class SxpEndpointAugmentorImplTest {
+
+ @Mock
+ private ReadableByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> epPolicyDao;
+ @Spy
+ private EpPolicyTemplateValueKeyFactory keyFactory = new EpPolicyTemplateValueKeyFactory(
+ EPTemplateUtil.createEndpointGroupIdOrdering(), EPTemplateUtil.createConditionNameOrdering());
+ @Captor
+ private ArgumentCaptor<EpPolicyTemplateValueKey> keyCapt;
+
+ private SxpEndpointAugmentorImpl augmetor;
+
+ @Before
+ public void setUp() throws Exception {
+ augmetor = new SxpEndpointAugmentorImpl(epPolicyDao, keyFactory);
+ }
+
+ @Test
+ public void testBuildAddressEndpointWithLocationAugmentation() throws Exception {
+ final TenantId tenantId = new TenantId("tn1");
+ final AddressEndpoint endpoint = new AddressEndpointBuilder()
+ .setTenant(tenantId)
+ .setCondition(buildConditions(new String[]{"cn2", "cn1"}))
+ .setEndpointGroup(buildEndpointGroupIds(new String[]{"epg2", "epg1"}))
+ .build();
+
+ Mockito.doCallRealMethod().when(keyFactory).sortValueKeyLists(Matchers.<EndpointPolicyTemplateBySgt>any());
+ final List<ConditionName> conditions = buildConditions(new String[]{"cn1", "cn2"});
+ final List<EndpointGroupId> endpointGroupIds = buildEndpointGroupIds(new String[]{"epg1", "epg2"});
+ final EndpointPolicyTemplateBySgt epPolicyTemplate = new EndpointPolicyTemplateBySgtBuilder()
+ .setTenant(tenantId)
+ .setEndpointGroups(endpointGroupIds)
+ .setConditions(conditions)
+ .setSgt(new Sgt(42))
+ .build();
+
+ Mockito.when(epPolicyDao.readBy(keyCapt.capture())).thenReturn(Collections.singletonList(epPolicyTemplate));
+
+ final Map.Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>>
+ augmentationEntry = augmetor.buildAddressEndpointWithLocationAugmentation(endpoint);
+
+ Assert.assertEquals(AddressEndpointWithLocationAug.class, augmentationEntry.getKey());
+ Assert.assertTrue(DataObject.class.isAssignableFrom(augmentationEntry.getValue().getClass()));
+ Assert.assertEquals(AddressEndpointWithLocationAug.class, ((DataObject) augmentationEntry.getValue()).getImplementedInterface());
+ Assert.assertEquals(42, ((AddressEndpointWithLocationAug) augmentationEntry.getValue()).getSgt().getValue().intValue());
+
+ final EpPolicyTemplateValueKey keyValue = keyCapt.getValue();
+ Assert.assertEquals(tenantId, keyValue.getTenantId());
+ Assert.assertEquals(endpointGroupIds, keyValue.getEpgId());
+ Assert.assertEquals(conditions, keyValue.getConditionName());
+ }
+
+ private static List<EndpointGroupId> buildEndpointGroupIds(final String[] names) {
+ final List<EndpointGroupId> endpointGroupIds = new ArrayList<>();
+ for (String epgId : names) {
+ endpointGroupIds.add(new EndpointGroupId(epgId));
+ }
+ return endpointGroupIds;
+ }
+
+ private static List<ConditionName> buildConditions(final String[] names) {
+ final List<ConditionName> conditions = new ArrayList<>();
+ for (String condition : names) {
+ conditions.add(new ConditionName(condition));
+ }
+ return conditions;
+ }
+
+ @Test
+ public void testBuildAddressEndpointAugmentation() throws Exception {
+ final AddressEndpointReg endpoint = new AddressEndpointRegBuilder().build();
+ Assert.assertNull(augmetor.buildAddressEndpointAugmentation(endpoint));
+ }
+
+ @Test
+ public void testBuildContainmentEndpointAugmentation() throws Exception {
+ final ContainmentEndpointReg endpoint = new ContainmentEndpointRegBuilder().build();
+ Assert.assertNull(augmetor.buildContainmentEndpointAugmentation(endpoint));
+ }
+
+ @Test
+ public void testBuildContainmentEndpointWithLocationAugmentation() throws Exception {
+ final ContainmentEndpoint endpoint = new ContainmentEndpointBuilder().build();
+ Assert.assertNull(augmetor.buildContainmentEndpointWithLocationAugmentation(endpoint));
+ }
+}
\ No newline at end of file
package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao;
import com.google.common.base.Optional;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
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 org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
import org.mockito.InOrder;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.Spy;
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.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SimpleCachedDao;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.EPTemplateUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.SxpMapper;
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;
private SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> cachedDao;
@Mock
private ReadOnlyTransaction rTx;
+ @Spy
+ private EpPolicyTemplateValueKeyFactory keyFactory = new EpPolicyTemplateValueKeyFactory(
+ EPTemplateUtil.createEndpointGroupIdOrdering(), EPTemplateUtil.createConditionNameOrdering());
+ @Captor
+ ArgumentCaptor<Sgt> sgtCapt;
+ @Captor
+ ArgumentCaptor<EndpointPolicyTemplateBySgt> epPolicyTemplateCapt;
private EPPolicyTemplateDaoImpl dao;
@Before
public void setUp() throws Exception {
- dao = new EPPolicyTemplateDaoImpl(dataBroker, cachedDao);
+ dao = new EPPolicyTemplateDaoImpl(dataBroker, cachedDao, keyFactory);
}
@Test
Matchers.<InstanceIdentifier<EndpointPolicyTemplateBySgt>>any())).thenReturn(
Futures.<Optional<EndpointPolicyTemplateBySgt>, ReadFailedException>immediateCheckedFuture(
Optional.of(EP_POLICY_TEMPLATE_VALUE)));
+ Mockito.doCallRealMethod().when(keyFactory).sortValueKeyLists(Matchers.<EndpointPolicyTemplateBySgt>any());
final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> read = dao.read(KEY_1);
Assert.assertTrue(read.isDone());
final InstanceIdentifier<EndpointPolicyTemplateBySgt> readPath = dao.buildReadPath(KEY_1);
Assert.assertEquals(expectedPath, readPath);
}
+
+ @Test
+ public void testReadBy_single() throws Exception {
+ final EpPolicyTemplateValueKey key = new EpPolicyTemplateValueKey(new TenantId("tn1"),
+ buildEndpointGroupIds(new String[]{"epg1", "epg2"}),
+ buildConditions(new String[]{"cn1", "cn2"}));
+
+ Mockito.doCallRealMethod().when(keyFactory).createKeyWithDefaultOrdering(Matchers.<EndpointPolicyTemplateBySgt>any());
+
+ Mockito.when(cachedDao.values()).thenReturn(Lists.newArrayList(
+ createEpPolicytemplate(new Sgt(1), new String[]{"cn2", "cn1"}, new String[]{"epg1", "epg2"}, "tn1"),
+ createEpPolicytemplate(new Sgt(2), new String[]{"cn1", "cn2"}, new String[]{"epg2", "epg1"}, "tn1"),
+ createEpPolicytemplate(new Sgt(3), new String[]{"cn2", "cn1"}, new String[]{"epg2", "epg1"}, "tn1"),
+ createEpPolicytemplate(new Sgt(4), new String[]{"cn1", "cn2"}, new String[]{"epg1", "epg2"}, "tn1")
+ ));
+
+ final Collection<EndpointPolicyTemplateBySgt> policyTemplates = dao.readBy(key);
+ Assert.assertEquals(1, policyTemplates.size());
+ Assert.assertEquals(4, Iterables.getFirst(policyTemplates, null).getSgt().getValue().intValue());
+ }
+
+ @Test
+ public void testRead_unsortedLists() throws Exception {
+ final EndpointPolicyTemplateBySgt epPolicytemplateUnsorted = createEpPolicytemplate(new Sgt(1),
+ new String[]{"cn2", "cn1"}, new String[]{"epg2", "epg1"}, "tn1");
+
+ Mockito.doCallRealMethod().when(keyFactory).createKeyWithDefaultOrdering(Matchers.<EndpointPolicyTemplateBySgt>any());
+
+ 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(
+ Futures.<Optional<EndpointPolicyTemplateBySgt>, ReadFailedException>immediateCheckedFuture(
+ Optional.of(epPolicytemplateUnsorted)));
+
+ dao.read(new Sgt(1));
+
+ Mockito.verify(cachedDao).update(sgtCapt.capture(), epPolicyTemplateCapt.capture());
+ Mockito.verify(cachedDao).find(sgtCapt.capture());
+
+ Assert.assertEquals(1, sgtCapt.getValue().getValue().intValue());
+ final EndpointPolicyTemplateBySgt template = epPolicyTemplateCapt.getValue();
+ Assert.assertEquals(1, template.getSgt().getValue().intValue());
+ Assert.assertEquals("tn1", template.getTenant().getValue());
+ Assert.assertEquals(buildEndpointGroupIds(new String[]{"epg1", "epg2"}), template.getEndpointGroups());
+ Assert.assertEquals(buildConditions(new String[]{"cn1", "cn2"}), template.getConditions());
+ }
+
+
+ private EndpointPolicyTemplateBySgt createEpPolicytemplate(final Sgt sgt, final String[] conditionNames,
+ final String[] epgIds, final String tenant) {
+ return new EndpointPolicyTemplateBySgtBuilder()
+ .setSgt(sgt)
+ .setEndpointGroups(buildEndpointGroupIds(epgIds))
+ .setConditions(buildConditions(conditionNames))
+ .setTenant(new TenantId(tenant))
+ .build();
+ }
+
+ private static List<EndpointGroupId> buildEndpointGroupIds(final String[] names) {
+ final List<EndpointGroupId> endpointGroupIds = new ArrayList<>();
+ for (String epgId : names) {
+ endpointGroupIds.add(new EndpointGroupId(epgId));
+ }
+ return endpointGroupIds;
+ }
+
+ private static List<ConditionName> buildConditions(final String[] names) {
+ final List<ConditionName> conditions = new ArrayList<>();
+ for (String condition : names) {
+ conditions.add(new ConditionName(condition));
+ }
+ return conditions;
+ }
}
\ No newline at end of file
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.ReadableAsyncByKey;
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;
@Mock
private DSAsyncDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao;
@Mock
- private ReadableByKey<Sgt, MasterDatabaseBinding> masterDBDao;
+ private ReadableAsyncByKey<Sgt, MasterDatabaseBinding> masterDBDao;
@Mock
private ListenerRegistration<? extends EPTemplateListener> listenerRegistration;
@Mock
Code Review / groupbasedpolicy.git / commitdiff