</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<sxp.version>1.4.0-SNAPSHOT</sxp.version>
<netconf.version>1.2.0-SNAPSHOT</netconf.version>
<vbd.version>1.1.0-SNAPSHOT</vbd.version>
+ <!-- for jolokia -->
+ <feature.controller.extras.version>1.8.0-SNAPSHOT</feature.controller.extras.version>
</properties>
<dependencyManagement>
<type>pom</type>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-extras</artifactId>
+ <version>${feature.controller.extras.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ </dependency>
+
+
<!-- netconf -->
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<type>xml</type>
<scope>runtime</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-extras</artifactId>
+ <classifier>features</classifier>
+ <type>xml</type>
+ </dependency>
<!-- Openflow plugin -->
<dependency>
<repository>mvn:org.opendaylight.mdsal/features-mdsal/{{VERSION}}/xml/features</repository>
<repository>mvn:org.opendaylight.controller/features-mdsal/{{VERSION}}/xml/features</repository>
<repository>mvn:org.opendaylight.mdsal.model/features-mdsal-model/{{VERSION}}/xml/features</repository>
+ <repository>mvn:org.opendaylight.controller/features-extras/{{VERSION}}/xml/features</repository>
<!-- Repos needed by the OpenFlow Overlay renderer -->
<repository>mvn:org.opendaylight.openflowplugin/features-openflowplugin/{{VERSION}}/xml/features</repository>
<repository>mvn:org.opendaylight.openflowplugin/features-openflowplugin-extension/{{VERSION}}/xml/features</repository>
<feature name='odl-groupbasedpolicy-vpp' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: VPP renderer '>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
<feature version="${netconf.version}">odl-netconf-clustered-topology</feature>
- <feature version="${vbd.version}">odl-vbd-api</feature>
+ <feature version="${vbd.version}">odl-vbd</feature>
<bundle>mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/vpp-renderer/{{VERSION}}</bundle>
<configfile finalname="${config.configfile.directory}/15-l2-l3-domain-extension.xml">mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}/xml/config</configfile>
<bundle>mvn:org.opendaylight.groupbasedpolicy/sxp-ep-provider/{{VERSION}}</bundle>
<configfile finalname="${config.configfile.directory}/15-groupbasedpolicy-sxp-ep-provider.xml">mvn:org.opendaylight.groupbasedpolicy/sxp-ep-provider/{{VERSION}}/xml/config</configfile>
</feature>
- <feature name='odl-groupbasedpolicy-sxp-mapper' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: sxp-mapper'>
- <!-- TODO: remove later - this is temporary "feature-forwarding" in order to keep integration feature test working -->
- <feature version="${project.version}">odl-groupbasedpolicy-sxp-ep-provider</feature>
- </feature>
<!--
GBP-SXP integration : ise-adapter
gbp.register = gbp; // for adding services, controllers, directives etc. to angular module before bootstrap
gbp.config(function ($stateProvider, $compileProvider, $controllerProvider, $provide, NavHelperProvider,
- $translateProvider, $translatePartialLoaderProvider, $mdThemingProvider) {
+ $translateProvider, $translatePartialLoaderProvider, $urlRouterProvider, $mdThemingProvider) {
gbp.register = {
controller: $controllerProvider.register,
directive: $compileProvider.directive,
service: $provide.service,
};
+ $urlRouterProvider.otherwise('/gbp/index');
+
/*$translatePartialLoaderProvider.addPart('app/gbp/assets/data/locale');*/
NavHelperProvider.addControllerUrl('app/gbp/common/gbp.controller');
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
-import java.util.concurrent.Future;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
import org.opendaylight.groupbasedpolicy.api.EndpointAugmentorRegistry;
import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentorRegistry;
ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
private final DataBroker dataBroker;
private ClusterSingletonServiceProvider clusterSingletonService;
+ private final RpcProviderRegistry rpcProviderRegistry;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
private EndpointAugmentorRegistryImpl endpointAugmentorRegistryImpl;
private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistryImpl;
private BaseEndpointServiceImpl baseEndpointServiceImpl;
private RendererManager rendererManager;
+ private BindingAwareBroker.RpcRegistration<BaseEndpointService> baseEndpointServiceRpcRegistration;
public DomainSpecificRegistryInstance(final DataBroker dataBroker,
- final ClusterSingletonServiceProvider clusterSingletonService) {
+ final ClusterSingletonServiceProvider clusterSingletonService,
+ final RpcProviderRegistry rpcProviderRegistry) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
+ this.rpcProviderRegistry = Preconditions.checkNotNull(rpcProviderRegistry);
}
@Override
netDomainAugmentorRegistryImpl = new NetworkDomainAugmentorRegistryImpl();
baseEndpointServiceImpl = new BaseEndpointServiceImpl(dataBroker, endpointAugmentorRegistryImpl);
rendererManager = new RendererManager(dataBroker, netDomainAugmentorRegistryImpl, endpointAugmentorRegistryImpl);
+
+ baseEndpointServiceRpcRegistration = rpcProviderRegistry.addRpcImplementation(BaseEndpointService.class, this);
}
@Override
public ListenableFuture<Void> closeServiceInstance() {
LOG.info("Instance {} closed", this.getClass().getSimpleName());
baseEndpointServiceImpl.close();
+ baseEndpointServiceRpcRegistration.close();
rendererManager.close();
+
return Futures.immediateFuture(null);
}
package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
-import java.util.concurrent.Future;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentation;
import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
import org.opendaylight.groupbasedpolicy.endpoint.EndpointRpcRegistry;
ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
private final DataBroker dataBroker;
private ClusterSingletonServiceProvider clusterSingletonService;
+ private final RpcProviderRegistry rpcProviderRegistry;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
private EndpointRpcRegistry endpointRpcRegistry;
+ private BindingAwareBroker.RpcRegistration<EndpointService> serviceRpcRegistration;
public EpRendererAugmentationRegistryImplInstance(final DataBroker dataBroker,
- final ClusterSingletonServiceProvider clusterSingletonService) {
+ final ClusterSingletonServiceProvider clusterSingletonService,
+ final RpcProviderRegistry rpcProviderRegistry) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
+ this.rpcProviderRegistry = rpcProviderRegistry;
}
@Override
public void instantiateServiceInstance() {
LOG.info("Instantiating {}", this.getClass().getSimpleName());
endpointRpcRegistry = new EndpointRpcRegistry(dataBroker);
+
+ serviceRpcRegistration = rpcProviderRegistry.addRpcImplementation(EndpointService.class, this);
}
@Override
public ListenableFuture<Void> closeServiceInstance() {
LOG.info("Instance {} closed", this.getClass().getSimpleName());
endpointRpcRegistry.close();
+ serviceRpcRegistration.close();
return Futures.immediateFuture(null);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupKey;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class RendererConfigurationBuilder {
+ private static final Logger LOG = LoggerFactory.getLogger(RendererConfigurationBuilder.class);
+
private final Table<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerEp =
HashBasedTable.create();
private final Table<RendererEndpointKey, PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerExtEp =
return peerExtContEps;
}
- public Endpoints buildEndoints(EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
- Map<InstanceIdentifier<?>, RendererName> rendererByNode, Set<EndpointAugmentor> augmentors) {
+ public Endpoints buildEndpoints(EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
+ Map<InstanceIdentifier<?>, RendererName> rendererByNode, Set<EndpointAugmentor> augmentors) {
List<AddressEndpointWithLocation> epsWithLoc =
resolveEpsWithLoc(getAddressEndpointKeys(), epInfo, epLocInfo, rendererByNode, augmentors);
List<ContainmentEndpointWithLocation> contEpsWithLoc =
Optional<AddressEndpointLocation> potentionalEpLoc = epLocInfo.getAdressEndpointLocation(epKey);
Preconditions.checkArgument(potentionalEpLoc.isPresent());
RendererName rendererName = resolveRendererName(potentionalEpLoc.get(), rendererByNode);
+ if (rendererName == null) {
+ LOG.debug("Endpoint {} has no location, skipped", epKey);
+ continue;
+ }
result.add(createEpWithLoc(potentialEp.get(), potentionalEpLoc.get(), rendererName, augmentors));
}
return result;
private boolean writeRenderersConfigs(Map<RendererName, Optional<Configuration>> configsByRendererName) {
List<Renderer> renderers = new ArrayList<>();
for (RendererName rendererName : configsByRendererName.keySet()) {
- RendererPolicy rendererPolicy = null;
+ RendererPolicy rendererPolicy;
if (configsByRendererName.get(rendererName).isPresent()) {
rendererPolicy = new RendererPolicyBuilder().setVersion(version)
.setConfiguration(configsByRendererName.get(rendererName).get())
configBuilder.setRendererEndpoints(rendererEndpoints);
org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints endpoints =
- rendererPolicyBuilder.buildEndoints(currentState.epInfo, currentState.epLocInfo,
+ rendererPolicyBuilder.buildEndpoints(currentState.epInfo, currentState.epLocInfo,
currentState.rendererByNode, epAugmentorRegistry.getEndpointAugmentors());
configBuilder.setEndpoints(endpoints);
<reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
<reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
+ <reference id="rpcRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
<!-- Modules /-->
<bean id="groupbasedpolicy" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.GroupbasedpolicyInstance"
- init-method="initialize" destroy-method="close">
+ init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
<argument ref="policyValidatorRegistry"/>
<argument ref="clusterSingletonService"/>
</bean>
<bean id="domainSpecificRegistry" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.DomainSpecificRegistryInstance"
- init-method="initialize" destroy-method="close">
+ init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
<argument ref="clusterSingletonService"/>
+ <argument ref="rpcRegistry"/>
</bean>
<bean id="epRendererAugmentationRegistry" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.EpRendererAugmentationRegistryImplInstance"
- init-method="initialize" destroy-method="close">
+ init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
<argument ref="clusterSingletonService"/>
+ <argument ref="rpcRegistry"/>
</bean>
<bean id="statisticsManagerImpl" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.StatisticsManagerImplInstance"
- init-method="initialize" destroy-method="close">
+ init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
<argument ref="clusterSingletonService"/>
</bean>
<bean id="policyValidatorRegistry" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.PolicyValidatorRegistryInstance"
- init-method="initialize" destroy-method="close">
+ init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
<argument ref="clusterSingletonService"/>
</bean>
<service ref="policyValidatorRegistry" interface="org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry" odl:type="default"/>
<service ref="statisticsManagerImpl" interface="org.opendaylight.groupbasedpolicy.api.StatisticsManager" odl:type="default"/>
- <!-- RPC implementations -->
- <odl:rpc-implementation ref="domainSpecificRegistry"/>
- <odl:rpc-implementation ref="epRendererAugmentationRegistry"/>
</blueprint>
\ No newline at end of file
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
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.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.neutron.mapper.NeutronMapper;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
private static final ServiceGroupIdentifier IDENTIFIER =
ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
private final DataBroker dataBroker;
- private final EndpointService epService;
- private final BaseEndpointService baseEndpointService;
private final ClusterSingletonServiceProvider clusterSingletonService;
+ private final RpcProviderRegistry rpcBroker;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
private NeutronMapper mapper;
public NeutronMapperInstance(final DataBroker dataBroker,
- final EndpointService epService,
- final BaseEndpointService baseEndpointService,
+ final RpcProviderRegistry rpcBroker,
final ClusterSingletonServiceProvider clusterSingletonService) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.epService = Preconditions.checkNotNull(epService);
- this.baseEndpointService = Preconditions.checkNotNull(baseEndpointService);
+ this.rpcBroker = Preconditions.checkNotNull(rpcBroker);
this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
}
@Override
public void instantiateServiceInstance() {
LOG.info("Instantiating {}", this.getClass().getSimpleName());
+ final EndpointService epService = rpcBroker.getRpcService(EndpointService.class);
+ final BaseEndpointService baseEndpointService = rpcBroker.getRpcService(BaseEndpointService.class);
mapper = new NeutronMapper(dataBroker, epService, baseEndpointService);
}
package org.opendaylight.groupbasedpolicy.neutron.mapper;
+import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
-
-import javax.annotation.Nullable;
-
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.RegisterEndpointInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnreg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnregBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3AddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.l3.prefix.fields.EndpointL3Gateways;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.l3.prefix.fields.EndpointL3GatewaysBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L3Builder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
public class EndpointRegistrator {
private static final Logger LOG = LoggerFactory.getLogger(EndpointRegistrator.class);
return true;
}
+ @Deprecated
+ public boolean unregisterL3EpAsExternalGateway(IpAddress ipAddress, L3ContextId l3Context) {
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.UnregisterEndpointInput unregisterEndpointInput =
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.UnregisterEndpointInputBuilder()
+ .setL3(ImmutableList.of(new L3Builder().setL3Context(l3Context)
+ .setIpAddress(ipAddress)
+ .build()))
+ .build();
+
+ try {
+ RpcResult<Void> rpcResult = epService.unregisterEndpoint(unregisterEndpointInput).get();
+ if (!rpcResult.isSuccessful()) {
+ LOG.warn("Illegal state - unregisterL3EndpointAsExternalGateway was not successful. Input of RPC: {}",
+ unregisterEndpointInput);
+ return false;
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("unregisterL3EndpointAsExternalGateway failed. {}", unregisterEndpointInput, e);
+ return false;
+ }
+ return true;
+ }
}
*/
package org.opendaylight.groupbasedpolicy.neutron.mapper;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
public class NeutronMapper implements ClusteredDataTreeChangeListener<Neutron>, AutoCloseable {
- public static final String EXC_MSG_UNKNOWN_MODIFICATION_TYPE_WITHIN_DATA = "Unknown modification type within data ";
+ private static final String EXC_MSG_UNKNOWN_MODIFICATION_TYPE_WITHIN_DATA = "Unknown modification type within data ";
private final static SecurityRuleBuilder EIG_INGRESS_IPV4_SEC_RULE_BUILDER = new SecurityRuleBuilder()
.setUuid(new Uuid("0a629f80-2408-11e6-b67b-9e71128cae77"))
}
@Override
- public void onDataTreeChanged(Collection<DataTreeModification<Neutron>> changes) {
+ public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Neutron>> changes) {
for (DataTreeModification<Neutron> change : changes) {
DataObjectModification<Neutron> neutronModif = change.getRootNode();
resolveAndSetNeutron(neutronModif);
private <T extends DataObject> void onDataObjectModification(List<DataObjectModification<T>> dataModifs,
NeutronAware<T> neutronAware) {
for (DataObjectModification<T> dataModif : dataModifs) {
- switch (dataModif.getModificationType()) {
- case DELETE:
- neutronAware.onDeleted(dataModif.getDataBefore(), neutronBefore, neutronAfter);
- break;
- case SUBTREE_MODIFIED:
- neutronAware.onUpdated(dataModif.getDataBefore(), dataModif.getDataAfter(), neutronBefore,
- neutronAfter);
- break;
- case WRITE:
- if (dataModif.getDataBefore() == null) {
- neutronAware.onCreated(dataModif.getDataAfter(), neutronAfter);
- } else {
- neutronAware.onUpdated(dataModif.getDataBefore(), dataModif.getDataAfter(), neutronBefore,
- neutronAfter);
- }
- break;
- default:
- throw new IllegalStateException(EXC_MSG_UNKNOWN_MODIFICATION_TYPE_WITHIN_DATA + dataModif);
+ final T dataBefore = dataModif.getDataBefore();
+ final T dataAfter = dataModif.getDataAfter();
+ if (dataBefore == null && dataAfter != null) {
+ neutronAware.onCreated(dataAfter, neutronAfter);
+ }
+ else if (dataBefore != null && dataAfter != null) {
+ neutronAware.onUpdated(dataBefore, dataAfter, neutronBefore, neutronAfter);
+ }
+ else if (dataBefore != null) {
+ neutronAware.onDeleted(dataBefore, neutronBefore, neutronAfter);
+ }
+ else {
+ throw new IllegalStateException(EXC_MSG_UNKNOWN_MODIFICATION_TYPE_WITHIN_DATA + dataModif);
}
}
}
}
private void changeL3ContextForEpsInSubnet(Uuid subnetUuid, Neutron neutron) {
+ if (neutron == null) {
+ LOG.debug("No new data are written, there is no L3 context in subnet {} to update", subnetUuid);
+ return;
+ }
Set<Port> portsInSameSubnet = PortUtils.findPortsBySubnet(subnetUuid, neutron.getPorts());
for (Port portInSameSubnet : portsInSameSubnet) {
if (PortUtils.isNormalPort(portInSameSubnet) || PortUtils.isDhcpPort(portInSameSubnet)
@Override
public void onUpdated(Port oldPort, Port newPort, Neutron oldNeutron, Neutron newNeutron) {
LOG.trace("updated port - OLD: {}\nNEW: {}", oldPort, newPort);
- onDeleted(oldPort, oldNeutron, false);
+ onDeleted(oldPort, oldNeutron, newNeutron, false);
onCreated(newPort, newNeutron, false);
}
@Override public void onDeleted(Port deletedItem, Neutron oldNeutron, Neutron newNeutron) {
- onDeleted(deletedItem, oldNeutron, true);
+ onDeleted(deletedItem, oldNeutron, newNeutron, true);
}
- public void onDeleted(Port port, Neutron oldNeutron, boolean removeBaseEpMapping) {
+ public void onDeleted(Port port, Neutron oldNeutron, Neutron newNeutron, boolean removeBaseEpMapping) {
LOG.trace("deleted port - {}", port);
if (PortUtils.isRouterInterfacePort(port)) {
LOG.trace("Port is router interface port: {}", port.getUuid().getValue());
}
FixedIps portIpWithSubnet = potentialPortIpWithSubnet.get();
L3ContextId l3Context = new L3ContextId(port.getNetworkId().getValue());
- // change L3Context for all EPs with same subnet as router port
- changeL3ContextForEpsInSubnet(portIpWithSubnet.getSubnetId(), oldNeutron);
+ // change L3Context for all new EPs with same subnet as router port
+ changeL3ContextForEpsInSubnet(portIpWithSubnet.getSubnetId(), newNeutron);
// set L3Context as parent for bridge domain which is parent of subnet
TenantId tenantId = new TenantId(port.getTenantId().getValue());
Optional<Subnet> potentialRouterPortSubnet = SubnetUtils.findSubnet(portIpWithSubnet.getSubnetId(),
NetworkDomain subnet = NeutronSubnetAware.createSubnet(routerPortSubnet, null);
rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnet.getNetworkDomainId()),
subnet);
- UniqueId portId = new UniqueId(port.getUuid().getValue());
- PortByBaseEndpointKey portByBaseEndpointKey = new PortByBaseEndpointKey(port.getMacAddress().getValue(),
- MacAddressType.class, new ContextId(port.getNetworkId().getValue()), MappingUtils.L2_BRDIGE_DOMAIN);
- if (removeBaseEpMapping) {
- removeBaseEndpointMappings(portByBaseEndpointKey, portId, rwTx);
- }
+ unregisterEndpointAndRemoveMapping(createUnregisterEndpointInput(port, oldNeutron), port, rwTx);
+ unregisterEndpointAndRemoveMapping(createUnregisterBaseEndpointInput(port, oldNeutron), port, rwTx, removeBaseEpMapping);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isDhcpPort(port)) {
LOG.trace("Port is DHCP port: {}", port.getUuid().getValue());
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnregBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3PrefixKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentForwarding;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentForwardingBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.has.subnet.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.has.subnet.SubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.fields.Parent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
return epRegistrator.registerEndpoint(addrEpBuilder.build());
}
+ private boolean unregisterExternalGateway(IpPrefix ipPrefix, ContextId routerl3ContextId) {
+ AddressEndpointUnregBuilder addrEpBuilder = new AddressEndpointUnregBuilder();
+ addrEpBuilder.setAddressType(IpPrefixType.class);
+ addrEpBuilder.setAddress(MappingUtils.ipPrefixToStringIpAddress(ipPrefix));
+ addrEpBuilder.setContextId(routerl3ContextId);
+ addrEpBuilder.setContextType(MappingUtils.L3_CONTEXT);
+ return epRegistrator.unregisterEndpoint(addrEpBuilder.build());
+ }
+
private NetworkDomain createSubnetWithVirtualRouterIp(IpPrefix gatewayIp, NetworkDomainId subnetId) {
Subnet subnet = new SubnetBuilder().setVirtualRouterIp(MappingUtils.ipPrefixToIpAddress(gatewayIp.getValue())).build();
return new NetworkDomainBuilder().setKey(new NetworkDomainKey(subnetId, MappingUtils.SUBNET))
.build();
rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BdId),
l2BdWithGw);
- }
+ }
+ }
+
+ private void deleteTenantForwarding(Neutron newNeutron, Router oldRouter, L3ContextId l3ContextId, TenantId tenantId, ReadWriteTransaction rwTx) {
+ InstanceIdentifier<L3Context> l3ContextIid = IidFactory.l3ContextIid(tenantId, l3ContextId);
+
+ LOG.trace("Deleting router from TenantForwarding {}", l3ContextIid);
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION, l3ContextIid, rwTx);
+
+ if (oldRouter.getGatewayPortId() != null) {
+ // external network is attached to router
+ Uuid gatewayPortId = oldRouter.getGatewayPortId();
+ Optional<Port> potentialGwPort = PortUtils.findPort(gatewayPortId, newNeutron.getPorts());
+ if (!potentialGwPort.isPresent()) {
+ LOG.trace("Gateway port {} is not present. Skipping delete of extGW from TenantForwarding",
+ gatewayPortId);
+ return;
+ }
+
+ Port gwPort = potentialGwPort.get();
+ List<FixedIps> fixedIpsFromGwPort = gwPort.getFixedIps();
+ if (fixedIpsFromGwPort == null || fixedIpsFromGwPort.isEmpty()) {
+ LOG.trace("Gateway port {} does not contain fixed IPs. Skipping delete of extGW from TenantForwarding",
+ gatewayPortId);
+ return;
+ }
+
+ // router can have only one external network
+ FixedIps ipWithSubnetFromGwPort = fixedIpsFromGwPort.get(0);
+ Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet>
+ potentialSubnet =
+ SubnetUtils.findSubnet(ipWithSubnetFromGwPort.getSubnetId(), newNeutron.getSubnets());
+ if (!potentialSubnet.isPresent()) {
+ LOG.trace("Gateway port {} does not contain fixed IPs. Skipping delete of extGW from TenantForwarding",
+ gatewayPortId);
+ return;
+ }
+ IpAddress gatewayIp = potentialSubnet.get().getGatewayIp();
+ boolean registeredExternalGateway = epRegistrator.unregisterL3EpAsExternalGateway(gatewayIp, l3ContextId);
+ if (!registeredExternalGateway) {
+ LOG.trace("L3 Gateway endpoint {} with IP {} was not unregistered.", l3ContextId, gatewayIp);
+ return;
+ } else {
+ LOG.trace("L3 Gateway endpoint {} with IP {} was unregistered successfully.", l3ContextId, gatewayIp);
+ }
+ EndpointL3Key epL3Key = new EndpointL3Key(gatewayIp, l3ContextId);
+
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.externalGatewayAsL3Endpoint(epL3Key.getL3Context(), epL3Key.getIpAddress()), rwTx);
+
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(Endpoints.class)
+ .child(EndpointL3Prefix.class, new EndpointL3PrefixKey(MappingUtils.DEFAULT_ROUTE, l3ContextId))
+ .build(), rwTx);
+
+ Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet>
+ subnetOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.subnetIid(tenantId, new SubnetId(ipWithSubnetFromGwPort.getSubnetId().getValue())),
+ dataProvider.newReadOnlyTransaction());
+
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet
+ subnet =
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder(
+ subnetOptional.get()).setVirtualRouterIp(null).build();
+ LOG.trace("Removing VirtualRouterIp from subnet {}.", subnetOptional.get());
+ rwTx.put(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.subnetIid(tenantId, new SubnetId(ipWithSubnetFromGwPort.getSubnetId().getValue())), subnet);
+
+ L2BridgeDomainId l2BdId = new L2BridgeDomainId(potentialSubnet.get().getNetworkId().getValue());
+ L3ContextId l3Context = new L3ContextId( potentialSubnet.get().getNetworkId().getValue());
+ Optional<L2BridgeDomain> optBd = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.l2BridgeDomainIid(tenantId, l2BdId), rwTx);
+ if (optBd.isPresent()) {
+ L2BridgeDomain l2BdWithGw = new L2BridgeDomainBuilder(optBd.get()).setParent(l3Context).build();
+ LOG.trace("Setting parent for L2BridgeDomain {} back to network {}.", l2BdWithGw, l3Context);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BdId),
+ l2BdWithGw);
+ }
+ }
}
private static @Nonnull ForwardingContext createL3ContextFromRouter(
@Override
public void onDeleted(Router router, Neutron oldNeutron, Neutron newNeutron) {
- LOG.trace("deleted router - {}", router);
+ LOG.debug("deleted router - {}", router);
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+ ContextId routerl3ContextId = new ContextId(router.getUuid().getValue());
+ TenantId tenantId = new TenantId(router.getTenantId().getValue());
+ deleteExtGw(router, tenantId, newNeutron, rwTx);
+ InstanceIdentifier<ForwardingContext> routerL3CtxIid = L2L3IidFactory.l3ContextIid(tenantId, routerl3ContextId);
+
+ LOG.trace("Removing router from forwardingByTenant. Router: {} Path: {}", router, routerL3CtxIid);
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION, routerL3CtxIid, rwTx);
+
+ InstanceIdentifier<L3Context> l3ContextInstanceIdentifier =
+ IidFactory.l3ContextIid(tenantId, new L3ContextId(routerl3ContextId));
+ LOG.trace("Removing router from Tenant`s forwarding context. Router: {} Path: {}", router,
+ l3ContextInstanceIdentifier);
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION, l3ContextInstanceIdentifier, rwTx);
+
+ DataStoreHelper.submitToDs(rwTx);
+ }
+
+ private void deleteExtGw(Router router, TenantId tenantId, Neutron newNeutron, ReadWriteTransaction rwTx) {
+ ContextId routerL3CtxId = new ContextId(router.getUuid().getValue());
+ if (router.getGatewayPortId() != null) {
+ // external network is attached to router
+ Uuid gatewayPortId = router.getGatewayPortId();
+ Optional<Port> potentialGwPort = PortUtils.findPort(gatewayPortId, newNeutron.getPorts());
+ if (!potentialGwPort.isPresent()) {
+ LOG.trace("Gateway port {} is not present. Skipping delete for external gateway", gatewayPortId);
+ return;
+ }
+
+ Port gwPort = potentialGwPort.get();
+ List<FixedIps> fixedIpsFromGwPort = gwPort.getFixedIps();
+ if (fixedIpsFromGwPort == null || fixedIpsFromGwPort.isEmpty()) {
+ LOG.trace("Gateway port {} with does not contain fixed IPs. Skipping delete for external gateway",
+ gatewayPortId);
+ return;
+ }
+
+ FixedIps ipWithSubnetFromGwPort = fixedIpsFromGwPort.get(0);
+ Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet>
+ potentialSubnet = SubnetUtils.findSubnet(ipWithSubnetFromGwPort.getSubnetId(), newNeutron.getSubnets());
+ if (!potentialSubnet.isPresent()) {
+ LOG.trace("Subnet for GW port {} is not present. Skipping delete for external gateway",
+ gatewayPortId);
+ return;
+ }
+ IpPrefix gatewayIp = MappingUtils.ipAddressToIpPrefix(potentialSubnet.get().getGatewayIp());
+
+ if (!unregisterExternalGateway(gatewayIp, routerL3CtxId)) {
+ LOG.warn("Could not unregister routerL3Prefix as gateway of default route. Gateway port {}", gwPort);
+ return;
+ }
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.externalGatewayAsEndpoint(routerL3CtxId, gatewayIp, MappingUtils.L3_CONTEXT),
+ rwTx);
+ NetworkDomainId domainId = new NetworkDomainId(ipWithSubnetFromGwPort.getSubnetId().getValue());
+ Optional<NetworkDomain> domainOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ L2L3IidFactory.subnetIid(tenantId, domainId), dataProvider.newReadWriteTransaction());
+
+ if (domainOptional.isPresent()) {
+ Subnet originalSubnet = domainOptional.get().getAugmentation(SubnetAugmentForwarding.class).getSubnet();
+ if (originalSubnet != null) {
+ LOG.trace("Deleting virtual router IP from Subnet {} in gateway {}", originalSubnet, gatewayPortId);
+ SubnetBuilder subnetBuilder = new SubnetBuilder(originalSubnet).setVirtualRouterIp(null);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION,
+ L2L3IidFactory.subnetIid(tenantId, domainId)
+ .augmentation(SubnetAugmentForwarding.class)
+ .child(Subnet.class),
+ subnetBuilder.build());
+ }
+ }
+ ContextId l2BdId = new ContextId(potentialSubnet.get().getNetworkId().getValue());
+ Optional<ForwardingContext> optBd = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ L2L3IidFactory.l2BridgeDomainIid(tenantId, l2BdId), rwTx);
+ Parent parent = MappingUtils.createParent(l2BdId, MappingUtils.L3_CONTEXT);
+ if (optBd.isPresent()) {
+ ForwardingContext bridgeDomain = new ForwardingContextBuilder(optBd.get()).setParent(parent).build();
+ LOG.trace("Setting parent for L2BridgeDomain {} back to network {}.", bridgeDomain, parent);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l2BridgeDomainIid(tenantId, l2BdId),
+ bridgeDomain);
+ }
+ }
+ deleteTenantForwarding(newNeutron, router, new L3ContextId(routerL3CtxId), tenantId, rwTx);
}
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
- <odl:rpc-service id="epService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService"/>
- <odl:rpc-service id="baseEpService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService"/>
+ <reference id="rpcRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
<reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
<bean id="neutronMapper" class="org.opendaylight.controller.config.yang.config.neutron_mapper.impl.NeutronMapperInstance"
- init-method="instantiate" destroy-method="close">
+ init-method="instantiate" destroy-method="close">
<argument ref="dataBroker"/>
- <argument ref="epService"/>
- <argument ref="baseEpService"/>
- <argument ref="clusterSingletonService" />
+ <argument ref="rpcRegistry"/>
+ <argument ref="clusterSingletonService"/>
</bean>
</blueprint>
\ No newline at end of file
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
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.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.neutron.ovsdb.NeutronOvsdb;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
private static final ServiceGroupIdentifier IDENTIFIER =
ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
private final DataBroker dataBroker;
- private final EndpointService epService;
private final IntegrationBridgeSetting settings;
private final ClusterSingletonServiceProvider clusterSingletonService;
+ private final RpcProviderRegistry rpcBroker;
private ClusterSingletonServiceRegistration singletonServiceRegistration;
private NeutronOvsdb neutronOvsdb;
public NeutronOvsdbInstance(final DataBroker dataBroker,
- final EndpointService epService,
+ final RpcProviderRegistry rpcBroker,
final IntegrationBridgeSetting settings,
final ClusterSingletonServiceProvider clusterSingletonService) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.epService = Preconditions.checkNotNull(epService);
+ this.rpcBroker = Preconditions.checkNotNull(rpcBroker);
this.settings = Preconditions.checkNotNull(settings);
this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
}
@Override
public void instantiateServiceInstance() {
LOG.info("Instantiating {}", this.getClass().getSimpleName());
+ final EndpointService epService = rpcBroker.getRpcService(EndpointService.class);
neutronOvsdb = new NeutronOvsdb(dataBroker, epService, settings);
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
- <odl:rpc-service id="epService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService"/>
+ <reference id="rpcRegistry" interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
<reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
<odl:clustered-app-config id="moduleConfig"
- binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.ovsdb.params.rev160812.IntegrationBridgeSetting">
+ binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.ovsdb.params.rev160812.IntegrationBridgeSetting">
<odl:default-config><![CDATA[
<integration-bridge-setting xmlns="urn:opendaylight:groupbasedpolicy:neutron:ovsdb:params">
<name>br-int</name>
</odl:clustered-app-config>
<bean id="neutronOvsdb" class="org.opendaylight.controller.config.yang.config.neutron_ovsdb.impl.NeutronOvsdbInstance"
- init-method="initialize" destroy-method="close">
+ init-method="initialize" destroy-method="close">
<argument ref="dataBroker"/>
- <argument ref="epService"/>
+ <argument ref="rpcRegistry"/>
<argument ref="moduleConfig"/>
- <argument ref="clusterSingletonService" />
+ <argument ref="clusterSingletonService"/>
</bean>
</blueprint>
\ No newline at end of file
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
public NeutronVppMapper(String socketPath, String socketPrefix, DataBroker dataBroker) {\r
SocketInfo socketInfo = new SocketInfo(socketPath, socketPrefix);\r
vppNodeListener = new VppNodeListener(dataBroker, socketInfo);\r
- neutronListener = new NeutronListener(dataBroker, socketInfo);\r
+ neutronListener = new NeutronListener(dataBroker);\r
LOG.info("Neutron VPP started!");\r
}\r
\r
@Override\r
protected void onSubtreeModified(DataObjectModification<RendererNode> rootNode,\r
InstanceIdentifier<RendererNode> rootIdentifier) {\r
- deleteData(rootNode.getDataAfter());\r
- writeData(rootNode.getDataBefore());\r
+ deleteData(rootNode.getDataBefore());\r
+ writeData(rootNode.getDataAfter());\r
}\r
\r
private void writeData(RendererNode rendererNode) {\r
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
-import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;\r
import org.opendaylight.yangtools.concepts.ListenerRegistration;\r
import org.opendaylight.yangtools.yang.binding.DataObject;\r
private final Set<MappingProvider<? extends DataObject>> dataChangeProviders = new LinkedHashSet<>();\r
protected ListenerRegistration<NeutronListener> registeredListener;\r
\r
- public NeutronListener(DataBroker dataBroker, SocketInfo socketInfo) {\r
- registerHandlersAndListeners(dataBroker, socketInfo);\r
+ public NeutronListener(DataBroker dataBroker) {\r
+ registerHandlersAndListeners(dataBroker);\r
registeredListener = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(\r
LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Neutron.class).build()), this);\r
}\r
\r
- private void registerHandlersAndListeners(DataBroker dataBroker, SocketInfo socketInfo) {\r
- PortHandler portHandler = new PortHandler(dataBroker, socketInfo);\r
+ private void registerHandlersAndListeners(DataBroker dataBroker) {\r
+ PortHandler portHandler = new PortHandler(dataBroker);\r
dataChangeProviders.add(new PortAware(portHandler, dataBroker));\r
dataChangeProviders.add(new NetworkAware(dataBroker));\r
}\r
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;\r
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;\r
-import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;\r
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;\r
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;\r
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;\r
import com.google.common.annotations.VisibleForTesting;\r
import com.google.common.base.Optional;\r
\r
+import javax.annotation.Nonnull;\r
public class PortHandler implements TransactionChainListener {\r
\r
- private static final Logger LOG = LoggerFactory.getLogger(MappingProvider.class);\r
+ private static final Logger LOG = LoggerFactory.getLogger(PortHandler.class);\r
\r
private static final String COMPUTE_OWNER = "compute";\r
private static final String DHCP_OWNER = "dhcp";\r
private static final String ROUTER_OWNER = "network:router_interface";\r
private static final String[] SUPPORTED_DEVICE_OWNERS = {COMPUTE_OWNER, DHCP_OWNER, ROUTER_OWNER};\r
private static final String VHOST_USER = "vhostuser";\r
+ private static final String UNBOUND = "unbound";\r
private static final String VPP_INTERFACE_NAME_PREFIX = "neutron_port_";\r
private static final String TAP_PORT_NAME_PREFIX = "tap";\r
private static final String RT_PORT_NAME_PREFIX = "qr-";\r
+ private static final String VHOST_SOCKET_KEY = "vhostuser_socket";\r
\r
private BindingTransactionChain transactionChain;\r
private DataBroker dataBroker;\r
- private SocketInfo socketInfo;\r
\r
- PortHandler(DataBroker dataBroker, SocketInfo socketInfo) {\r
+ PortHandler(DataBroker dataBroker) {\r
this.dataBroker = dataBroker;\r
- this.socketInfo = socketInfo;\r
transactionChain = this.dataBroker.createTransactionChain(this);\r
}\r
\r
processCreated(delta);\r
}\r
\r
- private boolean isUpdateNeeded(Port oldPort, Port newPort) {\r
+ private boolean isUpdateNeeded(final Port oldPort, final Port newPort) {\r
//TODO fix this to better support update of ports for VPP\r
- PortBindingExtension oldPortAugmentation = oldPort.getAugmentation(PortBindingExtension.class);\r
- PortBindingExtension newPortAugmentation = newPort.getAugmentation(PortBindingExtension.class);\r
-\r
- List<VifDetails> vifDetails = oldPortAugmentation.getVifDetails();\r
+ final PortBindingExtension oldPortAugmentation = oldPort.getAugmentation(PortBindingExtension.class);\r
+ final PortBindingExtension newPortAugmentation = newPort.getAugmentation(PortBindingExtension.class);\r
\r
if (newPortAugmentation == null) {\r
LOG.trace("Port {} is no longer a vhost type port, updating port...");\r
return true;\r
}\r
\r
+ final String oldDeviceOwner = oldPort.getDeviceOwner();\r
+ final String oldVifType = oldPortAugmentation.getVifType();\r
+ final String newDeviceOwner = newPort.getDeviceOwner();\r
+ final String newVifType = newPortAugmentation.getVifType();\r
+\r
+ // TODO potential bug here\r
+ // Temporary change for Openstack Mitaka: If old neutron-binding:vif-type is vhost, new one is unbound and\r
+ // device owner is ROUTER_OWNER, skip update. Openstack (or ml2) sometimes sends router update messages in\r
+ // incorrect order which causes unwanted port removal\r
+ if (oldVifType.equals(VHOST_USER) && newVifType.equals(UNBOUND) && oldDeviceOwner != null &&\r
+ ROUTER_OWNER.equals(oldDeviceOwner) && ROUTER_OWNER.equals(newDeviceOwner)) {\r
+ LOG.warn("Port vif-type was updated from vhost to unbound. This update is currently disabled and will be skipped");\r
+ return false;\r
+ }\r
+\r
+ if (newVifType != null && !newVifType.equals(oldVifType)) {\r
+ LOG.trace("Vif type changed, old: {} new {}", oldVifType, newVifType);\r
+ return true;\r
+ }\r
+\r
+ final List<VifDetails> vifDetails = oldPortAugmentation.getVifDetails();\r
+\r
if (!oldPortAugmentation.getHostId().equals(newPortAugmentation.getHostId()) ||\r
nullToEmpty(vifDetails).size() != nullToEmpty(newPortAugmentation.getVifDetails()).size()) {\r
return true;\r
.setAddressType(bebp.getAddressType())\r
.setVppInterfaceName(VPP_INTERFACE_NAME_PREFIX + bebp.getPortId().getValue())\r
.setVppNodeId(new NodeId(portBinding.getHostId()));\r
+\r
if (port.getDeviceOwner().contains(COMPUTE_OWNER)) {\r
- String socket = socketInfo.getSocketPath() + socketInfo.getSocketPrefix() + bebp.getPortId().getValue();\r
- vppEpBuilder.setInterfaceTypeChoice(new VhostUserCaseBuilder().setSocket(socket).build());\r
+ vppEpBuilder.setInterfaceTypeChoice(\r
+ new VhostUserCaseBuilder().setSocket(getSocketFromPortBinding(portBinding)).build());\r
} else if (port.getDeviceOwner().contains(DHCP_OWNER) && port.getMacAddress() != null) {\r
TapCase tapCase = new TapCaseBuilder().setPhysicalAddress(new PhysAddress(port.getMacAddress().getValue()))\r
.setName(createPortName(port.getUuid()))\r
return vppEpBuilder.build();\r
}\r
\r
+ private String getSocketFromPortBinding(@Nonnull PortBindingExtension portBindingExtension) {\r
+ List<VifDetails> vifDetails = nullToEmpty(portBindingExtension.getVifDetails());\r
+\r
+ for (VifDetails detail : vifDetails) {\r
+ if (VHOST_SOCKET_KEY.equalsIgnoreCase(detail.getDetailsKey())) {\r
+ return detail.getValue();\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
private LoopbackCase getLoopbackCase(Port port) {\r
LoopbackCaseBuilder loopbackCase = new LoopbackCaseBuilder()\r
.setPhysAddress(new PhysAddress(port.getMacAddress().getValue()));\r
public void init() {\r
port = TestUtils.createValidVppPort();\r
bebp = TestUtils.createBaseEndpointByPortForPort();\r
- socketInfo = new SocketInfo("/tmp/", "_socket");\r
dataBroker = getDataBroker();\r
- neutronListener = new NeutronListener(dataBroker, socketInfo);\r
+ neutronListener = new NeutronListener(dataBroker);\r
neutronListener.clearDataChangeProviders();\r
baseEpByPortListener = Mockito.spy(new PortAware(new PortHandler(\r
- dataBroker, socketInfo), dataBroker));\r
+ dataBroker), dataBroker));\r
neutronListener.addDataChangeProvider(baseEpByPortListener);\r
}\r
\r
@Test\r
public void constructorTest() {\r
dataBroker = Mockito.spy(dataBroker);\r
- NeutronListener neutronListener = new NeutronListener(dataBroker, socketInfo);\r
+ NeutronListener neutronListener = new NeutronListener(dataBroker);\r
verify(dataBroker).registerDataTreeChangeListener(\r
eq(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,\r
InstanceIdentifier.builder(Neutron.class)\r
private BindingTransactionChain transactionChain;
private Port port;
- private SocketInfo socketInfo;
private BaseEndpointByPort bebp;
@Rule
public void init() {
port = TestUtils.createValidVppPort();
bebp = TestUtils.createBaseEndpointByPortForPort();
- socketInfo = new SocketInfo("/tmp/", "_socket");
dataBroker = Mockito.spy(getDataBroker());
transactionChain = mock(BindingTransactionChain.class);
when(dataBroker.createTransactionChain(any(PortHandler.class))).thenReturn(transactionChain);
- portHandler = new PortHandler(dataBroker, socketInfo);
+ portHandler = new PortHandler(dataBroker);
when(transactionChain.newReadOnlyTransaction()).thenAnswer(new Answer<ReadTransaction>() {
@Override
assertTrue(vppEp.getInterfaceTypeChoice() instanceof VhostUserCase);
VhostUserCase vhostUserCase = (VhostUserCase) vppEp.getInterfaceTypeChoice();
assertNotNull(vhostUserCase);
- assertEquals(vhostUserCase.getSocket(), socketInfo.getSocketPath() + socketInfo.getSocketPrefix()
- + bebp.getPortId().getValue());
+ assertEquals(TestUtils.TEST_SOCKET, vhostUserCase.getSocket());
}
@Test
import static org.junit.Assert.assertNotNull;\r
import static org.junit.Assert.assertTrue;\r
\r
+import java.util.Collections;\r
import java.util.Iterator;\r
\r
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtensionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.binding.attributes.VifDetailsBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.binding.attributes.VifDetailsKey;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;\r
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;\r
\r
public class TestUtils {\r
+ public static String TEST_SOCKET = "/tmp/socket_testsocket";\r
\r
public static Port createValidVppPort() {\r
PortBindingExtension portBindingExt = new PortBindingExtensionBuilder().setHostId("devstack-control")\r
.setVifType("vhostuser")\r
+ .setVifDetails(Collections.singletonList(\r
+ new VifDetailsBuilder().setKey(new VifDetailsKey("vhostuser_socket"))\r
+ .setValue(TEST_SOCKET)\r
+ .build()))\r
.build();\r
return new PortBuilder().setUuid(new Uuid("00000000-1111-2222-3333-444444444444"))\r
.setDeviceOwner("compute")\r
<module>distribution-karaf</module>
<module>features</module>
<module>sxp-integration</module>
- <module>ip-sgt-distribution-service</module>
</modules>
<build>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<configuration>
<instructions>
<Export-Package>
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.*
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.*,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.*
</Export-Package>
</instructions>
</configuration>
-/*\r
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
- *\r
- * This program and the accompanying materials are made available under the\r
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
- * and is available at http://www.eclipse.org/legal/epl-v10.html\r
- */\r
-\r
-package org.opendaylight.groupbasedpolicy.renderer.vpp.adapter;\r
-\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.concurrent.Future;\r
-import java.util.stream.Collectors;\r
-\r
-import javax.annotation.Nonnull;\r
-\r
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.TapPortCommand;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;\r
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;\r
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;\r
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.AddInterfaceToBridgeDomainInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateInterfaceOnNodeInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateVirtualBridgeDomainOnNodesInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DelInterfaceFromBridgeDomainInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteInterfaceFromNodeInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteVirtualBridgeDomainFromNodesInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CloneVirtualBridgeDomainOnNodesInput;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vlan;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vxlan;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vlan.rev160429.network.topology.topology.tunnel.parameters.VlanNetworkParameters;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;\r
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;\r
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;\r
-import org.opendaylight.yangtools.yang.common.RpcResult;\r
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;\r
-import org.slf4j.Logger;\r
-import org.slf4j.LoggerFactory;\r
-\r
-import com.google.common.base.Optional;\r
-import com.google.common.util.concurrent.AsyncFunction;\r
-import com.google.common.util.concurrent.CheckedFuture;\r
-import com.google.common.util.concurrent.Futures;\r
-import com.google.common.util.concurrent.ListenableFuture;\r
-\r
-public class VppRpcServiceImpl {\r
-\r
- private static final Logger LOG = LoggerFactory.getLogger(VppRpcServiceImpl.class);\r
-\r
- private final DataBroker dataBroker;\r
- private final BridgeDomainManager bridgeDomainManager;\r
- private final InterfaceManager interfaceManager;\r
- private final MountedDataBrokerProvider mountDataProvider;\r
-\r
- public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountDataProvider,\r
- BridgeDomainManager bridgeDomainManager, InterfaceManager interfaceManager) {\r
- this.dataBroker = dataBroker;\r
- this.bridgeDomainManager = bridgeDomainManager;\r
- this.interfaceManager = interfaceManager;\r
- this.mountDataProvider = mountDataProvider;\r
- }\r
-\r
- public Future<RpcResult<Void>> createVirtualBridgeDomain(CreateVirtualBridgeDomainOnNodesInput input) {\r
- LOG.info("Processing a remote call for creating bridge domain {}", input.getId());\r
- if (input.getTunnelType() == null) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(ErrorType.RPC,\r
- "Failed to create bridge domain" + input.getId() + "." + "Tunnel type not specified")\r
- .build());\r
- }\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- List<NodeId> nodeIds = input.getPhysicalLocationRef()\r
- .stream()\r
- .map(locationRef -> locationRef.getNodeId())\r
- .collect(Collectors.toList());\r
- LOG.trace("Corresponding nodes for bridge-domain {}", input.getPhysicalLocationRef());\r
- if (input.getTunnelType() instanceof Vxlan) {\r
- LOG.trace("Detected VXLAN type for bridge domain {}", input.getId());\r
- Vxlan tunnelType = (Vxlan) input.getTunnelType();\r
- VxlanVni vxlanVni = new VxlanVni(tunnelType.getVni().getValue());\r
- nodeIds.forEach(nodeId -> {\r
- futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(input.getId(), vxlanVni, nodeId));\r
- });\r
- } else if (input.getTunnelType() instanceof Vlan) {\r
- LOG.trace("Detected VLAN type for bridge domain {}", input.getId());\r
- Vlan vlan = (Vlan) input.getTunnelType();\r
- VlanId vlanId = new VlanId(vlan.getVlanId().getValue());\r
- nodeIds.forEach(nodeId -> {\r
- futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(input.getId(), vlanId, nodeId));\r
- });\r
- }\r
- return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
- }\r
-\r
- public Future<RpcResult<Void>> deleteVirtualBridgeDomain(DeleteVirtualBridgeDomainFromNodesInput input) {\r
- LOG.info("Processing a remote call for removing bridge domain {}", input.getBridgeDomainId());\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- input.getBridgeDomainNode().forEach(nodeId -> {\r
- futures.add(bridgeDomainManager.removeBridgeDomainFromVppNode(input.getBridgeDomainId(), nodeId));\r
- });\r
- return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNode(CloneVirtualBridgeDomainOnNodesInput input) {\r
- LOG.info("Processing a remote call for clonning bridge domain {}", input.getBridgeDomainId());\r
- List<ListenableFuture<Void>> futures = new ArrayList<>();\r
- ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
- InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(new TopologyKey(new TopologyId(\r
- input.getBridgeDomainId())));\r
- return Futures.transform(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),\r
- new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Topology> optTopology) throws Exception {\r
- if (!optTopology.isPresent()) {\r
-\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Failed to clone bridge domain. Bridge domain " + input.getBridgeDomainId()\r
- + " does not exist.")\r
- .build());\r
- }\r
- TopologyVbridgeAugment vBridgeAug = optTopology.get().getAugmentation(TopologyVbridgeAugment.class);\r
- if (vBridgeAug == null) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Failed to clone bridge domain. Topology " + input.getBridgeDomainId()\r
- + " is not bridge domain type.")\r
- .build());\r
- }\r
- if (vBridgeAug.getTunnelParameters() instanceof VxlanTunnelParameters) {\r
- LOG.debug("Clonning VXLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),\r
- input.getBridgeDomainNode());\r
- VxlanTunnelParameters vxlanTunnelParams = (VxlanTunnelParameters) vBridgeAug.getTunnelParameters();\r
- VxlanVni vni = vxlanTunnelParams.getVni();\r
- input.getBridgeDomainNode().forEach(\r
- nodeId -> {\r
- futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(\r
- input.getBridgeDomainId(), vni, nodeId));\r
- });\r
- } else if (vBridgeAug.getTunnelParameters() instanceof VlanNetworkParameters) {\r
- LOG.debug("Clonning VLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),\r
- input.getBridgeDomainNode());\r
- VlanNetworkParameters vlanTunnelParams = (VlanNetworkParameters) vBridgeAug.getTunnelParameters();\r
- VlanId vlanId = vlanTunnelParams.getVlanId();\r
- input.getBridgeDomainNode().forEach(\r
- nodeId -> {\r
- futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(\r
- input.getBridgeDomainId(), vlanId, nodeId));\r
- });\r
- }\r
- return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> createInterfaceOnNodes(CreateInterfaceOnNodeInput input) {\r
- InterfaceTypeChoice interfaceType = input.getInterfaceTypeChoice();\r
- ConfigCommand ifaceCommand = null;\r
- if (interfaceType instanceof VhostUserCase) {\r
- VhostUserCommandBuilder vhostBuilder = VhostUserCommand.builder();\r
- vhostBuilder.setName(input.getVppInterfaceName());\r
- VhostUserCase vhostCase = (VhostUserCase) input.getInterfaceTypeChoice();\r
- vhostBuilder.setSocket(vhostCase.getSocket());\r
- vhostBuilder.setRole(VhostUserRole.Client);\r
- vhostBuilder.setDescription(input.getDescription());\r
- vhostBuilder.setOperation(Operations.PUT);\r
- ifaceCommand = vhostBuilder.build();\r
- }\r
- if (interfaceType instanceof TapCase) {\r
- TapPortCommand.TapPortCommandBuilder tapBuilder = TapPortCommand.builder();\r
- TapCase tapIface = (TapCase) input.getInterfaceTypeChoice();\r
- tapBuilder.setTapName(tapIface.getName());\r
- tapBuilder.setPhysAddress(tapIface.getPhysicalAddress());\r
- tapBuilder.setInterfaceName(input.getVppInterfaceName());\r
- tapBuilder.setDescription(input.getDescription());\r
- tapBuilder.setOperation(Operations.PUT);\r
- ifaceCommand = tapBuilder.build();\r
- }\r
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- if (!optDataBroker.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(ErrorType.RPC, "Cannot find data broker for mount point " + vppNodeIid)\r
- .build());\r
- }\r
- return Futures.transform(interfaceManager.createInterfaceOnVpp(ifaceCommand, optDataBroker.get()),\r
- voidToRpcResult());\r
- }\r
+/*
+ * 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.renderer.vpp.adapter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.TapPortCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.AddInterfaceToBridgeDomainInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateInterfaceOnNodeInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DelInterfaceFromBridgeDomainInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteInterfaceFromNodeInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteVirtualBridgeDomainFromNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CloneVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vxlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vlan.rev160429.network.topology.topology.tunnel.parameters.VlanNetworkParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
+public class VppRpcServiceImpl {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppRpcServiceImpl.class);
+
+ private final DataBroker dataBroker;
+ private final BridgeDomainManager bridgeDomainManager;
+ private final InterfaceManager interfaceManager;
+ private final MountedDataBrokerProvider mountDataProvider;
+
+ public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountDataProvider,
+ BridgeDomainManager bridgeDomainManager, InterfaceManager interfaceManager) {
+ this.dataBroker = dataBroker;
+ this.bridgeDomainManager = bridgeDomainManager;
+ this.interfaceManager = interfaceManager;
+ this.mountDataProvider = mountDataProvider;
+ }
+
+ public Future<RpcResult<Void>> createVirtualBridgeDomain(CreateVirtualBridgeDomainOnNodesInput input) {
+ LOG.info("Processing a remote call for creating bridge domain {}", input.getId());
+ if (input.getTunnelType() == null) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(ErrorType.RPC,
+ "Failed to create bridge domain" + input.getId() + "." + "Tunnel type not specified")
+ .build());
+ }
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ List<NodeId> nodeIds = (input.getPhysicalLocationRef() == null) ? new ArrayList<>() : input
+ .getPhysicalLocationRef().stream().map(locationRef -> locationRef.getNodeId()).collect(Collectors.toList());
+ LOG.trace("Corresponding nodes for bridge-domain {}", input.getPhysicalLocationRef());
+ if (input.getTunnelType() instanceof Vxlan) {
+ LOG.trace("Detected VXLAN type for bridge domain {}", input.getId());
+ Vxlan tunnelType = (Vxlan) input.getTunnelType();
+ VxlanVni vxlanVni = new VxlanVni(tunnelType.getVni().getValue());
+ nodeIds.forEach(nodeId -> {
+ futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(input.getId(), vxlanVni, nodeId));
+ });
+ } else if (input.getTunnelType() instanceof Vlan) {
+ LOG.trace("Detected VLAN type for bridge domain {}", input.getId());
+ Vlan vlan = (Vlan) input.getTunnelType();
+ VlanId vlanId = new VlanId(vlan.getVlanId().getValue());
+ nodeIds.forEach(nodeId -> {
+ futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(input.getId(), vlanId, nodeId));
+ });
+ }
+ return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+ }
+
+ public Future<RpcResult<Void>> deleteVirtualBridgeDomain(DeleteVirtualBridgeDomainFromNodesInput input) {
+ LOG.info("Processing a remote call for removing bridge domain {}", input.getBridgeDomainId());
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ input.getBridgeDomainNode().forEach(nodeId -> {
+ futures.add(bridgeDomainManager.removeBridgeDomainFromVppNode(input.getBridgeDomainId(), nodeId));
+ });
+ return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+ }
+
+ public ListenableFuture<RpcResult<Void>> cloneVirtualBridgeDomainOnNode(CloneVirtualBridgeDomainOnNodesInput input) {
+ LOG.info("Processing a remote call for clonning bridge domain {}", input.getBridgeDomainId());
+ List<ListenableFuture<Void>> futures = new ArrayList<>();
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(new TopologyKey(new TopologyId(
+ input.getBridgeDomainId())));
+ return Futures.transform(rTx.read(LogicalDatastoreType.CONFIGURATION, topologyIid),
+ new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Topology> optTopology) throws Exception {
+ if (!optTopology.isPresent()) {
+
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Failed to clone bridge domain. Bridge domain " + input.getBridgeDomainId()
+ + " does not exist.")
+ .build());
+ }
+ TopologyVbridgeAugment vBridgeAug = optTopology.get().getAugmentation(TopologyVbridgeAugment.class);
+ if (vBridgeAug == null) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Failed to clone bridge domain. Topology " + input.getBridgeDomainId()
+ + " is not bridge domain type.")
+ .build());
+ }
+ if (vBridgeAug.getTunnelParameters() instanceof VxlanTunnelParameters) {
+ LOG.debug("Clonning VXLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),
+ input.getBridgeDomainNode());
+ VxlanTunnelParameters vxlanTunnelParams = (VxlanTunnelParameters) vBridgeAug.getTunnelParameters();
+ VxlanVni vni = vxlanTunnelParams.getVni();
+ input.getBridgeDomainNode().forEach(
+ nodeId -> {
+ futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(
+ input.getBridgeDomainId(), vni, nodeId));
+ });
+ } else if (vBridgeAug.getTunnelParameters() instanceof VlanNetworkParameters) {
+ LOG.debug("Clonning VLAN type bridge domain {} on nodes {}", input.getBridgeDomainId(),
+ input.getBridgeDomainNode());
+ VlanNetworkParameters vlanTunnelParams = (VlanNetworkParameters) vBridgeAug.getTunnelParameters();
+ VlanId vlanId = vlanTunnelParams.getVlanId();
+ input.getBridgeDomainNode().forEach(
+ nodeId -> {
+ futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(
+ input.getBridgeDomainId(), vlanId, nodeId));
+ });
+ }
+ return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());
+ }
+ });
+ }
+
+ public ListenableFuture<RpcResult<Void>> createInterfaceOnNodes(CreateInterfaceOnNodeInput input) {
+ LOG.info("Processing a remote call for creating interface {} on node {}", input.getVppInterfaceName(),
+ input.getVppNodeId());
+ InterfaceTypeChoice interfaceType = input.getInterfaceTypeChoice();
+ ConfigCommand ifaceCommand = null;
+ if (interfaceType instanceof VhostUserCase) {
+ VhostUserCommandBuilder vhostBuilder = VhostUserCommand.builder();
+ vhostBuilder.setName(input.getVppInterfaceName());
+ VhostUserCase vhostCase = (VhostUserCase) input.getInterfaceTypeChoice();
+ vhostBuilder.setSocket(vhostCase.getSocket());
+ vhostBuilder.setRole(VhostUserRole.Client);
+ vhostBuilder.setDescription(input.getDescription());
+ vhostBuilder.setOperation(Operations.PUT);
+ ifaceCommand = vhostBuilder.build();
+ }
+ if (interfaceType instanceof TapCase) {
+ TapPortCommand.TapPortCommandBuilder tapBuilder = TapPortCommand.builder();
+ TapCase tapIface = (TapCase) input.getInterfaceTypeChoice();
+ tapBuilder.setTapName(tapIface.getName());
+ tapBuilder.setPhysAddress(tapIface.getPhysicalAddress());
+ tapBuilder.setInterfaceName(input.getVppInterfaceName());
+ tapBuilder.setDescription(input.getDescription());
+ tapBuilder.setOperation(Operations.PUT);
+ ifaceCommand = tapBuilder.build();
+ }
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ if (!optDataBroker.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(ErrorType.RPC, "Cannot find data broker for mount point " + vppNodeIid)
+ .build());
+ }
+ return Futures.transform(interfaceManager.createInterfaceOnVpp(ifaceCommand, optDataBroker.get()),
+ voidToRpcResult());
+ }
public ListenableFuture<RpcResult<Void>> deleteInterfaceFromNodes(DeleteInterfaceFromNodeInput input) {
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),\r
- new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
- InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());\r
- if (!optIface.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Cannot delete interface " + iKey + " on node " + vppNodeIid\r
- + ". Not found or already deleted.")\r
- .build());\r
- }\r
- Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- WriteTransaction wTx = dataBroker.get().newWriteOnlyTransaction();\r
- wTx.delete(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(iKey));\r
- return Futures.transform(wTx.submit(), voidToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {\r
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),\r
- new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
- InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());\r
- if (!optIface.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Cannot add interface " + iKey + " to bridge domain on node "\r
- + vppNodeIid + ". Not found or deleted.")\r
- .build());\r
- }\r
- Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- return Futures.transform(interfaceManager.configureInterface(dataBroker.get(), iKey,\r
- input.getBridgeDomainId(), null), voidToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- public ListenableFuture<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {\r
- InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());\r
- return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),\r
- new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
- if (!optIface.isPresent()) {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
- .withError(\r
- ErrorType.RPC,\r
- "Cannot remove interface " + input.getVppInterfaceName()\r
- + " from bridge domain on node " + vppNodeIid\r
- + ". Not found or deleted.")\r
- .build());\r
- }\r
- Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);\r
- return Futures.transform(interfaceManager.removeInterfaceFromBridgeDomain(dataBroker.get(),\r
- optIface.get().getKey()), voidToRpcResult());\r
- }\r
- });\r
- }\r
-\r
- private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<?> nodeIid,\r
- String interfaceName) {\r
- Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(nodeIid);\r
- if (!optDataBroker.isPresent()) {\r
- LOG.error("Cannot find data broker for node {}", nodeIid);\r
- return Futures.immediateCheckedFuture(Optional.absent());\r
- }\r
- ReadOnlyTransaction rwTx = optDataBroker.get().newReadOnlyTransaction();\r
- InterfaceKey iKey = new InterfaceKey(interfaceName);\r
- InstanceIdentifier<Interface> interfaceIID = VppIidFactory.getInterfaceIID(iKey);\r
- CheckedFuture<Optional<Interface>, ReadFailedException> readInterface = rwTx.read(\r
- LogicalDatastoreType.CONFIGURATION, interfaceIID);\r
- rwTx.close();\r
- return readInterface;\r
- }\r
-\r
- private AsyncFunction<Void, RpcResult<Void>> voidToRpcResult() {\r
- return new AsyncFunction<Void, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(Void input) throws Exception {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());\r
- }\r
- };\r
- }\r
-\r
- private AsyncFunction<List<Void>, RpcResult<Void>> voidsToRpcResult() {\r
- return new AsyncFunction<List<Void>, RpcResult<Void>>() {\r
-\r
- @Override\r
- public ListenableFuture<RpcResult<Void>> apply(List<Void> input) throws Exception {\r
- return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());\r
- }\r
- };\r
- }\r
-}\r
+ LOG.info("Processing a remote call for removing interface {} from node {}", input.getVppInterfaceName(),
+ input.getVppNodeId());
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+ new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {
+ InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());
+ if (!optIface.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Cannot delete interface " + iKey + " on node " + vppNodeIid
+ + ". Not found or already deleted.")
+ .build());
+ }
+ Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ WriteTransaction wTx = dataBroker.get().newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(iKey));
+ return Futures.transform(wTx.submit(), voidToRpcResult());
+ }
+ });
+ }
+
+ public ListenableFuture<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {
+ LOG.info("Processing a remote call for adding interface {} to bridge domain {}", input.getVppInterfaceName(),
+ input.getBridgeDomainId());
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+ new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {
+ InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());
+ if (!optIface.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Cannot add interface " + iKey + " to bridge domain on node "
+ + vppNodeIid + ". Not found or deleted.")
+ .build());
+ }
+ Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ return Futures.transform(interfaceManager.configureInterface(dataBroker.get(), iKey,
+ input.getBridgeDomainId(), null), voidToRpcResult());
+ }
+ });
+ }
+
+ public ListenableFuture<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {
+ LOG.info("Processing a remote call for removing interface {} from bridge domain.", input.getVppInterfaceName());
+ InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(input.getVppNodeId());
+ return Futures.transform(readInterface(vppNodeIid, input.getVppInterfaceName()),
+ new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {
+ if (!optIface.isPresent()) {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>failed()
+ .withError(
+ ErrorType.RPC,
+ "Cannot remove interface " + input.getVppInterfaceName()
+ + " from bridge domain on node " + vppNodeIid
+ + ". Not found or deleted.")
+ .build());
+ }
+ Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ return Futures.transform(interfaceManager.removeInterfaceFromBridgeDomain(dataBroker.get(),
+ optIface.get().getKey()), voidToRpcResult());
+ }
+ });
+ }
+
+ private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<?> nodeIid,
+ String interfaceName) {
+ Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(nodeIid);
+ if (!optDataBroker.isPresent()) {
+ LOG.error("Cannot find data broker for node {}", nodeIid);
+ return Futures.immediateCheckedFuture(Optional.absent());
+ }
+ ReadOnlyTransaction rwTx = optDataBroker.get().newReadOnlyTransaction();
+ InterfaceKey iKey = new InterfaceKey(interfaceName);
+ InstanceIdentifier<Interface> interfaceIID = VppIidFactory.getInterfaceIID(iKey);
+ CheckedFuture<Optional<Interface>, ReadFailedException> readInterface = rwTx.read(
+ LogicalDatastoreType.CONFIGURATION, interfaceIID);
+ rwTx.close();
+ return readInterface;
+ }
+
+ private AsyncFunction<Void, RpcResult<Void>> voidToRpcResult() {
+ return new AsyncFunction<Void, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(Void input) throws Exception {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ }
+ };
+ }
+
+ private AsyncFunction<List<Void>, RpcResult<Void>> voidsToRpcResult() {
+ return new AsyncFunction<List<Void>, RpcResult<Void>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(List<Void> input) throws Exception {
+ return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
+ }
+ };
+ }
+}
private ListenableFuture<Void> deleteIfaceOnVpp(ConfigCommand deleteIfaceWithoutBdCommand,
DataBroker vppDataBroker, VppEndpoint vppEndpoint, InstanceIdentifier<?> vppNodeIid) {
- final boolean transactionState = GbpNetconfTransaction.delete(vppDataBroker, deleteIfaceWithoutBdCommand,
+ final boolean transactionState = GbpNetconfTransaction.deleteIfExists(vppDataBroker, deleteIfaceWithoutBdCommand,
GbpNetconfTransaction.RETRY_COUNT);
if (transactionState) {
LOG.debug("Delete interface on VPP command was successful: VPP: {} Command: {}", vppNodeIid,
LOG.warn("Interface already not in bridge domain {} ", ifaceKey);
return Futures.immediateFuture(null);
}
- final boolean transactionState = GbpNetconfTransaction.delete(mountPoint,
+ final boolean transactionState = GbpNetconfTransaction.deleteIfExists(mountPoint,
VppIidFactory.getL2ForInterfaceIid(ifaceKey), GbpNetconfTransaction.RETRY_COUNT);
if (transactionState) {
LOG.debug("Removing bridge domain from interface {}", VppIidFactory.getInterfaceIID(ifaceKey));
InstanceIdentifier<L2> l2Iid =
interfaceIid.builder().augmentation(VppInterfaceAugmentation.class).child(L2.class).build();
LOG.debug("Deleting bridge domain from interface {}", interfacePath);
- final boolean transactionState = GbpNetconfTransaction.delete(mountpoint, l2Iid,
+ final boolean transactionState = GbpNetconfTransaction.deleteIfExists(mountpoint, l2Iid,
GbpNetconfTransaction.RETRY_COUNT);
if (transactionState) {
return vppEndpointLocationProvider.replaceLocationForEndpoint(new ExternalLocationCaseBuilder()
import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connected;
import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connecting;
+import javax.annotation.Nullable;
import java.util.Arrays;
import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
import java.util.stream.Collectors;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
public class VppNodeManager {
+ private static final short DURATION = 3000;
private static final TopologyId TOPOLOGY_ID = new TopologyId("topology-netconf");
private static final Logger LOG = LoggerFactory.getLogger(VppNodeManager.class);
private static final String V3PO_CAPABILITY = "(urn:opendaylight:params:xml:ns:yang:v3po?revision=2016-12-14)v3po";
}
}
+ @Nullable
private DataBroker getNodeMountPoint(InstanceIdentifier<Node> mountPointIid) {
- Optional<MountPoint> optionalObject = mountService.getMountPoint(mountPointIid);
- MountPoint mountPoint;
- if (optionalObject.isPresent()) {
- mountPoint = optionalObject.get();
- if (mountPoint != null) {
- Optional<DataBroker> optionalDataBroker = mountPoint.getService(DataBroker.class);
- if (optionalDataBroker.isPresent()) {
- return optionalDataBroker.get();
+ final Future<Optional<MountPoint>> futureOptionalObject = getMountpointFromSal(mountPointIid);
+ try {
+ final Optional<MountPoint> optionalObject = futureOptionalObject.get();
+ LOG.debug("Optional mountpoint object: {}", optionalObject);
+ MountPoint mountPoint;
+ if (optionalObject.isPresent()) {
+ mountPoint = optionalObject.get();
+ if (mountPoint != null) {
+ Optional<DataBroker> optionalDataBroker = mountPoint.getService(DataBroker.class);
+ if (optionalDataBroker.isPresent()) {
+ return optionalDataBroker.get();
+ } else {
+ LOG.warn("Cannot obtain data broker from mountpoint {}", mountPoint);
+ }
} else {
- LOG.warn("Cannot obtain data broker from mountpoint {}", mountPoint);
+ LOG.warn("Cannot obtain mountpoint with IID {}", mountPointIid);
}
- } else {
- LOG.warn("Cannot obtain mountpoint with IID {}", mountPointIid);
}
+ return null;
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.warn("Unable to obtain mountpoint ... {}", e);
+ return null;
}
- return null;
}
private RendererNode remapNode(InstanceIdentifier<Node> path) {
return Arrays.asList(capabilityEntries);
}
+ // TODO bug 7699
+ // This works as a workaround for mountpoint registration in cluster. If application is registered on different
+ // node as netconf service, it obtains mountpoint registered by SlaveSalFacade (instead of MasterSalFacade). However
+ // this service registers mountpoint a moment later then connectionStatus is set to "Connected". If NodeManager hits
+ // state where device is connected but mountpoint is not yet available, try to get it again in a while
+ private Future<Optional<MountPoint>> getMountpointFromSal(final InstanceIdentifier<Node> iid) {
+ final ExecutorService executorService = Executors.newSingleThreadExecutor();
+ final Callable<Optional<MountPoint>> task = () -> {
+ byte attempt = 0;
+ do {
+ try {
+ final Optional<MountPoint> optionalMountpoint = mountService.getMountPoint(iid);
+ if (optionalMountpoint.isPresent()) {
+ return optionalMountpoint;
+ }
+ LOG.warn("Mountpoint {} is not registered yet", iid);
+ Thread.sleep(DURATION);
+ } catch (InterruptedException e) {
+ LOG.warn("Thread interrupted to ", e);
+ }
+ attempt ++;
+ } while (attempt <= 3);
+ return Optional.absent();
+ };
+ return executorService.submit(task);
+ }
}
import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppRendererProcessingException;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.Containment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.NetworkDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.fields.Parent;
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.renderer.endpoints.RendererEndpointKey;
}
}
if (containment instanceof NetworkDomainContainment) {
- NetworkDomainContainment netDomainCont = (NetworkDomainContainment) containment;
- RendererNetworkDomain rendererNetworkDomain =
- policyCtx.getNetworkDomainTable().get(ep.getTenant(), new RendererNetworkDomainKey(
- netDomainCont.getNetworkDomainId(), netDomainCont.getNetworkDomainType()));
+ final NetworkDomainContainment netDomainCont = (NetworkDomainContainment) containment;
+ final TenantId tenantId = ep.getTenant();
+ final NetworkDomainId domainId = netDomainCont.getNetworkDomainId();
+ final Class<? extends NetworkDomain> domainKey = netDomainCont.getNetworkDomainType();
+ final RendererNetworkDomainKey rendererNetworkDomainKey = new RendererNetworkDomainKey(domainId, domainKey);
+ final RendererNetworkDomain rendererNetworkDomain =
+ policyCtx.getNetworkDomainTable().get(tenantId, rendererNetworkDomainKey);
+ if (rendererNetworkDomain == null) {
+ LOG.debug("Network domain not found. Containment: {}", containment);
+ return java.util.Optional.empty();
+ }
java.util.Optional<String> optL2Fd = getForwardingCtxForParent(ep.getTenant(),
rendererNetworkDomain.getParent(), policyCtx.getForwardingCtxTable())
.filter(fwdCtx -> L2FloodDomain.class.equals(fwdCtx.getContextType()))
package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.common.collect.ImmutableTable;
-import com.google.common.collect.ImmutableTable.Builder;
-import com.google.common.collect.Maps;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import java.util.function.Supplier;
import java.util.stream.Collectors;
+
import javax.annotation.Nonnull;
+
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Policy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
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.rule.groups.RuleGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupKey;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.ImmutableTable;
+import com.google.common.collect.ImmutableTable.Builder;
+import com.google.common.collect.Maps;
+
public class PolicyContext {
private final RendererPolicy policy;
}
@Override
- public int compareTo(RendererResolvedPolicy arg0) {
- return ruleGroup.compareTo(arg0.getRuleGroup());
+ public int compareTo(RendererResolvedPolicy resolvedPolicy) {
+ int comp = ruleGroup.compareTo(resolvedPolicy.getRuleGroup());
+ if (comp == 0 && (rendererEndpointParticipation.getIntValue() != resolvedPolicy
+ .getRendererEndpointParticipation().getIntValue())) {
+ return 1;
+ }
+ return comp;
}
@Override
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
public class GbpNetconfTransaction {
- public static final byte RETRY_COUNT = 5;
+ public static final byte RETRY_COUNT = 3;
private static final Logger LOG = LoggerFactory.getLogger(GbpNetconfTransaction.class);
/**
* @param retryCounter number of attempts
* @return true if transaction is successful, false otherwise
*/
- public synchronized static boolean write(final DataBroker mountpoint, final ConfigCommand command,
+ public static synchronized boolean write(final DataBroker mountpoint, final ConfigCommand command,
byte retryCounter) {
LOG.trace("Netconf WRITE transaction started. RetryCounter: {}", retryCounter);
Preconditions.checkNotNull(mountpoint);
command.execute(rwTx);
final CheckedFuture<Void, TransactionCommitFailedException> futureTask = rwTx.submit();
futureTask.get();
- LOG.trace("Netconf WRITE transaction done. Retry counter: {}", retryCounter);
+ LOG.trace("Netconf WRITE transaction done for command {}", command);
return true;
- } catch (IllegalStateException e) {
+ } catch (Exception e) {
// Retry
if (retryCounter > 0) {
- LOG.warn("Assuming that netconf write-transaction failed, restarting ...", e.getMessage());
+ LOG.warn("Netconf WRITE transaction failed to {}. Restarting transaction ... ", e.getMessage());
return write(mountpoint, command, --retryCounter);
} else {
- LOG.warn("Netconf write-transaction failed. Maximal number of attempts reached", e.getMessage());
+ LOG.warn("Netconf WRITE transaction unsuccessful. Maximal number of attempts reached. Trace: {}", e);
return false;
}
- } catch (Exception e) {
- LOG.warn("Exception while writing data ...", e.getMessage());
- return false;
}
}
* @param <T> generic data type. Has to be child of {@link DataObject}
* @return true if transaction is successful, false otherwise
*/
- public synchronized static <T extends DataObject> boolean write(final DataBroker mountpoint,
+ public static synchronized <T extends DataObject> boolean write(final DataBroker mountpoint,
final InstanceIdentifier<T> iid,
final T data,
byte retryCounter) {
rwTx.put(LogicalDatastoreType.CONFIGURATION, iid, data, true);
final CheckedFuture<Void, TransactionCommitFailedException> futureTask = rwTx.submit();
futureTask.get();
- LOG.trace("Netconf WRITE transaction done. Retry counter: {}", retryCounter);
+ LOG.trace("Netconf WRITE transaction done for {}", iid);
return true;
- } catch (IllegalStateException e) {
+ } catch (Exception e) {
// Retry
if (retryCounter > 0) {
- LOG.warn("Assuming that netconf write-transaction failed, restarting ...", e.getMessage());
+ LOG.warn("Netconf WRITE transaction failed to {}. Restarting transaction ... ", e.getMessage());
return write(mountpoint, iid, data, --retryCounter);
} else {
- LOG.warn("Netconf write-transaction failed. Maximal number of attempts reached", e.getMessage());
+ LOG.warn("Netconf WRITE transaction unsuccessful. Maximal number of attempts reached. Trace: {}", e);
return false;
}
- } catch (Exception e) {
- LOG.warn("Exception while writing data ...", e.getMessage());
- return false;
}
}
* @param <T> generic data type. Has to be child of {@link DataObject}
* @return optional data object if successful, {@link Optional#absent()} if failed
*/
- public synchronized static <T extends DataObject> Optional<T> read(final DataBroker mountpoint,
+ public static synchronized <T extends DataObject> Optional<T> read(final DataBroker mountpoint,
final LogicalDatastoreType datastoreType,
final InstanceIdentifier<T> iid,
byte retryCounter) {
final CheckedFuture<Optional<T>, ReadFailedException> futureData =
rTx.read(datastoreType, iid);
data = futureData.get();
- LOG.trace("Netconf READ transaction done. Data present: {}, Retry counter: {}",
- data.isPresent(), retryCounter);
+ LOG.trace("Netconf READ transaction done. Data present: {}", data.isPresent());
return data;
- } catch (IllegalStateException e) {
+ } catch (Exception e) {
// Retry
if (retryCounter > 0) {
- LOG.warn("Assuming that netconf read-transaction failed, restarting ...", e.getMessage());
+ LOG.warn("Netconf READ transaction failed to {}. Restarting transaction ... ", e.getMessage());
rTx.close();
return read(mountpoint, datastoreType, iid, --retryCounter);
} else {
- LOG.warn("Netconf read-transaction failed. Maximal number of attempts reached", e.getMessage());
+ LOG.warn("Netconf READ transaction unsuccessful. Maximal number of attempts reached. Trace: {}", e);
return Optional.absent();
}
- } catch (Exception e) {
- LOG.warn("Exception while reading data ...", e.getMessage());
- return Optional.absent();
}
}
/**
- * Remove data from remote device using {@link ConfigCommand}. Transaction is restarted if failed.
+ * Remove data from remote device using {@link ConfigCommand}
*
* @param mountpoint to access remote device
* @param command config command with data, datastore type and iid
* @param retryCounter number of attempts
* @return true if transaction is successful, false otherwise
*/
- public synchronized static boolean delete(final DataBroker mountpoint, final ConfigCommand command,
+ public static synchronized boolean deleteIfExists(final DataBroker mountpoint, final ConfigCommand command,
byte retryCounter) {
- LOG.trace("Netconf DELETE transaction started. RetryCounter: {}", retryCounter);
Preconditions.checkNotNull(mountpoint);
- final ReadWriteTransaction rwTx = mountpoint.newReadWriteTransaction();
- try {
- command.execute(rwTx);
- final CheckedFuture<Void, TransactionCommitFailedException> futureTask = rwTx.submit();
- futureTask.get();
- LOG.trace("Netconf DELETE transaction done. Retry counter: {}", retryCounter);
- return true;
- } catch (IllegalStateException e) {
- // Retry
- if (retryCounter > 0) {
- LOG.warn("Assuming that netconf delete-transaction failed, restarting ...", e.getMessage());
- return delete(mountpoint, command, --retryCounter);
- } else {
- LOG.warn("Netconf delete-transaction failed. Maximal number of attempts reached", e.getMessage());
- return false;
- }
- } catch (Exception e) {
- LOG.warn("Exception while removing data ...", e.getMessage());
- return false;
- }
+ InstanceIdentifier<Interface> iid = VppIidFactory.getInterfaceIID(command.getInterfaceBuilder().getKey());
+ return deleteIfExists(mountpoint, iid, retryCounter);
}
/**
- * Remove data from remote device. Transaction is restarted if failed.
+ * Remove data from remote device. Data presence is verified before removal. Transaction is restarted if failed.
*
* @param mountpoint to access remote device
* @param iid data identifier
* @param <T> generic data type. Has to be child of {@link DataObject}
* @return true if transaction is successful, false otherwise
*/
- public synchronized static <T extends DataObject> boolean delete(final DataBroker mountpoint,
+ public static synchronized <T extends DataObject> boolean deleteIfExists(final DataBroker mountpoint,
final InstanceIdentifier<T> iid,
byte retryCounter) {
- LOG.trace("Netconf DELETE transaction started. RetryCounter: {}", retryCounter);
+ LOG.trace("Netconf DELETE transaction started. Data will be read at first. RetryCounter: {}", retryCounter);
Preconditions.checkNotNull(mountpoint);
+ final Optional<T> optionalObject = read(mountpoint, LogicalDatastoreType.CONFIGURATION, iid, RETRY_COUNT);
+ if (!optionalObject.isPresent()) {
+ LOG.warn("Netconf DELETE transaction aborted. Data to remove are not present or cannot be read. Iid: {}",
+ iid);
+ // Return true, this state is not considered as an error
+ return true;
+ }
final ReadWriteTransaction rwTx = mountpoint.newReadWriteTransaction();
try {
rwTx.delete(LogicalDatastoreType.CONFIGURATION, iid);
final CheckedFuture<Void, TransactionCommitFailedException> futureTask = rwTx.submit();
futureTask.get();
- LOG.trace("Netconf DELETE transaction done. Retry counter: {}", retryCounter);
+ LOG.trace("Netconf DELETE transaction done for {}", iid);
return true;
- } catch (IllegalStateException e) {
+ } catch (Exception e) {
// Retry
if (retryCounter > 0) {
- LOG.warn("Assuming that netconf delete-transaction failed, restarting ...", e.getMessage());
- return delete(mountpoint, iid, --retryCounter);
+ LOG.warn("Netconf DELETE transaction failed to {}. Restarting transaction ... ", e.getMessage());
+ return deleteIfExists(mountpoint, iid, --retryCounter);
} else {
- LOG.warn("Netconf delete-transaction failed. Maximal number of attempts reached", e.getMessage());
+ LOG.warn("Netconf DELETE transaction unsuccessful. Maximal number of attempts reached. Trace: {}", e);
return false;
}
- } catch (Exception e) {
- LOG.warn("Exception while removing data ...", e.getMessage());
- return false;
}
}
-
-}
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 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.renderer.vpp;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.RendererResolvedPolicy;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.ResolvedRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
+
+/**
+ * It's important not to lose any resolved rule when caching policy.
+ */
+public class RendererResolvedPolicyTest {
+
+ private ResolvedRuleGroup resolvedRuleGroup1;
+ private ResolvedRuleGroup resolvedRuleGroup2;
+ private RendererResolvedPolicy rendResPolicy1;
+ private RendererResolvedPolicy rendResPolicy2;
+ private Set<RendererResolvedPolicy> testSet;
+
+ @Before
+ public void init() {
+ resolvedRuleGroup1 = Mockito.mock(ResolvedRuleGroup.class);
+ resolvedRuleGroup2 = Mockito.mock(ResolvedRuleGroup.class);
+ }
+
+ @Test
+ public void testCompareTo_sameParticipation() {
+ rendResPolicy1 = new RendererResolvedPolicy(EndpointPolicyParticipation.PROVIDER, resolvedRuleGroup1);
+ rendResPolicy2 = new RendererResolvedPolicy(EndpointPolicyParticipation.PROVIDER, resolvedRuleGroup1);
+ testSet = createSet(rendResPolicy1, rendResPolicy2);
+ Assert.assertEquals(testSet.size(), 1);
+ rendResPolicy2 = new RendererResolvedPolicy(EndpointPolicyParticipation.PROVIDER, resolvedRuleGroup2);
+ testSet = createSet(rendResPolicy1, rendResPolicy2);
+ Assert.assertEquals(testSet.size(), 2);
+ }
+
+ @Test
+ public void testCompareTo_differentParticipation() {
+ rendResPolicy1 = new RendererResolvedPolicy(EndpointPolicyParticipation.PROVIDER, resolvedRuleGroup1);
+ rendResPolicy2 = new RendererResolvedPolicy(EndpointPolicyParticipation.CONSUMER, resolvedRuleGroup1);
+ testSet = createSet(rendResPolicy1, rendResPolicy2);
+ Assert.assertEquals(testSet.size(), 2);
+ rendResPolicy2 = new RendererResolvedPolicy(EndpointPolicyParticipation.PROVIDER, resolvedRuleGroup2);
+ testSet = createSet(rendResPolicy1, rendResPolicy2);
+ Assert.assertEquals(testSet.size(), 2);
+ }
+
+ private Set<RendererResolvedPolicy> createSet(RendererResolvedPolicy... rendResolvedPolicies) {
+ Set<RendererResolvedPolicy> policies = new TreeSet<>();
+ Collections.addAll(policies, rendResolvedPolicies);
+ return policies;
+ }
+}
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.LoopbackCommand;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
public class GbpNetconfTransactionTest {
+ private final String INTERFACE_KEY = "interface-key";
+ private final String NODE_ID = "node-id";
private final DataBroker dataBroker = mock(DataBroker.class);
private final ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
private final ReadOnlyTransaction rTx = mock(ReadOnlyTransaction.class);
private final CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
@SuppressWarnings("unchecked")
private final CheckedFuture<Optional<Node>, ReadFailedException> futureNode = mock(CheckedFuture.class);
- private final ConfigCommand command = mock(ConfigCommand.class);
+ @SuppressWarnings("unchecked")
+ private final CheckedFuture<Optional<Interface>, ReadFailedException> futureInterface = mock(CheckedFuture.class);
+ private final ConfigCommand command = mock(LoopbackCommand.class);
+ private final InterfaceBuilder interfaceBuilder = new InterfaceBuilder().setKey(new InterfaceKey(INTERFACE_KEY));
- @Test
- public void writeConfigCommandExceptionTest() {
+ @Before
+ public void init() {
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
- doThrow(new RuntimeException()).when(command).execute(rwTx);
-
- final boolean result = GbpNetconfTransaction.write(dataBroker, command, (byte)5);
- verify(dataBroker, times(1)).newReadWriteTransaction();
- assertFalse(result);
-
}
@Test
public void writeConfigCommandReattemptTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
doThrow(new IllegalStateException()).when(command).execute(rwTx);
final boolean result = GbpNetconfTransaction.write(dataBroker, command, (byte)5);
@Test
public void writeConfigCommandTest() throws Exception {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
when(rwTx.submit()).thenReturn(future);
doNothing().when(command).execute(rwTx);
when(future.get()).thenReturn(null);
assertTrue(result);
}
- @Test
- public void writeDataExceptionTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
- doThrow(new RuntimeException()).when(rwTx).put(LogicalDatastoreType.CONFIGURATION, nodeIid, node, true);
-
- final boolean result = GbpNetconfTransaction.write(dataBroker, nodeIid, node, (byte)5);
- verify(dataBroker, times(1)).newReadWriteTransaction();
- assertFalse(result);
- }
-
@Test
public void writeDataReattemptTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
doThrow(new IllegalStateException()).when(rwTx).put(LogicalDatastoreType.CONFIGURATION, nodeIid, node, true);
final boolean result = GbpNetconfTransaction.write(dataBroker, nodeIid, node, (byte)5);
@Test
public void writeDataTest() throws Exception {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
when(rwTx.submit()).thenReturn(future);
doNothing().when(rwTx).put(LogicalDatastoreType.CONFIGURATION, nodeIid, node, true);
when(future.get()).thenReturn(null);
assertTrue(result);
}
- @Test
- public void readDataExceptionTest() {
- when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
- doThrow(new RuntimeException()).when(rTx).read(LogicalDatastoreType.CONFIGURATION, nodeIid);
-
- final Optional<Node> result = GbpNetconfTransaction.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- nodeIid, (byte)5);
- verify(dataBroker, times(1)).newReadOnlyTransaction();
- assertFalse(result.isPresent());
- }
-
@Test
public void readDataReattemptTest() {
- when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
doThrow(new IllegalStateException()).when(rTx).read(LogicalDatastoreType.CONFIGURATION, nodeIid);
final Optional<Node> result = GbpNetconfTransaction.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
@Test
public void readDataTest() throws Exception {
- when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
when(rTx.read(LogicalDatastoreType.CONFIGURATION, nodeIid)).thenReturn(futureNode);
when(futureNode.get()).thenReturn(Optional.of(new NodeBuilder()
- .setKey(new NodeKey(new NodeId("node"))).build()));
+ .setKey(new NodeKey(new NodeId(NODE_ID))).build()));
final Optional<Node> result = GbpNetconfTransaction.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
nodeIid, (byte)5);
}
@Test
- public void deleteConfigCommandExceptionTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
- doThrow(new RuntimeException()).when(command).execute(rwTx);
+ public void deleteConfigCommandMissingDataTest() throws Exception {
+ final InstanceIdentifier<Interface> iid = VppIidFactory.getInterfaceIID(interfaceBuilder.getKey());
+ when(command.getInterfaceBuilder()).thenReturn(interfaceBuilder);
+ when(rTx.read(LogicalDatastoreType.CONFIGURATION, iid)).thenReturn(futureInterface);
+ when(futureInterface.get()).thenReturn(Optional.absent());
+ doThrow(new IllegalStateException()).when(command).execute(rwTx);
- final boolean result = GbpNetconfTransaction.delete(dataBroker, command, (byte)5);
- verify(dataBroker, times(1)).newReadWriteTransaction();
- assertFalse(result);
+ final boolean result = GbpNetconfTransaction.deleteIfExists(dataBroker, command, (byte)5);
+ verify(dataBroker, times(1)).newReadOnlyTransaction();
+ assertTrue(result);
}
@Test
- public void deleteConfigCommandReattemptTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
+ public void deleteConfigCommandReattemptTest() throws Exception {
+ final InstanceIdentifier<Interface> iid = VppIidFactory.getInterfaceIID(interfaceBuilder.getKey());
+ when(command.getInterfaceBuilder()).thenReturn(interfaceBuilder);
+ when(rTx.read(LogicalDatastoreType.CONFIGURATION, iid)).thenReturn(futureInterface);
+ when(futureInterface.get()).thenReturn(Optional.of(new InterfaceBuilder()
+ .setKey(new InterfaceKey(INTERFACE_KEY)).build()));
doThrow(new IllegalStateException()).when(command).execute(rwTx);
- final boolean result = GbpNetconfTransaction.delete(dataBroker, command, (byte)5);
+ final boolean result = GbpNetconfTransaction.deleteIfExists(dataBroker, command, (byte)5);
verify(dataBroker, times(6)).newReadWriteTransaction();
assertFalse(result);
}
@Test
public void deleteConfigCommandTest() throws Exception {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
+ final InstanceIdentifier<Interface> iid = VppIidFactory.getInterfaceIID(interfaceBuilder.getKey());
+ when(command.getInterfaceBuilder()).thenReturn(interfaceBuilder);
+ when(rTx.read(LogicalDatastoreType.CONFIGURATION, iid)).thenReturn(futureInterface);
+ when(futureInterface.get()).thenReturn(Optional.of(new InterfaceBuilder()
+ .setKey(new InterfaceKey(INTERFACE_KEY)).build()));
when(rwTx.submit()).thenReturn(future);
doNothing().when(command).execute(rwTx);
when(future.get()).thenReturn(null);
- final boolean result = GbpNetconfTransaction.delete(dataBroker, command, (byte)5);
+ final boolean result = GbpNetconfTransaction.deleteIfExists(dataBroker, command, (byte)5);
verify(dataBroker, times(1)).newReadWriteTransaction();
assertTrue(result);
}
@Test
- public void deleteDataExceptionTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
- doThrow(new RuntimeException()).when(rwTx).delete(LogicalDatastoreType.CONFIGURATION, nodeIid);
+ public void deleteDataMissingDataTest() throws Exception {
+ when(rTx.read(LogicalDatastoreType.CONFIGURATION, nodeIid)).thenReturn(futureNode);
+ when(futureNode.get()).thenReturn(Optional.absent());
+ doThrow(new IllegalStateException()).when(command).execute(rwTx);
- final boolean result = GbpNetconfTransaction.delete(dataBroker, nodeIid, (byte)5);
- verify(dataBroker, times(1)).newReadWriteTransaction();
- assertFalse(result);
+ final boolean result = GbpNetconfTransaction.deleteIfExists(dataBroker, nodeIid, (byte)5);
+ verify(dataBroker, times(1)).newReadOnlyTransaction();
+ assertTrue(result);
}
@Test
- public void deleteDataReattemptTest() {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
+ public void deleteDataReattemptTest() throws Exception {
+ when(rTx.read(LogicalDatastoreType.CONFIGURATION, nodeIid)).thenReturn(futureNode);
+ when(futureNode.get()).thenReturn(Optional.of(new NodeBuilder()
+ .setKey(new NodeKey(new NodeId(NODE_ID))).build()));
doThrow(new IllegalStateException()).when(rwTx).delete(LogicalDatastoreType.CONFIGURATION, nodeIid);
- final boolean result = GbpNetconfTransaction.delete(dataBroker, nodeIid, (byte)5);
+ final boolean result = GbpNetconfTransaction.deleteIfExists(dataBroker, nodeIid, (byte)5);
verify(dataBroker, times(6)).newReadWriteTransaction();
assertFalse(result);
}
@Test
public void deleteDataTest() throws Exception {
- when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
+ when(rTx.read(LogicalDatastoreType.CONFIGURATION, nodeIid)).thenReturn(futureNode);
+ when(futureNode.get()).thenReturn(Optional.of(new NodeBuilder()
+ .setKey(new NodeKey(new NodeId(NODE_ID))).build()));
when(rwTx.submit()).thenReturn(future);
doNothing().when(rwTx).delete(LogicalDatastoreType.CONFIGURATION, nodeIid);
when(future.get()).thenReturn(null);
- final boolean result = GbpNetconfTransaction.delete(dataBroker, nodeIid, (byte)5);
+ final boolean result = GbpNetconfTransaction.deleteIfExists(dataBroker, nodeIid, (byte)5);
verify(dataBroker, times(1)).newReadWriteTransaction();
assertTrue(result);
}
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<artifactId>powermock-api-mockito</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.network.topology.topology.node.SxpDomains;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.network.topology.topology.node.SxpDomainsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.network.topology.topology.node.sxp.domains.SxpDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.network.topology.topology.node.sxp.domains.SxpDomainBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.network.topology.topology.node.sxp.domains.SxpDomainKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.sxp.connections.fields.Connections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.sxp.connections.fields.connections.Connection;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class SxpCapableNodeListenerTest extends CustomDataBrokerTest {
private final String SXP_NODE_ID = "sxp_node";
private final String TOPOLOGY_ID = "topology";
private final String DOMAIN_ID = TOPOLOGY_ID + "/" + NODE_ID;
private final PortNumber SXP_PORT = new PortNumber(64999);
+ private static final String SXP_DOMAIN_NAME = "JUNIT_SXP_DOMAIN_NAME";
private DataBroker dataBroker;
private SxpCapableNodeListener nodeListener;
nodeListener = new SxpCapableNodeListener(dataBroker, SXP_NODE_ID);
DataTreeIdentifier<SxpConnection> iid = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class)
- .child(Node.class)
- .augmentation(SxpConnectionAugmentation.class)
- .child(SxpConnection.class)
- .build());
+ .child(Topology.class)
+ .child(Node.class)
+ .augmentation(SxpConnectionAugmentation.class)
+ .child(SxpConnection.class)
+ .build());
verify(dataBroker).registerDataTreeChangeListener(iid, nodeListener);
}
dataBroker = mock(DataBroker.class);
ListenerRegistration<SxpCapableNodeListener> registration = mock(ListenerRegistration.class);
when(dataBroker.registerDataTreeChangeListener(any(), isA(SxpCapableNodeListener.class)))
- .thenReturn(registration);
+ .thenReturn(registration);
nodeListener = new SxpCapableNodeListener(dataBroker, SXP_NODE_ID);
nodeListener.close();
verify(registration).close();
public void testOnDataTreeChange_createAndDeleteNode() throws Exception {
Node sxpNode =
new NodeBuilder().setNodeId(new NodeId(SXP_NODE_ID))
- .addAugmentation(SxpNodeIdentity.class,
- new SxpNodeIdentityBuilder().setSxpDomains(new SxpDomainsBuilder().build()).build())
- .build();
+ .addAugmentation(SxpNodeIdentity.class,
+ new SxpNodeIdentityBuilder().setSxpDomains(new SxpDomainsBuilder()
+ .setSxpDomain(Collections.singletonList(
+ new SxpDomainBuilder()
+ .setDomainName(SXP_DOMAIN_NAME)
+ .build()))
+ .build()).build())
+ .build();
InstanceIdentifier<Node> sxpNodeIid =
InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class,
- new TopologyKey(new TopologyId(IpSgtDistributionServiceImpl.SXP_TOPOLOGY_ID)))
- .child(Node.class, new NodeKey(new NodeId(SXP_NODE_ID)))
- .build();
+ .child(Topology.class,
+ new TopologyKey(new TopologyId(IpSgtDistributionServiceImpl.SXP_TOPOLOGY_ID)))
+ .child(Node.class, new NodeKey(new NodeId(SXP_NODE_ID)))
+ .build();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
wtx.put(LogicalDatastoreType.CONFIGURATION, sxpNodeIid, sxpNode, true);
Node node = new NodeBuilder().setNodeId(new NodeId(NODE_ID))
- .addAugmentation(SxpConnectionAugmentation.class, new SxpConnectionAugmentationBuilder()
- .setSxpConnection(new SxpConnectionBuilder().setIpAddress(IP_ADDR).setPassword(PASSWD).build()).build())
- .build();
+ .addAugmentation(SxpConnectionAugmentation.class, new SxpConnectionAugmentationBuilder()
+ .setSxpConnection(new SxpConnectionBuilder().setIpAddress(IP_ADDR).setPassword(PASSWD).build()).build())
+ .build();
InstanceIdentifier<Node> nodeIid = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(new TopologyId(TOPOLOGY_ID)))
- .child(Node.class, new NodeKey(new NodeId(NODE_ID)))
- .build();
+ .child(Topology.class, new TopologyKey(new TopologyId(TOPOLOGY_ID)))
+ .child(Node.class, new NodeKey(new NodeId(NODE_ID)))
+ .build();
wtx.put(LogicalDatastoreType.CONFIGURATION, nodeIid, node, true);
wtx.submit().get();
assertEquals(DOMAIN_ID, nodeListener.getDomainIdForPeer(nodeIid));
InstanceIdentifier<SxpDomain> domainIid =
InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class,
- new TopologyKey(new TopologyId(IpSgtDistributionServiceImpl.SXP_TOPOLOGY_ID)))
- .child(Node.class, new NodeKey(new NodeId(SXP_NODE_ID)))
- .augmentation(SxpNodeIdentity.class)
- .child(SxpDomains.class)
- .child(SxpDomain.class, new SxpDomainKey(DOMAIN_ID))
- .build();
+ .child(Topology.class,
+ new TopologyKey(new TopologyId(IpSgtDistributionServiceImpl.SXP_TOPOLOGY_ID)))
+ .child(Node.class, new NodeKey(new NodeId(SXP_NODE_ID)))
+ .augmentation(SxpNodeIdentity.class)
+ .child(SxpDomains.class)
+ .child(SxpDomain.class, new SxpDomainKey(DOMAIN_ID))
+ .build();
ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
CheckedFuture<Optional<SxpDomain>, ReadFailedException> read =
rtx.read(LogicalDatastoreType.CONFIGURATION, domainIid);
<modules>
<module>sxp-ep-provider</module>
<module>sxp-ise-adapter</module>
+ <module>ip-sgt-distribution-service</module>
</modules>
<dependencyManagement>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
Code Review / groupbasedpolicy.git / commitdiff