import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
+import java.util.List;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.sf.Classifier;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.sf.EtherTypeClassifier;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.sf.IpProtoClassifier;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.List;
-import java.util.Optional;
-
/**
* Purpose: bootstrap provider implementation of Ios-xe renderer
*/
private static final Logger LOG = LoggerFactory.getLogger(IosXeRendererProviderImpl.class);
private final DataBroker dataBroker;
+ private final SxpEpProviderProvider sxpEpProvider;
private RendererConfigurationListenerImpl rendererConfigurationListener;
private IosXeCapableNodeListenerImpl iosXeCapableNodeListener;
- public IosXeRendererProviderImpl(final DataBroker dataBroker, final BindingAwareBroker broker) {
+ public IosXeRendererProviderImpl(final DataBroker dataBroker, final BindingAwareBroker broker,
+ final SxpEpProviderProvider sxpEpProvider) {
LOG.debug("ios-xe renderer bootstrap");
this.dataBroker = Preconditions.checkNotNull(dataBroker, "missing dataBroker dependency");
+ this.sxpEpProvider = Preconditions.checkNotNull(sxpEpProvider, "missing sxpEpProvider param");
broker.registerProvider(this);
}
iosXeCapableNodeListener = new IosXeCapableNodeListenerImpl(dataBroker, nodeManager);
// policy-manager and delegates
- final PolicyManager policyManager = new PolicyManagerImpl(dataBroker, nodeManager);
+ final PolicyManager policyManager = new PolicyManagerImpl(dataBroker, nodeManager, sxpEpProvider.getEPToSgtMapper());
final PolicyManager policyManagerZip = new PolicyManagerZipImpl(policyManager);
// renderer-configuration endpoints
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.IosXeRendererProviderImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
private final DataBroker dataBroker;
private final BindingAwareBroker bindingAwareBroker;
private final ClusterSingletonServiceProvider clusterSingletonService;
+ private final SxpEpProviderProvider sxpEpProvider;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
private IosXeRendererProviderImpl renderer;
public IosXeProviderInstance(final DataBroker dataBroker,
final BindingAwareBroker broker,
- final ClusterSingletonServiceProvider clusterSingletonService) {
+ final ClusterSingletonServiceProvider clusterSingletonService,
+ final SxpEpProviderProvider sxpEpProvider) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.bindingAwareBroker = Preconditions.checkNotNull(broker);
this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
+ this.sxpEpProvider = Preconditions.checkNotNull(sxpEpProvider);
}
public void initialize() {
@Override
public void instantiateServiceInstance() {
LOG.info("Instantiating {}", this.getClass().getSimpleName());
- renderer = new IosXeRendererProviderImpl(dataBroker, bindingAwareBroker);
+ renderer = new IosXeRendererProviderImpl(dataBroker, bindingAwareBroker, sxpEpProvider);
}
@Override
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.api.manager.PolicyManager;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.PolicyManagerUtil;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.StatusUtil;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
private static final String BASE_POLICY_MAP_NAME = "service-chains-";
private final DataBroker dataBroker;
private final NodeManager nodeManager;
+ private final EPToSgtMapper epToSgtMapper;
public PolicyManagerImpl(final DataBroker dataBroker,
- final NodeManager nodeManager) {
+ final NodeManager nodeManager, final EPToSgtMapper epToSgtMapper) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.nodeManager = Preconditions.checkNotNull(nodeManager);
+ this.epToSgtMapper = Preconditions.checkNotNull(epToSgtMapper);
}
@Override
managementIpAddress, mountpoint);
context.setPolicyMapLocation(policyMapLocation);
- final Sgt sourceSgt = PolicyManagerUtil.findSgtTag(rendererEndpoint, dataAfter.getEndpoints()
+ final Sgt sourceSgt = PolicyManagerUtil.findSgtTag(epToSgtMapper, rendererEndpoint, dataAfter.getEndpoints()
.getAddressEndpointWithLocation());
// Peer Endpoint
for (PeerEndpoint peerEndpoint : rendererEndpoint.getPeerEndpoint()) {
- final Sgt destinationSgt = PolicyManagerUtil.findSgtTag(peerEndpoint, dataAfter.getEndpoints()
+ final Sgt destinationSgt = PolicyManagerUtil.findSgtTag(epToSgtMapper, peerEndpoint, dataAfter.getEndpoints()
.getAddressEndpointWithLocation());
if (sourceSgt == null || destinationSgt == null) {
final String info = String.format("Endpoint-policy: missing sgt value(sourceSgt=%s, destinationSgt=%s)",
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.writer.PolicyWriterUtil;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.RenderedServicePath;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308.ClassNameType;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308.PolicyActionType;
}
@Nullable
- public static Sgt findSgtTag(final AddressEndpointKey endpointKey,
+ public static Sgt findSgtTag(final EPToSgtMapper sxpEpProvider, final AddressEndpointKey endpointKey,
final List<AddressEndpointWithLocation> endpointsWithLocation) {
if (endpointKey == null || endpointsWithLocation == null) {
return null;
}
final AddressEndpointWithLocation endpointWithLocation = RendererPolicyUtil.lookupEndpoint(endpointKey,
endpointsWithLocation);
+
+ //TODO: involve sxpEpProvider
final AddressEndpointWithLocationAug augmentation = endpointWithLocation.getAugmentation(AddressEndpointWithLocationAug.class);
if (augmentation == null) {
return null;
<reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
<reference id="broker" interface="org.opendaylight.controller.sal.binding.api.BindingAwareBroker"/>
<reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
+ <reference id="sxpEpProvider"
+ interface="org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider"/>
<bean id="iosXeRenderer" class="org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.config.IosXeProviderInstance"
init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
<argument ref="broker"/>
<argument ref="clusterSingletonService" />
+ <argument ref="sxpEpProvider"/>
</bean>
</blueprint>
\ No newline at end of file
*/
package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction.Out;
-import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation.PROVIDER;
-import static org.powermock.api.support.membermodification.MemberMatcher.method;
-import static org.powermock.api.support.membermodification.MemberModifier.stub;
-
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.PolicyManagerUtil;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.RendererPolicyUtil;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.ServiceChainingUtil;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
import org.opendaylight.groupbasedpolicy.util.IetfModelCodec;
import org.opendaylight.sfc.provider.api.SfcProviderServiceForwarderAPI;
import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.RspName;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction.Out;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation.PROVIDER;
+import static org.powermock.api.support.membermodification.MemberMatcher.method;
+import static org.powermock.api.support.membermodification.MemberModifier.stub;
+
@RunWith(PowerMockRunner.class)
@PrepareForTest({RendererPolicyUtil.class, PolicyManagerUtil.class, SfcProviderServiceForwarderAPI.class})
public class PolicyManagerImplTest {
private PolicyManagerImpl policyManager;
private DataBroker mountpoint;
private NodeManager nodeManager;
+ private EPToSgtMapper epToSgtMapper;
@Before
public void init() {
mountpoint = mock(DataBroker.class);
ReadWriteTransaction readWriteTransaction = mock(ReadWriteTransaction.class);
nodeManager = mock(NodeManager.class);
- policyManager = new PolicyManagerImpl(mountpoint, nodeManager);
+ epToSgtMapper = mock(EPToSgtMapper.class);
+ policyManager = new PolicyManagerImpl(mountpoint, nodeManager, epToSgtMapper);
when(mountpoint.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(readWriteTransaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
}
sxp-ep-provider:sxp-ep-provider-impl
</type>
<name>sxp-ep-provider-default-impl</name>
-
- <data-broker>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-async-data-broker</type>
- <name>binding-data-broker</name>
- </data-broker>
- <rpc-registry>
- <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
- <name>binding-rpc-broker</name>
- </rpc-registry>
- <domain-specific-registry>
- <type xmlns:gbp="urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy">
- gbp:domain-specific-registry
- </type>
- <name>domain-specific-registry</name>
- </domain-specific-registry>
</module>
</modules>
- <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <service>
- <type xmlns:sxp-ep-provider="urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy:sxp-integration:sxp-ep-provider">
- sxp-ep-provider:sxp-ep-provider
- </type>
-
- <instance>
- <name>sxp-ep-provider-service</name>
- <provider>/modules/module[type='sxp-ep-provider-impl'][name='sxp-ep-provider-default-impl']</provider>
- </instance>
- </service>
- </services>
</data>
</configuration>
--- /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.controller.config.yang.config.groupbasedpolicy.sxp_integration.sxp_ep_provider;
+
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.controller.config.yang.config.groupbasedpolicy.GroupbasedpolicyInstance;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProviderRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SxpEpProviderProviderImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+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.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SxpEpProviderProviderInstance implements SxpEpProviderProvider, ClusterSingletonService, AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(SxpEpProviderProviderInstance.class);
+
+ private static final ServiceGroupIdentifier IDENTIFIER =
+ ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
+
+ private final DataBroker dataBroker;
+ private final BaseEndpointService endpointService;
+ private final DomainSpecificRegistry registry;
+ private final ClusterSingletonServiceProvider clusterSingletonService;
+ private final SgtGeneratorConfig sgtGeneratorConfig;
+ private ClusterSingletonServiceRegistration singletonServiceRegistration;
+ private SxpEpProviderProviderImpl sxpEpProviderProvider;
+
+ public SxpEpProviderProviderInstance(DataBroker dataBroker, BaseEndpointService endpointService,
+ DomainSpecificRegistry registry,
+ ClusterSingletonServiceProvider clusterSingletonService,
+ SgtGeneratorConfig sgtGeneratorConfig) {
+ this.dataBroker = Preconditions.checkNotNull(dataBroker);
+ this.endpointService = Preconditions.checkNotNull(endpointService);
+ this.registry = Preconditions.checkNotNull(registry);
+ this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
+ this.sgtGeneratorConfig = Preconditions.checkNotNull(sgtGeneratorConfig);
+ }
+
+ public void initialize() {
+ LOG.info("Clustering session initiated for {}", this.getClass().getSimpleName());
+ singletonServiceRegistration = clusterSingletonService.registerClusterSingletonService(this);
+ }
+
+ @Override
+ public void instantiateServiceInstance() {
+ LOG.info("Instantiating {}", this.getClass().getSimpleName());
+ sxpEpProviderProvider = new SxpEpProviderProviderImpl(dataBroker, endpointService, registry, sgtGeneratorConfig);
+ }
+
+ @Override
+ public ListenableFuture<Void> closeServiceInstance() {
+ LOG.info("Instance {} closed", this.getClass().getSimpleName());
+ try {
+ sxpEpProviderProvider.close();
+ } catch (Exception e) {
+ LOG.warn("Exception while closing ... {}", e.getMessage());
+ }
+ return Futures.immediateFuture(null);
+ }
+
+ @Override
+ public void close() throws Exception {
+ LOG.info("Clustering provider closed for {}", this.getClass().getSimpleName());
+ if (singletonServiceRegistration != null) {
+ try {
+ singletonServiceRegistration.close();
+ } catch (Exception e) {
+ LOG.warn("{} closed unexpectedly. Cause: {}", e.getMessage());
+ }
+ singletonServiceRegistration = null;
+ }
+ }
+
+ @Override
+ public ServiceGroupIdentifier getIdentifier() {
+ return IDENTIFIER;
+ }
+
+ @Override
+ public EPToSgtMapper getEPToSgtMapper() {
+ return sxpEpProviderProvider.getEPToSgtMapper();
+ }
+
+ @Override
+ public EPPolicyTemplateProviderRegistry getEPPolicyTemplateProviderRegistry() {
+ return sxpEpProviderProvider.getEPPolicyTemplateProviderRegistry();
+ }
+}
package org.opendaylight.controller.config.yang.config.groupbasedpolicy.sxp_integration.sxp_ep_provider;
-import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SxpEpProviderProviderImpl;
+
+import org.opendaylight.controller.sal.common.util.NoopAutoCloseable;
/**
* sxp-ep-provider impl module
@Override
public java.lang.AutoCloseable createInstance() {
- return new SxpEpProviderProviderImpl(getDataBrokerDependency(), getRpcRegistryDependency(),
- getDomainSpecificRegistryDependency());
+ return NoopAutoCloseable.INSTANCE;
}
}
package org.opendaylight.groupbasedpolicy.sxp.ep.provider.api;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.DSAsyncDao;
-import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.ReadableByKey;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.ReadableAsyncByKey;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EpPolicyTemplateValueKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
* Purpose: union of template-dao and template provider consumer
*/
public interface EPPolicyTemplateDaoFacade extends TemplateProviderDistributionTarget<EPPolicyTemplateProvider>,
- DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt>, ReadableByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> {
+ DSAsyncDao<Sgt, EndpointPolicyTemplateBySgt>, ReadableAsyncByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> {
}
--- /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.ep.provider.api;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
+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.sxp.database.rev160308.Sgt;
+
+/**
+ * Purpose: expose endpoint to sgt mapping
+ */
+public interface EPToSgtMapper {
+
+ /**
+ * @param endpointWithLocation peer which sgt is being searched for
+ * @return found sgt
+ */
+ ListenableFuture<Collection<Sgt>> findSgtForEP(AddressEndpointWithLocation endpointWithLocation);
+}
--- /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.ep.provider.impl;
+
+import com.google.common.base.Function;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
+import java.util.HashSet;
+import javax.annotation.Nullable;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateDaoFacade;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EpPolicyTemplateValueKey;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EpPolicyTemplateValueKeyFactory;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.util.EPTemplateUtil;
+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.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+
+/**
+ * Purpose: mapper implementation based on {@link ReadableAsyncByKey} (e.g.: {@link EPPolicyTemplateDaoFacade})
+ */
+public class EPToSgtMapperImpl implements EPToSgtMapper {
+
+ public static final Function<Collection<EndpointPolicyTemplateBySgt>, Collection<Sgt>> TRANSFORM_TEMPLATE_TO_SGT =
+ new Function<Collection<EndpointPolicyTemplateBySgt>, Collection<Sgt>>() {
+ @Nullable
+ @Override
+ public Collection<Sgt> apply(@Nullable final Collection<EndpointPolicyTemplateBySgt> input) {
+ final Collection<Sgt> sgtBag = new HashSet<>();
+ for (EndpointPolicyTemplateBySgt template : input) {
+ sgtBag.add(template.getSgt());
+ }
+ return sgtBag;
+ }
+ };
+
+ private final ReadableAsyncByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> epPolicyTemplateReader;
+ private final EpPolicyTemplateValueKeyFactory keyFactory;
+
+ public EPToSgtMapperImpl(final ReadableAsyncByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> epPolicyTemplateReader) {
+ this.epPolicyTemplateReader = epPolicyTemplateReader;
+ keyFactory = new EpPolicyTemplateValueKeyFactory(
+ EPTemplateUtil.createEndpointGroupIdOrdering(), EPTemplateUtil.createConditionNameOrdering());
+
+ }
+
+ @Override
+ public ListenableFuture<Collection<Sgt>> findSgtForEP(final AddressEndpointWithLocation endpointWithLocation) {
+ final EpPolicyTemplateValueKey rawKey = new EpPolicyTemplateValueKey(endpointWithLocation);
+ final EpPolicyTemplateValueKey key = keyFactory.sortValueKeyLists(rawKey);
+ return Futures.transform(epPolicyTemplateReader.readBy(key), TRANSFORM_TEMPLATE_TO_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.ep.provider.impl;
+
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Ordering;
+import com.google.common.collect.Range;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.util.EPTemplateUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+
+import java.util.Optional;
+
+/**
+ * Purpose: generate {@link Sgt} value on demand
+ */
+public class SgtGeneratorImpl {
+ private final Ordering<Sgt> sgtOrdering;
+ private Optional<Range<Integer>> sgtRange = Optional.empty();
+
+ public SgtGeneratorImpl(final SgtGeneratorConfig sgtGenerator) {
+ if (sgtGenerator != null) {
+ sgtRange = Optional.of(
+ Range.closed(sgtGenerator.getSgtLow().getValue(), sgtGenerator.getSgtHigh().getValue()));
+ }
+ sgtOrdering = EPTemplateUtil.createSgtOrdering();
+ }
+
+ /**
+ * @param templateCache source of used sgt items
+ * @return next free sgt
+ */
+ public java.util.Optional<Sgt> generateNextSgt(SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> templateCache) {
+ return sgtRange.flatMap(range ->
+ findTopUsedSgt(templateCache.keySet())
+ .map(topUsedSgt -> incrementSafely(range, topUsedSgt))
+ );
+ }
+
+ private Optional<Sgt> findTopUsedSgt(final Iterable<Sgt> sgts) {
+ return java.util.Optional.ofNullable(sgts)
+ .filter(sgtBag -> !Iterables.isEmpty(sgtBag))
+ .map(sgtOrdering::max);
+ }
+
+ private Sgt incrementSafely(final Range<Integer> range, final Sgt topUsedSgt) {
+ final Sgt applicableSgt;
+
+ final int nextMax = topUsedSgt.getValue() + 1;
+ if (range.contains(nextMax)) {
+ applicableSgt = new Sgt(nextMax);
+ } else if (nextMax < range.lowerEndpoint()) {
+ applicableSgt = new Sgt(range.lowerEndpoint());
+ } else {
+ applicableSgt = null;
+ }
+
+ return applicableSgt;
+ }
+}
* @return unmodifiable iterator through all cached values
*/
Iterable<V> values();
+
+ /**
+ * @return unmodifiable iterator through all cached keys
+ */
+ Iterable<K> keySet();
}
package org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-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.ep.provider.api.EPPolicyTemplateDaoFacade;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProviderRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EPForwardingTemplateDaoImpl;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EPPolicyTemplateDaoFacadeImpl;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EPPolicyTemplateDaoImpl;
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.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointForwardingTemplateBySubnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig;
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.slf4j.Logger;
private final DomainSpecificRegistry domainSpecificRegistry;
private final EndpointAugmentor sxpEndpointAugmentor;
private final EPPolicyTemplateProviderRegistry epPolicyTemplateRegistry;
+ private final EPToSgtMapper epToSgtMapper;
- public SxpEpProviderProviderImpl(final DataBroker dataBroker, final RpcProviderRegistry rpcRegistryDependency,
- final DomainSpecificRegistry domainSpecificRegistry) {
+ public SxpEpProviderProviderImpl(final DataBroker dataBroker, final BaseEndpointService endpointService,
+ final DomainSpecificRegistry domainSpecificRegistry, final SgtGeneratorConfig sgtGeneratorConfig) {
LOG.info("starting SxmMapper ..");
this.domainSpecificRegistry = domainSpecificRegistry;
- epPolicyTemplateRegistry = new EPPolicyTemplateProviderRegistryImpl();
-
- final BaseEndpointService endpointService = rpcRegistryDependency.getRpcService(BaseEndpointService.class);
+ // low level reactor
final SxpMapperReactor sxpMapperReactor = new SxpMapperReactorImpl(endpointService, dataBroker);
+ // cached dao layer for templates and master-database
final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao = new SimpleCachedDaoImpl<>();
final SimpleCachedDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateCachedDao =
new SimpleCachedDaoEPForwardingTemplateImpl();
final SimpleCachedDao<IpPrefix, MasterDatabaseBinding> masterDBBindingCachedDao = new SimpleCachedDaoImpl<>();
+ // reading dao layer for templates and master-database
final EpPolicyTemplateValueKeyFactory epPolicyTemplateKeyFactory = new EpPolicyTemplateValueKeyFactory(
EPTemplateUtil.createEndpointGroupIdOrdering(), EPTemplateUtil.createConditionNameOrdering());
final EPPolicyTemplateDaoImpl epPolicyTemplateDao = new EPPolicyTemplateDaoImpl(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory);
- final EPPolicyTemplateDaoFacade epPolicyTemplateDaoFacade = new EPPolicyTemplateDaoFacadeImpl(dataBroker, epPolicyTemplateDao);
- epPolicyTemplateRegistry.addDistributionTarget(epPolicyTemplateDaoFacade);
-
final EPForwardingTemplateDaoImpl epForwardingTemplateDao = new EPForwardingTemplateDaoImpl(dataBroker,
epForwardingTemplateCachedDao);
-
final MasterDatabaseBindingDaoImpl masterDBBindingDao = new MasterDatabaseBindingDaoImpl(dataBroker, masterDBBindingCachedDao);
+ // facade for ep-policy-template: reading dao + consumer of ise provider + template generator
+ final SgtGeneratorImpl sgtGeneratorImpl = new SgtGeneratorImpl(sgtGeneratorConfig);
+ final EPPolicyTemplateDaoFacade epPolicyTemplateDaoFacade = new EPPolicyTemplateDaoFacadeImpl(dataBroker,
+ epPolicyTemplateDao, epPolicyTemplateCachedDao, sgtGeneratorImpl);
+ epPolicyTemplateRegistry = new EPPolicyTemplateProviderRegistryImpl();
+ epPolicyTemplateRegistry.addDistributionTarget(epPolicyTemplateDaoFacade);
+ epToSgtMapper = new EPToSgtMapperImpl(epPolicyTemplateDaoFacade);
+
+ // DS-listeners for templates and master-database
sxpDatabaseListener = new MasterDatabaseBindingListenerImpl(dataBroker, sxpMapperReactor, masterDBBindingCachedDao,
epPolicyTemplateDaoFacade, epForwardingTemplateDao);
epPolicyTemplateListener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao,
masterDBBindingDao, epForwardingTemplateDao);
epForwardingTemplateListener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapperReactor, epForwardingTemplateCachedDao,
masterDBBindingDao, epPolicyTemplateDaoFacade);
- sxpEndpointAugmentor = new SxpEndpointAugmentorImpl(epPolicyTemplateDaoFacade, epPolicyTemplateKeyFactory);
+
+ // sxp-ep-augmentor -> deprecated, will use ep2sxpMapper service
+ sxpEndpointAugmentor = new SxpEndpointAugmentorImpl(epPolicyTemplateDao, epPolicyTemplateKeyFactory);
domainSpecificRegistry.getEndpointAugmentorRegistry().register(sxpEndpointAugmentor);
+
LOG.info("started SxmMapper");
}
return epPolicyTemplateRegistry;
}
+ @Override
+ public EPToSgtMapper getEPToSgtMapper() {
+ return epToSgtMapper;
+ }
+
@Override
public void close() throws Exception {
sxpDatabaseListener.close();
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
+import java.util.Collections;
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.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateDaoFacade;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SgtGeneratorImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SimpleCachedDao;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.SxpEpMapper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.TemplateGenerated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgtBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgtKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private static final Logger LOG = LoggerFactory.getLogger(EPPolicyTemplateDaoFacadeImpl.class);
private final EPPolicyTemplateDaoImpl epPolicyTemplateDao;
+ private final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao;
+ private final SgtGeneratorImpl sgtGenerator;
private final DataBroker dataBroker;
private EPPolicyTemplateProvider templateProvider;
- public EPPolicyTemplateDaoFacadeImpl(final DataBroker dataBroker, final EPPolicyTemplateDaoImpl epPolicyTemplateDao) {
+ public EPPolicyTemplateDaoFacadeImpl(final DataBroker dataBroker, final EPPolicyTemplateDaoImpl epPolicyTemplateDao,
+ final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao,
+ final SgtGeneratorImpl sgtGenerator) {
this.dataBroker = dataBroker;
this.epPolicyTemplateDao = epPolicyTemplateDao;
+ this.epPolicyTemplateCachedDao = epPolicyTemplateCachedDao;
+ this.sgtGenerator = sgtGenerator;
}
@Override
.child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(sgtValue));
wTx.put(LogicalDatastoreType.CONFIGURATION, epPolicyTemplatePath, template, true);
- return Futures.transform(wTx.submit(), createStoreOutcomeHandler(template));
+ return Futures.transform(wTx.submit(), createStoreOutcomeHandlerToOptional(template));
}
- private Function<Void, Optional<EndpointPolicyTemplateBySgt>> createStoreOutcomeHandler(final EndpointPolicyTemplateBySgt template) {
+ private Function<Void, Optional<EndpointPolicyTemplateBySgt>> createStoreOutcomeHandlerToOptional(final EndpointPolicyTemplateBySgt template) {
return new Function<Void, Optional<EndpointPolicyTemplateBySgt>>() {
@Nullable
@Override
};
}
+ private Function<Void, Collection<EndpointPolicyTemplateBySgt>> createStoreOutcomeHandlerToCollection(final EndpointPolicyTemplateBySgt template) {
+ return new Function<Void, Collection<EndpointPolicyTemplateBySgt>>() {
+ @Nullable
+ @Override
+ public Collection<EndpointPolicyTemplateBySgt> apply(@Nullable final Void aVoid) {
+ return Collections.singletonList(template);
+ }
+ };
+ }
+
@Override
- public Collection<EndpointPolicyTemplateBySgt> readBy(@Nonnull final EpPolicyTemplateValueKey specialKey) {
- return epPolicyTemplateDao.readBy(specialKey);
+ public ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> readBy(@Nonnull final EpPolicyTemplateValueKey templateLookupKey) {
+ //TODO: expose to ios-xe renderer,
+ final Collection<EndpointPolicyTemplateBySgt> templatesFromDao = epPolicyTemplateDao.readBy(templateLookupKey);
+ final ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> result;
+ if (!templatesFromDao.isEmpty()) {
+ result = Futures.immediateFuture(templatesFromDao);
+ } else {
+ // generate
+ result = sgtGenerator.generateNextSgt(epPolicyTemplateCachedDao)
+ // build ep-policy-template
+ .map(sgt -> buildEpPolicyTemplate(templateLookupKey, sgt))
+ // store the template
+ .map(this::storeTemplate)
+ .orElse(Futures.immediateFuture(Collections.emptyList()));
+ }
+ return result;
+ }
+
+ private ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> storeTemplate(final EndpointPolicyTemplateBySgt template) {
+ final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
+ // store ep-policy-template
+ final Sgt sgt = template.getSgt();
+ LOG.trace("storing generated epPolicyTemplate: {}", sgt.getValue());
+ final InstanceIdentifier<EndpointPolicyTemplateBySgt> epPolicyTemplatePath = InstanceIdentifier
+ .create(SxpEpMapper.class)
+ .child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(sgt));
+ wTx.put(LogicalDatastoreType.CONFIGURATION, epPolicyTemplatePath, template, true);
+
+ return Futures.transform(wTx.submit(), createStoreOutcomeHandlerToCollection(template));
+ }
+
+ private EndpointPolicyTemplateBySgt buildEpPolicyTemplate(final EpPolicyTemplateValueKey templateLookupKey, final Sgt sgt) {
+ return new EndpointPolicyTemplateBySgtBuilder()
+ .setOrigin(TemplateGenerated.class)
+ .setTenant(templateLookupKey.getTenantId())
+ .setSgt(sgt)
+ .setEndpointGroups(templateLookupKey.getEpgId())
+ .setConditions(templateLookupKey.getConditionName())
+ .build();
}
}
public Iterable<EndpointForwardingTemplateBySubnet> values() {
return Iterables.unmodifiableIterable(Iterables.concat(plainCache.values(), subnetCache.values()));
}
+
+ @Override
+ public Iterable<IpPrefix> keySet() {
+ // bypassing subnets
+ return Iterables.unmodifiableIterable(plainCache.keySet());
+ }
}
public Iterable<V> values() {
return Iterables.unmodifiableIterable(cache.values());
}
+
+ @Override
+ public Iterable<K> keySet() {
+ return Iterables.unmodifiableIterable(cache.keySet());
+ }
}
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.util.L3EPServiceUtil;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.util.SxpListenerUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.TemplateGenerated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointForwardingTemplateBySubnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
SxpListenerUtil.updateCachedDao(templateCachedDao, changeKey, change);
final EndpointPolicyTemplateBySgt epPolicyTemplate = change.getRootNode().getDataAfter();
- processWithEPTemplates(epPolicyTemplate);
+
+ // skip generated template
+ if (epPolicyTemplate != null && !TemplateGenerated.class.equals(epPolicyTemplate.getOrigin())) {
+ processWithEPTemplates(epPolicyTemplate);
+ } else {
+ LOG.trace("skipping ep-policy-template processing: {}", epPolicyTemplate);
+ }
}
}
return result;
}
-};
+ };
}
private AsyncFunction<Collection<MasterDatabaseBinding>, List<Pair<MasterDatabaseBinding, EndpointForwardingTemplateBySubnet>>>
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.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointForwardingTemplateBySubnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
/**
* Purpose: util methods for {@link EndpointForwardingTemplateBySubnet} and {@link EndpointPolicyTemplateBySgt}
});
}
+ public static Ordering<Sgt> createSgtOrdering() {
+ return Ordering.natural().onResultOf(new Function<Sgt, Comparable>() {
+ @Nullable
+ @Override
+ public Comparable apply(@Nullable final Sgt 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());
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProviderRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
/**
* Purpose: spi for sxp-ep-provider
* @return registry point for {@link EPPolicyTemplateProvider}
*/
EPPolicyTemplateProviderRegistry getEPPolicyTemplateProviderRegistry();
+
+ /**
+ * @return endpoint-to-sgt mapper
+ */
+ EPToSgtMapper getEPToSgtMapper();
}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
+ xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
+ odl:use-default-for-reference-types="true">
+
+ <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ <reference id="domainSpecificRegistry" interface="org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry"/>
+ <reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
+ <odl:rpc-service id="baseEndpointService"
+ interface="org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService"/>
+
+ <odl:clustered-app-config id="sgtGeneratorConfig"
+ binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig">
+ <odl:default-config><![CDATA[
+ <sgt-generator-config
+ xmlns="urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy:sxp-integration:sxp-ep-provider">
+ <sgt-low>100</sgt-low>
+ <sgt-high>200</sgt-high>
+ </sgt-generator-config>
+ ]]></odl:default-config>
+ </odl:clustered-app-config>
+
+ <bean id="sxpEpProvider"
+ class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.sxp_integration.sxp_ep_provider.SxpEpProviderProviderInstance"
+ init-method="initialize" destroy-method="close">
+ <argument ref="dataBroker"/>
+ <argument ref="baseEndpointService"/>
+ <argument ref="domainSpecificRegistry"/>
+ <argument ref="clusterSingletonService"/>
+ <argument ref="sgtGeneratorConfig"/>
+ </bean>
+
+ <service ref="sxpEpProvider" interface="org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider"/>
+</blueprint>
\ No newline at end of file
import config { prefix config; revision-date 2013-04-05; }
import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
import groupbasedpolicy-cfg {prefix gbpcfg; revision-date 2015-11-06; }
+ import sxp-database { prefix sxp-database; revision-date 2016-03-08; }
description
"This module contains the base YANG definitions for
augment "/config:modules/config:module/config:configuration" {
case sxp-ep-provider-impl {
when "/config:modules/config:module/config:type = 'sxp-ep-provider-impl'";
+ }
+ }
- //wires in the data-broker service
- container data-broker {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity mdsal:binding-async-data-broker;
- }
- }
- }
- //RPC Registry
- container rpc-registry {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity mdsal:binding-rpc-registry;
- }
- }
- }
- //Domain specific registry
- container domain-specific-registry {
- uses config:service-ref {
- refine type {
- mandatory true;
- config:required-identity gbpcfg:domain-specific-registry;
- }
- }
- }
+ container sgt-generator-config {
+ description "sgt-generator configuration";
+ leaf sgt-low {
+ type sxp-database:sgt;
+ mandatory true;
+ description "minimal SGT value to be used by sgt-generator";
+ }
+ leaf sgt-high {
+ type sxp-database:sgt;
+ mandatory true;
+ description "maximal SGT value to be used by sgt-generator";
}
}
}
--- /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.controller.config.yang.config.groupbasedpolicy.sxp_integration.sxp_ep_provider;
+
+import static org.powermock.api.mockito.PowerMockito.verifyNew;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProviderRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPToSgtMapper;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SxpEpProviderProviderImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+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.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+/**
+ * Test for {@link SxpEpProviderProviderInstance}.
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({SxpEpProviderProviderInstance.class})
+public class SxpEpProviderProviderInstanceTest {
+
+ @Mock
+ private DataBroker dataBroker;
+ @Mock
+ private BindingAwareBroker bindingAwareBroker;
+ @Mock
+ private ClusterSingletonServiceProvider clusterSingletonService;
+ @Mock
+ private BaseEndpointService endpointService;
+ @Mock
+ private DomainSpecificRegistry domainSpecificRegistry;
+ @Mock
+ private SgtGeneratorConfig sgtGeneratorConfig;
+ @Mock
+ private SxpEpProviderProvider sxpEpProvider;
+ @Mock
+ private ClusterSingletonServiceRegistration clusterSingletonRegistration;
+ @Mock
+ private SxpEpProviderProviderImpl sxpEpProviderProvider;
+ @Mock
+ private EPToSgtMapper epToSgtMapper;
+ @Mock
+ private EPPolicyTemplateProviderRegistry epPolicyTemplateProviderRegistry;
+
+ private SxpEpProviderProviderInstance instance;
+
+ @Before
+ public void setUp() throws Exception {
+ Mockito.when(clusterSingletonService.registerClusterSingletonService(Matchers.<ClusterSingletonService>any()))
+ .thenReturn(clusterSingletonRegistration);
+ Mockito.when(sxpEpProviderProvider.getEPToSgtMapper()).thenReturn(epToSgtMapper);
+ Mockito.when(sxpEpProviderProvider.getEPPolicyTemplateProviderRegistry()).thenReturn(epPolicyTemplateProviderRegistry);
+
+ whenNew(SxpEpProviderProviderImpl.class)
+ .withArguments(dataBroker, endpointService, domainSpecificRegistry, sgtGeneratorConfig)
+ .thenReturn(sxpEpProviderProvider);
+
+ instance = new SxpEpProviderProviderInstance(dataBroker, endpointService, domainSpecificRegistry,
+ clusterSingletonService, sgtGeneratorConfig);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ Mockito.verifyNoMoreInteractions(dataBroker, bindingAwareBroker, clusterSingletonService, sxpEpProvider,
+ clusterSingletonRegistration, sgtGeneratorConfig, endpointService, domainSpecificRegistry);
+ }
+
+ @Test
+ public void testInitialize() throws Exception {
+ instance.initialize();
+ Mockito.verify(clusterSingletonService).registerClusterSingletonService(instance);
+ }
+
+ @Test
+ public void testInstantiateServiceInstance() throws Exception {
+ instance.instantiateServiceInstance();
+
+ verifyNew(SxpEpProviderProviderImpl.class).withArguments(dataBroker, endpointService, domainSpecificRegistry,
+ sgtGeneratorConfig);
+ }
+
+ @Test
+ public void testCloseServiceInstance() throws Exception {
+ instance.instantiateServiceInstance();
+ final ListenableFuture<Void> future = instance.closeServiceInstance();
+
+ Mockito.verify(sxpEpProviderProvider).close();
+ Assert.assertTrue(future.isDone());
+ Assert.assertNull(future.get());
+ }
+
+ @Test
+ public void testCloseServiceInstance_null() throws Exception {
+ final ListenableFuture<Void> future = instance.closeServiceInstance();
+
+ Assert.assertTrue(future.isDone());
+ Assert.assertNull(future.get());
+ }
+
+ @Test
+ public void testClose() throws Exception {
+ instance.initialize();
+ Mockito.verify(clusterSingletonService).registerClusterSingletonService(instance);
+
+ instance.close();
+ Mockito.verify(clusterSingletonRegistration).close();
+ }
+
+ @Test
+ public void testClose_null() throws Exception {
+ instance.close();
+ }
+
+ @Test
+ public void testGetIdentifier() throws Exception {
+ final ServiceGroupIdentifier identifier = instance.getIdentifier();
+ Assert.assertEquals("gbp-service-group-identifier", identifier.getValue());
+ }
+
+ @Test
+ public void testGetEPToSgtMapper() throws Exception {
+ instance.instantiateServiceInstance();
+ Assert.assertEquals(epToSgtMapper, instance.getEPToSgtMapper());
+ }
+
+ @Test
+ public void testGetEPPolicyTemplateProviderRegistry() throws Exception {
+ instance.instantiateServiceInstance();
+ Assert.assertEquals(epPolicyTemplateProviderRegistry, instance.getEPPolicyTemplateProviderRegistry());
+ }
+}
\ No newline at end of file
--- /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.ep.provider.impl;
+
+import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
+import java.util.Collections;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EpPolicyTemplateValueKey;
+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.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.TemplateGenerated;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgtBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+
+/**
+ * Test for {@link EPToSgtMapperImpl}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class EPToSgtMapperImplTest {
+
+ private static final EndpointGroupId EPG_ID = new EndpointGroupId("epg-42");
+ private static final TenantId TENANT_ID = new TenantId("tenant-01");
+ private static final Sgt SGT = new Sgt(42);
+
+ @Mock
+ private ReadableAsyncByKey<EpPolicyTemplateValueKey, EndpointPolicyTemplateBySgt> templateReader;
+
+ private EPToSgtMapperImpl mapper;
+
+ @Before
+ public void setUp() throws Exception {
+ mapper = new EPToSgtMapperImpl(templateReader);
+ }
+
+ @Test
+ public void testFindSgtForEP() throws Exception {
+ final AddressEndpointWithLocation epWithLocation = new AddressEndpointWithLocationBuilder()
+ .setEndpointGroup(Collections.singletonList(EPG_ID))
+ .setTenant(TENANT_ID)
+ .setCondition(Collections.emptyList())
+ .build();
+
+ final EndpointPolicyTemplateBySgt epPolicyTemplate = new EndpointPolicyTemplateBySgtBuilder()
+ .setConditions(epWithLocation.getCondition())
+ .setTenant(epWithLocation.getTenant())
+ .setEndpointGroups(epWithLocation.getEndpointGroup())
+ .setSgt(SGT)
+ .setOrigin(TemplateGenerated.class)
+ .build();
+
+ Mockito.when(templateReader.readBy(Matchers.<EpPolicyTemplateValueKey>any()))
+ .thenReturn(Futures.immediateFuture(Collections.singletonList(epPolicyTemplate)));
+
+ final ListenableFuture<Collection<Sgt>> sgtForEP = mapper.findSgtForEP(epWithLocation);
+ Assert.assertTrue(sgtForEP.isDone());
+ final Collection<Sgt> sgts = sgtForEP.get();
+ Assert.assertEquals(1, sgts.size());
+ Assert.assertEquals(SGT, Iterables.getFirst(sgts, null));
+ }
+}
\ No newline at end of file
--- /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.ep.provider.impl;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.rev160722.SgtGeneratorConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * Test for {@link SgtGeneratorImpl}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class SgtGeneratorImplTest {
+
+ @Mock
+ private SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> templateDao;
+
+ private SgtGeneratorImpl generator;
+ private Set<Sgt> sgts;
+
+ @Before
+ public void setUp() throws Exception {
+ final SgtGeneratorConfig config = new SgtGeneratorConfigBuilder()
+ .setSgtLow(new Sgt(10))
+ .setSgtHigh(new Sgt(20))
+ .build();
+
+ sgts = new HashSet<>();
+ Mockito.when(templateDao.keySet()).thenReturn(sgts);
+ generator = new SgtGeneratorImpl(config);
+ }
+
+ @Test
+ public void testGenerateNextSgt_noData() throws Exception {
+ final Optional<Sgt> sgt = generator.generateNextSgt(templateDao);
+ Assert.assertFalse(sgt.isPresent());
+ }
+
+ @Test
+ public void testGenerateNextSgt_topIsAboveLimit() throws Exception {
+ sgts.add(new Sgt(20));
+ final Optional<Sgt> sgt = generator.generateNextSgt(templateDao);
+ Assert.assertFalse(sgt.isPresent());
+ }
+
+ @Test
+ public void testGenerateNextSgt_topIsBelowLimit() throws Exception {
+ sgts.add(new Sgt(9));
+ final Optional<Sgt> sgt = generator.generateNextSgt(templateDao);
+
+ Assert.assertTrue(sgt.isPresent());
+ Assert.assertEquals(10, sgt.get().getValue().intValue());
+ }
+
+ @Test
+ public void testGenerateNextSgt_withinLimits() throws Exception {
+ sgts.add(new Sgt(10));
+ final Optional<Sgt> sgt = generator.generateNextSgt(templateDao);
+
+ Assert.assertTrue(sgt.isPresent());
+ Assert.assertEquals(11, sgt.get().getValue().intValue());
+ }
+}
\ No newline at end of file
package org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl;
-import static org.powermock.api.mockito.PowerMockito.verifyNew;
-import static org.powermock.api.mockito.PowerMockito.whenNew;
-import static org.powermock.api.support.membermodification.MemberMatcher.method;
-import static org.powermock.api.support.membermodification.MemberModifier.stub;
-
import com.google.common.collect.Ordering;
import org.junit.Assert;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
import org.opendaylight.groupbasedpolicy.api.EndpointAugmentorRegistry;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EPForwardingTemplateDaoImpl;
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.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.rev160722.SgtGeneratorConfig;
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.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
+import static org.powermock.api.mockito.PowerMockito.verifyNew;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+import static org.powermock.api.support.membermodification.MemberMatcher.method;
+import static org.powermock.api.support.membermodification.MemberModifier.stub;
+
/**
* Test for {@link SxpEpProviderProviderImpl}.
*/
@Mock
private DataBroker dataBroker;
@Mock
- private RpcProviderRegistry rpcRegistry;
- @Mock
private DomainSpecificRegistry domainSpecificRegistry;
@Mock
private EPPolicyTemplateProviderRegistryImpl templateProviderRegistry;
@Mock
private SxpMapperReactorImpl sxpMapperReactor;
@Mock
- private BaseEndpointService endPointService;
+ private BaseEndpointService endpointService;
@Mock
private SimpleCachedDaoImpl<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao;
@Mock
private EndpointAugmentorRegistry epAugmentorRegistry;
@Mock
private EPPolicyTemplateDaoFacadeImpl epPolicyTemplateDaoFacade;
+ @Mock
+ private SgtGeneratorConfig sgtGeneratorConfig;
+ @Mock
+ private SgtGeneratorImpl sgtGenerator;
+ @Mock
+ private EPToSgtMapperImpl epToSgtMapper;
private SxpEpProviderProviderImpl provider;
@Before
public void setUp() throws Exception {
- Mockito.when(rpcRegistry.getRpcService(BaseEndpointService.class)).thenReturn(endPointService);
Mockito.when(domainSpecificRegistry.getEndpointAugmentorRegistry()).thenReturn(epAugmentorRegistry);
whenNew(EPPolicyTemplateProviderRegistryImpl.class).withNoArguments().thenReturn(templateProviderRegistry);
- whenNew(SxpMapperReactorImpl.class).withArguments(endPointService, dataBroker).thenReturn(sxpMapperReactor);
+ whenNew(SxpMapperReactorImpl.class).withArguments(endpointService, dataBroker).thenReturn(sxpMapperReactor);
whenNew(SimpleCachedDaoImpl.class).withNoArguments().thenReturn(epPolicyTemplateCachedDao, masterDBBindingCachedDao);
whenNew(SimpleCachedDaoEPForwardingTemplateImpl.class).withNoArguments().thenReturn(epFwTemplateCachedDao);
stub(method(EPTemplateUtil.class, "createEndpointGroupIdOrdering")).toReturn(groupOrdering);
.thenReturn(epPolicyTemplateKeyFactory);
whenNew(EPPolicyTemplateDaoImpl.class).withArguments(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory)
.thenReturn(epPolicyTemplateDao);
- whenNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao)
+ whenNew(SgtGeneratorImpl.class).withArguments(sgtGeneratorConfig).thenReturn(sgtGenerator);
+ whenNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao, epPolicyTemplateCachedDao, sgtGenerator)
.thenReturn(epPolicyTemplateDaoFacade);
+ whenNew(EPToSgtMapperImpl.class).withArguments(epPolicyTemplateDaoFacade).thenReturn(epToSgtMapper);
+
whenNew(EPForwardingTemplateDaoImpl.class).withArguments(dataBroker, epFwTemplateCachedDao)
.thenReturn(epForwardingTemplateDao);
whenNew(MasterDatabaseBindingDaoImpl.class).withArguments(dataBroker, masterDBBindingCachedDao)
masterDBBindingDao, epForwardingTemplateDao).thenReturn(epPolicyTemplateListener);
whenNew(EPForwardingTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epFwTemplateCachedDao,
masterDBBindingDao, epPolicyTemplateDaoFacade).thenReturn(epForwardingTemplateListener);
- whenNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDaoFacade,epPolicyTemplateKeyFactory)
+ whenNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDao, epPolicyTemplateKeyFactory)
.thenReturn(sxpEPAugmentor);
- provider = new SxpEpProviderProviderImpl(dataBroker, rpcRegistry, domainSpecificRegistry);
+ provider = new SxpEpProviderProviderImpl(dataBroker, endpointService, domainSpecificRegistry, sgtGeneratorConfig);
- Mockito.verify(rpcRegistry).getRpcService(BaseEndpointService.class);
Mockito.verify(templateProviderRegistry).addDistributionTarget(epPolicyTemplateDaoFacade);
Mockito.verify(epAugmentorRegistry).register(sxpEPAugmentor);
// check if all expected object got constructed and wired
verifyNew(EPPolicyTemplateProviderRegistryImpl.class).withNoArguments();
- verifyNew(SxpMapperReactorImpl.class).withArguments(endPointService, dataBroker);
+ verifyNew(SxpMapperReactorImpl.class).withArguments(endpointService, dataBroker);
verifyNew(SimpleCachedDaoImpl.class, Mockito.times(2)).withNoArguments();
verifyNew(SimpleCachedDaoEPForwardingTemplateImpl.class).withNoArguments();
verifyNew(EpPolicyTemplateValueKeyFactory.class).withArguments(groupOrdering, conditionOrdering);
verifyNew(EPPolicyTemplateDaoImpl.class).withArguments(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory);
- verifyNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao);
+ verifyNew(SgtGeneratorImpl.class).withArguments(sgtGeneratorConfig);
+ verifyNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao, epPolicyTemplateCachedDao, sgtGenerator);
+ verifyNew(EPToSgtMapperImpl.class).withArguments(epPolicyTemplateDaoFacade);
verifyNew(EPForwardingTemplateDaoImpl.class).withArguments(dataBroker, epFwTemplateCachedDao);
verifyNew(MasterDatabaseBindingDaoImpl.class).withArguments(dataBroker, masterDBBindingCachedDao);
verifyNew(MasterDatabaseBindingListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, masterDBBindingCachedDao,
masterDBBindingDao, epForwardingTemplateDao);
verifyNew(EPForwardingTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epFwTemplateCachedDao,
masterDBBindingDao, epPolicyTemplateDaoFacade);
- verifyNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDaoFacade,epPolicyTemplateKeyFactory);
+ verifyNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDao, epPolicyTemplateKeyFactory);
}
@Test
package org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao;
import com.google.common.base.Optional;
+import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import org.hamcrest.BaseMatcher;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SgtGeneratorImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SimpleCachedDao;
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.integration.sxp.ep.provider.model.rev160302.TemplateGenerated;
@Mock
private EPPolicyTemplateDaoImpl delegateDao;
@Mock
+ private SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> delegateCachedDao;
+ @Mock
private DataBroker dataBroker;
@Mock
private EPPolicyTemplateProvider provider;
@Mock
+ private SgtGeneratorImpl sgtGeneratorImpl;
+ @Mock
private WriteTransaction wTx;
private EndpointPolicyTemplateBySgtBuilder templateBld;
private EPPolicyTemplateDaoFacadeImpl facade;
+ private EndpointPolicyTemplateBySgt first;
@Before
public void setUp() throws Exception {
.setSgt(SGT)
.setEndpointGroups(Collections.singletonList(EPG_ID));
- facade = new EPPolicyTemplateDaoFacadeImpl(dataBroker, delegateDao);
+ facade = new EPPolicyTemplateDaoFacadeImpl(dataBroker, delegateDao, delegateCachedDao, sgtGeneratorImpl);
}
@Test
});
actual.get();
}
+
+ @Test
+ public void testReadBy() throws Exception {
+ Mockito.when(sgtGeneratorImpl.generateNextSgt(delegateCachedDao))
+ .thenReturn(java.util.Optional.empty())
+ .thenReturn(java.util.Optional.of(new Sgt(42)));
+
+ final EpPolicyTemplateValueKey lookupKey = new EpPolicyTemplateValueKey(TENANT_ID,
+ Collections.singletonList(EPG_ID), Collections.emptyList());
+
+ final ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> templateFail = facade.readBy(lookupKey);
+ Assert.assertTrue(templateFail.isDone());
+ Assert.assertTrue(templateFail.get().isEmpty());
+
+ final ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> templateSuccess = facade.readBy(lookupKey);
+ Assert.assertTrue(templateSuccess.isDone());
+ final Collection<EndpointPolicyTemplateBySgt> templateBag = templateSuccess.get();
+ Assert.assertFalse(templateBag.isEmpty());
+ first = Iterables.getFirst(templateBag, null);
+ Assert.assertNotNull(templateBag);
+ Assert.assertEquals(TemplateGenerated.class, first.getOrigin());
+ Assert.assertEquals(Collections.singletonList(EPG_ID), Iterables.getFirst(templateBag, null).getEndpointGroups());
+ Assert.assertTrue(Iterables.getFirst(templateBag, null).getConditions().isEmpty());
+ Assert.assertEquals(42, Iterables.getFirst(templateBag, null).getSgt().getValue().intValue());
+ }
}
\ No newline at end of file
Code Review / groupbasedpolicy.git / commitdiff