<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-module-junit4</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-api-mockito</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<!-- project build -->
--- /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 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.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> {
+}
package org.opendaylight.groupbasedpolicy.sxp.ep.provider.api;
import java.util.Optional;
+import javax.annotation.Nonnull;
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.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
/**
* @param sgt of template
- * @param tenantId of template
* @return template if available (expecting empty conditions field)
*/
- Optional<EndpointPolicyTemplateBySgt> provideTemplate(final Sgt sgt, final TenantId tenantId);
+ Optional<EndpointPolicyTemplateBySgt> provideTemplate(@Nonnull final Sgt sgt);
}
/**
* Purpose: injection point for a {@link EPPolicyTemplateProvider}
*/
-public interface EPPolicyTemplateProviderRegistry {
+public interface EPPolicyTemplateProviderRegistry extends AutoCloseable {
/**
* @param templateProvider provider to register
* @return corresponding registration
*/
ObjectRegistration<EPPolicyTemplateProvider> registerTemplateProvider(EPPolicyTemplateProvider templateProvider);
+
+ /**
+ * @param templateProviderDistributionTarget consumer of template provider
+ */
+ void addDistributionTarget(TemplateProviderDistributionTarget<EPPolicyTemplateProvider> templateProviderDistributionTarget);
+
+ @Override
+ void close();
}
--- /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;
+
+/**
+ * Purpose: support injecting of template provider
+ */
+public interface TemplateProviderDistributionTarget<T> {
+
+ /**
+ * @param templateProvider current template provider
+ */
+ void setTemplateProvider(T templateProvider);
+
+}
+++ /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.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
-import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProviderRegistry;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
-
-/**
- * Purpose: provide registration and internal distribution for obtained {@link EPPolicyTemplateProvider}
- */
-public class EPPolicyTemplateFacade implements EPPolicyTemplateProviderRegistry {
- @Override
- public ObjectRegistration<EPPolicyTemplateProvider> registerTemplateProvider(final EPPolicyTemplateProvider templateProvider) {
- //TODO stub
- return null;
- }
-}
--- /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.Sets;
+import java.util.Set;
+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.TemplateProviderDistributionTarget;
+import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
+
+/**
+ * Purpose: provide registration and internal distribution for obtained {@link EPPolicyTemplateProvider}
+ */
+public class EPPolicyTemplateProviderRegistryImpl implements EPPolicyTemplateProviderRegistry {
+ private EPPolicyTemplateProvider templateProvider;
+ private Set<TemplateProviderDistributionTarget<EPPolicyTemplateProvider>> distributionTargets = Sets.newConcurrentHashSet();
+
+ @Override
+ public ObjectRegistration<EPPolicyTemplateProvider> registerTemplateProvider(final EPPolicyTemplateProvider templateProvider) {
+ distributeTemplateProvider(templateProvider);
+ return new AbstractObjectRegistration<EPPolicyTemplateProvider>(templateProvider) {
+ @Override
+ protected void removeRegistration() {
+ distributeTemplateProvider(null);
+ }
+ };
+ }
+
+ @Override
+ public void addDistributionTarget(final TemplateProviderDistributionTarget<EPPolicyTemplateProvider> templateProviderDistributionTarget) {
+ distributionTargets.add(templateProviderDistributionTarget);
+ if (templateProvider != null) {
+ templateProviderDistributionTarget.setTemplateProvider(templateProvider);
+ }
+ }
+
+ /**
+ * inject given templateProvider into available targets
+ * @param templateProvider current provider
+ */
+ private void distributeTemplateProvider(final EPPolicyTemplateProvider templateProvider) {
+ this.templateProvider = templateProvider;
+ for (TemplateProviderDistributionTarget<EPPolicyTemplateProvider> distributionTarget : distributionTargets) {
+ distributionTarget.setTemplateProvider(templateProvider);
+ }
+ }
+
+ @Override
+ public void close() {
+ distributeTemplateProvider(null);
+ distributionTargets.clear();
+ }
+}
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.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.groupbasedpolicy.sxp.ep.provider.impl.dao.EpPolicyTemplateValueKeyFactory;
import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.MasterDatabaseBindingDaoImpl;
private static final Logger LOG = LoggerFactory.getLogger(SxpEpProviderProviderImpl.class);
private final MasterDatabaseBindingListenerImpl sxpDatabaseListener;
- private final SxpMapperReactor sxpMapperReactor;
private final EPTemplateListener epPolicyTemplateListener;
private final EPTemplateListener epForwardingTemplateListener;
private final DomainSpecificRegistry domainSpecificRegistry;
LOG.info("starting SxmMapper ..");
this.domainSpecificRegistry = domainSpecificRegistry;
- epPolicyTemplateRegistry = new EPPolicyTemplateFacade();
+ epPolicyTemplateRegistry = new EPPolicyTemplateProviderRegistryImpl();
final BaseEndpointService endpointService = rpcRegistryDependency.getRpcService(BaseEndpointService.class);
- sxpMapperReactor = new SxpMapperReactorImpl(endpointService, dataBroker);
+ final SxpMapperReactor sxpMapperReactor = new SxpMapperReactorImpl(endpointService, dataBroker);
final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao = new SimpleCachedDaoImpl<>();
final SimpleCachedDao<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateCachedDao =
final EpPolicyTemplateValueKeyFactory epPolicyTemplateKeyFactory = new EpPolicyTemplateValueKeyFactory(
EPTemplateUtil.createEndpointGroupIdOrdering(), EPTemplateUtil.createConditionNameOrdering());
final EPPolicyTemplateDaoImpl epPolicyTemplateDao = new EPPolicyTemplateDaoImpl(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory);
- //TODO: inject delegate (ise-adapter-provider)
+ final EPPolicyTemplateDaoFacade epPolicyTemplateDaoFacade = new EPPolicyTemplateDaoFacadeImpl(dataBroker, epPolicyTemplateDao);
+ epPolicyTemplateRegistry.addDistributionTarget(epPolicyTemplateDaoFacade);
+
final EPForwardingTemplateDaoImpl epForwardingTemplateDao = new EPForwardingTemplateDaoImpl(dataBroker,
epForwardingTemplateCachedDao);
+
final MasterDatabaseBindingDaoImpl masterDBBindingDao = new MasterDatabaseBindingDaoImpl(dataBroker, masterDBBindingCachedDao);
sxpDatabaseListener = new MasterDatabaseBindingListenerImpl(dataBroker, sxpMapperReactor, masterDBBindingCachedDao,
- epPolicyTemplateDao, epForwardingTemplateDao);
+ epPolicyTemplateDaoFacade, epForwardingTemplateDao);
epPolicyTemplateListener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao,
masterDBBindingDao, epForwardingTemplateDao);
epForwardingTemplateListener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapperReactor, epForwardingTemplateCachedDao,
- masterDBBindingDao, epPolicyTemplateDao);
- sxpEndpointAugmentor = new SxpEndpointAugmentorImpl(epPolicyTemplateDao, epPolicyTemplateKeyFactory);
+ masterDBBindingDao, epPolicyTemplateDaoFacade);
+ sxpEndpointAugmentor = new SxpEndpointAugmentorImpl(epPolicyTemplateDaoFacade, epPolicyTemplateKeyFactory);
domainSpecificRegistry.getEndpointAugmentorRegistry().register(sxpEndpointAugmentor);
LOG.info("started SxmMapper");
}
sxpDatabaseListener.close();
epPolicyTemplateListener.close();
epForwardingTemplateListener.close();
+ epPolicyTemplateRegistry.close();
domainSpecificRegistry.getEndpointAugmentorRegistry().unregister(sxpEndpointAugmentor);
}
}
--- /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.dao;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+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.binding.api.WriteTransaction;
+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.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.common.rev140421.Name;
+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.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.EndpointPolicyTemplateBySgtKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Purpose: add template provider fallback to {@link EPPolicyTemplateDaoImpl}
+ */
+public class EPPolicyTemplateDaoFacadeImpl implements EPPolicyTemplateDaoFacade {
+
+ private static final Logger LOG = LoggerFactory.getLogger(EPPolicyTemplateDaoFacadeImpl.class);
+
+ private final EPPolicyTemplateDaoImpl epPolicyTemplateDao;
+ private final DataBroker dataBroker;
+
+ private EPPolicyTemplateProvider templateProvider;
+
+ public EPPolicyTemplateDaoFacadeImpl(final DataBroker dataBroker, final EPPolicyTemplateDaoImpl epPolicyTemplateDao) {
+ this.dataBroker = dataBroker;
+ this.epPolicyTemplateDao = epPolicyTemplateDao;
+ }
+
+ @Override
+ public void setTemplateProvider(final EPPolicyTemplateProvider templateProvider) {
+ this.templateProvider = templateProvider;
+ }
+
+
+ @Override
+ public ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> read(@Nonnull final Sgt key) {
+ // read from delegate
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> templateFu = epPolicyTemplateDao.read(key);
+
+ // involve fallback if template is absent
+ return Futures.transform(templateFu, new AsyncFunction<Optional<EndpointPolicyTemplateBySgt>, Optional<EndpointPolicyTemplateBySgt>>() {
+ @Override
+ public ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> apply(
+ @Nonnull final Optional<EndpointPolicyTemplateBySgt> templateOpt) throws Exception {
+
+ return templateOpt.transform(template -> Futures.immediateFuture(templateOpt))
+ // failed to read template -> invoke fallback if available
+ .or(() -> java.util.Optional.ofNullable(templateProvider)
+ .flatMap(provider -> templateProvider.provideTemplate(key))
+ .map(template -> storeTemplateAndEpg(template))
+ .orElse(Futures.immediateFuture(Optional.absent()))
+ );
+ }
+ });
+ }
+
+ private ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> storeTemplateAndEpg(final EndpointPolicyTemplateBySgt template) {
+ // store EPG (presume that it does not exist)
+ final Sgt sgtValue = template.getSgt();
+ LOG.trace("storing EPGs for generated epPolicyTemplate: {} [{}]",
+ sgtValue.getValue(), template.getEndpointGroups().size());
+ final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
+
+ boolean createParent = true;
+ for (EndpointGroupId epgId : template.getEndpointGroups()) {
+ final InstanceIdentifier<EndpointGroup> epgPath = IidFactory.endpointGroupIid(template.getTenant(), epgId);
+ final EndpointGroup epg = new EndpointGroupBuilder()
+ .setId(epgId)
+ .setDescription(new Description("imported from ISE for sgt=" + sgtValue.getValue()))
+ .setName(new Name(String.format("%s_ISE_SGT_%d", epgId.getValue(), sgtValue.getValue())))
+ .build();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, epgPath, epg, createParent);
+ createParent = false;
+ }
+
+ // store ep-policy-template
+ LOG.trace("storing generated epPolicyTemplate: {}", sgtValue.getValue());
+ final InstanceIdentifier<EndpointPolicyTemplateBySgt> epPolicyTemplatePath = InstanceIdentifier
+ .create(SxpEpMapper.class)
+ .child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(sgtValue));
+ wTx.put(LogicalDatastoreType.CONFIGURATION, epPolicyTemplatePath, template, true);
+
+ return Futures.transform(wTx.submit(), createStoreOutcomeHandler(template));
+ }
+
+ private Function<Void, Optional<EndpointPolicyTemplateBySgt>> createStoreOutcomeHandler(final EndpointPolicyTemplateBySgt template) {
+ return new Function<Void, Optional<EndpointPolicyTemplateBySgt>>() {
+ @Nullable
+ @Override
+ public Optional<EndpointPolicyTemplateBySgt> apply(@Nullable final Void aVoid) {
+ return Optional.of(template);
+ }
+ };
+ }
+
+ @Override
+ public Collection<EndpointPolicyTemplateBySgt> readBy(@Nonnull final EpPolicyTemplateValueKey specialKey) {
+ return epPolicyTemplateDao.readBy(specialKey);
+ }
+}
*/
package org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
@Override
public ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> read(@Nonnull final Sgt key) {
- final Optional<EndpointPolicyTemplateBySgt> cachedEndpointPolicyTemplateBySgtalue = lookup(cachedDao, key);
- if (cachedEndpointPolicyTemplateBySgtalue.isPresent()) {
- return Futures.immediateFuture(cachedEndpointPolicyTemplateBySgtalue);
+ final Optional<EndpointPolicyTemplateBySgt> cachedEndpointPolicyTemplateBySgtValue = lookup(cachedDao, key);
+ if (cachedEndpointPolicyTemplateBySgtValue.isPresent()) {
+ return Futures.immediateFuture(cachedEndpointPolicyTemplateBySgtValue);
} else if (!cachedDao.isEmpty()) {
- //TODO: delegate to ise-template-provider
return READ_FUTURE_ABSENT;
} else {
final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
}
}
+ @VisibleForTesting
protected InstanceIdentifier<EndpointPolicyTemplateBySgt> buildReadPath(final Sgt key) {
return EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH
.child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(key));
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;
+ status deprecated;
+ description "deprecated: to be replaced by sxp-ep-provider mechanism (lookup template with sgt or generate 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 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.api.EPPolicyTemplateProvider;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.TemplateProviderDistributionTarget;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
+
+/**
+ * Test for {@link EPPolicyTemplateProviderRegistryImpl}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class EPPolicyTemplateProviderRegistryImplTest {
+
+ @Mock
+ private EPPolicyTemplateProvider templateProvider;
+ @Mock
+ private TemplateProviderDistributionTarget<EPPolicyTemplateProvider> target1;
+ @Mock
+ private TemplateProviderDistributionTarget<EPPolicyTemplateProvider> target2;
+ @Mock
+ private TemplateProviderDistributionTarget<EPPolicyTemplateProvider> target3;
+
+ private EPPolicyTemplateProviderRegistryImpl registry;
+
+ @Before
+ public void setUp() throws Exception {
+ registry = new EPPolicyTemplateProviderRegistryImpl();
+ }
+
+ @Test
+ public void testRegisterTemplateProvider() throws Exception {
+ registry.addDistributionTarget(target1);
+ final ObjectRegistration<EPPolicyTemplateProvider> registration = registry.registerTemplateProvider(templateProvider);
+ Mockito.verify(target1).setTemplateProvider(templateProvider);
+ registry.addDistributionTarget(target2);
+ Mockito.verify(target2).setTemplateProvider(templateProvider);
+
+ registration.close();
+ Mockito.verify(target1).setTemplateProvider(null);
+ Mockito.verify(target2).setTemplateProvider(null);
+ registry.addDistributionTarget(target3);
+
+ Mockito.verifyNoMoreInteractions(target1, target2, target3);
+ }
+
+ @Test
+ public void testAddDistributionTarget() throws Exception {
+ registry.addDistributionTarget(target1);
+ Mockito.verify(target1, Mockito.never()).setTemplateProvider(Matchers.<EPPolicyTemplateProvider>any());
+
+ registry.registerTemplateProvider(templateProvider);
+ Mockito.verify(target1).setTemplateProvider(templateProvider);
+
+ registry.addDistributionTarget(target2);
+ Mockito.verify(target2).setTemplateProvider(templateProvider);
+ }
+
+ @Test
+ public void testClose() throws Exception {
+ registry.addDistributionTarget(target1);
+ final ObjectRegistration<EPPolicyTemplateProvider> registration = registry.registerTemplateProvider(templateProvider);
+ registry.addDistributionTarget(target2);
+ Mockito.verify(target1).setTemplateProvider(templateProvider);
+ Mockito.verify(target2).setTemplateProvider(templateProvider);
+
+ registry.close();
+ Mockito.verify(target1).setTemplateProvider(null);
+ Mockito.verify(target2).setTemplateProvider(null);
+
+ Mockito.verifyNoMoreInteractions(target1, target2);
+ }
+}
\ 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 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.junit.Test;
+import org.junit.runner.RunWith;
+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.groupbasedpolicy.sxp.ep.provider.impl.dao.EPPolicyTemplateDaoFacadeImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EPPolicyTemplateDaoImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.EpPolicyTemplateValueKeyFactory;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.MasterDatabaseBindingDaoImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.SimpleCachedDaoEPForwardingTemplateImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao.SimpleCachedDaoImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.listen.EPForwardingTemplateListenerImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.listen.EPPolicyTemplateListenerImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.listen.MasterDatabaseBindingListenerImpl;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.util.EPTemplateUtil;
+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.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService;
+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.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;
+
+/**
+ * Test for {@link SxpEpProviderProviderImpl}.
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({SxpEpProviderProviderImpl.class, EPTemplateUtil.class})
+public class SxpEpProviderProviderImplTest {
+
+ @Mock
+ private DataBroker dataBroker;
+ @Mock
+ private RpcProviderRegistry rpcRegistry;
+ @Mock
+ private DomainSpecificRegistry domainSpecificRegistry;
+ @Mock
+ private EPPolicyTemplateProviderRegistryImpl templateProviderRegistry;
+ @Mock
+ private SxpMapperReactorImpl sxpMapperReactor;
+ @Mock
+ private BaseEndpointService endPointService;
+ @Mock
+ private SimpleCachedDaoImpl<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao;
+ @Mock
+ private SimpleCachedDaoImpl<IpPrefix, MasterDatabaseBinding> masterDBBindingCachedDao;
+ @Mock
+ private SimpleCachedDaoEPForwardingTemplateImpl epFwTemplateCachedDao;
+ @Mock
+ private Ordering<EndpointGroupId> groupOrdering;
+ @Mock
+ private Ordering<ConditionName> conditionOrdering;
+ @Mock
+ private EpPolicyTemplateValueKeyFactory epPolicyTemplateKeyFactory;
+ @Mock
+ private EPPolicyTemplateDaoImpl epPolicyTemplateDao;
+ @Mock
+ private EPForwardingTemplateDaoImpl epForwardingTemplateDao;
+ @Mock
+ private MasterDatabaseBindingDaoImpl masterDBBindingDao;
+ @Mock
+ private MasterDatabaseBindingListenerImpl masterDBBindingListener;
+ @Mock
+ private EPPolicyTemplateListenerImpl epPolicyTemplateListener;
+ @Mock
+ private EPForwardingTemplateListenerImpl epForwardingTemplateListener;
+ @Mock
+ private SxpEndpointAugmentorImpl sxpEPAugmentor;
+ @Mock
+ private EndpointAugmentorRegistry epAugmentorRegistry;
+ @Mock
+ private EPPolicyTemplateDaoFacadeImpl epPolicyTemplateDaoFacade;
+
+ 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(SimpleCachedDaoImpl.class).withNoArguments().thenReturn(epPolicyTemplateCachedDao, masterDBBindingCachedDao);
+ whenNew(SimpleCachedDaoEPForwardingTemplateImpl.class).withNoArguments().thenReturn(epFwTemplateCachedDao);
+ stub(method(EPTemplateUtil.class, "createEndpointGroupIdOrdering")).toReturn(groupOrdering);
+ stub(method(EPTemplateUtil.class, "createConditionNameOrdering")).toReturn(conditionOrdering);
+ whenNew(EpPolicyTemplateValueKeyFactory.class).withArguments(groupOrdering, conditionOrdering)
+ .thenReturn(epPolicyTemplateKeyFactory);
+ whenNew(EPPolicyTemplateDaoImpl.class).withArguments(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory)
+ .thenReturn(epPolicyTemplateDao);
+ whenNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao)
+ .thenReturn(epPolicyTemplateDaoFacade);
+ whenNew(EPForwardingTemplateDaoImpl.class).withArguments(dataBroker, epFwTemplateCachedDao)
+ .thenReturn(epForwardingTemplateDao);
+ whenNew(MasterDatabaseBindingDaoImpl.class).withArguments(dataBroker, masterDBBindingCachedDao)
+ .thenReturn(masterDBBindingDao);
+ whenNew(MasterDatabaseBindingListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, masterDBBindingCachedDao,
+ epPolicyTemplateDaoFacade, epForwardingTemplateDao).thenReturn(masterDBBindingListener);
+ whenNew(EPPolicyTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao,
+ masterDBBindingDao, epForwardingTemplateDao).thenReturn(epPolicyTemplateListener);
+ whenNew(EPForwardingTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epFwTemplateCachedDao,
+ masterDBBindingDao, epPolicyTemplateDaoFacade).thenReturn(epForwardingTemplateListener);
+ whenNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDaoFacade,epPolicyTemplateKeyFactory)
+ .thenReturn(sxpEPAugmentor);
+
+
+ provider = new SxpEpProviderProviderImpl(dataBroker, rpcRegistry, domainSpecificRegistry);
+
+ 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(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(EPForwardingTemplateDaoImpl.class).withArguments(dataBroker, epFwTemplateCachedDao);
+ verifyNew(MasterDatabaseBindingDaoImpl.class).withArguments(dataBroker, masterDBBindingCachedDao);
+ verifyNew(MasterDatabaseBindingListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, masterDBBindingCachedDao,
+ epPolicyTemplateDaoFacade, epForwardingTemplateDao);
+ verifyNew(EPPolicyTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao,
+ masterDBBindingDao, epForwardingTemplateDao);
+ verifyNew(EPForwardingTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epFwTemplateCachedDao,
+ masterDBBindingDao, epPolicyTemplateDaoFacade);
+ verifyNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDaoFacade,epPolicyTemplateKeyFactory);
+ }
+
+ @Test
+ public void testGetEPPolicyTemplateProviderRegistry() throws Exception {
+ Assert.assertSame(templateProviderRegistry, provider.getEPPolicyTemplateProviderRegistry());
+ }
+
+ @Test
+ public void testClose() throws Exception {
+ provider.close();
+ Mockito.verify(masterDBBindingListener).close();
+ Mockito.verify(epPolicyTemplateListener).close();
+ Mockito.verify(epForwardingTemplateListener).close();
+ Mockito.verify(templateProviderRegistry).close();
+ Mockito.verify(epAugmentorRegistry).unregister(sxpEPAugmentor);
+ }
+}
\ 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.dao;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collections;
+import java.util.concurrent.ExecutionException;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
+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;
+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 EPPolicyTemplateDaoFacadeImpl}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class EPPolicyTemplateDaoFacadeImplTest {
+
+ private static final Sgt SGT = new Sgt(42);
+ private static final TenantId TENANT_ID = new TenantId("tenant-01");
+ private static final EndpointGroupId EPG_ID = new EndpointGroupId("epg-01");
+ private static final TransactionCommitFailedException TX_EXCEPTION = new TransactionCommitFailedException("unit-txSubmit-error");
+
+ @Rule
+ public ExpectedException thrownRule = ExpectedException.none();
+
+ @Mock
+ private EPPolicyTemplateDaoImpl delegateDao;
+ @Mock
+ private DataBroker dataBroker;
+ @Mock
+ private EPPolicyTemplateProvider provider;
+ @Mock
+ private WriteTransaction wTx;
+
+
+ private EndpointPolicyTemplateBySgtBuilder templateBld;
+ private EPPolicyTemplateDaoFacadeImpl facade;
+
+ @Before
+ public void setUp() throws Exception {
+ Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture((Void) null));
+ Mockito.when(dataBroker.newWriteOnlyTransaction()).thenReturn(wTx);
+ templateBld = new EndpointPolicyTemplateBySgtBuilder()
+ .setTenant(TENANT_ID)
+ .setSgt(SGT)
+ .setEndpointGroups(Collections.singletonList(EPG_ID));
+
+ facade = new EPPolicyTemplateDaoFacadeImpl(dataBroker, delegateDao);
+ }
+
+ @Test
+ public void testRead_trivial() throws Exception {
+ final EndpointPolicyTemplateBySgt template = templateBld.build();
+ Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.of(template)));
+
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
+ Assert.assertTrue(actual.isDone());
+ Assert.assertTrue(actual.get().isPresent());
+ Assert.assertEquals(template, actual.get().get());
+ }
+
+ @Test
+ public void testRead_success() throws Exception {
+ final EndpointPolicyTemplateBySgt template = templateBld
+ .setOrigin(TemplateGenerated.class)
+ .build();
+
+ Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
+ Mockito.when(provider.provideTemplate(SGT)).thenReturn(java.util.Optional.of(template));
+ Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ facade.setTemplateProvider(provider);
+
+
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
+ Assert.assertTrue(actual.isDone());
+ Assert.assertTrue(actual.get().isPresent());
+ Assert.assertEquals(template, actual.get().get());
+ }
+
+ @Test
+ public void testRead_failNoProvider() throws Exception {
+ Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
+
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
+ Assert.assertTrue(actual.isDone());
+ Assert.assertFalse(actual.get().isPresent());
+ }
+
+ @Test
+ public void testRead_failProviderMiss() throws Exception {
+ Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
+ Mockito.when(provider.provideTemplate(SGT)).thenReturn(java.util.Optional.empty());
+ facade.setTemplateProvider(provider);
+
+
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
+ Assert.assertTrue(actual.isDone());
+ Assert.assertFalse(actual.get().isPresent());
+ }
+
+ @Test
+ public void testRead_failProviderStoreError() throws Exception {
+ Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
+ final EndpointPolicyTemplateBySgt template = templateBld
+ .setOrigin(TemplateGenerated.class)
+ .build();
+
+ Mockito.when(delegateDao.read(SGT)).thenReturn(Futures.immediateFuture(Optional.absent()));
+ Mockito.when(provider.provideTemplate(SGT)).thenReturn(java.util.Optional.of(template));
+ Mockito.when(wTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(TX_EXCEPTION));
+ facade.setTemplateProvider(provider);
+
+ final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> actual = facade.read(SGT);
+ Assert.assertTrue(actual.isDone());
+
+ // prepare exception rule
+ thrownRule.expect(ExecutionException.class);
+ thrownRule.expectCause(new BaseMatcher<Throwable>() {
+ @Override
+ public boolean matches(final Object item) {
+ return TX_EXCEPTION == item;
+ }
+
+ @Override
+ public void describeTo(final Description description) {
+ description.appendText("TransactionCommitFailedException");
+ }
+ });
+ actual.get();
+ }
+}
\ No newline at end of file
import org.opendaylight.controller.config.yang.config.groupbasedpolicy.GroupbasedpolicyInstance;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
import org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.GbpIseAdapterProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
private final DataBroker dataBroker;
private final BindingAwareBroker bindingAwareBroker;
private final ClusterSingletonServiceProvider clusterSingletonService;
+ private final SxpEpProviderProvider sxpEpProvider;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
private GbpIseAdapterProvider iseAdapterProvider;
public GbpIseAdapterProviderInstance(final DataBroker dataBroker,
final BindingAwareBroker bindingAwareBroker,
- final ClusterSingletonServiceProvider clusterSingletonService) {
+ final ClusterSingletonServiceProvider clusterSingletonService,
+ final SxpEpProviderProvider sxpEpProvider) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.bindingAwareBroker = Preconditions.checkNotNull(bindingAwareBroker);
this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
+ this.sxpEpProvider = Preconditions.checkNotNull(sxpEpProvider);
}
public void initialize() {
@Override
public void instantiateServiceInstance() {
LOG.info("Instantiating {}", this.getClass().getSimpleName());
- iseAdapterProvider = new GbpIseAdapterProvider(dataBroker, bindingAwareBroker);
+ iseAdapterProvider = new GbpIseAdapterProvider(dataBroker, bindingAwareBroker, sxpEpProvider);
}
@Override
public ListenableFuture<Void> closeServiceInstance() {
LOG.info("Instance {} closed", this.getClass().getSimpleName());
- iseAdapterProvider.close();
+ try {
+ iseAdapterProvider.close();
+ } catch (Exception e) {
+ LOG.warn("iseAdapterProvider closing failed: {}", e.getMessage());
+ }
return Futures.immediateFuture(null);
}
--- /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_ise_adapter.impl;
+
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfig;
+
+/**
+ * Purpose: wrap {@link EPPolicyTemplateProvider} and {@link IseSourceConfig} injection
+ */
+public interface EPPolicyTemplateProviderFacade extends EPPolicyTemplateProvider {
+
+ /**
+ * @param iseSourceConfig current ise configuration
+ */
+ void assignIseSourceConfig(final IseSourceConfig iseSourceConfig);
+
+}
--- /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_ise_adapter.impl;
+
+import com.google.common.collect.Range;
+import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.WebResource;
+import java.util.Collections;
+import java.util.Optional;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.util.IseReplyUtil;
+import org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.util.RestClientFactory;
+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.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.ConnectionConfig;
+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;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Node;
+
+/**
+ * Purpose: query ise in order to get name of sgt for given tenant and build {@link EndpointPolicyTemplateBySgt}
+ */
+public class EPPolicyTemplateProviderIseImpl implements EPPolicyTemplateProviderFacade {
+
+ private static final Logger LOG = LoggerFactory.getLogger(EPPolicyTemplateProviderIseImpl.class);
+
+ private Optional<IseSourceConfig> iseSourceConfig = Optional.empty();
+
+ @Override
+ public Optional<EndpointPolicyTemplateBySgt> provideTemplate(@Nonnull final Sgt sgt) {
+ return findIseSourceConfigBySgt(sgt)
+ .flatMap(iseSourceConfig -> queryIseOnSgt(iseSourceConfig.getConnectionConfig(), sgt)
+ .map(sgtName -> buildTemplate(sgt, iseSourceConfig.getTenant(), sgtName)));
+ }
+
+ private EndpointPolicyTemplateBySgt buildTemplate(final @Nonnull Sgt sgt, final @Nonnull TenantId tenantId,
+ final @Nonnull String sgtName) {
+ return new EndpointPolicyTemplateBySgtBuilder()
+ .setSgt(sgt)
+ .setEndpointGroups(Collections.singletonList(new EndpointGroupId(sgtName)))
+ .setTenant(tenantId)
+ // no conditions
+ .setOrigin(TemplateGenerated.class)
+ .build();
+ }
+
+ private Optional<String> queryIseOnSgt(final ConnectionConfig connectionConfig, final Sgt sgt) {
+ String sgtName = null;
+ try {
+ final Client iseClient = RestClientFactory.createIseClient(connectionConfig);
+ final WebResource baseWebResource = iseClient.resource(connectionConfig.getIseRestUrl().getValue());
+
+ final String pathToSgtDetail = String.format("%s/%d", RestClientFactory.PATH_ERS_CONFIG_SGT, sgt.getValue());
+ final WebResource.Builder requestBuilder = RestClientFactory.createRequestBuilder(baseWebResource,
+ connectionConfig.getHeader(), pathToSgtDetail);
+ final String rawSgtDetail = IseReplyUtil.deliverResponse(requestBuilder);
+
+ final XPath xpath = IseReplyUtil.setupXpath();
+ final Node sgtNameNode = (Node) xpath.evaluate(
+ IseReplyUtil.EXPRESSION_SGT_NAME_ATTR, IseReplyUtil.createInputSource(rawSgtDetail),
+ XPathConstants.NODE);
+ sgtName = sgtNameNode.getNodeValue();
+ LOG.debug("obtained sgt/name: {}/{}", sgt.getValue(), sgtName);
+ } catch (Exception e) {
+ LOG.debug("failed to read sgt detail on ISE", e);
+ }
+ return Optional.ofNullable(sgtName);
+ }
+
+ private Optional<IseSourceConfig> findIseSourceConfigBySgt(final Sgt sgt) {
+ //TODO: cover multiple sources / tenants .. lookup (option: multiple servers per tenant?)
+ return iseSourceConfig
+ .filter(config ->
+ Range.closed(config.getSgtRangeMin().getValue(), config.getSgtRangeMax().getValue())
+ .contains(sgt.getValue()));
+ }
+
+ @Override
+ public void assignIseSourceConfig(final @Nullable IseSourceConfig iseSourceConfig) {
+ this.iseSourceConfig = Optional.ofNullable(iseSourceConfig);
+ }
+}
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.GbpSxpIseAdapter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfig;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(GbpIseAdapterProvider.class);
private final DataBroker dataBroker;
+ private final SxpEpProviderProvider sxpEpProvider;
private ListenerRegistration<ClusteredDataTreeChangeListener<IseSourceConfig>> registration;
+ private ObjectRegistration<EPPolicyTemplateProvider> epPolicyTemplateProviderRegistration;
- public GbpIseAdapterProvider(final DataBroker dataBroker, final BindingAwareBroker brokerDependency) {
+ public GbpIseAdapterProvider(final DataBroker dataBroker, final BindingAwareBroker broker,
+ final SxpEpProviderProvider sxpEpProvider) {
this.dataBroker = Preconditions.checkNotNull(dataBroker, "provided dataBroker must not be null");
- brokerDependency.registerProvider(this);
+ this.sxpEpProvider = Preconditions.checkNotNull(sxpEpProvider, "provided sxp-ep-provider must not be null");
+
+ broker.registerProvider(this);
}
@Override
- public void close() {
+ public void close() throws Exception {
if (registration != null) {
LOG.info("closing GbpIseAdapterProvider");
registration.close();
registration = null;
}
+ if (epPolicyTemplateProviderRegistration != null) {
+ LOG.info("closing EPPolicyTemplateProvider");
+ epPolicyTemplateProviderRegistration.close();
+ epPolicyTemplateProviderRegistration = null;
+ }
}
@Override
public void onSessionInitiated(final BindingAwareBroker.ProviderContext providerContext) {
LOG.info("Starting GbpIseAdapterProvider ..");
+ // setup template provider pipeline
+ final EPPolicyTemplateProviderFacade templateProviderFacade = new EPPolicyTemplateProviderIseImpl();
+ epPolicyTemplateProviderRegistration = sxpEpProvider.getEPPolicyTemplateProviderRegistry()
+ .registerTemplateProvider(templateProviderFacade);
+
// setup harvesting and processing pipeline
final SgtInfoProcessor epgGenerator = new SgtToEpgGeneratorImpl(dataBroker);
final SgtInfoProcessor templateGenerator = new SgtToEPTemplateGeneratorImpl(dataBroker);
final GbpIseSgtHarvester gbpIseSgtHarvester = new GbpIseSgtHarvesterImpl(epgGenerator, templateGenerator);
- final GbpIseConfigListenerImpl gbpIseConfigListener = new GbpIseConfigListenerImpl(dataBroker, gbpIseSgtHarvester);
+ final GbpIseConfigListenerImpl gbpIseConfigListener = new GbpIseConfigListenerImpl(
+ dataBroker, gbpIseSgtHarvester, templateProviderFacade);
// build data-tree path
final DataTreeIdentifier<IseSourceConfig> dataTreePath = new DataTreeIdentifier<>(
private final DataBroker dataBroker;
private final GbpIseSgtHarvester gbpIseSgtHarvester;
+ @Nonnull private final EPPolicyTemplateProviderFacade templateProviderFacade;
private final ThreadPoolExecutor pool;
- public GbpIseConfigListenerImpl(@Nonnull final DataBroker dataBroker, @Nonnull final GbpIseSgtHarvester gbpIseSgtHarvester) {
+ public GbpIseConfigListenerImpl(@Nonnull final DataBroker dataBroker, @Nonnull final GbpIseSgtHarvester gbpIseSgtHarvester,
+ @Nonnull final EPPolicyTemplateProviderFacade templateProviderFacade) {
this.dataBroker = dataBroker;
this.gbpIseSgtHarvester = gbpIseSgtHarvester;
+ this.templateProviderFacade = templateProviderFacade;
pool = new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10),
new ThreadFactoryBuilder().setNameFormat("ise-sgt-harverster-%d").build()) {
@Override
public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<IseSourceConfig>> collection) {
for (DataTreeModification<IseSourceConfig> modification : collection) {
final IseSourceConfig iseSourceConfig = modification.getRootNode().getDataAfter();
+ //TODO: separate template provider from harvesting
+ templateProviderFacade.assignIseSourceConfig(iseSourceConfig);
if (iseSourceConfig != null) {
pool.submit(() -> {
final ListenableFuture<Integer> harvestResult = gbpIseSgtHarvester.harvest(iseSourceConfig);
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.sun.jersey.api.client.Client;
-import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
-import java.io.StringReader;
import java.net.URI;
import java.util.ArrayList;
-import java.util.Iterator;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import javax.xml.XMLConstants;
-import javax.xml.namespace.NamespaceContext;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
-import javax.xml.xpath.XPathFactory;
+import org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.util.IseReplyUtil;
import org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.util.RestClientFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.ConnectionConfig;
private static final Logger LOG = LoggerFactory.getLogger(GbpIseSgtHarvesterImpl.class);
- public static final String PATH_ERS_CONFIG_SGT = "/ers/config/sgt";
- public static final String EXPRESSION_SGT_ALL_LINK_HREFS = "/ns3:searchResult/ns3:resources/ns5:resource/link/@href";
- public static final String EXPRESSION_SGT_DETAIL = "./ns4:sgt";
- public static final String EXPRESSION_SGT_NAME_ATTR = "./@name";
- public static final String EXPRESSION_SGT_VALUE = "./value/text()";
-
private final SgtInfoProcessor[] sgtInfoProcessors;
/**
final Client iseClient = RestClientFactory.createIseClient(connectionConfig);
final WebResource baseWebResource = iseClient.resource(connectionConfig.getIseRestUrl().getValue());
- final WebResource.Builder requestBuilder = createRequestBuilder(baseWebResource,
- connectionConfig.getHeader(), PATH_ERS_CONFIG_SGT);
- final String rawSgtSummary = deliverResponse(requestBuilder);
+ final WebResource.Builder requestBuilder = RestClientFactory.createRequestBuilder(baseWebResource,
+ connectionConfig.getHeader(), RestClientFactory.PATH_ERS_CONFIG_SGT);
+ final String rawSgtSummary = IseReplyUtil.deliverResponse(requestBuilder);
final List<SgtInfo> sgtInfos = harvestDetails(rawSgtSummary, baseWebResource, connectionConfig.getHeader());
return result;
}
- private static String deliverResponse(final WebResource.Builder requestBuilder) {
- return requestBuilder.get(ClientResponse.class).getEntity(String.class);
- }
-
- private static WebResource.Builder createRequestBuilder(final WebResource resource, final List<Header> headers,
- final String path) {
- final WebResource webResource = resource.path(path);
- final WebResource.Builder requestBuilder = webResource.getRequestBuilder();
- headers.stream().forEach(
- (header) -> requestBuilder.header(header.getName(), header.getValue()));
- return requestBuilder;
- }
-
private List<SgtInfo> harvestDetails(final String rawSgtSummary, final WebResource baseWebResource, final List<Header> headers) {
LOG.trace("rawSgtSummary: {}", rawSgtSummary);
final List<SgtInfo> sgtInfos = new ArrayList<>();
// parse sgtSummary
- final XPath xpath = setupXpath();
+ final XPath xpath = IseReplyUtil.setupXpath();
- InputSource inputSource = new InputSource(new StringReader(rawSgtSummary));
+ InputSource inputSource = IseReplyUtil.createInputSource(rawSgtSummary);
try {
- final NodeList sgtLinkNodes = (NodeList) xpath.evaluate(EXPRESSION_SGT_ALL_LINK_HREFS, inputSource,
+ final NodeList sgtLinkNodes = (NodeList) xpath.evaluate(IseReplyUtil.EXPRESSION_SGT_ALL_LINK_HREFS, inputSource,
XPathConstants.NODESET);
for (int i = 0; i < sgtLinkNodes.getLength(); i++) {
final String sgtLinkHrefValue = sgtLinkNodes.item(i).getNodeValue();
// query all sgt entries (serial-vise)
final URI hrefToSgtDetailUri = URI.create(sgtLinkHrefValue);
- final WebResource.Builder requestBuilder = createRequestBuilder(baseWebResource, headers, hrefToSgtDetailUri.getPath());
- final String rawSgtDetail = deliverResponse(requestBuilder);
+ final WebResource.Builder requestBuilder = RestClientFactory.createRequestBuilder(baseWebResource, headers, hrefToSgtDetailUri.getPath());
+ final String rawSgtDetail = IseReplyUtil.deliverResponse(requestBuilder);
LOG.trace("rawSgtDetail: {}", rawSgtDetail);
- final Node sgtNode = (Node) xpath.evaluate(EXPRESSION_SGT_DETAIL, new InputSource(new StringReader(rawSgtDetail)),
+ final Node sgtNode = (Node) xpath.evaluate(IseReplyUtil.EXPRESSION_SGT_DETAIL, IseReplyUtil.createInputSource(rawSgtDetail),
XPathConstants.NODE);
- final Node sgtName = (Node) xpath.evaluate(EXPRESSION_SGT_NAME_ATTR, sgtNode, XPathConstants.NODE);
- final Node sgtValue = (Node) xpath.evaluate(EXPRESSION_SGT_VALUE, sgtNode, XPathConstants.NODE);
+ final Node sgtName = (Node) xpath.evaluate(IseReplyUtil.EXPRESSION_SGT_NAME_ATTR, sgtNode, XPathConstants.NODE);
+ final Node sgtValue = (Node) xpath.evaluate(IseReplyUtil.EXPRESSION_SGT_VALUE, sgtNode, XPathConstants.NODE);
LOG.debug("sgt value [{}]: {} -> {}", i, sgtValue, sgtName);
// store replies into list of SgtInfo
return sgtInfos;
}
- /**
- * @return initiated xpath with ise namespace context injected
- */
- private static XPath setupXpath() {
- final NamespaceContext nsContext = new NamespaceContext() {
- public String getNamespaceURI(String prefix) {
- final String outcome;
- if (prefix == null) {
- throw new NullPointerException("Null prefix");
- }
-
- if ("ns5".equals(prefix)) {
- outcome = "ers.ise.cisco.com";
- } else if ("ns3".equals(prefix)) {
- outcome = "v2.ers.ise.cisco.com";
- } else if ("ns4".equals(prefix)) {
- outcome = "trustsec.ers.ise.cisco.com";
- } else {
- outcome = XMLConstants.NULL_NS_URI;
- }
- return outcome;
- }
-
- // This method isn't necessary for XPath processing.
- public String getPrefix(String uri) {
- throw new UnsupportedOperationException();
- }
-
- // This method isn't necessary for XPath processing either.
- public Iterator getPrefixes(String uri) {
- throw new UnsupportedOperationException();
- }
- };
-
- XPath xpath = XPathFactory.newInstance().newXPath();
- xpath.setNamespaceContext(nsContext);
- return xpath;
- }
}
--- /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_ise_adapter.impl.util;
+
+import com.sun.jersey.api.client.ClientResponse;
+import com.sun.jersey.api.client.WebResource;
+import java.io.StringReader;
+import java.util.Iterator;
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathFactory;
+import org.xml.sax.InputSource;
+
+/**
+ * Purpose: provide common functionality upon ise reply message
+ */
+public class IseReplyUtil {
+
+ public static final String EXPRESSION_SGT_ALL_LINK_HREFS = "/ns3:searchResult/ns3:resources/ns5:resource/link/@href";
+ public static final String EXPRESSION_SGT_DETAIL = "./ns4:sgt";
+ public static final String EXPRESSION_SGT_NAME_ATTR = "./@name";
+ public static final String EXPRESSION_SGT_VALUE = "./value/text()";
+
+ private IseReplyUtil() {
+ throw new IllegalAccessError("util class - no instances supported");
+ }
+
+
+ public static String deliverResponse(final WebResource.Builder requestBuilder) {
+ return requestBuilder.get(ClientResponse.class).getEntity(String.class);
+ }
+
+ /**
+ * @return initiated xpath with ise namespace context injected
+ */
+ public static XPath setupXpath() {
+ final NamespaceContext nsContext = new NamespaceContext() {
+ public String getNamespaceURI(String prefix) {
+ final String outcome;
+ if (prefix == null) {
+ throw new NullPointerException("Null prefix");
+ }
+
+ if ("ns5".equals(prefix)) {
+ outcome = "ers.ise.cisco.com";
+ } else if ("ns3".equals(prefix)) {
+ outcome = "v2.ers.ise.cisco.com";
+ } else if ("ns4".equals(prefix)) {
+ outcome = "trustsec.ers.ise.cisco.com";
+ } else {
+ outcome = XMLConstants.NULL_NS_URI;
+ }
+ return outcome;
+ }
+
+ // This method isn't necessary for XPath processing.
+ public String getPrefix(String uri) {
+ throw new UnsupportedOperationException();
+ }
+
+ // This method isn't necessary for XPath processing either.
+ public Iterator getPrefixes(String uri) {
+ throw new UnsupportedOperationException();
+ }
+ };
+
+ XPath xpath = XPathFactory.newInstance().newXPath();
+ xpath.setNamespaceContext(nsContext);
+ return xpath;
+ }
+
+ public static InputSource createInputSource(final String rawSgtDetail) {
+ return new InputSource(new StringReader(rawSgtDetail));
+ }
+}
package org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.util;
import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;
import com.sun.jersey.client.urlconnection.HTTPSProperties;
import java.security.GeneralSecurityException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
+import java.util.List;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import org.apache.commons.net.util.TrustManagerUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.ConnectionConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.connection.config.Header;
/**
* Purpose: setup ise-ready jersey {@link Client}
*/
public class RestClientFactory {
+ public static final String PATH_ERS_CONFIG_SGT = "/ers/config/sgt";
+
private RestClientFactory() {
throw new IllegalAccessError("factory class - no instances supported");
}
sslContext
));
}
+
+ public static WebResource.Builder createRequestBuilder(final WebResource resource, final List<Header> headers,
+ final String path) {
+ final WebResource webResource = resource.path(path);
+ final WebResource.Builder requestBuilder = webResource.getRequestBuilder();
+ headers.stream().forEach(
+ (header) -> requestBuilder.header(header.getName(), header.getValue()));
+ return requestBuilder;
+ }
}
<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ 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
+ -->
+
<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="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="gbpIseAdapter" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.gbp_ise_adapter.GbpIseAdapterProviderInstance"
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
import config { prefix config; revision-date 2013-04-05; }
import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
+ import sxp-ep-provider-cfg { prefix gbp-sxp-ep; revision-date 2016-07-22; }
description
"This module contains the base YANG definitions for
--- /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_ise_adapter.impl;
+
+import static org.powermock.api.support.membermodification.MemberMatcher.method;
+import static org.powermock.api.support.membermodification.MemberModifier.stub;
+
+import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.WebResource;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+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.groupbasedpolicy.sxp_ise_adapter.impl.util.IseReplyUtil;
+import org.opendaylight.groupbasedpolicy.sxp_ise_adapter.impl.util.RestClientFactory;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
+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.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.ConnectionConfig;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.ConnectionConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.ise.source.config.connection.config.HeaderBuilder;
+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.sxp.database.rev160308.Sgt;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.w3c.dom.Node;
+import org.xml.sax.InputSource;
+
+/**
+ * Test for {@link EPPolicyTemplateProviderIseImpl}.
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({IseReplyUtil.class, RestClientFactory.class})
+public class EPPolicyTemplateProviderIseImplTest {
+
+ private static final Sgt SGT = new Sgt(42);
+ private static final Sgt SGT_LOW = new Sgt(1);
+ private static final Sgt SGT_HI = new Sgt(100);
+ private static final TenantId TENANT_ID = new TenantId("tenant-01");
+
+ @Mock
+ private XPath xpathWalker;
+ @Mock
+ private Client iseClient;
+ @Mock
+ private WebResource.Builder wrBuilder;
+
+ private EPPolicyTemplateProviderIseImpl templateProvider;
+
+ @Before
+ public void setUp() throws Exception {
+ templateProvider = new EPPolicyTemplateProviderIseImpl();
+ }
+
+ @Test
+ public void testProvideTemplate_noConfig() throws Exception {
+ final Optional<EndpointPolicyTemplateBySgt> endpointPolicyTemplateBySgt = templateProvider.provideTemplate(SGT);
+ Assert.assertFalse(endpointPolicyTemplateBySgt.isPresent());
+ }
+
+ @Test
+ public void testProvideTemplate_config() throws Exception {
+ final ConnectionConfig connectionConfig = new ConnectionConfigBuilder()
+ .setIseRestUrl(new Uri("http://example.org"))
+ .setConnectionTimeout(10)
+ .setReadTimeout(10)
+ .setHeader(Collections.singletonList(new HeaderBuilder()
+ .setName("headerName")
+ .setValue("headerValue")
+ .build()))
+ .build();
+ final IseSourceConfig sourceConfig = new IseSourceConfigBuilder()
+ .setTenant(TENANT_ID)
+ .setConnectionConfig(connectionConfig)
+ .setSgtRangeMin(SGT_LOW)
+ .setSgtRangeMax(SGT_HI)
+ .build();
+
+ final String rawResponse = "";
+ stub(method(IseReplyUtil.class, "deliverResponse")).toReturn(rawResponse);
+ stub(method(IseReplyUtil.class, "setupXpath")).toReturn(xpathWalker);
+ stub(method(RestClientFactory.class, "createIseClient", ConnectionConfig.class)).toReturn(iseClient);
+ stub(method(RestClientFactory.class, "createRequestBuilder", WebResource.class, List.class, String.class)).toReturn(wrBuilder);
+
+
+ final String epgName = "name-for-sgt42";
+ final Node sgtNameNode = Mockito.mock(Node.class);
+ Mockito.when(sgtNameNode.getNodeValue()).thenReturn(epgName);
+ Mockito.when(xpathWalker.evaluate(Matchers.same(IseReplyUtil.EXPRESSION_SGT_NAME_ATTR),
+ Matchers.<InputSource>any(), Matchers.same(XPathConstants.NODE)))
+ .thenReturn(sgtNameNode);
+
+ templateProvider.assignIseSourceConfig(sourceConfig);
+ final Optional<EndpointPolicyTemplateBySgt> templateWrap = templateProvider.provideTemplate(SGT);
+
+ Assert.assertTrue(templateWrap.isPresent());
+ final EndpointPolicyTemplateBySgt template = templateWrap.get();
+ Assert.assertEquals(SGT, template.getSgt());
+ Assert.assertNull(template.getConditions());
+ Assert.assertEquals(TENANT_ID, template.getTenant());
+ Assert.assertEquals(1, template.getEndpointGroups().size());
+ Assert.assertEquals(epgName, template.getEndpointGroups().get(0).getValue());
+ Assert.assertEquals(TemplateGenerated.class, template.getOrigin());
+ }
+}
\ No newline at end of file
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProviderRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.ep.provider.spi.SxpEpProviderProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.gbp.sxp.ise.adapter.model.rev160630.gbp.sxp.ise.adapter.IseSourceConfig;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.powermock.core.classloader.annotations.PrepareForTest;
private GbpIseSgtHarvesterImpl harvester;
@Mock
private GbpIseConfigListenerImpl listener;
+ @Mock
+ private SxpEpProviderProvider sxpEpProvider;
+ @Mock
+ private EPPolicyTemplateProviderRegistry templateProviderRegistry;
+ @Mock
+ private EPPolicyTemplateProviderIseImpl templateProvider;
private GbpIseAdapterProvider provider;
@Before
public void setUp() throws Exception {
- provider = new GbpIseAdapterProvider(dataBroker, broker);
+ Mockito.when(sxpEpProvider.getEPPolicyTemplateProviderRegistry())
+ .thenReturn(templateProviderRegistry);
+ provider = new GbpIseAdapterProvider(dataBroker, broker, sxpEpProvider);
Mockito.verify(broker).registerProvider(provider);
}
whenNew(SgtToEPTemplateGeneratorImpl.class).withAnyArguments().thenReturn(generator2);
whenNew(GbpIseSgtHarvesterImpl.class).withArguments(generator1, generator2).thenReturn(harvester);
whenNew(GbpIseConfigListenerImpl.class).withAnyArguments().thenReturn(listener);
+ whenNew(EPPolicyTemplateProviderIseImpl.class).withNoArguments().thenReturn(templateProvider);
provider.onSessionInitiated(providerContext);
+ Mockito.verify(templateProviderRegistry).registerTemplateProvider(templateProvider);
// check if all expected object got constructed and wired
verifyNew(SgtToEpgGeneratorImpl.class).withArguments(dataBroker);
verifyNew(SgtToEPTemplateGeneratorImpl.class).withArguments(dataBroker);
verifyNew(GbpIseSgtHarvesterImpl.class).withArguments(generator1, generator2);
- verifyNew(GbpIseConfigListenerImpl.class).withArguments(dataBroker, harvester);
+ verifyNew(GbpIseConfigListenerImpl.class).withArguments(dataBroker, harvester, templateProvider);
// close provider check
provider.close();
private WriteTransaction wTx;
@Mock
private IseSourceConfig config;
+ @Mock
+ private EPPolicyTemplateProviderFacade templateProviderFacade;
private GbpIseConfigListenerImpl listener;
@Before
public void setUp() throws Exception {
- listener = new GbpIseConfigListenerImpl(dataBroker, harvester);
+ listener = new GbpIseConfigListenerImpl(dataBroker, harvester, templateProviderFacade);
}
@Test
Code Review / groupbasedpolicy.git / commitdiff