<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>testutils</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<type>test-jar</type>
<scope>test</scope>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchCtState;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceListener;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.Action;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.inject.AbstractLifecycle;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.utils.AclDataUtil;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
*/
package org.opendaylight.netvirt.aclservice;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.Action;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.MatchCriteria;
*/
package org.opendaylight.netvirt.aclservice;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchRegister;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.Action;
*/
package org.opendaylight.netvirt.aclservice.listeners;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.Action;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.slf4j.LoggerFactory;
@Singleton
-public class AclElanInterfaceListener extends AsyncDataTreeChangeListenerBase<ElanInterface, AclElanInterfaceListener>
+public class AclElanInterfaceListener extends AbstractAsyncDataTreeChangeListener<ElanInterface>
implements ClusteredDataTreeChangeListener<ElanInterface>, RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(AclElanInterfaceListener.class);
public AclElanInterfaceListener(AclServiceManager aclServiceManager, AclClusterUtil aclClusterUtil,
DataBroker dataBroker, AclInterfaceCache aclInterfaceCache,
ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(ElanInterface.class, AclElanInterfaceListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(ElanInterfaces.class).child(ElanInterface.class),
+ Executors.newListeningSingleThreadExecutor("AclElanInterfaceListener", LOG));
this.aclServiceManager = aclServiceManager;
this.aclClusterUtil = aclClusterUtil;
this.dataBroker = dataBroker;
serviceRecoveryRegistry.addRecoverableListener(AclServiceUtils.getRecoverServiceRegistryKey(), this);
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener();
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<ElanInterface> getWildCardPath() {
- return InstanceIdentifier.create(ElanInterfaces.class).child(ElanInterface.class);
+ public void deregisterListener() {
+ super.close();
}
@Override
- protected void remove(InstanceIdentifier<ElanInterface> key, ElanInterface dataObjectModification) {
+ public void remove(InstanceIdentifier<ElanInterface> key, ElanInterface dataObjectModification) {
// do nothing
}
@Override
- protected void update(InstanceIdentifier<ElanInterface> key, ElanInterface dataObjectModificationBefore,
+ public void update(InstanceIdentifier<ElanInterface> key, ElanInterface dataObjectModificationBefore,
ElanInterface dataObjectModificationAfter) {
// do nothing
}
@Override
- protected void add(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
+ public void add(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
String interfaceId = elanInterface.getName();
AclInterface aclInterface = aclInterfaceCache.updateIfPresent(interfaceId, (prevAclInterface, builder) -> {
if (prevAclInterface.getElanId() == null) {
}
@Override
- protected AclElanInterfaceListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
import java.util.Objects;
import java.util.Set;
import java.util.SortedSet;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager;
import org.opendaylight.netvirt.aclservice.api.utils.AclInterface;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.Ace;
import org.slf4j.LoggerFactory;
@Singleton
-public class AclEventListener extends AsyncDataTreeChangeListenerBase<Acl, AclEventListener> implements
+public class AclEventListener extends AbstractAsyncDataTreeChangeListener<Acl> implements
ClusteredDataTreeChangeListener<Acl>, RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(AclEventListener.class);
public AclEventListener(AclServiceManager aclServiceManager, AclClusterUtil aclClusterUtil, DataBroker dataBroker,
AclDataUtil aclDataUtil, AclServiceUtils aclServicUtils, AclInterfaceCache aclInterfaceCache,
ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(Acl.class, AclEventListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(AccessLists.class).child(Acl.class),
+ Executors.newListeningSingleThreadExecutor("AclEventListener", LOG));
this.aclServiceManager = aclServiceManager;
this.aclClusterUtil = aclClusterUtil;
this.dataBroker = dataBroker;
serviceRecoveryRegistry.addRecoverableListener(AclServiceUtils.getRecoverServiceRegistryKey(), this);
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener();
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<Acl> getWildCardPath() {
- return InstanceIdentifier.create(AccessLists.class).child(Acl.class);
+ public void deregisterListener() {
+ super.close();
}
@Override
- p
rotected void remove(InstanceIdentifier<Acl> key, Acl acl) {
+ p
ublic void remove(InstanceIdentifier<Acl> key, Acl acl) {
LOG.trace("On remove event, remove ACL: {}", acl);
String aclName = acl.getAclName();
this.aclDataUtil.removeAcl(aclName);
}
@Override
- p
rotected void update(InstanceIdentifier<Acl> key, Acl aclBefore, Acl aclAfter) {
+ p
ublic void update(InstanceIdentifier<Acl> key, Acl aclBefore, Acl aclAfter) {
String aclName = aclAfter.getAclName();
Collection<AclInterface> interfacesBefore =
ImmutableSet.copyOf(aclDataUtil.getInterfaceList(new Uuid(aclName)));
}
@Override
- p
rotected void add(InstanceIdentifier<Acl> key, Acl acl) {
+ p
ublic void add(InstanceIdentifier<Acl> key, Acl acl) {
LOG.trace("On add event, add ACL: {}", acl);
this.aclDataUtil.addAcl(acl);
}
}
- @Override
- protected AclEventListener getDataTreeChangeListener() {
- return this;
- }
-
private static @NonNull List<Ace> getChangedAceList(Acl updatedAcl, Acl currentAcl) {
if (updatedAcl == null) {
return Collections.emptyList();
}
return deletedAceList;
}
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
}
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.Action;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
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.yang.types.rev130715.Uuid;
import org.slf4j.LoggerFactory;
@Singleton
-public class AclInterfaceListener extends AsyncDataTreeChangeListenerBase<Interface, AclInterfaceListener>
+public class AclInterfaceListener extends AbstractAsyncDataTreeChangeListener<Interface>
implements ClusteredDataTreeChangeListener<Interface>, RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(AclInterfaceListener.class);
public AclInterfaceListener(AclServiceManager aclServiceManager, AclClusterUtil aclClusterUtil,
DataBroker dataBroker, AclDataUtil aclDataUtil, AclInterfaceCache aclInterfaceCache,
AclServiceUtils aclServicUtils, ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(Interface.class, AclInterfaceListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Interfaces.class).child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("AclEventListener", LOG));
this.aclServiceManager = aclServiceManager;
this.aclClusterUtil = aclClusterUtil;
this.dataBroker = dataBroker;
serviceRecoveryRegistry.addRecoverableListener(AclServiceUtils.getRecoverServiceRegistryKey(), this);
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener();
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
+ public void deregisterListener() {
+ super.close();
}
@Override
}
@Override
- protected AclInterfaceListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
import java.util.Collections;
import java.util.List;
import java.util.SortedSet;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.Action;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.slf4j.LoggerFactory;
@Singleton
-public class AclInterfaceStateListener extends AsyncDataTreeChangeListenerBase<Interface,
- AclInterfaceStateListener> implements ClusteredDataTreeChangeListener<Interface>, RecoverableListener {
+public class AclInterfaceStateListener extends AbstractAsyncDataTreeChangeListener<Interface>
+ implements ClusteredDataTreeChangeListener<Interface>, RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(AclInterfaceStateListener.class);
DataBroker dataBroker, AclDataUtil aclDataUtil, IInterfaceManager interfaceManager,
AclInterfaceCache aclInterfaceCache, AclServiceUtils aclServicUtils, JobCoordinator jobCoordinator,
ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(Interface.class, AclInterfaceStateListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(InterfacesState.class).child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("AclInterfaceStateListener", LOG));
this.aclServiceManger = aclServiceManger;
this.aclClusterUtil = aclClusterUtil;
this.dataBroker = dataBroker;
serviceRecoveryRegistry.addRecoverableListener(AclServiceUtils.getRecoverServiceRegistryKey(), this);
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener();
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
+ public void deregisterListener() {
+ super.close();
}
@Override
- protected void remove(InstanceIdentifier<Interface> key, Interface deleted) {
+ public void remove(InstanceIdentifier<Interface> key, Interface deleted) {
if (!L2vlan.class.equals(deleted.getType())) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<Interface> key, Interface before, Interface after) {
+ public void update(InstanceIdentifier<Interface> key, Interface before, Interface after) {
/*
* The update is not of interest as the attributes populated from this listener will not change.
* The northbound updates are handled in AclInterfaceListener.
}
@Override
- protected void add(InstanceIdentifier<Interface> key, Interface added) {
+ public void add(InstanceIdentifier<Interface> key, Interface added) {
if (!L2vlan.class.equals(added.getType())) {
return;
}
}
@Override
- protected AclInterfaceStateListener getDataTreeChangeListener() {
- return AclInterfaceStateListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.utils.AclConstants;
import org.opendaylight.netvirt.aclservice.utils.AclNodeDefaultFlowsTxBuilder;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
* during when node is discovered.
*/
@Singleton
-public class AclNodeListener extends AsyncDataTreeChangeListenerBase<FlowCapableNode, AclNodeListener>
+public class AclNodeListener extends AbstractAsyncDataTreeChangeListener<FlowCapableNode>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(AclNodeListener.class);
public AclNodeListener(final IMdsalApiManager mdsalManager, DataBroker dataBroker, AclserviceConfig config,
AclServiceUtils aclServiceUtils, JobCoordinator jobCoordinator,
ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(FlowCapableNode.class, AclNodeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class),
+ Executors.newListeningSingleThreadExecutor("AclNodeListener", LOG));
this.mdsalManager = mdsalManager;
this.dataBroker = dataBroker;
this.aclServiceUtils = aclServiceUtils;
this.jobCoordinator = jobCoordinator;
serviceRecoveryRegistry.addRecoverableListener(AclServiceUtils.getRecoverServiceRegistryKey(), this);
+ init();
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} start", getClass().getSimpleName());
if (config != null) {
this.securityGroupMode = config.getSecurityGroupMode();
}
- registerListener();
LOG.info("AclserviceConfig: {}", this.config);
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<FlowCapableNode> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class);
+ public void deregisterListener() {
+ super.close();
}
@Override
- protected void remove(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
+ public void remove(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
// do nothing
}
@Override
- protected void update(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModificationBefore,
+ public void update(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModificationBefore,
FlowCapableNode dataObjectModificationAfter) {
// do nothing
}
@Override
- protected void add(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
+ public void add(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
NodeKey nodeKey = key.firstKeyOf(Node.class);
Uint64 dpId = MDSALUtil.getDpnIdFromNodeName(nodeKey.getId());
LOG.info("Received ACL node [{}] add event", dpId);
}
@Override
- protected AclNodeListener getDataTreeChangeListener() {
- return AclNodeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
*/
package org.opendaylight.netvirt.aclservice.recovery;
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.api.utils.AclInterface;
import org.opendaylight.netvirt.aclservice.listeners.AclInterfaceListener;
import org.opendaylight.netvirt.aclservice.utils.AclDataUtil;
*/
package org.opendaylight.netvirt.aclservice.recovery;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.listeners.AclInterfaceListener;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.aclservice.utils.AclConstants;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.OpendaylightDirectStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.AclLiveStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.acl.live.statistics.rev161129.Direction;
package org.opendaylight.netvirt.aclservice.utils;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchRegister;
import org.opendaylight.genius.mdsalutil.packet.IPProtocols;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.api.AclServiceManager.MatchCriteria;
import org.opendaylight.netvirt.aclservice.api.utils.AclInterface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
*/
public static <T extends DataObject> Optional<T> read(
DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
- return tx.read(datastoreType, path).checkedGet();
- } catch (ReadFailedException e) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
+ return tx.read(datastoreType, path).get();
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read InstanceIdentifier {} from {}", path, datastoreType, e);
- return Optional.absent();
+ return Optional.empty();
}
}
.@Nullable Interface getInterfaceStateFromOperDS(DataBroker dataBroker, String interfaceName) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
.interfaces.state.Interface> ifStateId = buildStateInterfaceId(interfaceName);
- return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker).orNull();
+ return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker).orElse(null);
}
/**
@Nullable
public static ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName,DataBroker broker) {
InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
- return read(broker, LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
+ return read(broker, LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orElse(null);
}
public static InstanceIdentifier<ElanInterface> getElanInterfaceConfigurationDataPathId(String interfaceName) {
@Nullable
public static ElanInstance getElanInstanceByName(String elanInstanceName, DataBroker broker) {
InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
- return read(broker, LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
+ return read(broker, LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orElse(null);
}
public static InstanceIdentifier<ElanInstance> getElanInstanceConfigurationDataPath(String elanInstanceName) {
@Nullable
private AclPortsByIp getAclPortsByIpFromOperDs(String aclName) {
InstanceIdentifier<AclPortsByIp> path = aclPortsByIpPath(aclName);
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
- return tx.read(LogicalDatastoreType.OPERATIONAL, path).checkedGet().orNull();
- } catch (ReadFailedException e) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ return tx.read(LogicalDatastoreType.OPERATIONAL, path).get().orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read ACL ports {}", path, e);
return null;
}
@Nullable
private AclIpPrefixes getAclIpPrefixesFromOperDs(String aclName, IpPrefixOrAddress ipPrefix) {
InstanceIdentifier<AclIpPrefixes> path = getAclIpPrefixesPath(aclName, ipPrefix);
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
- return tx.read(LogicalDatastoreType.OPERATIONAL, path).checkedGet().orNull();
- } catch (ReadFailedException e) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ return tx.read(LogicalDatastoreType.OPERATIONAL, path).get().orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read ACL IP prefixes {}", path, e);
return null;
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="iMdsalApiManager"
interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
<reference id="entityOwnershipService"
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import static org.opendaylight.netvirt.aclservice.tests.StateInterfaceBuilderHelper.putNewStateInterface;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Future;
import javax.inject.Inject;
-
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
import org.opendaylight.genius.datastoreutils.testutils.TestableDataTreeChangeListenerModule;
import org.opendaylight.genius.testutils.TestInterfaceManager;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.aclservice.tests.AclServiceModule;
import org.opendaylight.netvirt.aclservice.tests.AclServiceTestModule;
import org.opendaylight.netvirt.aclservice.tests.IdentifiedInterfaceWithAclBuilder;
*/
package org.opendaylight.netvirt.aclservice.tests;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import static org.opendaylight.netvirt.aclservice.tests.StateInterfaceBuilderHelper.putNewStateInterface;
import java.math.BigInteger;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
import org.opendaylight.genius.testutils.TestInterfaceManager;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.aclservice.tests.infra.DataBrokerPairsUtil;
import org.opendaylight.netvirt.aclservice.utils.AclConstants;
import org.opendaylight.netvirt.aclservice.utils.AclServiceUtils;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
import com.google.inject.AbstractModule;
+import java.util.concurrent.Executors;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.TestableJobCoordinatorEventsWaiter;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.interfaces.testutils.TestIMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.netvirt.aclservice.AclInterfaceCacheImpl;
import org.opendaylight.netvirt.aclservice.api.AclInterfaceCache;
import org.opendaylight.netvirt.aclservice.stats.TestOdlDirectStatisticsService;
this.securityGroupMode = securityGroupMode;
}
+ @SuppressWarnings("checkstyle:IllegalCatch")
@Override
protected void configure() {
- bind(DataBroker.class).toInstance(DataBrokerTestModule.dataBroker());
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ try {
+ test.setup();
+ } catch (Exception e) {
+ LOG.trace("Exception", e.getMessage());
+ }
+ bind(DataBroker.class).toInstance(test.getDataBroker());
bind(AclserviceConfig.class).toInstance(aclServiceConfig());
bind(AclDataUtil.class).toInstance(aclDataUtil());
bind(AclClusterUtil.class).toInstance(() -> true);
*/
package org.opendaylight.netvirt.aclservice.tests;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import java.util.Optional;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.tests.infra.DataTreeIdentifierDataObjectPairBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.Ipv4Acl;
*/
package org.opendaylight.netvirt.aclservice.tests;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.aclservice.tests.infra.DataTreeIdentifierDataObjectPairBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
package org.opendaylight.netvirt.aclservice.tests;
import static java.util.Collections.singletonList;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import javax.inject.Inject;
import org.eclipse.xtext.xbase.lib.Pair;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package org.opendaylight.netvirt.aclservice.tests.infra;
import org.eclipse.xtext.xbase.lib.Pair;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
default Pair<DataTreeIdentifier<T>, T> build() {
- return Pair.of(new DataTreeIdentifier<>(type(), identifier()), dataObject());
+ return Pair.of(DataTreeIdentifier.create(type(), identifier()), dataObject());
}
}
<artifactId>vpnmanager-api</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<type>test-jar</type>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
</dependency>
<dependency>
<groupId>org.apache.karaf.shell</groupId>
import static org.opendaylight.netvirt.bgpmanager.oam.BgpConstants.HISTORY_LIMIT;
import static org.opendaylight.netvirt.bgpmanager.oam.BgpConstants.HISTORY_THRESHOLD;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.Futures;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Timer;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransport;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.metrics.MetricProvider;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.IVpnLinkService;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionHistory;
import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebfd.rev190219.BfdConfig;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebfd.rev190219.BfdConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.AddressFamily;
for (Class<?> reactor : REACTORS) {
Object obj = createListener(reactor);
if (obj != null) {
- AsyncDataTreeChangeListenerBase dcl = (AsyncDataTreeChangeListenerBase) obj;
- dcl.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ AbstractAsyncDataTreeChangeListener dcl = (AbstractAsyncDataTreeChangeListener) obj;
+ dcl.register();
listeners.add(dcl);
}
}
}
public class ConfigServerReactor
- extends AsyncDataTreeChangeListenerBase<ConfigServer, ConfigServerReactor>
+ extends AbstractAsyncDataTreeChangeListener<ConfigServer>
implements ClusteredDataTreeChangeListener<ConfigServer> {
private static final String YANG_OBJ = "config-server ";
public ConfigServerReactor() {
- super(ConfigServer.class, ConfigServerReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(ConfigServer.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("ConfigServerReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<ConfigServer> iid, ConfigServer val) {
+ public void add(InstanceIdentifier<ConfigServer> iid, ConfigServer val) {
LOG.trace("received bgp connect config host {}", val.getHost().getValue());
if (!isBGPEntityOwner()) {
return;
}
@Override
- protected ConfigServerReactor getDataTreeChangeListener() {
- return ConfigServerReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<ConfigServer> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(ConfigServer.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<ConfigServer> iid, ConfigServer val) {
+ public void remove(InstanceIdentifier<ConfigServer> iid, ConfigServer val) {
LOG.trace("received bgp disconnect");
if (!isBGPEntityOwner()) {
return;
}
@Override
- protected void update(InstanceIdentifier<ConfigServer> iid,
+ public void update(InstanceIdentifier<ConfigServer> iid,
ConfigServer oldval, ConfigServer newval) {
LOG.trace("received bgp Connection update");
if (!isBGPEntityOwner()) {
return bgpRouter;
}
- public class AsIdReactor
- extends AsyncDataTreeChangeListenerBase<AsId, AsIdReactor>
+ public class AsIdReactor extends AbstractAsyncDataTreeChangeListener<AsId>
implements ClusteredDataTreeChangeListener<AsId> {
private static final String YANG_OBJ = "as-id ";
public AsIdReactor() {
- super(AsId.class, AsIdReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(AsId.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("AsIdReactor", LOG));
}
+ @SuppressFBWarnings(value = "ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
@Override
- p
rotected void add(InstanceIdentifier<AsId> iid, AsId val) {
+ p
ublic void add(InstanceIdentifier<AsId> iid, AsId val) {
LOG.error("received bgp add asid {}", val);
if (!isBGPEntityOwner()) {
return;
}
@Override
- protected AsIdReactor getDataTreeChangeListener() {
- return AsIdReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<AsId> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(AsId.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<AsId> iid, AsId val) {
+ public void remove(InstanceIdentifier<AsId> iid, AsId val) {
LOG.error("received delete router config asNum {}", val.getLocalAs());
if (!isBGPEntityOwner()) {
return;
}
@Override
- p
rotected void update(InstanceIdentifier<AsId> iid,
+ p
ublic void update(InstanceIdentifier<AsId> iid,
AsId oldval, AsId newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class GracefulRestartReactor
- extends AsyncDataTreeChangeListenerBase<GracefulRestart, GracefulRestartReactor>
+ public class GracefulRestartReactor extends AbstractAsyncDataTreeChangeListener<GracefulRestart>
implements ClusteredDataTreeChangeListener<GracefulRestart> {
private static final String YANG_OBJ = "graceful-restart ";
public GracefulRestartReactor() {
- super(GracefulRestart.class, GracefulRestartReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(GracefulRestart.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("GracefulRestartReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<GracefulRestart> iid, GracefulRestart val) {
+ public void add(InstanceIdentifier<GracefulRestart> iid, GracefulRestart val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected GracefulRestartReactor getDataTreeChangeListener() {
- return GracefulRestartReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<GracefulRestart> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(GracefulRestart.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<GracefulRestart> iid, GracefulRestart val) {
+ public void remove(InstanceIdentifier<GracefulRestart> iid, GracefulRestart val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<GracefulRestart> iid,
+ public void update(InstanceIdentifier<GracefulRestart> iid,
GracefulRestart oldval, GracefulRestart newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class LoggingReactor
- extends AsyncDataTreeChangeListenerBase<Logging, LoggingReactor>
+ public class LoggingReactor extends AbstractAsyncDataTreeChangeListener<Logging>
implements ClusteredDataTreeChangeListener<Logging> {
private static final String YANG_OBJ = "logging ";
public LoggingReactor() {
- super(Logging.class, LoggingReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(Logging.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("LoggingReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<Logging> iid, Logging val) {
+ public void add(InstanceIdentifier<Logging> iid, Logging val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected LoggingReactor getDataTreeChangeListener() {
- return LoggingReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<Logging> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(Logging.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Logging> iid, Logging val) {
+ public void remove(InstanceIdentifier<Logging> iid, Logging val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<Logging> iid,
+ public void update(InstanceIdentifier<Logging> iid,
Logging oldval, Logging newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class NeighborsReactor
- extends AsyncDataTreeChangeListenerBase<Neighbors, NeighborsReactor>
+ public class NeighborsReactor extends AbstractAsyncDataTreeChangeListener<Neighbors>
implements ClusteredDataTreeChangeListener<Neighbors> {
private static final String YANG_OBJ = "neighbors ";
public NeighborsReactor() {
- super(Neighbors.class, NeighborsReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("NeighborsReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<Neighbors> iid, Neighbors val) {
+ public void add(InstanceIdentifier<Neighbors> iid, Neighbors val) {
if (nbrList != null && !nbrList.contains(val)) {
LOG.trace("Adding nbr {} to nbrlist", val.getAddress().getValue());
nbrList.add(val);
}
@Override
- protected NeighborsReactor getDataTreeChangeListener() {
- return NeighborsReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<Neighbors> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Neighbors> iid, Neighbors val) {
+ public void remove(InstanceIdentifier<Neighbors> iid, Neighbors val) {
if (nbrList != null && nbrList.contains(val)) {
LOG.trace("Removing nbr {} from nbr list", val.getAddress().getValue());
nbrList.remove(val);
}
@Override
- protected void update(InstanceIdentifier<Neighbors> iid,
+ public void update(InstanceIdentifier<Neighbors> iid,
Neighbors oldval, Neighbors newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class EbgpMultihopReactor
- extends AsyncDataTreeChangeListenerBase<EbgpMultihop, EbgpMultihopReactor>
+ public class EbgpMultihopReactor extends AbstractAsyncDataTreeChangeListener<EbgpMultihop>
implements ClusteredDataTreeChangeListener<EbgpMultihop> {
private static final String YANG_OBJ = "ebgp-multihop ";
public EbgpMultihopReactor() {
- super(EbgpMultihop.class, EbgpMultihopReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class)
+ .child(EbgpMultihop.class), org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("EbgpMultihopReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<EbgpMultihop> iid, EbgpMultihop val) {
+ public void add(InstanceIdentifier<EbgpMultihop> iid, EbgpMultihop val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected EbgpMultihopReactor getDataTreeChangeListener() {
- return EbgpMultihopReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<EbgpMultihop> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class)
- .child(EbgpMultihop.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<EbgpMultihop> iid, EbgpMultihop val) {
+ public void remove(InstanceIdentifier<EbgpMultihop> iid, EbgpMultihop val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<EbgpMultihop> iid,
+ public void update(InstanceIdentifier<EbgpMultihop> iid,
EbgpMultihop oldval, EbgpMultihop newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class UpdateSourceReactor
- extends AsyncDataTreeChangeListenerBase<UpdateSource, UpdateSourceReactor>
+ public class UpdateSourceReactor extends AbstractAsyncDataTreeChangeListener<UpdateSource>
implements ClusteredDataTreeChangeListener<UpdateSource> {
private static final String YANG_OBJ = "update-source ";
public UpdateSourceReactor() {
- super(UpdateSource.class, UpdateSourceReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class)
+ .child(UpdateSource.class), org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("UpdateSourceReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<UpdateSource> iid, UpdateSource val) {
+ public void add(InstanceIdentifier<UpdateSource> iid, UpdateSource val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected UpdateSourceReactor getDataTreeChangeListener() {
- return UpdateSourceReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<UpdateSource> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class)
- .child(UpdateSource.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<UpdateSource> iid, UpdateSource val) {
+ public void remove(InstanceIdentifier<UpdateSource> iid, UpdateSource val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<UpdateSource> iid,
+ public void update(InstanceIdentifier<UpdateSource> iid,
UpdateSource oldval, UpdateSource newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class AddressFamiliesReactor
- extends AsyncDataTreeChangeListenerBase<AddressFamilies, AddressFamiliesReactor>
+ public class AddressFamiliesReactor extends AbstractAsyncDataTreeChangeListener<AddressFamilies>
implements ClusteredDataTreeChangeListener<AddressFamilies> {
private static final String YANG_OBJ = "address-families ";
public AddressFamiliesReactor() {
- super(AddressFamilies.class, AddressFamiliesReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class)
+ .child(AddressFamilies.class), org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("AddressFamiliesReactor", LOG));
}
@Override
- p
rotected void add(InstanceIdentifier<AddressFamilies> iid, AddressFamilies val) {
+ p
ublic void add(InstanceIdentifier<AddressFamilies> iid, AddressFamilies val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected AddressFamiliesReactor getDataTreeChangeListener() {
- return AddressFamiliesReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<AddressFamilies> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(NeighborsContainer.class).child(Neighbors.class)
- .child(AddressFamilies.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<AddressFamilies> iid, AddressFamilies val) {
+ public void remove(InstanceIdentifier<AddressFamilies> iid, AddressFamilies val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- p
rotected void update(InstanceIdentifier<AddressFamilies> iid,
+ p
ublic void update(InstanceIdentifier<AddressFamilies> iid,
AddressFamilies oldval, AddressFamilies newval) {
if (!isBGPEntityOwner()) {
return;
}
}
- public class NetworksReactor
- extends AsyncDataTreeChangeListenerBase<Networks, NetworksReactor>
+ public class NetworksReactor extends AbstractAsyncDataTreeChangeListener<Networks>
implements ClusteredDataTreeChangeListener<Networks> {
private static final String YANG_OBJ = "networks ";
public NetworksReactor() {
- super(Networks.class, NetworksReactor.class);
- }
-
- @Override
- public NetworksReactor getDataTreeChangeListener() {
- return NetworksReactor.this;
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(NetworksContainer.class).child(Networks.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("NetworksReactor", LOG));
}
- @Override
- protected void add(InstanceIdentifier<Networks> iid, Networks val) {
+ public void add(InstanceIdentifier<Networks> iid, Networks val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected InstanceIdentifier<Networks> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(NetworksContainer.class).child(Networks.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Networks> iid, Networks val) {
+ public void remove(InstanceIdentifier<Networks> iid, Networks val) {
if (!isBGPEntityOwner()) {
return;
}
@Override
- protected void update(final InstanceIdentifier<Networks> iid,
+ public void update(final InstanceIdentifier<Networks> iid,
final Networks oldval, final Networks newval) {
if (!isBGPEntityOwner()) {
return;
static Timer timer = new Timer();
- public class VrfsReactor
- extends AsyncDataTreeChangeListenerBase<Vrfs, VrfsReactor>
+ public class VrfsReactor extends AbstractAsyncDataTreeChangeListener<Vrfs>
implements ClusteredDataTreeChangeListener<Vrfs> {
private static final String YANG_OBJ = "vrfs ";
public VrfsReactor() {
- super(Vrfs.class, VrfsReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(VrfsContainer.class).child(Vrfs.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("VrfsReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<Vrfs> iid, Vrfs vrfs) {
+ public void add(InstanceIdentifier<Vrfs> iid, Vrfs vrfs) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected VrfsReactor getDataTreeChangeListener() {
- return VrfsReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<Vrfs> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(VrfsContainer.class).child(Vrfs.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Vrfs> iid, Vrfs val) {
+ public void remove(InstanceIdentifier<Vrfs> iid, Vrfs val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<Vrfs> iid,
+ public void update(InstanceIdentifier<Vrfs> iid,
Vrfs oldval, Vrfs newval) {
if (oldval != null && newval != null) {
LOG.debug("received update Vrfs config val {}, VRFS: Update getting triggered for VRFS rd {}",
}
}
- public class BgpReactor
- extends AsyncDataTreeChangeListenerBase<Bgp, BgpReactor>
+ public class BgpReactor extends AbstractAsyncDataTreeChangeListener<Bgp>
implements ClusteredDataTreeChangeListener<Bgp> {
private static final String YANG_OBJ = "Bgp ";
public BgpReactor() {
- super(Bgp.class, BgpReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Bgp.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("BgpReactor", LOG));
}
-
@Override
- protected void add(InstanceIdentifier<Bgp> iid, Bgp val) {
+ public void add(InstanceIdentifier<Bgp> iid, Bgp val) {
LOG.debug("received add Bgp config");
try {
}
@Override
- protected BgpReactor getDataTreeChangeListener() {
- return BgpReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<Bgp> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Bgp> iid, Bgp val) {
+ public void remove(InstanceIdentifier<Bgp> iid, Bgp val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<Bgp> iid,
+ public void update(InstanceIdentifier<Bgp> iid,
Bgp oldval, Bgp newval) {
if (!isBGPEntityOwner()) {
return;
}
@SuppressWarnings("deprecation")
- public class MultipathReactor
- extends AsyncDataTreeChangeListenerBase<Multipath, MultipathReactor>
+ public class MultipathReactor extends AbstractAsyncDataTreeChangeListener<Multipath>
implements ClusteredDataTreeChangeListener<Multipath> {
private static final String YANG_OBJ = "multipath ";
public MultipathReactor() {
- super(Multipath.class, MultipathReactor.class);
- }
-
-
- @Override
- protected MultipathReactor getDataTreeChangeListener() {
- return MultipathReactor.this;
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Bgp.class)
+ .child(MultipathContainer.class).child(Multipath.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("MultipathReactor", LOG));
}
@Override
- protected InstanceIdentifier<Multipath> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(MultipathContainer.class).child(Multipath.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Multipath> iid, Multipath val) {
+ public void remove(InstanceIdentifier<Multipath> iid, Multipath val) {
executor.execute(new MultipathStatusChange(val));
}
@Override
- protected void update(InstanceIdentifier<Multipath> iid, Multipath oldval, Multipath newval) {
+ public void update(InstanceIdentifier<Multipath> iid, Multipath oldval, Multipath newval) {
executor.execute(new MultipathStatusChange(newval));
}
@Override
- protected void add(InstanceIdentifier<Multipath> key, Multipath dataObjectModification) {
+ public void add(InstanceIdentifier<Multipath> key, Multipath dataObjectModification) {
executor.execute(new MultipathStatusChange(dataObjectModification));
}
}
@SuppressWarnings("deprecation")
- public class VrfMaxpathReactor
- extends AsyncDataTreeChangeListenerBase<VrfMaxpath, VrfMaxpathReactor>
+ public class VrfMaxpathReactor extends AbstractAsyncDataTreeChangeListener<VrfMaxpath>
implements ClusteredDataTreeChangeListener<VrfMaxpath> {
private static final String YANG_OBJ = "vrfMaxpath ";
public VrfMaxpathReactor() {
- super(VrfMaxpath.class, VrfMaxpathReactor.class);
- }
-
-
- @Override
- protected VrfMaxpathReactor getDataTreeChangeListener() {
- return VrfMaxpathReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<VrfMaxpath> getWildCardPath() {
- return InstanceIdentifier.create(Bgp.class).child(VrfMaxpathContainer.class).child(VrfMaxpath.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Bgp.class).child(VrfMaxpathContainer.class).child(VrfMaxpath.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("VrfMaxpathReactor", LOG));
}
class VrfMaxPathConfigurator implements Runnable {
}
@Override
- protected void remove(InstanceIdentifier<VrfMaxpath> iid, VrfMaxpath vrfMaxPathVal) {
+ public void remove(InstanceIdentifier<VrfMaxpath> iid, VrfMaxpath vrfMaxPathVal) {
if (isBGPEntityOwner()) {
synchronized (BgpConfigurationManager.this) {
BgpRouter br = getClient(YANG_OBJ);
}
@Override
- protected void update(InstanceIdentifier<VrfMaxpath> iid,
+ public void update(InstanceIdentifier<VrfMaxpath> iid,
VrfMaxpath oldval, VrfMaxpath newval) {
if (!Objects.equals(oldval.getMaxpaths(), newval.getMaxpaths())) {
executor.execute(new VrfMaxPathConfigurator(newval));
}
@Override
- protected void add(InstanceIdentifier<VrfMaxpath> instanceIdentifier, VrfMaxpath vrfMaxpathVal) {
+ public void add(InstanceIdentifier<VrfMaxpath> instanceIdentifier, VrfMaxpath vrfMaxpathVal) {
executor.execute(new VrfMaxPathConfigurator(vrfMaxpathVal));
}
}
}
- public class BfdConfigReactor
- extends AsyncDataTreeChangeListenerBase<BfdConfig, BfdConfigReactor>
+ public class BfdConfigReactor extends AbstractAsyncDataTreeChangeListener<BfdConfig>
implements ClusteredDataTreeChangeListener<BfdConfig> {
private static final String YANG_OBJ = "BfdConfig ";
public BfdConfigReactor() {
- super(BfdConfig.class, BfdConfigReactor.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(BfdConfig.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("BfdConfigReactor", LOG));
}
@Override
- protected void add(InstanceIdentifier<BfdConfig> iid, BfdConfig val) {
+ public void add(InstanceIdentifier<BfdConfig> iid, BfdConfig val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected BfdConfigReactor getDataTreeChangeListener() {
- return BfdConfigReactor.this;
- }
-
- @Override
- protected InstanceIdentifier<BfdConfig> getWildCardPath() {
- return InstanceIdentifier.create(BfdConfig.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<BfdConfig> iid, BfdConfig val) {
+ public void remove(InstanceIdentifier<BfdConfig> iid, BfdConfig val) {
if (!isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<BfdConfig> iid,
+ public void update(InstanceIdentifier<BfdConfig> iid,
BfdConfig oldval, BfdConfig newval) {
LOG.debug("received bfd config: updated oldval bfd enabled {}"
+ "min-rx {} min-tx {} detect-mul {} mhop {}",
try {
InstanceIdentifier<GracefulRestart> id =
InstanceIdentifier.create(Bgp.class).child(GracefulRestart.class);
- Optional<GracefulRestart> gracefulRestartOptional = MDSALUtil.read(dataBroker,
+ Optional<GracefulRestart> gracefulRestartOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (gracefulRestartOptional.isPresent()) {
spt = gracefulRestartOptional.get().getStalepathTime().toJava();
LOG.trace("BGP AS id is not set using graceful");
spt = defValue;
}
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.trace("Exception while reading GracefulRestart DS for the As {}", asId.getStalepathTime());
+ spt = defValue;
}
if (spt == 0) {
LOG.trace("BGP config/Stale-path time is not set using graceful/start-bgp");
while (0 != bgpDSretryCount.decrementAndGet()) {
try {
return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.create(Bgp.class)).orNull();
- } catch (ReadFailedException e) {
+ InstanceIdentifier.create(Bgp.class)).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
//Config DS may not be up, so sleep for 1 second and retry
LOG.debug("failed to get bgp config, may be DS is yet in consistent state(?)", e);
try {
} else {
LOG.error("createStaleFibMap:: FIBentries.class is not present");
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("createStaleFibMap:: error ", e);
}
LOG.error("created {} staled entries ", totalStaledCount);
} else {
LOG.error("deleteExternalFibRoutes:: FIBentries.class is not present");
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("deleteExternalFibRoutes:: error ", e);
}
LOG.debug("deleted {} fib entries {} mac entries", totalExternalRoutes, totalExternalMacRoutes);
*/
package org.opendaylight.netvirt.bgpmanager;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.thrift.TException;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.bgpmanager.oam.BgpAlarmErrorCodes;
import org.opendaylight.netvirt.bgpmanager.oam.BgpConstants;
.child(NetworksContainer.class)
.child(Networks.class,
new NetworksKey(rd, prefix)).build();
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
Futures.addCallback(tx.read(LogicalDatastoreType.CONFIGURATION, networksId),
new FutureCallback<Optional<Networks>>() {
@Override
*/
package org.opendaylight.netvirt.bgpmanager;
-import com.google.common.base.Optional;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.LinkedBlockingQueue;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.batching.ActionableResource;
import org.opendaylight.genius.utils.batching.ActionableResourceImpl;
import org.opendaylight.genius.utils.batching.DefaultBatchHandler;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_afi;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_safi;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.encap_type;
public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = Optional.empty();
+ try {
+ vpnInstanceOpData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading VpnInstanceOpDataEntry DS for the Vpn Rd {}", rd, e);
+ }
if (vpnInstanceOpData.isPresent()) {
return vpnInstanceOpData.get();
}
private String getElanNamefromRd(String rd) {
InstanceIdentifier<EvpnRdToNetwork> id = getEvpnRdToNetworkIdentifier(rd);
- Optional<EvpnRdToNetwork> evpnRdToNetworkOpData = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id);
+ Optional<EvpnRdToNetwork> evpnRdToNetworkOpData = Optional.empty();
+ try {
+ evpnRdToNetworkOpData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading EvpnRdToNetwork DS for the Vpn Rd {}", rd, e);
+ }
if (evpnRdToNetworkOpData.isPresent()) {
return evpnRdToNetworkOpData.get().getNetworkId();
}
KeyedInstanceIdentifier<Vrfs, VrfsKey> id = InstanceIdentifier.create(Bgp.class)
.child(VrfsContainer.class)
.child(Vrfs.class, new VrfsKey(rd));
- Optional<Vrfs> vrfsFromDs = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<Vrfs> vrfsFromDs = Optional.empty();
+ try {
+ vrfsFromDs = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading BGP VRF table for the Vpn Rd {}", rd, e);
+ }
if (vrfsFromDs.isPresent()) {
vrfs = vrfsFromDs.get();
}
public BfdConfig getBfdConfig() {
InstanceIdentifier<BfdConfig> id =
InstanceIdentifier.builder(BfdConfig.class).build();
- Optional<BfdConfig> bfdConfigOptional = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id);
+ Optional<BfdConfig> bfdConfigOptional = Optional.empty();
+ try {
+ bfdConfigOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading BfdConfig", e);
+ }
if (bfdConfigOptional.isPresent()) {
return bfdConfigOptional.get();
}
public DcgwTepList getDcgwTepConfig() {
InstanceIdentifier<DcgwTepList> id =
InstanceIdentifier.builder(Bgp.class).child(DcgwTepList.class).build();
- Optional<DcgwTepList> dcgwTepListOptional = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id);
+ Optional<DcgwTepList> dcgwTepListOptional = Optional.empty();
+ try {
+ dcgwTepListOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getDcgwTepConfig: Exception while reading DcgwTepList", e);
+ }
if (dcgwTepListOptional.isPresent()) {
return dcgwTepListOptional.get();
}
InstanceIdentifier.builder(Bgp.class)
.child(DcgwTepList.class)
.child(DcgwTep.class, new DcgwTepKey(dcgwIp)).build();
- Optional<DcgwTep> tepListOptional = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id);
+ Optional<DcgwTep> tepListOptional = Optional.empty();
+ try {
+ tepListOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading DcgwTep for the IP {}", dcgwIp, e);
+ }
if (tepListOptional.isPresent()) {
return tepListOptional.get().getTepIps();
}
package org.opendaylight.netvirt.bgpmanager;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.EvpnRdToNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetwork;
import org.slf4j.LoggerFactory;
-public class EvpnRdNetworkListener extends AsyncDataTreeChangeListenerBase<EvpnRdToNetwork, EvpnRdNetworkListener>
+public class EvpnRdNetworkListener extends AbstractAsyncDataTreeChangeListener<EvpnRdToNetwork>
implements ClusteredDataTreeChangeListener<EvpnRdToNetwork> {
private static final Logger LOG = LoggerFactory.getLogger(EvpnRdNetworkListener.class);
public EvpnRdNetworkListener(DataBroker dataBroker, BgpConfigurationManager bgpConfigManager, BgpUtil bgpUtil,
final IdManagerService idManager) {
- super(EvpnRdToNetwork.class, EvpnRdNetworkListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(EvpnRdToNetworks.class)
+ .child(EvpnRdToNetwork.class),
+ Executors.newListeningSingleThreadExecutor("EvpnRdNetworkListener", LOG));
this.broker = dataBroker;
this.bgpConfigManager = bgpConfigManager;
this.bgpUtil = bgpUtil;
}
- @Override
+ @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
- }
-
- @Override
- protected InstanceIdentifier<EvpnRdToNetwork> getWildCardPath() {
- return InstanceIdentifier.create(EvpnRdToNetworks.class).child(EvpnRdToNetwork.class);
- }
-
- @Override
- protected EvpnRdNetworkListener getDataTreeChangeListener() {
- return this;
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
- protected void add(InstanceIdentifier<EvpnRdToNetwork> instanceIdentifier, EvpnRdToNetwork rdToNetwork) {
+ public void add(InstanceIdentifier<EvpnRdToNetwork> instanceIdentifier, EvpnRdToNetwork rdToNetwork) {
if (!bgpConfigManager.isBGPEntityOwner()) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<EvpnRdToNetwork> instanceIdentifier, EvpnRdToNetwork rdToNetwork,
+ public void update(InstanceIdentifier<EvpnRdToNetwork> instanceIdentifier, EvpnRdToNetwork rdToNetwork,
EvpnRdToNetwork rdToNetworkOld) {
String rd = rdToNetwork.getRd();
String elanName = rdToNetwork.getNetworkId();
}
@Override
- protected void remove(InstanceIdentifier<EvpnRdToNetwork> instanceIdentifier, EvpnRdToNetwork rdToNetwork) {
+ public void remove(InstanceIdentifier<EvpnRdToNetwork> instanceIdentifier, EvpnRdToNetwork rdToNetwork) {
if (!bgpConfigManager.isBGPEntityOwner()) {
return;
}
bgpUtil.deleteTepFromElanInstance(rd, tepIp);
}
}
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.StringUtils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.AddressFamily;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="entityOwnershipService"
interface="org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService" />
package org.opendaylight.netvirt.bgpmanager.test;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yangtools.yang.binding.DataObject;
public abstract class AbstractMockFibManager<D extends DataObject> implements DataTreeChangeListener<D> {
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.netvirt.bgpmanager.BgpUtil;
import org.opendaylight.netvirt.bgpmanager.FibDSWriter;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
package org.opendaylight.netvirt.bgpmanager.test;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
registerListener(db) ;
}
- private void registerListener(final DataBroker db) {
+ public void registerListener(final DataBroker db) {
final DataTreeIdentifier<VrfEntry> treeId =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, getWildCardPath());
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, getWildCardPath());
listenerRegistration = db.registerDataTreeChangeListener(treeId, MockFibManager.this);
}
<artifactId>javax.inject</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.genius</groupId>
*/
package org.opendaylight.netvirt.cloudservicechain;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NWUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
package org.opendaylight.netvirt.cloudservicechain;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
protected VpnInstanceOpDataEntry getVpnInstance(String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier.create(VpnInstanceOpData.class)
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd));
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id).orNull();
+ return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id).orElse(null);
}
/**
return SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, boundServicesIId)
.isPresent();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Error while reading [{}]", boundServicesIId, e);
return false;
}
String vpnRd = VpnServiceChainUtils.getVpnRd(dataBroker, vpnName);
if (vpnRd == null) {
LOG.trace("Checking if Vpn {} participates in SC. Could not find its RD", vpnName);
- return Optional.absent();
+ return Optional.empty();
}
return VpnServiceChainUtils.getVpnPseudoPortData(dataBroker, vpnRd);
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortDataBuilder;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnServiceChainUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortData;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
* Modifies VpnPseudoPort stateful data. Objects of this class are intended to
* be used with DataStoreJobCoordinator
*/
-public abstract class VpnPseudoPortDataBaseJob implements Callable<List<ListenableFuture<Void>>> {
+public abstract class VpnPseudoPortDataBaseJob implements Callable<List<? extends ListenableFuture<?>>> {
final ManagedNewTransactionRunner txRunner;
protected final String vpnRd;
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.netvirt.cloudservicechain.VPNServiceChainHandler;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
LOG.trace("Vpn {} is not related to ServiceChaining. No further action", vpnName);
return;
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the ServiceChaining information for VPN {}", vpnName, e);
}
break;
}
vpnScHandler.bindScfOnVpnInterface(vpnIfaceAdded.key().getName(),
optScfInfoForVpn.get().getScfTag());
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the ServiceChaining information for VPN {}", vpnName, e);
}
}
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.netvirt.cloudservicechain.utils.VpnPseudoPortCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.VpnToPseudoPortList;
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.netvirt.cloudservicechain.CloudServiceChainConstants;
VpnServiceChainUtils.programLPortDispatcherFlowForScfToVpn(mdsalMgr, vpnId, dpnId,
vpnToPseudoPortInfo.getVpnLportTag().intValue(),
addOrRemove);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving the VPN to pseudo-port data for {}", rd, e);
}
}
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
*/
package org.opendaylight.netvirt.cloudservicechain.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
*/
package org.opendaylight.netvirt.cloudservicechain.utils;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
*
* @param broker dataBroker service reference
* @param elanInstanceName the name of the Elan
- * @return the ElanToPseudoPortData object or Optional.absent() if it
+ * @return the ElanToPseudoPortData object or Optional.empty() if it
* cannot be found
*/
public static Optional<ElanServiceChainState> getElanServiceChainState(final DataBroker broker,
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.cloud.servicechain.state.rev160711.vpn.to.pseudo.port.list.VpnToPseudoPortData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
for (VpnToPseudoPortData vpnToPseudoPort : allVpnToPseudoPortData) {
add(vpnToPseudoPort.getVrfId(), vpnToPseudoPort.getVpnLportTag());
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading VPN to pseudo-port map", e);
}
}
*/
package org.opendaylight.netvirt.cloudservicechain.utils;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.FlowEntity;
.flatMap(dpn -> dpn.getVpnInterfaces().stream())
.map(VpnInterfaces::getInterfaceName)
.collect(Collectors.toList());
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("getAllVpnInterfaces for vpn {}: Failure on read operation", vpnName, e);
return Collections.emptyList();
}
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="pingpong" />
<reference id="iMdsalApiManager" interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
<reference id="iVpnFootprintService" interface="org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService" />
import static org.mockito.Mockito.when;
import static org.opendaylight.genius.mdsalutil.NWUtil.getEtherTypeFromIpPrefix;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import java.math.BigInteger;
import java.util.Collections;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.FlowEntity;
private VPNServiceChainHandler vpnsch; // SUT
@Mock DataBroker broker;
- @Mock ReadOnlyTransaction readTx;
+ @Mock ReadTransaction readTx;
@Mock WriteTransaction writeTx;
@Mock IMdsalApiManager mdsalMgr;
@Mock IVpnFootprintService vpnFootprintService;
InstanceIdentifier<VpnInstance> id = VpnServiceChainUtils.getVpnInstanceToVpnIdIdentifier(vpnName);
CheckedFuture chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.of(instance));
+ when(chkdFuture.get()).thenReturn(Optional.of(instance));
// when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION), eq(id))).thenReturn(chkdFuture);
when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION),
argThat(isIIdType(VpnInstance.class)))).thenReturn(chkdFuture);
private void stubNoRdForVpnName(String vpnName) throws Exception {
CheckedFuture<Optional<VpnInstance>, ReadFailedException> chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.absent());
+ when(chkdFuture.get()).thenReturn(Optional.empty());
when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION),
eq(VpnServiceChainUtils.getVpnInstanceToVpnIdIdentifier(vpnName))))
.thenReturn(chkdFuture);
private void stubNoVpnInstanceForRD(String rd) throws Exception {
CheckedFuture<Optional<VpnInstanceOpDataEntry>, ReadFailedException> chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.absent());
+ when(chkdFuture.get()).thenReturn(Optional.empty());
InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier.create(VpnInstanceOpData.class)
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd));
.setVpnToDpnList(Collections.singletonList(vtdlb.build()))
.setVrfId("1").build();
CheckedFuture chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.of(vpnInstanceOpDataEntry));
+ when(chkdFuture.get()).thenReturn(Optional.of(vpnInstanceOpDataEntry));
when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
eq(VpnServiceChainUtils.getVpnInstanceOpDataIdentifier(rd)))).thenReturn(chkdFuture);
}
VrfTables tables = new VrfTablesBuilder().withKey(new VrfTablesKey(rd)).setRouteDistinguisher(rd)
.setVrfEntry(vrfEntryList).build();
CheckedFuture chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.of(tables));
+ when(chkdFuture.get()).thenReturn(Optional.of(tables));
when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION), eq(VpnServiceChainUtils.buildVrfId(rd))))
.thenReturn(chkdFuture);
.collect(Collectors.toList());
CheckedFuture chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.of(vpnIfacesList));
+ when(chkdFuture.get()).thenReturn(Optional.of(vpnIfacesList));
when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL),
eq(VpnServiceChainUtils.getVpnToDpnListIdentifier(rd, dpnId))))
.thenReturn(chkdFuture);
CloudServiceChainConstants.COOKIE_SCF_BASE,
null /*instructions*/);
- when(chkdFuture.checkedGet()).thenReturn(Optional.of(boundService));
+ when(chkdFuture.get()).thenReturn(Optional.of(boundService));
when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION),
eq(VpnServiceChainUtils.buildBoundServicesIid(NwConstants.SCF_SERVICE_INDEX, ifName))))
.thenReturn(chkdFuture);
private void stubScfIsNotBoundOnIface(long scfTag, String ifName) throws Exception {
CheckedFuture chkdFuture = mock(CheckedFuture.class);
- when(chkdFuture.checkedGet()).thenReturn(Optional.absent());
+ when(chkdFuture.get()).thenReturn(Optional.empty());
when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION),
eq(VpnServiceChainUtils.buildBoundServicesIid(NwConstants.SCF_SERVICE_INDEX, ifName))))
.thenReturn(chkdFuture);
<artifactId>org.apache.karaf.shell.console</artifactId>
<scope>provided</scope>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-eos-binding-api</artifactId>
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import javax.annotation.PreDestroy;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.dhcpservice.jobs.DhcpAllocationPoolAddJob;
import org.opendaylight.netvirt.dhcpservice.jobs.DhcpAllocationPoolRemoveJob;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.dhcp_allocation_pool.rev161214.DhcpAllocationPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.dhcp_allocation_pool.rev161214.dhcp_allocation_pool.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.dhcp_allocation_pool.rev161214.dhcp_allocation_pool.network.AllocationPool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DhcpAllocationPoolListener
- extends AsyncDataTreeChangeListenerBase<AllocationPool, DhcpAllocationPoolListener> {
+public class DhcpAllocationPoolListener extends AbstractAsyncDataTreeChangeListener<AllocationPool> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpAllocationPoolListener.class);
public DhcpAllocationPoolListener(final DhcpAllocationPoolManager dhcpAllocationPoolManager,
final DataBroker dataBroker, final JobCoordinator jobCoordinator) {
- super(AllocationPool.class, DhcpAllocationPoolListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(DhcpAllocationPool.class)
+ .child(Network.class).child(AllocationPool.class),
+ Executors.newListeningSingleThreadExecutor("DhcpAllocationPoolListener", LOG));
this.dhcpAllocationPoolManager = dhcpAllocationPoolManager;
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.jobCoordinator = jobCoordinator;
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
LOG.info("DhcpAllocationPoolListener initialized");
}
@Override
- p
rotected void add(InstanceIdentifier<AllocationPool> key, AllocationPool dataObjectModification) {
+ p
ublic void add(InstanceIdentifier<AllocationPool> key, AllocationPool dataObjectModification) {
String networkId = key.firstKeyOf(Network.class).getNetworkId();
dhcpAllocationPoolManager.createIdAllocationPool(networkId, dataObjectModification);
Map<Uint64, List<String>> elanDpnInterfacesByName =
}
@Override
- protected DhcpAllocationPoolListener getDataTreeChangeListener() {
- return this;
- }
-
- @Override
- protected InstanceIdentifier<AllocationPool> getWildCardPath() {
- return InstanceIdentifier.builder(DhcpAllocationPool.class)//
- .child(Network.class).child(AllocationPool.class).build();
- }
-
- @Override
- protected void remove(InstanceIdentifier<AllocationPool> key, AllocationPool dataObjectModification) {
+ public void remove(InstanceIdentifier<AllocationPool> key, AllocationPool dataObjectModification) {
String networkId = key.firstKeyOf(Network.class).getNetworkId();
dhcpAllocationPoolManager.releaseIdAllocationPool(networkId, dataObjectModification);
Map<Uint64, List<String>> elanDpnInterfacesByName =
}
@Override
- p
rotected void update(InstanceIdentifier<AllocationPool> key, AllocationPool dataObjectModificationBefore,
+ p
ublic void update(InstanceIdentifier<AllocationPool> key, AllocationPool dataObjectModificationBefore,
AllocationPool dataObjectModificationAfter) {
// TODO Auto-generated method stub
}
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
}
*/
package org.opendaylight.netvirt.dhcpservice;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.EventListener;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
}
@Nullable
- public AllocationPool getAllocationPoolByNetwork(String networkId) throws ReadFailedException {
+ public AllocationPool getAllocationPoolByNetwork(String networkId) throws ExecutionException, InterruptedException {
InstanceIdentifier<Network> network = InstanceIdentifier.builder(DhcpAllocationPool.class)
.child(Network.class, new NetworkKey(networkId)).build();
Optional<Network> optionalNetworkConfData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
public Map<Uint64, List<String>> getElanDpnInterfacesByName(DataBroker broker, String elanInstanceName) {
InstanceIdentifier<ElanDpnInterfacesList> elanDpnIfacesIid = InstanceIdentifier.builder(ElanDpnInterfaces.class)
.child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName)).build();
- Optional<ElanDpnInterfacesList> elanDpnIfacesOpc = MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- elanDpnIfacesIid);
+ Optional<ElanDpnInterfacesList> elanDpnIfacesOpc;
+ try {
+ elanDpnIfacesOpc = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
+ elanDpnIfacesIid);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getElanDpnInterfacesByName: Exception while reading the ElanDpnInterfacesList DS for the "
+ + "elan-instance {}", elanInstanceName, e);
+ return Collections.emptyMap();
+ }
if (!elanDpnIfacesOpc.isPresent()) {
LOG.warn("Could not find DpnInterfaces for elan {}", elanInstanceName);
return Collections.emptyMap();
}
@Nullable
- public String getNetworkByPort(String portUuid) throws ReadFailedException {
+ public String getNetworkByPort(String portUuid) throws ExecutionException, InterruptedException {
InstanceIdentifier<ElanInterface> elanInterfaceName = InstanceIdentifier.builder(ElanInterfaces.class)
.child(ElanInterface.class, new ElanInterfaceKey(portUuid)).build();
Optional<ElanInterface> optionalElanInterface = SingleTransactionDataBroker.syncReadOptional(dataBroker,
*/
package org.opendaylight.netvirt.dhcpservice;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DhcpConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.dhcp.config.Configs;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.LoggerFactory;
@Singleton
-public class DhcpConfigListener extends AsyncClusteredDataTreeChangeListenerBase<DhcpConfig, DhcpConfigListener> {
+public class DhcpConfigListener extends AbstractClusteredAsyncDataTreeChangeListener<DhcpConfig> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpConfigListener.class);
@Inject
public DhcpConfigListener(final DataBroker db, final DhcpManager dhcpMgr) {
- super(DhcpConfig.class, DhcpConfigListener.class);
+ super(db, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(DhcpConfig.class),
+ Executors.newListeningSingleThreadExecutor("DhcpConfigListener", LOG));
dhcpManager = dhcpMgr;
this.dataBroker = db;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<DhcpConfig> getWildCardPath() {
- return InstanceIdentifier.create(DhcpConfig.class);
+ LOG.info("{} close", getClass().getSimpleName());
}
@Override
@PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.debug("DhcpConfig Listener Closed");
}
@Override
- protected void remove(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig del) {
+ public void remove(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig del) {
LOG.trace("DhcpConfig removed: {}", del);
updateConfig(null);
}
@Override
- protected void update(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig original, DhcpConfig update) {
+ public void update(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig original, DhcpConfig update) {
LOG.trace("DhcpConfig changed to {}", update);
updateConfig(update);
}
@Override
- protected void add(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig add) {
+ public void add(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig add) {
LOG.trace("DhcpConfig added {}", add);
updateConfig(add);
}
//TODO: What to do if string is ""
}
}
-
- @Override
- protected DhcpConfigListener getDataTreeChangeListener() {
- return DhcpConfigListener.this;
- }
}
*/
package org.opendaylight.netvirt.dhcpservice;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.dhcp.rev160428.DesignatedSwitchesForExternalTunnels;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.dhcp.rev160428.designated.switches._for.external.tunnels.DesignatedSwitchForTunnel;
import org.slf4j.LoggerFactory;
@Singleton
-public class DhcpDesignatedDpnListener
- extends AsyncClusteredDataTreeChangeListenerBase<DesignatedSwitchForTunnel, DhcpDesignatedDpnListener> {
+public class DhcpDesignatedDpnListener extends AbstractClusteredAsyncDataTreeChangeListener<DesignatedSwitchForTunnel> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpDesignatedDpnListener.class);
private final DhcpExternalTunnelManager dhcpExternalTunnelManager;
public DhcpDesignatedDpnListener(final DhcpExternalTunnelManager dhcpExternalTunnelManager,
final DataBroker broker,
final DhcpserviceConfig config) {
- super(DesignatedSwitchForTunnel.class, DhcpDesignatedDpnListener.class);
+ super(broker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(DesignatedSwitchesForExternalTunnels.class)
+ .child(DesignatedSwitchForTunnel.class),
+ Executors.newListeningSingleThreadExecutor("DhcpDesignatedDpnListener", LOG));
this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
this.broker = broker;
this.config = config;
+ init();
}
- @PostConstruct
public void init() {
if (config.isControllerDhcpEnabled()) {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
+ LOG.info("{} close", getClass().getSimpleName());
}
}
@PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.debug("DhcpDesignatedDpnListener Listener Closed");
}
@Override
- protected void remove(InstanceIdentifier<DesignatedSwitchForTunnel> identifier, DesignatedSwitchForTunnel del) {
+ public void remove(InstanceIdentifier<DesignatedSwitchForTunnel> identifier, DesignatedSwitchForTunnel del) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.debug("Remove for DesignatedSwitchForTunnel : {}", del);
dhcpExternalTunnelManager.removeFromLocalCache(Uint64.valueOf(del.getDpId()),
del.getTunnelRemoteIpAddress(), del.getElanInstanceName());
}
@Override
- protected void update(InstanceIdentifier<DesignatedSwitchForTunnel> identifier, DesignatedSwitchForTunnel original,
+ public void update(InstanceIdentifier<DesignatedSwitchForTunnel> identifier, DesignatedSwitchForTunnel original,
DesignatedSwitchForTunnel update) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.debug("Update for DesignatedSwitchForTunnel original {}, update {}", original, update);
dhcpExternalTunnelManager.removeFromLocalCache(Uint64.valueOf(original.getDpId()),
original.getTunnelRemoteIpAddress(), original.getElanInstanceName());
}
@Override
- protected void add(InstanceIdentifier<DesignatedSwitchForTunnel> identifier, DesignatedSwitchForTunnel add) {
+ public void add(InstanceIdentifier<DesignatedSwitchForTunnel> identifier, DesignatedSwitchForTunnel add) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.debug("Add for DesignatedSwitchForTunnel : {}", add);
Uint64 designatedDpnId = Uint64.valueOf(add.getDpId());
IpAddress tunnelRemoteIpAddress = add.getTunnelRemoteIpAddress();
subnetDhcpData.get().getPortMacaddress());
}
}
-
- @Override
- protected InstanceIdentifier<DesignatedSwitchForTunnel> getWildCardPath() {
- return InstanceIdentifier.create(DesignatedSwitchesForExternalTunnels.class)
- .child(DesignatedSwitchForTunnel.class);
- }
-
- @Override
- protected DhcpDesignatedDpnListener getDataTreeChangeListener() {
- return DhcpDesignatedDpnListener.this;
- }
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Locale;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.apache.commons.lang3.tuple.Pair;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.dhcpservice.api.IDhcpExternalTunnelManager;
LOG.trace("Loading designatedDpnsToTunnelIpElanNameCache");
InstanceIdentifier<DesignatedSwitchesForExternalTunnels> instanceIdentifier =
InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).build();
- Optional<DesignatedSwitchesForExternalTunnels> designatedSwitchForTunnelOptional =
- MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ Optional<DesignatedSwitchesForExternalTunnels> designatedSwitchForTunnelOptional;
+ try {
+ designatedSwitchForTunnelOptional = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("initilizeCaches: Exception while reading the DesignatedSwitchesForExternalTunnels DS", e);
+ return;
+ }
if (designatedSwitchForTunnelOptional.isPresent()) {
List<DesignatedSwitchForTunnel> list =
designatedSwitchForTunnelOptional.get().nonnullDesignatedSwitchForTunnel();
}
LOG.trace("Loading vniMacAddressToPortCache");
InstanceIdentifier<Ports> inst = InstanceIdentifier.builder(Neutron.class).child(Ports.class).build();
- Optional<Ports> optionalPorts = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ Optional<Ports> optionalPorts;
+ try {
+ optionalPorts = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ inst);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("initilizeCaches: Exception while reading the Ports DS", e);
+ return;
+ }
if (optionalPorts.isPresent()) {
List<Port> list = optionalPorts.get().nonnullPort();
for (Port port : list) {
InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class)
.child(DesignatedSwitchForTunnel.class,
new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp)).build();
- Optional<DesignatedSwitchForTunnel> designatedSwitchForTunnelOptional =
- MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ Optional<DesignatedSwitchForTunnel> designatedSwitchForTunnelOptional;
+ try {
+ designatedSwitchForTunnelOptional = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("readDesignatedSwitchesForExternalTunnel: Exception while reading the DesignatedSwitchForTunnel "
+ + "DS for the elan-instance {} tunnelIp {}", elanInstanceName, tunnelIp, e);
+ return Uint64.ZERO;
+ }
if (designatedSwitchForTunnelOptional.isPresent()) {
return Uint64.valueOf(designatedSwitchForTunnelOptional.get().getDpId());
}
private boolean isDpnDesignatedDpn(Uint64 dpId) {
InstanceIdentifier<DesignatedSwitchesForExternalTunnels> instanceIdentifier =
InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).build();
- Optional<DesignatedSwitchesForExternalTunnels> designatedSwitchForTunnelOptional =
- MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ Optional<DesignatedSwitchesForExternalTunnels> designatedSwitchForTunnelOptional;
+ try {
+ designatedSwitchForTunnelOptional = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("isDpnDesignatedDpn: Exception while reading the DesignatedSwitchesForExternalTunnels "
+ + "DS for the dpId {}", dpId, e);
+ return false;
+ }
if (designatedSwitchForTunnelOptional.isPresent()) {
List<DesignatedSwitchForTunnel> list =
designatedSwitchForTunnelOptional.get().nonnullDesignatedSwitchForTunnel();
.setLogicalSwitchRef(lsRef).build();
InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(
dstDevice.getNodeId(), remoteMcastMacs.key());
- ReadOnlyTransaction transaction = broker.newReadOnlyTransaction();
+ ReadTransaction transaction = broker.newReadOnlyTransaction();
try {
//TODO do async mdsal read
- remoteMcastMacs = transaction.read(LogicalDatastoreType.CONFIGURATION, iid).checkedGet().get();
+ remoteMcastMacs = transaction.read(LogicalDatastoreType.CONFIGURATION, iid).get().get();
locators.addAll(remoteMcastMacs.getLocatorSet());
return new RemoteMcastMacsBuilder(remoteMcastMacs).setLocatorSet(new ArrayList<>(locators)).build();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read the macs {}", iid);
} finally {
transaction.close();
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import javax.annotation.PreDestroy;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
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.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DhcpInterfaceConfigListener
- extends AsyncDataTreeChangeListenerBase<Interface, DhcpInterfaceConfigListener> {
+public class DhcpInterfaceConfigListener extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpInterfaceConfigListener.class);
public DhcpInterfaceConfigListener(DataBroker dataBroker,
DhcpExternalTunnelManager dhcpExternalTunnelManager, DhcpManager dhcpManager,
JobCoordinator jobCoordinator) {
- super(Interface.class, DhcpInterfaceConfigListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Interfaces.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("DhcpInterfaceConfigListener", LOG));
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
this.dhcpManager = dhcpManager;
this.jobCoordinator = jobCoordinator;
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
+ @PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.info("DhcpInterfaceConfigListener Closed");
}
@Override
- protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface del) {
jobCoordinator.enqueueJob(DhcpServiceUtils.getJobKey(del.getName()), () -> {
IfTunnel tunnelInterface = del.augmentation(IfTunnel.class);
IfL2vlan vlanInterface = del.augmentation(IfL2vlan.class);
}
@Override
- protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
+ public void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
// Handled in update () DhcpInterfaceEventListener
}
@Override
- protected void add(InstanceIdentifier<Interface> identifier, Interface add) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface add) {
jobCoordinator.enqueueJob(DhcpServiceUtils.getJobKey(add.getName()), () -> {
String interfaceName = add.getName();
IfL2vlan vlanInterface = add.augmentation(IfL2vlan.class);
return Collections.emptyList();
}, DhcpMConstants.RETRY_COUNT);
}
-
- @Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
- }
-
- @Override
- protected DhcpInterfaceConfigListener getDataTreeChangeListener() {
- return DhcpInterfaceConfigListener.this;
- }
}
package org.opendaylight.netvirt.dhcpservice;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import javax.annotation.PreDestroy;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.dhcpservice.jobs.DhcpInterfaceAddJob;
import org.opendaylight.netvirt.dhcpservice.jobs.DhcpInterfaceRemoveJob;
import org.opendaylight.netvirt.dhcpservice.jobs.DhcpInterfaceUpdateJob;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DhcpInterfaceEventListener
- extends AsyncDataTreeChangeListenerBase<Interface, DhcpInterfaceEventListener> {
+public class DhcpInterfaceEventListener extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpInterfaceEventListener.class);
IInterfaceManager interfaceManager, IElanService elanService,
DhcpPortCache dhcpPortCache, JobCoordinator jobCoordinator,
ItmRpcService itmRpcService) {
- super(Interface.class, DhcpInterfaceEventListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("DhcpInterfaceEventListener", LOG));
this.dhcpManager = dhcpManager;
this.dataBroker = dataBroker;
this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
this.dhcpPortCache = dhcpPortCache;
this.jobCoordinator = jobCoordinator;
this.itmRpcService = itmRpcService;
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
+ @PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.info("DhcpInterfaceEventListener Closed");
}
@Override
- protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface del) {
if (!L2vlan.class.equals(del.getType()) && !Tunnel.class.equals(del.getType())) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<Interface> identifier,
+ public void update(InstanceIdentifier<Interface> identifier,
Interface original, Interface update) {
// We're only interested in Vlan and Tunnel ports
if (!L2vlan.class.equals(update.getType()) && !Tunnel.class.equals(update.getType())) {
}
@Override
- protected void add(InstanceIdentifier<Interface> identifier, Interface add) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface add) {
// We're only interested in Vlan and Tunnel ports
if (!L2vlan.class.equals(add.getType()) && !Tunnel.class.equals(add.getType())) {
return;
add, dpnId, interfaceManager, elanService, itmRpcService);
jobCoordinator.enqueueJob(DhcpServiceUtils.getJobKey(interfaceName), job, DhcpMConstants.RETRY_COUNT);
}
-
- @Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
- }
-
- @Override
- protected DhcpInterfaceEventListener getDataTreeChangeListener() {
- return DhcpInterfaceEventListener.this;
- }
}
*/
package org.opendaylight.netvirt.dhcpservice;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.function.Predicate;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayCache;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
@Nullable
private IpAddress getTunnelIp(InstanceIdentifier<Node> nodeIid) {
- Optional<Node> nodeOptional =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, nodeIid);
- if (!CONTAINS_GLOBAL_AUGMENTATION.test(nodeOptional)) {
- return null;
- }
- List<Switches> switchIids = nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class).getSwitches();
- if (EMPTY_LIST.test(switchIids)) {
- return null;
- }
- InstanceIdentifier<Node> psIid = (InstanceIdentifier<Node>) switchIids.get(0).getSwitchRef().getValue();
- nodeOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, psIid);
- if (!CONTAINS_SWITCH_AUGMENTATION.test(nodeOptional)) {
- return null;
- }
- List<TunnelIps> tunnelIps = nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class).getTunnelIps();
- if (EMPTY_LIST.test(tunnelIps)) {
+ Optional<Node> nodeOptional;
+ try {
+ nodeOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, nodeIid);
+ if (!CONTAINS_GLOBAL_AUGMENTATION.test(nodeOptional)) {
+ return null;
+ }
+ List<Switches> switchIids = nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class).getSwitches();
+ if (EMPTY_LIST.test(switchIids)) {
+ return null;
+ }
+ InstanceIdentifier<Node> psIid = (InstanceIdentifier<Node>) switchIids.get(0).getSwitchRef().getValue();
+ nodeOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ psIid);
+ if (!CONTAINS_SWITCH_AUGMENTATION.test(nodeOptional)) {
+ return null;
+ }
+ List<TunnelIps> tunnelIps = nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class)
+ .getTunnelIps();
+ if (EMPTY_LIST.test(tunnelIps)) {
+ return null;
+ }
+ return tunnelIps.get(0).key().getTunnelIpsKey();
+ } catch (ExecutionException | InterruptedException e) {
return null;
}
- return tunnelIps.get(0).key().getTunnelIpsKey();
}
}
*/
package org.opendaylight.netvirt.dhcpservice;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Named;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.mdsalutil.instructions.InstructionGotoTable;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
Subnet subnet = null;
InstanceIdentifier<Subnet> inst = InstanceIdentifier.create(Neutron.class).child(Subnets.class).child(Subnet
.class, new SubnetKey(subnetId));
- Optional<Subnet> sn = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ Optional<Subnet> sn;
+ try {
+ sn = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ inst);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading subnet DS for the subnetId {}", subnetId.getValue(), e);
+ return subnet;
+ }
if (sn.isPresent()) {
subnet = sn.get();
}
Port prt = null;
InstanceIdentifier<Port> inst = InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class,
new PortKey(new Uuid(name)));
- Optional<Port> port = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ Optional<Port> port;
+ try {
+ port = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ inst);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while reading port DS for the port {}", name, e);
+ return prt;
+ }
if (port.isPresent()) {
prt = port.get();
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractAsyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.config.rev150710.DhcpserviceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import java.util.List;
import java.util.Locale;
import java.util.function.Consumer;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput.ArpReponderInputBuilder;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
import org.slf4j.LoggerFactory;
@Singleton
-public class DhcpNeutronPortListener
- extends AsyncClusteredDataTreeChangeListenerBase<Port, DhcpNeutronPortListener> {
+public class DhcpNeutronPortListener extends AbstractClusteredAsyncDataTreeChangeListener<Port> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpNeutronPortListener.class);
private final DhcpExternalTunnelManager dhcpExternalTunnelManager;
@Named("elanService") IElanService ielanService, IInterfaceManager interfaceManager,
DhcpserviceConfig config, final JobCoordinator jobCoordinator, DhcpManager dhcpManager,
ItmRpcService itmRpcService) {
-
- super(Port.class, DhcpNeutronPortListener.class);
+ super(db, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class).child(Ports.class)
+ .child(Port.class),
+ Executors.newListeningSingleThreadExecutor("DhcpNeutronPortListener", LOG));
this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
this.elanService = ielanService;
this.interfaceManager = interfaceManager;
this.jobCoordinator = jobCoordinator;
this.dhcpManager = dhcpManager;
this.itmRpcService = itmRpcService;
+ init();
}
- @PostConstruct
public void init() {
if (config.isControllerDhcpEnabled()) {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
+ LOG.info("{} init", getClass().getSimpleName());
}
}
- @Override
- protected InstanceIdentifier<Port> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
- }
-
@Override
@PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.debug("DhcpNeutronPortListener Listener Closed");
}
@Override
- protected void remove(InstanceIdentifier<Port> identifier, Port del) {
+ public void remove(InstanceIdentifier<Port> identifier, Port del) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.trace("Port removed: {}", del);
if (NeutronConstants.IS_ODL_DHCP_PORT.test(del)) {
jobCoordinator.enqueueJob(getJobKey(del),
}
@Override
- protected void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
+ public void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.trace("Port changed to {}", update);
//With Ipv6 changes we can get ipv4 subnets later. The below check is to support such scenario.
if (original.nonnullFixedIps().size() < update.nonnullFixedIps().size()) {
}
@Override
- protected void add(InstanceIdentifier<Port> identifier, Port add) {
+ public void add(InstanceIdentifier<Port> identifier, Port add) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.trace("Port added {}", add);
if (NeutronConstants.IS_ODL_DHCP_PORT.test(add)) {
jobCoordinator.enqueueJob(getJobKey(add),
return vnicType.equals("direct") || vnicType.equals("macvtap");
}
- @Override
- protected DhcpNeutronPortListener getDataTreeChangeListener() {
- return DhcpNeutronPortListener.this;
- }
-
/**
* Handle(Add/Remove) ARP Responder for DHCP IP on all the DPNs when DHCP is
* enabled/disabled on subnet add or update or delete.
package org.opendaylight.netvirt.dhcpservice;
import java.math.BigInteger;
-
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.slf4j.LoggerFactory;
@Singleton
-public class DhcpNodeListener extends AsyncClusteredDataTreeChangeListenerBase<Node, DhcpNodeListener> {
+public class DhcpNodeListener extends AbstractClusteredAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpNodeListener.class);
private final DataBroker broker;
@Inject
public DhcpNodeListener(DataBroker broker) {
- super(Node.class, DhcpNodeListener.class);
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class),
+ Executors.newListeningSingleThreadExecutor("DhcpNodeListener", LOG));
this.broker = broker;
}
- @PostConstruct
- public void start() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ public void init() {
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
+ @PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Node> key, Node del) {
+ public void remove(InstanceIdentifier<Node> key, Node del) {
LOG.trace("Received remove for {}", del);
NodeId nodeId = del.getId();
String[] node = nodeId.getValue().split(":");
}
@Override
- protected void update(InstanceIdentifier<Node> key, Node dataObjectModificationBefore,
+ public void update(InstanceIdentifier<Node> key, Node dataObjectModificationBefore,
Node dataObjectModificationAfter) {
}
@Override
- protected void add(InstanceIdentifier<Node> key, Node add) {
+ public void add(InstanceIdentifier<Node> key, Node add) {
LOG.trace("Received add for {}", add);
NodeId nodeId = add.getId();
String[] node = nodeId.getValue().split(":");
BigInteger dpId = new BigInteger(node[1]);
DhcpServiceUtils.addToDpnIdCache(Uint64.valueOf(dpId));
}
-
- @Override
- protected DhcpNodeListener getDataTreeChangeListener() {
- return DhcpNodeListener.this;
- }
-
}
import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.metrics.MetricDescriptor;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.api.DHCP;
import org.opendaylight.netvirt.dhcpservice.api.DHCPConstants;
import org.opendaylight.netvirt.dhcpservice.api.DHCPUtils;
default:
break;
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading from MD-SAL", e);
}
return null;
package org.opendaylight.netvirt.dhcpservice;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.function.BiConsumer;
import java.util.stream.LongStream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.mdsalutil.matches.MatchUdpDestinationPort;
import org.opendaylight.genius.mdsalutil.matches.MatchUdpSourcePort;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
if (!connectedDpnIds.isEmpty()) {
return connectedDpnIds;
}
- return extractDpnsFromNodes(MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(Nodes.class).build()));
+ try {
+ return extractDpnsFromNodes(MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(Nodes.class).build()));
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getListOfDpns: Exception while reading getListOfDpns DS", e);
+ return Collections.emptyList();
+ }
}
@NonNull
private static List<Uint64> extractDpnsFromNodes(Optional<Nodes> optionalNodes) {
- return optionalNodes.toJavaUtil().map(
+ return optionalNodes.map(
nodes -> nodes.nonnullNode().stream().map(Node::getId).filter(Objects::nonNull).map(
MDSALUtil::getDpnIdFromNodeName).collect(
Collectors.toList())).orElse(Collections.emptyList());
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInstanceIdentifier =
InstanceIdentifier.builder(ElanDpnInterfaces.class)
.child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName)).build();
- Optional<ElanDpnInterfacesList> elanDpnOptional =
- MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInstanceIdentifier);
+ Optional<ElanDpnInterfacesList> elanDpnOptional;
+ try {
+ elanDpnOptional = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
+ elanDpnInstanceIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getDpnsForElan: Exception while reading ElanDpnInterfacesList DS for the elanInstanceName {}",
+ elanInstanceName, e);
+ return Collections.emptyList();
+ }
if (elanDpnOptional.isPresent()) {
List<DpnInterfaces> dpns = elanDpnOptional.get().nonnullDpnInterfaces();
for (DpnInterfaces dpnInterfaces : dpns) {
.interfaces.state.Interface> interfaceId = InstanceIdentifier.builder(InterfacesState.class)
.child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
.interfaces.state.Interface.class, interfaceKey).build();
- return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, interfaceId, dataBroker).orNull();
+ return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, interfaceId, dataBroker).orElse(null);
}
public static String getSegmentationId(Uuid networkId, DataBroker broker) {
InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class)
.child(Networks.class).child(Network.class, new NetworkKey(networkId));
- Optional<Network> optionalNetwork = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ Optional<Network> optionalNetwork;
+ try {
+ optionalNetwork = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getSegmentationId: Exception while reading Network DS for the Network {}",
+ networkId.getValue(), e);
+ return null;
+ }
if (!optionalNetwork.isPresent()) {
return null;
}
try {
return java.util.Optional
.ofNullable(SingleTransactionDataBroker.syncRead(broker, LogicalDatastoreType.CONFIGURATION, id));
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read SubnetToDhcpPort for DS due to error {}", e.getMessage());
}
return java.util.Optional.empty();
@NonNull
public static List<Uuid> getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) {
InstanceIdentifier id = buildNetworkMapIdentifier(networkId);
- Optional<NetworkMap> optionalNetworkMap = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<NetworkMap> optionalNetworkMap;
+ try {
+ optionalNetworkMap = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getSubnetIdsFromNetworkId: Exception while reading NetworkMap DS for the network {}",
+ networkId.getValue(), e);
+ return Collections.emptyList();
+ }
if (optionalNetworkMap.isPresent()) {
@Nullable List<Uuid> subnetIdList = optionalNetworkMap.get().getSubnetIdList();
if (subnetIdList != null) {
final SubnetKey subnetkey = new SubnetKey(subnetUuid);
final InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
.child(Subnets.class).child(Subnet.class, subnetkey);
- final Optional<Subnet> subnet = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, subnetidentifier);
+ final Optional<Subnet> subnet;
+ try {
+ subnet = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ subnetidentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("isIpv4Subnet: Exception while reading Subnet DS for the Subnet {}",
+ subnetUuid.getValue(), e);
+ return false;
+ }
if (subnet.isPresent()) {
Class<? extends IpVersionBase> ipVersionBase = subnet.get().getIpVersion();
return IpVersionV4.class.equals(ipVersionBase);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
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.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.slf4j.LoggerFactory;
@Singleton
-public class DhcpSubnetListener extends AsyncClusteredDataTreeChangeListenerBase<Subnet, DhcpSubnetListener> {
+public class DhcpSubnetListener extends AbstractClusteredAsyncDataTreeChangeListener<Subnet> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpSubnetListener.class);
private final DataBroker dataBroker;
@Inject
public DhcpSubnetListener(final DhcpManager dhcpManager, final DhcpExternalTunnelManager
dhcpExternalTunnelManager, final DataBroker broker, final DhcpserviceConfig config) {
- super(Subnet.class, DhcpSubnetListener.class);
+ super(broker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class).child(Subnets.class)
+ .child(Subnet.class), Executors.newListeningSingleThreadExecutor("DhcpSubnetListener", LOG));
this.dhcpManager = dhcpManager;
this.dataBroker = broker;
this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
this.config = config;
+ init();
}
- @PostConstruct
public void init() {
if (config.isControllerDhcpEnabled()) {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ LOG.info("{} init", getClass().getSimpleName());
}
}
@Override
- protected void add(InstanceIdentifier<Subnet> identifier, Subnet add) {
+ public void add(InstanceIdentifier<Subnet> identifier, Subnet add) {
}
@Override
- protected void remove(InstanceIdentifier<Subnet> identifier, Subnet del) {
+ public void remove(InstanceIdentifier<Subnet> identifier, Subnet del) {
}
@Override
- protected InstanceIdentifier<Subnet> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Subnets.class).child(Subnet.class);
- }
-
- @Override
- protected void update(InstanceIdentifier<Subnet> identifier, Subnet original, Subnet update) {
+ public void update(InstanceIdentifier<Subnet> identifier, Subnet original, Subnet update) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
LOG.trace("DhcpSubnetListener Update : Original dhcpstatus: {}, Updated dhcpstatus {}", original.isEnableDhcp(),
update.isEnableDhcp());
SubnetmapBuilder builder = null ;
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
- ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
+ ReadTransaction tx = broker.newReadOnlyTransaction();
Optional<Subnetmap> sn ;
try {
@PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.info("DhcpSubnetListener Closed");
}
-
- @Override
- protected DhcpSubnetListener getDataTreeChangeListener() {
- return DhcpSubnetListener.this;
- }
}
*/
package org.opendaylight.netvirt.dhcpservice;
-import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
import org.slf4j.LoggerFactory;
@Singleton
-public class DhcpUCastMacListener
- extends AsyncClusteredDataTreeChangeListenerBase<LocalUcastMacs, DhcpUCastMacListener> {
+public class DhcpUCastMacListener extends AbstractClusteredAsyncDataTreeChangeListener<LocalUcastMacs> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpUCastMacListener.class);
private final DhcpExternalTunnelManager dhcpExternalTunnelManager;
@Inject
public DhcpUCastMacListener(final DhcpManager dhcpManager, final DhcpExternalTunnelManager dhcpExtTunnelMgr,
final DataBroker dataBroker, final DhcpserviceConfig config) {
- super(LocalUcastMacs.class, DhcpUCastMacListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class).child(Node.class).augmentation(HwvtepGlobalAugmentation.class)
+ .child(LocalUcastMacs.class),
+ Executors.newListeningSingleThreadExecutor("DhcpUCastMacListener", LOG));
this.broker = dataBroker;
this.dhcpExternalTunnelManager = dhcpExtTunnelMgr;
this.dhcpManager = dhcpManager;
this.config = config;
+ init();
}
- @PostConstruct
public void init() {
if (config.isControllerDhcpEnabled()) {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} init", getClass().getSimpleName());
}
}
- @Override
- protected InstanceIdentifier<LocalUcastMacs> getWildCardPath() {
- return InstanceIdentifier.create(NetworkTopology.class).child(Topology.class).child(Node.class)
- .augmentation(HwvtepGlobalAugmentation.class).child(LocalUcastMacs.class);
- }
-
@Override
@PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.info("DhcpUCastMacListener Closed");
}
@Override
- protected void remove(InstanceIdentifier<LocalUcastMacs> identifier,
+ public void remove(InstanceIdentifier<LocalUcastMacs> identifier,
LocalUcastMacs del) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
// Flow removal for table 18 is handled in Neutron Port delete.
//remove the new CR-DHCP
NodeId torNodeId = identifier.firstKeyOf(Node.class).getNodeId();
}
@Override
- protected void update(InstanceIdentifier<LocalUcastMacs> identifier,
+ public void update(InstanceIdentifier<LocalUcastMacs> identifier,
LocalUcastMacs original, LocalUcastMacs update) {
// TODO Auto-generated method stub
}
@Override
- protected void add(InstanceIdentifier<LocalUcastMacs> identifier,
+ public void add(InstanceIdentifier<LocalUcastMacs> identifier,
LocalUcastMacs add) {
+ if (!config.isControllerDhcpEnabled()) {
+ return;
+ }
NodeId torNodeId = identifier.firstKeyOf(Node.class).getNodeId();
InstanceIdentifier<LogicalSwitches> logicalSwitchRef =
(InstanceIdentifier<LogicalSwitches>) add.getLogicalSwitchRef().getValue();
- Optional<LogicalSwitches> logicalSwitchOptional =
- MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, logicalSwitchRef);
+ Optional<LogicalSwitches> logicalSwitchOptional;
+ try {
+ logicalSwitchOptional = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.OPERATIONAL, logicalSwitchRef);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("add: Exception while reading LogicalSwitches DS for the TOR Node ID {}", torNodeId, e);
+ return;
+ }
if (!logicalSwitchOptional.isPresent()) {
LOG.error("Logical Switch ref doesn't have data {}", logicalSwitchRef);
return;
private LogicalSwitches getLogicalSwitches(LocalUcastMacs ucastMacs) {
InstanceIdentifier<LogicalSwitches> logicalSwitchRef =
(InstanceIdentifier<LogicalSwitches>)ucastMacs.getLogicalSwitchRef().getValue();
- return MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, logicalSwitchRef).orNull();
- }
-
- @Override
- protected DhcpUCastMacListener getDataTreeChangeListener() {
- return DhcpUCastMacListener.this;
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
+ logicalSwitchRef).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getLogicalSwitches: Exception while reading LogicalSwitches DS for ucastMacs {}", ucastMacs, e);
+ return null;
+ }
}
}
*/
package org.opendaylight.netvirt.dhcpservice;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.slf4j.LoggerFactory;
@Singleton
-public class NodeListener extends AsyncDataTreeChangeListenerBase<Node, NodeListener> {
+public class NodeListener extends AbstractAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(NodeListener.class);
@Inject
public NodeListener(final DataBroker db, final DhcpManager dhcpMgr,
final DhcpExternalTunnelManager dhcpExternalTunnelManager) {
- super(Node.class, NodeListener.class);
+ super(db, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class),
+ Executors.newListeningSingleThreadExecutor("NodeListener", LOG));
this.broker = db;
this.dhcpManager = dhcpMgr;
this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
this.txRunner = new ManagedNewTransactionRunnerImpl(db);
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected void remove(InstanceIdentifier<Node> identifier, Node del) {
+ public void remove(InstanceIdentifier<Node> identifier, Node del) {
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
}
@Override
- protected void add(InstanceIdentifier<Node> identifier, Node add) {
+ public void add(InstanceIdentifier<Node> identifier, Node add) {
NodeId nodeId = add.getId();
String[] node = nodeId.getValue().split(":");
if (node.length < 2) {
@PreDestroy
public void close() {
super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
LOG.debug("Node Listener Closed");
}
-
- @Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class);
- }
-
- @Override
- protected NodeListener getDataTreeChangeListener() {
- return NodeListener.this;
- }
}
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.netvirt.dhcpservice.DhcpServiceUtils;
-public class DhcpAllocationPoolAddJob implements Callable<List<ListenableFuture<Void>>> {
+public class DhcpAllocationPoolAddJob implements Callable<List<? extends ListenableFuture<?>>> {
private final ManagedNewTransactionRunner txRunner;
private final String interfaceName;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.netvirt.dhcpservice.DhcpServiceUtils;
-public class DhcpAllocationPoolRemoveJob implements Callable<List<ListenableFuture<Void>>> {
+public class DhcpAllocationPoolRemoveJob implements Callable<List<? extends ListenableFuture<?>>> {
private final ManagedNewTransactionRunner txRunner;
private final String interfaceName;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.DhcpExternalTunnelManager;
import org.opendaylight.netvirt.dhcpservice.DhcpManager;
import org.opendaylight.netvirt.dhcpservice.DhcpServiceUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DhcpInterfaceAddJob implements Callable<List<ListenableFuture<Void>>> {
+public class DhcpInterfaceAddJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpInterfaceAddJob.class);
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.DhcpExternalTunnelManager;
import org.opendaylight.netvirt.dhcpservice.DhcpManager;
import org.opendaylight.netvirt.dhcpservice.DhcpServiceUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DhcpInterfaceRemoveJob implements Callable<List<ListenableFuture<Void>>> {
+public class DhcpInterfaceRemoveJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpInterfaceRemoveJob.class);
InstanceIdentifier<InterfaceNameMacAddress> instanceIdentifier =
InstanceIdentifier.builder(InterfaceNameMacAddresses.class)
.child(InterfaceNameMacAddress.class, new InterfaceNameMacAddressKey(interfaceName)).build();
- return tx.read(instanceIdentifier).get().toJavaUtil().map(
+ return tx.read(instanceIdentifier).get().map(
interfaceNameMacAddress -> {
String vmMacAddress = interfaceNameMacAddress.getMacAddress();
LOG.trace("Entry for interface found in InterfaceNameVmMacAddress map {}, {}", interfaceName,
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.DhcpExternalTunnelManager;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DhcpInterfaceUpdateJob implements Callable<List<ListenableFuture<Void>>> {
+public class DhcpInterfaceUpdateJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(DhcpInterfaceUpdateJob.class);
private final DhcpExternalTunnelManager dhcpExternalTunnelManager;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="entityOwnershipService"
interface="org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService" />
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
return existingElanDpnInterfaces.getDpnInterfaces().stream().flatMap(v -> v.getInterfaces().stream())
.collect(Collectors.toList());
}
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read ElanDpnInterfacesList with error {}", e.getMessage());
}
return Collections.emptyList();
<artifactId>neutronvpn-api</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
- </dependency>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
<artifactId>hwvtepsouthbound-api</artifactId>
<version>${genius.version}</version>
<scope>test</scope>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<type>test-jar</type>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
*/
package org.opendaylight.netvirt.elan.cache;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elan.utils.Scheduler;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
return get(ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName));
} catch (ReadFailedException e) {
LOG.warn("Error reading ElanInstance {}", elanInstanceName, e);
- return Optional.absent();
+ return Optional.empty();
}
}
*/
package org.opendaylight.netvirt.elan.cache;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
return get(ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName));
} catch (ReadFailedException e) {
LOG.warn("Error reading ElanInterface {}", interfaceName, e);
- return Optional.absent();
+ return Optional.empty();
}
}
@NonNull
public Optional<EtreeInterface> getEtreeInterface(@NonNull String interfaceName) {
Optional<ElanInterface> elanInterface = get(interfaceName);
- return elanInterface.isPresent() ? Optional.fromNullable(
- elanInterface.get().augmentation(EtreeInterface.class)) : Optional.absent();
+ return elanInterface.isPresent() ? Optional.ofNullable(
+ elanInterface.get().augmentation(EtreeInterface.class)) : Optional.empty();
}
@NonNull
package org.opendaylight.netvirt.elan.cli.l2gw;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LogicalSwitchesCmd;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.MergeCommand;
verifyConfigVsOperationalDiff();
verifyL2GatewayConnections();
pw.close();
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
session.getConsole().println("Failed with error " + e.getMessage());
LOG.error("Failed with error ", e);
}
return null;
}
- private void readNodes() throws ReadFailedException {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ private void readNodes() throws ExecutionException, InterruptedException {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
InstanceIdentifier<Topology> topoId = HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier();
- Optional<Topology> operationalTopoOptional = tx.read(LogicalDatastoreType.OPERATIONAL, topoId).checkedGet();
- Optional<Topology> configTopoOptional = tx.read(LogicalDatastoreType.CONFIGURATION, topoId).checkedGet();
+ Optional<Topology> operationalTopoOptional = tx.read(LogicalDatastoreType.OPERATIONAL, topoId).get();
+ Optional<Topology> configTopoOptional = tx.read(LogicalDatastoreType.CONFIGURATION, topoId).get();
if (operationalTopoOptional.isPresent()) {
for (Node node : operationalTopoOptional.get().nonnullNode()) {
fillNodesData(configNodes, configNodesData);
Optional<ElanInstances> elanInstancesOptional = tx.read(LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.builder(ElanInstances.class).build()).checkedGet();
+ InstanceIdentifier.builder(ElanInstances.class).build()).get();
if (elanInstancesOptional.isPresent() && elanInstancesOptional.get().getElanInstance() != null) {
for (ElanInstance elanInstance : elanInstancesOptional.get().getElanInstance()) {
package org.opendaylight.netvirt.elan.cli.l2gw;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
protected Object doExecute() {
List<Node> nodes = new ArrayList<>();
Set<String> networks = new HashSet<>();
- if (nodeId == null) {
- Optional<Topology> topologyOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- createHwvtepTopologyInstanceIdentifier());
- if (topologyOptional.isPresent()) {
- nodes.addAll(topologyOptional.get().nonnullNode());
- }
- } else {
- Optional<Node> nodeOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- createInstanceIdentifier(new NodeId(new Uri(nodeId))));
- if (nodeOptional.isPresent()) {
- nodes.add(nodeOptional.get());
+ try {
+ if (nodeId == null) {
+ Optional<Topology> topologyOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, createHwvtepTopologyInstanceIdentifier());
+ if (topologyOptional.isPresent()) {
+ nodes.addAll(topologyOptional.get().nonnullNode());
+ }
+ } else {
+ Optional<Node> nodeOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, createInstanceIdentifier(new NodeId(new Uri(nodeId))));
+ if (nodeOptional.isPresent()) {
+ nodes.add(nodeOptional.get());
+ }
}
- }
- if (elanName == null) {
- //get all elan instance
- //get all device node id
- //print result
- Optional<ElanInstances> elanInstancesOptional = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.builder(ElanInstances.class).build());
- if (elanInstancesOptional.isPresent()) {
- List<ElanInstance> elans = elanInstancesOptional.get().getElanInstance();
- if (elans != null) {
- for (ElanInstance elan : elans) {
- networks.add(elan.getElanInstanceName());
+ if (elanName == null) {
+ //get all elan instance
+ //get all device node id
+ //print result
+ Optional<ElanInstances> elanInstancesOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.builder(ElanInstances.class).build());
+ if (elanInstancesOptional.isPresent()) {
+ List<ElanInstance> elans = elanInstancesOptional.get().getElanInstance();
+ if (elans != null) {
+ for (ElanInstance elan : elans) {
+ networks.add(elan.getElanInstanceName());
+ }
}
}
+ } else {
+ networks.add(elanName);
}
- } else {
- networks.add(elanName);
- }
- if (nodes != null) {
- for (Node node : nodes) {
- if (node.getNodeId().getValue().contains("physicalswitch")) {
- continue;
- }
- Node hwvtepConfigNode =
- HwvtepUtils.getHwVtepNode(dataBroker, LogicalDatastoreType.CONFIGURATION, node.getNodeId());
- Node hwvtepOpPsNode = getPSnode(node, LogicalDatastoreType.OPERATIONAL);
- Node hwvtepConfigPsNode = null;
- if (hwvtepOpPsNode != null) {
- hwvtepConfigPsNode = HwvtepUtils.getHwVtepNode(dataBroker, LogicalDatastoreType.CONFIGURATION,
- hwvtepOpPsNode.getNodeId());
- opPSNodes.put(node.getNodeId(), hwvtepOpPsNode);
- }
- opNodes.put(node.getNodeId(), node);
- configNodes.put(node.getNodeId(), hwvtepConfigNode);
-
- if (hwvtepConfigPsNode != null) {
- configPSNodes.put(node.getNodeId(), hwvtepConfigPsNode);
- }
- }
- }
- if (!networks.isEmpty()) {
- for (String network : networks) {
- session.getConsole().println("Network info for " + network);
+ if (nodes != null) {
for (Node node : nodes) {
if (node.getNodeId().getValue().contains("physicalswitch")) {
continue;
}
- session.getConsole().println("Printing for node " + node.getNodeId().getValue());
- process(node.getNodeId(), network);
+ Node hwvtepConfigNode =
+ HwvtepUtils.getHwVtepNode(dataBroker, LogicalDatastoreType.CONFIGURATION, node.getNodeId());
+ Node hwvtepOpPsNode = getPSnode(node, LogicalDatastoreType.OPERATIONAL);
+ Node hwvtepConfigPsNode = null;
+ if (hwvtepOpPsNode != null) {
+ hwvtepConfigPsNode = HwvtepUtils.getHwVtepNode(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ hwvtepOpPsNode.getNodeId());
+ opPSNodes.put(node.getNodeId(), hwvtepOpPsNode);
+ }
+ opNodes.put(node.getNodeId(), node);
+ configNodes.put(node.getNodeId(), hwvtepConfigNode);
+
+ if (hwvtepConfigPsNode != null) {
+ configPSNodes.put(node.getNodeId(), hwvtepConfigPsNode);
+ }
+ }
+ }
+ if (!networks.isEmpty()) {
+ for (String network : networks) {
+ session.getConsole().println("Network info for " + network);
+ for (Node node : nodes) {
+ if (node.getNodeId().getValue().contains("physicalswitch")) {
+ continue;
+ }
+ session.getConsole().println("Printing for node " + node.getNodeId().getValue());
+ process(node.getNodeId(), network);
+ }
}
}
+ } catch (ExecutionException | InterruptedException e) {
+ session.getConsole().println("Failed with error " + e.getMessage());
}
return null;
}
}
@Nullable
- Node getPSnode(Node hwvtepNode, LogicalDatastoreType datastoreType) {
+ Node getPSnode(Node hwvtepNode, LogicalDatastoreType datastoreType) throws ExecutionException,
+ InterruptedException {
if (hwvtepNode.augmentation(HwvtepGlobalAugmentation.class) != null) {
List<Switches> switches = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class).getSwitches();
if (switches != null) {
package org.opendaylight.netvirt.elan.evpn.listeners;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.evpn.utils.EvpnUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanForwardingTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.forwarding.tables.MacTable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanMacEntryListener extends AsyncDataTreeChangeListenerBase<MacEntry, ElanMacEntryListener> {
+public class ElanMacEntryListener extends AbstractAsyncDataTreeChangeListener<MacEntry> {
private static final Logger LOG = LoggerFactory.getLogger(ElanMacEntryListener.class);
private final DataBroker broker;
@Inject
public ElanMacEntryListener(final DataBroker broker, final EvpnUtils evpnUtils,
final ElanInstanceCache elanInstanceCache) {
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanForwardingTables.class)
+ .child(MacTable.class).child(MacEntry.class),
+ Executors.newListeningSingleThreadExecutor("ElanMacEntryListener", LOG));
this.broker = broker;
this.evpnUtils = evpnUtils;
this.elanInstanceCache = elanInstanceCache;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
- }
-
- @Override
- // Confusing with CacheElanInstanceListener.getWildcardPath but this method is implemented from an interface.
- @SuppressFBWarnings("NM_CONFUSING")
- protected InstanceIdentifier<MacEntry> getWildCardPath() {
- return InstanceIdentifier.builder(ElanForwardingTables.class)
- .child(MacTable.class).child(MacEntry.class).build();
- }
-
- @Override
- protected ElanMacEntryListener getDataTreeChangeListener() {
- return ElanMacEntryListener.this;
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected void add(InstanceIdentifier<MacEntry> instanceIdentifier, MacEntry macEntry) {
+ public void add(InstanceIdentifier<MacEntry> instanceIdentifier, MacEntry macEntry) {
LOG.info("ElanMacEntryListener : ADD macEntry {} ", instanceIdentifier);
String elanName = instanceIdentifier.firstKeyOf(MacTable.class).getElanInstanceName();
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
if (EvpnUtils.getEvpnNameFromElan(elanInfo) == null) {
LOG.trace("ElanMacEntryListener : Add evpnName is null for elan {} ", elanInfo);
return;
}
@Override
- protected void remove(InstanceIdentifier<MacEntry> instanceIdentifier, MacEntry macEntry) {
+ public void remove(InstanceIdentifier<MacEntry> instanceIdentifier, MacEntry macEntry) {
LOG.info("ElanMacEntryListener : remove macEntry {} ", instanceIdentifier);
String elanName = instanceIdentifier.firstKeyOf(MacTable.class).getElanInstanceName();
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
if (EvpnUtils.getEvpnNameFromElan(elanInfo) == null) {
LOG.trace("ElanMacEntryListener : Remove evpnName is null for elan {} ", elanInfo);
return;
}
@Override
- protected void update(InstanceIdentifier<MacEntry> instanceIdentifier, MacEntry macEntry, MacEntry t1) {
+ public void update(InstanceIdentifier<MacEntry> instanceIdentifier, MacEntry macEntry, MacEntry t1) {
+ }
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.evpn.utils.EvpnMacVrfUtils;
import org.opendaylight.netvirt.elan.evpn.utils.EvpnUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.EvpnAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
@Singleton
-public class EvpnElanInstanceListener extends AsyncDataTreeChangeListenerBase<ElanInstance, EvpnElanInstanceListener> {
+public class EvpnElanInstanceListener extends AbstractAsyncDataTreeChangeListener<ElanInstance> {
private static final Logger LOG = LoggerFactory.getLogger(EvpnElanInstanceListener.class);
private final DataBroker broker;
private final ManagedNewTransactionRunner txRunner;
@Inject
public EvpnElanInstanceListener(final DataBroker dataBroker, final EvpnUtils evpnUtils,
EvpnMacVrfUtils evpnMacVrfUtils, IMdsalApiManager mdsalApiManager) {
- super(ElanInstance.class, EvpnElanInstanceListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ElanInstances.class)
+ .child(ElanInstance.class),
+ Executors.newListeningSingleThreadExecutor("EvpnElanInstanceListener", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.evpnUtils = evpnUtils;
this.mdsalManager = mdsalApiManager;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<ElanInstance> getWildCardPath() {
- return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class).build();
+ public void add(InstanceIdentifier<ElanInstance> instanceIdentifier, ElanInstance evpnAugmentation) {
}
@Override
- protected void add(InstanceIdentifier<ElanInstance> instanceIdentifier, ElanInstance evpnAugmentation) {
+ public void remove(InstanceIdentifier<ElanInstance> instanceIdentifier, ElanInstance evpnAugmentation) {
}
@Override
- protected void remove(InstanceIdentifier<ElanInstance> instanceIdentifier, ElanInstance evpnAugmentation) {
- }
-
- @Override
- protected void update(InstanceIdentifier<ElanInstance> instanceIdentifier, ElanInstance original,
+ public void update(InstanceIdentifier<ElanInstance> instanceIdentifier, ElanInstance original,
ElanInstance update) {
String elanName = update.getElanInstanceName();
LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, confTx -> {
}
@Override
- protected EvpnElanInstanceListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
-
}
package org.opendaylight.netvirt.elan.evpn.listeners;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.evpn.utils.EvpnMacVrfUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.macvrfentries.MacVrfEntry;
* received dest MAC in all the DPN's (with this network footprint).
*/
@Singleton
-public class MacVrfEntryListener extends AsyncDataTreeChangeListenerBase<MacVrfEntry, MacVrfEntryListener> {
+public class MacVrfEntryListener extends AbstractAsyncDataTreeChangeListener<MacVrfEntry> {
private static final Logger LOG = LoggerFactory.getLogger(MacVrfEntryListener.class);
private final DataBroker broker;
private final EvpnMacVrfUtils evpnMacVrfUtils;
@Inject
public MacVrfEntryListener(final DataBroker broker, final EvpnMacVrfUtils evpnMacVrfUtils) {
+ super(broker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(FibEntries.class)
+ .child(VrfTables.class).child(MacVrfEntry.class),
+ Executors.newListeningSingleThreadExecutor("MacVrfEntryListener", LOG));
this.broker = broker;
this.evpnMacVrfUtils = evpnMacVrfUtils;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
- }
-
- @Override
- protected InstanceIdentifier<MacVrfEntry> getWildCardPath() {
- return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(MacVrfEntry.class);
- }
-
- @Override
- protected MacVrfEntryListener getDataTreeChangeListener() {
- return MacVrfEntryListener.this;
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected void add(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry) {
+ public void add(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry) {
LOG.info("ADD: Adding DMAC Entry for MACVrfEntry {} ", macVrfEntry);
evpnMacVrfUtils.addEvpnDmacFlow(instanceIdentifier, macVrfEntry);
}
@Override
- protected void update(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry, MacVrfEntry t1) {
+ public void update(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry, MacVrfEntry t1) {
}
@Override
- protected void remove(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry) {
+ public void remove(InstanceIdentifier<MacVrfEntry> instanceIdentifier, MacVrfEntry macVrfEntry) {
LOG.info("REMOVE: Removing DMAC Entry for MACVrfEntry {} ", macVrfEntry);
evpnMacVrfUtils.removeEvpnDmacFlow(instanceIdentifier, macVrfEntry);
}
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
}
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanEtreeUtils;
import org.opendaylight.netvirt.elan.utils.ElanItmUtils;
*/
package org.opendaylight.netvirt.elan.evpn.utils;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
if (elanName == null) {
LOG.error("getElanTag: elanName is NULL for iid = {}", macVrfEntryIid);
}
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
if (elanInstance == null) {
return null;
}
}
public String getElanNameByMacvrfiid(InstanceIdentifier<MacVrfEntry> instanceIdentifier) {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
String rd = instanceIdentifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
String elanName = null;
InstanceIdentifier<EvpnRdToNetwork> iidEvpnRdToNet =
new EvpnRdToNetworkKey(rd)).build();
try {
Optional<EvpnRdToNetwork> evpnRdToNetwork =
- tx.read(LogicalDatastoreType.CONFIGURATION, iidEvpnRdToNet).checkedGet();
+ tx.read(LogicalDatastoreType.CONFIGURATION, iidEvpnRdToNet).get();
if (evpnRdToNetwork.isPresent()) {
elanName = evpnRdToNetwork.get().getNetworkId();
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getElanName: unable to read elanName, exception ", e);
}
return elanName;
}
public boolean checkEvpnAttachedToNet(String elanName) {
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
String evpnName = EvpnUtils.getEvpnNameFromElan(elanInfo);
if (evpnName == null) {
LOG.error("Error : evpnName is null for elanName {}", elanName);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.function.BiConsumer;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-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.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.utils.SettableFutureCallback;
return;
}
String rd = vpnManager.getVpnRd(broker, evpnName);
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
macEntries.stream().filter(isIpv4PrefixAvailable).forEach(macEntry -> {
InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(macEntry.getInterface());
if (interfaceInfo == null) {
if (l3VpName != null) {
VpnInstance l3VpnInstance = vpnManager.getVpnInstance(broker, l3VpName);
l3vni = l3VpnInstance.getL3vni();
- com.google.common.base.Optional<String> gatewayMac = getGatewayMacAddressForInterface(l3VpName,
+ Optional<String> gatewayMac = getGatewayMacAddressForInterface(l3VpName,
interfaceName, prefix);
gatewayMacAddr = gatewayMac.isPresent() ? gatewayMac.get() : null;
ExternalTunnelList externalTunnelList = null;
try {
externalTunnelList = elanUtils.read2(LogicalDatastoreType.CONFIGURATION,
- externalTunnelListId).orNull();
- } catch (ReadFailedException e) {
+ externalTunnelListId).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getExternalTunnelList: unable to read ExternalTunnelList, exception ", e);
}
- return Optional.fromNullable(externalTunnelList);
+ return Optional.ofNullable(externalTunnelList);
}
public static InstanceIdentifier<DcGatewayIpList> getDcGatewayIpListIdentifier() {
DcGatewayIpList dcGatewayIpListConfig = null;
try {
dcGatewayIpListConfig = elanUtils.read2(LogicalDatastoreType.CONFIGURATION,
- dcGatewayIpListInstanceIdentifier).orNull();
- } catch (ReadFailedException e) {
+ dcGatewayIpListInstanceIdentifier).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getDcGatewayTunnelInterfaceNameList: unable to read DcGatewayTunnelList, exception ", e);
}
- return Optional.fromNullable(dcGatewayIpListConfig);
+ return Optional.ofNullable(dcGatewayIpListConfig);
}
public List<String> getDcGatewayTunnelInterfaceNameList() {
Uint32 elanTag = elanInfo.getElanTag();
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchTunnelId(Uint64.valueOf(ElanUtils.getVxlanSegmentationId(elanInfo).longValue())));
- NWUtil.getOperativeDPNs(broker).forEach(dpnId -> {
- LOG.debug("Updating tunnel flow to dpnid {}", dpnId);
- List<InstructionInfo> instructions = getInstructionsForExtTunnelTable(elanTag);
- String flowRef = getFlowRef(NwConstants.L2VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, elanTag.longValue(), dpnId);
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(
- dpnId,
- NwConstants.L2VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
- flowRef,
- 5, // prio
- elanInfo.getElanInstanceName(), // flowName
- 0, // idleTimeout
- 0, // hardTimeout
- Uint64.valueOf(ITMConstants.COOKIE_ITM_EXTERNAL.longValue() + elanTag.longValue()),
- mkMatches,
- instructions);
- flowHandler.accept(dpnId, flowEntity);
- });
+ try {
+ NWUtil.getOperativeDPNs(broker).forEach(dpnId -> {
+ LOG.debug("Updating tunnel flow to dpnid {}", dpnId);
+ List<InstructionInfo> instructions = getInstructionsForExtTunnelTable(elanTag);
+ String flowRef = getFlowRef(NwConstants.L2VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, elanTag.longValue(), dpnId);
+ FlowEntity flowEntity = MDSALUtil.buildFlowEntity(
+ dpnId,
+ NwConstants.L2VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
+ flowRef,
+ 5, // prio
+ elanInfo.getElanInstanceName(), // flowName
+ 0, // idleTimeout
+ 0, // hardTimeout
+ Uint64.valueOf(ITMConstants.COOKIE_ITM_EXTERNAL.longValue() + elanTag.longValue()),
+ mkMatches,
+ instructions);
+ flowHandler.accept(dpnId, flowEntity);
+ });
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("programEvpnL2vniFlow: Exception while programming Evpn L2vni flow for elanInstance {}",
+ elanInfo, e);
+ }
}
public void programEvpnL2vniDemuxTable(String elanName, final BiConsumer<String, String> serviceHandler,
BiConsumer<Uint64, FlowEntity> flowHandler) {
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
List<String> tunnelInterfaceNameList = getDcGatewayTunnelInterfaceNameList();
if (tunnelInterfaceNameList.isEmpty()) {
LOG.info("No DC gateways tunnels while programming l2vni table for elan {}.", elanName);
SettableFuture<Optional<T>> settableFuture = SettableFuture.create();
List futures = Collections.singletonList(settableFuture);
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
Futures.addCallback(tx.read(datastoreType, iid),
new SettableFutureCallback<Optional<T>>(settableFuture) {
@Override
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
import static java.util.Collections.emptyList;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.cache.ElanInstanceDpnsCache;
import org.opendaylight.netvirt.elan.l2gw.jobs.BcGroupUpdateJob;
import org.opendaylight.netvirt.elan.utils.ElanDmacUtils;
import org.opendaylight.netvirt.elan.utils.ElanItmUtils;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
@Singleton
public class ElanDpnInterfaceClusteredListener
- extends AsyncClusteredDataTreeChangeListenerBase<DpnInterfaces, ElanDpnInterfaceClusteredListener> {
+ extends AbstractClusteredAsyncDataTreeChangeListener<DpnInterfaces> {
private static final Logger LOG = LoggerFactory.getLogger(ElanDpnInterfaceClusteredListener.class);
private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("NetvirtEventLogger");
ElanInstanceDpnsCache elanInstanceDpnsCache,
ElanRefUtil elanRefUtil, ElanDmacUtils elanDmacUtils,
ElanItmUtils elanItmUtils) {
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanDpnInterfaces.class)
+ .child(ElanDpnInterfacesList.class).child(DpnInterfaces.class),
+ Executors.newListeningSingleThreadExecutor("ElanDpnInterfaceClusteredListener", LOG));
this.broker = broker;
this.entityOwnershipUtils = entityOwnershipUtils;
this.elanL2GatewayUtils = elanL2GatewayUtils;
this.elanInstanceDpnsCache = elanInstanceDpnsCache;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, this.broker);
- }
-
- @Override
- public InstanceIdentifier<DpnInterfaces> getWildCardPath() {
- return InstanceIdentifier.builder(ElanDpnInterfaces.class).child(ElanDpnInterfacesList.class)
- .child(DpnInterfaces.class).build();
+ LOG.info("{} start", getClass().getSimpleName());
}
void handleUpdate(InstanceIdentifier<DpnInterfaces> id, DpnInterfaces dpnInterfaces) {
}
@Override
- protected void remove(InstanceIdentifier<DpnInterfaces> identifier, final DpnInterfaces dpnInterfaces) {
+ public void remove(InstanceIdentifier<DpnInterfaces> identifier, final DpnInterfaces dpnInterfaces) {
// this is the last dpn interface on this elan
final String elanName = getElanName(identifier);
//Cache need to be updated in all cluster nodes and not only by leader node .
}
@Override
- protected void update(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces original,
+ public void update(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces original,
final DpnInterfaces dpnInterfaces) {
List<String> interfaces = dpnInterfaces.getInterfaces();
if (interfaces != null && !interfaces.isEmpty()) {
elanInstanceDpnsCache.add(getElanName(identifier), dpnInterfaces);
if (entityOwnershipUtils.isEntityOwner(HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
HwvtepSouthboundConstants.ELAN_ENTITY_NAME)) {
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
if (elanInstance != null) {
BcGroupUpdateJob.updateAllBcGroups(elanName, elanRefUtil, elanL2GatewayMulticastUtils,
broker, true);
}
@Override
- protected ElanDpnInterfaceClusteredListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
-
}
import static java.util.Collections.emptyList;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
@Singleton
public class ElanDpnInterfacesListener
- extends AsyncDataTreeChangeListenerBase<DpnInterfaces, ElanDpnInterfacesListener> {
+ extends AbstractAsyncDataTreeChangeListener<DpnInterfaces> {
private static final Logger LOG = LoggerFactory.getLogger(ElanDpnInterfacesListener.class);
private final DataBroker dataBroker;
public ElanDpnInterfacesListener(final DataBroker dataBroker, final IInterfaceManager interfaceManager,
final ElanServiceProvider elanService, final JobCoordinator jobCoordinator,
final ElanInstanceCache elanInstanceCache) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanDpnInterfaces.class)
+ .child(ElanDpnInterfacesList.class).child(DpnInterfaces.class),
+ Executors.newListeningSingleThreadExecutor("ElanDpnInterfacesListener", LOG));
this.dataBroker = dataBroker;
this.interfaceManager = interfaceManager;
this.elanService = elanService;
this.elanInstanceCache = elanInstanceCache;
}
- @PostConstruct
public void start() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- public InstanceIdentifier<DpnInterfaces> getWildCardPath() {
- return InstanceIdentifier.builder(ElanDpnInterfaces.class).child(ElanDpnInterfacesList.class)
- .child(DpnInterfaces.class).build();
- }
-
- @Override
- protected void remove(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
+ public void remove(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
}
@Override
- protected void update(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces original,
+ public void update(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces original,
DpnInterfaces update) {
LOG.debug("received Dpninterfaces update event for dpn {}", update.getDpId());
Uint64 dpnId = update.getDpId();
String elanInstanceName = identifier.firstKeyOf(ElanDpnInterfacesList.class).getElanInstanceName();
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance != null && !elanInstance.isExternal() && ElanUtils.isVlan(elanInstance)) {
List<String> interfaces = update.getInterfaces();
}
@Override
- protected void add(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
+ public void add(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
LOG.debug("received Dpninterfaces add event for dpn {}", dpnInterfaces.getDpId());
Uint64 dpnId = dpnInterfaces.getDpId();
String elanInstanceName = identifier.firstKeyOf(ElanDpnInterfacesList.class).getElanInstanceName();
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
// trigger creation of vlan provider intf for the vlan provider network
// on br-int patch port for this DPN
}
@Override
- protected ElanDpnInterfacesListener getDataTreeChangeListener() {
- return ElanDpnInterfacesListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
*/
package org.opendaylight.netvirt.elan.internal;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.elan.utils.TransportZoneNotificationUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
@Singleton
public class ElanDpnToTransportZoneListener
- extends AsyncDataTreeChangeListenerBase<DpnInterfaces, ElanDpnToTransportZoneListener> {
+ extends AbstractAsyncDataTreeChangeListener<DpnInterfaces> {
private static final Logger LOG = LoggerFactory.getLogger(ElanDpnToTransportZoneListener.class);
private final TransportZoneNotificationUtil transportZoneNotificationUtil;
public ElanDpnToTransportZoneListener(final DataBroker dbx,
final ElanConfig elanConfig, final TransportZoneNotificationUtil tznu,
final ElanInstanceCache elanInstanceCache) {
+ super(dbx, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanDpnInterfaces.class)
+ .child(ElanDpnInterfacesList.class).child(DpnInterfaces.class),
+ Executors.newListeningSingleThreadExecutor("ElanDpnToTransportZoneListener", LOG));
useTransportZone = elanConfig.isAutoConfigTransportZones();
transportZoneNotificationUtil = tznu;
this.dbx = dbx;
this.elanInstanceCache = elanInstanceCache;
+ start();
}
- @PostConstruct
public void start() {
-
if (useTransportZone) {
- registerListener(LogicalDatastoreType.OPERATIONAL, dbx);
LOG.info("{} registered", getClass().getSimpleName());
}
}
@Override
- public InstanceIdentifier<DpnInterfaces> getWildCardPath() {
- return InstanceIdentifier.builder(ElanDpnInterfaces.class).child(ElanDpnInterfacesList.class)
- .child(DpnInterfaces.class).build();
- }
-
- @Override
- protected void remove(InstanceIdentifier<DpnInterfaces> key, DpnInterfaces dataObjectModification) {
+ public void remove(InstanceIdentifier<DpnInterfaces> key, DpnInterfaces dataObjectModification) {
+ //Proceed only if "auto-config-transport-zones = TRUE"
+ if (!useTransportZone) {
+ return;
+ }
LOG.debug("Elan dpn {} delete detected, deleting transport zones", dataObjectModification.getDpId());
Uint64 dpId = dataObjectModification.getDpId();
String elanInstanceName = key.firstKeyOf(ElanDpnInterfacesList.class).getElanInstanceName();
- if (!ElanUtils.isVxlanNetworkOrVxlanSegment(elanInstanceCache.get(elanInstanceName).orNull())) {
+ if (!ElanUtils.isVxlanNetworkOrVxlanSegment(elanInstanceCache.get(elanInstanceName).orElse(null))) {
LOG.debug("ElanInstance {} is not vxlan network, nothing to do", elanInstanceName);
return;
}
}
@Override
- protected void update(InstanceIdentifier<DpnInterfaces> key, DpnInterfaces dataObjectModificationBefore,
+ public void update(InstanceIdentifier<DpnInterfaces> key, DpnInterfaces dataObjectModificationBefore,
DpnInterfaces dataObjectModificationAfter) {
}
@Override
- protected void add(InstanceIdentifier<DpnInterfaces> key, DpnInterfaces dataObjectModification) {
+ public void add(InstanceIdentifier<DpnInterfaces> key, DpnInterfaces dataObjectModification) {
+ //Proceed only if "auto-config-transport-zones = TRUE"
+ if (!useTransportZone) {
+ return;
+ }
LOG.debug("Elan dpn {} add detected, updating transport zones", dataObjectModification.getDpId());
Uint64 dpId = dataObjectModification.getDpId();
String elanInstanceName = key.firstKeyOf(ElanDpnInterfacesList.class).getElanInstanceName();
- if (!ElanUtils.isVxlanNetworkOrVxlanSegment(elanInstanceCache.get(elanInstanceName).orNull())) {
+ if (!ElanUtils.isVxlanNetworkOrVxlanSegment(elanInstanceCache.get(elanInstanceName).orElse(null))) {
return;
}
}
@Override
- protected ElanDpnToTransportZoneListener getDataTreeChangeListener() {
- return ElanDpnToTransportZoneListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTeps;
@Singleton
public class ElanExtnTepConfigListener
- extends AsyncDataTreeChangeListenerBase<ExternalTeps, ElanExtnTepConfigListener> {
+ extends AbstractAsyncDataTreeChangeListener<ExternalTeps> {
private static final Logger LOG = LoggerFactory.getLogger(ElanExtnTepConfigListener.class);
@Inject
public ElanExtnTepConfigListener(DataBroker dataBroker) {
- super(ExternalTeps.class, ElanExtnTepConfigListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ElanInstances.class)
+ .child(ElanInstance.class).child(ExternalTeps.class),
+ Executors.newListeningSingleThreadExecutor("ElanExtnTepConfigListener", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
- }
-
- @Override
- public InstanceIdentifier<ExternalTeps> getWildCardPath() {
- return InstanceIdentifier
- .builder(ElanInstances.class)
- .child(ElanInstance.class)
- .child(ExternalTeps.class).build();
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
- protected void add(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep) {
+ public void add(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep) {
LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
tx.put(iid, tep, true);
}), LOG, "Failed to update operational external teps {}", iid);
}
@Override
- protected void update(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep, ExternalTeps t1) {
+ public void update(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep, ExternalTeps t1) {
}
@Override
- protected void remove(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep) {
+ public void remove(InstanceIdentifier<ExternalTeps> iid, ExternalTeps tep) {
LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
tx.delete(iid);
}), LOG, "Failed to update operational external teps {}", iid);
}
@Override
- protected ElanExtnTepConfigListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
*/
package org.opendaylight.netvirt.elan.internal;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.jobs.BcGroupUpdateJob;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanRefUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTeps;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanExtnTepListener extends AsyncClusteredDataTreeChangeListenerBase<ExternalTeps, ElanExtnTepListener> {
+public class ElanExtnTepListener extends AbstractClusteredAsyncDataTreeChangeListener<ExternalTeps> {
private static final Logger LOG = LoggerFactory.getLogger(ElanExtnTepListener.class);
@Inject
public ElanExtnTepListener(DataBroker dataBroker, ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils,
JobCoordinator jobCoordinator, ElanInstanceCache elanInstanceCache, ElanRefUtil elanRefUtil) {
- super(ExternalTeps.class, ElanExtnTepListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanInstances.class)
+ .child(ElanInstance.class).child(ExternalTeps.class),
+ Executors.newListeningSingleThreadExecutor("ElanExtnTepListener", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.elanRefUtil = elanRefUtil;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
- public InstanceIdentifier<ExternalTeps> getWildCardPath() {
- return InstanceIdentifier.create(ElanInstances.class).child(ElanInstance.class).child(ExternalTeps.class);
- }
-
- @Override
- protected void add(InstanceIdentifier<ExternalTeps> instanceIdentifier, ExternalTeps tep) {
+ public void add(InstanceIdentifier<ExternalTeps> instanceIdentifier, ExternalTeps tep) {
LOG.trace("ExternalTeps add received {}", instanceIdentifier);
updateBcGroupOfElan(instanceIdentifier, tep, true);
}
@Override
- protected void update(InstanceIdentifier<ExternalTeps> instanceIdentifier, ExternalTeps tep, ExternalTeps t1) {
+ public void update(InstanceIdentifier<ExternalTeps> instanceIdentifier, ExternalTeps tep, ExternalTeps t1) {
}
@Override
- protected void remove(InstanceIdentifier<ExternalTeps> instanceIdentifier, ExternalTeps tep) {
+ public void remove(InstanceIdentifier<ExternalTeps> instanceIdentifier, ExternalTeps tep) {
LOG.trace("ExternalTeps remove received {}", instanceIdentifier);
updateBcGroupOfElan(instanceIdentifier, tep, false);
}
}
@Override
- protected ElanExtnTepListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
package org.opendaylight.netvirt.elan.internal;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
-
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.utils.Scheduler;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanGroupCache extends AsyncClusteredDataTreeChangeListenerBase<Group, ElanGroupCache> {
+public class ElanGroupCache extends AbstractClusteredAsyncDataTreeChangeListener<Group> {
private static final Logger LOG = LoggerFactory.getLogger(ElanGroupCache.class);
private final DataBroker dataBroker;
private final Scheduler scheduler;
@Inject
public ElanGroupCache(final DataBroker dataBroker, final Scheduler scheduler) {
- super(Group.class, ElanGroupCache.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class).augmentation(FlowCapableNode.class).child(Group.class),
+ Executors.newListeningSingleThreadExecutor("ElanGroupCache", LOG));
this.dataBroker = dataBroker;
this.scheduler = scheduler;
}
- @PostConstruct
public synchronized void init() {
- this.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Group> getWildCardPath() {
- return InstanceIdentifier.builder(Nodes.class)
- .child(Node.class).augmentation(FlowCapableNode.class)
- .child(Group.class).build();
+ LOG.info("{} registered", getClass().getSimpleName());
}
public synchronized void addJobToWaitList(InstanceIdentifier<Group> key,
}
@Override
- protected ElanGroupCache getDataTreeChangeListener() {
- return ElanGroupCache.this;
- }
-
- @Override
- protected synchronized void remove(InstanceIdentifier<Group> key, Group deleted) {
+ public synchronized void remove(InstanceIdentifier<Group> key, Group deleted) {
groupsById.remove(key);
}
@Override
- protected void update(InstanceIdentifier<Group> key, Group old, Group updated) {
+ public void update(InstanceIdentifier<Group> key, Group old, Group updated) {
add(key, updated);
}
@Override
- protected synchronized void add(InstanceIdentifier<Group> key, Group added) {
+ public synchronized void add(InstanceIdentifier<Group> key, Group added) {
if (groupsById.containsKey(key)) {
groupsById.put(key, added);
return;
}, ElanInterfaceManager.WAIT_TIME_FOR_SYNC_INSTALL, TimeUnit.MILLISECONDS);
}
- public Optional<Group> getGroup(InstanceIdentifier<Group> key) throws ReadFailedException {
+ public Optional<Group> getGroup(InstanceIdentifier<Group> key) throws InterruptedException, ExecutionException {
if (groupsById.containsKey(key)) {
return Optional.of(groupsById.get(key));
}
- ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<Group> optional = transaction.read(LogicalDatastoreType.CONFIGURATION, key).checkedGet();
+ ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
+ Optional<Group> optional = transaction.read(LogicalDatastoreType.CONFIGURATION, key).get();
transaction.close();
return optional;
}
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
+
}
import java.util.ArrayList;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInterfaceCache;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanInstanceManager extends AsyncDataTreeChangeListenerBase<ElanInstance, ElanInstanceManager> {
+public class ElanInstanceManager extends AbstractAsyncDataTreeChangeListener<ElanInstance> {
private static final Logger LOG = LoggerFactory.getLogger(ElanInstanceManager.class);
private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("NetvirtEventLogger");
final ElanInterfaceManager elanInterfaceManager,
final IInterfaceManager interfaceManager, final JobCoordinator jobCoordinator,
final ElanInterfaceCache elanInterfaceCache) {
- super(ElanInstance.class, ElanInstanceManager.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ElanInstances.class)
+ .child(ElanInstance.class),
+ Executors.newListeningSingleThreadExecutor("ElanInstanceManager", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.idManager = managerService;
this.elanInterfaceCache = elanInterfaceCache;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
- protected void remove(InstanceIdentifier<ElanInstance> identifier, ElanInstance deletedElan) {
+ public void remove(InstanceIdentifier<ElanInstance> identifier, ElanInstance deletedElan) {
LOG.trace("Remove ElanInstance - Key: {}, value: {}", identifier, deletedElan);
String elanName = deletedElan.getElanInstanceName();
EVENT_LOGGER.debug("ELAN-Instance, REMOVE {}",elanName);
}
@Override
- protected void update(InstanceIdentifier<ElanInstance> identifier, ElanInstance original, ElanInstance update) {
+ public void update(InstanceIdentifier<ElanInstance> identifier, ElanInstance original, ElanInstance update) {
EVENT_LOGGER.debug("ELAN-Instance, UPDATE {}", original.getElanInstanceName());
Uint32 existingElanTag = original.getElanTag();
String elanName = update.getElanInstanceName();
}
@Override
- protected void add(InstanceIdentifier<ElanInstance> identifier, ElanInstance elanInstanceAdded) {
+ public void add(InstanceIdentifier<ElanInstance> identifier, ElanInstance elanInstanceAdded) {
LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operTx -> {
String elanInstanceName = elanInstanceAdded.getElanInstanceName();
EVENT_LOGGER.debug("ELAN-Instance, ADD {}", elanInstanceName);
}
@Override
- protected InstanceIdentifier<ElanInstance> getWildCardPath() {
- return InstanceIdentifier.create(ElanInstances.class).child(ElanInstance.class);
- }
-
- @Override
- protected ElanInstanceManager getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInterfaceCache;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
@Singleton
public class ElanInterfaceConfigListener
- extends AsyncDataTreeChangeListenerBase<Interface, ElanInterfaceConfigListener> {
+ extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(ElanInterfaceConfigListener.class);
@Inject
public ElanInterfaceConfigListener(DataBroker dataBroker, ElanInterfaceManager elanInterfaceManager,
JobCoordinator jobCoordinator, ElanInterfaceCache elanInterfaceCache) {
- super(Interface.class, ElanInterfaceConfigListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Interfaces.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("ElanInterfaceConfigListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.elanInterfaceManager = elanInterfaceManager;
this.elanInterfaceCache = elanInterfaceCache;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("ElanInterfaceConfigListener init");
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Interface> key, Interface intrf) {
+ public void remove(InstanceIdentifier<Interface> key, Interface intrf) {
// Sometimes elan service is not unbound on the interface when the user does nova delete followed
// by neutron port delete since interface config is deleted a bit later. so adding logic to
// unbind service for interface config removal.
}
@Override
- protected void update(InstanceIdentifier<Interface> key, Interface dataObjectModificationBefore,
+ public void update(InstanceIdentifier<Interface> key, Interface dataObjectModificationBefore,
Interface dataObjectModificationAfter) {
// Not required to handle this event
}
@Override
- protected void add(InstanceIdentifier<Interface> key, Interface dataObjectModification) {
+ public void add(InstanceIdentifier<Interface> key, Interface dataObjectModification) {
// Not required to handle this event
}
@Override
- protected ElanInterfaceConfigListener getDataTreeChangeListener() {
- return this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
-
}
package org.opendaylight.netvirt.elan.internal;
import static java.util.Collections.emptyList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.StringUtils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.infra.TransactionAdapter;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.cache.ElanInterfaceCache;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
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.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
* @see org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface
*/
@Singleton
-public class ElanInterfaceManager extends AsyncDataTreeChangeListenerBase<ElanInterface, ElanInterfaceManager>
+public class ElanInterfaceManager extends AbstractAsyncDataTreeChangeListener<ElanInterface>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(ElanInterfaceManager.class);
private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("NetvirtEventLogger");
final ElanServiceRecoveryHandler elanServiceRecoveryHandler,
ElanGroupCache elanGroupCache,
final ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(ElanInterface.class, ElanInterfaceManager.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ElanInterfaces.class)
+ .child(ElanInterface.class),
+ Executors.newListeningSingleThreadExecutor("ElanInterfaceManager", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.idManager = managerService;
serviceRecoveryRegistry.addRecoverableListener(elanServiceRecoveryHandler.buildServiceRegistryKey(), this);
}
- @Override
- @PostConstruct
public void init() {
- registerListener();
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
+ super.register();
+ LOG.info("Registering ElanInterfaceManager");
+ }
+
+ @Override
+ public void deregisterListener() {
+ super.close();
+ LOG.info("Deregistering ElanInterfaceManager");
}
@Override
- protected InstanceIdentifier<ElanInterface> getWildCardPath() {
- return InstanceIdentifier.create(ElanInterfaces.class).child(ElanInterface.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<ElanInterface> identifier, ElanInterface del) {
+ public void remove(InstanceIdentifier<ElanInterface> identifier, ElanInterface del) {
String interfaceName = del.getName();
String elanInstanceName = del.getElanInstanceName();
EVENT_LOGGER.debug("ELAN-Interface, REMOVE {} Instance {}", interfaceName, elanInstanceName);
unProcessedElanInterfaces.remove(elanInstanceName);
}
}
- ElanInstance elanInfo = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanInstanceName).orElse(null);
/*
* Handling in case the elan instance is deleted.If the Elan instance is
* deleted, there is no need to explicitly delete the elan interfaces
}
private void deleteElanInterfaceFromConfigDS(String interfaceName, TypedReadWriteTransaction<Configuration> tx)
- throws ReadFailedException {
+ throws ExecutionException, InterruptedException {
// removing the ElanInterface from the config data_store if interface is
// not present in Interface config DS
- if (interfaceManager.getInterfaceInfoFromConfigDataStore(TransactionAdapter.toReadWriteTransaction(tx),
- interfaceName) == null
- && elanInterfaceCache.get(interfaceName).isPresent()) {
+ InstanceIdentifier<ElanInterface> elanInterfaceId = ElanUtils
+ .getElanInterfaceConfigurationDataPathId(interfaceName);
+ FluentFuture<Optional<ElanInterface>> interfaceOptional = tx.read(elanInterfaceId);
+ if (!interfaceOptional.get().isPresent() && elanInterfaceCache.get(interfaceName).isPresent()) {
tx.delete(ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName));
}
}
* */
@SuppressWarnings("checkstyle:ForbidCertainMethod")
@Override
- protected void update(InstanceIdentifier<ElanInterface> identifier, ElanInterface original, ElanInterface update) {
+ public void update(InstanceIdentifier<ElanInterface> identifier, ElanInterface original, ElanInterface update) {
// updating the static-Mac Entries for the existing elanInterface
String elanName = update.getElanInstanceName();
String interfaceName = update.getName();
}
@Override
- protected void add(InstanceIdentifier<ElanInterface> identifier, ElanInterface elanInterfaceAdded) {
+ public void add(InstanceIdentifier<ElanInterface> identifier, ElanInterface elanInterfaceAdded) {
LOG.info("Init for ELAN interface Add {}", elanInterfaceAdded);
addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, operTx -> {
String elanInstanceName = elanInterfaceAdded.getElanInstanceName();
LOG.info("Interface {} is removed from Interface Oper DS due to port down ", interfaceName);
return;
}
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
// Add the ElanInstance in the Configuration data-store
MacEntry macEntry = new MacEntryBuilder().setMacAddress(physAddress).setInterface(interfaceName)
.withKey(new MacEntryKey(physAddress)).build();
elanForwardingEntriesHandler.deleteElanInterfaceForwardingEntries(
- elanInstanceCache.get(elanInstanceName).orNull(), interfaceInfo, macEntry);
+ elanInstanceCache.get(elanInstanceName).orElse(null), interfaceInfo, macEntry);
}
private boolean checkIfFirstInterface(String elanInterface, String elanInstanceName,
for (ElanDpnInterfacesList elanDpns : elanDpnIf) {
int cnt = 0;
String elanName = elanDpns.getElanInstanceName();
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
if (elanInfo == null) {
LOG.warn("ELAN Info is null for elanName {} that does exist in elanDpnInterfaceList, "
+ "skipping this ELAN for tunnel handling", elanName);
List<ElanDpnInterfacesList> elanDpnIf = dpnInterfaceLists.nonnullElanDpnInterfacesList();
for (ElanDpnInterfacesList elanDpns : elanDpnIf) {
String elanName = elanDpns.getElanInstanceName();
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
DpnInterfaces dpnInterfaces = elanUtils.getElanInterfaceInfoByElanDpn(elanName, dpId);
if (elanInfo == null || dpnInterfaces == null || dpnInterfaces.getInterfaces() == null
return mkMatches;
}
- @Override
- protected ElanInterfaceManager getDataTreeChangeListener() {
- return this;
- }
-
public void handleExternalInterfaceEvent(ElanInstance elanInstance, DpnInterfaces dpnInterfaces,
Uint64 dpId) {
LOG.debug("setting up remote BC group for elan {}", elanInstance.getPhysicalNetworkName());
*/
package org.opendaylight.netvirt.elan.internal;
-import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.cache.ElanInterfaceCache;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@Singleton
public class ElanInterfaceStateChangeListener
- extends AsyncDataTreeChangeListenerBase<Interface, ElanInterfaceStateChangeListener> {
+ extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(ElanInterfaceStateChangeListener.class);
public ElanInterfaceStateChangeListener(final DataBroker db, final ElanInterfaceManager ifManager,
final JobCoordinator jobCoordinator, final ElanInstanceCache elanInstanceCache,
final ElanInterfaceCache elanInterfaceCache) {
- super(Interface.class, ElanInterfaceStateChangeListener.class);
+ super(db, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("ElanInterfaceStateChangeListener", LOG));
broker = db;
elanInterfaceManager = ifManager;
this.jobCoordinator = jobCoordinator;
this.elanInterfaceCache = elanInterfaceCache;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} registered", getClass().getSimpleName());
+ }
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Interface> identifier, Interface delIf) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface delIf) {
if (!L2vlan.class.equals(delIf.getType())) {
return;
}
interfaceInfo.setInterfaceType(InterfaceInfo.InterfaceType.VLAN_INTERFACE);
interfaceInfo.setInterfaceTag(delIf.getIfIndex());
String elanInstanceName = elanInterface.get().getElanInstanceName();
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.debug("No Elan instance is available for the interface:{} ", interfaceName);
return;
}
@Override
- protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
+ public void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
}
@Override
- protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
if (!L2vlan.class.equals(intrf.getType())) {
return;
}
.getElanInterfaceConfigurationDataPathId(interfaceName);
elanInterfaceManager.add(elanInterfaceId, elanInterface.get());
}
-
- @Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
- }
-
-
- @Override
- protected ElanInterfaceStateChangeListener getDataTreeChangeListener() {
- return this;
- }
-
}
*/
package org.opendaylight.netvirt.elan.internal;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@Singleton
public class ElanInterfaceStateClusteredListener extends
- AsyncClusteredDataTreeChangeListenerBase<Interface, ElanInterfaceStateClusteredListener> {
+ AbstractClusteredAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(ElanInterfaceStateClusteredListener.class);
@Inject
public ElanInterfaceStateClusteredListener(DataBroker broker, ElanInterfaceManager elanInterfaceManager,
ElanUtils elanUtils, ElanClusterUtils elanClusterUtils) {
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("ElanInterfaceStateClusteredListener", LOG));
this.broker = broker;
this.elanInterfaceManager = elanInterfaceManager;
this.elanUtils = elanUtils;
this.elanClusterUtils = elanClusterUtils;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
- public InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Interface> identifier, Interface delIf) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface delIf) {
}
@Override
- protected void update(InstanceIdentifier<Interface> identifier, Interface original, final Interface update) {
+ public void update(InstanceIdentifier<Interface> identifier, Interface original, final Interface update) {
add(identifier, update);
}
@Override
- protected void add(InstanceIdentifier<Interface> identifier, final Interface intrf) {
+ public void add(InstanceIdentifier<Interface> identifier, final Interface intrf) {
if (intrf.getType() != null && intrf.getType().equals(Tunnel.class)) {
if (Interface.OperStatus.Up.equals(intrf.getOperStatus())) {
final String interfaceName = intrf.getName();
/* (non-Javadoc)
* @see org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase#getDataTreeChangeListener()
*/
- @Override
- protected ElanInterfaceStateClusteredListener getDataTreeChangeListener() {
- return this;
- }
-
}
* 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.netvirt.elan.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.cache.ElanInterfaceCache;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
@Singleton
public class ElanLearntVpnVipToPortListener extends
- AsyncDataTreeChangeListenerBase<LearntVpnVipToPort, ElanLearntVpnVipToPortListener> {
+ AbstractAsyncDataTreeChangeListener<LearntVpnVipToPort> {
private static final Logger LOG = LoggerFactory.getLogger(ElanLearntVpnVipToPortListener.class);
private final DataBroker broker;
private final ManagedNewTransactionRunner txRunner;
@Inject
public ElanLearntVpnVipToPortListener(DataBroker broker, IInterfaceManager interfaceManager, ElanUtils elanUtils,
JobCoordinator jobCoordinator, ElanInstanceCache elanInstanceCache, ElanInterfaceCache elanInterfaceCache) {
- super(LearntVpnVipToPort.class, ElanLearntVpnVipToPortListener.class);
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(LearntVpnVipToPortData.class)
+ .child(LearntVpnVipToPort.class),
+ Executors.newListeningSingleThreadExecutor("ElanLearntVpnVipToPortListener", LOG));
this.broker = broker;
this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
this.interfaceManager = interfaceManager;
this.elanInterfaceCache = elanInterfaceCache;
}
- @Override
- @PostConstruct
public void init() {
- /* ELAN will learn the MAC by itself using ElanPacketInHandler class.
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
- */
- }
+ LOG.info("{} registered", getClass().getSimpleName());
+
+ // ELAN will learn the MAC by itself using ElanPacketInHandler class.
+ //registerListener(LogicalDatastoreType.OPERATIONAL, broker);
- @Override
- protected InstanceIdentifier<LearntVpnVipToPort> getWildCardPath() {
- return InstanceIdentifier.create(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class);
}
@Override
- protected void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort dataObjectModification) {
+ public void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort dataObjectModification) {
String macAddress = dataObjectModification.getMacAddress();
String interfaceName = dataObjectModification.getPortName();
LOG.trace("Removing mac address {} from interface {} ", macAddress, interfaceName);
}
@Override
- protected void update(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort dataObjectModificationBefore,
+ public void update(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort dataObjectModificationBefore,
LearntVpnVipToPort dataObjectModificationAfter) {
}
@Override
- protected void add(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort dataObjectModification) {
+ public void add(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort dataObjectModification) {
String macAddress = dataObjectModification.getMacAddress();
String interfaceName = dataObjectModification.getPortName();
LOG.trace("Adding mac address {} to interface {} ", macAddress, interfaceName);
new StaticMacAddWorker(macAddress, interfaceName));
}
- @Override
- protected ElanLearntVpnVipToPortListener getDataTreeChangeListener() {
- return this;
- }
-
- private class StaticMacAddWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class StaticMacAddWorker implements Callable<List<? extends ListenableFuture<?>>> {
String macAddress;
String interfaceName;
InstanceIdentifier<MacEntry> elanMacEntryId =
ElanUtils.getMacEntryOperationalDataPath(elanName, physAddress);
interfaceTx.put(elanMacEntryId, macEntry);
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
elanUtils.setupMacFlows(elanInstance, interfaceManager.getInterfaceInfo(interfaceName), macTimeOut,
macAddress, true, flowTx);
}
}
- private class StaticMacRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class StaticMacRemoveWorker implements Callable<List<? extends ListenableFuture<?>>> {
String macAddress;
String interfaceName;
MacEntry macEntry = elanUtils.getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress);
InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
if (macEntry != null && interfaceInfo != null) {
- elanUtils.deleteMacFlows(elanInstanceCache.get(elanName).orNull(), interfaceInfo, macEntry, flowTx);
+ elanUtils.deleteMacFlows(elanInstanceCache.get(elanName).orElse(null), interfaceInfo, macEntry, flowTx);
interfaceTx.delete(
ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress));
interfaceTx.delete(
}
+*/
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchRegister;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderConstant;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderUtil;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanNodeListener extends AsyncDataTreeChangeListenerBase<Node, ElanNodeListener> {
+public class ElanNodeListener extends AbstractAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(ElanNodeListener.class);
private static final int LEARN_MATCH_REG4_VALUE = 1;
public ElanNodeListener(DataBroker dataBroker, IMdsalApiManager mdsalManager, ElanConfig elanConfig,
IdManagerService idManagerService, JobCoordinator jobCoordinator,
DataTreeEventCallbackRegistrar eventCallbacks) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class),
+ Executors.newListeningSingleThreadExecutor("ElanNodeListener", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.eventCallbacks = eventCallbacks;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} registered", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Node> identifier, Node del) {
+ public void remove(InstanceIdentifier<Node> identifier, Node del) {
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
}
@Override
- protected void add(InstanceIdentifier<Node> identifier, Node add) {
+ public void add(InstanceIdentifier<Node> identifier, Node add) {
NodeId nodeId = add.getId();
String[] node = nodeId.getValue().split(":");
if (node.length < 2) {
return String.valueOf(tableId);
}
- @Override
- protected ElanNodeListener getDataTreeChangeListener() {
- return ElanNodeListener.this;
- }
-
private void setupTableMissApResponderFlow(TypedWriteTransaction<Configuration> tx, final Uint64 dpnId) {
mdsalManager.addFlow(tx, ArpResponderUtil.getArpResponderTableMissFlow(dpnId));
}
*/
package org.opendaylight.netvirt.elan.internal;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.utils.TransportZoneNotificationUtil;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
* Listen for new OVSDB nodes and then make sure they have the necessary bridges configured.
*/
@Singleton
-public class ElanOvsdbNodeListener extends AsyncDataTreeChangeListenerBase<Node, ElanOvsdbNodeListener> {
+public class ElanOvsdbNodeListener extends AbstractAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(ElanOvsdbNodeListener.class);
private final DataBroker dataBroker;
private final ElanBridgeManager bridgeMgr;
public ElanOvsdbNodeListener(final DataBroker dataBroker, ElanConfig elanConfig,
final ElanBridgeManager bridgeMgr,
final IElanService elanProvider, final TransportZoneNotificationUtil tzUtil) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID)).child(Node.class),
+ Executors.newListeningSingleThreadExecutor("ElanOvsdbNodeListener", LOG));
this.dataBroker = dataBroker;
autoCreateBridge = elanConfig.isAutoCreateBridge();
this.generateIntBridgeMac = elanConfig.isIntBridgeGenMac();
this.tzUtil = tzUtil;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier
- .create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
- .child(Node.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Node> identifier, Node node) {
+ public void remove(InstanceIdentifier<Node> identifier, Node node) {
elanProvider.deleteExternalElanNetworks(node);
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
LOG.debug("ElanOvsdbNodeListener.update, updated node detected. original: NodeId = {}", original.getNodeId());
boolean integrationBridgeExist = bridgeMgr.isBridgeOnOvsdbNode(update, bridgeMgr.getIntegrationBridgeName());
// ignore updates where the bridge was deleted
}
@Override
- protected void add(InstanceIdentifier<Node> identifier, Node node) {
+ public void add(InstanceIdentifier<Node> identifier, Node node) {
LOG.debug("ElanOvsdbNodeListener.add, new node detected {}", node);
doNodeUpdate(node);
elanProvider.createExternalElanNetworks(node);
/* (non-Javadoc)
* @see org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase#getDataTreeChangeListener()
*/
- @Override
- protected ElanOvsdbNodeListener getDataTreeChangeListener() {
- return ElanOvsdbNodeListener.this;
- }
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.mdsalutil.packet.Ethernet;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.evpn.utils.EvpnUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
}
String elanName = elanTagName.getName();
PhysAddress physAddress = new PhysAddress(macAddress);
- MacEntry oldMacEntry = elanUtils.getMacEntryForElanInstance(elanName, physAddress).orNull();
+ MacEntry oldMacEntry = elanUtils.getMacEntryForElanInstance(elanName, physAddress).orElse(null);
boolean isVlanOrFlatProviderIface = interfaceManager.isExternalInterface(interfaceName);
Optional<IpAddress> srcIpAddress = elanUtils.getSourceIpAddress(res);
if (srcIpAddress.isPresent()) {
String prefix = srcIpAddress.get().getIpv4Address().getValue();
InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
evpnUtils.advertisePrefix(elanInstance, macAddress, prefix, interfaceName, interfaceInfo.getDpId());
}
enqueueJobForMacSpecificTasks(macAddress, elanTag, interfaceName, elanName, physAddress, oldMacEntry,
newMacEntry, isVlanOrFlatProviderIface);
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
if (interfaceInfo == null) {
LOG.trace("Interface:{} is not present under Config DS", interfaceName);
* Static MAC having been added on a wrong ELAN.
*/
private void tryAndRemoveInvalidMacEntry(String elanName, MacEntry macEntry) {
- ElanInstance elanInfo = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInfo = elanInstanceCache.get(elanName).orElse(null);
if (elanInfo == null) {
LOG.warn("MAC {} is been added (either statically or dynamically) for an invalid Elan {}. "
+ "Manual cleanup may be necessary", macEntry.getMacAddress(), elanName);
import static java.util.Collections.emptyList;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.function.BiFunction;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.infrautils.inject.AbstractLifecycle;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
@Override
@Nullable
public EtreeInterface getEtreeInterfaceByElanInterfaceName(String elanInterface) {
- return elanInterfaceCache.getEtreeInterface(elanInterface).orNull();
+ return elanInterfaceCache.getEtreeInterface(elanInterface).orElse(null);
}
public static boolean compareWithExistingElanInstance(ElanInstance existingElanInstance, long macTimeOut,
@Override
@Nullable
public ElanInstance getElanInstance(String elanName) {
- return elanInstanceCache.get(elanName).orNull();
+ return elanInstanceCache.get(elanName).orElse(null);
}
@Override
public List<ElanInstance> getElanInstances() {
InstanceIdentifier<ElanInstances> elanInstancesIdentifier = InstanceIdentifier.builder(ElanInstances.class)
.build();
- return ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).toJavaUtil().map(
+ return ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).map(
ElanInstances::getElanInstance).orElse(emptyList());
}
@Override
@Nullable
public ElanInterface getElanInterfaceByElanInterfaceName(String interfaceName) {
- return elanInterfaceCache.get(interfaceName).orNull();
+ return elanInterfaceCache.get(interfaceName).orElse(null);
}
@Override
LOG.trace("ELAN service is after L3VPN in the Netvirt pipeline skip known L3DMAC flows installation");
return;
}
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.warn("Null elan instance {}", elanInstanceName);
return;
LOG.trace("ELAN service is after L3VPN in the Netvirt pipeline skip known L3DMAC flows installation");
return;
}
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.warn("Null elan instance {}", elanInstanceName);
return;
ingressInterfaceName, macAddress, ipAddress);
Optional<ElanInterface> elanIface = elanInterfaceCache.get(ingressInterfaceName);
ElanInstance elanInstance = elanIface.isPresent()
- ? elanInstanceCache.get(elanIface.get().getElanInstanceName()).orNull() : null;
+ ? elanInstanceCache.get(elanIface.get().getElanInstanceName()).orElse(null) : null;
if (elanInstance == null) {
LOG.debug("addArpResponderFlow: elanInstance is null, Failed to install arp responder flow for dpnId {}"
+ "for Interface {} with MAC {} & IP {}", dpnId, ingressInterfaceName, macAddress, ipAddress);
LOG.trace("Installing the ExternalTunnel ARP responder flow on DPN {} for ElanInstance {} with MAC {} & IP {}",
dpnId, elanInstanceName, macAddress, ipAddress);
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.warn("Null elan instance {}", elanInstanceName);
return;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
LOG.info("Deleting the Mac-Entry:{} present on ElanInstance:{}", macEntry, elanInstanceName);
ListenableFuture<Void> result = txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
if (macEntry != null && interfaceInfo != null) {
- deleteSmacAndDmacFlows(elanInstanceCache.get(elanInstanceName).orNull(),
+ deleteSmacAndDmacFlows(elanInstanceCache.get(elanInstanceName).orElse(null),
interfaceInfo, srcMacAddress, tx);
} else if (macEntry == null) { //Remove flow of src flow entry only for MAC movement
MacEntry macEntryOfElanForwarding = elanUtils.getMacEntryForElanInstance(elanTagInfo.getName(),
- physAddress).orNull();
+ physAddress).orElse(null);
if (macEntryOfElanForwarding != null) {
String macAddress = macEntryOfElanForwarding.getMacAddress().getValue();
- elanUtils.deleteSmacFlowOnly(elanInstanceCache.get(elanInstanceName).orNull(),
+ elanUtils.deleteSmacFlowOnly(elanInstanceCache.get(elanInstanceName).orElse(null),
interfaceInfo, macAddress, tx);
} else {
- deleteSmacAndDmacFlows(elanInstanceCache.get(elanInstanceName).orNull(), interfaceInfo,
+ deleteSmacAndDmacFlows(elanInstanceCache.get(elanInstanceName).orElse(null), interfaceInfo,
srcMacAddress, tx);
}
}
tx -> {
tx.delete(macEntryIdForElanInterface);
MacEntry macEntryInElanInstance = elanUtils.getMacEntryForElanInstance(elanInstanceName,
- physAddress).orNull();
+ physAddress).orElse(null);
if (macEntryInElanInstance != null
&& macEntryInElanInstance.getInterface().equals(interfaceName)) {
InstanceIdentifier<MacEntry> macEntryIdForElanInstance = ElanUtils
package org.opendaylight.netvirt.elan.internal;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanTunnelInterfaceStateListener extends AsyncDataTreeChangeListenerBase<StateTunnelList,
- ElanTunnelInterfaceStateListener> {
+public class ElanTunnelInterfaceStateListener extends AbstractAsyncDataTreeChangeListener<StateTunnelList> {
private static final Logger LOG = LoggerFactory.getLogger(ElanTunnelInterfaceStateListener.class);
private final DataBroker dataBroker;
private final ElanInterfaceManager elanInterfaceManager;
public ElanTunnelInterfaceStateListener(final DataBroker dataBroker,
final ElanInterfaceManager elanInterfaceManager, final ElanUtils elanUtils,
final JobCoordinator jobCoordinator) {
- super(StateTunnelList.class, ElanTunnelInterfaceStateListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TunnelsState.class)
+ .child(StateTunnelList.class),
+ Executors.newListeningSingleThreadExecutor("ElanTunnelInterfaceStateListener", LOG));
this.dataBroker = dataBroker;
this.elanInterfaceManager = elanInterfaceManager;
this.elanUtils = elanUtils;
this.jobCoordinator = jobCoordinator;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<StateTunnelList> getWildCardPath() {
- return InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<StateTunnelList> key, StateTunnelList delete) {
+ public void remove(InstanceIdentifier<StateTunnelList> key, StateTunnelList delete) {
}
@Override
- protected void update(InstanceIdentifier<StateTunnelList> key, StateTunnelList original,
+ public void update(InstanceIdentifier<StateTunnelList> key, StateTunnelList original,
StateTunnelList update) {
}
@Override
- protected void add(InstanceIdentifier<StateTunnelList> key, StateTunnelList add) {
+ public void add(InstanceIdentifier<StateTunnelList> key, StateTunnelList add) {
LOG.info("processing add state for StateTunnelList {}", add);
if (!isInternalTunnel(add)) {
LOG.trace("tunnel {} is not a internal vxlan tunnel", add);
}
}
- @Override
- protected ElanTunnelInterfaceStateListener getDataTreeChangeListener() {
- return this;
- }
-
private static boolean isInternalTunnel(StateTunnelList stateTunnelList) {
return stateTunnelList.getDstInfo() != null
? stateTunnelList.getDstInfo().getTepDeviceType() == TepTypeInternal.class : false;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterfaceAddWorkerOnElan implements Callable<List<ListenableFuture<Void>>> {
+public class InterfaceAddWorkerOnElan implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceAddWorkerOnElan.class);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterfaceAddWorkerOnElanInterface implements Callable<List<ListenableFuture<Void>>> {
+public class InterfaceAddWorkerOnElanInterface implements Callable<List<? extends ListenableFuture<?>>> {
private final String key;
private final ElanInterface elanInterface;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterfaceRemoveWorkerOnElan implements Callable<List<ListenableFuture<Void>>> {
+public class InterfaceRemoveWorkerOnElan implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceRemoveWorkerOnElan.class);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterfaceRemoveWorkerOnElanInterface implements Callable<List<ListenableFuture<Void>>> {
+public class InterfaceRemoveWorkerOnElanInterface implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceRemoveWorkerOnElanInterface.class);
package org.opendaylight.netvirt.elan.internal;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.utils.TransportZoneNotificationUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
@Singleton
public class VpnDpnToTransportZoneListener
- extends AsyncDataTreeChangeListenerBase<VpnToDpnList, VpnDpnToTransportZoneListener> {
+ extends AbstractAsyncDataTreeChangeListener<VpnToDpnList> {
private static final Logger LOG = LoggerFactory.getLogger(VpnDpnToTransportZoneListener.class);
private final TransportZoneNotificationUtil transportZoneNotificationUtil;
@Inject
public VpnDpnToTransportZoneListener(final DataBroker dbx,
final ElanConfig elanConfig, final TransportZoneNotificationUtil tznu) {
+ super(dbx, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VpnInstanceOpData.class)
+ .child(VpnInstanceOpDataEntry.class).child(VpnToDpnList.class),
+ Executors.newListeningSingleThreadExecutor("VpnDpnToTransportZoneListener", LOG));
useTransportZone = elanConfig.isAutoConfigTransportZones();
transportZoneNotificationUtil = tznu;
this.dbx = dbx;
+ start();
}
- @PostConstruct
public void start() {
-
if (useTransportZone) {
- registerListener(LogicalDatastoreType.OPERATIONAL, dbx);
LOG.info("{} registered", getClass().getSimpleName());
}
}
@Override
- protected InstanceIdentifier<VpnToDpnList> getWildCardPath() {
- return InstanceIdentifier.builder(VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class)
- .child(VpnToDpnList.class).build();
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<VpnToDpnList> identifier, VpnToDpnList del) {
+ public void remove(InstanceIdentifier<VpnToDpnList> identifier, VpnToDpnList del) {
+ if (!useTransportZone) {
+ return;
+ }
LOG.debug("Vpn dpn {} remove detected, SHOULD BE deleting transport zones", del.getDpnId());
}
@Override
- protected void update(InstanceIdentifier<VpnToDpnList> identifier, VpnToDpnList original, VpnToDpnList update) {
+ public void update(InstanceIdentifier<VpnToDpnList> identifier, VpnToDpnList original, VpnToDpnList update) {
+ if (!useTransportZone) {
+ return;
+ }
LOG.debug("Vpn dpn {} update detected, updating transport zones", update.getDpnId());
if (update.getVpnInterfaces() == null || update.getVpnInterfaces().isEmpty()) {
}
@Override
- protected void add(InstanceIdentifier<VpnToDpnList> identifier, VpnToDpnList add) {
+ public void add(InstanceIdentifier<VpnToDpnList> identifier, VpnToDpnList add) {
+ if (!useTransportZone) {
+ return;
+ }
LOG.debug("Vpn dpn {} add detected, updating transport zones", add.getDpnId());
boolean shouldCreateVtep = transportZoneNotificationUtil.shouldCreateVtep(add.getVpnInterfaces());
transportZoneNotificationUtil.updateTransportZone(vrfId, add.getDpnId());
}
}
-
- @Override
- protected VpnDpnToTransportZoneListener getDataTreeChangeListener() {
- return VpnDpnToTransportZoneListener.this;
- }
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.SwitchesCmd;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
*/
package org.opendaylight.netvirt.elan.l2gw.ha.commands;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil.isEmptyList;
import java.io.Serializable;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
*/
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.GlobalAugmentationMerger;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.GlobalNodeMerger;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.PSAugmentationMerger;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
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;
*/
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
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;
*/
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAJobScheduler;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.GlobalAugmentationMerger;
return;
}
for (Switches ps : switches) {
- Node childPsNode = tx.read((InstanceIdentifier<Node>) ps.getSwitchRef().getValue()).get().orNull();
+ Node childPsNode = tx.read((InstanceIdentifier<Node>) ps.getSwitchRef().getValue()).get().orElse(null);
if (childPsNode != null) {
InstanceIdentifier<Node> haPsPath = HwvtepHAUtil.convertPsPath(childPsNode, haNodePath);
copyChildPSOpToHAPS(childPsNode, haNodePath, haPsPath, tx);
PhysicalSwitchAugmentation src = childPsNode.augmentation(PhysicalSwitchAugmentation.class);
- Node existingHAPSNode = tx.read(haPspath).get().orNull();
+ Node existingHAPSNode = tx.read(haPspath).get().orElse(null);
PhysicalSwitchAugmentation existingHAPSAugumentation =
HwvtepHAUtil.getPhysicalSwitchAugmentationOfNode(existingHAPSNode);
*/
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAJobScheduler;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.GlobalAugmentationMerger;
PhysicalSwitchAugmentation srcPsAugmenatation =
srcPsNodeOptional.get().augmentation(PhysicalSwitchAugmentation.class);
- Node existingDstPsNode = tx.read(dstPsPath).get().orNull();
+ Node existingDstPsNode = tx.read(dstPsPath).get().orElse(null);
PhysicalSwitchAugmentation existingDstPsAugmentation =
HwvtepHAUtil.getPhysicalSwitchAugmentationOfNode(existingDstPsNode);
if (Operational.class.equals(datastoreType)) {
*/
package org.opendaylight.netvirt.elan.l2gw.ha.handlers;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.GlobalAugmentationMerger;
import org.opendaylight.netvirt.elan.l2gw.ha.merge.GlobalNodeMerger;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.HashSet;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.metrics.MetricProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.handlers.HAEventHandler;
import org.opendaylight.netvirt.elan.l2gw.ha.handlers.IHAEventHandler;
String nodeId =
HwvtepHAUtil.convertToGlobalNodeId(childPsPath.firstKeyOf(Node.class).getNodeId().getValue());
InstanceIdentifier<Node> childGlobalPath = HwvtepHAUtil.convertToInstanceIdentifier(nodeId);
- nodeCopier.copyPSNode(Optional.fromNullable(haPSNode), haPsPath, childPsPath, childGlobalPath,
+ nodeCopier.copyPSNode(Optional.ofNullable(haPSNode), haPsPath, childPsPath, childGlobalPath,
CONFIGURATION, tx);
}
LOG.trace("Handle config ps node add {}", psId);
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import java.util.Collections;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.metrics.MetricProvider;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
public synchronized void runAfterNodeIsConnected(InstanceIdentifier<Node> iid, Consumer<Optional<Node>> consumer) {
if (connectedNodes.contains(iid)) {
HAJobScheduler.getInstance().submitJob(() -> {
- try (ReadOnlyTransaction tx = getDataBroker().newReadOnlyTransaction()) {
- consumer.accept(tx.read(LogicalDatastoreType.OPERATIONAL, iid).checkedGet());
- } catch (ReadFailedException e) {
+ try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
+ consumer.accept(tx.read(LogicalDatastoreType.OPERATIONAL, iid).get());
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read oper ds {}", iid);
}
});
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.handlers.HAEventHandler;
import org.opendaylight.netvirt.elan.l2gw.ha.handlers.IHAEventHandler;
InstanceIdentifier<Node> haNodePath = getHwvtepNodeHACache().getParent(childGlobalPath);
LOG.trace("Ha enabled child node connected {}", childNode.getNodeId().getValue());
try {
- nodeCopier.copyGlobalNode(Optional.fromNullable(childNode), childGlobalPath, haNodePath, OPERATIONAL, tx);
+ nodeCopier.copyGlobalNode(Optional.ofNullable(childNode), childGlobalPath, haNodePath, OPERATIONAL, tx);
LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- confTx -> nodeCopier.copyGlobalNode(Optional.fromNullable(null), haNodePath, childGlobalPath,
+ confTx -> nodeCopier.copyGlobalNode(Optional.ofNullable(null), haNodePath, childGlobalPath,
CONFIGURATION, confTx)), LOG, "Error copying to configuration");
} catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read nodes {} , {} ", childGlobalPath, haNodePath);
Node updatedChildNode,
Node originalChildNode,
DataObjectModification<Node> mod,
- TypedReadWriteTransaction<Operational> tx) throws ReadFailedException {
+ TypedReadWriteTransaction<Operational> tx) {
String oldHAId = HwvtepHAUtil.getHAIdFromManagerOtherConfig(originalChildNode);
if (!Strings.isNullOrEmpty(oldHAId)) { //was already ha child
InstanceIdentifier<Node> haGlobalPath = getHwvtepNodeHACache().getParent(childGlobalPath);
InstanceIdentifier<Node> haPsPath = HwvtepHAUtil.convertPsPath(childPsNode, haGlobalPath);
try {
- nodeCopier.copyPSNode(Optional.fromNullable(childPsNode), childPsPath, haPsPath, haGlobalPath,
+ nodeCopier.copyPSNode(Optional.ofNullable(childPsNode), childPsPath, haPsPath, haGlobalPath,
OPERATIONAL, tx);
LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- confTx -> nodeCopier.copyPSNode(Optional.fromNullable(null), haPsPath, childPsPath, childGlobalPath,
+ confTx -> nodeCopier.copyPSNode(Optional.ofNullable(null), haPsPath, childPsPath, childGlobalPath,
CONFIGURATION, confTx)), LOG, "Error copying to configuration");
} catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read nodes {} , {} ", childPsPath, haGlobalPath);
import java.util.concurrent.ExecutionException;
import java.util.function.Function;
import javax.annotation.PreDestroy;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.TaskRetryLooper;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.infrautils.metrics.MetricDescriptor;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
}
protected void registerListener(Class<D> dsType, DataBroker broker) throws Exception {
- final DataTreeIdentifier<Node> treeId = new DataTreeIdentifier<>(Datastore.toType(dsType),
+ final DataTreeIdentifier<Node> treeId = DataTreeIdentifier.create(Datastore.toType(dsType),
getWildcardPath());
TaskRetryLooper looper = new TaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
registration = looper.loopUntilNoException(() ->
private void processUpdatedNodes(Collection<DataTreeModification<Node>> changes,
TypedReadWriteTransaction<D> tx)
- throws ReadFailedException, ExecutionException, InterruptedException {
+ throws ExecutionException, InterruptedException {
for (DataTreeModification<Node> change : changes) {
final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
final DataObjectModification<Node> mod = change.getRootNode();
private void processDisconnectedNodes(Collection<DataTreeModification<Node>> changes,
TypedReadWriteTransaction<D> tx)
- throws InterruptedException, ExecutionException, ReadFailedException {
+ throws InterruptedException, ExecutionException {
for (DataTreeModification<Node> change : changes) {
final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
final DataObjectModification<Node> mod = change.getRootNode();
//default methods
void onGlobalNodeDelete(InstanceIdentifier<Node> key, Node added, TypedReadWriteTransaction<D> tx)
- throws ReadFailedException, ExecutionException, InterruptedException {
+ throws ExecutionException, InterruptedException {
}
void onPsNodeDelete(InstanceIdentifier<Node> key, Node addedPSNode, TypedReadWriteTransaction<D> tx)
- throws ReadFailedException, ExecutionException, InterruptedException {
+ throws ExecutionException, InterruptedException {
}
}
void onGlobalNodeUpdate(InstanceIdentifier<Node> key, Node updated, Node original,
- DataObjectModification<Node> mod, TypedReadWriteTransaction<D> tx)
- throws ReadFailedException, InterruptedException, ExecutionException {
+ DataObjectModification<Node> mod, TypedReadWriteTransaction<D> tx) {
}
void onPsNodeUpdate(Node updated,
- DataObjectModification<Node> mod, TypedReadWriteTransaction<D> tx)
- throws ReadFailedException, InterruptedException, ExecutionException {
+ DataObjectModification<Node> mod, TypedReadWriteTransaction<D> tx) {
}
+++ /dev/null
-/*
- * Copyright (c) 2017 Ericsson India Global Services Pvt Ltd. 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.netvirt.elan.l2gw.ha.listeners;
-
-import com.google.common.base.Optional;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.function.BiConsumer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
-import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.genius.infra.Datastore;
-import org.opendaylight.genius.infra.Datastore.Operational;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.infra.TypedReadWriteTransaction;
-import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
-import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
-import org.opendaylight.netvirt.elan.l2gw.ha.commands.MergeCommand;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
-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.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Listens for the node children data updates and propagates the updates between ha child and parent nodes.
- * When an operational child node data is updated, it is copied to parent
- * When a config parent node data is updated , it is copied to all its children.
- */
-public abstract class HwvtepNodeDataListener<D extends Datastore, T extends DataObject>
- extends AsyncDataTreeChangeListenerBase<T, HwvtepNodeDataListener<D, T>> {
-
- private static final Logger LOG = LoggerFactory.getLogger(HwvtepNodeDataListener.class);
-
- private final ManagedNewTransactionRunner txRunner;
- private final SingleTransactionDataBroker singleTxBroker;
- private final MergeCommand<T, ?, ?> mergeCommand;
- private final Class<D> datastoreType;
- private final BiConsumer<InstanceIdentifier<T>, T> addOperation;
- private final BiConsumer<InstanceIdentifier<T>, T> removeOperation;
- private final HwvtepNodeHACache hwvtepNodeHACache;
-
- public HwvtepNodeDataListener(DataBroker broker,
- HwvtepNodeHACache hwvtepNodeHACache,
- Class<T> clazz,
- Class<HwvtepNodeDataListener<D, T>> eventClazz,
- MergeCommand<T, ?, ?> mergeCommand,
- Class<D> datastoreType) {
- super(clazz, eventClazz);
- this.hwvtepNodeHACache = hwvtepNodeHACache;
- this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
- this.singleTxBroker = new SingleTransactionDataBroker(broker);
- this.mergeCommand = mergeCommand;
- this.datastoreType = datastoreType;
- if (Operational.class.equals(datastoreType)) {
- this.addOperation = this::copyToParent;
- this.removeOperation = this::deleteFromParent;
- } else {
- this.addOperation = this::copyToChildren;
- this.removeOperation = this::deleteFromChildren;
- }
- }
-
- @Override
- protected abstract InstanceIdentifier<T> getWildCardPath();
-
- @Override
- protected void add(InstanceIdentifier<T> identifier, T dataAdded) {
- HAJobScheduler.getInstance().submitJob(() -> addOperation.accept(identifier, dataAdded));
- }
-
- @Override
- protected void update(InstanceIdentifier<T> key, T before, T after) {
- HAJobScheduler.getInstance().submitJob(() -> {
- if (Objects.equals(before, after)) {
- //incase of cluter reboots tx.put will rewrite the data and fire unnecessary updates
- return;
- }
- add(key, after);
- });
- }
-
- @Override
- protected void remove(InstanceIdentifier<T> identifier, T dataRemoved) {
- HAJobScheduler.getInstance().submitJob(() -> removeOperation.accept(identifier, dataRemoved));
- }
-
- private boolean isNodeConnected(InstanceIdentifier<T> identifier)
- throws ReadFailedException {
- return singleTxBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL,
- identifier.firstIdentifierOf(Node.class)).isPresent();
- }
-
- private static <T extends DataObject> boolean isDataUpdated(Optional<T> existingDataOptional, T newData) {
- return !existingDataOptional.isPresent() || !Objects.equals(existingDataOptional.get(), newData);
- }
-
- private void copyToParent(InstanceIdentifier<T> identifier, T data) {
- if (clazz == RemoteUcastMacs.class) {
- LOG.trace("Skipping remote ucast macs to parent");
- return;
- }
- InstanceIdentifier<Node> parent = getHAParent(identifier);
- if (parent != null) {
- LOG.trace("Copy child op data {} to parent {}", mergeCommand.getDescription(), getNodeId(parent));
- T parentData = mergeCommand.transform(parent, data);
- InstanceIdentifier<T> parentIdentifier = mergeCommand.generateId(parent, parentData);
- LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(datastoreType,
- tx -> writeToMdsal(tx, parentData, parentIdentifier)), LOG, "Error copying to parent");
- }
- }
-
- private void deleteFromParent(InstanceIdentifier<T> identifier, T data) {
- if (clazz == RemoteUcastMacs.class) {
- LOG.trace("Skipping remote ucast macs to parent");
- return;
- }
- InstanceIdentifier<Node> parent = getHAParent(identifier);
- if (parent != null) {
- LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(datastoreType, tx -> {
- if (isNodeConnected(identifier)) {
- LOG.trace("Copy child op data {} to parent {} create:{}", mergeCommand.getDescription(),
- getNodeId(parent), false);
- T parentData = mergeCommand.transform(parent, data);
- InstanceIdentifier<T> parentIdentifier = mergeCommand.generateId(parent, parentData);
- deleteFromMdsal(tx, parentIdentifier);
- }
- }), LOG, "Error deleting from parent");
- }
- }
-
- private void copyToChildren(final InstanceIdentifier<T> parentIdentifier, final T parentData) {
- Set<InstanceIdentifier<Node>> children = getChildrenForHANode(parentIdentifier);
- if (children != null) {
- LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(datastoreType, tx -> {
- for (InstanceIdentifier<Node> child : children) {
- LOG.trace("Copy parent config data {} to child {}", mergeCommand.getDescription(),
- getNodeId(child));
- final T childData = mergeCommand.transform(child, parentData);
- final InstanceIdentifier<T> identifier = mergeCommand.generateId(child, childData);
- writeToMdsal(tx, childData, identifier);
- }
- }), LOG, "Error copying to children");
- }
- }
-
- private void deleteFromChildren(final InstanceIdentifier<T> parentIdentifier, final T parentData) {
- Set<InstanceIdentifier<Node>> children = getChildrenForHANode(parentIdentifier);
- if (children != null) {
- LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(datastoreType, tx -> {
- for (InstanceIdentifier<Node> child : children) {
- LOG.trace("Delete parent config data {} to child {}", mergeCommand.getDescription(),
- getNodeId(child));
- final T childData = mergeCommand.transform(child, parentData);
- final InstanceIdentifier<T> identifier = mergeCommand.generateId(child, childData);
- deleteFromMdsal(tx, identifier);
- }
- }), LOG, "Error deleting from children");
- }
- }
-
- private void writeToMdsal(final TypedReadWriteTransaction<D> tx, final T data,
- final InstanceIdentifier<T> identifier) throws ExecutionException, InterruptedException {
- if (isDataUpdated(tx.read(identifier).get(), data)) {
- tx.put(identifier, data);
- }
- }
-
- private void deleteFromMdsal(final TypedReadWriteTransaction<D> tx,
- final InstanceIdentifier<T> identifier) throws ExecutionException, InterruptedException {
- if (tx.read(identifier).get().isPresent()) {
- tx.delete(identifier);
- }
- }
-
- private static String getNodeId(InstanceIdentifier<Node> iid) {
- return iid.firstKeyOf(Node.class).getNodeId().getValue();
- }
-
- @Override
- protected HwvtepNodeDataListener<D, T> getDataTreeChangeListener() {
- return HwvtepNodeDataListener.this;
- }
-
- protected Set<InstanceIdentifier<Node>> getChildrenForHANode(InstanceIdentifier<T> identifier) {
- InstanceIdentifier<Node> parent = identifier.firstIdentifierOf(Node.class);
- return hwvtepNodeHACache.getChildrenForHANode(parent);
- }
-
- protected InstanceIdentifier<Node> getHAParent(InstanceIdentifier<T> identifier) {
- InstanceIdentifier<Node> child = identifier.firstIdentifierOf(Node.class);
- return hwvtepNodeHACache.getParent(child);
- }
-}
package org.opendaylight.netvirt.elan.l2gw.ha.listeners;
import java.util.Arrays;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Managers;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.slf4j.LoggerFactory;
@Singleton
-public final class ManagerListener extends AsyncClusteredDataTreeChangeListenerBase<Managers, ManagerListener> {
+public final class ManagerListener extends AbstractClusteredAsyncDataTreeChangeListener<Managers> {
private static final Logger LOG = LoggerFactory.getLogger(ManagerListener.class);
@Inject
public ManagerListener(DataBroker dataBroker, HwvtepNodeHACache hwvtepNodeHACache) {
- super(Managers.class, ManagerListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier().child(Node.class)
+ .augmentation(HwvtepGlobalAugmentation.class).child(Managers.class),
+ Executors.newListeningSingleThreadExecutor("ManagerListener", LOG));
this.dataBroker = dataBroker;
this.hwvtepNodeHACache = hwvtepNodeHACache;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<Managers> getWildCardPath() {
- return HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier()
- .child(Node.class)
- .augmentation(HwvtepGlobalAugmentation.class)
- .child(Managers.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Managers> key, Managers managers) {
+ public void remove(InstanceIdentifier<Managers> key, Managers managers) {
}
@Override
- protected void update(InstanceIdentifier<Managers> key, Managers before, Managers after) {
+ public void update(InstanceIdentifier<Managers> key, Managers before, Managers after) {
}
@Override
- protected void add(InstanceIdentifier<Managers> key, Managers managers) {
+ public void add(InstanceIdentifier<Managers> key, Managers managers) {
InstanceIdentifier<Node> parent = key.firstIdentifierOf(Node.class);
if (managers.key().getTarget().getValue().contains(HwvtepHAUtil.MANAGER_KEY)
&& managers.getManagerOtherConfigs() != null) {
.forEach(childIid -> hwvtepNodeHACache.addChild(parent, childIid));
}
}
-
- @Override
- protected ManagerListener getDataTreeChangeListener() {
- return this;
- }
}
*/
package org.opendaylight.netvirt.elan.l2gw.ha.merge;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.function.BiPredicate;
-
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.utils.SuperTypeUtil;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LocalMcastCmd;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LocalUcastCmd;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.MergeCommand;
*/
package org.opendaylight.netvirt.elan.l2gw.jobs;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
/**
* Created by ekvsver on 4/15/2016.
*/
-public class AssociateHwvtepToElanJob implements Callable<List<ListenableFuture<Void>>> {
+public class AssociateHwvtepToElanJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(AssociateHwvtepToElanJob.class);
private final DataBroker broker;
}
@Override
- public List<ListenableFuture<Void>> call() {
+ public List<ListenableFuture<?>> call() {
String hwvtepNodeId = l2GatewayDevice.getHwvtepNodeId();
String elanInstanceName = elanInstance.getElanInstanceName();
LOG.debug("running assosiate l2gw connection job for {} {} ", elanInstanceName, hwvtepNodeId);
return logicalSwitchAddedJob.call();
}
- private ListenableFuture<Void> createLogicalSwitch() {
+ private FluentFuture<? extends @NonNull CommitInfo> createLogicalSwitch() {
final String logicalSwitchName = ElanL2GatewayUtils.getLogicalSwitchFromElan(
elanInstance.getElanInstanceName());
String segmentationId = ElanUtils.getVxlanSegmentationId(elanInstance).toString();
LOG.trace("logical switch {} is created on {} with VNI {}", logicalSwitchName,
l2GatewayDevice.getHwvtepNodeId(), segmentationId);
NodeId hwvtepNodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
- String dbVersion = HwvtepUtils.getDbVersion(broker,hwvtepNodeId);
+ String dbVersion = null;
+ try {
+ dbVersion = HwvtepUtils.getDbVersion(broker,hwvtepNodeId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("createLogicalSwitch: Exception while reading DB version for the node {}", hwvtepNodeId, e);
+ }
if (SouthboundUtils.compareDbVersionToMinVersion(dbVersion, "1.6.0")) {
replicationMode = "source_node";
}
LogicalSwitches logicalSwitch = HwvtepSouthboundUtils.createLogicalSwitch(logicalSwitchName,
elanInstance.getDescription(), segmentationId, replicationMode);
- ListenableFuture<Void> lsCreateFuture = HwvtepUtils.addLogicalSwitch(broker, hwvtepNodeId, logicalSwitch);
- Futures.addCallback(lsCreateFuture, new FutureCallback<Void>() {
+ FluentFuture<? extends @NonNull CommitInfo> lsCreateFuture = HwvtepUtils.addLogicalSwitch(broker, hwvtepNodeId,
+ logicalSwitch);
+ lsCreateFuture.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(Void noarg) {
+ public void onSuccess(CommitInfo noarg) {
// Listener will be closed after all configuration completed
// on hwvtep by
// listener itself
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanRefUtil;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class BcGroupUpdateJob implements Callable<List<ListenableFuture<Void>>> {
+public class BcGroupUpdateJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger("HwvtepEventLogger");
* The Job class to delete L2 gateway device local ucast macs from other Elan L2
* gateway devices.
*/
-public class DeleteL2GwDeviceMacsFromElanJob implements Callable<List<ListenableFuture<Void>>> {
+public class DeleteL2GwDeviceMacsFromElanJob implements Callable<List<? extends ListenableFuture<?>>> {
/** The Constant JOB_KEY_PREFIX. */
private static final String JOB_KEY_PREFIX = "hwvtep:";
package org.opendaylight.netvirt.elan.l2gw.jobs;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
/**
* The Class DeleteLogicalSwitchJob.
*/
-public class DeleteLogicalSwitchJob implements Callable<List<ListenableFuture<Void>>> {
+public class DeleteLogicalSwitchJob implements Callable<List<? extends ListenableFuture<?>>> {
private DataBroker broker;
/** The logical switch name. */
}
@Override
- public List<ListenableFuture<Void>> call() {
+ public List<ListenableFuture<?>> call() {
if (cancelled) {
LOG.info("Delete logical switch job cancelled ");
return Collections.emptyList();
L2GatewayDevice l2GatewayDevice = new L2GatewayDevice("");
l2GatewayDevice.setHwvtepNodeId(hwvtepNodeId.getValue());
- List<ListenableFuture<Void>> futures = new ArrayList<>();
+ List<ListenableFuture<?>> futures = new ArrayList<>();
futures.add(HwvtepUtils.deleteLogicalSwitch(broker, hwvtepNodeId, logicalSwitchName));
if (clearUcast) {
LOG.trace("Clearing the local ucast macs of device {} macs ", hwvtepNodeId.getValue());
/**
* Created by ekvsver on 4/15/2016.
*/
-public class DisAssociateHwvtepFromElanJob implements Callable<List<ListenableFuture<Void>>> {
+public class DisAssociateHwvtepFromElanJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(DisAssociateHwvtepFromElanJob.class);
private final ElanL2GatewayUtils elanL2GatewayUtils;
}
@Override
- public List<ListenableFuture<Void>> call() {
+ public List<ListenableFuture<?>> call() {
String strHwvtepNodeId = hwvtepNodeId.getValue();
LOG.info("running disassosiate l2gw connection job for {} {}", elanName, strHwvtepNodeId);
- List<ListenableFuture<Void>> futures = new ArrayList<>();
+ List<ListenableFuture<?>> futures = new ArrayList<>();
// Remove remote MACs and vlan mappings from physical port
// Once all above configurations are deleted, delete logical
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DpnDmacJob implements Callable<List<ListenableFuture<Void>>> {
+public class DpnDmacJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(DpnDmacJob.class);
private String elanName;
@Override
public List<ListenableFuture<Void>> call() throws Exception {
- ElanInstance elan = elanRefUtil.getElanInstanceCache().get(elanName).orNull();
+ ElanInstance elan = elanRefUtil.getElanInstanceCache().get(elanName).orElse(null);
if (elan == null) {
LOG.error("failed.elan.not.found.{}", jobKey);
return null;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepDeviceMcastMacUpdateJob implements Callable<List<ListenableFuture<Void>>> {
+public class HwvtepDeviceMcastMacUpdateJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepDeviceMcastMacUpdateJob.class);
private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
/**
* The Class LogicalSwitchAddedWorker.
*/
-public class LogicalSwitchAddedJob implements Callable<List<ListenableFuture<Void>>> {
+public class LogicalSwitchAddedJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalSwitchAddedJob.class);
/** The logical switch name. */
}
@Override
- public List<ListenableFuture<Void>> call() {
+ public List<ListenableFuture<?>> call() {
elanL2GatewayUtils.cancelDeleteLogicalSwitch(new NodeId(elanL2GwDevice.getHwvtepNodeId()), logicalSwitchName);
LOG.debug("running logical switch added job for {} {}", logicalSwitchName,
elanL2GwDevice.getHwvtepNodeId());
- List<ListenableFuture<Void>> futures = new ArrayList<>();
+ List<ListenableFuture<?>> futures = new ArrayList<>();
LOG.info("creating vlan bindings for {} {}", logicalSwitchName, elanL2GwDevice.getHwvtepNodeId());
futures.add(elanL2GatewayUtils.updateVlanBindingsInL2GatewayDevice(
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yangtools.yang.common.Uint64;
-public class McastUpdateJob implements Callable<List<ListenableFuture<Void>>> {
+public class McastUpdateJob implements Callable<List<? extends ListenableFuture<?>>> {
private String elanName;
private String nodeId;
private ElanL2GatewayMulticastUtils mcastUtils;
}
@Override
- public List<ListenableFuture<Void>> call() throws Exception {
+ public List<ListenableFuture<?>> call() throws Exception {
L2GatewayDevice device = ElanL2GwCacheUtils.getL2GatewayDeviceFromCache(elanName, nodeId);
- ListenableFuture<Void> ft = null;
+ ListenableFuture<?> ft = null;
//TODO: make prepareRemoteMcastMacUpdateOnDevice return a ListenableFuture<Void>
if (add) {
ft = mcastUtils.prepareRemoteMcastMacUpdateOnDevice(elanName, device, !dpnOrConnectionRemoved ,
} else {
ft = mcastUtils.deleteRemoteMcastMac(new NodeId(nodeId), elanName);
}
- List<ListenableFuture<Void>> fts = new ArrayList<ListenableFuture<Void>>();
+ List<ListenableFuture<?>> fts = new ArrayList<>();
fts.add(ft);
return fts;
}
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.PreDestroy;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.TaskRetryLooper;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
protected ListenerRegistration<?> registerListener(final LogicalDatastoreType dsType,
final InstanceIdentifier wildCard) throws Exception {
- DataTreeIdentifier<P> treeId = new DataTreeIdentifier<>(dsType, wildCard);
+ DataTreeIdentifier<P> treeId = DataTreeIdentifier.create(dsType, wildCard);
TaskRetryLooper looper = new TaskRetryLooper(STARTUP_LOOP_TICK, STARTUP_LOOP_MAX_RETRIES);
return looper.loopUntilNoException(() -> dataBroker.registerDataTreeChangeListener(treeId, this));
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.List;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanGroupListener extends AsyncClusteredDataTreeChangeListenerBase<Group, ElanGroupListener> {
+public class ElanGroupListener extends AbstractClusteredAsyncDataTreeChangeListener<Group> {
private static final Logger LOG = LoggerFactory.getLogger(ElanGroupListener.class);
private final ManagedNewTransactionRunner txRunner;
@Inject
public ElanGroupListener(DataBroker db, ElanClusterUtils elanClusterUtils, ElanUtils elanUtils,
ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils, ElanInstanceCache elanInstanceCache) {
- super(Group.class, ElanGroupListener.class);
+ super(db, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class).child(Group.class),
+ Executors.newListeningSingleThreadExecutor("ElanGroupListener", LOG));
this.txRunner = new ManagedNewTransactionRunnerImpl(db);
this.elanClusterUtils = elanClusterUtils;
this.elanUtils = elanUtils;
this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
this.elanInstanceCache = elanInstanceCache;
- registerListener(LogicalDatastoreType.CONFIGURATION, db);
LOG.trace("ElanGroupListener registered");
}
+ public void init() {
+ LOG.info("{} init", getClass().getSimpleName());
+ }
+
@Override
- protected InstanceIdentifier<Group> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class)
- .augmentation(FlowCapableNode.class).child(Group.class);
+ @PreDestroy
+ public void close() {
+ super.close();
}
@Override
- protected void remove(InstanceIdentifier<Group> identifier, Group del) {
+ public void remove(InstanceIdentifier<Group> identifier, Group del) {
LOG.trace("received group removed {}", del.key().getGroupId());
}
}
@Override
- protected void update(InstanceIdentifier<Group> identifier, @Nullable Group original, Group update) {
+ public void update(InstanceIdentifier<Group> identifier, @Nullable Group original, Group update) {
LOG.trace("received group updated {}", update.key().getGroupId());
final Uint64 dpnId = getDpnId(identifier.firstKeyOf(Node.class).getId().getValue());
if (dpnId == null) {
}
@Override
- protected void add(InstanceIdentifier<Group> identifier, Group added) {
+ public void add(InstanceIdentifier<Group> identifier, Group added) {
LOG.trace("received group add {}", added.key().getGroupId());
update(identifier, null/*original*/, added);
}
-
- @Override
- protected ElanGroupListener getDataTreeChangeListener() {
- return this;
- }
}
*/
package org.opendaylight.netvirt.elan.l2gw.listeners;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.netvirt.elan.utils.ElanConstants.ELAN_EOS_DELAY;
-import com.google.common.base.Optional;
-
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
LOG.info("Not the owner for Elan entity {}", ownershipChange);
}
ft = null;
- } catch (Exception e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Failed to read mdsal ", e);
}
}, ELAN_EOS_DELAY, TimeUnit.MINUTES);
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayServiceRecoveryHandler;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.L2gatewayConnections;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanInstanceListener extends AsyncClusteredDataTreeChangeListenerBase<ElanInstance, ElanInstanceListener>
+public class ElanInstanceListener extends AbstractClusteredAsyncDataTreeChangeListener<ElanInstance>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(ElanInstanceListener.class);
public ElanInstanceListener(final DataBroker db, final ElanClusterUtils elanClusterUtils,
final L2GatewayServiceRecoveryHandler l2GatewayServiceRecoveryHandler,
final ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(ElanInstance.class, ElanInstanceListener.class);
+ super(db, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ElanInstances.class)
+ .child(ElanInstance.class),
+ Executors.newListeningSingleThreadExecutor("ElanInstanceListener", LOG));
broker = db;
this.txRunner = new ManagedNewTransactionRunnerImpl(db);
this.elanClusterUtils = elanClusterUtils;
serviceRecoveryRegistry.addRecoverableListener(l2GatewayServiceRecoveryHandler.buildServiceRegistryKey(), this);
}
- @PostConstruct
public void init() {
registerListener();
}
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
+
@Override
public void registerListener() {
+ super.register();
LOG.info("Registering ElanInstanceListener");
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
}
public void deregisterListener() {
+ super.close();
LOG.info("Deregistering ElanInstanceListener");
- super.deregisterListener();
}
@Override
- protected void remove(final InstanceIdentifier<ElanInstance> identifier,
+ public void remove(final InstanceIdentifier<ElanInstance> identifier,
final ElanInstance del) {
elanClusterUtils.runOnlyInOwnerNode(del.getElanInstanceName(), "delete Elan instance",
() -> {
}
@Override
- protected void update(InstanceIdentifier<ElanInstance> identifier, ElanInstance original, ElanInstance update) {
-
- }
-
- @Override
- protected void add(InstanceIdentifier<ElanInstance> identifier, ElanInstance add) {
- }
+ public void update(InstanceIdentifier<ElanInstance> identifier, ElanInstance original, ElanInstance update) {
- @Override
- protected ElanInstanceListener getDataTreeChangeListener() {
- return ElanInstanceListener.this;
}
@Override
- protected InstanceIdentifier<ElanInstance> getWildCardPath() {
- return InstanceIdentifier.create(ElanInstances.class).child(ElanInstance.class);
+ public void add(InstanceIdentifier<ElanInstance> identifier, ElanInstance add) {
}
-
}
package org.opendaylight.netvirt.elan.l2gw.listeners;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanForwardingTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.forwarding.tables.MacTable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.LoggerFactory;
@Singleton
-public class ElanMacTableCache extends AsyncClusteredDataTreeChangeListenerBase<MacTable, ElanMacTableCache> {
+public class ElanMacTableCache extends AbstractClusteredAsyncDataTreeChangeListener<MacTable> {
private static final Logger LOG = LoggerFactory.getLogger(ElanMacTableCache.class);
private final DataBroker dataBroker;
private final ConcurrentHashMap<String, MacTable> macsByElan = new ConcurrentHashMap<>();
@Inject
public ElanMacTableCache(final DataBroker dataBroker) {
- super(MacTable.class, ElanMacTableCache.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanForwardingTables.class)
+ .child(MacTable.class),
+ Executors.newListeningSingleThreadExecutor("ElanMacTableCache", LOG));
this.dataBroker = dataBroker;
}
- @PostConstruct
public void init() {
- this.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<MacTable> getWildCardPath() {
- return InstanceIdentifier.builder(ElanForwardingTables.class).child(MacTable.class).build();
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected ElanMacTableCache getDataTreeChangeListener() {
- return ElanMacTableCache.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<MacTable> key, MacTable mac) {
+ public void remove(InstanceIdentifier<MacTable> key, MacTable mac) {
macsByElan.remove(mac.getElanInstanceName());
}
@Override
- protected void update(InstanceIdentifier<MacTable> key, MacTable old, MacTable mac) {
+ public void update(InstanceIdentifier<MacTable> key, MacTable old, MacTable mac) {
macsByElan.put(mac.getElanInstanceName(), mac);
}
@Override
- protected void add(InstanceIdentifier<MacTable> key, MacTable mac) {
+ public void add(InstanceIdentifier<MacTable> key, MacTable mac) {
macsByElan.put(mac.getElanInstanceName(), mac);
}
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
-
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
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.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@Singleton
-public class HwvtepConfigNodeCache extends AsyncClusteredDataTreeChangeListenerBase<Node, HwvtepConfigNodeCache> {
+public class HwvtepConfigNodeCache extends AbstractClusteredAsyncDataTreeChangeListener<Node> {
+ private static final Logger LOG = LoggerFactory.getLogger(HwvtepConfigNodeCache.class);
+
private final DataBroker dataBroker;
private final Map<InstanceIdentifier<Node>, Node> cache = new ConcurrentHashMap<>();
private final Map<InstanceIdentifier<Node>, List<Runnable>> waitList = new ConcurrentHashMap<>();
@Inject
public HwvtepConfigNodeCache(final DataBroker dataBroker) {
- super(Node.class, HwvtepConfigNodeCache.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
+ .child(Node.class), Executors.newListeningSingleThreadExecutor("HwvtepConfigNodeCache", LOG));
this.dataBroker = dataBroker;
}
- @PostConstruct
public void init() {
- this.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID))
- .child(Node.class);
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected HwvtepConfigNodeCache getDataTreeChangeListener() {
- return HwvtepConfigNodeCache.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Node> key, Node deleted) {
+ public void remove(InstanceIdentifier<Node> key, Node deleted) {
cache.remove(key);
}
@Override
- protected void update(InstanceIdentifier<Node> key, Node old, Node added) {
+ public void update(InstanceIdentifier<Node> key, Node old, Node added) {
cache.put(key, added);
}
@Override
- protected synchronized void add(InstanceIdentifier<Node> key, Node added) {
+ public synchronized void add(InstanceIdentifier<Node> key, Node added) {
cache.put(key, added);
if (waitList.containsKey(key)) {
waitList.remove(key).stream().forEach(runnable -> runnable.run());
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.hwvtep.HwvtepAbstractDataTreeChangeListener;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAOpClusteredListener;
import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayServiceRecoveryHandler;
HAOpClusteredListener haListener, L2GatewayCache l2GatewayCache,
StaleVlanBindingsCleaner staleVlanBindingsCleaner,
HwvtepNodeHACache hwvtepNodeHACache) {
- super(PhysicalSwitchAugmentation.class, HwvtepPhysicalSwitchListener.class, hwvtepNodeHACache);
+ super(dataBroker, DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID)).child(Node.class)
+ .augmentation(PhysicalSwitchAugmentation.class)),
+ Executors.newListeningSingleThreadExecutor("HwvtepPhysicalSwitchListener", LOG),
+ hwvtepNodeHACache);
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.itmRpcService = itmRpcService;
this);
}
- @Override
- @PostConstruct
public void init() {
registerListener();
}
@Override
public void registerListener() {
+ super.register();
LOG.info("Registering HwvtepPhysicalSwitchListener");
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
public void deregisterListener() {
+ super.close();
LOG.info("Deregistering HwvtepPhysicalSwitchListener");
- super.deregisterListener();
- }
-
- @Override
- protected InstanceIdentifier<PhysicalSwitchAugmentation> getWildCardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID)).child(Node.class)
- .augmentation(PhysicalSwitchAugmentation.class);
}
@Override
- protected HwvtepPhysicalSwitchListener getDataTreeChangeListener() {
- return HwvtepPhysicalSwitchListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
*/
package org.opendaylight.netvirt.elan.l2gw.listeners;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.hwvtep.HwvtepClusteredDataTreeChangeListener;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
AtomicBoolean executeTask = new AtomicBoolean(true);
- Callable<List<ListenableFuture<Void>>> taskToRun;
+ Callable<List<? extends ListenableFuture<?>>> taskToRun;
private final JobCoordinator jobCoordinator;
public HwvtepRemoteMcastMacListener(DataBroker broker, ElanUtils elanUtils, String logicalSwitchName,
L2GatewayDevice l2GatewayDevice,
List<IpAddress> expectedPhyLocatorIps,
- Callable<List<ListenableFuture<Void>>> task,
+ Callable<List<? extends ListenableFuture<?>>> task,
JobCoordinator jobCoordinator, HwvtepNodeHACache hwvtepNodeHACache)
throws Exception {
- super(RemoteMcastMacs.class, HwvtepRemoteMcastMacListener.class, hwvtepNodeHACache);
+ super(broker, DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(new NodeId(l2GatewayDevice.getHwvtepNodeId()),
+ logicalSwitchName, new MacAddress(ElanConstants.UNKNOWN_DMAC))),
+ Executors.newListeningSingleThreadExecutor("HwvtepRemoteMcastMacListener", LOG),
+ hwvtepNodeHACache);
this.elanUtils = elanUtils;
this.nodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
this.taskToRun = task;
this.expectedPhyLocatorIps = expectedPhyLocatorIps;
this.jobCoordinator = jobCoordinator;
LOG.info("registering the listener for mcast mac ");
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
- LOG.info("registered the listener for mcast mac ");
+ //registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("registered the listener for mcast mac");
if (isDataPresentInOpDs(getWildCardPath())) {
LOG.info("mcast mac already present running the task ");
if (executeTask.compareAndSet(true, false)) {
return true;
}
- @Override
public InstanceIdentifier<RemoteMcastMacs> getWildCardPath() {
return HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(nodeId,
logicalSwitchName, new MacAddress(ElanConstants.UNKNOWN_DMAC));
}
- @Override
- protected HwvtepRemoteMcastMacListener getDataTreeChangeListener() {
- return this;
- }
-
@Override
protected void removed(InstanceIdentifier<RemoteMcastMacs> identifier, RemoteMcastMacs deleted) {
LOG.trace("Received Remove DataChange Notification for identifier: {}, RemoteMcastMacs: {}", identifier,
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.hwvtep.HwvtepClusteredDataTreeChangeListener;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
public HwvtepTerminationPointListener(DataBroker broker, ElanL2GatewayUtils elanL2GatewayUtils,
ElanClusterUtils elanClusterUtils, L2GatewayCache l2GatewayCache,
HwvtepNodeHACache hwvtepNodeHACache) {
- super(TerminationPoint.class, HwvtepTerminationPointListener.class, hwvtepNodeHACache);
+ //super(TerminationPoint.class, HwvtepTerminationPointListener.class, hwvtepNodeHACache);
+ super(broker, DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID)).child(Node.class)
+ .child(TerminationPoint.class)),
+ Executors.newListeningSingleThreadExecutor("HwvtepTerminationPointListener", LOG),
+ hwvtepNodeHACache);
this.broker = broker;
this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
this.elanL2GatewayUtils = elanL2GatewayUtils;
LOG.trace("physical locator available {}", identifier);
}
- @Override
- protected InstanceIdentifier<TerminationPoint> getWildCardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID)).child(Node.class)
- .child(TerminationPoint.class);
- }
-
- @Override
- protected HwvtepTerminationPointListener getDataTreeChangeListener() {
- return this;
- }
-
private List<ListenableFuture<Void>> handlePortAdded(TerminationPoint portAdded, NodeId psNodeId) {
- Node psNode = HwvtepUtils.getHwVtepNode(broker, LogicalDatastoreType.OPERATIONAL, psNodeId);
+ Node psNode = null;
+ try {
+ psNode = HwvtepUtils.getHwVtepNode(broker, LogicalDatastoreType.OPERATIONAL, psNodeId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while retriving HwVtepNode {}", psNodeId.getValue(), e);
+ }
if (psNode != null) {
String psName = psNode.augmentation(PhysicalSwitchAugmentation.class).getHwvtepNodeName().getValue();
L2GatewayDevice l2GwDevice = l2GatewayCache.get(psName);
private List<ListenableFuture<Void>> handlePortDeleted(InstanceIdentifier<TerminationPoint> identifier) {
InstanceIdentifier<Node> psNodeIid = identifier.firstIdentifierOf(Node.class);
return Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- tx -> tx.read(psNodeIid).get().toJavaUtil().ifPresent(
- node -> tx.delete(identifier))));
+ tx -> tx.read(psNodeIid).get().ifPresent(node -> tx.delete(identifier))));
}
private List<VlanBindings> getVlanBindings(List<L2gatewayConnection> l2GwConns, NodeId hwvtepNodeId, String psName,
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toMap;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.Predicate;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.infrautils.metrics.Counter;
import org.opendaylight.infrautils.metrics.Labeled;
import org.opendaylight.infrautils.metrics.MetricDescriptor;
import org.opendaylight.infrautils.metrics.MetricProvider;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayConnectionInstanceRecoveryHandler;
import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayServiceRecoveryHandler;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.L2gatewayConnections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.l2gatewayconnections.L2gatewayConnection;
import org.slf4j.LoggerFactory;
@Singleton
-public class L2GatewayConnectionListener extends AsyncClusteredDataTreeChangeListenerBase<L2gatewayConnection,
- L2GatewayConnectionListener> implements RecoverableListener {
+public class L2GatewayConnectionListener extends AbstractClusteredAsyncDataTreeChangeListener<L2gatewayConnection>
+ implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(L2GatewayConnectionListener.class);
private static final int MAX_READ_TRIALS = 120;
final L2GatewayServiceRecoveryHandler l2GatewayServiceRecoveryHandler,
final L2GatewayConnectionInstanceRecoveryHandler l2InstanceRecoveryHandler,
final ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(L2gatewayConnection.class, L2GatewayConnectionListener.class);
+ super(db, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(L2gatewayConnections.class).child(L2gatewayConnection.class),
+ Executors.newListeningSingleThreadExecutor("L2GatewayConnectionListener", LOG));
this.broker = db;
this.l2GatewayConnectionUtils = l2GatewayConnectionUtils;
this.scheduler = scheduler;
this);
serviceRecoveryRegistry.addRecoverableListener(l2InstanceRecoveryHandler.buildServiceRegistryKey(),
this);
+ init();
}
- @PostConstruct
public void init() {
loadL2GwDeviceCache(1);
LOG.trace("Loading l2gw connection cache");
loadL2GwConnectionCache();
- registerListener();
+ }
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
public void registerListener() {
+ super.register();
LOG.info("Registering L2GatewayConnectionListener");
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
}
public void deregisterListener() {
+ super.close();
LOG.info("Deregistering L2GatewayConnectionListener");
- super.deregisterListener();
}
@Override
- protected void add(final InstanceIdentifier<L2gatewayConnection> identifier, final L2gatewayConnection input) {
+ public void add(final InstanceIdentifier<L2gatewayConnection> identifier, final L2gatewayConnection input) {
LOG.trace("Adding L2gatewayConnection: {}", input);
elanConnectionsCounter
.label(DataObjectModification.ModificationType.WRITE.name())
}
@Override
- protected void remove(InstanceIdentifier<L2gatewayConnection> identifier, L2gatewayConnection input) {
+ public void remove(InstanceIdentifier<L2gatewayConnection> identifier, L2gatewayConnection input) {
LOG.trace("Removing L2gatewayConnection: {}", input);
elanConnectionsCounter
.label(DataObjectModification.ModificationType.DELETE.name())
}
@Override
- protected void update(InstanceIdentifier<L2gatewayConnection> identifier, L2gatewayConnection original,
+ public void update(InstanceIdentifier<L2gatewayConnection> identifier, L2gatewayConnection original,
L2gatewayConnection update) {
LOG.trace("Updating L2gatewayConnection : original value={}, updated value={}", original, update);
}
- @Override
- protected InstanceIdentifier<L2gatewayConnection> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(L2gatewayConnections.class)
- .child(L2gatewayConnection.class);
- }
-
- @Override
- protected L2GatewayConnectionListener getDataTreeChangeListener() {
- return this;
- }
-
@SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void loadL2GwDeviceCache(final int trialNo) {
LOG.error("Failed to read config topology");
return;
}
- ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
+ ReadTransaction tx = broker.newReadOnlyTransaction();
InstanceIdentifier<Topology> topoIid = HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier();
Futures.addCallback(tx.read(CONFIGURATION, topoIid), new FutureCallback<Optional<Topology>>() {
@Override
if (topologyOptional != null && topologyOptional.isPresent()) {
loadL2GwDeviceCache(topologyOptional.get().getNode());
}
- registerListener(CONFIGURATION, broker);
+ registerListener();
}
@Override
.create(Neutron.class)
.child(L2gatewayConnections.class);
- Optional<L2gatewayConnections> optional = MDSALUtil.read(broker, CONFIGURATION, parentIid);
+ Optional<L2gatewayConnections> optional = Optional.empty();
+ try {
+ optional = SingleTransactionDataBroker.syncReadOptional(broker, CONFIGURATION,
+ parentIid);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("loadL2GwConnectionCache: Exception while reading L2gatewayConnections DS", e);
+ }
if (optional.isPresent() && optional.get().getL2gatewayConnection() != null) {
LOG.trace("Found some connections to fill in l2gw connection cache");
optional.get().getL2gatewayConnection()
import java.util.List;
import java.util.Map;
import java.util.Set;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayInstanceRecoveryHandler;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
import org.slf4j.LoggerFactory;
@Singleton
-public class L2GatewayListener extends AsyncClusteredDataTreeChangeListenerBase<L2gateway, L2GatewayListener>
+public class L2GatewayListener extends AbstractClusteredAsyncDataTreeChangeListener<L2gateway>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(L2GatewayListener.class);
private final DataBroker dataBroker;
final JobCoordinator jobCoordinator, final L2GatewayCache l2GatewayCache,
L2GatewayInstanceRecoveryHandler l2GatewayInstanceRecoveryHandler,
ServiceRecoveryRegistry serviceRecoveryRegistry) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(L2gateways.class).child(L2gateway.class),
+ Executors.newListeningSingleThreadExecutor("L2GatewayListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.entityOwnershipUtils = new EntityOwnershipUtils(entityOwnershipService);
this.l2GatewayCache = l2GatewayCache;
serviceRecoveryRegistry.addRecoverableListener(l2GatewayInstanceRecoveryHandler.buildServiceRegistryKey(),
this);
+ init();
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener();
+ }
+
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
public void registerListener() {
+ super.register();
LOG.info("Registering L2Gateway Listener");
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
public void deregisterListener() {
+ super.close();
LOG.info("Deregistering L2GatewayListener");
- super.deregisterListener();
}
@Override
- protected InstanceIdentifier<L2gateway> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(L2gateways.class).child(L2gateway.class);
- }
-
- @Override
- protected void add(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
+ public void add(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
LOG.info("Adding L2gateway with ID: {}", input.getUuid());
for (Devices l2Device : input.nonnullDevices()) {
}
@Override
- protected void remove(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
+ public void remove(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
LOG.info("Removing L2gateway with ID: {}", input.getUuid());
List<L2gatewayConnection> connections = l2gwService
.getL2GwConnectionsByL2GatewayId(input.getUuid());
}
@Override
- protected void update(InstanceIdentifier<L2gateway> identifier, L2gateway original, L2gateway update) {
+ public void update(InstanceIdentifier<L2gateway> identifier, L2gateway original, L2gateway update) {
LOG.trace("Updating L2gateway : key: {}, original value={}, update value={}", identifier, original, update);
List<L2gatewayConnection> connections = l2gwService.getAssociatedL2GwConnections(
Sets.newHashSet(update.getUuid()));
}
}
- @Override
- protected L2GatewayListener getDataTreeChangeListener() {
- return this;
- }
-
static class DeviceInterfaces {
Map<String, Map<String, Interfaces>> deviceInterfacesMap = new HashMap<>();
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAOpClusteredListener;
}
elanL2GwDevice.removeUcastLocalMac(macRemoved);
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
elanL2GatewayUtils.unInstallL2GwUcastMacFromL2gwDevices(elanName, elanL2GwDevice,
Collections.singletonList(macAddress));
elanL2GatewayUtils.unInstallL2GwUcastMacFromElanDpns(elanInstance, elanL2GwDevice,
LOG.trace("LocalUcastMacs {} added to {}", macAddress, hwvtepNodeId);
- ElanInstance elan = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elan = elanInstanceCache.get(elanName).orElse(null);
if (elan == null) {
LOG.warn("Could not find ELAN for mac {} being added", macAddress);
return;
LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
LOG.trace("On parent add {}", nodeIid);
Node operNode = modification.getRootNode().getDataAfter();
- Set<LocalUcastMacs> configMacs = getMacs(tx.read(nodeIid).get().orNull());
+ Set<LocalUcastMacs> configMacs = getMacs(tx.read(nodeIid).get().orElse(null));
Set<LocalUcastMacs> operMacs = getMacs(operNode);
Set<LocalUcastMacs> staleMacs = Sets.difference(configMacs, operMacs);
staleMacs.forEach(staleMac -> removed(getMacIid(nodeIid, staleMac), staleMac));
*/
package org.opendaylight.netvirt.elan.l2gw.recovery.impl;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
.child(L2gatewayConnections.class)
.child(L2gatewayConnection.class, new L2gatewayConnectionKey(uuid));
- Optional<L2gatewayConnection> l2gatewayConnectionOptional = MDSALUtil
- .read(dataBroker, LogicalDatastoreType.CONFIGURATION, connectionInstanceIdentifier);
+ Optional<L2gatewayConnection> l2gatewayConnectionOptional = Optional.empty();
+ try {
+ l2gatewayConnectionOptional = SingleTransactionDataBroker.syncReadOptional(
+ dataBroker, LogicalDatastoreType.CONFIGURATION, connectionInstanceIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("recoverService: Exception while reading L2gatewayConnection DS", e);
+ }
//l2GatewayConnectionUtils.addL2GatewayConnection(l2gatewayConnectionOptional.get());
- L2gatewayConnection l2gatewayConnection = l2gatewayConnectionOptional.get();
+ if (l2gatewayConnectionOptional.isPresent()) {
+ L2gatewayConnection l2gatewayConnection = l2gatewayConnectionOptional.get();
- try {
- LOG.info("deleting l2 gateway connection {}",l2gatewayConnection.key());
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.delete(LogicalDatastoreType.CONFIGURATION, connectionInstanceIdentifier)).get();
- LOG.info("recreating l2 gateway connection {}, {}",entityId, l2gatewayConnection.key());
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.put(LogicalDatastoreType.CONFIGURATION, connectionInstanceIdentifier,
- l2gatewayConnection)).get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Service recovery failed for l2gw connection {}", entityId);
+ try {
+ LOG.info("deleting l2 gateway connection {}",l2gatewayConnection.key());
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ tx -> tx.delete(LogicalDatastoreType.CONFIGURATION, connectionInstanceIdentifier)).get();
+ LOG.info("recreating l2 gateway connection {}, {}",entityId, l2gatewayConnection.key());
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ tx -> tx.put(LogicalDatastoreType.CONFIGURATION, connectionInstanceIdentifier,
+ l2gatewayConnection)).get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Service recovery failed for l2gw connection {}", entityId);
+ }
}
}
*/
package org.opendaylight.netvirt.elan.l2gw.recovery.impl;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
InstanceIdentifier<L2gateway> l2gatewayInstanceIdentifier = InstanceIdentifier.create(Neutron.class)
.child(L2gateways.class).child(L2gateway.class, new L2gatewayKey(uuid));
- Optional<L2gateway> l2gatewayOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- l2gatewayInstanceIdentifier);
- L2gateway l2gateway = l2gatewayOptional.get();
+ Optional<L2gateway> l2gatewayOptional = Optional.empty();
+ try {
+ l2gatewayOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, l2gatewayInstanceIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("recoverService: Exception while reading L2gateway DS for the entity {}", entityId, e);
+ }
+
+ if (l2gatewayOptional.isPresent()) {
+ L2gateway l2gateway = l2gatewayOptional.get();
- List<L2gatewayConnection> l2gatewayConnections = l2GatewayConnectionUtils.getL2GwConnectionsByL2GatewayId(uuid);
- // Do a delete of l2 gateway connection instances.
- //No null check required since l2gatewayConnections is known to be non-null.
- LOG.info("Deleting all l2 gateway connections of l2 gateway instance {}", l2gateway.key());
- for (L2gatewayConnection l2gatewayConnection: l2gatewayConnections) {
- InstanceIdentifier<L2gatewayConnection> identifier = InstanceIdentifier.create(Neutron.class)
+ List<L2gatewayConnection> l2gatewayConnections = l2GatewayConnectionUtils
+ .getL2GwConnectionsByL2GatewayId(uuid);
+ // Do a delete of l2 gateway connection instances.
+ //No null check required since l2gatewayConnections is known to be non-null.
+ LOG.info("Deleting all l2 gateway connections of l2 gateway instance {}",
+ l2gateway.key());
+ for (L2gatewayConnection l2gatewayConnection : l2gatewayConnections) {
+ InstanceIdentifier<L2gatewayConnection> identifier = InstanceIdentifier
+ .create(Neutron.class)
.child(L2gatewayConnections.class)
.child(L2gatewayConnection.class, l2gatewayConnection.key());
- try {
- LOG.info("Deleting l2 gateway connection {}",l2gatewayConnection.key());
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.delete(LogicalDatastoreType.CONFIGURATION, identifier)).get();
- LOG.info("Recreating l2 gateway connection {}",l2gatewayConnection.key());
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.put(LogicalDatastoreType.CONFIGURATION, identifier, l2gatewayConnection)).get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Service recovery failed for l2gw {}", entityId);
+ try {
+ LOG.info("Deleting l2 gateway connection {}", l2gatewayConnection.key());
+ managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ tx -> tx.delete(LogicalDatastoreType.CONFIGURATION, identifier)).get();
+ LOG.info("Recreating l2 gateway connection {}", l2gatewayConnection.key());
+ managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ tx -> tx.put(LogicalDatastoreType.CONFIGURATION, identifier,
+ l2gatewayConnection)).get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Service recovery failed for l2gw {}", entityId);
+ }
}
+ LOG.info("Finished recreation of all l2 gateway connections of l2 gateway instance {}",
+ l2gateway.key());
}
- LOG.info("Finished recreation of all l2 gateway connections of l2 gateway instance {}", l2gateway.key());
}
public String buildServiceRegistryKey() {
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
-import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elan.l2gw.jobs.HwvtepDeviceMcastMacUpdateJob;
import org.opendaylight.netvirt.elan.l2gw.jobs.McastUpdateJob;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
operElanInstance = new SingleTransactionDataBroker(broker).syncReadOptional(
LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class, elanInfo.key())
- .build()).orNull();
- } catch (ReadFailedException e) {
+ .build()).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read elan instance operational path {}", elanInfo, e);
return emptyList();
}
* the l2 gateway device
* @return the listenable future
*/
- public List<ListenableFuture<Void>> handleMcastForElanL2GwDeviceDelete(String elanName,
+ public List<FluentFuture<?>> handleMcastForElanL2GwDeviceDelete(String elanName,
L2GatewayDevice l2GatewayDevice) {
- ListenableFuture<Void> deleteTepFuture =
+ FluentFuture<?> deleteTepFuture =
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> tx.delete(buildExternalTepPath(elanName, l2GatewayDevice.getTunnelIp())));
updateMcastMacsForAllElanDevices(elanName, l2GatewayDevice, false/* updateThisDevice */);
- ListenableFuture<Void> deleteRemoteMcastMacFuture = deleteRemoteMcastMac(
+ FluentFuture<?> deleteRemoteMcastMacFuture = deleteRemoteMcastMac(
new NodeId(l2GatewayDevice.getHwvtepNodeId()), elanName);
return Arrays.asList(deleteRemoteMcastMacFuture, deleteTepFuture);
}
* the logical switch name
* @return the listenable future
*/
- public ListenableFuture<Void> deleteRemoteMcastMac(NodeId nodeId, String logicalSwitchName) {
+ public FluentFuture<? extends @NonNull CommitInfo> deleteRemoteMcastMac(NodeId nodeId, String logicalSwitchName) {
InstanceIdentifier<LogicalSwitches> logicalSwitch = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
RemoteMcastMacsKey remoteMcastMacsKey = new RemoteMcastMacsKey(new HwvtepLogicalSwitchRef(logicalSwitch),
*/
public DesignatedSwitchForTunnel getDesignatedSwitchForExternalTunnel(IpAddress tunnelIp,
String elanInstanceName) {
- InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier
+ try {
+ InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier
.builder(DesignatedSwitchesForExternalTunnels.class)
- .child(DesignatedSwitchForTunnel.class, new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp))
+ .child(DesignatedSwitchForTunnel.class,
+ new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp))
.build();
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier).orNull();
+ return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier)
+ .orElse(null);
+ } catch (ExecutionException e) {
+ LOG.error("Exception while retriving DesignatedSwitch for elan {} and tunnel {}",
+ elanInstanceName, tunnelIp, e);
+ } catch (InterruptedException e) {
+ LOG.error("Exception while retriving DesignatedSwitch for elan {} and tunnel {}",
+ elanInstanceName, tunnelIp, e);
+ }
+ return null;
}
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.apache.commons.lang3.tuple.Pair;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.cache.ElanInstanceDpnsCache;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
RemoteMcastMacsKey remoteMcastMacsKey = new RemoteMcastMacsKey(new HwvtepLogicalSwitchRef(logicalSwitch),
new MacAddress(ElanConstants.UNKNOWN_DMAC));
- return HwvtepUtils.getRemoteMcastMac(broker, datastoreType, nodeId, remoteMcastMacsKey);
+ try {
+ return HwvtepUtils.getRemoteMcastMac(broker, datastoreType, nodeId, remoteMcastMacsKey);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("readRemoteMcastMac: Exception while reading LogicalSwitches DS for the nodeId {}, "
+ + "logicalSwitchName {}", nodeId.getValue(), logicalSwitch, e);
+ }
+ return null;
}
/**
* the mac addresses
* @return the listenable future
*/
- private ListenableFuture<Void> removeRemoteUcastMacsFromExternalDevice(String deviceNodeId,
- String logicalSwitchName, List<PhysAddress> macAddresses) {
+ private FluentFuture<? extends CommitInfo> removeRemoteUcastMacsFromExternalDevice(String deviceNodeId,
+ String logicalSwitchName,
+ List<PhysAddress> macAddresses) {
NodeId nodeId = new NodeId(deviceNodeId);
// TODO (eperefr)
&& !areMLAGDevices(extL2GwDevice, otherDevice)) {
final String hwvtepId = otherDevice.getHwvtepNodeId();
final String logicalSwitchName = elanInstanceName;
- futures.add(HwvtepUtils.installUcastMacs(
- broker, hwvtepId, macList, logicalSwitchName, extL2GwDeviceTepIp));
+ HwvtepUtils.installUcastMacs(broker, hwvtepId, macList, logicalSwitchName,
+ extL2GwDeviceTepIp);
}
}
return futures;
LOG.trace("No L2 gateway devices in Elan [{}] cache.", elanName);
return;
}
- final ElanInstance elan = elanInstanceCache.get(elanName).orNull();
+ final ElanInstance elan = elanInstanceCache.get(elanName).orElse(null);
if (elan == null) {
LOG.error("Could not find Elan by name: {}", elanName);
return;
* the elan name
* @return the listenable future
*/
- public ListenableFuture<Void> deleteElanMacsFromL2GatewayDevice(String hwvtepNodeId, String elanName) {
+ public FluentFuture<? extends CommitInfo> deleteElanMacsFromL2GatewayDevice(String hwvtepNodeId, String elanName) {
String logicalSwitch = getLogicalSwitchFromElan(elanName);
List<MacAddress> lstElanMacs = getRemoteUcastMacs(new NodeId(hwvtepNodeId), logicalSwitch,
LogicalDatastoreType.CONFIGURATION);
- ListenableFuture<Void> future = HwvtepUtils.deleteRemoteUcastMacs(broker, new NodeId(hwvtepNodeId),
+ FluentFuture<? extends CommitInfo> future = HwvtepUtils.deleteRemoteUcastMacs(broker, new NodeId(hwvtepNodeId),
logicalSwitch, lstElanMacs);
- Futures.addCallback(future, new FutureCallback<Void>() {
+ Futures.addCallback(future, new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(Void noarg) {
+ public void onSuccess(CommitInfo noarg) {
LOG.trace("Successful in batch deletion of elan [{}] macs from l2gw device [{}]", elanName,
hwvtepNodeId);
}
public List<MacAddress> getRemoteUcastMacs(NodeId hwvtepNodeId, String logicalSwitch,
LogicalDatastoreType datastoreType) {
List<MacAddress> lstMacs = Collections.emptyList();
- Node hwvtepNode = HwvtepUtils.getHwVtepNode(broker, datastoreType, hwvtepNodeId);
+ Node hwvtepNode;
+ try {
+ hwvtepNode = HwvtepUtils.getHwVtepNode(broker, datastoreType, hwvtepNodeId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getRemoteUcastMacs: Exception while reading hwvtepNodeId DS for the hwvtepNodeId {}",
+ hwvtepNodeId.getValue(), e);
+ return Collections.emptyList();
+ }
if (hwvtepNode != null) {
List<RemoteUcastMacs> remoteUcastMacs = hwvtepNode.augmentation(HwvtepGlobalAugmentation.class)
.getRemoteUcastMacs();
* the l2 gateway device which has to be configured
* @return the listenable future
*/
- public ListenableFuture<Void> installElanMacsInL2GatewayDevice(String elanName,
- L2GatewayDevice l2GatewayDevice) {
+ public FluentFuture<? extends CommitInfo> installElanMacsInL2GatewayDevice(String elanName,
+ L2GatewayDevice l2GatewayDevice) {
String logicalSwitchName = getLogicalSwitchFromElan(elanName);
NodeId hwVtepNodeId = new NodeId(l2GatewayDevice.getHwvtepNodeId());
List<RemoteUcastMacs> lstRemoteUcastMacs = new ArrayList<>(lstL2GatewayDevicesMacs);
lstRemoteUcastMacs.addAll(lstElanMacTableEntries);
- ListenableFuture<Void> future = HwvtepUtils.addRemoteUcastMacs(broker, hwVtepNodeId, lstRemoteUcastMacs);
+ FluentFuture<? extends CommitInfo> future = HwvtepUtils.addRemoteUcastMacs(broker, hwVtepNodeId,
+ lstRemoteUcastMacs);
LOG.info("Added RemoteUcastMacs entries [{}] in config DS. NodeID: {}, LogicalSwitch: {}",
lstRemoteUcastMacs.size(), hwVtepNodeId.getValue(), logicalSwitchName);
InstanceIdentifier<Interface> interfaceId = getInterfaceIdentifier(interfaceKey);
try {
return SingleTransactionDataBroker
- .syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, interfaceId).orNull();
- } catch (ReadFailedException e) {
+ .syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, interfaceId).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
// TODO remove this, and propagate ReadFailedException instead of re-throw RuntimeException
LOG.error("getInterfaceFromConfigDS({}) failed", interfaceKey, e);
throw new RuntimeException(e);
LOG.info("Deleting L2GatewayDevice [{}] UcastLocalMacs from elan [{}]", l2GatewayDevice.getHwvtepNodeId(),
elanName);
- ElanInstance elan = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elan = elanInstanceCache.get(elanName).orElse(null);
if (elan == null) {
LOG.error("Could not find Elan by name: {}", elanName);
return;
.filter(deviceVteps -> !Objects.equals(psNodeId, deviceVteps.getNodeId())
|| !Objects.equals(tunnelIp, deviceVteps.getIpAddress()))//node id or tunnel ip is changed
.forEach(deviceVteps -> deleteStaleL2gwTep(dataBroker, itmRpcService, deviceVteps));
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Failed delete stale tunnels for {}", globalNodeId);
}
}
- private static Optional<TransportZones> readTransportZone(DataBroker dataBroker) throws ReadFailedException {
+ private static Optional<TransportZones> readTransportZone(DataBroker dataBroker) throws ExecutionException,
+ InterruptedException {
return new SingleTransactionDataBroker(dataBroker).syncReadOptional(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(TransportZones.class).build());
}
- private static Optional<ElanInstances> readElanInstances(DataBroker dataBroker) throws ReadFailedException {
+ private static Optional<ElanInstances> readElanInstances(DataBroker dataBroker) throws ExecutionException,
+ InterruptedException {
return new SingleTransactionDataBroker(dataBroker).syncReadOptional(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(ElanInstances.class).build());
}
.forEach(tx::delete)), LOG,
"Failed to delete stale external teps {}", deviceVteps);
Thread.sleep(10000);//TODO remove the sleep currently it waits for interfacemgr to finish the cleanup
- } catch (ReadFailedException | InterruptedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Failed to delete stale l2gw tep {}", deviceVteps, e);
}
}
.map(mac -> new MacAddress(mac.getMacEntryKey().getValue().toLowerCase(Locale.ENGLISH)))
.collect(Collectors.toList()));
}
- Optional<Node> configNode = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
- HwvtepSouthboundUtils.createInstanceIdentifier(new NodeId(l2gwDevice.getHwvtepNodeId())));
+ Optional<Node> configNode;
+ try {
+ configNode = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ HwvtepSouthboundUtils.createInstanceIdentifier(new NodeId(l2gwDevice.getHwvtepNodeId())));
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getL2GwDeviceLocalMacs: Exception while reading l2gwDevice DS for the elan {}, l2gwDevice {}",
+ elanName, l2gwDevice, e);
+ return Collections.emptyList();
+ }
if (configNode.isPresent()) {
HwvtepGlobalAugmentation augmentation = configNode.get().augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.cache.ConfigMcastCache;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.cache.ElanInstanceDpnsCache;
import static java.util.Collections.emptyList;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
-import com.google.common.util.concurrent.SettableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.RetryingManagedNewTransactionRunner;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAOpClusteredListener;
import org.opendaylight.netvirt.elan.l2gw.jobs.AssociateHwvtepToElanJob;
private final ElanRefUtil elanRefUtil;
private final L2GatewayServiceRecoveryHandler l2GatewayServiceRecoveryHandler;
private final ServiceRecoveryRegistry serviceRecoveryRegistry;
+ private final ManagedNewTransactionRunner txRunner;
@Inject
public L2GatewayConnectionUtils(DataBroker dataBroker, ElanClusterUtils elanClusterUtils,
this.elanRefUtil = elanRefUtil;
this.l2GatewayServiceRecoveryHandler = l2GatewayServiceRecoveryHandler;
this.serviceRecoveryRegistry = serviceRecoveryRegistry;
+ this.txRunner = new RetryingManagedNewTransactionRunner(dataBroker);
}
@Override
LOG.debug("getNeutronL2gateway for {}", l2GatewayId.getValue());
InstanceIdentifier<L2gateway> inst = InstanceIdentifier.create(Neutron.class).child(L2gateways.class)
.child(L2gateway.class, new L2gatewayKey(l2GatewayId));
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst).orNull();
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, inst)
+ .orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS for the ID {}", l2GatewayId, e);
+ }
+ return null;
}
@NonNull
public static List<L2gateway> getL2gatewayList(DataBroker broker) {
InstanceIdentifier<L2gateways> inst = InstanceIdentifier.create(Neutron.class).child(L2gateways.class);
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst).toJavaUtil().map(
- L2gateways::getL2gateway).orElse(emptyList());
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, inst).map(
+ L2gateways::getL2gateway).orElse(emptyList());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS", e);
+ }
+ return null;
}
@NonNull
public static List<L2gatewayConnection> getAllL2gatewayConnections(DataBroker broker) {
InstanceIdentifier<L2gatewayConnections> inst = InstanceIdentifier.create(Neutron.class)
.child(L2gatewayConnections.class);
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst).toJavaUtil().map(
- L2gatewayConnections::getL2gatewayConnection).orElse(emptyList());
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, inst).map(
+ L2gatewayConnections::getL2gatewayConnection).orElse(emptyList());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNeutronL2gateway: Exception while reading L2gateway DS", e);
+ }
+ return null;
}
/**
// comes we need to wait for elaninstance to resolve. Hence updating the map with the runnable .
// When elanInstance add comes , it look in to the map and run the associated runnable associated with it.
ElanInstance elanInstance = elanInstanceCache.get(networkUuid.getValue(),
- () -> addL2GatewayConnection(input, l2GwDeviceName)).orNull();
+ () -> addL2GatewayConnection(input, l2GwDeviceName)).orElse(null);
if (elanInstance == null) {
return;
}
final InstanceIdentifier<Node> nodeIid = HwvtepSouthboundUtils.createInstanceIdentifier(
new NodeId(l2GatewayDevice.getHwvtepNodeId()));
jobCoordinator.enqueueJob(elanName + ":" + l2GatewayDevice.getDeviceName(), () -> {
- final SettableFuture settableFuture = SettableFuture.create();
- Futures.addCallback(broker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
- nodeIid), new SettableFutureCallback<Optional<Node>>(settableFuture) {
- @Override
- public void onSuccess(@NonNull Optional<Node> resultNode) {
+ FluentFuture<Optional<Node>> fluentFuture = broker.newReadOnlyTransaction().read(
+ LogicalDatastoreType.OPERATIONAL, nodeIid);
+ Futures.addCallback(fluentFuture, new FutureCallback<Optional<Node>>() {
+ @Override
+ public void onSuccess(Optional<Node> nodeOptional) {
+ if (nodeOptional.isPresent()) {
+ Node node = nodeOptional.get();
+ if (node.augmentation(HwvtepGlobalAugmentation.class) != null) {
+ List<LocalUcastMacs> localUcastMacs =
+ node.augmentation(HwvtepGlobalAugmentation.class).getLocalUcastMacs();
+ if (localUcastMacs == null) {
+ return;
+ }
LocalUcastMacListener localUcastMacListener =
new LocalUcastMacListener(broker, haOpClusteredListener,
elanL2GatewayUtils, jobCoordinator, elanInstanceCache, hwvtepNodeHACache,
l2GatewayServiceRecoveryHandler, serviceRecoveryRegistry);
- settableFuture.set(resultNode);
- Optional<Node> nodeOptional = resultNode;
- if (nodeOptional.isPresent()) {
- Node node = nodeOptional.get();
- if (node.augmentation(HwvtepGlobalAugmentation.class) != null) {
- List<LocalUcastMacs> localUcastMacs =
- node.augmentation(HwvtepGlobalAugmentation.class).getLocalUcastMacs();
- if (localUcastMacs == null) {
- return;
- }
- localUcastMacs.stream()
- .filter((mac) -> macBelongsToLogicalSwitch(mac, elanName))
- .forEach((mac) -> {
- InstanceIdentifier<LocalUcastMacs> macIid = getMacIid(nodeIid, mac);
- localUcastMacListener.added(macIid, mac);
- });
- }
- }
+ localUcastMacs.stream()
+ .filter((mac) -> macBelongsToLogicalSwitch(mac, elanName))
+ .forEach((mac) -> {
+ InstanceIdentifier<LocalUcastMacs> macIid = getMacIid(nodeIid, mac);
+ localUcastMacListener.added(macIid, mac);
+ });
}
- }, MoreExecutors.directExecutor());
- return Lists.newArrayList(settableFuture);
+ }
+ }
+
+ @Override
+ public void onFailure(Throwable throwable) {
+ }
+ }, MoreExecutors.directExecutor());
+ return Lists.newArrayList(fluentFuture);
} , 5);
}
import java.util.Set;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.infrautils.inject.AbstractLifecycle;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.netvirt.elanmanager.api.IL2gwService;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.utils.Scheduler;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayCache;
() -> {
L2GatewayDevice l2GwDevice = l2GatewayCache.get(deviceName);
NodeId globalNodeId = globalNodeIid.firstKeyOf(Node.class).getNodeId();
- Node configNode = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, globalNodeIid)
- .or(defaultNode(globalNodeId));
- Node configPsNode =
- MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, psNodeIid).or(defaultNode(psNodeId));
- cleanupStaleLogicalSwitches(l2GwDevice, configNode, configPsNode);
- cleanupTasks.remove(psNodeIid.firstKeyOf(Node.class).getNodeId());
+ try {
+ Node configNode = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, globalNodeIid).orElse(defaultNode(globalNodeId));
+ Node configPsNode = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, psNodeIid)
+ .orElse(defaultNode(psNodeId));
+ cleanupStaleLogicalSwitches(l2GwDevice, configNode, configPsNode);
+ cleanupTasks.remove(psNodeIid.firstKeyOf(Node.class).getNodeId());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("scheduleStaleCleanup: Exception while reading globalNodeIid/psNodeIid DS for "
+ + "the globalNodeIid {} psNodeIid {}", globalNodeId, psNodeId, e);
+ }
}, getCleanupDelay(), TimeUnit.SECONDS);
});
}
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
*/
package org.opendaylight.netvirt.elan.statisitcs;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
HwvtepSouthboundConstants.ELAN_ENTITY_NAME, jobCoordinator, jobDesc, job);
}
- public void runOnlyInOwnerNode(String jobKey, String jobDesc, Callable<List<ListenableFuture<Void>>> job) {
+ public void runOnlyInOwnerNode(String jobKey, String jobDesc, Callable<List<? extends ListenableFuture<?>>> job) {
entityOwnershipUtils.runOnlyInOwnerNode(HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
HwvtepSouthboundConstants.ELAN_ENTITY_NAME, jobCoordinator, jobKey, jobDesc, job);
}
*/
package org.opendaylight.netvirt.elan.utils;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
*/
package org.opendaylight.netvirt.elan.utils;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeLeafTagName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.netvirt.elan.utils;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntry;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
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.interfaces.rev140508.interfaces.Interface;
package org.opendaylight.netvirt.elan.utils;
import static java.util.Collections.emptyList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import com.google.common.primitives.Ints;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-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.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
import org.opendaylight.infrautils.utils.concurrent.NamedLocks;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderUtil;
import org.opendaylight.netvirt.elan.cache.ElanInterfaceCache;
import org.opendaylight.netvirt.elan.internal.ElanGroupCache;
.setBucketId(new BucketId(id.incrementAndGet()))
.build();
- public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
+ public static final FutureCallback<CommitInfo> DEFAULT_CALLBACK = new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(CommitInfo result) {
LOG.debug("Success in Datastore operation");
}
@SuppressWarnings("checkstyle:IllegalCatch")
public static <T extends DataObject> Optional<T> read(@NonNull DataBroker broker,
LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
- } catch (Exception e) {
+ } catch (ExecutionException | InterruptedException e) {
throw new RuntimeException(e);
}
}
public <T extends DataObject> Optional<T> read2(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
- throws ReadFailedException {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
- CheckedFuture<Optional<T>, ReadFailedException> checkedFuture = tx.read(datastoreType, path);
- return checkedFuture.checkedGet();
+ throws InterruptedException, ExecutionException {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
+ FluentFuture<Optional<T>> checkedFuture = tx.read(datastoreType, path);
+ return checkedFuture.get();
}
}
@SuppressWarnings("checkstyle:ForbidCertainMethod")
public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) {
+ InstanceIdentifier<T> path) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.delete(datastoreType, path);
- Futures.addCallback(tx.submit(), DEFAULT_CALLBACK, MoreExecutors.directExecutor());
+ FluentFuture<? extends @NonNull CommitInfo> future = tx.commit();
+ future.addCallback(DEFAULT_CALLBACK, MoreExecutors.directExecutor());
}
public static InstanceIdentifier<ElanInterface> getElanInterfaceConfigurationDataPathId(String interfaceName) {
@Nullable
public static Elan getElanByName(DataBroker broker, String elanInstanceName) {
InstanceIdentifier<Elan> elanIdentifier = getElanInstanceOperationalDataPath(elanInstanceName);
- return MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanIdentifier).orNull();
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
+ elanIdentifier).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getElanByName: Exception while reading elan-instance DS for the elan instance {}",
+ elanInstanceName, e);
+ return null;
+ }
}
@Nullable
public static Elan getElanByName(TypedReadTransaction<Operational> tx, String elanInstanceName)
throws ExecutionException, InterruptedException {
- return tx.read(getElanInstanceOperationalDataPath(elanInstanceName)).get().orNull();
+ return tx.read(getElanInstanceOperationalDataPath(elanInstanceName)).get().orElse(null);
}
public static InstanceIdentifier<Elan> getElanInstanceOperationalDataPath(String elanInstanceName) {
public MacEntry getInterfaceMacEntriesOperationalDataPath(String interfaceName, PhysAddress physAddress) {
InstanceIdentifier<MacEntry> existingMacEntryId = getInterfaceMacEntriesIdentifierOperationalDataPath(
interfaceName, physAddress);
- return read(broker, LogicalDatastoreType.OPERATIONAL, existingMacEntryId).orNull();
+ return read(broker, LogicalDatastoreType.OPERATIONAL, existingMacEntryId).orElse(null);
}
@Nullable
public MacEntry getInterfaceMacEntriesOperationalDataPathFromId(TypedReadTransaction<Operational> tx,
InstanceIdentifier<MacEntry> identifier) throws ExecutionException, InterruptedException {
- return tx.read(identifier).get().orNull();
+ return tx.read(identifier).get().orElse(null);
}
public static InstanceIdentifier<MacEntry> getInterfaceMacEntriesIdentifierOperationalDataPath(String interfaceName,
@Nullable
public MacEntry getMacEntryFromElanMacId(TypedReadTransaction<Operational> tx,
InstanceIdentifier<MacEntry> identifier) throws ExecutionException, InterruptedException {
- return tx.read(identifier).get().orNull();
+ return tx.read(identifier).get().orElse(null);
}
public static InstanceIdentifier<MacEntry> getMacEntryOperationalDataPath(String elanName,
public static ElanInterfaceMac getElanInterfaceMacByInterfaceName(DataBroker dataBroker, String interfaceName) {
InstanceIdentifier<ElanInterfaceMac> elanInterfaceId = getElanInterfaceMacEntriesOperationalDataPath(
interfaceName);
- return read(dataBroker, LogicalDatastoreType.OPERATIONAL, elanInterfaceId).orNull();
+ return read(dataBroker, LogicalDatastoreType.OPERATIONAL, elanInterfaceId).orElse(null);
}
public static InstanceIdentifier<ElanInterfaceMac> getElanInterfaceMacEntriesOperationalDataPath(
public DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, Uint64 dpId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
dpId);
- return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orElse(null);
}
/**
InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
Optional<ElanTagName> existingElanInfo = read(broker,
LogicalDatastoreType.OPERATIONAL, elanId);
- return existingElanInfo.orNull();
+ return existingElanInfo.orElse(null);
}
public static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(Uint32 elanTag) {
@Nullable
public ElanDpnInterfacesList getElanDpnInterfacesList(String elanName) {
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanName);
- return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId).orNull();
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId).orElse(null);
}
@Nullable
public ElanDpnInterfaces getElanDpnInterfacesList() {
InstanceIdentifier<ElanDpnInterfaces> elanDpnInterfaceId = InstanceIdentifier.builder(ElanDpnInterfaces.class)
.build();
- return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId).orNull();
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId).orElse(null);
}
/**
@Nullable
public static MacTable getElanMacTable(DataBroker dataBroker, String elanName) {
InstanceIdentifier<MacTable> elanMacTableId = getElanMacTableOperationalDataPath(elanName);
- return read(dataBroker, LogicalDatastoreType.OPERATIONAL, elanMacTableId).orNull();
+ return read(dataBroker, LogicalDatastoreType.OPERATIONAL, elanMacTableId).orElse(null);
}
public static long getElanLocalBCGId(long elanTag) {
}
private Uint32 getElanTag(ElanInstance elanInfo, InterfaceInfo interfaceInfo) {
- EtreeInterface etreeInterface = elanInterfaceCache.getEtreeInterface(interfaceInfo.getInterfaceName()).orNull();
+ EtreeInterface etreeInterface = elanInterfaceCache
+ .getEtreeInterface(interfaceInfo.getInterfaceName()).orElse(null);
if (etreeInterface == null || etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
return elanInfo.getElanTag();
} else { // Leaf
@NonNull
public List<DpnInterfaces> getElanDPNByName(String elanInstanceName) {
InstanceIdentifier<ElanDpnInterfacesList> elanIdentifier = getElanDpnOperationDataPath(elanInstanceName);
- return MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanIdentifier).toJavaUtil().map(
- ElanDpnInterfacesList::getDpnInterfaces).orElse(emptyList());
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
+ elanIdentifier).map(ElanDpnInterfacesList::getDpnInterfaces).orElse(emptyList());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getElanDPNByName: Exception while reading elanDpnInterfaceList DS for the elan "
+ + "instance {}", elanInstanceName, e);
+ return emptyList();
+ }
}
private void setupLocalDmacFlow(Uint32 elanTag, Uint64 dpId, String ifName, String macAddress,
private void installEtreeLocalDmacFlow(Uint32 elanTag, Uint64 dpId, String ifName, String macAddress,
ElanInstance elanInfo, long ifTag, TypedWriteTransaction<Configuration> writeFlowGroupTx) {
- EtreeInterface etreeInterface = elanInterfaceCache.getEtreeInterface(ifName).orNull();
+ EtreeInterface etreeInterface = elanInterfaceCache.getEtreeInterface(ifName).orElse(null);
if (etreeInterface != null && etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
EtreeLeafTagName etreeTagName = elanEtreeUtils.getEtreeLeafTagByElanTag(elanTag.longValue());
if (etreeTagName == null) {
TypedWriteTransaction<Configuration> writeFlowGroupTx,
ElanInstance elanInstance) {
Flow flowEntity;
- EtreeInterface etreeInterface = elanInterfaceCache.getEtreeInterface(interfaceName).orNull();
+ EtreeInterface etreeInterface = elanInterfaceCache.getEtreeInterface(interfaceName).orElse(null);
if (etreeInterface != null && etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
EtreeLeafTagName etreeTagName = elanEtreeUtils.getEtreeLeafTagByElanTag(elanTag.longValue());
if (etreeTagName == null) {
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
InstanceIdentifier<ExternalTunnel> iid = InstanceIdentifier.builder(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(destinationDevice, sourceDevice, tunType)).build();
- return read(broker, datastoreType, iid).orNull();
+ return read(broker, datastoreType, iid).orElse(null);
}
/**
*/
public List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
- return read(broker, datastoreType, iid).toJavaUtil().map(ExternalTunnelList::getExternalTunnel).orElse(
+ return read(broker, datastoreType, iid).map(ExternalTunnelList::getExternalTunnel).orElse(
emptyList());
}
*/
public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
.@Nullable Interface getInterfaceStateFromOperDS(String interfaceName, DataBroker dataBroker) {
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- createInterfaceStateInstanceIdentifier(interfaceName)).orNull();
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ createInterfaceStateInstanceIdentifier(interfaceName)).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getInterfaceStateFromOperDS: Exception while reading interface DS for the interface {}",
+ interfaceName, e);
+ return null;
+ }
}
/**
}
public Optional<IpAddress> getSourceIpAddress(Ethernet ethernet) {
- Optional<IpAddress> srcIpAddress = Optional.absent();
+ Optional<IpAddress> srcIpAddress = Optional.empty();
if (ethernet.getPayload() == null) {
return srcIpAddress;
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.collect.MapDifference;
import com.google.common.collect.MapDifference.ValueDifference;
import com.google.common.collect.Maps;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.internal.ElanBridgeManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
}
if (ElanUtils.isVxlanNetworkOrVxlanSegment(
- elanInstanceCache.get(elanInt.getElanInstanceName()).orNull())) {
+ elanInstanceCache.get(elanInt.getElanInstanceName()).orElse(null))) {
return true;
} else {
LOG.debug("Non-VXLAN elanInstance: {}", elanInt.getElanInstanceName());
.child(TransportZone.class, new TransportZoneKey(zoneName));
// FIXME: Read this through a cache
- TransportZone zone = tx.read(inst).get().orNull();
+ TransportZone zone = tx.read(inst).get().orElse(null);
if (zone == null) {
zone = createZone(ALL_SUBNETS, zoneName);
.child(TransportZone.class, new TransportZoneKey(zoneName));
// FIXME: Read this through a cache
- TransportZone zone = tx.read(inst).get().orNull();
+ TransportZone zone = tx.read(inst).get().orElse(null);
if (zone != null) {
try {
deleteTransportZone(zone, dpnId, tx);
return tx.read(identifier).get();
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to read DPNTEPsInfo for DPN id {}", dpId);
- return Optional.absent();
+ return Optional.empty();
}
}
private Map<String, String> getDpnLocalIps(Uint64 dpId) throws ReadFailedException {
// Example of local IPs from other_config:
// local_ips="10.0.43.159:MPLS,11.11.11.11:DSL,ip:underlay-network"
- return getPortsNode(dpId).toJavaUtil().map(
+ return getPortsNode(dpId).map(
node -> elanBridgeManager.getOpenvswitchOtherConfigMap(node, LOCAL_IPS)).orElse(Collections.emptyMap());
}
InstanceIdentifier<BridgeRefEntry> bridgeRefInfoPath = InstanceIdentifier.create(BridgeRefInfo.class)
.child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId));
- // FIXME: Read this through a cache
- Optional<BridgeRefEntry> optionalBridgeRefEntry =
- singleTxBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
- if (!optionalBridgeRefEntry.isPresent()) {
- LOG.error("no bridge ref entry found for dpnId {}", dpnId);
- return Optional.absent();
- }
+ try {
+ // FIXME: Read this through a cache
+ Optional<BridgeRefEntry> optionalBridgeRefEntry =
+ singleTxBroker
+ .syncReadOptional(LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
+ if (!optionalBridgeRefEntry.isPresent()) {
+ LOG.error("no bridge ref entry found for dpnId {}", dpnId);
+ return Optional.empty();
+ }
- InstanceIdentifier<Node> nodeId =
- optionalBridgeRefEntry.get().getBridgeReference().getValue().firstIdentifierOf(Node.class);
+ InstanceIdentifier<Node> nodeId =
+ optionalBridgeRefEntry.get().getBridgeReference().getValue()
+ .firstIdentifierOf(Node.class);
- // FIXME: Read this through a cache
- Optional<Node> optionalNode = singleTxBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, nodeId);
- if (!optionalNode.isPresent()) {
- LOG.error("missing node for dpnId {}", dpnId);
+ // FIXME: Read this through a cache
+ Optional<Node> optionalNode = singleTxBroker
+ .syncReadOptional(LogicalDatastoreType.OPERATIONAL, nodeId);
+ if (!optionalNode.isPresent()) {
+ LOG.error("missing node for dpnId {}", dpnId);
+ }
+ return optionalNode;
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while getting ports for Node {}", dpnId, e);
}
- return optionalNode;
+ return Optional.empty();
}
private static String getTzNameForUnderlayNetwork(String zoneNamePrefix, String underlayNetworkName) {
private static Optional<String> getZonePrefixForUnderlayNetwork(String zoneName, String underlayNetworkName) {
String[] zoneParts = zoneName.split(IP_NETWORK_ZONE_NAME_DELIMITER + underlayNetworkName);
- return zoneParts.length == 2 ? Optional.of(zoneParts[0]) : Optional.absent();
+ return zoneParts.length == 2 ? Optional.of(zoneParts[0]) : Optional.empty();
}
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
- odl:type="pingpong" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
+ odl:type="default" />
<reference id="notificationService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationService" />
+ interface="org.opendaylight.mdsal.binding.api.NotificationService" />
<reference id="entityOwnershipService"
interface="org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService" />
<reference id="iMdsalApiManager"
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LogicalSwitchesCmd;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.UUID;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.handlers.NodeConnectedHandler;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
}
public void readNodes() throws Exception {
- ReadOnlyTransaction tx = getDataBroker().newReadOnlyTransaction();
+ ReadTransaction tx = getDataBroker().newReadOnlyTransaction();
d1GlobalOpNode = TestUtil.readNode(LogicalDatastoreType.OPERATIONAL, d1NodePath, tx);
d2GlobalOpNode = TestUtil.readNode(LogicalDatastoreType.OPERATIONAL, d2NodePath, tx);
haGlobalOpNode = TestUtil.readNode(LogicalDatastoreType.OPERATIONAL, haNodePath, tx);
*/
package org.opendaylight.netvirt.elan.l2gw.nodehandlertest;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LocalMcastCmd;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LocalUcastCmd;
import org.opendaylight.netvirt.elan.l2gw.ha.commands.LogicalSwitchesCmd;
InstanceIdentifier<Node> d2psnodePath,
InstanceIdentifier<Node> haPsnodePath,
ReadWriteTransaction readWriteTransaction, String switchName,
- Node d1, Node d2, Node ha) throws ReadFailedException {
+ Node d1, Node d2, Node ha)
+ throws ExecutionException, InterruptedException {
+
PhysicalSwitchAugmentation d1PsAug = d1ps.augmentation(PhysicalSwitchAugmentation.class);
PhysicalSwitchAugmentation d2PsAug = d2ps.augmentation(PhysicalSwitchAugmentation.class);
PhysicalSwitchAugmentation haPsAug = haps.augmentation(PhysicalSwitchAugmentation.class);
public static void comparePhysicalSwitches(Node d1ps, Node haps, InstanceIdentifier<Node> d1psnodePath,
InstanceIdentifier<Node> haPsnodePath,
ReadWriteTransaction readWriteTransaction,
- String switchName, Node d1, Node ha) throws ReadFailedException {
+ String switchName, Node d1, Node ha)
+ throws ExecutionException, InterruptedException {
//Compare Physical Augmentation data
PhysicalSwitchAugmentation d1PsAug = d1ps.augmentation(PhysicalSwitchAugmentation.class);
PhysicalSwitchAugmentation haPsAug = haps.augmentation(PhysicalSwitchAugmentation.class);
public static void assertTerminationPoint(List<String> terminationPointNames, InstanceIdentifier<Node> d1ps,
InstanceIdentifier<Node> haPsa, ReadWriteTransaction readWriteTransaction,
- Node nodeD, Node nodeHa) throws ReadFailedException {
+ Node nodeD, Node nodeHa) throws ExecutionException, InterruptedException {
for (String portName : terminationPointNames) {
InstanceIdentifier<TerminationPoint> tpPathd = d1ps.child(TerminationPoint.class,
new TerminationPointKey(new TpId(portName)));
TerminationPoint tpNoded = readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, tpPathd)
- .checkedGet().get();
+ .get().get();
HwvtepPhysicalPortAugmentation hwvtepPhysicalPortAugmentationD =
tpNoded.augmentation(HwvtepPhysicalPortAugmentation.class);
InstanceIdentifier<TerminationPoint> tpPathha = haPsa.child(TerminationPoint.class,
new TerminationPointKey(new TpId(portName)));
TerminationPoint tpNodeha = readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, tpPathha)
- .checkedGet().get();
+ .get().get();
HwvtepPhysicalPortAugmentation hwvtepPhysicalPortAugmentationHa =
tpNodeha.augmentation(HwvtepPhysicalPortAugmentation.class);
assertEquals("Termination point hwvtep-node-name should be same",
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Optional;
-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.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
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;
}
static Optional<Node> readNode(LogicalDatastoreType datastoreType, InstanceIdentifier<Node> id,
- ReadOnlyTransaction tx) throws Exception {
- return tx.read(datastoreType, id).checkedGet();
+ ReadTransaction tx) throws Exception {
+ return tx.read(datastoreType, id).get();
}
package org.opendaylight.netvirt.elanmanager.tests;
import static java.util.Arrays.asList;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
import javax.inject.Inject;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.rules.MethodRule;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.infrautils.metrics.testimpl.TestMetricProviderImpl;
import org.opendaylight.infrautils.testutils.LogRule;
import org.opendaylight.mdsal.binding.testutils.AssertDataObjects;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elan.cache.ElanInstanceDpnsCache;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.awaitility.Awaitility;
import org.awaitility.core.ConditionFactory;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.testutils.TestInterfaceManager;
import org.opendaylight.genius.testutils.interfacemanager.TunnelInterfaceDetails;
import org.opendaylight.genius.testutils.itm.ItmRpcTestImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.internal.ElanInstanceManager;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
}
- protected void setupItm() throws TransactionCommitFailedException {
+ protected void setupItm() throws ExecutionException, InterruptedException {
/*Add tap port and tunnel ports in DPN1 and DPN2*/
interfaceMgr.addInterfaceInfo(ELAN_INTERFACES.get(ELAN1 + ":" + DPN1MAC1).getLeft());
interfaceMgr.addInterfaceInfo(ELAN_INTERFACES.get(ELAN1 + ":" + DPN1MAC2).getLeft());
}
public void addElanInterface(String elanInstanceName, InterfaceInfo interfaceInfo, String prefix) {
- ElanInstance existingElanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance existingElanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
String interfaceName = interfaceInfo.getInterfaceName();
if (existingElanInstance != null) {
import static org.mockito.Mockito.CALLS_REAL_METHODS;
import static org.mockito.Mockito.mock;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
+import java.util.concurrent.Executors;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.infrautils.inject.guice.testutils.AbstractGuiceJsr250Module;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.metrics.testimpl.TestMetricProviderImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
public class ElanServiceTestModule extends AbstractGuiceJsr250Module {
@Override
- protected void configureBindings() {
- DataBroker dataBroker = DataBrokerTestModule.dataBroker();
+ protected void configureBindings() throws Exception {
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();
EntityOwnershipService mockedEntityOwnershipService = mock(EntityOwnershipService.class);
EntityOwnershipState mockedEntityOwnershipState = EntityOwnershipState.IS_OWNER;
Mockito.when(mockedEntityOwnershipService.getOwnershipState(Mockito.any()))
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.elan.l2gw.nodehandlertest.GlobalAugmentationHelper;
import org.opendaylight.netvirt.elan.l2gw.nodehandlertest.TestBuilders;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
*/
package org.opendaylight.netvirt.elanmanager.tests;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.awaitility.core.ConditionFactory;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.actions.ActionGroup;
import org.opendaylight.genius.testutils.interfacemanager.TunnelInterfaceDetails;
import org.opendaylight.mdsal.binding.testutils.AssertDataObjects;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import java.util.Collections;
import java.util.List;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.BgpControlPlaneType;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.StringUtils;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.elanmanager.tests.ExpectedObjects;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
*/
package org.opendaylight.netvirt.elanmanager.tests.utils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
public abstract class VpnManagerTestImpl implements IVpnManager {
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
.collect(Collectors.toList());
}
- public static com.google.common.base.Optional<VrfEntry> getVrfEntry(DataBroker broker, String rd, String ipPrefix) {
+ public static Optional<VrfEntry> getVrfEntry(DataBroker broker, String rd, String ipPrefix) {
InstanceIdentifier<VrfEntry> vrfEntryId = InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
return read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
}
- private static <T extends DataObject> com.google.common.base.Optional<T> read(DataBroker broker,
+ private static <T extends DataObject> Optional<T> read(DataBroker broker,
LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
package org.opendaylight.netvirt.fibmanager.api;
import com.google.common.util.concurrent.FutureCallback;
-
import java.util.List;
-
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.RouterInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
void removeFibEntry(String rd, String prefix, String eventSource,
@Nullable TypedWriteTransaction<Configuration> writeConfigTxn);
- void updateRoutePathForFibEntry(String rd, String prefix, String nextHop,
- Uint32 label, boolean nextHopAdd, WriteTransaction writeConfigTxn);
+ void updateRoutePathForFibEntry(String rd, String prefix, String nextHop, Uint32 label, boolean nextHopAdd,
+ TypedWriteTransaction<Configuration> writeConfigTxn);
void addVrfTable(String rd, WriteTransaction writeConfigTxn);
import static java.util.stream.Collectors.toList;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
-import com.google.common.base.Optional;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.batching.SubTransactionImpl;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.NexthopManager.AdjacencyResult;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
public Routes getVpnToExtraroute(Uint32 vpnId, String vpnRd, String destPrefix) {
String optVpnName = fibUtil.getVpnNameFromId(vpnId);
if (optVpnName != null) {
- InstanceIdentifier<Routes> vpnExtraRoutesId = getVpnToExtrarouteIdentifier(
- optVpnName, vpnRd, destPrefix);
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, vpnExtraRoutesId).orNull();
+ InstanceIdentifier<Routes> vpnExtraRoutesId = getVpnToExtrarouteIdentifier(optVpnName, vpnRd, destPrefix);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ vpnExtraRoutesId).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnToExtraroute: Exception while reading vpn-to-extraroute DS for the prefix {} "
+ + "rd {} vpnId {} ", destPrefix, vpnRd, vpnId, e);
+ }
}
return null;
}
import static java.util.stream.Collectors.toList;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Consumer;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.batching.ResourceHandler;
import org.opendaylight.genius.utils.batching.SubTransaction;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
}
}
+ @Override
+ public void updateContainer(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
+ Object original, Object update, List<SubTransaction> transactionObjects) {
+ }
+
@Override
public void create(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
Object vrfEntry, List<SubTransaction> subTxns) {
usedRds.get(0), vrfEntry.getDestPrefix());
}
} else {
- extraRouteOptional = Optional.absent();
+ extraRouteOptional = Optional.empty();
}
for (VpnToDpnList curDpn : vpnToDpnList) {
if (curDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
.ifPresent(routes -> {
LOG.trace(" deleting remote FIB entry {}", vrfEntry);
deleteRemoteRoute(null, dpnId, vpnId, vrfTable.get().key(), vrfEntry,
- Optional.absent(), writeCfgTxn, subTxns);
+ Optional.empty(), writeCfgTxn, subTxns);
});
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.Optional;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
import org.opendaylight.genius.utils.batching.SubTransaction;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
if (vpnToDpnList != null) {
jobCoordinator.enqueueJob("FIB" + rd + vrfEntry.getDestPrefix(),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
- final Optional<Routes> extraRouteOptional = Optional.absent();
+ final Optional<Routes> extraRouteOptional = Optional.empty();
if (localDpnIdList.size() <= 0) {
for (VpnToDpnList curDpn1 : vpnToDpnList) {
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
*/
package org.opendaylight.netvirt.fibmanager;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
@Override
public void updateRoutePathForFibEntry(String rd, String prefix, String nextHop,
- Uint32 label, boolean nextHopAdd, WriteTransaction writeConfigTxn) {
+ Uint32 label, boolean nextHopAdd, TypedWriteTransaction<Configuration> writeConfigTxn) {
fibUtil.updateRoutePathForFibEntry(rd, prefix, nextHop, label, nextHopAdd, writeConfigTxn);
}
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Destination;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
@Nullable
public static String getVpnRd(DataBroker broker, String vpnName) {
InstanceIdentifier<VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
- VpnInstance::getVrfId).orElse(null);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, id)
+ .map(VpnInstance::getVrfId).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnRd: Exception while reading VpnInstance DS for the vpn {}", vpnName, e);
+ }
+ return null;
}
static InstanceIdentifier<VpnInstance> getVpnInstanceToVpnIdIdentifier(String vpnName) {
static Uint32 getVpnId(DataBroker broker, String vpnName) {
InstanceIdentifier<VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
- VpnInstance::getVpnId).orElse(Uint32.ZERO);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, id)
+ .map(VpnInstance::getVpnId).orElse(Uint32.ZERO);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnId: Exception while reading VpnInstance DS for the vpn {}", vpnName, e);
+ }
+ return Uint32.ZERO;
}
}
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.mdsalutil.NWUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.fibmanager.NexthopManager.AdjacencyResult;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
Optional<VpnInstanceOpDataEntry> getVpnInstanceOpData(String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnInstance: Exception while reading the VpnInstanceOpData DS for the rd {} ", rd, e);
+ }
+ return Optional.empty();
}
static Optional<VpnInstanceOpDataEntry> getVpnInstanceOpData(TypedReadTransaction<Operational> operTx, String rd)
InstanceIdentifier<VpnInstanceOpDataEntry> id =
InstanceIdentifier.create(VpnInstanceOpData.class)
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd));
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpData =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = Optional.empty();
+ try {
+ vpnInstanceOpData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnInstance: Exception while reading the VpnInstanceOpData DS for the rd {} ", rd, e);
+ }
return vpnInstanceOpData.isPresent() ? vpnInstanceOpData.get() : null;
}
@Nullable
Prefixes getPrefixToInterface(Uint32 vpnId, String ipPrefix) {
- Optional<Prefixes> localNextHopInfoData = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- getPrefixToInterfaceIdentifier(vpnId, ipPrefix));
+ Optional<Prefixes> localNextHopInfoData = Optional.empty();
+ try {
+ localNextHopInfoData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL,
+ getPrefixToInterfaceIdentifier(vpnId, ipPrefix));
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getPrefixToInterface: Exception while reading the prefixToInterface DS for the "
+ + "prefix {} vpnId {}", ipPrefix, vpnId, e);
+ }
return localNextHopInfoData.isPresent() ? localNextHopInfoData.get() : null;
}
@Nullable
static Prefixes getPrefixToInterface(TypedReadTransaction<Operational> operTx, Uint32 vpnId, String ipPrefix)
throws ExecutionException, InterruptedException {
- return operTx.read(getPrefixToInterfaceIdentifier(vpnId, ipPrefix)).get().orNull();
+ return operTx.read(getPrefixToInterfaceIdentifier(vpnId, ipPrefix)).get().orElse(null);
}
@Nullable
String getMacAddressFromPrefix(String ifName, String vpnName, String ipPrefix) {
- Optional<Adjacency> adjacencyData = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- getAdjacencyIdentifierOp(ifName, vpnName, ipPrefix));
+ Optional<Adjacency> adjacencyData;
+ try {
+ adjacencyData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, getAdjacencyIdentifierOp(ifName, vpnName, ipPrefix));
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getMacAddressFromPrefix: Exception while reading adj-op DS for the interface {} prefix {} "
+ + "vpn {}", ifName, ipPrefix, vpnName, e);
+ return null;
+ }
return adjacencyData.isPresent() ? adjacencyData.get().getMacAddress() : null;
}
}
public Uint32 getVpnId(String vpnName) {
-
InstanceIdentifier<VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
- VpnInstance::getVpnId).orElse(Uint32.ZERO);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, id)
+ .map(VpnInstance::getVpnId).orElse(Uint32.ZERO);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnNameFromId: Exception while reading vpnInstanceToVpnId DS for the vpn {}", vpnName, e);
+ }
+ return Uint32.ZERO;
}
/**
* @return The vpn instance
*/
public Optional<String> getVpnNameFromRd(String rd) {
- return Optional.fromJavaUtil(
- getVpnInstanceOpData(rd).toJavaUtil().map(VpnInstanceOpDataEntry::getVpnInstanceName));
+ return Optional.ofNullable(getVpnInstanceOpData(rd).map(VpnInstanceOpDataEntry::getVpnInstanceName)
+ .orElse(null));
}
@Nullable
public String getVpnNameFromId(Uint32 vpnId) {
InstanceIdentifier<VpnIds> id = getVpnIdToVpnInstanceIdentifier(vpnId);
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
- VpnIds::getVpnInstanceName).orElse(null);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, id)
+ .map(VpnIds::getVpnInstanceName).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnNameFromId: Exception while reading vpnIdToVpnInstance DS for the vpnId {}", vpnId, e);
+ }
+ return null;
}
static InstanceIdentifier<VpnIds> getVpnIdToVpnInstanceIdentifier(Uint32 vpnId) {
InstanceIdentifier<VrfEntry> vrfEntryId =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(prefix)).build();
- Optional<VrfEntry> entry = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> entry = Optional.empty();
+ try {
+ entry = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeOrUpdateFibEntry: Exception while reading vrfEntry for the prefix {} rd {} nexthop {}",
+ prefix, rd, nextHopToRemove, e);
+ }
if (entry.isPresent()) {
final List<RoutePaths> routePaths = entry.get().getRoutePaths();
if (routePaths == null || routePaths.isEmpty()) {
* Adds or removes nextHop from routePath based on the flag nextHopAdd.
*/
public void updateRoutePathForFibEntry(String rd, String prefix, String nextHop, Uint32 label,
- boolean nextHopAdd, WriteTransaction writeConfigTxn) {
+ boolean nextHopAdd, TypedWriteTransaction<Configuration> writeConfigTxn) {
LOG.debug("Updating fib entry for prefix {} with nextHop {} for rd {}.", prefix, nextHop, rd);
if (nextHopAdd) {
RoutePaths routePaths = FibHelper.buildRoutePath(nextHop, label);
if (writeConfigTxn != null) {
- writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION, routePathId, routePaths,
- CREATE_MISSING_PARENTS);
+ writeConfigTxn.put(routePathId, routePaths, CREATE_MISSING_PARENTS);
} else {
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routePathId, routePaths);
}
LOG.debug("Added routepath with nextHop {} for prefix {} and label {}.", nextHop, prefix, label);
} else {
- Optional<RoutePaths> routePath = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, routePathId);
+ Optional<RoutePaths> routePath;
+ try {
+ routePath = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routePathId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("updateRoutePathForFibEntry: Exception while reading the RoutePath with rd {}, "
+ + "prefix {} and nh {}", rd, prefix, nextHop, e);
+ return;
+ }
if (!routePath.isPresent()) {
LOG.warn("Couldn't find RoutePath with rd {}, prefix {} and nh {} for deleting",
rd, prefix, nextHop);
return;
}
if (writeConfigTxn != null) {
- writeConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, routePathId);
+ writeConfigTxn.delete(routePathId);
} else {
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, routePathId);
}
if (writeConfigTxn != null) {
writeConfigTxn.delete(vrfTableId);
} else {
- Optional<VrfTables> ifStateOptional = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.CONFIGURATION, vrfTableId);
+ Optional<VrfTables> ifStateOptional;
+ try {
+ ifStateOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, vrfTableId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeVrfTable: Exception while reading vrfTable for the rd {}", rd, e);
+ return;
+ }
if (ifStateOptional.isPresent()) {
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId);
}
.@Nullable Interface getInterfaceStateFromOperDS(String interfaceName) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
.interfaces.state.Interface> ifStateId = buildStateInterfaceId(interfaceName);
- Optional<Interface> ifStateOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, ifStateId);
+ Optional<Interface> ifStateOptional;
+ try {
+ ifStateOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, ifStateId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getInterfaceStateFromOperDS: Exception while reading interface-state for the interface {}",
+ interfaceName, e);
+ return null;
+ }
if (ifStateOptional.isPresent()) {
return ifStateOptional.get();
}
-
return null;
}
String nextHopIp = null;
InstanceIdentifier<DPNTEPsInfo> tunnelInfoId =
InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpnId)).build();
- Optional<DPNTEPsInfo> tunnelInfo = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, tunnelInfoId);
+ Optional<DPNTEPsInfo> tunnelInfo;
+ try {
+ tunnelInfo = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, tunnelInfoId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getEndpointIpAddressForDPN: Exception while reading DPN {} TEP info", dpnId, e);
+ return null;
+ }
if (tunnelInfo.isPresent()) {
List<TunnelEndPoints> nexthopIpList = tunnelInfo.get().getTunnelEndPoints();
if (nexthopIpList != null && !nexthopIpList.isEmpty()) {
public List<String> getNextHopAddresses(String rd, String prefix) {
InstanceIdentifier<VrfEntry> vrfEntryId = getNextHopIdentifier(rd, prefix);
- Optional<VrfEntry> vrfEntry = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> vrfEntry;
+ try {
+ vrfEntry = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNextHopAddresses: Exception while reading vrfEntry DS for the prefix {} rd {}",
+ prefix, rd, e);
+ return Collections.emptyList();
+ }
if (vrfEntry.isPresent()) {
return FibHelper.getNextHopListFromRoutePaths(vrfEntry.get());
} else {
public Optional<Nexthops> getNexthops(String nextHopKey) {
InstanceIdentifier<Nexthops> nextHopsId = InstanceIdentifier.builder(L3vpnLbNexthops.class)
.child(Nexthops.class, new NexthopsKey(nextHopKey)).build();
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, nextHopsId);
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ nextHopsId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNexthops: Exception while reading L3-vpn-nexthop DS for the nexthop {}", nextHopKey, e);
+ }
+ return Optional.empty();
}
public List<String> getL3VpnDcGateWays() {
InstanceIdentifier<L3vpnDcGws> id = InstanceIdentifier.builder(L3vpnDcGws.class)
.build();
- Optional<L3vpnDcGws> dcGwsOpt = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<L3vpnDcGws> dcGwsOpt;
+ try {
+ dcGwsOpt = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNexthops: Exception while reading L3vpnDcGws DS", e);
+ return Collections.emptyList();
+ }
if (!dcGwsOpt.isPresent()) {
return Collections.emptyList();
}
&& !vpnToDpnList.getVpnInterfaces().isEmpty()) {
return true;
}
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read interfaces with error {}", e.getMessage());
}
return false;
InstanceIdentifier<VrfEntry> vrfEntryId =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(prefix)).build();
- Optional<VrfEntry> entry = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> entry;
+ try {
+ entry = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkFibEntryExist: Exception while reading vrfEntry DS for the prefix {} rd {} nexthop {}",
+ prefix, rd, nextHopIp, e);
+ return false;
+ }
if (entry.isPresent()) {
List<RoutePaths> paths = entry.get().getRoutePaths();
for (RoutePaths path: paths) {
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldVlanVid;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.L3VPNTransportTypes;
InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class,
new VpnNexthopsKey(vpnId));
InstanceIdentifier<VpnNexthops> id = idBuilder.build();
- Optional<VpnNexthops> vpnNexthops = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnNexthops> vpnNexthops;
+ try {
+ vpnNexthops = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnNexthop: Exception while reading VpnNexthops DS for the address {} vpn {}", ipAddress,
+ vpnId, e);
+ return null;
+ }
if (vpnNexthops.isPresent()) {
// get nexthops list for vpn
List<VpnNexthop> nexthops = vpnNexthops.get().nonnullVpnNexthop();
* if the value is Unset, cache value as VxLAN.
*/
LOG.trace("configureTransportType is not yet set.");
- Optional<ConfTransportTypeL3vpn> configuredTransTypeFromConfig =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, getConfTransportTypeIdentifier());
-
+ Optional<ConfTransportTypeL3vpn> configuredTransTypeFromConfig;
+ try {
+ configuredTransTypeFromConfig = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, getConfTransportTypeIdentifier());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getReqTransType: Exception while reading ConfTransportTypeL3vpn DS", e);
+ return null;
+ }
if (configuredTransTypeFromConfig.isPresent()) {
if (TunnelTypeGre.class.equals(configuredTransTypeFromConfig.get().getTransportType())) {
configuredTransportTypeL3VPN = L3VPNTransportTypes.GRE;
private List<String> getDcGwIps() {
InstanceIdentifier<DcGatewayIpList> dcGatewayIpListid =
InstanceIdentifier.builder(DcGatewayIpList.class).build();
- DcGatewayIpList dcGatewayIpListConfig =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, dcGatewayIpListid).orNull();
+ DcGatewayIpList dcGatewayIpListConfig;
+ try {
+ dcGatewayIpListConfig = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, dcGatewayIpListid).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getDcGwIps: Exception while reading DcGatewayIpList DS", e);
+ return Collections.emptyList();
+ }
if (dcGatewayIpListConfig == null) {
return Collections.emptyList();
}
InstanceIdentifier<StateTunnelList> tunnelStateId =
InstanceIdentifier.builder(TunnelsState.class).child(
StateTunnelList.class, new StateTunnelListKey(tunnelName)).build();
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, tunnelStateId)
- .toJavaUtil().map(StateTunnelList::getOperState)
- .orElse(TunnelOperStatus.Down) == TunnelOperStatus.Up;
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ tunnelStateId).map(StateTunnelList::getOperState)
+ .orElse(TunnelOperStatus.Down) == TunnelOperStatus.Up;
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("isTunnelUp: Exception while reading StateTunnelList DS for tunnel {} tunnelType {}",
+ tunnelName, tunnelType, e);
+ return false;
+ }
}
return false;
}
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
*/
package org.opendaylight.netvirt.fibmanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FutureCallback;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.genius.utils.batching.SubTransaction;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.NexthopManager.AdjacencyResult;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
@Singleton
-public class VrfEntryListener extends AsyncDataTreeChangeListenerBase<VrfEntry, VrfEntryListener> {
+public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEntry> {
private static final Logger LOG = LoggerFactory.getLogger(VrfEntryListener.class);
private static final String FLOWID_PREFIX = "L3.";
final InterVpnLinkCache interVpnLinkCache,
final UpgradeState upgradeState,
final DataTreeEventCallbackRegistrar eventCallbacks) {
- super(VrfEntry.class, VrfEntryListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(FibEntries.class)
+ .child(VrfTables.class).child(VrfEntry.class),
+ Executors.newListeningSingleThreadExecutor("VrfEntryListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.retryingTxRunner = new RetryingManagedNewTransactionRunner(dataBroker, MAX_RETRIES);
this.eventCallbacks = eventCallbacks;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
LOG.warn("Error closing {}", c, e);
}
});
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected VrfEntryListener getDataTreeChangeListener() {
- return VrfEntryListener.this;
- }
-
- @Override
- protected InstanceIdentifier<VrfEntry> getWildCardPath() {
- return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
- }
-
- @Override
- protected void add(final InstanceIdentifier<VrfEntry> identifier, final VrfEntry vrfEntry) {
+ public void add(final InstanceIdentifier<VrfEntry> identifier, final VrfEntry vrfEntry) {
Preconditions.checkNotNull(vrfEntry, "VrfEntry should not be null or empty.");
String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("ADD: Adding Fib Entry rd {} prefix {} route-paths {}",
}
@Override
- protected void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry) {
+ public void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry) {
Preconditions.checkNotNull(vrfEntry, "VrfEntry should not be null or empty.");
String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("REMOVE: Removing Fib Entry rd {} prefix {} route-paths {}",
// "Redundant nullcheck of originalRoutePath, which is known to be non-null" - the null checking for
// originalRoutePath is a little dicey - safest to keep the checking even if not needed.
@SuppressFBWarnings("RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE")
- protected void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
+ public void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
Preconditions.checkNotNull(update, "VrfEntry should not be null or empty.");
final String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("UPDATE: Updating Fib Entries to rd {} prefix {} route-paths {} origin {} old-origin {}", rd,
if (RouteOrigin.BGP.getValue().equals(vrfEntry.getOrigin())) {
bgpRouteVrfEntryHandler.createRemoteFibEntry(vpnDpn.getDpnId(),
vpnId, vrfTableKey.getRouteDistinguisher(), vrfEntry,
- TransactionAdapter.toWriteTransaction(tx),
- txnObjects);
+ TransactionAdapter.toWriteTransaction(tx), txnObjects);
} else {
createRemoteFibEntry(vpnDpn.getDpnId(),
vpnInstance.getVpnId(),
Optional<String> optVpnUuid = fibUtil.getVpnNameFromRd(rd);
if (optVpnUuid.isPresent()) {
String vpnUuid = optVpnUuid.get();
- InterVpnLinkDataComposite interVpnLink = interVpnLinkCache.getInterVpnLinkByVpnId(vpnUuid).orNull();
+ InterVpnLinkDataComposite interVpnLink = interVpnLinkCache.getInterVpnLinkByVpnId(vpnUuid).orElse(null);
if (interVpnLink != null) {
LOG.debug("InterVpnLink {} found in Cache linking Vpn {}", interVpnLink.getInterVpnLinkName(), vpnUuid);
FibUtil.getFirstNextHopAddress(vrfEntry).ifPresent(routeNexthop -> {
InstanceIdentifier<VrfEntry> vrfEntryId =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(prefix)).build();
- Optional<VrfEntry> vrfEntry = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> vrfEntry;
+ try {
+ vrfEntry = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("refreshFibTables: Exception while reading VrfEntry Ds for the prefix {} rd {}", prefix, rd, e);
+ return;
+ }
if (vrfEntry.isPresent()) {
createFibEntries(vrfEntryId, vrfEntry.get());
}
// After having received a static route, we should check if the vpn is part of an inter-vpn-link.
// In that case, we should populate the FIB table of the VPN pointing to LPortDisptacher table
// using as metadata the LPortTag associated to that vpn in the inter-vpn-link.
- if (interVpnLink.getState().or(State.Error) != State.Active) {
+ if (interVpnLink.getState().orElse(State.Error) != State.Active) {
LOG.warn("Route to {} with nexthop={} cannot be installed because the interVpnLink {} is not active",
destination, nextHop, interVpnLinkName);
return;
return Uint64.ZERO;
}
- private boolean isVpnPresentInDpn(String rd, Uint64 dpnId) {
+ private boolean isVpnPresentInDpn(String rd, Uint64 dpnId) {
InstanceIdentifier<VpnToDpnList> id = VpnHelper.getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnToDpnList> dpnInVpn;
+ try {
+ dpnInVpn = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("isVpnPresentInDpn: Exception while reading VpnToDpnList Ds for the rd {} dpnId {}", rd,
+ dpnId, e);
+ return false;
+ }
return dpnInVpn.isPresent();
}
private LabelRouteInfo getLabelRouteInfo(LabelRouteInfoKey label) {
InstanceIdentifier<LabelRouteInfo> lriIid = InstanceIdentifier.builder(LabelRouteMap.class)
.child(LabelRouteInfo.class, label).build();
- Optional<LabelRouteInfo> opResult = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, lriIid);
+ Optional<LabelRouteInfo> opResult = null;
+ try {
+ opResult = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ lriIid);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("refreshFibTables: Exception while reading LabelRouteInfo Ds for the label {}", label, e);
+ return null;
+ }
if (opResult.isPresent()) {
return opResult.get();
}
new CleanupVpnInterfaceWorker(prefixInfo, vpnId, rd, vrfEntry, extraRoute));
}
- private class CleanupVpnInterfaceWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class CleanupVpnInterfaceWorker implements Callable<List<? extends ListenableFuture<?>>> {
Prefixes prefixInfo;
Uint32 vpnId;
String rd;
baseVrfEntryHandler.makeConnectedRoute(curDpn.getDpnId(),
vpnInstance.getVpnId(),
- vrfEntry, vrfTableKey.getRouteDistinguisher(), null, NwConstants.DEL_FLOW,
- TransactionAdapter.toWriteTransaction(tx), null);
+ vrfEntry, vrfTableKey.getRouteDistinguisher(), null,
+ NwConstants.DEL_FLOW, TransactionAdapter.toWriteTransaction(tx), null);
if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.SELF_IMPORTED) {
optionalLabel.ifPresent(label -> makeLFibTableEntry(curDpn.getDpnId(),
label, null, DEFAULT_FIB_FLOW_PRIORITY, NwConstants.DEL_FLOW, tx));
.getVpnExtraroutes(dataBroker, vpnName, usedRds.get(0), vrfEntry.getDestPrefix());
}
} else {
- extraRouteOptional = Optional.absent();
+ extraRouteOptional = Optional.empty();
}
jobCoordinator.enqueueJob(FibUtil.getJobKeyForRdPrefix(rd, vrfEntry.getDestPrefix()),
for (VpnToDpnList curDpn : vpnToDpnList) {
baseVrfEntryHandler.deleteRemoteRoute(Uint64.ZERO, curDpn.getDpnId(),
vpnInstance.getVpnId(), vrfTableKey, vrfEntry, extraRouteOptional,
- TransactionAdapter.toWriteTransaction(tx));
+ TransactionAdapter.toWriteTransaction(tx));
}
} else {
for (Uint64 localDpnId : localDpnIdList) {
if (!Objects.equals(curDpn.getDpnId(), localDpnId)) {
baseVrfEntryHandler.deleteRemoteRoute(localDpnId, curDpn.getDpnId(),
vpnInstance.getVpnId(), vrfTableKey, vrfEntry, extraRouteOptional,
- TransactionAdapter.toWriteTransaction(tx));
+ TransactionAdapter.toWriteTransaction(tx));
}
}
}
InstanceIdentifier<VrfTables> id = buildVrfId(rd);
final VpnInstanceOpDataEntry vpnInstance = fibUtil.getVpnInstance(rd);
List<SubTransaction> txnObjects = new ArrayList<>();
- final Optional<VrfTables> vrfTable = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ final Optional<VrfTables> vrfTable;
+ try {
+ vrfTable = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("populateExternalRoutesOnDpn: Exception while reading the VrfTable for the rd {}", rd, e);
+ return;
+ }
if (vrfTable.isPresent()) {
jobCoordinator.enqueueJob(FibUtil.getJobKeyForVpnIdDpnId(vpnId, dpnId),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
}
//Is this fib route an extra route? If yes, get the nexthop which would be
//an adjacency in the vpn
- Optional<Routes> extraRouteOptional = Optional.absent();
+ Optional<Routes> extraRouteOptional = Optional.empty();
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.STATIC && usedRds.size() != 0) {
extraRouteOptional = VpnExtraRouteHelper.getVpnExtraroutes(dataBroker,
fibUtil.getVpnNameFromId(vpnInstance.getVpnId()),
}
} else {
- extraRouteOptional = Optional.absent();
+ extraRouteOptional = Optional.empty();
}
if (RouteOrigin.BGP.getValue().equals(vrfEntry.getOrigin())) {
bgpRouteVrfEntryHandler.deleteRemoteRoute(null, dpnId, vpnId,
InstanceIdentifier<VrfTables> id = buildVrfId(rd);
final VpnInstanceOpDataEntry vpnInstance = fibUtil.getVpnInstance(rd);
List<SubTransaction> txnObjects = new ArrayList<>();
- final Optional<VrfTables> vrfTable = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ final Optional<VrfTables> vrfTable;
+ try {
+ vrfTable = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVrfEntry: Exception while reading VrfTable for the rd {} vpnId {}", rd, vpnId, e);
+ return;
+ }
if (vrfTable.isPresent()) {
jobCoordinator.enqueueJob(FibUtil.getJobKeyForVpnIdDpnId(vpnId, dpnId),
() -> {
.filter(vrfEntry -> RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP)
.forEach(bgpRouteVrfEntryHandler.getConsumerForDeletingRemoteFib(dpnId, vpnId,
remoteNextHopIp, vrfTable, TransactionAdapter.toWriteTransaction(tx),
- txnObjects))));
+ txnObjects))));
} finally {
lock.unlock();
}
InstanceIdentifier<VrfEntry> vrfEntryId = InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
- Optional<VrfEntry> vrfEntry = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> vrfEntry;
+ try {
+ vrfEntry = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVrfEntry: Exception while reading VrfEntry for the prefix {} rd {}", ipPrefix, rd, e);
+ return null;
+ }
if (vrfEntry.isPresent()) {
return vrfEntry.get();
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default"/>
<reference id="iMdsalApiManager"
interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager"/>
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.netvirt.fibmanager.VrfEntryListener;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
@Mock
DataBroker dataBroker;
@Mock
- ReadOnlyTransaction mockReadTx;
+ ReadTransaction mockReadTx;
@Mock
WriteTransaction mockWriteTx;
@Mock
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.VrfEntryBase.EncapType;
odl:use-default-for-reference-types="true">
<reference id="fibManagerRef" interface="org.opendaylight.netvirt.fibmanager.api.IFibManager" />
- <reference id="dataBrokerRef" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ <reference id="dataBrokerRef" interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
<command>
<artifactId>javax.inject</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>interfacemanager-api</artifactId>
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.ipv6util.api.Ipv6Constants.Ipv6RouterAdvertisementType;
import org.opendaylight.genius.ipv6util.api.Ipv6Util;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.ipv6service.api.ElementCache;
import org.opendaylight.netvirt.ipv6service.api.IVirtualNetwork;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionNxResubmit;
import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.slf4j.LoggerFactory;
@Singleton
-public class Ipv6NodeListener extends AsyncClusteredDataTreeChangeListenerBase<FlowCapableNode, Ipv6NodeListener> {
+public class Ipv6NodeListener extends AbstractClusteredAsyncDataTreeChangeListener<FlowCapableNode> {
private static final Logger LOG = LoggerFactory.getLogger(Ipv6NodeListener.class);
private final DataBroker dataBroker;
private final IMdsalApiManager mdsalUtil;
@Inject
public Ipv6NodeListener(final DataBroker dataBroker, final IMdsalApiManager mdsalUtil,
final Ipv6ServiceEosHandler ipv6ServiceEosHandler) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class),
+ Executors.newListeningSingleThreadExecutor("Ipv6NodeListener", LOG));
this.dataBroker = dataBroker;
this.mdsalUtil = mdsalUtil;
this.ipv6ServiceEosHandler = ipv6ServiceEosHandler;
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<FlowCapableNode> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void update(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModificationBefore,
+ public void update(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModificationBefore,
FlowCapableNode dataObjectModificationAfter) {
// do nothing
}
@Override
- protected void add(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
+ public void add(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
LOG.trace("FlowCapableNode Added: key: {}", key);
NodeKey nodeKey = key.firstKeyOf(Node.class);
}
@Override
- protected void remove(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
+ public void remove(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
// do nothing
}
-
- /* (non-Javadoc)
- * @see org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase#getDataTreeChangeListener()
- */
- @Override
- protected Ipv6NodeListener getDataTreeChangeListener() {
- return Ipv6NodeListener.this;
- }
-
}
import java.util.Collections;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.ipv6service.utils.Ipv6ServiceConstants;
import org.opendaylight.netvirt.ipv6service.utils.Ipv6ServiceUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@Singleton
public class Ipv6ServiceInterfaceEventListener
- extends AsyncClusteredDataTreeChangeListenerBase<Interface, Ipv6ServiceInterfaceEventListener> {
+ extends AbstractClusteredAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(Ipv6ServiceInterfaceEventListener.class);
private final DataBroker dataBroker;
private final IfMgr ifMgr;
@Inject
public Ipv6ServiceInterfaceEventListener(DataBroker broker, IfMgr ifMgr, Ipv6ServiceUtils ipv6ServiceUtils,
final JobCoordinator jobCoordinator, Ipv6ServiceEosHandler ipv6ServiceEosHandler) {
- super(Interface.class, Ipv6ServiceInterfaceEventListener.class);
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("Ipv6ServiceInterfaceEventListener", LOG));
this.dataBroker = broker;
this.ifMgr = ifMgr;
this.ipv6ServiceUtils = ipv6ServiceUtils;
this.ipv6ServiceEosHandler = ipv6ServiceEosHandler;
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Interface> key, Interface del) {
+ public void remove(InstanceIdentifier<Interface> key, Interface del) {
LOG.debug("Port removed {}, {}", key, del);
if (!L2vlan.class.equals(del.getType())) {
return;
}
@Override
- protected void update(InstanceIdentifier<Interface> key, Interface before, Interface after) {
+ public void update(InstanceIdentifier<Interface> key, Interface before, Interface after) {
if (before.getType() == null && L2vlan.class.equals(after.getType())) {
add(key, after);
}
}
@Override
- protected void add(InstanceIdentifier<Interface> key, Interface add) {
+ public void add(InstanceIdentifier<Interface> key, Interface add) {
List<String> ofportIds = add.getLowerLayerIf();
if (!L2vlan.class.equals(add.getType())) {
}
}
}
-
- @Override
- protected Ipv6ServiceInterfaceEventListener getDataTreeChangeListener() {
- return Ipv6ServiceInterfaceEventListener.this;
- }
}
*/
package org.opendaylight.netvirt.ipv6service;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.mtu.ext.rev181114.NetworkMtuExtension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronNetworkChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Network,
- NeutronNetworkChangeListener> {
+public class NeutronNetworkChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Network> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkChangeListener.class);
@Inject
public NeutronNetworkChangeListener(final DataBroker dataBroker, IfMgr ifMgr) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Networks.class).child(Network.class),
+ Executors.newListeningSingleThreadExecutor("NeutronNetworkChangeListener", LOG));
this.dataBroker = dataBroker;
this.ifMgr = ifMgr;
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Network> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<Network> identifier, Network input) {
+ public void add(InstanceIdentifier<Network> identifier, Network input) {
int mtu = 0;
LOG.debug("Add Network notification handler is invoked {} ", input);
if (input.augmentation(NetworkMtuExtension.class) != null) {
}
@Override
- protected void remove(InstanceIdentifier<Network> identifier, Network input) {
+ public void remove(InstanceIdentifier<Network> identifier, Network input) {
LOG.debug("Remove Network notification handler is invoked {} ", input);
ifMgr.removeNetwork(input.getUuid());
}
@Override
- protected void update(InstanceIdentifier<Network> identifier, Network original, Network update) {
+ public void update(InstanceIdentifier<Network> identifier, Network original, Network update) {
LOG.debug("Update Network notification handler is invoked...");
}
-
- /* (non-Javadoc)
- * @see org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase#getDataTreeChangeListener()
- */
- @Override
- protected NeutronNetworkChangeListener getDataTreeChangeListener() {
- return NeutronNetworkChangeListener.this;
- }
-
}
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.ipv6service.utils.Ipv6ServiceConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronPortChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Port,
- NeutronPortChangeListener> {
+public class NeutronPortChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Port> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronPortChangeListener.class);
private final DataBroker dataBroker;
private final IfMgr ifMgr;
@Inject
public NeutronPortChangeListener(final DataBroker dataBroker, IfMgr ifMgr) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Ports.class).child(Port.class),
+ Executors.newListeningSingleThreadExecutor("NeutronPortChangeListener", LOG));
this.dataBroker = dataBroker;
this.ifMgr = ifMgr;
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Port> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- p
rotected void add(InstanceIdentifier<Port> identifier, Port port) {
+ p
ublic void add(InstanceIdentifier<Port> identifier, Port port) {
if (Ipv6ServiceConstants.NETWORK_ROUTER_GATEWAY.equalsIgnoreCase(port.getDeviceOwner())) {
// Todo: revisit when IPv6 north-south support is implemented.
LOG.info("IPv6Service (TODO): Skipping router_gateway port {} for add event", port);
}
@Override
- p
rotected void remove(InstanceIdentifier<Port> identifier, Port port) {
+ p
ublic void remove(InstanceIdentifier<Port> identifier, Port port) {
if (Ipv6ServiceConstants.NETWORK_ROUTER_GATEWAY.equalsIgnoreCase(port.getDeviceOwner())) {
// Todo: revisit when IPv6 north-south support is implemented.
LOG.info("IPv6Service (TODO): Skipping router_gateway port {} for remove event", port);
}
@Override
- p
rotected void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
+ p
ublic void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
if (Ipv6ServiceConstants.NETWORK_ROUTER_GATEWAY.equalsIgnoreCase(update.getDeviceOwner())) {
// Todo: revisit when IPv6 north-south support is implemented.
LOG.info("IPv6Service (TODO): Skipping router_gateway port {} for update event", update);
private Set<FixedIps> getFixedIpSet(@Nullable List<FixedIps> fixedIps) {
return fixedIps != null ? new HashSet<>(fixedIps) : Collections.emptySet();
}
-
- @Override
- protected NeutronPortChangeListener getDataTreeChangeListener() {
- return NeutronPortChangeListener.this;
- }
}
*/
package org.opendaylight.netvirt.ipv6service;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronRouterChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Router,
- NeutronRouterChangeListener> {
+public class NeutronRouterChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Router> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronRouterChangeListener.class);
private final DataBroker dataBroker;
private final IfMgr ifMgr;
@Inject
public NeutronRouterChangeListener(final DataBroker dataBroker, IfMgr ifMgr) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Routers.class).child(Router.class),
+ Executors.newListeningSingleThreadExecutor("NeutronRouterChangeListener", LOG));
this.dataBroker = dataBroker;
this.ifMgr = ifMgr;
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Router> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Routers.class).child(Router.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<Router> identifier, Router input) {
+ public void add(InstanceIdentifier<Router> identifier, Router input) {
LOG.info("Add Router notification handler is invoked {}.", input.getUuid());
ifMgr.addRouter(input.getUuid(), input.getName(), input.getTenantId());
}
@Override
- protected void remove(InstanceIdentifier<Router> identifier, Router input) {
+ public void remove(InstanceIdentifier<Router> identifier, Router input) {
LOG.info("Remove Router notification handler is invoked {}.", input.getUuid());
ifMgr.removeRouter(input.getUuid());
}
@Override
- protected void update(InstanceIdentifier<Router> identifier, Router original, Router update) {
+ public void update(InstanceIdentifier<Router> identifier, Router original, Router update) {
LOG.debug("Update Router notification handler is invoked. Original: {}, Updated: {}.", original, update);
}
-
- @Override
- protected NeutronRouterChangeListener getDataTreeChangeListener() {
- return NeutronRouterChangeListener.this;
- }
-
}
package org.opendaylight.netvirt.ipv6service;
import com.google.common.collect.ImmutableBiMap;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.ipv6service.utils.Ipv6ServiceConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Base;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Off;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Slaac;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronSubnetChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Subnet,
- NeutronSubnetChangeListener> {
+public class NeutronSubnetChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Subnet> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSubnetChangeListener.class);
private final DataBroker dataBroker;
private final IfMgr ifMgr;
@Inject
public NeutronSubnetChangeListener(final DataBroker dataBroker, IfMgr ifMgr) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Subnets.class).child(Subnet.class),
+ Executors.newListeningSingleThreadExecutor("NeutronSubnetChangeListener", LOG));
this.dataBroker = dataBroker;
this.ifMgr = ifMgr;
}
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Subnet> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Subnets.class).child(Subnet.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<Subnet> identifier, Subnet input) {
+ public void add(InstanceIdentifier<Subnet> identifier, Subnet input) {
if (IPV_MAP.get(input.getIpVersion()).equals(Ipv6ServiceConstants.IP_VERSION_V6)) {
LOG.info("Add Subnet notification handler is invoked {} ", input);
String ipv6AddrMode = "";
}
@Override
- protected void remove(InstanceIdentifier<Subnet> identifier, Subnet input) {
+ public void remove(InstanceIdentifier<Subnet> identifier, Subnet input) {
ifMgr.removeSubnet(input.getUuid());
}
@Override
- protected void update(InstanceIdentifier<Subnet> identifier, Subnet original, Subnet update) {
+ public void update(InstanceIdentifier<Subnet> identifier, Subnet original, Subnet update) {
LOG.debug("Update Subnet notification handler is invoked Original: {}, Update: {}", original, update);
}
-
- @Override
- protected NeutronSubnetChangeListener getDataTreeChangeListener() {
- return NeutronSubnetChangeListener.this;
- }
-
}
package org.opendaylight.netvirt.ipv6service.utils;
-import com.google.common.base.Optional;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.packet.IPProtocols;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.ipv6service.VirtualSubnet;
import org.opendaylight.netvirt.ipv6service.api.IVirtualPort;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
* @return the required object.
*/
public <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
*/
public org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
.@Nullable Interface getInterface(String interfaceName) {
- return read(LogicalDatastoreType.CONFIGURATION, getInterfaceIdentifier(interfaceName)).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, getInterfaceIdentifier(interfaceName)).orElse(null);
}
/**
*/
public org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
.@Nullable Interface getInterfaceStateFromOperDS(String interfaceName) {
- return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, buildStateInterfaceId(interfaceName), broker).orNull();
+ return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, buildStateInterfaceId(interfaceName), broker)
+ .orElse(null);
}
private static List<MatchInfo> getIcmpv6RSMatch(Long elanTag) {
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="iMdsalApiManager"
interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ </dependency>
<dependency>
<groupId>org.apache.karaf.shell</groupId>
<artifactId>org.apache.karaf.shell.commands</artifactId>
package org.opendaylight.netvirt.natservice.cli;
-import com.google.common.base.Optional;
import java.io.PrintStream;
import java.math.BigInteger;
+import java.util.Optional;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.natservice.internal.NatUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
if (!bridgeRefEntry.isPresent()) {
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<Node> nodeId =
@Nullable
private String getDpnLocalIp(BigInteger dpId) {
- return getPortsNode(dpId).toJavaUtil().map(node -> getOpenvswitchOtherConfig(node, LOCAL_IP)).orElse(null);
+ return getPortsNode(dpId).map(node -> getOpenvswitchOtherConfig(node, LOCAL_IP)).orElse(null);
}
@Nullable
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
}
- return Optional.absent();
+ return Optional.empty();
}
import java.util.concurrent.ConcurrentMap;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.natservice.api.NatSwitchCache;
import org.opendaylight.netvirt.natservice.api.NatSwitchCacheListener;
import org.opendaylight.netvirt.natservice.api.SwitchInfo;
import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
import org.opendaylight.netvirt.natservice.internal.NatConstants;
import org.opendaylight.netvirt.natservice.internal.NatUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig.NatMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
*/
@Singleton
public class SnatCentralizedSwitchChangeListener
- extends AsyncDataTreeChangeListenerBase<RouterToNaptSwitch, SnatCentralizedSwitchChangeListener> {
+ extends AbstractAsyncDataTreeChangeListener<RouterToNaptSwitch> {
private static final Logger LOG = LoggerFactory.getLogger(SnatCentralizedSwitchChangeListener.class);
private final DataBroker dataBroker;
public SnatCentralizedSwitchChangeListener(final DataBroker dataBroker,
final SnatServiceManager snatServiceManger, NatDataUtil natDataUtil, final NatserviceConfig config,
final DataTreeEventCallbackRegistrar dataTreeEventCallbackRegistrar) {
- super(RouterToNaptSwitch.class, SnatCentralizedSwitchChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(NaptSwitches.class)
+ .child(RouterToNaptSwitch.class),
+ Executors.newListeningSingleThreadExecutor("SnatCentralizedSwitchChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.snatServiceManger = snatServiceManger;
}
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<RouterToNaptSwitch> getWildCardPath() {
- return InstanceIdentifier.create(NaptSwitches.class).child(RouterToNaptSwitch.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
+ public void remove(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
LOG.debug("Deleting {}", routerToNaptSwitch);
if (natMode == NatMode.Controller) {
LOG.info("Do Not Processing this remove() event for (routerName:designatedDpn) {}:{}"
}
@Override
- protected void update(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch origRouterToNaptSwitch,
+ public void update(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch origRouterToNaptSwitch,
RouterToNaptSwitch updatedRouterToNaptSwitch) {
LOG.debug("Updating old {} new {}", origRouterToNaptSwitch, updatedRouterToNaptSwitch);
if (natMode == NatMode.Controller) {
}
@Override
- protected void add(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
+ public void add(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
LOG.debug("Adding {}", routerToNaptSwitch);
if (natMode == NatMode.Controller) {
LOG.info("Do Not Processing this add() event for (routerName:designatedDpn) {}:{}"
LOG.error("Router {} not found for primarySwitch {}", routerName, primarySwitchId);
}
}
-
- @Override
- protected SnatCentralizedSwitchChangeListener getDataTreeChangeListener() {
- return this;
- }
}
package org.opendaylight.netvirt.natservice.ha;
import java.util.concurrent.Executors;
-
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
-
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.natservice.api.NatSwitchCache;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredAsyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
public SnatNodeEventListener(final DataBroker dataBroker,
final NatSwitchCache centralizedSwitchCache) {
- super(dataBroker,new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
+ super(dataBroker, DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
.create(Nodes.class).child(Node.class)),
Executors.newSingleThreadExecutor());
this.centralizedSwitchCache = centralizedSwitchCache;
}
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ org.opendaylight.infrautils.utils.concurrent.Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
+
@Override
public void remove(Node dataObjectModification) {
NodeKey nodeKey = dataObjectModification.key();
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.natservice.api.CentralizedSwitchScheduler;
import org.opendaylight.netvirt.natservice.api.NatSwitchCache;
import org.opendaylight.netvirt.natservice.api.NatSwitchCacheListener;
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
getNaptSwitchesIdentifier(routerName), routerToNaptSwitchBuilder.build());
}
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.error("updateCentralizedSwitch ReadFailedException for {}", routerName);
} catch (TransactionCommitFailedException e) {
LOG.error("updateCentralizedSwitch TransactionCommitFailedException for {}", routerName);
try {
String primaryRd = txRunner.applyWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
for (Uuid subnetUuid : addedSubnetIds) {
- Subnetmap subnetMapEntry = tx.read(getSubnetMapIdentifier(subnetUuid)).get().orNull();
+ Subnetmap subnetMapEntry = tx.read(getSubnetMapIdentifier(subnetUuid)).get().orElse(null);
subnetMapEntries.put(subnetUuid, subnetMapEntry);
Uuid routerPortUuid = subnetMapEntry.getRouterInterfacePortId();
subnetIdToRouterPortMap.put(subnetUuid.getValue(), routerPortUuid.getValue());
try {
optRouters = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ExtRouters.class));
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("addSwitch: Error reading external routers", e);
return;
}
if (dpnId == null || dpnId.equals(Uint64.ZERO)) {
return false;
}
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.error("isPrimarySwitchAllocatedForRouter: Error reading RouterToNaptSwitch model", e);
return false;
}
private NaptSwitches getNaptSwitches() {
InstanceIdentifier<NaptSwitches> id = InstanceIdentifier.builder(NaptSwitches.class).build();
- return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id).orNull();
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getNaptSwitches: Exception while reading Napt-Switch DS", e);
+ }
+ return null;
}
private Uint64 getSwitchWithLowestWeight(String providerNet) {
return null;
}
return naptSwitches.get().getPrimarySwitchId();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading RouterToNaptSwitch model", e);
return null;
}
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.natservice.api.SnatServiceListener;
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnInterfacesId, vpnInterfacesBuilder.build());
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read removeMipAdjacencies with error {}", e.getMessage());
} catch (TransactionCommitFailedException e) {
LOG.warn("Failed to remove removeMipAdjacencies with error {}", e.getMessage());
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Destination;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchCtState;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.ha.NatDataUtil;
import org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService;
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.BucketInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldEthernetDestination;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
import org.slf4j.LoggerFactory;
@Singleton
-public class ExternalNetworksChangeListener
- extends AsyncDataTreeChangeListenerBase<Networks, ExternalNetworksChangeListener> {
+public class ExternalNetworksChangeListener extends AbstractAsyncDataTreeChangeListener<Networks> {
private static final Logger LOG = LoggerFactory.getLogger(ExternalNetworksChangeListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
final OdlInterfaceRpcService interfaceManager,
final NatserviceConfig config,
final JobCoordinator coordinator) {
- super(Networks.class, ExternalNetworksChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ExternalNetworks.class)
+ .child(Networks.class),
+ Executors.newListeningSingleThreadExecutor("ExternalNetworksChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.floatingIpListener = floatingIpListener;
}
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Networks> getWildCardPath() {
- return InstanceIdentifier.create(ExternalNetworks.class).child(Networks.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<Networks> identifier, Networks networks) {
-
- }
+ public void add(InstanceIdentifier<Networks> identifier, Networks networks) {
- @Override
- protected ExternalNetworksChangeListener getDataTreeChangeListener() {
- return ExternalNetworksChangeListener.this;
}
@Override
- protected void remove(InstanceIdentifier<Networks> identifier, Networks networks) {
+ public void remove(InstanceIdentifier<Networks> identifier, Networks networks) {
if (identifier == null || networks == null || networks.getRouterIds() == null
|| networks.getRouterIds().isEmpty()) {
LOG.warn("remove : returning without processing since networks/identifier is null: "
}
@Override
- protected void update(InstanceIdentifier<Networks> identifier, Networks original, Networks update) {
+ public void update(InstanceIdentifier<Networks> identifier, Networks original, Networks update) {
//Check for VPN disassociation
Uuid originalVpn = original.getVpnid();
Uuid updatedVpn = update.getVpnid();
//long router = NatUtil.getVpnId(dataBroker, routerId.getValue());
InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
- Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- routerPortsId);
+ Optional<RouterPorts> optRouterPorts = null;
+ try {
+ optRouterPorts = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routerPortsId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("associateExternalNetworkWithVPN: Exception while reading RouterPorts DS for the "
+ + "router {} network {} ", routerId, network.getId().getValue(), e);
+ continue;
+ }
if (!optRouterPorts.isPresent()) {
LOG.debug("associateExternalNetworkWithVPN : Could not read Router Ports data object with id: {} "
+ "to handle associate ext nw {}", routerId, network.getId());
Uint64 dpnId = Uint64.valueOf("0");
InstanceIdentifier<RouterToNaptSwitch> routerToNaptSwitch =
NatUtil.buildNaptSwitchRouterIdentifier(routerId.getValue());
- Optional<RouterToNaptSwitch> rtrToNapt =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
+ Optional<RouterToNaptSwitch> rtrToNapt = Optional.empty();
+ try {
+ rtrToNapt = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("associateExternalNetworkWithVPN: Exception while reading routerToNaptSwitch DS for the "
+ + "router {}", routerId, e);
+ }
if (rtrToNapt.isPresent()) {
dpnId = rtrToNapt.get().getPrimarySwitchId();
}
if (network.getRouterIds() != null) {
for (Uuid routerId : network.getRouterIds()) {
InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
- Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- routerPortsId);
+ Optional<RouterPorts> optRouterPorts = Optional.empty();
+ try {
+ optRouterPorts = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routerPortsId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("disassociateExternalNetworkFromVPN: Exception while reading RouterPorts DS for the "
+ + "router {} network {} vpn {}", routerId, network.getId().getValue(), vpnName, e);
+ }
if (!optRouterPorts.isPresent()) {
LOG.debug(
"disassociateExternalNetworkFromVPN : Could not read Router Ports data object with id: {} "
*/
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.math.BigInteger;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.matches.MatchMplsLabel;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
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.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
@Singleton
-public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Routers, ExternalRoutersListener> {
+public class ExternalRoutersListener extends AbstractAsyncDataTreeChangeListener<Routers> {
private static final Logger LOG = LoggerFactory.getLogger(ExternalRoutersListener.class);
private static final Uint64 COOKIE_TUNNEL = Uint64.valueOf("9000000", 16).intern();
final JobCoordinator coordinator,
final NatOverVxlanUtil natOverVxlanUtil,
final IInterfaceManager interfaceManager) {
- super(Routers.class, ExternalRoutersListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ExtRouters.class)
+ .child(Routers.class),
+ Executors.newListeningSingleThreadExecutor("ExternalRoutersListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.natMode = NatMode.Controller;
this.snatPuntTimeout = 0;
}
+ init();
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
// This class handles ExternalRouters for Controller SNAT mode.
// For Conntrack SNAT mode, its handled in SnatExternalRoutersListener.java
if (natMode == NatMode.Controller) {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
NatUtil.createGroupIdPool(idManager);
}
}
@Override
- protected InstanceIdentifier<Routers> getWildCardPath() {
- return InstanceIdentifier.create(ExtRouters.class).child(Routers.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Routers> identifier, Routers routers) {
+ public void add(InstanceIdentifier<Routers> identifier, Routers routers) {
+ if (natMode != NatMode.Controller) {
+ return;
+ }
// Populate the router-id-name container
String routerName = routers.getRouterName();
LOG.info("add : external router event for {}", routerName);
try {
sn = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, subnetmapId);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read SubnetMap for subnetmap Id {}", subnetmapId, e);
- sn = Optional.absent();
+ sn = Optional.empty();
}
if (sn.isPresent()) {
// subnets
}
@Override
- protected void update(InstanceIdentifier<Routers> identifier, Routers original, Routers update) {
+ public void update(InstanceIdentifier<Routers> identifier, Routers original, Routers update) {
+ if (natMode != NatMode.Controller) {
+ return;
+ }
LOG.trace("update : origRouter: {} updatedRouter: {}", original, update);
String routerName = original.getRouterName();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
ipPortMapping = SingleTransactionDataBroker
.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, ipPortMappingId);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read ipPortMapping for router id {}", routerId, e);
- ipPortMapping = Optional.absent();
+ ipPortMapping = Optional.empty();
}
if (ipPortMapping.isPresent()) {
try {
externalCountersData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, id);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read external counters data for ExternalIp {}", externalIp, e);
- externalCountersData = Optional.absent();
+ externalCountersData = Optional.empty();
}
if (externalCountersData.isPresent()) {
ExternalIpsCounter externalIpsCounters = externalCountersData.get();
}
@Override
- protected void remove(InstanceIdentifier<Routers> identifier, Routers router) {
+ public void remove(InstanceIdentifier<Routers> identifier, Routers router) {
+ if (natMode != NatMode.Controller) {
+ return;
+ }
LOG.trace("remove : Router delete method");
/*
ROUTER DELETE SCENARIO
try {
rtrToNapt = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read NAPT switch for router {}", routerName, e);
- rtrToNapt = Optional.absent();
+ rtrToNapt = Optional.empty();
}
if (rtrToNapt.isPresent()) {
naptSwitchDpnId = rtrToNapt.get().getPrimarySwitchId();
.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, routerInstanceIndentifier);
return routerData.isPresent() && routerData.get().isEnableSnat();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read data for router id {}", routerUuid, e);
return false;
}
return flowEntity;
}
- @Override
- protected ExternalRoutersListener getDataTreeChangeListener() {
- return ExternalRoutersListener.this;
- }
-
protected void installNaptPfibEntriesForExternalSubnets(String routerName, Uint64 dpnId,
@Nullable TypedWriteTransaction<Configuration> writeFlowInvTx) {
Collection<Uuid> externalSubnetIdsForRouter = NatUtil.getExternalSubnetIdsForRouter(dataBroker,
*/
package org.opendaylight.netvirt.natservice.internal;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalSubnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.LoggerFactory;
@Singleton
-public class ExternalSubnetChangeListener extends AsyncDataTreeChangeListenerBase<Subnets,
- ExternalSubnetChangeListener> {
+public class ExternalSubnetChangeListener extends AbstractAsyncDataTreeChangeListener<Subnets> {
private static final Logger LOG = LoggerFactory.getLogger(ExternalSubnetChangeListener.class);
private final DataBroker dataBroker;
private final SNATDefaultRouteProgrammer snatDefaultRouteProgrammer;
final SNATDefaultRouteProgrammer snatDefaultRouteProgrammer,
final IElanService elanService, final IVpnManager vpnManager,
DataTreeEventCallbackRegistrar dataTreeEventCallbackRegistrar) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ExternalSubnets.class)
+ .child(Subnets.class),
+ Executors.newListeningSingleThreadExecutor("ExternalSubnetChangeListener", LOG));
this.dataBroker = dataBroker;
this.snatDefaultRouteProgrammer = snatDefaultRouteProgrammer;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Subnets> getWildCardPath() {
- return InstanceIdentifier.create(ExternalSubnets.class).child(Subnets.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Subnets> key, Subnets subnet) {
+ public void remove(InstanceIdentifier<Subnets> key, Subnets subnet) {
LOG.info("remove : External Subnet remove mapping method - key:{}. value={}",
subnet.key(), subnet);
String extSubnetUuid = subnet.getId().getValue();
}
@Override
- protected void update(InstanceIdentifier<Subnets> key, Subnets orig,
+ public void update(InstanceIdentifier<Subnets> key, Subnets orig,
Subnets update) {
}
@Override
- protected void add(InstanceIdentifier<Subnets> key, Subnets subnet) {
- }
-
- @Override
- protected ExternalSubnetChangeListener getDataTreeChangeListener() {
- return ExternalSubnetChangeListener.this;
+ public void add(InstanceIdentifier<Subnets> key, Subnets subnet) {
}
}
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
import org.slf4j.LoggerFactory;
@Singleton
-public class ExternalSubnetVpnInstanceListener extends AsyncDataTreeChangeListenerBase<VpnInstance,
- ExternalSubnetVpnInstanceListener> {
+public class ExternalSubnetVpnInstanceListener extends AbstractAsyncDataTreeChangeListener<VpnInstance> {
private static final Logger LOG = LoggerFactory.getLogger(ExternalSubnetVpnInstanceListener.class);
private final DataBroker dataBroker;
private final SNATDefaultRouteProgrammer snatDefaultRouteProgrammer;
public ExternalSubnetVpnInstanceListener(final DataBroker dataBroker,
final SNATDefaultRouteProgrammer snatDefaultRouteProgrammer,
final IElanService elanService, final IVpnManager vpnManager) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VpnInstanceToVpnId.class)
+ .child(VpnInstance.class),
+ Executors.newListeningSingleThreadExecutor("ExternalSubnetVpnInstanceListener", LOG));
this.dataBroker = dataBroker;
this.snatDefaultRouteProgrammer = snatDefaultRouteProgrammer;
this.elanService = elanService;
this.vpnManager = vpnManager;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<VpnInstance> getWildCardPath() {
- return InstanceIdentifier.create(VpnInstanceToVpnId.class).child(VpnInstance.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<VpnInstance> key, VpnInstance vpnInstance) {
+ public void remove(InstanceIdentifier<VpnInstance> key, VpnInstance vpnInstance) {
LOG.trace("remove : External Subnet VPN Instance remove mapping method - key:{}. value={}",
vpnInstance.key(), vpnInstance);
String possibleExtSubnetUuid = vpnInstance.getVpnInstanceName();
}
@Override
- protected void update(InstanceIdentifier<VpnInstance> key, VpnInstance vpnInstanceOrig,
+ public void update(InstanceIdentifier<VpnInstance> key, VpnInstance vpnInstanceOrig,
VpnInstance vpnInstanceNew) {
LOG.trace("update : External Subnet VPN Instance update mapping method - key:{} original:{} new:{}",
vpnInstanceNew.key(), vpnInstanceOrig, vpnInstanceNew);
}
@Override
- protected void add(InstanceIdentifier<VpnInstance> key, VpnInstance vpnInstance) {
+ public void add(InstanceIdentifier<VpnInstance> key, VpnInstance vpnInstance) {
LOG.trace("add : External Subnet VPN Instance OP Data Entry add mapping method - key:{}. value={}",
vpnInstance.key(), vpnInstance);
String possibleExtSubnetUuid = vpnInstance.getVpnInstanceName();
snatDefaultRouteProgrammer.addOrDelDefaultFibRouteToSNATForSubnet(subnet,
subnet.getExternalNetworkId().getValue(), flowAction, vpnInstance.getVpnId());
}
-
- @Override
- protected ExternalSubnetVpnInstanceListener getDataTreeChangeListener() {
- return ExternalSubnetVpnInstanceListener.this;
- }
}
package org.opendaylight.netvirt.natservice.internal;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.ha.NatDataUtil;
import org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Source;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.natservice.api.CentralizedSwitchScheduler;
import org.opendaylight.netvirt.natservice.api.NatSwitchCache;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.slf4j.LoggerFactory;
@Singleton
-public class FloatingIPListener extends AsyncDataTreeChangeListenerBase<InternalToExternalPortMap, FloatingIPListener> {
+public class FloatingIPListener extends AbstractAsyncDataTreeChangeListener<InternalToExternalPortMap> {
private static final Logger LOG = LoggerFactory.getLogger(FloatingIPListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
final JobCoordinator coordinator,
final CentralizedSwitchScheduler centralizedSwitchScheduler,
final NatSwitchCache natSwitchCache) {
- super(InternalToExternalPortMap.class, FloatingIPListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(FloatingIpInfo.class)
+ .child(RouterPorts.class).child(Ports.class).child(InternalToExternalPortMap.class),
+ Executors.newListeningSingleThreadExecutor("FloatingIPListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.natSwitchCache = natSwitchCache;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<InternalToExternalPortMap> getWildCardPath() {
- return InstanceIdentifier.create(FloatingIpInfo.class).child(RouterPorts.class).child(Ports.class)
- .child(InternalToExternalPortMap.class);
}
@Override
- protected FloatingIPListener getDataTreeChangeListener() {
- return FloatingIPListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(final InstanceIdentifier<InternalToExternalPortMap> identifier,
+ public void add(final InstanceIdentifier<InternalToExternalPortMap> identifier,
final InternalToExternalPortMap mapping) {
LOG.trace("FloatingIPListener add ip mapping method - key: {} value: {}",mapping.key(), mapping);
processFloatingIPAdd(identifier, mapping);
}
@Override
- protected void remove(InstanceIdentifier<InternalToExternalPortMap> identifier, InternalToExternalPortMap mapping) {
+ public void remove(InstanceIdentifier<InternalToExternalPortMap> identifier, InternalToExternalPortMap mapping) {
LOG.trace("FloatingIPListener remove ip mapping method - kkey: {} value: {}",mapping.key(), mapping);
processFloatingIPDel(identifier, mapping);
}
@Override
- protected void update(InstanceIdentifier<InternalToExternalPortMap> identifier, InternalToExternalPortMap
+ public void update(InstanceIdentifier<InternalToExternalPortMap> identifier, InternalToExternalPortMap
original, InternalToExternalPortMap update) {
LOG.trace("FloatingIPListener update ip mapping method - key: {}, original: {}, update: {}",
update.key(), original, update);
InstanceIdentifier<InternalToExternalPortMap> intExtPortMapIdentifier =
NatUtil.getIntExtPortMapIdentifier(routerId, interfaceName, internalIp);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.OPERATIONAL, intExtPortMapIdentifier).toJavaUtil().map(
+ LogicalDatastoreType.OPERATIONAL, intExtPortMapIdentifier).map(
InternalToExternalPortMap::getLabel).orElse(NatConstants.INVALID_ID);
}
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.natservice.api.SnatServiceListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
-
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.matches.MatchIpv6Source;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchBuilder;
}
private Map<Uint64, Integer> constructNAPTSwitches() {
- Optional<NaptSwitches> optNaptSwitches =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, getNaptSwitchesIdentifier());
+ Optional<NaptSwitches> optNaptSwitches = Optional.empty();
+ try {
+ optNaptSwitches = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, getNaptSwitchesIdentifier());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("constructNAPTSwitches: Exception while reading the NaptSwitches DS", e);
+ }
Map<Uint64, Integer> switchWeights = new HashMap<>();
if (optNaptSwitches.isPresent()) {
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.common.util.Arguments;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.packet.TCP;
import org.opendaylight.genius.mdsalutil.packet.UDP;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.openflowplugin.libraries.liblldp.PacketException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.locks.ReentrantLock;
import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
InstanceIdentifier<ExternalIpCounter> id = InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(segmentId))
.child(ExternalIpCounter.class, new ExternalIpCounterKey(externalIp)).build();
- Optional<ExternalIpCounter> externalIpCounter =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<ExternalIpCounter> externalIpCounter = Optional.empty();
+ try {
+ externalIpCounter = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("updateCounter: Exception while reading ExternalIpCounter DS for the segmentId {} externalIp {} ",
+ segmentId, externalIp, e);
+ }
if (externalIpCounter.isPresent()) {
counter = externalIpCounter.get().getCounter().toJava();
if (isAdd) {
public static List<IpMap> getIpMapList(DataBroker broker, Uint32 routerId) {
InstanceIdentifier<IpMapping> id = getIpMapList(routerId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.OPERATIONAL, id).toJavaUtil().map(IpMapping::getIpMap).orElse(
+ LogicalDatastoreType.OPERATIONAL, id).map(IpMapping::getIpMap).orElse(
Collections.emptyList());
}
.child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType))
.child(IpPortMap.class, new IpPortMapKey(internalIpPort));
InstanceIdentifier<IpPortMap> id = idBuilder.build();
- Optional<IpPortMap> ipPortMapType =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<IpPortMap> ipPortMapType = Optional.empty();
+ try {
+ ipPortMapType = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkIpPortMap: Exception while reading IpMap DS for the segmentId {} "
+ + "internalIpPort {} protocol {}", segmentId, internalIpPort, protocol, e);
+ }
if (ipPortMapType.isPresent()) {
LOG.debug("checkIpPortMap : {}", ipPortMapType.get());
SessionAddress externalIpPort = new SessionAddress(ipPortMapType.get().getIpPortExternal().getIpAddress(),
InstanceIdentifierBuilder<IpMapping> idBuilder =
InstanceIdentifier.builder(IntextIpMap.class).child(IpMapping.class, new IpMappingKey(segmentId));
InstanceIdentifier<IpMapping> id = idBuilder.build();
- Optional<IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMapping> ipMapping = Optional.empty();
+ try {
+ ipMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkIpMap: Exception while reading IpMapping DS for the segmentId {} internalIp {}",
+ segmentId, internalIp, e);
+ }
if (ipMapping.isPresent()) {
for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
if (Objects.equals(ipMap.getInternalIp(), internalIp)) {
InstanceIdentifier<IpMap> id = idBuilder.build();
// Get externalIp and decrement the counter
String externalIp = null;
- Optional<IpMap> ipMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMap> ipMap = Optional.empty();
+ try {
+ ipMap = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeFromIpMapDS: Exception while reading IpMap DS for the segmentId {} "
+ + "internalIp {}", segmentId, internalIp, e);
+ }
if (ipMap.isPresent()) {
externalIp = ipMap.get().getExternalIp();
LOG.debug("removeFromIpMapDS : externalIP is {}", externalIp);
.child(IpMap.class, new IpMapKey(internalIp));
InstanceIdentifier<IpMap> id = idBuilder.build();
- Optional<IpMap> ipMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMap> ipMap;
+ try {
+ ipMap = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getExternalIpAllocatedForSubnet: Exception while reading IpMap DS for the segmentId {} "
+ + "internalIp {}", segmentId, internalIp, e);
+ return null;
+ }
if (ipMap.isPresent()) {
return ipMap.get().getExternalIp();
}
.child(IpMapping.class, new IpMappingKey(segmentId));
InstanceIdentifier<IpMapping> id = idBuilder.build();
// Get all externalIps and decrement their counters before deleting the ipmap
- Optional<IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMapping> ipMapping = Optional.empty();
+ try {
+ ipMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeIpMappingForRouterID: Exception while reading IpMapping DS for the segmentId {} ",
+ segmentId, e);
+ }
if (ipMapping.isPresent()) {
for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
String externalIp = ipMap.getExternalIp();
void removeIpPortMappingForRouterID(Uint32 segmentId) {
InstanceIdentifier<IpPortMapping> idBuilder = InstanceIdentifier.builder(IntextIpPortMap.class)
.child(IpPortMapping.class, new IpPortMappingKey(segmentId)).build();
- Optional<IpPortMapping> ipPortMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- idBuilder);
+ Optional<IpPortMapping> ipPortMapping = Optional.empty();
+ try {
+ ipPortMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, idBuilder);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeIpPortMappingForRouterID: Exception while reading IpPortMapping DS for the segmentId {} ",
+ segmentId, e);
+ }
if (ipPortMapping.isPresent()) {
// remove from IntExtIpPortmap DS
LOG.debug("removeIpPortMappingForRouterID : Removing IntExtIpPort map for router {} from datastore",
void removeIntIpPortMappingForRouterID(Uint32 segmentId) {
InstanceIdentifier<IntipPortMap> intIp = InstanceIdentifier.builder(SnatintIpPortMap.class)
.child(IntipPortMap.class, new IntipPortMapKey(segmentId)).build();
- Optional<IntipPortMap> intIpPortMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, intIp);
+ Optional<IntipPortMap> intIpPortMap = Optional.empty();
+ try {
+ intIpPortMap = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, intIp);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeIntIpPortMappingForRouterID: Exception while reading IntipPortMap DS for the "
+ + "segmentId {} ", segmentId, e);
+ }
if (intIpPortMap.isPresent()) {
// remove from SnatIntIpPortmap DS
LOG.debug("removeIntIpPortMappingForRouterID : Removing SnatIntIpPort from datastore : {}", intIp);
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(prefix));
InstanceIdentifier<VrfEntry> vrfEntryId = idBuilder.build();
- Optional<VrfEntry> ent = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> ent;
+ try {
+ ent = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeFibEntry: Exception while reading the VrfEntry for the prefix {} rd {}", prefix, rd, e);
+ return;
+ }
if (ent.isPresent()) {
LOG.debug("removeFibEntry : Removing Fib entry rd {} prefix {}", rd, prefix);
fibManager.removeFibEntry(rd, prefix, null, null);
import java.util.Objects;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpRequestReceived;
notification.getDpnId(), targetIfc.getName());
VipState cachedState = null;
try {
- cachedState = this.vipStateTracker.get(newVipState.getIp()).orNull();
+ cachedState = this.vipStateTracker.get(newVipState.getIp()).orElse(null);
} catch (ReadFailedException e) {
LOG.warn("NatArpNotificationHandler failed to read vip state {}", notification, e);
}
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetDestination;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetSource;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
private static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id = NatUtil.getVpnInstanceOpDataIdentifier(rd);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.OPERATIONAL, id).orNull();
+ LogicalDatastoreType.OPERATIONAL, id).orElse(null);
}
private static boolean isL3VpnOverVxLan(Uint32 l3Vni) {
InstanceIdentifier<FloatingIpIdToPortMapping> id =
NatUtil.buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
FloatingIpIdToPortMapping::getFloatingIpPortId).orElse(null);
}
}
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@Singleton
public class NatInterfaceStateChangeListener
- extends AsyncDataTreeChangeListenerBase<Interface, NatInterfaceStateChangeListener> {
+ extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(NatInterfaceStateChangeListener.class);
private final DataBroker dataBroker;
@Inject
public NatInterfaceStateChangeListener(final DataBroker dataBroker,
final NatSouthboundEventHandlers southboundEventHandlers) {
- super(Interface.class, NatInterfaceStateChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("NatInterfaceStateChangeListener", LOG));
this.dataBroker = dataBroker;
this.southboundEventHandlers = southboundEventHandlers;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
}
@Override
- protected NatInterfaceStateChangeListener getDataTreeChangeListener() {
- return NatInterfaceStateChangeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
LOG.trace("add : Interface {} up event received", intrf);
if (!L2vlan.class.equals(intrf.getType())) {
LOG.debug("add : Interface {} is not Vlan Interface.Ignoring", intrf.getName());
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
LOG.trace("remove : Interface {} removed event received", intrf);
if (!L2vlan.class.equals(intrf.getType())) {
LOG.debug("remove : Interface {} is not Vlan Interface.Ignoring", intrf.getName());
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
+ public void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
LOG.trace("update : Operation Interface update event - Old: {}, New: {}", original, update);
if (!L2vlan.class.equals(update.getType())) {
LOG.debug("update : Interface {} is not Vlan Interface.Ignoring", update.getName());
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceBuilder;
import org.slf4j.LoggerFactory;
@Singleton
-public class NatRouterInterfaceListener
- extends AsyncDataTreeChangeListenerBase<Interfaces, NatRouterInterfaceListener> {
+public class NatRouterInterfaceListener extends AbstractAsyncDataTreeChangeListener<Interfaces> {
private static final Logger LOG = LoggerFactory.getLogger(NatRouterInterfaceListener.class);
private final DataBroker dataBroker;
public NatRouterInterfaceListener(final DataBroker dataBroker, final OdlInterfaceRpcService interfaceManager,
final IMdsalApiManager mdsalManager,final NaptManager naptManager,
final NeutronvpnService neutronvpnService) {
- super(Interfaces.class, NatRouterInterfaceListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(RouterInterfacesMap.class)
+ .child(RouterInterfaces.class).child(Interfaces.class),
+ Executors.newListeningSingleThreadExecutor("NatRouterInterfaceListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.interfaceManager = interfaceManager;
this.neutronVpnService = neutronvpnService;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected NatRouterInterfaceListener getDataTreeChangeListener() {
- return NatRouterInterfaceListener.this;
}
@Override
- protected InstanceIdentifier<Interfaces> getWildCardPath() {
- return InstanceIdentifier.create(RouterInterfacesMap.class)
- .child(RouterInterfaces.class).child(Interfaces.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
+ public void add(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
LOG.trace("add : Add event - key: {}, value: {}", interfaceInfo.key(), interfaceInfo);
final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();
final String interfaceName = interfaceInfo.getInterfaceId();
}
@Override
- protected void remove(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
+ public void remove(InstanceIdentifier<Interfaces> identifier, Interfaces interfaceInfo) {
LOG.trace("remove : Remove event - key: {}, value: {}", interfaceInfo.key(), interfaceInfo);
final String routerId = identifier.firstKeyOf(RouterInterfaces.class).getRouterId().getValue();
final String interfaceName = interfaceInfo.getInterfaceId();
}
@Override
- protected void update(InstanceIdentifier<Interfaces> identifier, Interfaces original, Interfaces update) {
+ public void update(InstanceIdentifier<Interfaces> identifier, Interfaces original, Interfaces update) {
LOG.trace("update key: {}, original: {}, update: {}", update.key(), original, update);
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.List;
-
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
return transitionState;
}
- private class NatInterfaceStateAddWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class NatInterfaceStateAddWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final String interfaceName;
private final String routerName;
private final Uint64 intfDpnId;
}
}
- private class NatInterfaceStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class NatInterfaceStateRemoveWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final String interfaceName;
private final String routerName;
private final Uint64 intfDpnId;
}
}
- private class NatInterfaceStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class NatInterfaceStateUpdateWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final Interface original;
private final Interface update;
private final Uint64 intfDpnId;
}
}
- private class NatFlowAddWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class NatFlowAddWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final String interfaceName;
private final String routerName;
private final Uint64 dpnId;
}
}
- private class NatFlowUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class NatFlowUpdateWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final Interface original;
private final Interface update;
private final String routerName;
}
}
- private class NatFlowRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class NatFlowRemoveWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final String interfaceName;
private final String routerName;
private final Uint64 intfDpnId;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.natservice.api.NatSwitchCache;
import org.opendaylight.netvirt.natservice.api.NatSwitchCacheListener;
import org.opendaylight.netvirt.natservice.api.SwitchInfo;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.slf4j.LoggerFactory;
@Singleton
-public class NatTepChangeListener extends
- AsyncDataTreeChangeListenerBase<TunnelEndPoints, NatTepChangeListener> {
+public class NatTepChangeListener extends AbstractAsyncDataTreeChangeListener<TunnelEndPoints> {
private static final Logger LOG = LoggerFactory
.getLogger(NatTepChangeListener.class);
final SnatServiceManager natServiceManager,
final JobCoordinator coordinator,
final NatOverVxlanUtil natOverVxlanUtil) {
- super(TunnelEndPoints.class, NatTepChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(DpnEndpoints.class)
+ .child(DPNTEPsInfo.class).child(TunnelEndPoints.class).build(),
+ Executors.newListeningSingleThreadExecutor("NatTepChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.defaultRouteProgrammer = defaultRouteProgrammer;
}
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<TunnelEndPoints> getWildCardPath() {
- return InstanceIdentifier.builder(DpnEndpoints.class)
- .child(DPNTEPsInfo.class).child(TunnelEndPoints.class).build();
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<TunnelEndPoints> key,
+ public void remove(InstanceIdentifier<TunnelEndPoints> key,
TunnelEndPoints tep) {
/*
* Whenever the TEP on a given DPNID is removed, this API take care
}
@Override
- protected void update(InstanceIdentifier<TunnelEndPoints> key,
+ public void update(InstanceIdentifier<TunnelEndPoints> key,
TunnelEndPoints origTep, TunnelEndPoints updatedTep) {
// Will be handled in NatTunnelInterfaceStateListener.add()
LOG.debug("NO ACTION duing update event : {}", updatedTep.key());
}
@Override
- protected void add(InstanceIdentifier<TunnelEndPoints> key,
+ public void add(InstanceIdentifier<TunnelEndPoints> key,
TunnelEndPoints tep) {
LOG.debug("NO ACTION duing add event : {}", tep.key());
}
+ "associated to the router {}", routerName);
InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerName);
- Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType
- .CONFIGURATION, routerPortsId);
+ Optional<RouterPorts> optRouterPorts;
+ try {
+ optRouterPorts = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routerPortsId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("hndlTepDelForDnatInEachRtr: Exception while reading RouterPorts DS for the router {}",
+ routerName, e);
+ return isFipExists;
+ }
if (!optRouterPorts.isPresent()) {
LOG.debug(
"hndlTepDelForDnatInEachRtr : DNAT -> Could not read Router Ports data object with id: {} "
// Check if this is externalRouter else ignore
InstanceIdentifier<Routers> extRoutersId = NatUtil.buildRouterIdentifier(routerName);
- Optional<Routers> routerData = Optional.absent();
+ Optional<Routers> routerData = Optional.empty();
try {
routerData = confTx.read(extRoutersId).get();
} catch (InterruptedException | ExecutionException e) {
}
}
}
-
- @Override
- protected NatTepChangeListener getDataTreeChangeListener() {
- return this;
- }
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.BucketInfo;
import org.opendaylight.genius.mdsalutil.FlowEntity;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.instructions.InstructionGotoTable;
import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.slf4j.LoggerFactory;
@Singleton
-public class NatTunnelInterfaceStateListener
- extends AsyncDataTreeChangeListenerBase<StateTunnelList, NatTunnelInterfaceStateListener> {
+public class NatTunnelInterfaceStateListener extends AbstractAsyncDataTreeChangeListener<StateTunnelList> {
private static final Logger LOG = LoggerFactory.getLogger(NatTunnelInterfaceStateListener.class);
private final DataBroker dataBroker;
final IElanService elanManager,
final IInterfaceManager interfaceManager,
final NatOverVxlanUtil natOverVxlanUtils) {
- super(StateTunnelList.class, NatTunnelInterfaceStateListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TunnelsState.class)
+ .child(StateTunnelList.class),
+ Executors.newListeningSingleThreadExecutor("NatTunnelInterfaceStateListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.bgpManager = bgpManager;
}
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<StateTunnelList> getWildCardPath() {
- return InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class);
}
@Override
- protected NatTunnelInterfaceStateListener getDataTreeChangeListener() {
- return NatTunnelInterfaceStateListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<StateTunnelList> instanceIdentifier, StateTunnelList add) {
+ public void add(InstanceIdentifier<StateTunnelList> instanceIdentifier, StateTunnelList add) {
LOG.trace("add : TEP addtion---- {}", add);
hndlTepEvntsForDpn(add, TunnelAction.TUNNEL_EP_ADD);
}
@Override
- protected void remove(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList del) {
+ public void remove(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList del) {
LOG.trace("remove : TEP deletion---- {}", del);
// Moved the remove implementation logic to NatTepChangeLister.remove()
}
@Override
- protected void update(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList original,
+ public void update(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList original,
StateTunnelList update) {
LOG.trace("update : Tunnel updation---- {}", update);
//UPDATE IS A SEQUENCE OF DELETE AND ADD EVENTS . DELETE MIGHT HAVE CHANGED THE PRIMARY AND ADVERTISED. SO
routerData = writeFlowInvTx.read(extRoutersId).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading router data for {}", extRoutersId, e);
- routerData = Optional.absent();
+ routerData = Optional.empty();
}
if (!routerData.isPresent()) {
LOG.warn("hndlTepAddForSnatInEachRtr : SNAT->Ignoring TEP add for router {} since its not External Router",
final String routerName = router.getRouter();
InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerName);
- Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType
- .CONFIGURATION, routerPortsId);
+ Optional<RouterPorts> optRouterPorts;
+ try {
+ optRouterPorts = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routerPortsId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("hndlTepAddForDnatInEachRtr: Exception while reading RouterPorts DS for the router {}",
+ routerName, e);
+ return;
+ }
if (!optRouterPorts.isPresent()) {
LOG.debug("hndlTepAddForDnatInEachRtr : DNAT -> Could not read Router Ports data object with id: {} "
+ "from DNAT FloatinIpInfo", routerName);
package org.opendaylight.netvirt.natservice.internal;
import static java.util.Collections.emptyList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.apache.commons.net.util.SubnetUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.common.util.Arguments;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
}
try {
- return confTx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().toJavaUtil().map(
+ return confTx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVpnId).orElse(NatConstants.INVALID_ID);
} catch (InterruptedException | ExecutionException e) {
try {
routerInterfacesData = SingleTransactionDataBroker.syncReadOptional(broker,
LogicalDatastoreType.CONFIGURATION, vmInterfaceIdentifier);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Read Failed Exception While read RouterInterface data for router {}", routerName, e);
- routerInterfacesData = Optional.absent();
+ routerInterfacesData = Optional.empty();
}
if (routerInterfacesData.isPresent()) {
return Boolean.TRUE;
InstanceIdentifier<VpnIds> id = InstanceIdentifier.builder(VpnIdToVpnInstance.class)
.child(VpnIds.class, new VpnIdsKey(vpnId)).build();
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(VpnIds::getVpnInstanceName).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(VpnIds::getVpnInstanceName).orElse(null);
}
/*
}
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Routers::getNetworkId).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Routers::getNetworkId).orElse(null);
}
static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
static boolean isSnatEnabledForRouterId(DataBroker broker, String routerId) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Routers::isEnableSnat).orElse(false);
+ LogicalDatastoreType.CONFIGURATION, id).map(Routers::isEnableSnat).orElse(false);
}
@Nullable
public static Uuid getVpnIdfromNetworkId(DataBroker broker, Uuid networkId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Networks::getVpnid).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Networks::getVpnid).orElse(null);
}
@Nullable
public static Uuid getVpnIdfromNetworkId(TypedReadTransaction<Configuration> tx, Uuid networkId) {
try {
- return tx.read(buildNetworkIdentifier(networkId)).get().toJavaUtil().map(Networks::getVpnid).orElse(null);
+ return tx.read(buildNetworkIdentifier(networkId)).get().map(Networks::getVpnid).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading network VPN id for {}", networkId, e);
return null;
public static ProviderTypes getProviderTypefromNetworkId(DataBroker broker, Uuid networkId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Networks::getProviderNetworkType).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Networks::getProviderNetworkType).orElse(null);
}
@Nullable
public static ProviderTypes getProviderTypefromNetworkId(TypedReadTransaction<Configuration> tx, Uuid networkId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
try {
- return tx.read(id).get().toJavaUtil().map(Networks::getProviderNetworkType).orElse(null);
+ return tx.read(id).get().map(Networks::getProviderNetworkType).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving provider type for {}", networkId, e);
return null;
}
InstanceIdentifier<RouterToNaptSwitch> id = buildNaptSwitchIdentifier(routerName);
return (SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(RouterToNaptSwitch::getPrimarySwitchId).orElse(
+ LogicalDatastoreType.CONFIGURATION, id).map(RouterToNaptSwitch::getPrimarySwitchId).orElse(
Uint64.valueOf(0L)));
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
.instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVrfId).orElse(null);
}
@Nullable
public static String getVpnRd(TypedReadTransaction<Configuration> tx, String vpnName) {
try {
- return tx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().toJavaUtil().map(
+ return tx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVrfId).orElse(null);
} catch (InterruptedException | ExecutionException e) {
InstanceIdentifier<IpPortMap> ipPortMapId =
buildIpToPortMapIdentifier(routerId, internalIpAddress, internalPort, protocolType);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, ipPortMapId).toJavaUtil().map(IpPortMap::getIpPortExternal).orElse(
+ LogicalDatastoreType.CONFIGURATION, ipPortMapId).map(IpPortMap::getIpPortExternal).orElse(
null);
}
static Uint32 getAssociatedVpn(DataBroker broker, String routerName) {
InstanceIdentifier<Routermapping> routerMappingId = NatUtil.getRouterVpnMappingId(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.OPERATIONAL, routerMappingId).toJavaUtil().map(Routermapping::getVpnId).orElse(
+ LogicalDatastoreType.OPERATIONAL, routerMappingId).map(Routermapping::getVpnId).orElse(
NatConstants.INVALID_ID);
}
List<Uint16> portList = SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION,
- buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)).toJavaUtil().map(
+ buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)).map(
IntIpProtoType::getPorts).orElse(emptyList());
if (!portList.isEmpty()) {
String internalIpAddress) {
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION,
- buildSnatIntIpPortIdentifier(routerId, internalIpAddress)).orNull();
+ buildSnatIntIpPortIdentifier(routerId, internalIpAddress)).orElse(null);
}
public static ProtocolTypes getProtocolType(NAPTEntryEvent.Protocol protocol) {
@Nullable
public static IpPortMapping getIportMapping(DataBroker broker, Uint32 routerId) {
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orNull();
+ LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orElse(null);
}
public static InstanceIdentifier<IpPortMapping> getIportMappingIdentifier(Uint32 routerId) {
InstanceIdentifier<ExternalCounters> id =
InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(segmentId)).build();
- Optional<ExternalCounters> externalCountersData =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<ExternalCounters> externalCountersData;
+ try {
+ externalCountersData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getLeastLoadedExternalIp: Exception while reading ExternalCounters DS for the segmentId {}",
+ segmentId, e);
+ return leastLoadedExternalIp;
+ }
if (externalCountersData.isPresent()) {
ExternalCounters externalCounter = externalCountersData.get();
short countOfLstLoadExtIp = 32767;
.child(Subnetmap.class, new SubnetmapKey(subnetId))
.build();
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, subnetmapId).toJavaUtil().map(Subnetmap::getSubnetIp).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, subnetmapId).map(Subnetmap::getSubnetIp).orElse(null);
}
public static String[] getExternalIpAndPrefix(String leastLoadedExtIpAddr) {
static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces
.@Nullable RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) {
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)).orNull();
+ LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)).orElse(null);
}
static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
optionalRouterDpnList = operTx.read(routerDpnListIdentifier).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the router DPN list for {}", routerDpnListIdentifier, e);
- optionalRouterDpnList = Optional.absent();
+ optionalRouterDpnList = Optional.empty();
}
if (optionalRouterDpnList.isPresent()) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns
InstanceIdentifier<Subnetmap> subnetmapId = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, subnetmapId).orNull();
+ LogicalDatastoreType.CONFIGURATION, subnetmapId).orElse(null);
}
@NonNull
.child(NetworkMap.class, new NetworkMapKey(networkId)).build();
List<Uuid> subnetIdList = SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(NetworkMap::getSubnetIdList).orElse(
+ LogicalDatastoreType.CONFIGURATION, id).map(NetworkMap::getSubnetIdList).orElse(
emptyList());
if (!subnetIdList.isEmpty()) {
subnetIdList = new ArrayList<>(subnetIdList);
protected static String getFloatingIpPortMacFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
InstanceIdentifier<FloatingIpIdToPortMapping> id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
FloatingIpIdToPortMapping::getFloatingIpPortMacAddress).orElse(null);
}
protected static String getFloatingIpPortMacFromFloatingIpId(TypedReadTransaction<Configuration> confTx,
Uuid floatingIpId) {
try {
- return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().toJavaUtil().map(
+ return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().map(
FloatingIpIdToPortMapping::getFloatingIpPortMacAddress).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the floating IP port MAC for {}", floatingIpId, e);
protected static Uuid getFloatingIpPortSubnetIdFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
InstanceIdentifier<FloatingIpIdToPortMapping> id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
FloatingIpIdToPortMapping::getFloatingIpPortSubnetId).orElse(null);
}
protected static Uuid getFloatingIpPortSubnetIdFromFloatingIpId(TypedReadTransaction<Configuration> confTx,
Uuid floatingIpId) {
try {
- return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().toJavaUtil().map(
+ return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().map(
FloatingIpIdToPortMapping::getFloatingIpPortSubnetId).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the floating IP port subnet for {}", floatingIpId, e);
InstanceIdentifier<Interface> ifStateId =
buildStateInterfaceId(interfaceName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.OPERATIONAL, ifStateId).orNull();
+ LogicalDatastoreType.OPERATIONAL, ifStateId).orElse(null);
}
static InstanceIdentifier<Interface> buildStateInterfaceId(String interfaceName) {
public static Routers getRoutersFromConfigDS(DataBroker dataBroker, String routerName) {
InstanceIdentifier<Routers> routerIdentifier = NatUtil.buildRouterIdentifier(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, routerIdentifier).orNull();
+ LogicalDatastoreType.CONFIGURATION, routerIdentifier).orElse(null);
}
@Nullable
public static Routers getRoutersFromConfigDS(TypedReadTransaction<Configuration> confTx, String routerName) {
try {
- return confTx.read(NatUtil.buildRouterIdentifier(routerName)).get().orNull();
+ return confTx.read(NatUtil.buildRouterIdentifier(routerName)).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading router {}", routerName, e);
return null;
static String getExtGwMacAddFromRouterName(DataBroker broker, String routerName) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Routers::getExtGwMacAddress).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Routers::getExtGwMacAddress).orElse(null);
}
@Nullable
static String getExtGwMacAddFromRouterName(TypedReadTransaction<Configuration> tx, String routerName) {
try {
- return tx.read(buildRouterIdentifier(routerName)).get().toJavaUtil().map(
+ return tx.read(buildRouterIdentifier(routerName)).get().map(
Routers::getExtGwMacAddress).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving external gateway MAC address for router {}", routerName, e);
public static String getNeutronRouterNamebyUuid(DataBroker broker, Uuid routerUuid) {
InstanceIdentifier<Router> neutronRouterIdentifier = NatUtil.buildNeutronRouterIdentifier(routerUuid);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, neutronRouterIdentifier).toJavaUtil().map(Router::getName).orElse(
+ LogicalDatastoreType.CONFIGURATION, neutronRouterIdentifier).map(Router::getName).orElse(
null);
}
InstanceIdentifier<RouterPorts> routerPortsIdentifier = getRouterPortsId(routerUuid.getValue());
List<Ports> portsList = SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, LogicalDatastoreType.CONFIGURATION,
- routerPortsIdentifier).toJavaUtil().map(RouterPorts::getPorts).orElse(emptyList());
+ routerPortsIdentifier).map(RouterPorts::getPorts).orElse(emptyList());
if (!portsList.isEmpty()) {
portsList = new ArrayList<>(portsList);
}
.subnets.Subnets> getOptionalExternalSubnets(DataBroker dataBroker, Uuid subnetId) {
if (subnetId == null) {
LOG.warn("getOptionalExternalSubnets : subnetId is null");
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
.subnets.Subnets> getOptionalExternalSubnets(TypedReadTransaction<Configuration> tx, Uuid subnetId) {
if (subnetId == null) {
LOG.warn("getOptionalExternalSubnets : subnetId is null");
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
return tx.read(subnetsIdentifier).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving external subnets on {}", subnetId, e);
- return Optional.absent();
+ return Optional.empty();
}
}
public static ElanInstance getElanInstanceByName(String elanInstanceName, DataBroker broker) {
InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
+ LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orElse(null);
}
@Nullable
public static ElanInstance getElanInstanceByName(TypedReadTransaction<Configuration> tx, String elanInstanceName) {
try {
- return tx.read(getElanInstanceConfigurationDataPath(elanInstanceName)).get().orNull();
+ return tx.read(getElanInstanceConfigurationDataPath(elanInstanceName)).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving ELAN instance by name {}", elanInstanceName, e);
return null;
String vpnName, String externalIp,
Boolean isMoreThanOneFipCheckOnDpn) {
InstanceIdentifier<VpnToDpnList> id = getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnToDpnList> dpnInVpn;
+ try {
+ dpnInVpn = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("isFloatingIpPresentForDpn: Exception while reading VpnToDpnList DS for the rd {} dpnId {}",
+ rd, dpnId, e);
+ return false;
+ }
if (dpnInVpn.isPresent()) {
LOG.debug("isFloatingIpPresentForDpn : vpn-to-dpn-list is not empty for vpnName {}, dpn id {}, "
+ "rd {} and floatingIp {}", vpnName, dpnId, rd, externalIp);
@Nullable
public static String getPrimaryRd(String vpnName, TypedReadTransaction<Configuration> tx)
throws ExecutionException, InterruptedException {
- return tx.read(getVpnInstanceIdentifier(vpnName)).get().toJavaUtil().map(NatUtil::getPrimaryRd).orElse(null);
+ return tx.read(getVpnInstanceIdentifier(vpnName)).get().map(NatUtil::getPrimaryRd).orElse(null);
}
@Nullable
public static boolean checkForRoutersWithSameExtNetAndNaptSwitch(DataBroker broker, Uuid networkId,
String routerName, Uint64 dpnId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
- Optional<Networks> networkData = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
+ Optional<Networks> networkData = null;
+ try {
+ networkData = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkForRoutersWithSameExtNetAndNaptSwitch: Exception while reading Networks DS for the "
+ + "network {} router {} dpnId {}", networkId.getValue(), routerName, dpnId, e);
+ return false;
+ }
if (networkData != null && networkData.isPresent()) {
List<Uuid> routerUuidList = networkData.get().getRouterIds();
if (routerUuidList != null && !routerUuidList.isEmpty()) {
public static boolean checkForRoutersWithSameExtSubnetAndNaptSwitch(DataBroker broker, Uuid externalSubnetId,
String routerName, Uint64 dpnId) {
- List<Uuid> routerUuidList = getOptionalExternalSubnets(broker, externalSubnetId).toJavaUtil()
- .map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external
+ List<Uuid> routerUuidList = getOptionalExternalSubnets(broker, externalSubnetId)
+ .map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external
.subnets.Subnets::getRouterIds).orElse(emptyList());
if (!routerUuidList.isEmpty()) {
for (Uuid routerUuid : routerUuidList) {
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
elanDpnInterfaceId, dpnInterface);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to read elanDpnInterface with error {}", e.getMessage());
} catch (TransactionCommitFailedException e) {
LOG.warn("Failed to add elanDpnInterface with error {}", e.getMessage());
.withKey(new DpnInterfacesKey(dpnId)).build();
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
elanDpnInterfaceId, dpnInterface);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to read elanDpnInterface with error {}", e.getMessage());
} catch (TransactionCommitFailedException e) {
LOG.warn("Failed to remove elanDpnInterface with error {}", e.getMessage());
return SingleTransactionDataBroker.syncRead(dataBroker,
LogicalDatastoreType.OPERATIONAL, getLearntVpnVipToPortDataId());
}
- catch (ReadFailedException e) {
+ catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read LearntVpnVipToPortData with error {}", e.getMessage());
return null;
}
LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
if (!bridgeRefEntry.isPresent()) {
LOG.info("getBridgeRefInfo : bridgeRefEntry is not present for {}", dpnId);
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<Node> nodeId =
@Nullable
public static String getProviderMappings(Uint64 dpId, DataBroker dataBroker) {
- return getBridgeRefInfo(dpId, dataBroker).toJavaUtil().map(node -> getOpenvswitchOtherConfigs(node,
+ return getBridgeRefInfo(dpId, dataBroker).map(node -> getOpenvswitchOtherConfigs(node,
PROVIDER_MAPPINGS, dataBroker)).orElse(null);
}
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
}
- return Optional.absent();
+ return Optional.empty();
}
if (optionalExternalSubnets.isPresent()) {
return optionalExternalSubnets.get();
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read the subnets from the datastore.");
}
return null;
try {
portsOptional = SingleTransactionDataBroker
.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, portsIdentifier);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Read Failed Exception While Reading Neutron Port for {}", ifaceName, e);
- portsOptional = Optional.absent();
+ portsOptional = Optional.empty();
}
if (!portsOptional.isPresent()) {
LOG.error("getNeutronPort : No neutron ports found for interface {}", ifaceName);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
.vpn.instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
- .vpn.instance.to.vpn.id.VpnInstance> vpnInstance = Optional.absent();
+ .vpn.instance.to.vpn.id.VpnInstance> vpnInstance = Optional.empty();
try {
vpnInstance = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, id);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read VpnInstance {}", vpnInstance, e);
}
if (vpnInstance.isPresent()) {
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.slf4j.LoggerFactory;
@Singleton
-public class NatVpnMapsChangeListener extends AsyncDataTreeChangeListenerBase<VpnMap, NatVpnMapsChangeListener> {
+public class NatVpnMapsChangeListener extends AbstractAsyncDataTreeChangeListener<VpnMap> {
private static final Logger LOG = LoggerFactory.getLogger(NatVpnMapsChangeListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
final FloatingIPListener floatingIpListener,
final OdlInterfaceRpcService interfaceManager,
final ExternalRoutersListener externalRoutersListener) {
- super(VpnMap.class, NatVpnMapsChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VpnMaps.class)
+ .child(VpnMap.class),
+ Executors.newListeningSingleThreadExecutor("NatVpnMapsChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.floatingIpListener = floatingIpListener;
this.externalRoutersListener = externalRoutersListener;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<VpnMap> getWildCardPath() {
- return InstanceIdentifier.create(VpnMaps.class).child(VpnMap.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<VpnMap> identifier, VpnMap vpnMap) {
+ public void add(InstanceIdentifier<VpnMap> identifier, VpnMap vpnMap) {
Uuid vpnUuid = vpnMap.getVpnId();
String vpnName = vpnUuid.getValue();
if (vpnMap.getRouterIds() != null) {
}
@Override
- protected void remove(InstanceIdentifier<VpnMap> identifier, VpnMap vpnMap) {
+ public void remove(InstanceIdentifier<VpnMap> identifier, VpnMap vpnMap) {
Uuid vpnUuid = vpnMap.getVpnId();
String vpnName = vpnUuid.getValue();
if (vpnMap.getRouterIds() != null) {
}
@Override
- protected void update(InstanceIdentifier<VpnMap> identifier, VpnMap original, VpnMap updated) {
+ public void update(InstanceIdentifier<VpnMap> identifier, VpnMap original, VpnMap updated) {
Uuid vpnUuid = updated.getVpnId();
String vpnName = vpnUuid.getValue();
}
}
- @Override
- protected NatVpnMapsChangeListener getDataTreeChangeListener() {
- return this;
- }
-
public void onRouterAssociatedToVpn(String vpnName, String routerName) {
//check router is associated to external network
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.slf4j.LoggerFactory;
@Singleton
-public class RouterDpnChangeListener
- extends AsyncDataTreeChangeListenerBase<DpnVpninterfacesList, RouterDpnChangeListener> {
+public class RouterDpnChangeListener extends AbstractAsyncDataTreeChangeListener<DpnVpninterfacesList> {
private static final Logger LOG = LoggerFactory.getLogger(RouterDpnChangeListener.class);
private final DataBroker dataBroker;
final NatserviceConfig config,
final JobCoordinator coordinator,
final UpgradeState upgradeState) {
- super(DpnVpninterfacesList.class, RouterDpnChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(NeutronRouterDpns.class)
+ .child(RouterDpnList.class).child(DpnVpninterfacesList.class),
+ Executors.newListeningSingleThreadExecutor("RouterDpnChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.upgradeState = upgradeState;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- }
-
- @Override
- protected RouterDpnChangeListener getDataTreeChangeListener() {
- return RouterDpnChangeListener.this;
}
@Override
- protected InstanceIdentifier<DpnVpninterfacesList> getWildCardPath() {
- return InstanceIdentifier.create(NeutronRouterDpns.class).child(RouterDpnList.class)
- .child(DpnVpninterfacesList.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(final InstanceIdentifier<DpnVpninterfacesList> identifier, final DpnVpninterfacesList dpnInfo) {
+ public void add(final InstanceIdentifier<DpnVpninterfacesList> identifier, final DpnVpninterfacesList dpnInfo) {
LOG.trace("add : key: {}, value: {}", dpnInfo.key(), dpnInfo);
final String routerUuid = identifier.firstKeyOf(RouterDpnList.class).getRouterId();
Uint64 dpnId = dpnInfo.getDpnId();
}
@Override
- protected void remove(InstanceIdentifier<DpnVpninterfacesList> identifier, DpnVpninterfacesList dpnInfo) {
+ public void remove(InstanceIdentifier<DpnVpninterfacesList> identifier, DpnVpninterfacesList dpnInfo) {
LOG.trace("remove : key: {}, value: {}", dpnInfo.key(), dpnInfo);
final String routerUuid = identifier.firstKeyOf(RouterDpnList.class).getRouterId();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerUuid);
}
@Override
- protected void update(InstanceIdentifier<DpnVpninterfacesList> identifier, DpnVpninterfacesList original,
+ public void update(InstanceIdentifier<DpnVpninterfacesList> identifier, DpnVpninterfacesList original,
DpnVpninterfacesList update) {
LOG.trace("Update key: {}, original: {}, update: {}", update.key(), original, update);
}
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.FloatingIpInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.RouterPorts;
import org.slf4j.LoggerFactory;
@Singleton
-public class RouterPortsListener
- extends AsyncDataTreeChangeListenerBase<RouterPorts, RouterPortsListener> {
+public class RouterPortsListener extends AbstractAsyncDataTreeChangeListener<RouterPorts> {
private static final Logger LOG = LoggerFactory.getLogger(RouterPortsListener.class);
private final DataBroker dataBroker;
@Inject
public RouterPortsListener(final DataBroker dataBroker) {
- super(RouterPorts.class, RouterPortsListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(FloatingIpInfo.class)
+ .child(RouterPorts.class),
+ Executors.newListeningSingleThreadExecutor("RouterPortsListener", LOG));
this.dataBroker = dataBroker;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<RouterPorts> getWildCardPath() {
- return InstanceIdentifier.create(FloatingIpInfo.class).child(RouterPorts.class);
}
@Override
- protected RouterPortsListener getDataTreeChangeListener() {
- return RouterPortsListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(final InstanceIdentifier<RouterPorts> identifier, final RouterPorts routerPorts) {
+ public void add(final InstanceIdentifier<RouterPorts> identifier, final RouterPorts routerPorts) {
LOG.trace("add : key:{} value:{}",routerPorts.key(), routerPorts);
Optional<RouterPorts> optRouterPorts =
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
}
@Override
- protected void remove(InstanceIdentifier<RouterPorts> identifier, RouterPorts routerPorts) {
+ public void remove(InstanceIdentifier<RouterPorts> identifier, RouterPorts routerPorts) {
LOG.trace("remove : key:{} value:{}",routerPorts.key(), routerPorts);
//MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
//Remove the router to vpn association mapping entry if at all present
}
@Override
- protected void update(InstanceIdentifier<RouterPorts> identifier, RouterPorts original, RouterPorts update) {
+ public void update(InstanceIdentifier<RouterPorts> identifier, RouterPorts original, RouterPorts update) {
LOG.trace("Update : key: {}, original:{}, update:{}",update.key(), original, update);
}
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.natservice.api.NatSwitchCache;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.Objects;
-
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.natservice.api.CentralizedSwitchScheduler;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.slf4j.LoggerFactory;
@Singleton
-public class SnatExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Routers, SnatExternalRoutersListener> {
+public class SnatExternalRoutersListener extends AbstractAsyncDataTreeChangeListener<Routers> {
private static final Logger LOG = LoggerFactory.getLogger(SnatExternalRoutersListener.class);
private final DataBroker dataBroker;
final NatserviceConfig config,
final SnatServiceManager natServiceManager,
final UpgradeState upgradeState) {
- super(Routers.class, SnatExternalRoutersListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(ExtRouters.class)
+ .child(Routers.class),
+ Executors.newListeningSingleThreadExecutor("SnatExternalRoutersListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.idManager = idManager;
} else {
this.natMode = NatMode.Conntrack;
}
+ init();
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
// This class handles ExternalRouters for Conntrack SNAT mode.
// For Controller SNAT mode, its handled in ExternalRoutersListeners.java
if (natMode == NatMode.Conntrack) {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
NatUtil.createGroupIdPool(idManager);
}
}
@Override
- protected InstanceIdentifier<Routers> getWildCardPath() {
- return InstanceIdentifier.create(ExtRouters.class).child(Routers.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Routers> identifier, Routers routers) {
+ public void add(InstanceIdentifier<Routers> identifier, Routers routers) {
+ if (natMode != NatMode.Conntrack) {
+ return;
+ }
String routerName = routers.getRouterName();
if (upgradeState.isUpgradeInProgress()) {
LOG.warn("add event for ext-router {}, but upgrade is in progress.", routerName);
}
@Override
- protected void update(InstanceIdentifier<Routers> identifier, Routers original, Routers update) {
+ public void update(InstanceIdentifier<Routers> identifier, Routers original, Routers update) {
+ if (natMode != NatMode.Conntrack) {
+ return;
+ }
String routerName = original.getRouterName();
Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
if (routerId == NatConstants.INVALID_ID) {
}
@Override
- protected void remove(InstanceIdentifier<Routers> identifier, Routers router) {
+ public void remove(InstanceIdentifier<Routers> identifier, Routers router) {
+ if (natMode != NatMode.Conntrack) {
+ return;
+ }
if (identifier == null || router == null) {
LOG.error("remove : returning without processing since ext-router is null");
return;
LOG.info("remove : external router event for {}", router.getRouterName());
centralizedSwitchScheduler.releaseCentralizedSwitch(router);
}
-
- @Override
- protected SnatExternalRoutersListener getDataTreeChangeListener() {
- return SnatExternalRoutersListener.this;
- }
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.inject.AbstractLifecycle;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.ha.NatDataUtil;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
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.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.slf4j.LoggerFactory;
@Singleton
-public class SubnetGwMacChangeListener
- extends AsyncDataTreeChangeListenerBase<LearntVpnVipToPort, SubnetGwMacChangeListener> {
+public class SubnetGwMacChangeListener extends AbstractAsyncDataTreeChangeListener<LearntVpnVipToPort> {
private static final Logger LOG = LoggerFactory.getLogger(SubnetGwMacChangeListener.class);
private final DataBroker broker;
@Inject
public SubnetGwMacChangeListener(final DataBroker broker, final INeutronVpnManager nvpnManager,
final ExternalNetworkGroupInstaller extNetworkInstaller) {
- super(LearntVpnVipToPort.class, SubnetGwMacChangeListener.class);
+ super(broker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(LearntVpnVipToPortData.class)
+ .child(LearntVpnVipToPort.class),
+ Executors.newListeningSingleThreadExecutor("SubnetGwMacChangeListener", LOG));
this.broker = broker;
this.nvpnManager = nvpnManager;
this.extNetworkInstaller = extNetworkInstaller;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<LearntVpnVipToPort> getWildCardPath() {
- return InstanceIdentifier.builder(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class).build();
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort learntVpnVipToPort) {
+ public void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort learntVpnVipToPort) {
}
@Override
- protected void update(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort origLearntVpnVipToPort,
+ public void update(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort origLearntVpnVipToPort,
LearntVpnVipToPort updatedLearntVpnVipToPort) {
handleSubnetGwIpChange(updatedLearntVpnVipToPort);
}
@Override
- protected void add(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort learntVpnVipToPort) {
+ public void add(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort learntVpnVipToPort) {
handleSubnetGwIpChange(learntVpnVipToPort);
}
- @Override
- protected SubnetGwMacChangeListener getDataTreeChangeListener() {
- return this;
- }
-
private void handleSubnetGwIpChange(LearntVpnVipToPort learntVpnVipToPort) {
String macAddress = learntVpnVipToPort.getMacAddress();
if (macAddress == null) {
package org.opendaylight.netvirt.natservice.internal;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.LoggerFactory;
@Singleton
-public class SubnetmapListener extends AsyncDataTreeChangeListenerBase<Subnetmap, SubnetmapListener> {
+public class SubnetmapListener extends AbstractAsyncDataTreeChangeListener<Subnetmap> {
private static final Logger LOG = LoggerFactory.getLogger(SubnetmapListener.class);
private final DataBroker dataBroker;
private final ExternalNetworkGroupInstaller externalNetworkGroupInstaller;
public SubnetmapListener(final DataBroker dataBroker,
final ExternalNetworkGroupInstaller externalNetworkGroupInstaller,
NatServiceCounters natServiceCounters) {
- super(Subnetmap.class, SubnetmapListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Subnetmaps.class).child(Subnetmap.class),
+ Executors.newListeningSingleThreadExecutor("SubnetmapListener", LOG));
this.dataBroker = dataBroker;
this.externalNetworkGroupInstaller = externalNetworkGroupInstaller;
this.natServiceCounters = natServiceCounters;
}
- @Override
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ LOG.info("{} init", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<Subnetmap> getWildCardPath() {
- return InstanceIdentifier.create(Subnetmaps.class).child(Subnetmap.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
+ public void remove(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
LOG.trace("remove key: {} value: {}", subnetmap.key(), subnetmap);
natServiceCounters.subnetmapRemove();
externalNetworkGroupInstaller.removeExtNetGroupEntries(subnetmap);
}
@Override
- protected void update(InstanceIdentifier<Subnetmap> identifier,
+ public void update(InstanceIdentifier<Subnetmap> identifier,
Subnetmap subnetmapBefore, Subnetmap subnetmapAfter) {
LOG.trace("update key: {}, original: {}, update: {}", subnetmapAfter.key(), subnetmapBefore, subnetmapAfter);
natServiceCounters.subnetmapUpdate();
}
@Override
- protected void add(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
+ public void add(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
LOG.trace("add key: {} value: {}", subnetmap.key(), subnetmap);
natServiceCounters.subnetmapAdd();
externalNetworkGroupInstaller.installExtNetGroupEntries(subnetmap);
}
-
- @Override
- protected SubnetmapListener getDataTreeChangeListener() {
- return this;
- }
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.natservice.api.CentralizedSwitchScheduler;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
final IdManagerService idManager,
final NaptSwitchHA naptSwitchHA,
final NatserviceConfig config, final JobCoordinator coordinator) {
- super(dataBroker, new DataTreeIdentifier<>(
+ super(dataBroker, DataTreeIdentifier.create(
LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(UpgradeConfig.class)));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
import com.google.common.util.concurrent.FluentFuture;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NeutronVipStates;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.neutron.vip.states.VipState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.neutron.vip.states.VipStateBuilder;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.netvirt.natservice.internal.NatUtil.buildfloatingIpIdToPortMappingIdentifier;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchCtState;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.ha.NatDataUtil;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.natservice.internal.NatConstants;
import org.opendaylight.netvirt.natservice.internal.NatUtil;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0">
<reference id="dataBrokerRef"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
- odl:type="pingpong"/>
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
+ odl:type="default"/>
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
<command>
<action class="org.opendaylight.netvirt.natservice.cli.DisplayNaptSwithcesCli">
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="iBgpManager"
interface="org.opendaylight.netvirt.bgpmanager.api.IBgpManager" />
<modelVersion>4.0.0</modelVersion>
<dependencies>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>mdsalutil-api</artifactId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.genius</groupId>
+ <artifactId>mdsalutil-api</artifactId>
+ <version>0.9.0-SNAPSHOT</version>
+ </dependency>
</dependencies>
</project>
import java.util.Queue;
import java.util.Set;
import java.util.function.Predicate;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap.RouterIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
List<String> showVpnConfigCLI(Uuid vuuid) throws InterruptedException, ExecutionException;
- List<String> showNeutronPortsCLI() throws ReadFailedException;
+ List<String> showNeutronPortsCLI() throws ExecutionException, InterruptedException;
Network getNeutronNetwork(Uuid networkId);
package org.opendaylight.netvirt.neutronvpn;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.Hostconfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.hostconfigs.Hostconfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.hostconfigs.HostconfigKey;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronBgpvpnChangeListener extends AsyncDataTreeChangeListenerBase<Bgpvpn, NeutronBgpvpnChangeListener> {
+public class NeutronBgpvpnChangeListener extends AbstractAsyncDataTreeChangeListener<Bgpvpn> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronBgpvpnChangeListener.class);
private final DataBroker dataBroker;
private final NeutronvpnManager nvpnManager;
@Inject
public NeutronBgpvpnChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
final IdManagerService idManager, final NeutronvpnUtils neutronvpnUtils) {
- super(Bgpvpn.class, NeutronBgpvpnChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Bgpvpns.class).child(Bgpvpn.class), Executors.newSingleThreadExecutor(
+ "NeutronBgpvpnChangeListener", LOG));
this.dataBroker = dataBroker;
nvpnManager = neutronvpnManager;
this.idManager = idManager;
this.neutronvpnUtils = neutronvpnUtils;
BundleContext bundleContext = FrameworkUtil.getBundle(NeutronBgpvpnChangeListener.class).getBundleContext();
adminRDValue = bundleContext.getProperty(NeutronConstants.RD_PROPERTY_KEY);
+ init();
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
createIdPool();
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Bgpvpn> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Bgpvpns.class).child(Bgpvpn.class);
}
@Override
- protected NeutronBgpvpnChangeListener getDataTreeChangeListener() {
- return NeutronBgpvpnChangeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
private boolean isBgpvpnTypeL3(Class<? extends BgpvpnTypeBase> bgpvpnType) {
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
+ public void add(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
LOG.trace("Adding Bgpvpn : key: {}, value={}", identifier, input);
String vpnName = input.getUuid().getValue();
if (isBgpvpnTypeL3(input.getType())) {
}
@Override
- protected void remove(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
+ public void remove(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
LOG.trace("Removing Bgpvpn : key: {}, value={}", identifier, input);
Uuid vpnId = input.getUuid();
if (isBgpvpnTypeL3(input.getType())) {
}
@Override
- protected void update(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn original, Bgpvpn update) {
+ public void update(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn original, Bgpvpn update) {
LOG.trace("Update Bgpvpn : key: {}, value={}", identifier, update);
Uuid vpnId = update.getUuid();
if (isBgpvpnTypeL3(update.getType())) {
import static org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.NamedLocks;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.FloatingIpInfo;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronFloatingToFixedIpMappingChangeListener extends AsyncDataTreeChangeListenerBase<Floatingip,
- NeutronFloatingToFixedIpMappingChangeListener> {
+public class NeutronFloatingToFixedIpMappingChangeListener extends AbstractAsyncDataTreeChangeListener<Floatingip> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronFloatingToFixedIpMappingChangeListener.class);
private static final long LOCK_WAIT_TIME = 10L;
@Inject
public NeutronFloatingToFixedIpMappingChangeListener(final DataBroker dataBroker) {
- super(Floatingip.class, NeutronFloatingToFixedIpMappingChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Floatingips.class).child(Floatingip.class),
+ Executors.newSingleThreadExecutor("NeutronFloatingToFixedIpMappingChangeListener", LOG));
this.dataBroker = dataBroker;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Floatingip> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Floatingips.class).child(Floatingip.class);
}
@Override
- protected NeutronFloatingToFixedIpMappingChangeListener getDataTreeChangeListener() {
- return NeutronFloatingToFixedIpMappingChangeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<Floatingip> identifier, Floatingip input) {
+ public void add(InstanceIdentifier<Floatingip> identifier, Floatingip input) {
LOG.trace("Neutron Floating IP created: key: {}, value={}", identifier, input);
IpAddress fixedIp = input.getFixedIpAddress();
String floatingIp = input.getFloatingIpAddress().getIpv4Address().getValue();
}
@Override
- protected void remove(InstanceIdentifier<Floatingip> identifier, Floatingip input) {
+ public void remove(InstanceIdentifier<Floatingip> identifier, Floatingip input) {
LOG.trace("Neutron Floating IP deleted : key: {}, value={}", identifier, input);
IpAddress fixedIp = input.getFixedIpAddress();
if (fixedIp != null) {
// populate the floating to fixed ip map upon association/dissociation from fixed ip
@Override
- protected void update(InstanceIdentifier<Floatingip> identifier, Floatingip original, Floatingip update) {
+ public void update(InstanceIdentifier<Floatingip> identifier, Floatingip original, Floatingip update) {
LOG.trace("Handling FloatingIptoFixedIp mapping : key: {}, original value={}, update value={}", identifier,
original, update);
IpAddress oldFixedIp = original.getFixedIpAddress();
routerPortsBuilder.build());
LOG.debug("FloatingIpInfo DS updated for floating IP {} ", floatingIpAddress);
}
- } catch (ReadFailedException | RuntimeException e) {
+ } catch (RuntimeException | ExecutionException | InterruptedException e) {
LOG.error("addToFloatingIpInfo failed for floating IP: {} ", floatingIpAddress, e);
}
}
} else {
LOG.warn("routerPorts for router {} - fixedIp {} not found", routerName, fixedIpAddress);
}
- } catch (RuntimeException | ReadFailedException e) {
+ } catch (RuntimeException | ExecutionException | InterruptedException e) {
LOG.error("Failed to delete internal-to-external-port-map from FloatingIpInfo DS for fixed Ip {}",
fixedIpAddress, e);
}
LOG.debug("FloatingIPInfo DS empty. Hence, no router present containing fixed to floating IP "
+ "association(s)");
}
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Failed to dissociate fixedIP from FloatingIpInfo DS for neutron port {}",
fixedNeutronPortName, e);
}
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
-import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.Hostconfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.hostconfigs.Hostconfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.hostconfigs.HostconfigBuilder;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronHostConfigChangeListener
- extends AsyncDataTreeChangeListenerBase<Node,NeutronHostConfigChangeListener> {
+public class NeutronHostConfigChangeListener extends AbstractAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronHostConfigChangeListener.class);
private static final String OS_HOST_CONFIG_HOST_ID_KEY = "odl_os_hostconfig_hostid";
private static final String OS_HOST_CONFIG_CONFIG_KEY_PREFIX = "odl_os_hostconfig_config_odl_";
private final DataBroker dataBroker;
private final SouthboundUtils southboundUtils;
- private final ControllerMdsalUtils mdsalUtils;
+ private final MdsalUtils mdsalUtils;
@Inject
public NeutronHostConfigChangeListener(final DataBroker dataBroker) {
- super(Node.class,NeutronHostConfigChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class,new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID)).child(Node.class),
+ Executors.newSingleThreadExecutor("NeutronHostConfigChangeListener", LOG));
this.dataBroker = dataBroker;
- this.mdsalUtils = new ControllerMdsalUtils(dataBroker);
+ this.mdsalUtils = new MdsalUtils(dataBroker);
this.southboundUtils = new SouthboundUtils(mdsalUtils);
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier
- .create(NetworkTopology.class)
- .child(Topology.class,new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
- .child(Node.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected NeutronHostConfigChangeListener getDataTreeChangeListener() {
- return NeutronHostConfigChangeListener.this;
- }
-
-
- @Override
- protected void remove(InstanceIdentifier<Node> identifier, Node del) {
+ public void remove(InstanceIdentifier<Node> identifier, Node del) {
updateHostConfig(del, Action.DELETE);
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
updateHostConfig(update, Action.UPDATE);
}
@Override
- protected void add(InstanceIdentifier<Node> identifier, Node add) {
+ public void add(InstanceIdentifier<Node> identifier, Node add) {
updateHostConfig(add, Action.ADD);
}
*/
package org.opendaylight.netvirt.neutronvpn;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeFlat;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronNetworkChangeListener
- extends AsyncDataTreeChangeListenerBase<Network, NeutronNetworkChangeListener> {
+public class NeutronNetworkChangeListener extends AbstractAsyncDataTreeChangeListener<Network> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkChangeListener.class);
private final DataBroker dataBroker;
private final NeutronvpnManager nvpnManager;
public NeutronNetworkChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
final NeutronvpnNatManager neutronvpnNatManager,
final IElanService elanService, final NeutronvpnUtils neutronvpnUtils) {
- super(Network.class, NeutronNetworkChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Networks.class).child(Network.class), Executors.newSingleThreadExecutor(
+ "NeutronNetworkChangeListener", LOG));
this.dataBroker = dataBroker;
nvpnManager = neutronvpnManager;
nvpnNatManager = neutronvpnNatManager;
this.neutronvpnUtils = neutronvpnUtils;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Network> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected NeutronNetworkChangeListener getDataTreeChangeListener() {
- return NeutronNetworkChangeListener.this;
- }
-
-
- @Override
- protected void add(InstanceIdentifier<Network> identifier, Network input) {
+ public void add(InstanceIdentifier<Network> identifier, Network input) {
LOG.trace("Adding Network : key: {}, value={}", identifier, input);
String networkId = input.getUuid().getValue();
if (!NeutronvpnUtils.isNetworkTypeSupported(input)) {
}
@Override
- protected void remove(InstanceIdentifier<Network> identifier, Network input) {
+ public void remove(InstanceIdentifier<Network> identifier, Network input) {
LOG.trace("Removing Network : key: {}, value={}", identifier, input);
if (NeutronvpnUtils.getIsExternal(input)) {
if (NeutronvpnUtils.isFlatOrVlanNetwork(input)) {
}
@Override
- protected void update(InstanceIdentifier<Network> identifier, Network original, Network update) {
+ public void update(InstanceIdentifier<Network> identifier, Network original, Network update) {
LOG.trace("Updating Network : key: {}, original value={}, update value={}", identifier, original, update);
neutronvpnUtils.addToNetworkCache(update);
String elanInstanceName = original.getUuid().getValue();
private ElanInstance createElanInstance(Network input) {
String elanInstanceName = input.getUuid().getValue();
InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
- Optional<ElanInstance> existingElanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- id);
- if (existingElanInstance.isPresent()) {
- return existingElanInstance.get();
+ Optional<ElanInstance> existingElanInstance = null;
+ try {
+ existingElanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ id);
+ if (existingElanInstance.isPresent()) {
+ return existingElanInstance.get();
+ }
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("createElanInstance: failed to read elanInstance {} due to exception ", elanInstanceName, e);
}
Class<? extends SegmentTypeBase> segmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(input);
String segmentationId = NeutronvpnUtils.getSegmentationIdFromNeutronNetwork(input);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.gson.Gson;
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.ObjectUtils;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.api.enums.IpVersionChoice;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
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.slf4j.LoggerFactory;
@Singleton
-public class NeutronPortChangeListener extends AsyncDataTreeChangeListenerBase<Port, NeutronPortChangeListener> {
+public class NeutronPortChangeListener extends AbstractAsyncDataTreeChangeListener<Port> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronPortChangeListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
private final DataTreeEventCallbackRegistrar eventCallbacks;
private final NeutronvpnConfig neutronvpnConfig;
+ @Inject
public NeutronPortChangeListener(final DataBroker dataBroker,
final NeutronvpnManager neutronvpnManager,
final NeutronvpnNatManager neutronvpnNatManager,
final HostConfigCache hostConfigCache,
final DataTreeEventCallbackRegistrar dataTreeEventCallbackRegistrar,
final NeutronvpnConfig neutronvpnConfig) {
- super(Port.class, NeutronPortChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Ports.class).child(Port.class),
+ Executors.newSingleThreadExecutor("NeutronPortChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
nvpnManager = neutronvpnManager;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Port> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
}
@Override
- protected NeutronPortChangeListener getDataTreeChangeListener() {
- return NeutronPortChangeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
-
@Override
- p
rotected void add(InstanceIdentifier<Port> identifier, Port input) {
+ p
ublic void add(InstanceIdentifier<Port> identifier, Port input) {
LOG.trace("Received port add event: port={}", input);
String portName = input.getUuid().getValue();
LOG.trace("Adding Port : key: {}, value={}", identifier, input);
}
@Override
- p
rotected void remove(InstanceIdentifier<Port> identifier, Port input) {
+ p
ublic void remove(InstanceIdentifier<Port> identifier, Port input) {
LOG.trace("Removing Port : key: {}, value={}", identifier, input);
Network network = neutronvpnUtils.getNeutronNetwork(input.getNetworkId());
// need to proceed with deletion in case network is null for a case where v2 sync happens and a read for
}
@Override
- p
rotected void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
+ p
ublic void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
LOG.trace("Received port update event: original={}, update={}", original, update);
// Switchdev ports need to be bounded to a host before creation
// in order to validate the supported vnic types from the hostconfig
// the MAC of the router's gw port is not available to be set when the
// router is written. We catch that here.
InstanceIdentifier<Routers> routersId = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
- Optional<Routers> optionalRouter = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routersId);
- if (!optionalRouter.isPresent()) {
- return;
- }
+ Optional<Routers> optionalRouter = null;
+ try {
+ optionalRouter = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routersId);
+ if (!optionalRouter.isPresent()) {
+ return;
+ }
+ Routers extRouters = optionalRouter.get();
+ if (extRouters.getExtGwMacAddress() != null) {
+ return;
+ }
- Routers extRouters = optionalRouter.get();
- if (extRouters.getExtGwMacAddress() != null) {
- return;
+ RoutersBuilder builder = new RoutersBuilder(extRouters);
+ builder.setExtGwMacAddress(routerGwPort.getMacAddress().getValue());
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routersId, builder.build());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("setExternalGwMac: failed to read EXT-Routers for router Id {} rout-Gw port {} due to exception",
+ routerId, routerGwPort, e);
}
- RoutersBuilder builder = new RoutersBuilder(extRouters);
- builder.setExtGwMacAddress(routerGwPort.getMacAddress().getValue());
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, routersId, builder.build());
}
@Nullable
LOG.error("failed to read host config from host {}", hostId, e);
return null;
}
- return hostConfig.orNull();
+ return hostConfig.orElse(null);
}
private boolean isPortBound(final Port port) {
} else {
LOG.warn("Interface {} is already present", infName);
}
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("failed to create interface {}", infName, e);
}
return infName;
} else {
LOG.warn("deleteOfPortInterface: Interface {} is not present", name);
}
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("deleteOfPortInterface: Failed to delete interface {}", name, e);
}
}
*/
package org.opendaylight.netvirt.neutronvpn;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronRouterChangeListener extends AsyncDataTreeChangeListenerBase<Router, NeutronRouterChangeListener> {
+public class NeutronRouterChangeListener extends AbstractAsyncDataTreeChangeListener<Router> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronRouterChangeListener.class);
private final DataBroker dataBroker;
private final NeutronvpnManager nvpnManager;
final NeutronSubnetGwMacResolver gwMacResolver,
final NeutronvpnUtils neutronvpnUtils,
final JobCoordinator jobCoordinator) {
- super(Router.class, NeutronRouterChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Routers.class).child(Router.class),
+ Executors.newSingleThreadExecutor("NeutronRouterChangeListener", LOG));
this.dataBroker = dataBroker;
nvpnManager = neutronvpnManager;
nvpnNatManager = neutronvpnNatManager;
this.jobCoordinator = jobCoordinator;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Router> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Routers.class).child(Router.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected NeutronRouterChangeListener getDataTreeChangeListener() {
- return NeutronRouterChangeListener.this;
- }
-
-
- @Override
- protected void add(InstanceIdentifier<Router> identifier, Router input) {
+ public void add(InstanceIdentifier<Router> identifier, Router input) {
LOG.trace("Adding Router : key: {}, value={}", identifier, input);
neutronvpnUtils.addToRouterCache(input);
// Create internal VPN
}
@Override
- protected void remove(InstanceIdentifier<Router> identifier, Router input) {
+ public void remove(InstanceIdentifier<Router> identifier, Router input) {
LOG.trace("Removing router : key: {}, value={}", identifier, input);
Uuid routerId = input.getUuid();
// Handle router deletion for the NAT service
}
@Override
- protected void update(InstanceIdentifier<Router> identifier, Router original, Router update) {
+ public void update(InstanceIdentifier<Router> identifier, Router original, Router update) {
LOG.trace("Updating Router : key: {}, original value={}, update value={}", identifier, original, update);
neutronvpnUtils.addToRouterCache(update);
Uuid routerId = update.getUuid();
*/
package org.opendaylight.netvirt.neutronvpn;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.ArrayList;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclBuilder;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronSecurityGroupListener
- extends AsyncDataTreeChangeListenerBase<SecurityGroup, NeutronSecurityGroupListener> {
+public class NeutronSecurityGroupListener extends AbstractAsyncDataTreeChangeListener<SecurityGroup> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityGroupListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
@Inject
public NeutronSecurityGroupListener(DataBroker dataBroker, JobCoordinator jobCoordinator,
final NeutronSecurityGroupUtils neutronSecurityGroupUtils) {
- super(SecurityGroup.class, NeutronSecurityGroupListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(SecurityGroups.class).child(SecurityGroup.class),
+ Executors.newSingleThreadExecutor("NeutronSecurityGroupListener", LOG));
this.dataBroker = dataBroker;
this.jobCoordinator = jobCoordinator;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.neutronSecurityGroupUtils = neutronSecurityGroupUtils;
+ init();
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
neutronSecurityGroupUtils.createAclIdPool();
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<SecurityGroup> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(SecurityGroups.class).child(SecurityGroup.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<SecurityGroup> key, SecurityGroup securityGroup) {
+ public void remove(InstanceIdentifier<SecurityGroup> key, SecurityGroup securityGroup) {
LOG.trace("Removing securityGroup: {}", securityGroup);
InstanceIdentifier<Acl> identifier = getAclInstanceIdentifier(securityGroup);
String securityGroupId = securityGroup.key().getUuid().getValue();
}
@Override
- protected void update(InstanceIdentifier<SecurityGroup> key, SecurityGroup dataObjectModificationBefore,
+ public void update(InstanceIdentifier<SecurityGroup> key, SecurityGroup dataObjectModificationBefore,
SecurityGroup dataObjectModificationAfter) {
LOG.debug("Do nothing");
}
@Override
- protected void add(InstanceIdentifier<SecurityGroup> instanceIdentifier, SecurityGroup securityGroup) {
+ public void add(InstanceIdentifier<SecurityGroup> instanceIdentifier, SecurityGroup securityGroup) {
LOG.trace("Adding securityGroup: {}", securityGroup);
String securityGroupId = securityGroup.key().getUuid().getValue();
InstanceIdentifier<Acl> identifier = getAclInstanceIdentifier(securityGroup);
});
}
- @Override
- protected NeutronSecurityGroupListener getDataTreeChangeListener() {
- return this;
- }
-
private InstanceIdentifier<Acl> getAclInstanceIdentifier(SecurityGroup securityGroup) {
return InstanceIdentifier
.builder(AccessLists.class).child(Acl.class,
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
}
public Acl getAcl(DataBroker broker, InstanceIdentifier<Acl> aclInstanceIdentifier) {
- return MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, aclInstanceIdentifier, broker).orNull();
+ return MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, aclInstanceIdentifier, broker).orElse(null);
}
}
*/
package org.opendaylight.netvirt.neutronvpn;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.ImmutableBiMap;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclKey;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronSecurityRuleListener
- extends AsyncDataTreeChangeListenerBase<SecurityRule, NeutronSecurityRuleListener> {
+public class NeutronSecurityRuleListener extends AbstractAsyncDataTreeChangeListener<SecurityRule> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityRuleListener.class);
private static final ImmutableBiMap<Class<? extends DirectionBase>,
Class<?extends org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.DirectionBase>>
@Inject
public NeutronSecurityRuleListener(final DataBroker dataBroker, JobCoordinator jobCoordinator) {
- super(SecurityRule.class, NeutronSecurityRuleListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(SecurityRules.class).child(SecurityRule.class),
+ Executors.newSingleThreadExecutor("NeutronSecurityRuleListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.jobCoordinator = jobCoordinator;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<SecurityRule> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(SecurityRules.class).child(SecurityRule.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule securityRule) {
+ public void add(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule securityRule) {
LOG.trace("added securityRule: {}", securityRule);
try {
Ace ace = toAceBuilder(securityRule, false).build();
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void remove(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule securityRule) {
+ public void remove(InstanceIdentifier<SecurityRule> instanceIdentifier, SecurityRule securityRule) {
LOG.trace("removed securityRule: {}", securityRule);
InstanceIdentifier<Ace> identifier = getAceInstanceIdentifier(securityRule);
try {
}
@Override
- protected void update(InstanceIdentifier<SecurityRule> instanceIdentifier,
+ public void update(InstanceIdentifier<SecurityRule> instanceIdentifier,
SecurityRule oldSecurityRule, SecurityRule updatedSecurityRule) {
// security rule updation is not supported from openstack, so no need to handle update.
LOG.trace("updates on security rules not supported.");
}
-
- @Override
- protected NeutronSecurityRuleListener getDataTreeChangeListener() {
- return this;
- }
}
*/
package org.opendaylight.netvirt.neutronvpn;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
-import javax.annotation.PostConstruct;
+import java.util.concurrent.ExecutionException;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.vpn.instance.vpntargets.VpnTarget;
import org.slf4j.LoggerFactory;
@Singleton
-public class NeutronSubnetChangeListener extends AsyncDataTreeChangeListenerBase<Subnet, NeutronSubnetChangeListener> {
+public class NeutronSubnetChangeListener extends AbstractAsyncDataTreeChangeListener<Subnet> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSubnetChangeListener.class);
private final DataBroker dataBroker;
private final NeutronvpnManager nvpnManager;
public NeutronSubnetChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
final NeutronExternalSubnetHandler externalSubnetHandler, final NeutronvpnUtils neutronvpnUtils,
final IVpnManager vpnManager) {
- super(Subnet.class, NeutronSubnetChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Subnets.class).child(Subnet.class),
+ Executors.newSingleThreadExecutor("NeutronSubnetChangeListener", LOG));
this.dataBroker = dataBroker;
this.nvpnManager = neutronvpnManager;
this.externalSubnetHandler = externalSubnetHandler;
this.vpnManager = vpnManager;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<Subnet> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Subnets.class).child(Subnet.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected NeutronSubnetChangeListener getDataTreeChangeListener() {
- return NeutronSubnetChangeListener.this;
- }
-
-
- @Override
- protected void add(InstanceIdentifier<Subnet> identifier, Subnet input) {
+ public void add(InstanceIdentifier<Subnet> identifier, Subnet input) {
LOG.trace("Adding Subnet : key: {}, value={}", identifier, input);
Uuid networkId = input.getNetworkId();
Uuid subnetId = input.getUuid();
}
@Override
- protected void remove(InstanceIdentifier<Subnet> identifier, Subnet input) {
+ public void remove(InstanceIdentifier<Subnet> identifier, Subnet input) {
LOG.trace("Removing subnet : key: {}, value={}", identifier, input);
Uuid networkId = input.getNetworkId();
Uuid subnetId = input.getUuid();
}
@Override
- protected void update(InstanceIdentifier<Subnet> identifier, Subnet original, Subnet update) {
+ public void update(InstanceIdentifier<Subnet> identifier, Subnet original, Subnet update) {
LOG.trace("Updating Subnet : key: {}, original value={}, update value={}", identifier, original, update);
neutronvpnUtils.addToSubnetCache(update);
}
.build());
LOG.debug("Created subnet-network mapping for subnet {} network {}", subnetId.getValue(),
networkId.getValue());
- } catch (ReadFailedException | RuntimeException e) {
+ } catch (RuntimeException | ExecutionException | InterruptedException e) {
LOG.error("Create subnet-network mapping failed for subnet {} network {}", subnetId.getValue(),
networkId.getValue());
}
} else {
LOG.error("network {} not present for subnet {} ", networkId, subnetId);
}
- } catch (ReadFailedException | RuntimeException e) {
+ } catch (RuntimeException | ExecutionException | InterruptedException e) {
LOG.error("Delete subnet-network mapping failed for subnet {} network {}", subnetId.getValue(),
networkId.getValue());
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
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.slf4j.LoggerFactory;
@Singleton
-public class NeutronTrunkChangeListener extends AsyncDataTreeChangeListenerBase<Trunk, NeutronTrunkChangeListener> {
+public class NeutronTrunkChangeListener extends AbstractAsyncDataTreeChangeListener<Trunk> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronTrunkChangeListener.class);
private final DataBroker dataBroker;
@Inject
public NeutronTrunkChangeListener(final DataBroker dataBroker, final IInterfaceManager ifMgr,
final JobCoordinator jobCoordinator) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Neutron.class).child(Trunks.class).child(Trunk.class),
+ Executors.newSingleThreadExecutor("NeutronTrunkChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.ifMgr = ifMgr;
this.jobCoordinator = jobCoordinator;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<Trunk> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Trunks.class).child(Trunk.class);
}
@Override
- protected NeutronTrunkChangeListener getDataTreeChangeListener() {
- return NeutronTrunkChangeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void add(InstanceIdentifier<Trunk> identifier, Trunk input) {
+ public void add(InstanceIdentifier<Trunk> identifier, Trunk input) {
Preconditions.checkNotNull(input.getPortId());
LOG.trace("Adding Trunk : key: {}, value={}", identifier, input);
List<SubPorts> subPorts = input.getSubPorts();
}
@Override
- protected void remove(InstanceIdentifier<Trunk> identifier, Trunk input) {
+ public void remove(InstanceIdentifier<Trunk> identifier, Trunk input) {
Preconditions.checkNotNull(input.getPortId());
LOG.trace("Removing Trunk : key: {}, value={}", identifier, input);
List<SubPorts> subPorts = input.getSubPorts();
}
@Override
- protected void update(InstanceIdentifier<Trunk> identifier, Trunk original, Trunk update) {
+ public void update(InstanceIdentifier<Trunk> identifier, Trunk original, Trunk update) {
List<SubPorts> updatedSubPorts = update.getSubPorts();
if (updatedSubPorts == null) {
updatedSubPorts = Collections.emptyList();
import static org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker.syncReadOptional;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.infrautils.utils.concurrent.NamedLocks;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.AcquireResult;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.alarm.NeutronvpnAlarms;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
} finally {
lock.unlock();
}
- } catch (TransactionCommitFailedException | ReadFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("createSubnetmapNode: Creating subnetmap node failed for subnet {}", subnetId.getValue());
}
// check if there are ports to update for already created Subnetmap node
LOG.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
return subnetmap;
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Subnet map update failed for node {}", subnetId.getValue(), e);
return null;
} finally {
LOG.debug("WithRouterFixedIP Creating/Updating subnetMap node for Router FixedIp: {} ",
subnetId.getValue());
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("updateSubnetNodeWithFixedIp: subnet map for Router FixedIp failed for node {}",
subnetId.getValue(), e);
} finally {
+ "cache ", subnetId.getValue(), portId.getValue());
unprocessedPortsMap.put(portId, subnetId);
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Updating port list of a given subnetMap failed for node: {}", subnetId.getValue(), e);
} finally {
lock.unlock();
} else {
LOG.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Removal from subnetmap failed for node: {}", subnetId.getValue());
} finally {
lock.unlock();
} else {
LOG.info("Trying to remove port from non-existing subnetmap node {}", subnetId.getValue());
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Removing a port from port list of a subnetmap failed for node: {}",
subnetId.getValue(), e);
} finally {
+ "Updating Config vpn-instance: {} with the list of RDs: {}", vpnInstanceId, rds);
SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier,
updateVpnInstanceBuilder.build());
- } catch (ReadFailedException | TransactionCommitFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.warn("updateVpnInstanceWithRDs: Error configuring vpn-instance: {} with "
+ "the list of RDs: {}", vpnInstanceId, rds, ex);
}
try {
optionalVpn = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnIdentifier);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Update VPN Instance node failed for node: {} {} {} {}", vpnName, rd, irt, ert);
return;
}
builder.build());
LOG.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue());
}
}
optionalVpnMap =
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnMapIdentifier);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Error reading the VPN map for {}", vpnMapIdentifier, e);
return;
}
optionalVpnInterface = SingleTransactionDataBroker
.syncReadOptional(dataBroker, LogicalDatastoreType
.CONFIGURATION, vpnIfIdentifier);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("withdrawPortIpFromVpnIface: Error reading the VPN interface for {}", vpnIfIdentifier, e);
return;
}
optionalVpnInterface =
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnIfIdentifier);
- } catch (ReadFailedException ex) {
+ } catch (ExecutionException | InterruptedException ex) {
LOG.error("Error during deletion of vpninterface {}", infName, ex);
return;
}
} else {
LOG.info("removeVpnFromVpnInterface: VPN Interface {} not found", infName);
}
- } catch (ReadFailedException ex) {
+ } catch (ExecutionException | InterruptedException ex) {
LOG.error("Update of vpninterface {} failed", infName, ex);
}
}
} else {
LOG.error("VPN Interface {} not found", infName);
}
- } catch (ReadFailedException ex) {
+ } catch (ExecutionException | InterruptedException ex) {
LOG.error("Updation of vpninterface {} failed", infName, ex);
}
}
opBuilder.setL3vpnInstances(l3vpnList);
result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
- } catch (ReadFailedException ex) {
+ } catch (ExecutionException | InterruptedException ex) {
result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION,
formatAndLog(LOG::error, "GetVPN failed due to {}", ex.getMessage())).build());
}
formatAndLog(LOG::warn, "VPN with vpnid: {} does not exist", vpn.getValue())));
warningcount++;
}
- } catch (ReadFailedException ex) {
+ } catch (ExecutionException | InterruptedException ex) {
errorList.add(RpcResultBuilder.newError(ErrorType.APPLICATION,
formatAndLog(LOG::error, "Deletion of L3VPN failed when deleting for uuid {}", vpn.getValue()),
ex.getMessage()));
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
routerInterfacesId, builder.setInterfaces(interfaces).build());
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Error reading router interfaces for {}", routerInterfacesId, e);
} finally {
lock.unlock();
}
}
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Error reading the router interfaces for {}", routerInterfacesId, e);
} finally {
lock.unlock();
} catch (TransactionCommitFailedException e) {
LOG.error("exception in adding extra route with destination: {}, next hop: {}",
destination, nextHop, e);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Exception on reading data-store ", e);
}
} else {
LOG.trace("extra route {} deleted successfully", route);
}
}
- } catch (TransactionCommitFailedException | ReadFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("exception in deleting extra route with destination {} for interface {}",
destination, infName, e);
}
}
passedNwList.add(nw);
}
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("associateNetworksToVpn: Failed to associate VPN {} with networks {}: ", vpnId.getValue(),
networkList, e);
failedNwList.add(String.format("Failed to associate VPN %s with networks %s: %s", vpnId.getValue(),
* Implementation of the "vpnservice:neutron-ports-show" Karaf CLI command.
*
* @return a List of String to be printed on screen
- * @throws ReadFailedException if there was a problem reading from the data store
+ * @throws ExecutionException or InterruptedException if there was a problem reading from the data store
*/
- public List<String> showNeutronPortsCLI() throws ReadFailedException {
+ public List<String> showNeutronPortsCLI() throws ExecutionException, InterruptedException {
List<String> result = new ArrayList<>();
result.add(String.format(" %-36s %-19s %-13s %-20s ", "Port ID", "Mac Address", "Prefix Length",
"IP Address"));
LOG.info("Updating vpn interface {} with new adjacencies", infName);
wrtConfigTxn.put(vpnIfIdentifier, vpnIfBuilder.build());
}
- } catch (IllegalStateException | ReadFailedException ex) {
+ } catch (IllegalStateException | ExecutionException | InterruptedException ex) {
// FIXME: why are we catching IllegalStateException here?
LOG.error("Update of vpninterface {} failed", infName, ex);
}
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, extNetIdentifier,
networks);
return true;
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("addExternalNetworkToVpn: Failed to set VPN Id {} to Provider Network {}: ", vpnId.getValue(),
extNetId.getValue(), ex);
}
extNetId.getValue());
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, extNetsId, networks);
return true;
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("removeExternalNetworkFromVpn: Failed to withdraw VPN Id from Provider Network node {}: ",
extNetId.getValue(), ex);
}
Optional<String> existingVpnName = Optional.of(primaryRd);
Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataOptional;
try {
- vpnInstanceOpDataOptional = SingleTransactionDataBroker
- .syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ vpnInstanceOpDataOptional = syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
neutronvpnUtils.getVpnOpDataIdentifier(primaryRd));
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("getExistingOperationalVpn: Exception while checking operational status of vpn with rd {}",
primaryRd, e);
/*Read failed. We don't know if a VPN exists or not.
if (vpnInstanceOpDataOptional.isPresent()) {
existingVpnName = Optional.of(vpnInstanceOpDataOptional.get().getVpnInstanceName());
} else {
- existingVpnName = Optional.absent();
+ existingVpnName = Optional.empty();
}
return existingVpnName;
}
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
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.yang.types.rev130715.Uuid;
}
@Override
- public List<String> showNeutronPortsCLI() throws ReadFailedException {
+ public List<String> showNeutronPortsCLI() throws ExecutionException, InterruptedException {
return nvManager.showNeutronPortsCLI();
}
*/
package org.opendaylight.netvirt.neutronvpn;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier,
networkss);
LOG.trace("Wrote externalnetwork successfully to CONFIG Datastore");
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Creation of External Network {} failed", extNetId.getValue(), ex);
}
}
SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
LOG.trace("Deleted External Network {} successfully from CONFIG Datastore", extNetId.getValue());
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Deletion of External Network {} failed", extNetId.getValue(), ex);
}
}
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier,
networkss);
LOG.trace("Updated externalnetworks successfully to CONFIG Datastore");
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Creation of externalnetworks failed for {}",
extNetId.getValue(), ex);
}
try {
optionalNets = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, netsIdentifier);
- } catch (ReadFailedException ex) {
+ } catch (ExecutionException | InterruptedException ex) {
LOG.error("removeExternalNetworkFromRouter: Failed to remove provider network {} from router {}",
origExtNetId.getValue(), routerId.getValue(), ex);
return;
builder.build());
LOG.trace("Wrote successfully Routers to CONFIG Datastore");
- } catch (ReadFailedException | TransactionCommitFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Creation of extrouters failed for router {} failed",
routerId.getValue(), ex);
}
routersIdentifier);
LOG.trace("Removed router {} from extrouters", routerId.getValue());
}
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Removing extrouter {} from extrouters failed", routerId.getValue(), ex);
}
}
SingleTransactionDataBroker.syncDelete(broker, LogicalDatastoreType.CONFIGURATION,
routerPortsIdentifierBuilder.build());
}
- } catch (ReadFailedException | TransactionCommitFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("Failed to read from FloatingIpInfo DS for routerid {}", routerId, e);
}
}
routerss);
LOG.trace("Added External Fixed IPs successfully for Routers to CONFIG Datastore");
}
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Updating extfixedips for {} in extrouters failed", routerId.getValue(), ex);
}
}
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
routersIdentifier, routerss);
LOG.trace("Updated successfully Routers to CONFIG Datastore");
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Updation of internal subnets for extrouters failed for router {}",
routerId.getValue(), ex);
}
routersIdentifier, routerss);
LOG.trace("Updated successfully Routers to CONFIG Datastore");
- } catch (TransactionCommitFailedException | ReadFailedException ex) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException ex) {
LOG.error("Updation of snat for extrouters failed for router {}", routerId.getValue(), ex);
}
}
}
}
}
- } catch (TransactionCommitFailedException | ReadFailedException e) {
+ } catch (TransactionCommitFailedException | ExecutionException | InterruptedException e) {
LOG.error("exception in removeAdjacencyAndLearnedEntriesforExternalSubnet for interface {}",
infName, e);
}
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.api.enums.IpVersionChoice;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
}
LOG.debug("getNeutronNetwork for {}", networkId.getValue());
InstanceIdentifier<Network> inst = NEUTRON_NETWORKS_IID.child(Network.class, new NetworkKey(networkId));
- return read(LogicalDatastoreType.CONFIGURATION, inst).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, inst).orElse(null);
}
protected @Nullable Port getNeutronPort(Uuid portId) {
}
LOG.debug("getNeutronPort for {}", portId.getValue());
InstanceIdentifier<Port> inst = NEUTRON_PORTS_IID.child(Port.class, new PortKey(portId));
- return read(LogicalDatastoreType.CONFIGURATION, inst).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, inst).orElse(null);
}
public PortIdToSubport getPortIdToSubport(Uuid portId) {
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
try {
return SingleTransactionDataBroker.syncReadOptional(dataBroker, datastoreType, path);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
throw new RuntimeException(e);
}
}
*/
public Optional<InterVpnLink> getInterVpnLinkByEndpointIp(String endpointIp) {
InstanceIdentifier<InterVpnLinks> interVpnLinksIid = InstanceIdentifier.builder(InterVpnLinks.class).build();
- Optional<InterVpnLinks> interVpnLinksOpData = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- interVpnLinksIid);
- if (interVpnLinksOpData.isPresent()) {
- for (InterVpnLink interVpnLink : interVpnLinksOpData.get().nonnullInterVpnLink()) {
- if (interVpnLink.getFirstEndpoint().getIpAddress().getValue().equals(endpointIp)
- || interVpnLink.getSecondEndpoint().getIpAddress().getValue().equals(endpointIp)) {
- return Optional.of(interVpnLink);
+ Optional<InterVpnLinks> interVpnLinksOpData = null;
+ try {
+ interVpnLinksOpData = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ interVpnLinksIid);
+ if (interVpnLinksOpData.isPresent()) {
+ for (InterVpnLink interVpnLink : interVpnLinksOpData.get().nonnullInterVpnLink()) {
+ if (interVpnLink.getFirstEndpoint().getIpAddress().getValue().equals(endpointIp)
+ || interVpnLink.getSecondEndpoint().getIpAddress().getValue().equals(endpointIp)) {
+ return Optional.of(interVpnLink);
+ }
}
}
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getInterVpnLinkByEndpointIp: Exception when reading intervpn Links for endpoint Ip {} ",
+ endpointIp, e);
}
- return Optional.absent();
+ return Optional.empty();
}
protected Integer releaseId(String poolName, String idKey) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
.instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVrfId).orElse(null);
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
.instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVpnId).orElse(null).toJava();
}
jobCoordinator.enqueueJob(jobKey, () -> {
SettableFuture<Optional<T>> settableFuture = SettableFuture.create();
List futures = Collections.singletonList(settableFuture);
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
Futures.addCallback(tx.read(datastoreType, iid),
new SettableFutureCallback<Optional<T>>(settableFuture) {
@Override
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.serviceutils.upgrade.rev180702.UpgradeConfig;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
@Inject
public UpgradeStateListener(final DataBroker dataBroker,
final NeutronSubnetGwMacResolver neutronSubnetGwMacResolver) {
- super(dataBroker, new DataTreeIdentifier<>(
- LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(UpgradeConfig.class)));
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(UpgradeConfig.class));
LOG.trace("UpgradeStateListener (neutronvpn) initialized");
this.neutronSubnetGwMacResolver = neutronSubnetGwMacResolver;
}
*/
package org.opendaylight.netvirt.neutronvpn.evpn.manager;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.NeutronvpnManager;
import org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
VpnMap vpnMap = optionalVpnMap.get();
evpn.setTenantId(vpnMap.getTenantId()).setName(vpnMap.getName());
}
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Error reading the VPN map for {}", vpnMapIdentifier, e);
result.set(RpcResultBuilder.<GetEVPNOutput>failed().withError(RpcError.ErrorType.APPLICATION,
"Error reading the VPN map for " + vpnMapIdentifier, e).build());
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.Collections;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.EvpnAugmentation;
this.jobCoordinator = jobCoordinator;
}
- public boolean isVpnAssociatedWithNetwork(VpnInstance vpnInstance) throws ReadFailedException {
+ public boolean isVpnAssociatedWithNetwork(VpnInstance vpnInstance)
+ throws InterruptedException, ExecutionException {
String rd = vpnManager.getPrimaryRdFromVpnInstance(vpnInstance);
InstanceIdentifier<EvpnRdToNetwork> id = InstanceIdentifier.builder(EvpnRdToNetworks.class)
.child(EvpnRdToNetwork.class, new EvpnRdToNetworkKey(rd)).build();
/**
* The Class AddL2GwDevicesToTransportZoneJob.
*/
-public class AddL2GwDevicesToTransportZoneJob implements Callable<List<ListenableFuture<Void>>> {
+public class AddL2GwDevicesToTransportZoneJob implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(AddL2GwDevicesToTransportZoneJob.class);
private final ItmRpcService itmRpcService;
package org.opendaylight.netvirt.neutronvpn.l2gw;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayCache;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
* The listener class for ITM transport zone updates.
*/
@Singleton
-public class L2GwTransportZoneListener
- extends AsyncDataTreeChangeListenerBase<TransportZone, L2GwTransportZoneListener> {
+public class L2GwTransportZoneListener extends AbstractAsyncDataTreeChangeListener<TransportZone> {
private static final Logger LOG = LoggerFactory.getLogger(L2GwTransportZoneListener.class);
private final DataBroker dataBroker;
private final ItmRpcService itmRpcService;
@Inject
public L2GwTransportZoneListener(final DataBroker dataBroker, final ItmRpcService itmRpcService,
final JobCoordinator jobCoordinator, final L2GatewayCache l2GatewayCache) {
- super(TransportZone.class, L2GwTransportZoneListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(TransportZones.class)
+ .child(TransportZone.class), Executors.newSingleThreadExecutor("L2GwTransportZoneListener", LOG));
this.dataBroker = dataBroker;
this.itmRpcService = itmRpcService;
this.jobCoordinator = jobCoordinator;
this.l2GatewayCache = l2GatewayCache;
}
- @Override
- @PostConstruct
public void init() {
LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.vpnservice.datastoreutils.
- * AsyncDataTreeChangeListenerBase#getWildCardPath()
- */
@Override
- protected InstanceIdentifier<TransportZone> getWildCardPath() {
- return InstanceIdentifier.create(TransportZones.class).child(TransportZone.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
/*
* org.opendaylight.yangtools.yang.binding.DataObject)
*/
@Override
- protected void remove(InstanceIdentifier<TransportZone> key, TransportZone dataObjectModification) {
+ public void remove(InstanceIdentifier<TransportZone> key, TransportZone dataObjectModification) {
// do nothing
}
* org.opendaylight.yangtools.yang.binding.DataObject)
*/
@Override
- protected void update(InstanceIdentifier<TransportZone> key, TransportZone dataObjectModificationBefore,
+ public void update(InstanceIdentifier<TransportZone> key, TransportZone dataObjectModificationBefore,
TransportZone dataObjectModificationAfter) {
// do nothing
}
* org.opendaylight.yangtools.yang.binding.DataObject)
*/
@Override
- protected void add(InstanceIdentifier<TransportZone> key, TransportZone tzNew) {
+ public void add(InstanceIdentifier<TransportZone> key, TransportZone tzNew) {
LOG.trace("Received Transport Zone Add Event: {}", tzNew);
if (TunnelTypeVxlan.class.equals(tzNew.getTunnelType())) {
AddL2GwDevicesToTransportZoneJob job =
}
}
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.vpnservice.datastoreutils.
- * AsyncDataTreeChangeListenerBase#getDataTreeChangeListener()
- */
- @Override
- protected L2GwTransportZoneListener getDataTreeChangeListener() {
- return this;
- }
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="iElanService"
interface="org.opendaylight.netvirt.elanmanager.api.IElanService" />
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.jobcoordinator.internal.JobCoordinatorImpl;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.metrics.testimpl.TestMetricProviderImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
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.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@RunWith(MockitoJUnitRunner.class)
@Mock
WriteTransaction mockWriteTx;
@Mock
- ReadOnlyTransaction mockReadTx;
+ ReadTransaction mockReadTx;
@Mock
Network mockNetwork;
@Mock
public void setUp() {
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
when(mockReadTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
- .thenReturn(Futures.immediateCheckedFuture(Optional.of(mockNetwork)));
+ .thenReturn(FluentFutures.immediateFluentFuture(Optional.of(mockNetwork)));
neutronPortChangeListener = new NeutronPortChangeListener(dataBroker, neutronvpnManager, neutronvpnNatManager,
gwMacResolver, elanService, jobCoordinator, new NeutronvpnUtils(dataBroker, idManager, jobCoordinator,
ipV6InternetDefRt),
package org.opendaylight.netvirt.neutronvpn.shell;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import java.util.Collections;
import java.util.List;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DhcpConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DhcpConfigBuilder;
package org.opendaylight.netvirt.neutronvpn.shell;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DhcpConfig;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.netvirt.neutronvpn.shell;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker.syncReadOptional;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.base.Optional;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
Optional<SubnetOpDataEntry> optionalSubnetOpDataEntries =
syncReadOptional(dataBroker, OPERATIONAL, subOpIdentifier);
if (optionalSubnetOpDataEntries.isPresent()) {
- optionalSubnetOpDataEntries.asSet().forEach(subnetOpDataEntry -> {
+ Collections.singleton(optionalSubnetOpDataEntries.get()).forEach(subnetOpDataEntry -> {
SubnetOpDataEntry data = subnetOpDataEntry;
System.out.println("Fetching subnetmapdataentry for given subnetId\n");
System.out.println("------------------------"
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private void getSubnet() throws ReadFailedException {
+ private void getSubnet() throws ExecutionException, InterruptedException {
List<SubnetOpDataEntry> subnetOpDataEntryList = new ArrayList<>();
InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
InstanceIdentifier<SubnetOpData> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class).build();
*/
package org.opendaylight.netvirt.neutronvpn.shell;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker.syncReadOptional;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortKey;
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private void getNeutronVpnPort() throws ReadFailedException {
+ private void getNeutronVpnPort() throws ExecutionException, InterruptedException {
InstanceIdentifier<NeutronVpnPortipPortData> neutronVpnPortipPortDataIdentifier = InstanceIdentifier
.builder(NeutronVpnPortipPortData.class).build();
Optional<NeutronVpnPortipPortData> optionalNeutronVpnPort = syncReadOptional(dataBroker, CONFIGURATION,
}
@SuppressWarnings("checkstyle:RegexpSinglelineJava")
- private void getLearntVpnVipPort() throws ReadFailedException {
+ private void getLearntVpnVipPort() throws ExecutionException, InterruptedException {
InstanceIdentifier<LearntVpnVipToPortData> learntVpnVipPortDataIdentifier = InstanceIdentifier
.builder(LearntVpnVipToPortData.class).build();
Optional<LearntVpnVipToPortData> optionalLearntVpnPort = syncReadOptional(dataBroker, OPERATIONAL,
availability="optional"/>
<reference id="rpcRegistryRef" interface="org.opendaylight.mdsal.binding.api.RpcConsumerRegistry"
availability="optional"/>
- <reference id="dataBrokerRef" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ <reference id="dataBrokerRef" interface="org.opendaylight.mdsal.binding.api.DataBroker"
availability="optional"/>
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
package org.opendaylight.netvirt.policyservice;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
}
}
- return Optional.absent();
+ return Optional.empty();
}
private Optional<PolicyAceFlowWrapper> getIngressInterfaceFlow(IngressInterface ingressInterface) {
String interfaceName = ingressInterface.getName();
if (interfaceName == null) {
LOG.error("Invalid ingress interface augmentation. missing interface name");
- return Optional.absent();
+ return Optional.empty();
}
String flowName = "INGRESS_INTERFACE_" + interfaceName;
Class<? extends ServiceTypeBase> serviceType = service.getServiceType();
if (serviceName == null || serviceType == null) {
LOG.error("Invalid policy service augmentation {}", service);
- return Optional.absent();
+ return Optional.empty();
}
if (serviceType.isAssignableFrom(L2vpnServiceType.class)) {
PolicyServiceConstants.POLICY_ACL_L3VPN_FLOW_PRIOPITY));
}
- return Optional.absent();
+ return Optional.empty();
}
}
package org.opendaylight.netvirt.policyservice;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.netvirt.policyservice.util.PolicyServiceFlowUtil;
import org.opendaylight.netvirt.policyservice.util.PolicyServiceUtil;
package org.opendaylight.netvirt.policyservice.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.netvirt.policyservice.PolicyAceFlowProgrammer;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
package org.opendaylight.netvirt.policyservice.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.netvirt.policyservice.PolicyAceFlowProgrammer;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.netvirt.elanmanager.api.IElanBridgeManager;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.netvirt.policyservice.PolicyAceFlowProgrammer;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
package org.opendaylight.netvirt.policyservice.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
SetPolicyClassifier setPolicyClassifier = actions.augmentation(SetPolicyClassifier.class);
if (setPolicyClassifier == null) {
LOG.warn("No valid policy action found for ACE rule {}", ace.getRuleName());
- return Optional.absent();
+ return Optional.empty();
}
Class<? extends DirectionBase> direction;
direction = setPolicyClassifier.getDirection();
} catch (IllegalArgumentException e) {
LOG.warn("Failed to parse policy classifier direction");
- return Optional.absent();
+ return Optional.empty();
}
if (direction == null || !direction.isAssignableFrom(DirectionEgress.class)) {
LOG.trace("Ignoring non egress policy ACE rule {}", ace.getRuleName());
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(setPolicyClassifier.getPolicyClassifier());
try {
return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
identifier);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get policy ACE rule {} for ACL {}", ruleName, aclName);
- return Optional.absent();
+ return Optional.empty();
}
}
Optional<PolicyProfiles> optProfiles = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, identifier);
return optProfiles.isPresent() ? optProfiles.get().getPolicyProfile() : Collections.emptyList();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get policy profiles");
return Collections.emptyList();
}
LogicalDatastoreType.CONFIGURATION, identifier);
return optProfile.isPresent() ? getUnderlayNetworksFromPolicyRoutes(optProfile.get().getPolicyRoute())
: Collections.emptyList();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get policy routes for classifier {}", policyClassifier);
return Collections.emptyList();
}
Optional<UnderlayNetwork> optUnderlayNet = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, identifier);
return optUnderlayNet.isPresent() ? optUnderlayNet.get().getPolicyProfile() : Collections.emptyList();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get policy classifiers for underlay network {}", underlayNetwork);
return Collections.emptyList();
}
Optional<PolicyProfile> optProfile = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, identifier);
return optProfile.isPresent() ? optProfile.get().getPolicyAclRule() : Collections.emptyList();
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get policy rules for policy classifier {}", policyClassifier);
return Collections.emptyList();
}
.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier)
.toJavaUtil().map(UnderlayNetwork::getDpnToInterface)
.orElse(Collections.emptyList());
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get DPNs for underlay network {}", underlayNetwork);
return Collections.emptyList();
}
Optional<DpnToInterface> dpnToInterfaceOpt = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, identifier);
return dpnToInterfaceOpt;
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get DPN {} for underlay network {}", dpId, underlayNetwork);
- return Optional.absent();
+ return Optional.empty();
}
}
Optional<String> logicalTunnelNameOpt = getLogicalTunnelName(srcDpId, dstDpId);
if (!logicalTunnelNameOpt.isPresent()) {
LOG.debug("Failed to get logical tunnel for source DPN {} dst DPN {}", srcDpId, dstDpId);
- return Optional.absent();
+ return Optional.empty();
}
String logicalTunnelName = logicalTunnelNameOpt.get();
InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(logicalTunnelName);
if (interfaceInfo == null) {
LOG.debug("Failed to get interface info for logical tunnel {}", logicalTunnelName);
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(interfaceInfo.getInterfaceTag());
LOG.error("Error in RPC call getTunnelInterfaceName for source DPN {} dst DPN {}", srcDpId, dstDpId, e);
}
- return Optional.absent();
+ return Optional.empty();
}
List<Interface> vlanMemberInterfaces = interfaceManager.getChildInterfaces(trunkInterface);
if (vlanMemberInterfaces == null || vlanMemberInterfaces.isEmpty()) {
LOG.debug("No child interfaces found for trunk {}", trunkInterface);
- return Optional.absent();
+ return Optional.empty();
}
return vlanMemberInterfaces.stream()
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="iMdsalApiManager"
interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
<reference id="iInterfaceManager"
package org.opendaylight.netvirt.qosservice;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.qosalert.config.rev170301.QosalertConfig;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
@Singleton
-public class QosAlertConfigListener extends
- AsyncClusteredDataTreeChangeListenerBase<QosalertConfig, QosAlertConfigListener> {
+public class QosAlertConfigListener extends AbstractClusteredAsyncDataTreeChangeListener<QosalertConfig> {
private static final Logger LOG = LoggerFactory.getLogger(QosAlertConfigListener.class);
private final DataBroker dataBroker;
@Inject
public QosAlertConfigListener(final DataBroker dataBroker, final QosAlertManager qosAlertManager) {
- super(QosalertConfig.class, QosAlertConfigListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(QosalertConfig.class),
+ Executors.newListeningSingleThreadExecutor("QosAlertConfigListener", LOG));
this.dataBroker = dataBroker;
this.qosAlertManager = qosAlertManager;
LOG.trace("{} created", getClass().getSimpleName());
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<QosalertConfig> getWildCardPath() {
- return InstanceIdentifier.create(QosalertConfig.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<QosalertConfig> identifier, QosalertConfig del) {
+ public void remove(InstanceIdentifier<QosalertConfig> identifier, QosalertConfig del) {
LOG.debug("QosalertConfig removed: {}", del);
qosAlertManager.restoreDefaultConfig();
}
@Override
- protected void update(InstanceIdentifier<QosalertConfig> identifier, QosalertConfig original,
+ public void update(InstanceIdentifier<QosalertConfig> identifier, QosalertConfig original,
QosalertConfig update) {
LOG.debug("QosalertConfig changed to {}", update);
qosAlertManager.setQosalertConfig(update);
}
@Override
- protected void add(InstanceIdentifier<QosalertConfig> identifier, QosalertConfig add) {
+ public void add(InstanceIdentifier<QosalertConfig> identifier, QosalertConfig add) {
LOG.debug("QosalertConfig added {}", add);
qosAlertManager.setQosalertConfig(add);
}
-
- @Override
- protected QosAlertConfigListener getDataTreeChangeListener() {
- return this;
- }
-
}
package org.opendaylight.netvirt.qosservice;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.List;
import java.util.Map.Entry;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.OpendaylightDirectStatisticsService;
package org.opendaylight.netvirt.qosservice;
-import com.google.common.base.Optional;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.netvirt.qosservice.recovery.QosServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.slf4j.LoggerFactory;
@Singleton
-public class QosInterfaceStateChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Interface,
- QosInterfaceStateChangeListener> implements RecoverableListener {
+public class QosInterfaceStateChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Interface>
+ implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(QosInterfaceStateChangeListener.class);
final ServiceRecoveryRegistry serviceRecoveryRegistry,
final QosServiceRecoveryHandler qosServiceRecoveryHandler,
final JobCoordinator jobCoordinator) {
- super(Interface.class, QosInterfaceStateChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("QosInterfaceStateChangeListener", LOG));
this.dataBroker = dataBroker;
this.uuidUtil = new UuidUtil();
this.qosAlertManager = qosAlertManager;
LOG.trace("{} created", getClass().getSimpleName());
}
- @PostConstruct
public void init() {
- registerListener();
LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
@Override
- public void registerListener() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
+ public void registerListener() {
+ super.register();
}
@Override
- protected QosInterfaceStateChangeListener getDataTreeChangeListener() {
- return QosInterfaceStateChangeListener.this;
+ public void deregisterListener() {
+ super.close();
}
+
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
if (L2vlan.class.equals(intrf.getType())) {
final String interfaceName = intrf.getName();
getNeutronPort(interfaceName).ifPresent(port -> {
private java.util.Optional<Port> getNeutronPort(String portName) {
return uuidUtil.newUuidIfValidPattern(portName)
- .toJavaUtil()
.map(qosNeutronUtils::getNeutronPort);
}
if (uuid.isPresent()) {
Port port = qosNeutronUtils.getNeutronPort(portName);
if (port != null) {
- return Optional.fromJavaUtil(uuid.toJavaUtil().map(qosNeutronUtils::getNeutronPort));
+ return Optional.ofNullable(uuid.map(qosNeutronUtils::getNeutronPort).orElse(null));
}
if (qosNeutronUtils.isBindServiceDone(uuid)) {
LOG.trace("Qos Service : interface {} clearing stale flow entries if any", portName);
});
}
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
- protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
if (L2vlan.class.equals(intrf.getType())) {
final String interfaceName = intrf.getName();
// Guava Optional asSet().forEach() emulates Java 8 Optional ifPresent()
- getNeutronPortForRemove(intrf).asSet().forEach(port -> {
+ getNeutronPortForRemove(intrf).stream().forEach(port -> {
LOG.trace("Qos Service : Received interface {} PORT DOWN event ", interfaceName);
String lowerLayerIf = intrf.getLowerLayerIf().get(0);
}
@Override
- protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
+ public void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
if (original.getType() == null && L2vlan.class.equals(update.getType())) {
// IfType was missing at creation, add it now
add(identifier, update);
package org.opendaylight.netvirt.qosservice;
import java.util.Objects;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.qosservice.recovery.QosServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.ext.rev160613.QosNetworkExtension;
import org.slf4j.LoggerFactory;
@Singleton
-public class QosNeutronNetworkChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Network,
- QosNeutronNetworkChangeListener> implements RecoverableListener {
+public class QosNeutronNetworkChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Network>
+ implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(QosNeutronNetworkChangeListener.class);
private final DataBroker dataBroker;
private final QosNeutronUtils qosNeutronUtils;
final QosNeutronUtils qosNeutronUtils,
final ServiceRecoveryRegistry serviceRecoveryRegistry,
final QosServiceRecoveryHandler qosServiceRecoveryHandler) {
- super(Network.class, QosNeutronNetworkChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Networks.class).child(Network.class),
+ Executors.newListeningSingleThreadExecutor("QosNeutronNetworkChangeListener", LOG));
this.dataBroker = dataBroker;
this.qosNeutronUtils = qosNeutronUtils;
serviceRecoveryRegistry.addRecoverableListener(qosServiceRecoveryHandler.buildServiceRegistryKey(),
LOG.trace("{} created", getClass().getSimpleName());
}
- @PostConstruct
public void init() {
- registerListener();
LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
@Override
- public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InstanceIdentifier<Network> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class);
+ public void registerListener() {
+ super.register();
}
@Override
- protected QosNeutronNetworkChangeListener getDataTreeChangeListener() {
- return QosNeutronNetworkChangeListener.this;
+ public void deregisterListener() {
+ super.close();
}
@Override
- protected void remove(InstanceIdentifier<Network> instanceIdentifier, Network network) {
+ public void remove(InstanceIdentifier<Network> instanceIdentifier, Network network) {
qosNeutronUtils.removeFromNetworkCache(network);
}
@Override
- protected void update(InstanceIdentifier<Network> instanceIdentifier, Network original, Network update) {
+ public void update(InstanceIdentifier<Network> instanceIdentifier, Network original, Network update) {
qosNeutronUtils.addToNetworkCache(update);
QosNetworkExtension updateQos = update.augmentation(QosNetworkExtension.class);
}
@Override
- protected void add(InstanceIdentifier<Network> instanceIdentifier, Network network) {
+ public void add(InstanceIdentifier<Network> instanceIdentifier, Network network) {
qosNeutronUtils.addToNetworkCache(network);
QosNetworkExtension networkQos = network.augmentation(QosNetworkExtension.class);
import java.util.Collections;
import java.util.Objects;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.qosservice.recovery.QosServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.slf4j.LoggerFactory;
@Singleton
-public class QosNeutronPortChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Port,
- QosNeutronPortChangeListener> implements RecoverableListener {
+public class QosNeutronPortChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Port>
+ implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(QosNeutronPortChangeListener.class);
private final DataBroker dataBroker;
private final QosNeutronUtils qosNeutronUtils;
final ServiceRecoveryRegistry serviceRecoveryRegistry,
final QosEosHandler qosEosHandler,
final JobCoordinator jobCoordinator) {
- super(Port.class, QosNeutronPortChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(Ports.class).child(Port.class),
+ Executors.newListeningSingleThreadExecutor("QosNeutronPortChangeListener", LOG));
this.dataBroker = dataBroker;
this.qosNeutronUtils = qosNeutronUtils;
this.qosEosHandler = qosEosHandler;
LOG.trace("{} created", getClass().getSimpleName());
}
- @PostConstruct
public void init() {
- registerListener();
LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<Port> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ super.register();
}
@Override
- protected QosNeutronPortChangeListener getDataTreeChangeListener() {
- return QosNeutronPortChangeListener.this;
+ public void deregisterListener() {
+ super.close();
}
@Override
- p
rotected void add(InstanceIdentifier<Port> instanceIdentifier, Port port) {
+ p
ublic void add(InstanceIdentifier<Port> instanceIdentifier, Port port) {
qosNeutronUtils.addToPortCache(port);
}
@Override
- p
rotected void remove(InstanceIdentifier<Port> instanceIdentifier, Port port) {
+ p
ublic void remove(InstanceIdentifier<Port> instanceIdentifier, Port port) {
qosNeutronUtils.removeFromPortCache(port);
}
@Override
- p
rotected void update(InstanceIdentifier<Port> instanceIdentifier, Port original, Port update) {
+ p
ublic void update(InstanceIdentifier<Port> instanceIdentifier, Port original, Port update) {
qosNeutronUtils.addToPortCache(update);
// check for QoS updates
QosPortExtension updateQos = update.augmentation(QosPortExtension.class);
import static java.util.Collections.emptyList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
@Nullable
private BridgeEntry getBridgeEntryFromConfigDS(InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier) {
- return MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker).orNull();
+ return MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker)
+ .orElse(null);
}
@Nullable
private BridgeRefEntry getBridgeRefEntryFromOperDS(InstanceIdentifier<BridgeRefEntry> dpnBridgeEntryIid) {
- return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, dpnBridgeEntryIid, dataBroker).orNull();
+ return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, dpnBridgeEntryIid, dataBroker).orElse(null);
}
@Nullable
public org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
.@Nullable Interface getInterfaceStateFromOperDS(String interfaceName) {
- return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- createInterfaceStateInstanceIdentifier(interfaceName)).orNull();
+ try {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ createInterfaceStateInstanceIdentifier(interfaceName)).orElse(null);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getInterfaceStateFromOperDS: Exception while reading interface DS for the interface {}",
+ interfaceName, e);
+ }
+ return null;
}
@NonNull
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.actions.ActionNxResubmit;
import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.qosservice.recovery.QosServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.slf4j.LoggerFactory;
@Singleton
-public class QosNodeListener extends AsyncDataTreeChangeListenerBase<FlowCapableNode, QosNodeListener>
+public class QosNodeListener extends AbstractAsyncDataTreeChangeListener<FlowCapableNode>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(QosNodeListener.class);
public QosNodeListener(final DataBroker dataBroker, final IMdsalApiManager mdsalUtils,
final ServiceRecoveryRegistry serviceRecoveryRegistry,
final QosServiceRecoveryHandler qosServiceRecoveryHandler) {
- super(FlowCapableNode.class, QosNodeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class),
+ Executors.newListeningSingleThreadExecutor("QosNodeListener", LOG));
this.dataBroker = dataBroker;
this.mdsalUtils = mdsalUtils;
serviceRecoveryRegistry.addRecoverableListener(qosServiceRecoveryHandler.buildServiceRegistryKey(),
LOG.trace("{} created", getClass().getSimpleName());
}
- @Override
- @PostConstruct
public void init() {
- registerListener();
LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
+ @Override
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
+
@Override
public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<FlowCapableNode> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class);
+ public void deregisterListener() {
+ super.close();
}
@Override
- protected void remove(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
+ public void remove(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
//do nothing
}
@Override
- protected void update(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModificationBefore,
+ public void update(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModificationBefore,
FlowCapableNode dataObjectModificationAfter) {
//do nothing
}
@Override
- protected void add(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
+ public void add(InstanceIdentifier<FlowCapableNode> key, FlowCapableNode dataObjectModification) {
NodeKey nodeKey = key.firstKeyOf(Node.class);
Uint64 dpId = MDSALUtil.getDpnIdFromNodeName(nodeKey.getId());
createTableMissEntry(dpId);
}
- @Override
- protected QosNodeListener getDataTreeChangeListener() {
- return QosNodeListener.this;
- }
-
public void createTableMissEntry(Uint64 dpnId) {
List<MatchInfo> matches = new ArrayList<>();
List<InstructionInfo> instructions = new ArrayList<>();
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
-import org.opendaylight.netvirt.neutronvpn.api.utils.ChangeUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.qosservice.recovery.QosServiceRecoveryHandler;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.QosRuleTypesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.policies.QosPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.policies.qos.policy.BandwidthLimitRules;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.policies.qos.policy.BandwidthLimitRulesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.policies.qos.policy.DscpmarkingRules;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.rule.types.RuleTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.rule.types.RuleTypesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-public class QosPolicyChangeListener extends AsyncClusteredDataTreeChangeListenerBase<QosPolicy,
- QosPolicyChangeListener> implements RecoverableListener {
+public class QosPolicyChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<QosPolicy>
+ implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(QosPolicyChangeListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
final QosNeutronUtils qosNeutronUtils, final JobCoordinator jobCoordinator,
final ServiceRecoveryRegistry serviceRecoveryRegistry,
final QosServiceRecoveryHandler qosServiceRecoveryHandler) {
- super(QosPolicy.class, QosPolicyChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ .child(QosPolicies.class).child(QosPolicy.class),
+ Executors.newListeningSingleThreadExecutor("QosPolicyChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.qosNeutronUtils = qosNeutronUtils;
serviceRecoveryRegistry.addRecoverableListener(qosServiceRecoveryHandler.buildServiceRegistryKey(),
this);
LOG.trace("{} created", getClass().getSimpleName());
+ init();
}
- @PostConstruct
public void init() {
- registerListener();
supportedQoSRuleTypes();
LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
@Override
- public void registerListener() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InstanceIdentifier<QosPolicy> getWildCardPath() {
- return InstanceIdentifier.create(Neutron.class).child(QosPolicies.class).child(QosPolicy.class);
+ public void registerListener() {
+ super.register();
}
+ @Override
+ public void deregisterListener() {
+ super.close();
+ }
+/*
@Override
public void onDataTreeChanged(Collection<DataTreeModification<QosPolicy>> changes) {
handleQosPolicyChanges(changes);
handleDscpMarkingRulesChanges(changes);
}
- @Override
- protected QosPolicyChangeListener getDataTreeChangeListener() {
- return QosPolicyChangeListener.this;
- }
-
private void handleQosPolicyChanges(Collection<DataTreeModification<QosPolicy>> changes) {
Map<InstanceIdentifier<QosPolicy>, QosPolicy> qosPolicyOriginalMap =
ChangeUtils.extractOriginal(changes, QosPolicy.class);
ChangeUtils.extractRemoved(changes, DscpmarkingRules.class)) {
remove(dscpMarkIid, dscpMarkOriginalMap.get(dscpMarkIid));
}
- }
+ }*/
@Override
- protected void add(InstanceIdentifier<QosPolicy> identifier, QosPolicy input) {
+ public void add(InstanceIdentifier<QosPolicy> identifier, QosPolicy input) {
LOG.debug("Adding QosPolicy : key: {}, value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(),input);
qosNeutronUtils.addToQosPolicyCache(input);
}
}
- private void add(InstanceIdentifier<DscpmarkingRules> identifier, DscpmarkingRules input) {
+/* private void add(InstanceIdentifier<DscpmarkingRules> identifier, DscpmarkingRules input) {
LOG.debug("Adding DscpMarkingRules : key: {}, value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), input);
return Collections.emptyList();
});
}
- }
+ }*/
@Override
- protected void remove(InstanceIdentifier<QosPolicy> identifier, QosPolicy input) {
+ public void remove(InstanceIdentifier<QosPolicy> identifier, QosPolicy input) {
LOG.debug("Removing QosPolicy : key: {}, value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), input);
qosNeutronUtils.removeFromQosPolicyCache(input);
}
- private void remove(InstanceIdentifier<BandwidthLimitRules> identifier, BandwidthLimitRules input) {
+/* private void remove(InstanceIdentifier<BandwidthLimitRules> identifier, BandwidthLimitRules input) {
LOG.debug("Removing BandwidthLimitRules : key: {}, value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), input);
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> qosNeutronUtils.setPortBandwidthLimits(port, zeroBwLimitRule, tx))));
}
- }
+ }*/
- private void remove(InstanceIdentifier<DscpmarkingRules> identifier,DscpmarkingRules input) {
+/* private void remove(InstanceIdentifier<DscpmarkingRules> identifier,DscpmarkingRules input) {
LOG.debug("Removing DscpMarkingRules : key: {}, value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), input);
return Collections.emptyList();
});
}
- }
+ }*/
public void reapplyPolicy(String entityid) {
Uuid policyUuid = Uuid.getDefaultInstance(entityid);
}
@Override
- protected void update(InstanceIdentifier<QosPolicy> identifier, QosPolicy original, QosPolicy update) {
+ public void update(InstanceIdentifier<QosPolicy> identifier, QosPolicy original, QosPolicy update) {
LOG.debug("Updating QosPolicy : key: {}, original value={}, update value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), original, update);
qosNeutronUtils.addToQosPolicyCache(update);
}
- private void update(InstanceIdentifier<BandwidthLimitRules> identifier, BandwidthLimitRules original,
+/* private void update(InstanceIdentifier<BandwidthLimitRules> identifier, BandwidthLimitRules original,
BandwidthLimitRules update) {
LOG.debug("Updating BandwidthLimitRules : key: {}, original value={}, update value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), original,
update);
Uuid qosUuid = identifier.firstKeyOf(QosPolicy.class).getUuid();
update(qosUuid, update);
- }
+ }*/
private void update(Uuid qosUuid, BandwidthLimitRules update) {
for (Network network : qosNeutronUtils.getQosNetworks(qosUuid)) {
}
}
- private void update(InstanceIdentifier<DscpmarkingRules> identifier, DscpmarkingRules original,
+/* private void update(InstanceIdentifier<DscpmarkingRules> identifier, DscpmarkingRules original,
DscpmarkingRules update) {
LOG.debug("Updating DscpMarkingRules : key: {}, original value={}, update value={}",
identifier.firstKeyOf(QosPolicy.class).getUuid().getValue(), original, update);
Uuid qosUuid = identifier.firstKeyOf(QosPolicy.class).getUuid();
update(qosUuid, update);
- }
+ }*/
private void update(Uuid qosUuid, DscpmarkingRules update) {
for (Network network : qosNeutronUtils.getQosNetworks(qosUuid)) {
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import java.util.Collections;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.policies.QosPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.rev160613.qos.attributes.qos.policies.qos.policy.BandwidthLimitRules;
@Singleton
public class QosTerminationPointListener extends
- AsyncClusteredDataTreeChangeListenerBase<OvsdbTerminationPointAugmentation, QosTerminationPointListener> {
+ AbstractClusteredAsyncDataTreeChangeListener<OvsdbTerminationPointAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(QosTerminationPointListener.class);
private static final String EXTERNAL_ID_INTERFACE_ID = "iface-id";
private final DataBroker dataBroker;
final QosEosHandler qosEosHandler,
final QosAlertManager qosAlertManager,
final JobCoordinator jobCoordinator) {
- super(OvsdbTerminationPointAugmentation.class, QosTerminationPointListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
+ .child(Node.class).child(TerminationPoint.class)
+ .augmentation(OvsdbTerminationPointAugmentation.class),
+ Executors.newListeningSingleThreadExecutor("QosTerminationPointListener", LOG));
this.dataBroker = dataBroker;
this.qosNeutronUtils = qosNeutronUtils;
this.qosEosHandler = qosEosHandler;
this.jobCoordinator = jobCoordinator;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ LOG.trace("{} init and registerListener done", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<OvsdbTerminationPointAugmentation> getWildCardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
- .child(Node.class).child(TerminationPoint.class)
- .augmentation(OvsdbTerminationPointAugmentation.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<OvsdbTerminationPointAugmentation> instanceIdentifier,
+ public void remove(InstanceIdentifier<OvsdbTerminationPointAugmentation> instanceIdentifier,
OvsdbTerminationPointAugmentation tp) {
if (isBandwidthRuleApplied(tp)) {
String ifaceId = getIfaceId(tp);
}
@Override
- protected void update(InstanceIdentifier<OvsdbTerminationPointAugmentation> instanceIdentifier,
+ public void update(InstanceIdentifier<OvsdbTerminationPointAugmentation> instanceIdentifier,
OvsdbTerminationPointAugmentation original,
OvsdbTerminationPointAugmentation update) {
String ifaceId = getIfaceId(update);
}
@Override
- protected void add(InstanceIdentifier<OvsdbTerminationPointAugmentation> instanceIdentifier,
+ public void add(InstanceIdentifier<OvsdbTerminationPointAugmentation> instanceIdentifier,
OvsdbTerminationPointAugmentation tpAugment) {
String ifaceId = getIfaceId(tpAugment);
if ((ifaceId != null) && isBandwidthRuleApplied(tpAugment)) {
}
}
- @Override
- protected QosTerminationPointListener getDataTreeChangeListener() {
- return QosTerminationPointListener.this;
- }
-
private void setPortBandwidthRule(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
OvsdbTerminationPointAugmentation update, Port port) {
QosPolicy qosPolicy = qosNeutronUtils.getQosPolicy(port);
*/
package org.opendaylight.netvirt.qosservice;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import java.util.regex.Pattern;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
if (uuidPattern.matcher(possibleUuid).matches()) {
return Optional.of(new Uuid(possibleUuid));
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="iMdsalApiManager"
interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
@Test
public void valid() {
- assertThat(uuidUtil.newUuidIfValidPattern("f81d4fae-7dec-11d0-a765-00a0c91e6bf6"))
- .hasValue(new Uuid("f81d4fae-7dec-11d0-a765-00a0c91e6bf6"));
+ assertThat(uuidUtil.newUuidIfValidPattern("f81d4fae-7dec-11d0-a765-00a0c91e6bf6").get())
+ .isEqualTo(new Uuid("f81d4fae-7dec-11d0-a765-00a0c91e6bf6"));
}
@Test
public void invalid() {
- assertThat(uuidUtil.newUuidIfValidPattern("tap61d7aec1-2c")).isAbsent();
+ assertThat(uuidUtil.newUuidIfValidPattern("tap61d7aec1-2c"))
+ .isNotEqualTo("tap61d7aec1-11");
}
@Test
public void empty() {
- assertThat(uuidUtil.newUuidIfValidPattern("")).isAbsent();
+ assertThat(uuidUtil.newUuidIfValidPattern("")).isNotNull();
}
@Test(expected = NullPointerException.class)
<artifactId>javax.inject</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
+ <!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency>-->
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgpmanager-api</artifactId>
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="iBgpManager"
interface="org.opendaylight.netvirt.bgpmanager.api.IBgpManager" />
import java.math.BigInteger;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
*/
package org.opendaylight.netvirt.statistics;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.netvirt.statistics.api.ICountersInterfaceChangeHandler;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
*/
package org.opendaylight.netvirt.statistics;
-import com.google.common.base.Optional;
+import java.util.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.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.ReadWriteTransaction;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
if (input.getIncomingTraffic() != null) {
Optional<EgressElementCountersRequestConfig> eecrcOpt =
transaction.read(LogicalDatastoreType.CONFIGURATION,
- CountersServiceUtils.EECRC_IDENTIFIER).checkedGet();
+ CountersServiceUtils.EECRC_IDENTIFIER).get();
if (!eecrcOpt.isPresent()) {
LOG.warn("failed creating incoming traffic counter request data container in DB");
statisticsCounters.failedCreatingEgressCounterDataConfig();
if (input.getOutgoingTraffic() != null) {
Optional<IngressElementCountersRequestConfig> iecrcOpt =
transaction.read(LogicalDatastoreType.CONFIGURATION,
- CountersServiceUtils.IECRC_IDENTIFIER).checkedGet();
+ CountersServiceUtils.IECRC_IDENTIFIER).get();
if (!iecrcOpt.isPresent()) {
LOG.warn("failed creating outgoing traffc counter request data container in DB");
statisticsCounters.failedCreatingIngressCounterDataConfig();
SettableFuture<RpcResult<ReleaseElementCountersRequestHandlerOutput>> result = SettableFuture.create();
ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
Optional<IngressElementCountersRequestConfig> iecrcOpt =
- tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.IECRC_IDENTIFIER).checkedGet();
+ tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.IECRC_IDENTIFIER).get();
Optional<EgressElementCountersRequestConfig> eecrcOpt =
- tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.EECRC_IDENTIFIER).checkedGet();
+ tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.EECRC_IDENTIFIER).get();
if (!iecrcOpt.isPresent() || !eecrcOpt.isPresent()) {
LOG.warn("Couldn't read element counters config data from DB");
statisticsCounters.failedReadingCounterDataFromConfig();
return;
}
Optional<CounterRequests> ingressRequestOpt =
- tx.read(LogicalDatastoreType.CONFIGURATION, ingressPath).checkedGet();
+ tx.read(LogicalDatastoreType.CONFIGURATION, ingressPath).get();
Optional<CounterRequests> egressRequestOpt =
- tx.read(LogicalDatastoreType.CONFIGURATION, egressPath).checkedGet();
+ tx.read(LogicalDatastoreType.CONFIGURATION, egressPath).get();
if (!ingressRequestOpt.isPresent() && !egressRequestOpt.isPresent()) {
LOG.warn("Handler does not exists");
statisticsCounters.unknownRequestHandler();
InstanceIdentifier.builder(EgressElementCountersRequestConfig.class)
.child(CounterRequests.class, new CounterRequestsKey(input.getHandler())).build();
- ReadOnlyTransaction tx = db.newReadOnlyTransaction();
+ ReadTransaction tx = db.newReadOnlyTransaction();
CheckedFuture<Optional<CounterRequests>, ReadFailedException> ingressRequestData =
tx.read(LogicalDatastoreType.CONFIGURATION, ingressPath);
CheckedFuture<Optional<CounterRequests>, ReadFailedException> egressRequestData =
public void handleInterfaceRemoval(String interfaceId) {
CheckedFuture<Optional<IngressElementCountersRequestConfig>, ReadFailedException> iecrc;
CheckedFuture<Optional<EgressElementCountersRequestConfig>, ReadFailedException> eecrc;
- try (ReadOnlyTransaction tx = db.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = db.newReadOnlyTransaction()) {
iecrc = tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.IECRC_IDENTIFIER);
eecrc = tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.EECRC_IDENTIFIER);
}
@Override
public ListenableFuture<RpcResult<CleanAllElementCounterRequestsOutput>> cleanAllElementCounterRequests(
CleanAllElementCounterRequestsInput input) {
- ReadOnlyTransaction tx = db.newReadOnlyTransaction();
+ ReadTransaction tx = db.newReadOnlyTransaction();
CheckedFuture<Optional<IngressElementCountersRequestConfig>, ReadFailedException> iecrc =
tx.read(LogicalDatastoreType.CONFIGURATION, CountersServiceUtils.IECRC_IDENTIFIER);
CheckedFuture<Optional<EgressElementCountersRequestConfig>, ReadFailedException> eecrc =
txRunner.callWithNewReadWriteTransactionAndSubmit(transaction -> {
Optional<IngressElementCountersRequestConfig> iecrcOpt =
transaction.read(LogicalDatastoreType.CONFIGURATION,
- CountersServiceUtils.IECRC_IDENTIFIER).checkedGet();
+ CountersServiceUtils.IECRC_IDENTIFIER).get();
Optional<EgressElementCountersRequestConfig> eecrcOpt =
transaction.read(LogicalDatastoreType.CONFIGURATION,
- CountersServiceUtils.EECRC_IDENTIFIER).checkedGet();
+ CountersServiceUtils.EECRC_IDENTIFIER).get();
if (!iecrcOpt.isPresent()) {
creatIngressEelementCountersContainerInConfig(transaction,
CountersServiceUtils.IECRC_IDENTIFIER);
}
private boolean checkPoolExists() {
- ReadOnlyTransaction roTransaction = db.newReadOnlyTransaction();
+ ReadTransaction roTransaction = db.newReadOnlyTransaction();
InstanceIdentifier<IdPool> path = InstanceIdentifier.create(IdPools.class).child(IdPool.class,
new IdPoolKey(CountersServiceUtils.COUNTERS_PULL_NAME));
CheckedFuture<Optional<IdPool>, ReadFailedException> pool =
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderService;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="rpcProviderRegistry"
- interface="org.opendaylight.controller.sal.binding.api.RpcProviderService" />
+ interface="org.opendaylight.mdsal.binding.api.RpcProviderService" />
<reference id="notificationService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationService" />
+ interface="org.opendaylight.mdsal.binding.api.NotificationService" />
<reference id="iInterfaceManager"
interface="org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager" />
<reference id="iMdsalApiManager"
import java.util.Collection;
import java.util.List;
import java.util.Set;
-
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadTransaction;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
*/
package org.opendaylight.netvirt.vpnmanager.api;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
}
public static Optional<String> getMacAddressForInterface(DataBroker dataBroker, String interfaceName) {
- Optional<String> macAddressOptional = Optional.absent();
+ Optional<String> macAddressOptional = Optional.empty();
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces
.rev140508.interfaces.state.Interface>
ifStateId =
}
public static Optional<String> getMacAddressFromInterfaceState(Interface ifState) {
- Optional<String> macAddressOptional = Optional.absent();
+ Optional<String> macAddressOptional = Optional.empty();
PhysAddress macAddress = ifState.getPhysAddress();
if (macAddress != null) {
macAddressOptional = Optional.of(macAddress.getValue());
InstanceIdentifier<T> path) {
try {
return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, path);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
throw new RuntimeException(e);
}
}
import static java.util.stream.Collectors.toList;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadTransaction;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeOutput;
public static Optional<Routes> getVpnExtraroutes(DataBroker broker, String vpnName,
String vpnRd, String destPrefix) {
InstanceIdentifier<Routes> vpnExtraRoutesId = getVpnToExtrarouteVrfIdIdentifier(vpnName, vpnRd, destPrefix);
- return MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, vpnExtraRoutesId);
+ Optional<Routes> extraRouteOptional = Optional.empty();
+ try {
+ extraRouteOptional = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
+ vpnExtraRoutesId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getVpnExtraroutes: failed to read VpnToExtraRoutes for vpn {} rd {} destprefix {} due "
+ + "to exception", vpnName, vpnRd, destPrefix, e);
+ }
+ return extraRouteOptional;
}
public static Optional<Routes> getVpnExtraroutes(TypedReadTransaction<Operational> operTx, String vpnName,
List<String> usedRds, String destPrefix) {
List<Routes> routes = new ArrayList<>();
for (String rd : usedRds) {
- Optional<Routes> extraRouteInfo =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- getVpnToExtrarouteVrfIdIdentifier(vpnName, rd, destPrefix));
- if (extraRouteInfo.isPresent()) {
- routes.add(extraRouteInfo.get());
+ try {
+ Optional<Routes> extraRouteInfo = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ getVpnToExtrarouteVrfIdIdentifier(vpnName, rd, destPrefix));
+ extraRouteInfo.ifPresent(routes::add);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getAllVpnExtraRoutes: failed to read VpnToExtraRouteVrf for vpn {} rd {} destprefix {} due "
+ + "to exception", vpnName, rd, destPrefix, e);
}
}
return routes;
public static List<String> getUsedRds(DataBroker broker, Uint32 vpnId, String destPrefix) {
InstanceIdentifier<DestPrefixes> usedRdsId = getUsedRdsIdentifier(vpnId, destPrefix);
- Optional<DestPrefixes> usedRds = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId);
+ Optional<DestPrefixes> usedRds = Optional.empty();
+ try {
+ usedRds = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getUsedRds: failed to read Used Rds for vpn {} destprefix {} due to exception", vpnId,
+ destPrefix, e);
+ }
return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null ? usedRds.get().getAllocatedRds().stream()
.map(AllocatedRds::getRd).distinct().collect(toList()) : new ArrayList<>();
}
public static java.util.Optional<String> getRdAllocatedForExtraRoute(DataBroker broker,
Uint32 vpnId, String destPrefix, String nextHop) {
InstanceIdentifier<AllocatedRds> usedRdsId = getUsedRdsIdentifier(vpnId, destPrefix, nextHop);
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId)
- .toJavaUtil().map(AllocatedRds::getRd);
+ try {
+ return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId)
+ .map(AllocatedRds::getRd);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getRdAllocatedForExtraRoute: failed to read Used Rds for vpn {} destprefix {} nexthop {} due "
+ + "to exception", vpnId, destPrefix, nextHop, e);
+ }
+ return Optional.empty();
}
public static List<DestPrefixes> getExtraRouteDestPrefixes(DataBroker broker, Uint32 vpnId) {
- Optional<ExtrarouteRds> optionalExtraRoutes = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
- getUsedRdsIdentifier(vpnId));
- List<DestPrefixes> prefixes =
- optionalExtraRoutes.isPresent() ? optionalExtraRoutes.get().getDestPrefixes() : null;
- return prefixes == null ? Collections.emptyList() : prefixes;
+ try {
+ Optional<ExtrarouteRds> optionalExtraRoutes = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
+ getUsedRdsIdentifier(vpnId));
+ List<DestPrefixes> prefixes = optionalExtraRoutes.map(ExtrarouteRds::getDestPrefixes).orElse(null);
+ return prefixes == null ? Collections.emptyList() : prefixes;
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getExtraRouteDestPrefixes: failed to read ExRoutesRdsMap for vpn {} due to exception", vpnId, e);
+ }
+ return new ArrayList<>();
}
}
*/
package org.opendaylight.netvirt.vpnmanager.api;
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
*/
package org.opendaylight.netvirt.vpnmanager.api.intervpnlink;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import static java.util.Collections.emptyList;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
}
public Optional<InterVpnLinkState.State> getState() {
- return this.interVpnLinkState == null ? Optional.absent()
- : Optional.fromNullable(this.interVpnLinkState.getState());
+ return this.interVpnLinkState == null ? Optional.empty()
+ : Optional.ofNullable(this.interVpnLinkState.getState());
}
public boolean isActive() {
}
public boolean isIpAddrTheOtherVpnEndpoint(String ipAddr, String vpnUuid) {
- return (vpnUuid.equals(getFirstEndpointVpnUuid().orNull())
- && ipAddr.equals(getSecondEndpointIpAddr().orNull()))
- || (vpnUuid.equals(getSecondEndpointVpnUuid().orNull())
- && ipAddr.equals(getFirstEndpointIpAddr().orNull()));
+ return (vpnUuid.equals(getFirstEndpointVpnUuid().orElse(null))
+ && ipAddr.equals(getSecondEndpointIpAddr().orElse(null)))
+ || (vpnUuid.equals(getSecondEndpointVpnUuid().orElse(null))
+ && ipAddr.equals(getFirstEndpointIpAddr().orElse(null)));
}
@Nullable
public Optional<String> getFirstEndpointVpnUuid() {
if (this.interVpnLinkCfg == null) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(this.interVpnLinkCfg.getFirstEndpoint().getVpnUuid().getValue());
}
public Optional<String> getFirstEndpointIpAddr() {
if (this.interVpnLinkCfg == null) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(this.interVpnLinkCfg.getFirstEndpoint().getIpAddress().getValue());
}
public Optional<Uint32> getFirstEndpointLportTag() {
return (!isComplete() || this.interVpnLinkState.getFirstEndpointState().getLportTag() == null)
- ? Optional.absent()
+ ? Optional.empty()
: Optional.of(this.interVpnLinkState.getFirstEndpointState().getLportTag());
}
public Optional<String> getSecondEndpointVpnUuid() {
if (!isComplete()) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(this.interVpnLinkCfg.getSecondEndpoint().getVpnUuid().getValue());
}
public Optional<String> getSecondEndpointIpAddr() {
if (!isComplete()) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(this.interVpnLinkCfg.getSecondEndpoint().getIpAddress().getValue());
}
public Optional<Uint32> getSecondEndpointLportTag() {
return (!isComplete() || this.interVpnLinkState.getSecondEndpointState().getLportTag() == null)
- ? Optional.absent()
+ ? Optional.empty()
: Optional.of(this.interVpnLinkState.getSecondEndpointState().getLportTag());
}
endpointIpAddr, getInterVpnLinkName());
return null;
}
- return isFirstEndpointIpAddr(endpointIpAddr) ? getFirstEndpointVpnUuid().orNull()
- : getSecondEndpointVpnUuid().orNull();
+ return isFirstEndpointIpAddr(endpointIpAddr) ? getFirstEndpointVpnUuid().orElse(null)
+ : getSecondEndpointVpnUuid().orElse(null);
}
@Nullable
return null;
}
- return isFirstEndpointVpnName(vpnUuid) ? getSecondEndpointIpAddr().orNull()
- : getFirstEndpointIpAddr().orNull();
+ return isFirstEndpointVpnName(vpnUuid) ? getSecondEndpointIpAddr().orElse(null)
+ : getFirstEndpointIpAddr().orElse(null);
}
@Nullable
endpointIpAddr, getInterVpnLinkName());
return null;
}
- return isFirstEndpointIpAddr(endpointIpAddr) ? getSecondEndpointVpnUuid().orNull()
- : getFirstEndpointVpnUuid().orNull();
+ return isFirstEndpointIpAddr(endpointIpAddr) ? getSecondEndpointVpnUuid().orElse(null)
+ : getFirstEndpointVpnUuid().orElse(null);
}
public Optional<Uint32> getEndpointLportTagByVpnName(String vpnName) {
if (!isComplete()) {
- return Optional.absent();
+ return Optional.empty();
}
return isFirstEndpointVpnName(vpnName) ? Optional.of(interVpnLinkState.getFirstEndpointState().getLportTag())
public Optional<Uint32> getEndpointLportTagByIpAddr(String endpointIp) {
if (!isComplete()) {
- return Optional.absent();
+ return Optional.empty();
}
return isFirstEndpointIpAddr(endpointIp)
- ? Optional.fromNullable(interVpnLinkState.getFirstEndpointState().getLportTag())
- : Optional.fromNullable(interVpnLinkState.getSecondEndpointState().getLportTag());
+ ? Optional.ofNullable(interVpnLinkState.getFirstEndpointState().getLportTag())
+ : Optional.ofNullable(interVpnLinkState.getSecondEndpointState().getLportTag());
}
public Optional<Uint32> getOtherEndpointLportTagByVpnName(String vpnName) {
if (!isComplete()) {
- return Optional.absent();
+ return Optional.empty();
}
return isFirstEndpointVpnName(vpnName) ? Optional.of(interVpnLinkState.getSecondEndpointState().getLportTag())
return null;
}
- return isFirstEndpointVpnName(vpnName) ? getSecondEndpointVpnUuid().orNull()
- : getFirstEndpointVpnUuid().orNull();
+ return isFirstEndpointVpnName(vpnName) ? getSecondEndpointVpnUuid().orElse(null)
+ : getFirstEndpointVpnUuid().orElse(null);
}
@Nullable
return null;
}
- return isFirstEndpointVpnName(vpnUuid) ? getSecondEndpointIpAddr().orNull()
- : getFirstEndpointIpAddr().orNull();
+ return isFirstEndpointVpnName(vpnUuid) ? getSecondEndpointIpAddr().orElse(null)
+ : getFirstEndpointIpAddr().orElse(null);
}
@Nullable
return null;
}
- return isFirstEndpointVpnName(vpnUuid) ? getFirstEndpointIpAddr().orNull()
- : getSecondEndpointIpAddr().orNull();
+ return isFirstEndpointVpnName(vpnUuid) ? getFirstEndpointIpAddr().orElse(null)
+ : getSecondEndpointIpAddr().orElse(null);
}
public List<Uint64> getEndpointDpnsByVpnName(String vpnUuid) {
@Override
public String toString() {
final String ns = "Not specified";
- return "InterVpnLink " + getInterVpnLinkName() + " 1stEndpoint=[vpn=" + getFirstEndpointVpnUuid().or(ns)
- + " ipAddr=" + getFirstEndpointIpAddr().or(ns) + " dpn=" + getFirstEndpointDpns() + "] 2ndEndpoint=[vpn="
- + getSecondEndpointVpnUuid().or(ns) + " ipAddr=" + getSecondEndpointIpAddr().or(ns) + " dpn="
- + getSecondEndpointDpns() + "]";
+ return "InterVpnLink " + getInterVpnLinkName() + " 1stEndpoint=[vpn=" + getFirstEndpointVpnUuid().orElse(ns)
+ + " ipAddr=" + getFirstEndpointIpAddr().orElse(ns) + " dpn=" + getFirstEndpointDpns() + "] "
+ + "2ndEndpoint=[vpn=" + getSecondEndpointVpnUuid().orElse(ns) + " ipAddr="
+ + getSecondEndpointIpAddr().orElse(ns) + " dpn=" + getSecondEndpointDpns() + "]";
}
@Override
InterVpnLinkDataComposite other = (InterVpnLinkDataComposite) obj;
String none = "";
return getInterVpnLinkName().equals(other.getInterVpnLinkName())
- && getFirstEndpointVpnUuid().or(none).equals(other.getFirstEndpointVpnUuid().or(none))
- && getFirstEndpointIpAddr().or(none).equals(other.getFirstEndpointIpAddr().or(none));
+ && getFirstEndpointVpnUuid().orElse(none).equals(other.getFirstEndpointVpnUuid().orElse(none))
+ && getFirstEndpointIpAddr().orElse(none).equals(other.getFirstEndpointIpAddr().orElse(none));
}
@Override
<modelVersion>4.0.0</modelVersion>
<dependencies>
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.genius</groupId>
</dependency>
<!-- Testing dependencies -->
- <dependency>
+<!-- <dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<type>test-jar</type>
+ </dependency>-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
</dependency>
</dependencies>
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
*/
@Singleton
public class CentralizedSwitchChangeListener
- extends AsyncDataTreeChangeListenerBase<RouterToNaptSwitch, CentralizedSwitchChangeListener> {
+ extends AbstractAsyncDataTreeChangeListener<RouterToNaptSwitch> {
private static final Logger LOG = LoggerFactory.getLogger(CentralizedSwitchChangeListener.class);
@Inject
public CentralizedSwitchChangeListener(final DataBroker dataBroker, final IVpnManager vpnManager,
final ExternalRouterDataUtil externalRouterDataUtil, final VpnUtil vpnUtil) {
- super(RouterToNaptSwitch.class, CentralizedSwitchChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(NaptSwitches.class).child(RouterToNaptSwitch.class),
+ Executors.newListeningSingleThreadExecutor("CentralizedSwitchChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.vpnManager = vpnManager;
this.vpnUtil = vpnUtil;
}
- @Override
- @PostConstruct
- public void init() {
- LOG.info("{} init", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<RouterToNaptSwitch> getWildCardPath() {
- return InstanceIdentifier.create(NaptSwitches.class).child(RouterToNaptSwitch.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
+ public void remove(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
LOG.debug("Removing {}", routerToNaptSwitch);
ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx ->
setupRouterGwFlows(routerToNaptSwitch, tx, NwConstants.DEL_FLOW)), LOG,
}
@Override
- protected void update(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch origRouterToNaptSwitch,
+ public void update(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch origRouterToNaptSwitch,
RouterToNaptSwitch updatedRouterToNaptSwitch) {
LOG.debug("Updating old {} new {}", origRouterToNaptSwitch, updatedRouterToNaptSwitch);
if (!Objects.equals(updatedRouterToNaptSwitch.getPrimarySwitchId(),
}
@Override
- protected void add(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
+ public void add(InstanceIdentifier<RouterToNaptSwitch> key, RouterToNaptSwitch routerToNaptSwitch) {
LOG.debug("Adding {}", routerToNaptSwitch);
ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx ->
setupRouterGwFlows(routerToNaptSwitch, tx, NwConstants.ADD_FLOW)), LOG,
"Error processing switch addition for {}", routerToNaptSwitch);
}
- @Override
- protected CentralizedSwitchChangeListener getDataTreeChangeListener() {
- return this;
- }
-
private void setupRouterGwFlows(RouterToNaptSwitch routerToNaptSwitch,
TypedReadWriteTransaction<Configuration> confTx, int addOrRemove)
throws ExecutionException, InterruptedException {
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddDpnEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AddInterfaceToDpnOnVpnEvent;
}
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("onRemoveDpnEvent: Failed to read data store for rd {} vpn {} dpn {}", rd, vpnName, dpnId);
} finally {
lock.unlock();
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.slf4j.LoggerFactory;
@Singleton
-public class FibEntriesListener extends AsyncDataTreeChangeListenerBase<VrfEntry, FibEntriesListener> {
+public class FibEntriesListener extends AbstractAsyncDataTreeChangeListener<VrfEntry> {
private static final Logger LOG = LoggerFactory.getLogger(FibEntriesListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
@Inject
public FibEntriesListener(final DataBroker dataBroker, final VpnInstanceListener vpnInstanceListener) {
- super(VrfEntry.class, FibEntriesListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class),
+ Executors.newListeningSingleThreadExecutor("FibEntriesListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.vpnInstanceListener = vpnInstanceListener;
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<VrfEntry> getWildCardPath() {
- return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
- }
-
- @Override
- protected FibEntriesListener getDataTreeChangeListener() {
- return FibEntriesListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected void remove(InstanceIdentifier<VrfEntry> identifier,
+ public void remove(InstanceIdentifier<VrfEntry> identifier,
VrfEntry del) {
LOG.trace("Remove Fib event - Key : {}, value : {} ", identifier, del);
final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class);
}
@Override
- protected void update(InstanceIdentifier<VrfEntry> identifier,
+ public void update(InstanceIdentifier<VrfEntry> identifier,
VrfEntry original, VrfEntry update) {
final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class);
String rd = key.getRouteDistinguisher();
}
@Override
- protected void add(InstanceIdentifier<VrfEntry> identifier,
+ public void add(InstanceIdentifier<VrfEntry> identifier,
VrfEntry add) {
LOG.trace("Add Vrf Entry event - Key : {}, value : {}", identifier, add);
final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import com.google.common.util.concurrent.FutureCallback;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.slf4j.LoggerFactory;
@Singleton
-public class InterfaceStateChangeListener
- extends AsyncDataTreeChangeListenerBase<Interface, InterfaceStateChangeListener> {
+public class InterfaceStateChangeListener extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceStateChangeListener.class);
private static final short DJC_MAX_RETRIES = 3;
@Inject
public InterfaceStateChangeListener(final DataBroker dataBroker, final VpnInterfaceManager vpnInterfaceManager,
final VpnUtil vpnUtil, final JobCoordinator jobCoordinator, final IFibManager fibManager) {
- super(Interface.class, InterfaceStateChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("InterfaceStateChangeListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.vpnInterfaceManager = vpnInterfaceManager;
initialize();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- }
-
-
- @Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
}
@Override
- protected InterfaceStateChangeListener getDataTreeChangeListener() {
- return InterfaceStateChangeListener.this;
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
try {
if (L2vlan.class.equals(intrf.getType())) {
LOG.info("VPN Interface add event - intfName {} from InterfaceStateChangeListener",
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
final String ifName = intrf.getName();
Uint64 dpId = Uint64.ZERO;
try {
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected void update(InstanceIdentifier<Interface> identifier,
+ public void update(InstanceIdentifier<Interface> identifier,
Interface original, Interface update) {
final String ifName = update.getName();
try {
*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PortOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
} catch (TransactionCommitFailedException ex) {
LOG.error("addDpnToSubnet: Creation of SubnetToDpn for subnet {} with DpnId {} failed",
subnetId.getValue(), dpnId, ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("addDpnToSubnet: Failed to read data store for subnet {} dpn {}", subnetId.getValue(),
dpnId);
}
} catch (TransactionCommitFailedException ex) {
LOG.error("removeDpnFromSubnet: Deletion of SubnetToDpn for subnet {} with DPN {} failed",
subnetId.getValue(), dpnId, ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("removeDpnFromSubnet: Failed to read data store for subnet {} dpn {}", subnetId, dpnId);
}
}
} catch (TransactionCommitFailedException ex) {
LOG.error("addInterfaceToDpn: Addition of Interface {} for SubnetToDpn on subnet {} with DPN {} failed",
intfName, subnetId.getValue(), dpnId, ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("addInterfaceToDpn: Failed to read data store for interface {} subnet {} dpn {}", intfName,
subnetId, dpnId);
}
} catch (TransactionCommitFailedException ex) {
LOG.error("addPortOpDataEntry: Addition of Interface {} for SubnetToDpn on subnet {} with DPN {} failed",
intfName, subnetId.getValue(), dpnId, ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("addPortOpDataEntry: Failed to read from data store for interface {} subnet {} dpn {}",
intfName, subnetId, dpnId);
}
} catch (TransactionCommitFailedException ex) {
LOG.error("removeInterfaceFromDpn: Deletion of Interface {} for SubnetToDpn on subnet {}"
+ " with DPN {} failed", intfName, subnetId.getValue(), dpnId, ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("removeInterfaceFromDpn: Failed to read data store for interface {} subnet {} dpn {}",
intfName, subnetId, dpnId);
}
portOpEntry = null;
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("removePortOpDataEntry: Failed to read data store for interface {} subnet {}", intfName,
subnetId);
} catch (TransactionCommitFailedException e) {
if (optionalPortOp.isPresent()) {
portOpDataEntry = optionalPortOp.get();
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getPortOpDataEntry: Failed to read data store for interface {}", intfName);
}
return portOpDataEntry;
*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.slf4j.LoggerFactory;
@Singleton
-public class SubnetRouteInterfaceStateChangeListener extends AsyncDataTreeChangeListenerBase<Interface,
- SubnetRouteInterfaceStateChangeListener> {
+public class SubnetRouteInterfaceStateChangeListener extends AbstractAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(SubnetRouteInterfaceStateChangeListener.class);
private static final String LOGGING_PREFIX = "SUBNETROUTE:";
private final DataBroker dataBroker;
public SubnetRouteInterfaceStateChangeListener(final DataBroker dataBroker,
final VpnSubnetRouteHandler vpnSubnetRouteHandler, final SubnetOpDpnManager subnetOpDpnManager,
final INeutronVpnManager neutronVpnService, final JobCoordinator jobCoordinator) {
- super(Interface.class, SubnetRouteInterfaceStateChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(InterfacesState.class).child(Interface.class),
+ Executors.newListeningSingleThreadExecutor("SubnetRouteInterfaceStateChangeListener", LOG));
this.dataBroker = dataBroker;
this.vpnSubnetRouteHandler = vpnSubnetRouteHandler;
this.subOpDpnManager = subnetOpDpnManager;
this.neutronVpnManager = neutronVpnService;
this.jobCoordinator = jobCoordinator;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<Interface> getWildCardPath() {
- return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
- @Override
- protected SubnetRouteInterfaceStateChangeListener getDataTreeChangeListener() {
- return SubnetRouteInterfaceStateChangeListener.this;
- }
@Override
- protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
LOG.trace("{} add: Received interface {} up event", LOGGING_PREFIX, intrf);
if (L2vlan.class.equals(intrf.getType())) {
LOG.trace("SubnetRouteInterfaceListener add: Received interface {} up event", intrf);
}
vpnSubnetRouteHandler.onInterfaceUp(dpnId, intrf.getName(), subnetId);
LOG.info("{} add: Processed interface {} up event", LOGGING_PREFIX, intrf.getName());
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("add: Failed to read data store for interface {} dpn {}", interfaceName,
dpnId);
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ public void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
if (L2vlan.class.equals(intrf.getType())) {
LOG.trace("SubnetRouteInterfaceListener remove: Received interface {} down event", intrf);
List<Uuid> subnetIdList = getSubnetId(intrf);
}
LOG.info("{} remove: Processed interface {} down event in ", LOGGING_PREFIX,
intrf.getName());
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} remove: Failed to read data store for {}", LOGGING_PREFIX, intrf.getName());
}
return futures;
}
@Override
- protected void update(InstanceIdentifier<Interface> identifier,
+ public void update(InstanceIdentifier<Interface> identifier,
Interface original, Interface update) {
String interfaceName = update.getName();
if (L2vlan.class.equals(update.getType())) {
vpnSubnetRouteHandler.onInterfaceDown(dpnId, update.getName(), subnetId);
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("update: Failed to read data store for interface {} dpn {}", interfaceName,
dpnId);
}
*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.Optional;
import com.google.common.primitives.Ints;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.infrautils.metrics.MetricDescriptor;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.ICentralizedSwitchProvider;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
import org.opendaylight.netvirt.vpnmanager.iplearn.ipv4.ArpUtils;
.label(NWUtil.toStringIpAddress(srcIpBytes) + "." + NWUtil.toStringIpAddress(srcIpBytes));
counter.increment();
LOG.error("{} onPacketReceived: Failed to handle subnetroute packet.", LOGGING_PREFIX, ex);
- } catch (ReadFailedException e) {
- Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString())
- .label(NWUtil.toStringIpAddress(srcIpBytes) + "." + NWUtil.toStringIpAddress(srcIpBytes));
- counter.increment();
- LOG.error("{} onPacketReceived: Failed to read data-store.", LOGGING_PREFIX, e);
- } catch (UnknownHostException e) {
+ } catch (UnknownHostException e) {
Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString())
.label(CounterUtility.getSubnetRouteInvalidPacket());
counter.increment();
private void handleIpPackets(byte[] srcIp, byte[] dstIp, String srcIpStr, String dstIpStr, String srcMac,
Uint64 metadata)
- throws UnknownHostException, InterruptedException, ExecutionException, ReadFailedException {
+ throws UnknownHostException, InterruptedException, ExecutionException {
Uint32 vpnId = Uint32.valueOf(MetaDataUtil.getVpnIdFromMetadata(metadata));
LOG.info("{} onPacketReceived: Processing IP Packet received with Source IP {} and Target IP {}"
transmitArpOrNsPacket(targetSubnetForPacketOut.getNhDpnId(),
sourceIp, sourceMac, dstIp, dstIpStr, elanTag);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("handlePacketToInternalNetwork: Failed to read data store for destIp {} elanTag {}", dstIpStr,
elanTag);
}
}
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} getTargetDpnForPacketOut: Failed to read data store for elan {}", LOGGING_PREFIX,
elanInfo.getName());
}
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.slf4j.LoggerFactory;
@Singleton
-public class SubnetmapChangeListener extends AsyncDataTreeChangeListenerBase<Subnetmap, SubnetmapChangeListener> {
+public class SubnetmapChangeListener extends AbstractAsyncDataTreeChangeListener<Subnetmap> {
private static final Logger LOG = LoggerFactory.getLogger(SubnetmapChangeListener.class);
private final DataBroker dataBroker;
private final VpnSubnetRouteHandler vpnSubnetRouteHandler;
@Inject
public SubnetmapChangeListener(final DataBroker dataBroker, final VpnSubnetRouteHandler vpnSubnetRouteHandler,
VpnUtil vpnUtil, IVpnManager vpnManager) {
- super(Subnetmap.class, SubnetmapChangeListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Subnetmaps.class).child(Subnetmap.class),
+ Executors.newListeningSingleThreadExecutor("SubnetmapChangeListener", LOG));
this.dataBroker = dataBroker;
this.vpnSubnetRouteHandler = vpnSubnetRouteHandler;
this.vpnUtil = vpnUtil;
this.vpnManager = vpnManager;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(dataBroker);
}
@Override
- protected InstanceIdentifier<Subnetmap> getWildCardPath() {
- return InstanceIdentifier.create(Subnetmaps.class).child(Subnetmap.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- private void registerListener(final DataBroker db) {
- try {
- registerListener(LogicalDatastoreType.CONFIGURATION, db);
- } catch (final Exception e) {
- LOG.error("VPNManager subnetMap config DataChange listener registration fail!", e);
- throw new IllegalStateException("VPNManager subnetMap config DataChange listener registration failed.", e);
- }
- }
@Override
- protected void add(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
+ public void add(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
LOG.debug("add: subnetmap method - key: {}, value: {}", identifier, subnetmap);
Uuid subnetId = subnetmap.getId();
Network network = vpnUtil.getNeutronNetwork(subnetmap.getNetworkId());
}
@Override
- protected void remove(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
+ public void remove(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmap) {
LOG.trace("remove: subnetmap method - key: {}, value: {}", identifier, subnetmap);
}
@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void update(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmapOriginal, Subnetmap
+ public void update(InstanceIdentifier<Subnetmap> identifier, Subnetmap subnetmapOriginal, Subnetmap
subnetmapUpdate) {
LOG.debug("update: method - key {}, original {}, update {}", identifier,
subnetmapOriginal, subnetmapUpdate);
}
}
- @Override
- protected SubnetmapChangeListener getDataTreeChangeListener() {
- return this;
- }
-
@SuppressWarnings("all")
protected long getElanTag(String elanInstanceName) {
final long[] elanTag = {0L};
InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class)
.child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
ElanInstance elanInstance = tx.read(LogicalDatastoreType.CONFIGURATION, elanIdentifierId)
- .checkedGet().orNull();
+ .get().orElse(null);
if (elanInstance != null) {
if (elanInstance.getElanTag() != null) {
elanTag[0] =elanInstance.getElanTag().longValue();
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
@Singleton
public class TunnelEndPointChangeListener
- extends AsyncDataTreeChangeListenerBase<TunnelEndPoints, TunnelEndPointChangeListener> {
+ extends AbstractAsyncDataTreeChangeListener<TunnelEndPoints> {
private static final Logger LOG = LoggerFactory.getLogger(TunnelEndPointChangeListener.class);
private final DataBroker broker;
@Inject
public TunnelEndPointChangeListener(final DataBroker broker, final VpnInterfaceManager vpnInterfaceManager,
final JobCoordinator jobCoordinator, VpnUtil vpnUtil, final IFibManager fibManager) {
- super(TunnelEndPoints.class, TunnelEndPointChangeListener.class);
+ super(broker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(DpnEndpoints.class).child(DPNTEPsInfo.class).child(TunnelEndPoints.class),
+ Executors.newListeningSingleThreadExecutor("TunnelEndPointChangeListener", LOG));
this.broker = broker;
this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
this.vpnInterfaceManager = vpnInterfaceManager;
this.jobCoordinator = jobCoordinator;
this.vpnUtil = vpnUtil;
this.fibManager = fibManager;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
}
@Override
- protected InstanceIdentifier<TunnelEndPoints> getWildCardPath() {
- return InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class).child(TunnelEndPoints.class)
- .build();
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
+
@Override
- protected void remove(InstanceIdentifier<TunnelEndPoints> key, TunnelEndPoints tep) {
+ public void remove(InstanceIdentifier<TunnelEndPoints> key, TunnelEndPoints tep) {
}
@Override
- protected void update(InstanceIdentifier<TunnelEndPoints> key, TunnelEndPoints origTep,
+ public void update(InstanceIdentifier<TunnelEndPoints> key, TunnelEndPoints origTep,
TunnelEndPoints updatedTep) {
}
@Override
- protected void add(InstanceIdentifier<TunnelEndPoints> key, TunnelEndPoints tep) {
+ public void add(InstanceIdentifier<TunnelEndPoints> key, TunnelEndPoints tep) {
Uint64 dpnId = key.firstIdentifierOf(DPNTEPsInfo.class).firstKeyOf(DPNTEPsInfo.class).getDPNID();
if (Uint64.ZERO.equals(dpnId)) {
LOG.warn("add: Invalid DPN id for TEP {}", tep.getInterfaceName());
}
}
- @Override
- protected TunnelEndPointChangeListener getDataTreeChangeListener() {
- return this;
- }
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
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.interfaces.rev140508.interfaces.Interface;
import org.slf4j.LoggerFactory;
@Singleton
-public class TunnelInterfaceStateListener extends AsyncDataTreeChangeListenerBase<StateTunnelList,
- TunnelInterfaceStateListener> {
+public class TunnelInterfaceStateListener extends AbstractAsyncDataTreeChangeListener<StateTunnelList> {
private static final Logger LOG = LoggerFactory.getLogger(TunnelInterfaceStateListener.class);
final VpnSubnetRouteHandler vpnSubnetRouteHandler,
final JobCoordinator jobCoordinator,
VpnUtil vpnUtil) {
- super(StateTunnelList.class, TunnelInterfaceStateListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class),
+ Executors.newListeningSingleThreadExecutor("TunnelInterfaceStateListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.fibManager = fibManager;
this.vpnSubnetRouteHandler = vpnSubnetRouteHandler;
this.jobCoordinator = jobCoordinator;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<StateTunnelList> getWildCardPath() {
- return InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
- @Override
- protected TunnelInterfaceStateListener getDataTreeChangeListener() {
- return TunnelInterfaceStateListener.this;
- }
@Override
- protected void remove(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList del) {
+ public void remove(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList del) {
LOG.trace("remove: Tunnel deletion---- {}", del);
if (isGreTunnel(del)) {
programDcGwLoadBalancingGroup(del, NwConstants.MOD_FLOW, false);
}
@Override
- protected void update(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList original,
+ public void update(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList original,
StateTunnelList update) {
LOG.trace("update: Tunnel updation---- {}", update);
LOG.info("update: ITM Tunnel {} of type {} state event changed from :{} to :{}",
}
@Override
- protected void add(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList add) {
+ public void add(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList add) {
LOG.trace("add: Tunnel addition---- {}", add);
TunnelOperStatus tunOpStatus = add.getOperState();
if (tunOpStatus != TunnelOperStatus.Down && tunOpStatus != TunnelOperStatus.Up) {
}
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("handleTunnelEventForDPN: Failed to read data store for interface {} srcDpn {} srcTep {} "
+ "dstTep {}", intfName, srcDpnId, srcTepIp, destTepIp);
}
import java.util.ArrayList;
import java.util.List;
-
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnElanInterfaceChangeListener
- extends AsyncDataTreeChangeListenerBase<ElanInterface, VpnElanInterfaceChangeListener> {
+public class VpnElanInterfaceChangeListener extends AbstractAsyncDataTreeChangeListener<ElanInterface> {
private static final Logger LOG = LoggerFactory.getLogger(VpnElanInterfaceChangeListener.class);
private final DataBroker broker;
@Inject
public VpnElanInterfaceChangeListener(final DataBroker broker, final IElanService elanService,
final VpnUtil vpnUtil) {
- super(ElanInterface.class, VpnElanInterfaceChangeListener.class);
+ super(broker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(ElanInterfaces.class).child(ElanInterface.class),
+ Executors.newListeningSingleThreadExecutor("VpnElanInterfaceChangeListener", LOG));
this.broker = broker;
this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
this.elanService = elanService;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, broker);
}
@Override
- protected InstanceIdentifier<ElanInterface> getWildCardPath() {
- return InstanceIdentifier.create(ElanInterfaces.class).child(ElanInterface.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
+
@Override
- protected void remove(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
+ public void remove(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
String interfaceName = elanInterface.getName();
if (!elanService.isExternalInterface(interfaceName)) {
LOG.debug("remove: Interface {} is not external. Ignoring interface removal", interfaceName);
}
@Override
- protected void update(InstanceIdentifier<ElanInterface> key, ElanInterface origElanInterface,
+ public void update(InstanceIdentifier<ElanInterface> key, ElanInterface origElanInterface,
ElanInterface updatedElanInterface) {
}
@Override
- protected void add(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
+ public void add(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
String interfaceName = elanInterface.getName();
if (!elanService.isExternalInterface(interfaceName)) {
LOG.debug("add: Interface {} is not external. Ignoring", interfaceName);
elanInterface.getElanInstanceName());
}
- @Override
- protected VpnElanInterfaceChangeListener getDataTreeChangeListener() {
- return this;
- }
}
package org.opendaylight.netvirt.vpnmanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Singleton;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
*/
package org.opendaylight.netvirt.vpnmanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnInstanceListener extends AsyncDataTreeChangeListenerBase<VpnInstance, VpnInstanceListener> {
+public class VpnInstanceListener extends AbstractAsyncDataTreeChangeListener<VpnInstance> {
private static final Logger LOG = LoggerFactory.getLogger(VpnInstanceListener.class);
private static final String LOGGING_PREFIX_ADD = "VPN-ADD:";
private static final String LOGGING_PREFIX_UPDATE = "VPN-UPDATE:";
final VpnInterfaceManager vpnInterfaceManager, final IFibManager fibManager,
final VpnOpDataSyncer vpnOpDataSyncer, final IMdsalApiManager mdsalManager,
final JobCoordinator jobCoordinator, VpnUtil vpnUtil) {
- super(VpnInstance.class, VpnInstanceListener.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(VpnInstances.class).child(VpnInstance.class),
+ Executors.newListeningSingleThreadExecutor("VpnInstanceListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.idManager = idManager;
this.mdsalManager = mdsalManager;
this.jobCoordinator = jobCoordinator;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<VpnInstance> getWildCardPath() {
- return InstanceIdentifier.create(VpnInstances.class).child(VpnInstance.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
- @Override
- protected VpnInstanceListener getDataTreeChangeListener() {
- return VpnInstanceListener.this;
- }
@Override
- protected void remove(InstanceIdentifier<VpnInstance> identifier, VpnInstance del) {
+ public void remove(InstanceIdentifier<VpnInstance> identifier, VpnInstance del) {
LOG.trace("{} : VPN event key: {}, value: {}", LOGGING_PREFIX_DELETE, identifier, del);
final String vpnName = del.getVpnInstanceName();
Optional<VpnInstanceOpDataEntry> vpnOpValue;
try {
vpnOpValue = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(primaryRd));
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{}, failed to remove VPN: Exception while retrieving VpnInstanceOpDataEntry for VPN {}. ",
LOGGING_PREFIX_DELETE, vpnName, e);
return;
}
@Override
- protected void update(InstanceIdentifier<VpnInstance> identifier,
+ public void update(InstanceIdentifier<VpnInstance> identifier,
VpnInstance original, VpnInstance update) {
LOG.trace("VPN-UPDATE: update: VPN event key: {}, value: {}.", identifier, update);
String vpnName = update.getVpnInstanceName();
}
@Override
- protected void add(final InstanceIdentifier<VpnInstance> identifier, final VpnInstance value) {
+ public void add(final InstanceIdentifier<VpnInstance> identifier, final VpnInstance value) {
LOG.trace("{} add: Add VPN event key: {}, value: {}", LOGGING_PREFIX_ADD, identifier, value);
final String vpnName = value.getVpnInstanceName();
jobCoordinator.enqueueJob("VPN-" + vpnName, new AddVpnInstanceWorker(dataBroker, value),
SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
- private class AddVpnInstanceWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class AddVpnInstanceWorker implements Callable<List<? extends ListenableFuture<?>>> {
private final Logger log = LoggerFactory.getLogger(AddVpnInstanceWorker.class);
VpnInstance vpnInstance;
DataBroker broker;
Arrays.asList(new InstructionWriteMetadata(MetaDataUtil.getVpnIdMetadata(vpnInstanceOpDataEntry
.getVpnId().toJava()), MetaDataUtil.METADATA_MASK_VRFID),
new InstructionGotoTable(NwConstants.L3_GW_MAC_TABLE));
-
- for (Uint64 dpnId: NWUtil.getOperativeDPNs(dataBroker)) {
- String flowRef = getFibFlowRef(dpnId, NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
- vpnName, VpnConstants.DEFAULT_FLOW_PRIORITY);
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpnId,
- NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, flowRef, VpnConstants.DEFAULT_FLOW_PRIORITY,
- "VxLAN VPN Tunnel Bind Service", 0, 0, NwConstants.COOKIE_VM_FIB_TABLE,
- mkMatches, instructions);
- mdsalManager.installFlow(dpnId, flowEntity);
+ try {
+ for (Uint64 dpnId: NWUtil.getOperativeDPNs(dataBroker)) {
+ String flowRef = getFibFlowRef(dpnId, NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
+ vpnName, VpnConstants.DEFAULT_FLOW_PRIORITY);
+ FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpnId,
+ NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, flowRef,
+ VpnConstants.DEFAULT_FLOW_PRIORITY, "VxLAN VPN Tunnel Bind Service",
+ 0, 0, NwConstants.COOKIE_VM_FIB_TABLE, mkMatches, instructions);
+ mdsalManager.installFlow(dpnId, flowEntity);
+ }
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("PostAddVpnInstanceWorker: Exception while getting the list of Operative DPNs for Vpn {}",
+ vpnName, e);
}
///////////////////////
InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
try {
return SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
- id).orNull();
- } catch (ReadFailedException e) {
+ id).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
throw new RuntimeException("Error reading VPN instance data for " + rd, e);
}
}
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getDcGatewayTunnelInterfaceNameList: Failed to read data store");
}
return tunnelInterfaceNameList;
package org.opendaylight.netvirt.vpnmanager;
import static java.util.Collections.emptyList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterators;
import com.google.common.util.concurrent.FutureCallback;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.infra.TransactionAdapter;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.populator.input.L3vpnInput;
import org.opendaylight.netvirt.vpnmanager.populator.intfc.VpnPopulator;
import org.opendaylight.netvirt.vpnmanager.populator.registry.L3vpnRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnInterfaceManager extends AsyncDataTreeChangeListenerBase<VpnInterface, VpnInterfaceManager> {
+public class VpnInterfaceManager extends AbstractAsyncDataTreeChangeListener<VpnInterface> {
private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceManager.class);
private static final short DJC_MAX_RETRIES = 3;
final JobCoordinator jobCoordinator,
final CacheProvider cacheProvider,
final VpnUtil vpnUtil) {
- super(VpnInterface.class, VpnInterfaceManager.class);
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class),
+ Executors.newListeningSingleThreadExecutor("VpnInterfaceManager", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
vpnInstanceOpDataEntryCache = new InstanceIdDataObjectCache<>(VpnInstanceOpDataEntry.class, dataBroker,
LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(
VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class).build(), cacheProvider);
+ start();
}
public Runnable isNotifyTaskQueued(String intfName) {
return vpnIntfMap.remove(intfName);
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
public void close() {
super.close();
vpnInstanceOpDataEntryCache.close();
- }
-
- @Override
- protected InstanceIdentifier<VpnInterface> getWildCardPath() {
- return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
- }
-
- @Override
- protected VpnInterfaceManager getDataTreeChangeListener() {
- return VpnInterfaceManager.this;
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
addNewAdjToVpnInterface(vpnInterfaceOpIdentifier, primaryRd, adjacency,
dpId, writeOperTxn, writeConfigTxn, writeInvTxn, prefixListForRefreshFib);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("processVpnInterfaceUp: Failed to read data store for interface {} vpn {} rd {} dpn {}",
interfaceName, vpnName, primaryRd, dpId);
}
}
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("advertiseAdjacenciesForVpnToBgp: Failed to read data store for interface {} dpn {} nexthop {}"
+ "vpn {} rd {}", interfaceName, dpnId, nextHopIp, vpnName, rd);
}
}
LOG.info("withdrawAdjacenciesForVpnFromBgp: For interface {} in vpn {} with rd {}", interfaceName,
vpnName, rd);
- Optional<AdjacenciesOp> adjacencies = Optional.absent();
+ Optional<AdjacenciesOp> adjacencies = Optional.empty();
try {
adjacencies = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
path);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("withdrawAdjacenciesForVpnFromBgp: Failed to read data store for interface {} vpn {}",
interfaceName, vpnName);
}
throws ExecutionException, InterruptedException {
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
// Read NextHops
- Optional<VpnInterface> vpnInteface = Optional.absent();
+ Optional<VpnInterface> vpnInteface = Optional.empty();
try {
vpnInteface = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, identifier);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("processVpnInterfaceAdjacencies: Failed to read data store for interface {} vpn {} rd {}"
+ "dpn {}", interfaceName, vpnName, primaryRd, dpnId);
}
LOG.debug("processVpnInterfaceAdjacencies: NextHop for interface {} on dpn {} in vpn {} is {}",
interfaceName, dpnId, vpnName, nhList);
}
- Optional<String> gwMac = Optional.absent();
+ Optional<String> gwMac = Optional.empty();
String vpnInterfaceSubnetGwMacAddress = null;
VpnInstanceOpDataEntry vpnInstanceOpData = vpnUtil.getVpnInstanceOpData(primaryRd);
Uint32 l3vni = vpnInstanceOpData.getL3vni() != null ? vpnInstanceOpData.getL3vni() : Uint32.ZERO;
gwMac.isPresent() ? gwMac.get() : null, gatewayIp, writeOperTxn);
L3vpnInput input = new L3vpnInput().setNextHopIp(nextHopIp).setL3vni(l3vni.longValue()).setPrimaryRd(primaryRd)
- .setGatewayMac(gwMac.orNull()).setInterfaceName(interfaceName)
+ .setGatewayMac(gwMac.orElse(null)).setInterfaceName(interfaceName)
.setVpnName(vpnName).setDpnId(dpnId).setEncapType(encapType);
for (Adjacency nextHop : aug.getAdjacency()) {
+ " vpn {} vpnid {} rd {} interface {}", label, srcDpnId , prefix, nhList,
vpnInterface.getVpnInstanceName(), vpnId, rd, vpnInterface.getName());
// Update the VRF entry with nextHop
- fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp,
- label, true, TransactionAdapter.toWriteTransaction(writeConfigTxn));
+ fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp, label, true,
+ writeConfigTxn);
//Get the list of VPN's importing this route(prefix) .
// Then update the VRF entry with nhList
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
- fibManager.updateRoutePathForFibEntry(vpnRd, prefix,
- srcTepIp, label, true, TransactionAdapter.toWriteTransaction(writeConfigTxn));
+ fibManager.updateRoutePathForFibEntry(vpnRd, prefix, srcTepIp, label, true,
+ writeConfigTxn);
LOG.info("updateVpnInterfaceOnTepAdd: Exported route with rd {} prefix {} nhList {} label {}"
+ " interface {} dpn {} from vpn {} to VPN {} vpnRd {}", rd, prefix, nhList, label,
vpnInterface.getName(), srcDpnId, vpnName,
prefix, nhList, vpnName,
vpnId, rd, vpnInterface.getName());
// Update the VRF entry with removed nextHop
- fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp,
- label, false, TransactionAdapter.toWriteTransaction(writeConfigTxn));
+ fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp, label, false,
+ writeConfigTxn);
//Get the list of VPN's importing this route(prefix) .
// Then update the VRF entry with nhList
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
- fibManager.updateRoutePathForFibEntry(vpnRd, prefix,
- srcTepIp, label, false, TransactionAdapter.toWriteTransaction(writeConfigTxn));
+ fibManager.updateRoutePathForFibEntry(vpnRd, prefix, srcTepIp, label, false,
+ writeConfigTxn);
LOG.info("updateVpnInterfaceOnTepDelete: Exported route with rd {} prefix {} nhList {}"
+ " label {} interface {} dpn {} from vpn {} to VPN {} vpnRd {}", rd, prefix,
nhList, label, vpnInterface.getName(), srcDpnId,
try {
optVpnInterface = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, interfaceId);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("remove: Failed to read data store for interface {} vpn {}",
interfaceName, vpnName);
return;
+ " Removing it.", interfaceName, vpnName, dpnId);
writeOperTxn.delete(identifier);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("removeAdjacenciesFromVpn: Failed to read data store for interface {} dpn {} vpn {}",
interfaceName, dpnId, vpnName);
}
gwPort.getMacAddress(), ipAddress, ifName, vpnName);
return Optional.of(gwPort.getMacAddress());
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
- protected void update(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface original,
+ public void update(final InstanceIdentifier<VpnInterface> identifier, final VpnInterface original,
final VpnInterface update) {
LOG.trace("Received VpnInterface update event: original={}, update={}", original, update);
LOG.info("update: VPN Interface update event - intfName {} on dpn {} oldVpn {} newVpn {}", update.getName(),
}
LOG.info("updateLabelMapper: Updated label rotue info for label {} with nextHopList {}", label,
nextHopIpList);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("updateLabelMapper: Failed to read data store for label {} nexthopList {}", label,
nextHopIpList);
} catch (TransactionCommitFailedException e) {
currVpnIntf.getGatewayMacAddress(), currVpnIntf.getGatewayIpAddress());
writeOperTxn.merge(identifier, newVpnIntf, CREATE_MISSING_PARENTS);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("addNewAdjToVpnInterface: Failed to read data store for interface {} dpn {} vpn {} rd {} ip "
+ "{}", interfaceName, dpnId, configVpnName, primaryRd, adj.getIpAddress());
}
+ "unavailable dpnId {} adjIP {} rd {}", dpnId, adj.getIpAddress(), adj.getVrfId());
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("delAdjFromVpnInterface: Failed to read data store for ip {} interface {} dpn {} vpn {}",
adj.getIpAddress(), interfaceName, dpnId, vpnName);
}
}
});
});
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("updateVpnInterfacesForUnProcessAdjancencies: Failed to read data store for vpn {} rd {}",
vpnName, primaryRd);
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInterfaceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnInterfaceOpListener extends AsyncDataTreeChangeListenerBase<VpnInterfaceOpDataEntry,
- VpnInterfaceOpListener> {
+public class VpnInterfaceOpListener extends AbstractAsyncDataTreeChangeListener<VpnInterfaceOpDataEntry> {
private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceOpListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
public VpnInterfaceOpListener(final DataBroker dataBroker, final VpnInterfaceManager vpnInterfaceManager,
final VpnFootprintService vpnFootprintService, final JobCoordinator jobCoordinator,
final VpnUtil vpnUtil) {
- super(VpnInterfaceOpDataEntry.class, VpnInterfaceOpListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VpnInterfaceOpData.class)
+ .child(VpnInterfaceOpDataEntry.class),
+ org.opendaylight.infrautils.utils.concurrent.Executors
+ .newListeningSingleThreadExecutor("VpnInterfaceOpListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.vpnInterfaceManager = vpnInterfaceManager;
this.vpnFootprintService = vpnFootprintService;
this.jobCoordinator = jobCoordinator;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<VpnInterfaceOpDataEntry> getWildCardPath() {
- InstanceIdentifier<VpnInterfaceOpDataEntry> id = InstanceIdentifier.create(VpnInterfaceOpData.class
- ).child(VpnInterfaceOpDataEntry.class);
- return id;
+ @PreDestroy
+ public void close() {
+ super.close();
+ org.opendaylight.infrautils.utils.concurrent.Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected VpnInterfaceOpListener getDataTreeChangeListener() {
- return VpnInterfaceOpListener.this;
- }
-
-
- @Override
- protected void remove(final InstanceIdentifier<VpnInterfaceOpDataEntry> identifier,
+ public void remove(final InstanceIdentifier<VpnInterfaceOpDataEntry> identifier,
final VpnInterfaceOpDataEntry del) {
final VpnInterfaceOpDataEntryKey key = identifier.firstKeyOf(VpnInterfaceOpDataEntry.class);
final String interfaceName = key.getName();
}
@Override
- protected void update(final InstanceIdentifier<VpnInterfaceOpDataEntry> identifier,
+ public void update(final InstanceIdentifier<VpnInterfaceOpDataEntry> identifier,
final VpnInterfaceOpDataEntry original, final VpnInterfaceOpDataEntry update) {
LOG.info("update: interface {} vpn {}", original.getName(), original.getVpnInstanceName());
}
@Override
- protected void add(InstanceIdentifier<VpnInterfaceOpDataEntry> identifier, VpnInterfaceOpDataEntry add) {
+ public void add(InstanceIdentifier<VpnInterfaceOpDataEntry> identifier, VpnInterfaceOpDataEntry add) {
LOG.info("add: interface {} vpn {}. Ignoring", add.getName(), add.getVpnInstanceName());
}
}
*/
package org.opendaylight.netvirt.vpnmanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput.ArpReponderInputBuilder;
LOG.trace("isVPNConfigured: No VPNs configured.");
return false;
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
throw new RuntimeException("Error reading VPN " + vpnsIdentifier, e);
}
LOG.trace("isVPNConfigured: VPNs are configured on the system.");
}
}
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("doesExistingVpnsHaveConflictingSubnet: Failed to read route targets to subnet"
+ "association for rt {} type {} subnet-cidr {}", routerTarget.getRt(),
RouteTarget.RtType.ERT, subnetCidr);
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.matches.MatchArpOp;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.config.rev161130.VpnConfig;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnNodeListener extends AsyncClusteredDataTreeChangeListenerBase<Node, VpnNodeListener> {
+public class VpnNodeListener extends AbstractAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(VpnNodeListener.class);
private static final String FLOWID_PREFIX = "L3.";
@Inject
public VpnNodeListener(DataBroker dataBroker, IMdsalApiManager mdsalManager, JobCoordinator jobCoordinator,
VpnConfig vpnConfig) {
- super(Node.class, VpnNodeListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class),
+ Executors.newListeningSingleThreadExecutor("VpnNodeListener", LOG));
this.broker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.jobCoordinator = jobCoordinator;
this.connectedDpnIds = new CopyOnWriteArrayList<>();
this.vpnConfig = vpnConfig;
+ start();
}
- @PostConstruct
public void start() {
- registerListener(LogicalDatastoreType.OPERATIONAL, broker);
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected VpnNodeListener getDataTreeChangeListener() {
- return VpnNodeListener.this;
- }
-
- @Override
- protected void add(InstanceIdentifier<Node> identifier, Node add) {
+ public void add(InstanceIdentifier<Node> identifier, Node add) {
Uint64 dpId = MDSALUtil.getDpnIdFromNodeName(add.getId());
if (!connectedDpnIds.contains(dpId)) {
connectedDpnIds.add(dpId);
}
@Override
- protected void remove(InstanceIdentifier<Node> identifier, Node del) {
+ public void remove(InstanceIdentifier<Node> identifier, Node del) {
Uint64 dpId = MDSALUtil.getDpnIdFromNodeName(del.getId());
connectedDpnIds.remove(dpId);
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
}
public boolean isConnectedNode(Uint64 nodeId) {
import static java.util.Collections.emptyList;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnOpStatusListener extends AsyncDataTreeChangeListenerBase<VpnInstanceOpDataEntry, VpnOpStatusListener> {
+public class VpnOpStatusListener extends AbstractAsyncDataTreeChangeListener<VpnInstanceOpDataEntry> {
private static final Logger LOG = LoggerFactory.getLogger(VpnOpStatusListener.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
final IdManagerService idManager, final IFibManager fibManager,
final IMdsalApiManager mdsalManager, final VpnFootprintService vpnFootprintService,
final JobCoordinator jobCoordinator, VpnUtil vpnUtil) {
- super(VpnInstanceOpDataEntry.class, VpnOpStatusListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VpnInstanceOpData.class)
+ .child(VpnInstanceOpDataEntry.class), Executors
+ .newListeningSingleThreadExecutor("VpnOpStatusListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.bgpManager = bgpManager;
this.vpnFootprintService = vpnFootprintService;
this.jobCoordinator = jobCoordinator;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<VpnInstanceOpDataEntry> getWildCardPath() {
- return InstanceIdentifier.create(VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
- @Override
- protected VpnOpStatusListener getDataTreeChangeListener() {
- return VpnOpStatusListener.this;
- }
@Override
- protected void remove(InstanceIdentifier<VpnInstanceOpDataEntry> identifier, VpnInstanceOpDataEntry value) {
+ public void remove(InstanceIdentifier<VpnInstanceOpDataEntry> identifier, VpnInstanceOpDataEntry value) {
LOG.info("remove: Ignoring vpn Op {} with rd {}", value.getVpnInstanceName(), value.getVrfId());
}
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void update(InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
+ public void update(InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
LOG.info("update: Processing update for vpn {} with rd {}", update.getVpnInstanceName(), update.getVrfId());
if (update.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete
}
InstanceIdentifier<Vpn> vpnToExtraroute =
VpnExtraRouteHelper.getVpnToExtrarouteVpnIdentifier(vpnName);
- Optional<Vpn> optVpnToExtraroute = Optional.absent();
+ Optional<Vpn> optVpnToExtraroute = Optional.empty();
try {
optVpnToExtraroute = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("update: Failed to read VpnToExtraRoute for vpn {}", vpnName);
}
if (optVpnToExtraroute.isPresent()) {
vpnUtil.removeExternalTunnelDemuxFlows(vpnName);
}
// Clean up PrefixToInterface Operational DS
- Optional<VpnIds> optPrefixToIntf = Optional.absent();
+ Optional<VpnIds> optPrefixToIntf = Optional.empty();
try {
optPrefixToIntf = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, VpnUtil.getPrefixToInterfaceIdentifier(vpnId));
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("update: Failed to read PrefixToInterface for vpn {}", vpnName);
}
if (optPrefixToIntf.isPresent()) {
// Clean up L3NextHop Operational DS
InstanceIdentifier<VpnNexthops> vpnNextHops = InstanceIdentifier.builder(L3nexthop.class).child(
VpnNexthops.class, new VpnNexthopsKey(vpnId)).build();
- Optional<VpnNexthops> optL3nexthopForVpnId = Optional.absent();
+ Optional<VpnNexthops> optL3nexthopForVpnId = Optional.empty();
try {
optL3nexthopForVpnId = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, vpnNextHops);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("update: Failed to read VpnNextHops for vpn {}", vpnName);
}
if (optL3nexthopForVpnId.isPresent()) {
}
@Override
- protected void add(final InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
+ public void add(final InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
final VpnInstanceOpDataEntry value) {
LOG.debug("add: Ignoring vpn Op {} with rd {}", value.getVpnInstanceName(), value.getVrfId());
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.Optional;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-public class VpnServiceElanDpnInterfacesListener
- extends AsyncDataTreeChangeListenerBase<DpnInterfaces, VpnServiceElanDpnInterfacesListener> {
+public class VpnServiceElanDpnInterfacesListener extends AbstractAsyncDataTreeChangeListener<DpnInterfaces> {
private static final Logger LOG = LoggerFactory.getLogger(VpnServiceElanDpnInterfacesListener.class);
private final DataBroker dataBroker;
@Inject
public VpnServiceElanDpnInterfacesListener(final DataBroker dataBroker, final IInterfaceManager interfaceManager,
final IFibManager fibManager,final JobCoordinator jobCoordinator, VpnUtil vpnUtil) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(ElanDpnInterfaces.class)
+ .child(ElanDpnInterfacesList.class).child(DpnInterfaces.class),
+ Executors.newListeningSingleThreadExecutor("VpnServiceElanDpnInterfacesListener", LOG));
this.dataBroker = dataBroker;
this.interfaceManager = interfaceManager;
this.fibManager = fibManager;
this.jobCoordinator = jobCoordinator;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- public InstanceIdentifier<DpnInterfaces> getWildCardPath() {
- return InstanceIdentifier.builder(ElanDpnInterfaces.class).child(ElanDpnInterfacesList.class)
- .child(DpnInterfaces.class).build();
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
+
@Override
- protected void remove(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
+ public void remove(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
}
@Override
- protected void update(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces original,
+ public void update(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces original,
DpnInterfaces update) {
LOG.info("received Dpninterfaces update event for dpn {}", update.getDpId());
Uint64 dpnId = update.getDpId();
}
@Override
- protected void add(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
+ public void add(InstanceIdentifier<DpnInterfaces> identifier, DpnInterfaces dpnInterfaces) {
Uint64 dpnId = dpnInterfaces.getDpId();
String elanInstanceName = identifier.firstKeyOf(ElanDpnInterfacesList.class).getElanInstanceName();
ElanInstance elanInstance = vpnUtil.getElanInstanceByName(elanInstanceName);
vpnUtil.addRouterPortToElanForVlanInDpn(vpnName, dpnId);
}
- @Override
- protected VpnServiceElanDpnInterfacesListener getDataTreeChangeListener() {
- return VpnServiceElanDpnInterfacesListener.this;
- }
-
-
public static List<String> getUpdatedInterfaceList(List<String> updatedInterfaceList,
List<String> currentInterfaceList) {
if (updatedInterfaceList == null) {
*/
package org.opendaylight.netvirt.vpnmanager;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
LOG.error("{} onSubnetAddedToVpn: Unable to handle subnet {} with ip {} added to vpn {}", LOGGING_PREFIX,
subnetId.getValue(), subnetIp, vpnName, e);
return;
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onSubnetAddedToVpn: Failed to read data store for subnet {} ip {} vpn {}", LOGGING_PREFIX,
subnetId, subnetIp, vpnName);
return;
} catch (RuntimeException e) {
LOG.error("{} onSubnetAddedToVpn: Unable to handle subnet {} with ip {} added to vpn {}", LOGGING_PREFIX,
subnetId.getValue(), subnetIp, vpnName, e);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onSubnetAddedToVpn: Failed to read data store for subnet {} ip {} vpn {}", LOGGING_PREFIX,
subnetId, subnetIp, vpnName);
} catch (TransactionCommitFailedException ex) {
LOG.error("{} onSubnetDeletedFromVpn: Removal of SubnetOpDataEntry for subnet {} subnetIp {}"
+ " vpnId {} failed", LOGGING_PREFIX, subnetId.getValue(), subnetmap.getSubnetIp(),
subnetmap.getVpnId(), ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onSubnetDeletedFromVpn: Failed to read data store for subnet {} ip {} vpn {}",
LOGGING_PREFIX, subnetId, subnetmap.getSubnetIp(), subnetmap.getVpnId());
} finally {
}
LOG.info("{} onSubnetUpdatedInVpn: subnet {} with Ip {} updated successfully for vpn {}", LOGGING_PREFIX,
subnetId.getValue(), subnetIp, vpnName);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("onSubnetUpdatedInVpn: Failed to read data store for subnet{} ip {} elanTag {} vpn {}",subnetId,
subnetIp, elanTag, vpnName);
}
} catch (RuntimeException e) { //TODO: Avoid this
LOG.error("{} onPortAddedToSubnet: Unable to handle port {} added to subnet {}", LOGGING_PREFIX,
portId.getValue(), subnetId.getValue(), e);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onPortAddedToSubnet: Failed to read data store for port {} subnet {}", LOGGING_PREFIX,
portId, subnetId);
} catch (TransactionCommitFailedException e) {
} catch (RuntimeException e) {
LOG.error("{} onPortRemovedFromSubnet: Unable to handle port {} removed from subnet {}", LOGGING_PREFIX,
portId.getValue(), subnetId.getValue(), e);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onPortRemovedFromSubnet: Failed to read data store for port {} subnet {}", LOGGING_PREFIX,
portId, subnetId);
} catch (TransactionCommitFailedException e) {
} catch (RuntimeException e) {
LOG.error("{} onInterfaceUp: Unable to handle interface up event for port {} in subnet {}",
LOGGING_PREFIX, intfName, subnetId.getValue(), e);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onInterfaceUp: Failed to read data store for interface {} dpn {} subnet {}", LOGGING_PREFIX,
intfName, dpnId, subnetId);
} catch (TransactionCommitFailedException e) {
} catch (RuntimeException e) { //TODO: Remove RuntimeException
LOG.error("{} onInterfaceDown: Unable to handle interface down event for port {} in subnet {}",
LOGGING_PREFIX, interfaceName, subnetId.getValue(), e);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} onInterfaceDown: Failed to read data store for interface {} dpn {} subnet {}",
LOGGING_PREFIX, interfaceName, dpnId, subnetId.getValue(), e);
} catch (TransactionCommitFailedException ex) {
} catch (TransactionCommitFailedException ex) {
LOG.error("{} updateSubnetRouteOnTunnelUpEvent: Failed to update subnetRoute for subnet {} on dpn {}",
LOGGING_PREFIX, subnetId.getValue(), dpnId.toString(), ex);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} updateSubnetRouteOnTunnelUpEvent: Failed to read data store for subnet {} on dpn {}",
LOGGING_PREFIX, subnetId.getValue(), dpnId.toString(), e);
}
} catch (RuntimeException e) {
LOG.error("{} updateSubnetRouteOnTunnelDownEvent: Unable to handle tunnel down event for subnetId {}"
+ " dpnId {}", LOGGING_PREFIX, subnetId.getValue(), dpnId.toString(), e);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("{} Failed to read data store for subnet {} dpn {}", LOGGING_PREFIX, subnetId, dpnId);
} catch (TransactionCommitFailedException e) {
LOG.error("{} updateSubnetRouteOnTunnelDownEvent: Updation of SubnetOpDataEntry for subnet {}"
import static java.util.Collections.emptyList;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterators;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.FutureCallback;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
}
return read(LogicalDatastoreType.CONFIGURATION, VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName))
- .toJavaUtil().map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
+ .map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
.vpn.instance.to.vpn.id.VpnInstance::getVpnId)
.orElse(VpnConstants.INVALID_ID);
}
public static String getVpnRd(TypedReadTransaction<Configuration> confTx, String vpnName) {
try {
- return confTx.read(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName)).get().toJavaUtil().map(
+ return confTx.read(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName)).get().map(
vpnInstance -> vpnInstance.getVrfId()).orElse(null);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
@Nullable
public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
- return read(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(rd)).orNull();
+ return read(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(rd)).orElse(null);
}
@Nullable
public Optional<List<String>> getVpnHandlingIpv4AssociatedWithInterface(String interfaceName) {
InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
- Optional<List<String>> vpnOptional = Optional.absent();
+ Optional<List<String>> vpnOptional = Optional.empty();
Optional<VpnInterface> optConfiguredVpnInterface = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
if (optConfiguredVpnInterface.isPresent()) {
VpnInterface cfgVpnInterface = optConfiguredVpnInterface.get();
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
try {
return SingleTransactionDataBroker.syncReadOptional(dataBroker, datastoreType, path);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
}
String vpnName, String fixedIp) {
InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
try {
- return confTx.read(id).get().orNull();
+ return confTx.read(id).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
throws ExecutionException, InterruptedException {
InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(Routers.class,
new RoutersKey(routerId)).build();
- return tx.read(id).get().orNull();
+ return tx.read(id).get().orElse(null);
}
static InstanceIdentifier<Subnetmaps> buildSubnetMapsWildCardPath() {
}
public Optional<IpAddress> getGatewayIpAddressFromInterface(MacEntry macEntry) {
- Optional<IpAddress> gatewayIp = Optional.absent();
+ Optional<IpAddress> gatewayIp = Optional.empty();
String srcInterface = macEntry.getInterfaceName();
InetAddress hiddenIp = macEntry.getIpAddress();
if (neutronVpnService != null) {
}
public Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp) {
- Optional<String> gatewayMac = Optional.absent();
+ Optional<String> gatewayMac = Optional.empty();
Uint32 vpnId = getVpnId(macEntry.getVpnName());
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
.instance.VpnIds>
}
public Optional<String> getVpnSubnetGatewayIp(final Uuid subnetUuid) {
- Optional<String> gwIpAddress = Optional.absent();
+ Optional<String> gwIpAddress = Optional.empty();
final SubnetKey subnetkey = new SubnetKey(subnetUuid);
final InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
.child(Subnets.class)
InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class).child(
org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks.class).child(
Network.class, new NetworkKey(networkId));
- return read(LogicalDatastoreType.CONFIGURATION, inst).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, inst).orElse(null);
}
public static boolean isEligibleForBgp(@Nullable String rd, @Nullable String vpnName, @Nullable Uint64 dpnId,
void removeExternalTunnelDemuxFlows(String vpnName) {
LOG.info("Removing external tunnel flows for vpn {}", vpnName);
- for (Uint64 dpnId: NWUtil.getOperativeDPNs(dataBroker)) {
- LOG.debug("Removing external tunnel flows for vpn {} from dpn {}", vpnName, dpnId);
- String flowRef = getFibFlowRef(dpnId, NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
- vpnName, VpnConstants.DEFAULT_FLOW_PRIORITY);
- FlowEntity flowEntity = VpnUtil.buildFlowEntity(dpnId,
- NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, flowRef);
- mdsalManager.removeFlow(flowEntity);
+ try {
+ for (Uint64 dpnId: NWUtil.getOperativeDPNs(dataBroker)) {
+ LOG.debug("Removing external tunnel flows for vpn {} from dpn {}", vpnName, dpnId);
+ String flowRef = getFibFlowRef(dpnId, NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
+ vpnName, VpnConstants.DEFAULT_FLOW_PRIORITY);
+ FlowEntity flowEntity = VpnUtil.buildFlowEntity(dpnId,
+ NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, flowRef);
+ mdsalManager.removeFlow(flowEntity);
+ }
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeExternalTunnelDemuxFlows: Exception while removing external tunnel flows for vpn {}",
+ vpnName, e);
}
}
@Nullable
public Subnetmap getSubnetmapFromItsUuid(Uuid subnetUuid) {
InstanceIdentifier<Subnetmap> id = buildSubnetmapIdentifier(subnetUuid);
- return read(LogicalDatastoreType.CONFIGURATION, id).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, id).orElse(null);
}
boolean isAdjacencyEligibleToVpnInternet(Adjacency adjacency) {
@Nullable
ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName) {
InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
- return read(LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orElse(null);
}
static InstanceIdentifier<ElanInterface> getElanInterfaceConfigurationDataPathId(String interfaceName) {
DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, Uint64 dpId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
dpId);
- return read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
+ return read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orElse(null);
}
@Nullable
ElanInstance getElanInstanceByName(String elanInstanceName) {
InstanceIdentifier<ElanInstance> elanIdentifierId =
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName);
- return read(LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orElse(null);
}
@Nullable
} else {
LOG.error("getRtListForVpn: Vpn Instance {} not present in config DS", vpnName);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getRtListForVpn: Read failed for Vpn Instance {}", vpnName);
}
return rtList;
*/
package org.opendaylight.netvirt.vpnmanager.arp.responder;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.NWUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput.ArpReponderInputBuilder;
import org.opendaylight.netvirt.elan.arp.responder.ArpResponderUtil;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
this.interVpnLinkUtil = interVpnLinkUtil;
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
}
private Map<String, String> buildRouterXL3VPNMap() {
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
- Optional<VpnMaps> optVpnMaps =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
+ Optional<VpnMaps> optVpnMaps = Optional.empty();
+ try {
+ optVpnMaps = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ vpnMapsIdentifier);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("buildRouterXL3VPNMap: Exception while reading VpnMaps DS", e);
+ }
if (!optVpnMaps.isPresent()) {
LOG.info("Could not retrieve VpnMaps object from Configurational DS");
return new HashMap<>();
// Retrieving all Routers
InstanceIdentifier<Routers> routersIid = InstanceIdentifier.builder(Neutron.class)
.child(Routers.class).build();
- Optional<Routers> routerOpData = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routersIid);
+ Optional<Routers> routerOpData = Optional.empty();
+ try {
+ routerOpData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, routersIid);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("handleStaticRoutes: Exception while reading routers DS", e);
+ }
if (!routerOpData.isPresent()) {
-
return;
}
List<Router> routers = routerOpData.get().nonnullRouter();
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* caches updated.
*/
@Singleton
-public class InterVpnLinkCacheFeeder
- extends AsyncClusteredDataTreeChangeListenerBase<InterVpnLink, InterVpnLinkCacheFeeder> {
+public class InterVpnLinkCacheFeeder extends AbstractClusteredAsyncDataTreeChangeListener<InterVpnLink> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkCacheFeeder.class);
@Inject
public InterVpnLinkCacheFeeder(final DataBroker dataBroker, final InterVpnLinkCache interVpnLinkCache) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(InterVpnLinks.class)
+ .child(InterVpnLink.class), Executors
+ .newListeningSingleThreadExecutor("InterVpnLinkCacheFeeder", LOG));
this.dataBroker = dataBroker;
this.interVpnLinkCache = interVpnLinkCache;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected void remove(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink del) {
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
+
+ @Override
+ public void remove(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink del) {
interVpnLinkCache.removeInterVpnLinkFromCache(del);
}
@Override
- protected void update(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink original, InterVpnLink update) {
+ public void update(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink original, InterVpnLink update) {
// TODO Auto-generated method stub
}
@Override
- protected void add(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink add) {
+ public void add(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink add) {
LOG.debug("Added interVpnLink {} with vpn1={} and vpn2={}", add.getName(),
add.getFirstEndpoint().getVpnUuid(), add.getSecondEndpoint().getVpnUuid());
interVpnLinkCache.addInterVpnLinkToCaches(add);
}
- @Override
- protected InstanceIdentifier<InterVpnLink> getWildCardPath() {
- return InstanceIdentifier.create(InterVpnLinks.class).child(InterVpnLink.class);
- }
-
- @Override
- protected InterVpnLinkCacheFeeder getDataTreeChangeListener() {
- return this;
- }
-
}
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkStates;
public void initialFeed() {
// Read all InterVpnLinks and InterVpnLinkStates from MD-SAL.
InstanceIdentifier<InterVpnLinks> interVpnLinksIid = InstanceIdentifier.builder(InterVpnLinks.class).build();
-
- Optional<InterVpnLinks> optIVpnLinksOpData =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, interVpnLinksIid);
-
- if (!optIVpnLinksOpData.isPresent()) {
- return; // Nothing to be added to cache
- }
- InterVpnLinks interVpnLinks = optIVpnLinksOpData.get();
- for (InterVpnLink interVpnLink : interVpnLinks.nonnullInterVpnLink()) {
- addInterVpnLinkToCaches(interVpnLink);
- }
-
- // Now the States
- InstanceIdentifier<InterVpnLinkStates> interVpnLinkStateIid =
- InstanceIdentifier.builder(InterVpnLinkStates.class).build();
-
- Optional<InterVpnLinkStates> optIVpnLinkStateOpData =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, interVpnLinkStateIid);
- if (!optIVpnLinkStateOpData.isPresent()) {
- return;
- }
- InterVpnLinkStates interVpnLinkStates = optIVpnLinkStateOpData.get();
- for (InterVpnLinkState interVpnLinkState : interVpnLinkStates.nonnullInterVpnLinkState()) {
- addInterVpnLinkStateToCaches(interVpnLinkState);
+ try {
+ Optional<InterVpnLinks> optIVpnLinksOpData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, interVpnLinksIid);
+ if (!optIVpnLinksOpData.isPresent()) {
+ return; // Nothing to be added to cache
+ }
+ InterVpnLinks interVpnLinks = optIVpnLinksOpData.get();
+ for (InterVpnLink interVpnLink : interVpnLinks.nonnullInterVpnLink()) {
+ addInterVpnLinkToCaches(interVpnLink);
+ }
+
+ // Now the States
+ InstanceIdentifier<InterVpnLinkStates> interVpnLinkStateIid =
+ InstanceIdentifier.builder(InterVpnLinkStates.class).build();
+
+ Optional<InterVpnLinkStates> optIVpnLinkStateOpData =
+ SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ interVpnLinkStateIid);
+ if (!optIVpnLinkStateOpData.isPresent()) {
+ return;
+ }
+ InterVpnLinkStates interVpnLinkStates = optIVpnLinkStateOpData.get();
+ for (InterVpnLinkState interVpnLinkState : interVpnLinkStates.nonnullInterVpnLinkState()) {
+ addInterVpnLinkStateToCaches(interVpnLinkState);
+ }
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("initialFeed: Exception while reading interVpnLink DS", e);
}
}
interVpnLink.getFirstEndpoint().getIpAddress(), interVpnLink.getSecondEndpoint().getVpnUuid(),
interVpnLink.getSecondEndpoint().getIpAddress());
- InterVpnLinkDataComposite interVpnLinkDataComposite = getInterVpnLinkByName(ivlName).orNull();
+ InterVpnLinkDataComposite interVpnLinkDataComposite = getInterVpnLinkByName(ivlName).orElse(null);
if (interVpnLinkDataComposite != null) {
interVpnLinkDataComposite.setInterVpnLinkConfig(interVpnLink);
} else {
LOG.debug("Adding InterVpnLinkState {} with vpn1=[{}] and vpn2=[{}]",
ivlName, interVpnLinkState.getFirstEndpointState(), interVpnLinkState.getSecondEndpointState());
- InterVpnLinkDataComposite ivl = getInterVpnLinkByName(ivlName).orNull();
+ InterVpnLinkDataComposite ivl = getInterVpnLinkByName(ivlName).orElse(null);
if (ivl != null) {
ivl.setInterVpnLinkState(interVpnLinkState);
} else {
}
private void addToEndpointCache(InterVpnLinkDataComposite interVpnLink) {
- safePut(endpointToInterVpnLinkCache, interVpnLink.getFirstEndpointIpAddr().orNull(), interVpnLink);
- safePut(endpointToInterVpnLinkCache, interVpnLink.getSecondEndpointIpAddr().orNull(), interVpnLink);
+ safePut(endpointToInterVpnLinkCache, interVpnLink.getFirstEndpointIpAddr().orElse(null), interVpnLink);
+ safePut(endpointToInterVpnLinkCache, interVpnLink.getSecondEndpointIpAddr().orElse(null), interVpnLink);
}
private void addToVpnUuidCache(InterVpnLinkDataComposite interVpnLink) {
- safePut(uuidToInterVpnLinkCache, interVpnLink.getFirstEndpointVpnUuid().orNull(), interVpnLink);
- safePut(uuidToInterVpnLinkCache, interVpnLink.getSecondEndpointVpnUuid().orNull(), interVpnLink);
+ safePut(uuidToInterVpnLinkCache, interVpnLink.getFirstEndpointVpnUuid().orElse(null), interVpnLink);
+ safePut(uuidToInterVpnLinkCache, interVpnLink.getSecondEndpointVpnUuid().orElse(null), interVpnLink);
}
private void addToIVpnLinkNameCache(InterVpnLinkDataComposite interVpnLink) {
private void removeFromVpnUuidCache(InterVpnLinkDataComposite interVpnLinkComposite) {
- safeRemove(uuidToInterVpnLinkCache, interVpnLinkComposite.getFirstEndpointVpnUuid().orNull());
- safeRemove(uuidToInterVpnLinkCache, interVpnLinkComposite.getSecondEndpointVpnUuid().orNull());
+ safeRemove(uuidToInterVpnLinkCache, interVpnLinkComposite.getFirstEndpointVpnUuid().orElse(null));
+ safeRemove(uuidToInterVpnLinkCache, interVpnLinkComposite.getSecondEndpointVpnUuid().orElse(null));
}
private void removeFromEndpointIpAddressCache(InterVpnLinkDataComposite interVpnLinkComposite) {
- safeRemove(endpointToInterVpnLinkCache, interVpnLinkComposite.getFirstEndpointIpAddr().orNull());
- safeRemove(endpointToInterVpnLinkCache, interVpnLinkComposite.getSecondEndpointIpAddr().orNull());
+ safeRemove(endpointToInterVpnLinkCache, interVpnLinkComposite.getFirstEndpointIpAddr().orElse(null));
+ safeRemove(endpointToInterVpnLinkCache, interVpnLinkComposite.getSecondEndpointIpAddr().orElse(null));
}
@Override
public Optional<InterVpnLinkDataComposite> getInterVpnLinkByName(String interVpnLinkName) {
- return Optional.fromNullable(safeGet(nameToInterVpnLinkCache, interVpnLinkName));
+ return Optional.ofNullable(safeGet(nameToInterVpnLinkCache, interVpnLinkName));
}
@Override
public Optional<InterVpnLinkDataComposite> getInterVpnLinkByEndpoint(String endpointIp) {
LOG.trace("Checking if {} is configured as an InterVpnLink endpoint", endpointIp);
- return Optional.fromNullable(safeGet(endpointToInterVpnLinkCache, endpointIp));
+ return Optional.ofNullable(safeGet(endpointToInterVpnLinkCache, endpointIp));
}
@Override
public Optional<InterVpnLinkDataComposite> getInterVpnLinkByVpnId(String vpnId) {
- return Optional.fromNullable(safeGet(uuidToInterVpnLinkCache, vpnId));
+ return Optional.ofNullable(safeGet(uuidToInterVpnLinkCache, vpnId));
}
@Override
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks.InterVpnLinkCleanedCheckerTask;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks.InterVpnLinkCreatorTask;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks.InterVpnLinkRemoverTask;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.slf4j.LoggerFactory;
@Singleton
-public class InterVpnLinkListener extends AsyncDataTreeChangeListenerBase<InterVpnLink, InterVpnLinkListener> {
+public class InterVpnLinkListener extends AbstractAsyncDataTreeChangeListener<InterVpnLink> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkListener.class);
final JobCoordinator jobCoordinator,
final InterVpnLinkCache interVpnLinkCache, final VpnUtil vpnUtil,
final InterVpnLinkUtil interVpnLinkUtil) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(InterVpnLinks.class)
+ .child(InterVpnLink.class),
+ Executors.newListeningSingleThreadExecutor("InterVpnLinkListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.idManager = idManager;
this.interVpnLinkUtil = interVpnLinkUtil;
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<InterVpnLink> getWildCardPath() {
- return InstanceIdentifier.create(InterVpnLinks.class).child(InterVpnLink.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InterVpnLinkListener getDataTreeChangeListener() {
- return InterVpnLinkListener.this;
- }
-
- @Override
- protected void add(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink add) {
+ public void add(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink add) {
String ivpnLinkName = add.getName();
LOG.debug("Reacting to IVpnLink {} creation. Vpn1=[name={} EndpointIp={}] Vpn2=[name={} endpointIP={}]",
}
@Override
- protected void remove(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink del) {
+ public void remove(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink del) {
LOG.debug("Reacting to InterVpnLink {} removal", del.getName());
}
@Override
- protected void update(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink original, InterVpnLink update) {
+ public void update(InstanceIdentifier<InterVpnLink> identifier, InterVpnLink original, InterVpnLink update) {
LOG.debug("Update InterVpnLink {}. "
+ " original=[1stEndpoint=[vpn=<{}> ipAddr=<{}>] 2ndEndpoint=[vpn=<{}> ipAddr=<{}>]]"
import java.util.List;
import java.util.Objects;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.mdsalutil.NWUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
*/
public List<Uint64> selectSuitableDpns(InterVpnLink interVpnLink) {
int numberOfDpns = Integer.getInteger(NBR_OF_DPNS_PROPERTY_NAME, 1);
- List<Uint64> dpnIdPool = NWUtil.getOperativeDPNs(dataBroker).stream()
- .map(dpn -> dpn)
- .collect(Collectors.toList());
+ List<Uint64> dpnIdPool = new ArrayList<>();
+ try {
+ dpnIdPool = NWUtil.getOperativeDPNs(dataBroker).stream().map(dpn -> dpn).collect(Collectors.toList());
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("selectSuitableDpns: Exception while reading Operative DPNs", e);
+ }
LOG.trace("selectSuitableDpns for {} with numberOfDpns={} and availableDpns={}",
interVpnLink.getName(), numberOfDpns, dpnIdPool);
int poolSize = dpnIdPool.size();
if (ivl.getInterVpnLinkName().equals(ivpnLinkToMatch.getName())) {
return false; // ivl and ivpnLinlToMatch are the same InterVpnLink
}
- String vpn1Name = ivl.getFirstEndpointVpnUuid().orNull();
- String vpn2Name = ivl.getSecondEndpointVpnUuid().orNull();
+ String vpn1Name = ivl.getFirstEndpointVpnUuid().orElse(null);
+ String vpn2Name = ivl.getSecondEndpointVpnUuid().orElse(null);
if (vpn1Name == null) {
return false;
}
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.vpnmanager.VpnFootprintService;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
* there are no DPNs connected to controller by the time the InterVpnLink is
* created.
*/
-public class InterVpnLinkNodeAddTask implements Callable<List<ListenableFuture<Void>>> {
+public class InterVpnLinkNodeAddTask implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkNodeAddTask.class);
private static final String NBR_OF_DPNS_PROPERTY_NAME = "vpnservice.intervpnlink.number.dpns";
import java.math.BigInteger;
import java.util.List;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.VpnFootprintService;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks.InterVpnLinkCleanedCheckerTask;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks.InterVpnLinkCreatorTask;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks.InterVpnLinkRemoverTask;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
* moved to some other DPN.
*/
@Singleton
-public class InterVpnLinkNodeListener extends AsyncDataTreeChangeListenerBase<Node, InterVpnLinkNodeListener> {
+public class InterVpnLinkNodeListener extends AbstractAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkNodeListener.class);
public static final TopologyId FLOW_TOPOLOGY_ID = new TopologyId(new Uri("flow:1"));
final VpnFootprintService vpnFootprintService,
final JobCoordinator jobCoordinator, final InterVpnLinkCache interVpnLinkCache,
VpnUtil vpnUtil, InterVpnLinkUtil interVpnLinkUtil) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(FLOW_TOPOLOGY_ID))
+ .child(Node.class), Executors.newListeningSingleThreadExecutor("InterVpnLinkNodeListener",
+ LOG));
this.dataBroker = dataBroker;
this.mdsalManager = mdsalMgr;
this.vpnFootprintService = vpnFootprintService;
this.interVpnLinkUtil = interVpnLinkUtil;
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
- protected InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(FLOW_TOPOLOGY_ID))
- .child(Node.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InterVpnLinkNodeListener getDataTreeChangeListener() {
- return InterVpnLinkNodeListener.this;
- }
-
- @Override
- protected void add(InstanceIdentifier<Node> identifier, Node add) {
+ public void add(InstanceIdentifier<Node> identifier, Node add) {
NodeId nodeId = add.getNodeId();
String[] node = nodeId.getValue().split(":");
if (node.length < 2) {
}
@Override
- protected void remove(InstanceIdentifier<Node> identifier, Node del) {
+ public void remove(InstanceIdentifier<Node> identifier, Node del) {
LOG.trace("Node {} has been deleted", identifier.firstKeyOf(Node.class).toString());
NodeId nodeId = del.getNodeId();
String[] node = nodeId.getValue().split(":");
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
}
}
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkStates;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* InterVpnLinkState changes.
*/
@Singleton
-public class InterVpnLinkStateCacheFeeder
- extends AsyncClusteredDataTreeChangeListenerBase<InterVpnLinkState, InterVpnLinkStateCacheFeeder> {
+public class InterVpnLinkStateCacheFeeder extends AbstractClusteredAsyncDataTreeChangeListener<InterVpnLinkState> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkStateCacheFeeder.class);
@Inject
public InterVpnLinkStateCacheFeeder(final DataBroker dataBroker, final InterVpnLinkCache interVpnLinkCache) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(InterVpnLinkStates.class)
+ .child(InterVpnLinkState.class),
+ Executors.newListeningSingleThreadExecutor("InterVpnLinkStateCacheFeeder", LOG));
this.dataBroker = dataBroker;
this.interVpnLinkCache = interVpnLinkCache;
}
- @PostConstruct
public void init() {
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ LOG.info("{} start", getClass().getSimpleName());
}
@Override
- protected void remove(InstanceIdentifier<InterVpnLinkState> identifier, InterVpnLinkState del) {
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
+ }
+
+ @Override
+ public void remove(InstanceIdentifier<InterVpnLinkState> identifier, InterVpnLinkState del) {
LOG.debug("InterVpnLinkState {} has been removed", del.getInterVpnLinkName());
interVpnLinkCache.removeInterVpnLinkStateFromCache(del);
}
@Override
- protected void update(InstanceIdentifier<InterVpnLinkState> identifier, InterVpnLinkState original,
+ public void update(InstanceIdentifier<InterVpnLinkState> identifier, InterVpnLinkState original,
InterVpnLinkState update) {
LOG.debug("InterVpnLinkState {} has been updated", update.getInterVpnLinkName());
interVpnLinkCache.addInterVpnLinkStateToCaches(update);
}
@Override
- protected void add(InstanceIdentifier<InterVpnLinkState> identifier, InterVpnLinkState add) {
+ public void add(InstanceIdentifier<InterVpnLinkState> identifier, InterVpnLinkState add) {
LOG.debug("InterVpnLinkState {} has been added", add.getInterVpnLinkName());
interVpnLinkCache.addInterVpnLinkStateToCaches(add);
}
- @Override
- protected InstanceIdentifier<InterVpnLinkState> getWildCardPath() {
- return InstanceIdentifier.create(InterVpnLinkStates.class).child(InterVpnLinkState.class);
- }
-
- @Override
- protected InterVpnLinkStateCacheFeeder getDataTreeChangeListener() {
- return this;
- }
-
}
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
+import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.IVpnLinkService;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkStates;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* specially for when the InterVpnLink becomes active.
*/
@Singleton
-public class InterVpnLinkStateListener
- extends AsyncDataTreeChangeListenerBase<InterVpnLinkState, InterVpnLinkStateListener> {
+public class InterVpnLinkStateListener extends AbstractAsyncDataTreeChangeListener<InterVpnLinkState> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkStateListener.class);
@Inject
public InterVpnLinkStateListener(final DataBroker dataBroker, final IVpnLinkService interVpnLinkService,
final InterVpnLinkCache interVpnLinkCache) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(InterVpnLinkStates.class)
+ .child(InterVpnLinkState.class),
+ Executors.newListeningSingleThreadExecutor("InterVpnLinkStateListener", LOG));
this.dataBroker = dataBroker;
this.ivpnLinkService = interVpnLinkService;
this.interVpnLinkCache = interVpnLinkCache;
}
- @PostConstruct
public void start() {
LOG.info("{} start", getClass().getSimpleName());
- registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
}
@Override
- protected InstanceIdentifier<InterVpnLinkState> getWildCardPath() {
- return InstanceIdentifier.create(InterVpnLinkStates.class).child(InterVpnLinkState.class);
+ @PreDestroy
+ public void close() {
+ super.close();
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
@Override
- protected InterVpnLinkStateListener getDataTreeChangeListener() {
- return InterVpnLinkStateListener.this;
- }
-
-
- @Override
- protected void remove(InstanceIdentifier<InterVpnLinkState> key, InterVpnLinkState dataObjectModification) {
+ public void remove(InstanceIdentifier<InterVpnLinkState> key, InterVpnLinkState dataObjectModification) {
}
@Override
- protected void update(InstanceIdentifier<InterVpnLinkState> key, InterVpnLinkState before,
+ public void update(InstanceIdentifier<InterVpnLinkState> key, InterVpnLinkState before,
InterVpnLinkState after) {
if (before.getState() == InterVpnLinkState.State.Error && after.getState() == InterVpnLinkState.State.Active) {
Optional<InterVpnLinkDataComposite> optIVpnLink =
@Override
- protected void add(InstanceIdentifier<InterVpnLinkState> key, InterVpnLinkState dataObjectModification) {
+ public void add(InstanceIdentifier<InterVpnLinkState> key, InterVpnLinkState dataObjectModification) {
}
}
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
* Retrieves the State of an InterVpnLink.
*
* @param interVpnLinkName The name of the InterVpnLink
- * @return the object that contains the State of the specified InterVpnLink or Optional.absent() if it doesnt exist
+ * @return the object that contains the State of the specified InterVpnLink or Optional.empty() if it doesnt exist
*/
public Optional<InterVpnLinkState> getInterVpnLinkState(String interVpnLinkName) {
- Optional<InterVpnLinkState> interVpnLinkStateOptional = Optional.absent();
+ Optional<InterVpnLinkState> interVpnLinkStateOptional = Optional.empty();
try {
interVpnLinkStateOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, getInterVpnLinkStateIid(interVpnLinkName));
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("getInterVpnLinkState: Failed to read intervpn link state for {}", interVpnLinkName);
}
return interVpnLinkStateOptional;
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeoutException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.InterVpnLinkUtil;
* InterVpnLink has been removed, like the stateful information, leaked
* vrfEntries, etc.
*/
-public class InterVpnLinkCleanedCheckerTask implements Callable<List<ListenableFuture<Void>>> {
+public class InterVpnLinkCleanedCheckerTask implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkCleanedCheckerTask.class);
private static final long MAX_WAIT_FOR_REMOVAL = 10000; // 10 seconds
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink.tasks;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.vpnmanager.intervpnlink.InterVpnLinkUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterVpnLinkCreatorTask implements Callable<List<ListenableFuture<Void>>> {
+public class InterVpnLinkCreatorTask implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkCreatorTask.class);
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterVpnLinkRemoverTask implements Callable<List<ListenableFuture<Void>>> {
+public class InterVpnLinkRemoverTask implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkRemoverTask.class);
private final InstanceIdentifier<InterVpnLink> interVpnLinkIid;
package org.opendaylight.netvirt.vpnmanager.iplearn;
-import com.google.common.base.Optional;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import org.apache.commons.lang3.tuple.ImmutablePair;
*/
package org.opendaylight.netvirt.vpnmanager.iplearn;
-import com.google.common.base.Optional;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.arputil.api.ArpConstants;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
}
private Optional<Uint32> allocateIpMonitorProfile(IpAddress targetIp) {
- Optional<Uint32> profileIdOptional = Optional.absent();
+ Optional<Uint32> profileIdOptional = Optional.empty();
if (targetIp.getIpv4Address() != null) {
profileIdOptional = allocateArpMonitorProfile();
} else if (targetIp.getIpv6Address() != null) {
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Exception when allocating profile Id", e);
}
- return Optional.absent();
+ return Optional.empty();
}
private MonitorProfileGetInput buildMonitorGetProfile(long monitorInterval, long monitorWindow,
public java.util.Optional<Uint32> getMonitorIdFromInterface(MacEntry macEntry) {
String interfaceName = macEntry.getInterfaceName();
java.util.Optional<Uint32> monitorId = java.util.Optional.empty();
- Optional<InterfaceMonitorEntry> interfaceMonitorEntryOptional = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.OPERATIONAL, getInterfaceMonitorMapId(interfaceName));
+ Optional<InterfaceMonitorEntry> interfaceMonitorEntryOptional = Optional.empty();
+ try {
+ interfaceMonitorEntryOptional = SingleTransactionDataBroker
+ .syncReadOptional(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ getInterfaceMonitorMapId(interfaceName));
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getMonitorIdFromInterface: Exception while reading Interface Monitor MapId for the "
+ + "interface {} ", interfaceName, e);
+ }
if (interfaceMonitorEntryOptional.isPresent()) {
return java.util.Optional.of(interfaceMonitorEntryOptional.get().getMonitorIds().get(0));
}
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorListener;
import java.util.concurrent.Callable;
import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
-public class IpMonitorStartTask implements Callable<List<ListenableFuture<Void>>> {
+public class IpMonitorStartTask implements Callable<List<? extends ListenableFuture<?>>> {
private final MacEntry macEntry;
private final Long arpMonitorProfileId;
private final AlivenessMonitorUtils alivenessMonitorUtils;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Callable;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class IpMonitorStopTask implements Callable<List<ListenableFuture<Void>>> {
+public class IpMonitorStopTask implements Callable<List<? extends ListenableFuture<?>>> {
private static final Logger LOG = LoggerFactory.getLogger(IpMonitorStopTask.class);
private MacEntry macEntry;
private DataBroker dataBroker;
*/
package org.opendaylight.netvirt.vpnmanager.iplearn;
-import com.google.common.base.Optional;
import java.net.InetAddress;
import java.net.UnknownHostException;
-import javax.annotation.PostConstruct;
+import java.util.Optional;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.NWUtil;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.netvirt.vpnmanager.VpnConstants;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
import org.slf4j.LoggerFactory;
@Singleton
-public class IpMonitoringHandler
- extends AsyncClusteredDataTreeChangeListenerBase<LearntVpnVipToPort, IpMonitoringHandler> {
+public class IpMonitoringHandler extends AbstractClusteredAsyncDataTreeChangeListener<LearntVpnVipToPort> {
private static final Logger LOG = LoggerFactory.getLogger(IpMonitoringHandler.class);
private final DataBroker dataBroker;
private final AlivenessMonitorService alivenessManager;
private final JobCoordinator jobCoordinator;
private final VpnUtil vpnUtil;
- private Optional<Uint32> arpMonitorProfileId = Optional.absent();
- private Optional<Uint32> ipv6NdMonitorProfileId = Optional.absent();
+ private Optional<Uint32> arpMonitorProfileId = Optional.empty();
+ private Optional<Uint32> ipv6NdMonitorProfileId = Optional.empty();
private EntityOwnershipCandidateRegistration candidateRegistration;
@Inject
INeutronVpnManager neutronVpnService, IInterfaceManager interfaceManager,
EntityOwnershipService entityOwnershipService, JobCoordinator jobCoordinator,
AlivenessMonitorUtils alivenessMonitorUtils, VpnUtil vpnUtil) {
- super(LearntVpnVipToPort.class, IpMonitoringHandler.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(LearntVpnVipToPortData.class)
+ .child(LearntVpnVipToPort.class),
+ Executors.newListeningSingleThreadExecutor("IpMonitoringHandler", LOG));
this.dataBroker = dataBroker;
this.alivenessManager = alivenessManager;
this.neutronVpnService = neutronVpnService;
this.jobCoordinator = jobCoordinator;
this.alivenessMonitorUtils = alivenessMonitorUtils;
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
+ LOG.info("{} start", getClass().getSimpleName());
this.arpMonitorProfileId = alivenessMonitorUtils.allocateArpMonitorProfile();
this.ipv6NdMonitorProfileId = alivenessMonitorUtils.allocateIpv6NaMonitorProfile();
if (this.arpMonitorProfileId == null || this.ipv6NdMonitorProfileId == null) {
LOG.error("Error while allocating ARP and IPv6 ND Profile Ids: ARP={}, IPv6ND={}", arpMonitorProfileId,
ipv6NdMonitorProfileId);
}
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
try {
candidateRegistration = entityOwnershipUtils.getEntityOwnershipService().registerCandidate(
if (candidateRegistration != null) {
candidateRegistration.close();
}
- }
-
- @Override
- protected InstanceIdentifier<LearntVpnVipToPort> getWildCardPath() {
- return InstanceIdentifier.create(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class);
- }
-
- @Override
- protected IpMonitoringHandler getDataTreeChangeListener() {
- return this;
+ Executors.shutdownAndAwaitTermination(getExecutorService());
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- protected void update(InstanceIdentifier<LearntVpnVipToPort> id, LearntVpnVipToPort value,
+ public void update(InstanceIdentifier<LearntVpnVipToPort> id, LearntVpnVipToPort value,
LearntVpnVipToPort dataObjectModificationAfter) {
runOnlyInOwnerNode("IpMonitoringHandler: update event", () -> {
try {
}
@Override
- protected void add(InstanceIdentifier<LearntVpnVipToPort> identifier, LearntVpnVipToPort value) {
+ public void add(InstanceIdentifier<LearntVpnVipToPort> identifier, LearntVpnVipToPort value) {
runOnlyInOwnerNode("IpMonitoringHandler: add event", () -> {
try {
InetAddress srcInetAddr = InetAddress.getByName(value.getPortFixedip());
}
@Override
- protected void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort value) {
+ public void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort value) {
runOnlyInOwnerNode("IpMonitoringHandler: remove event", () -> {
try {
InetAddress srcInetAddr = InetAddress.getByName(value.getPortFixedip());
*/
package org.opendaylight.netvirt.vpnmanager.iplearn;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
import org.opendaylight.netvirt.vpnmanager.VpnConstants;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventAction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventData;
@Singleton
public class LearntVpnVipToPortEventProcessor
- extends AsyncClusteredDataTreeChangeListenerBase<LearntVpnVipToPortEvent, LearntVpnVipToPortEventProcessor> {
+ extends AbstractClusteredAsyncDataTreeChangeListener<LearntVpnVipToPortEvent> {
private static final Logger LOG = LoggerFactory.getLogger(LearntVpnVipToPortEventProcessor.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
@Inject
public LearntVpnVipToPortEventProcessor(final DataBroker dataBroker, IInterfaceManager interfaceManager,
EntityOwnershipService entityOwnershipService, final JobCoordinator jobCoordinator, VpnUtil vpnUtil) {
- super(LearntVpnVipToPortEvent.class, LearntVpnVipToPortEventProcessor.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
+ .create(LearntVpnVipToPortEventData.class).child(LearntVpnVipToPortEvent.class),
+ Executors.newListeningSingleThreadExecutor("LearntVpnVipToPortEventProcessor", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.interfaceManager = interfaceManager;
this.jobCoordinator = jobCoordinator;
this.entityOwnershipUtils = new EntityOwnershipUtils(entityOwnershipService);
this.vpnUtil = vpnUtil;
+ start();
}
- @PostConstruct
public void start() {
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ LOG.info("{} start", getClass().getSimpleName());
try {
candidateRegistration = entityOwnershipUtils.getEntityOwnershipService()
.registerCandidate(new Entity(VpnConstants.IP_MONITORING_ENTITY,
}
@Override
- protected InstanceIdentifier<LearntVpnVipToPortEvent> getWildCardPath() {
- return InstanceIdentifier.create(LearntVpnVipToPortEventData.class).child(LearntVpnVipToPortEvent.class);
- }
-
- @Override
- protected LearntVpnVipToPortEventProcessor getDataTreeChangeListener() {
- return this;
- }
-
- @Override
- protected void update(InstanceIdentifier<LearntVpnVipToPortEvent> id, LearntVpnVipToPortEvent value,
+ public void update(InstanceIdentifier<LearntVpnVipToPortEvent> id, LearntVpnVipToPortEvent value,
LearntVpnVipToPortEvent dataObjectModificationAfter) {
// Updates does not make sense on an event queue .
// NOTE: DONOT ADD ANY CODE HERE AND MAKE A CIRCUS
}
@Override
- protected void add(InstanceIdentifier<LearntVpnVipToPortEvent> identifier, LearntVpnVipToPortEvent value) {
+ public void add(InstanceIdentifier<LearntVpnVipToPortEvent> identifier, LearntVpnVipToPortEvent value) {
// AFTER PROCESSING THE EVENT, REMOVE THE EVENT FROM THE QUEUE
entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY,
jobCoordinator, "LearntVpnVipToPortEvent-Handler", () -> {
}
@Override
- protected void remove(InstanceIdentifier<LearntVpnVipToPortEvent> key, LearntVpnVipToPortEvent value) {
+ public void remove(InstanceIdentifier<LearntVpnVipToPortEvent> key, LearntVpnVipToPortEvent value) {
// Removals are triggered by add handling.
// NOTE: DONOT ADD ANY CODE HERE AND MAKE A CIRCUS
}
- private class AddMipAdjacencyWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class AddMipAdjacencyWorker implements Callable<List<? extends ListenableFuture<?>>> {
String vpnName;
String interfaceName;
String srcIpAddress;
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfId,
newVpnIntf, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
LOG.debug(" Successfully stored subnetroute Adjacency into VpnInterface {}", vpnInterface);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("addMipAdjacency: Failed to read data store for interface {} vpn {} ip {} mac {}",
vpnInterface, vpnInstName, srcPrefix, mipMacAddress);
} catch (TransactionCommitFailedException e) {
}
}
- private class DeleteMipAdjacencyWorker implements Callable<List<ListenableFuture<Void>>> {
+ private class DeleteMipAdjacencyWorker implements Callable<List<? extends ListenableFuture<?>>> {
String vpnName;
String interfaceName;
String ipAddress;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
*/
package org.opendaylight.netvirt.vpnmanager.populator.impl;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.infrautils.utils.concurrent.ListenableFutures.addErrorLogging;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReentrantLock;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedWriteTransaction;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.JvmGlobalLocks;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.FibHelper;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(prefix)).build();
- Optional<VrfEntry> entry = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
-
+ Optional<VrfEntry> entry = Optional.empty();
+ try {
+ entry = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("addSubnetRouteFibEntry: Exception while reading vrfEntry for the prefix {} rd {}", prefix,
+ rd, e);
+ }
if (!entry.isPresent()) {
List<VrfEntry> vrfEntryList = Collections.singletonList(vrfEntry);
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="iMdsalApiManager"
interface="org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager" />
<reference id="iInterfaceManager"
interface="org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager" />
<reference id="notificationPublishService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService" />
+ interface="org.opendaylight.mdsal.binding.api.NotificationPublishService" />
<reference id="iBgpManager"
interface="org.opendaylight.netvirt.bgpmanager.api.IBgpManager" />
<reference id="iElanService"
import java.util.Collections;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.ConstantSchemaAbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class InterVpnLinkLocatorTest extends ConstantSchemaAbstractDataBrokerTest {
+public class InterVpnLinkLocatorTest extends AbstractConcurrentDataBrokerTest {
static final Logger LOG = LoggerFactory.getLogger(InterVpnLinkLocatorTest.class);
// Creating both empty containers: InterVpnLinks and InterVpnLinkStates
WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
- writeTx.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(InterVpnLinks.class).build(),
- new InterVpnLinksBuilder().setInterVpnLink(Collections.emptyList()).build(), true);
- writeTx.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(InterVpnLinkStates.class).build(),
- new InterVpnLinkStatesBuilder().setInterVpnLinkState(Collections.emptyList()).build(), true);
- writeTx.submit().checkedGet();
+ writeTx.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(InterVpnLinks.class),
+ new InterVpnLinksBuilder().setInterVpnLink(Collections.emptyList()).build());
+ writeTx.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(InterVpnLinkStates.class),
+ new InterVpnLinkStatesBuilder().setInterVpnLinkState(Collections.emptyList()).build());
+ writeTx.commit().get();
interVpnLinkCache = new InterVpnLinkCacheImpl(dataBroker);
interVpnLinkCache.initialFeed();
//////////////
public void populateL3Vpns(DataBroker broker, List<L3VpnComposite> vpns)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
for (L3VpnComposite vpn : vpns) {
VpnInstance vpnInstance = new VpnInstanceBuilder().setVpnId(vpn.vpnOpData.getVpnId())
.setVpnInstanceName(vpn.vpnOpData.getVpnInstanceName())
writeTx1.merge(LogicalDatastoreType.CONFIGURATION,
VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpn.vpnCfgData.getVpnInstanceName()),
vpnInstance, true);
- writeTx1.submit().checkedGet();
+ writeTx1.commit().get();
WriteTransaction writeTx2 = broker.newWriteOnlyTransaction();
writeTx2.merge(LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(vpn.vpnOpData.getVrfId()), vpn.vpnOpData, true);
- writeTx2.submit().checkedGet();
+ writeTx2.commit().get();
}
}
public void cleanL3Vpns(DataBroker broker, List<L3VpnComposite> vpns)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
for (L3VpnComposite vpn : vpns) {
WriteTransaction writeTx1 = broker.newWriteOnlyTransaction();
writeTx1.delete(LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(vpn.vpnOpData.getVrfId()));
- writeTx1.submit().checkedGet();
+ writeTx1.commit().get();
WriteTransaction writeTx2 = broker.newWriteOnlyTransaction();
writeTx2.delete(LogicalDatastoreType.CONFIGURATION,
VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpn.vpnCfgData.getVpnInstanceName()));
- writeTx2.submit().checkedGet();
+ writeTx2.commit().get();
}
}
writeTx1.merge(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(nodeId)).build(), node);
}
- writeTx1.submit().checkedGet();
+ writeTx1.commit().get();
}
-
}
*/
package org.opendaylight.netvirt.vpnmanager.intervpnlink;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
.setDpId(vpn2Dpns).build();
InterVpnLinkState ivpnLinkState =
new InterVpnLinkStateBuilder().setInterVpnLinkName(ivpnLinkName).setState(state)
- .setErrorDescription(errMsg.or(""))
+ .setErrorDescription(errMsg.orElse(""))
.setFirstEndpointState(firstEndpointState)
.setSecondEndpointState(secondEndpointState).build();
return new InterVpnLinkDataComposite(ivpnLinkCfg, ivpnLinkState);
static void updateEndpointDpns(InterVpnLinkDataComposite ivl, boolean is1stEndpoint, List<Uint64> newDpns) {
Optional<FirstEndpointState> new1stEpState = (is1stEndpoint)
? Optional.of(InterVpnLinkUtil.buildFirstEndpointState(ivl.getInterVpnLinkState().getFirstEndpointState(),
- Optional.of(newDpns), Optional.absent()))
- : Optional.absent();
+ Optional.of(newDpns), Optional.empty()))
+ : Optional.empty();
Optional<SecondEndpointState> new2ndEpState = (is1stEndpoint)
- ? Optional.absent()
+ ? Optional.empty()
: Optional.of(InterVpnLinkUtil.buildSecondEndpointState(ivl.getInterVpnLinkState().getSecondEndpointState(),
- Optional.of(newDpns), Optional.absent()));
+ Optional.of(newDpns), Optional.empty()));
InterVpnLinkState newIvlState =
InterVpnLinkUtil.buildIvlStateFromOriginal(ivl.getInterVpnLinkState(), new1stEpState, new2ndEpState,
- /*errMsg*/ Optional.absent());
+ /*errMsg*/ Optional.empty());
ivl.setInterVpnLinkState(newIvlState);
}
L3VpnTestCatalog.VPN_2.vpnCfgData.getVpnInstanceName(), "2.2.2.2", false, false, false,
Arrays.asList(Uint64.valueOf(BigInteger.ONE)), 100001,
Arrays.asList(Uint64.valueOf(BigInteger.ONE)), 100002,
- InterVpnLinkState.State.Active, Optional.absent());
+ InterVpnLinkState.State.Active, Optional.empty());
// InterVpnLink linking VPN_1 and VPN_2. Erroneous.
static InterVpnLinkDataComposite I_VPN_LINK_12_ERR =
L3VpnTestCatalog.VPN_2.vpnCfgData.getVpnInstanceName(), "2.2.2.2", false, false, false,
Arrays.asList(Uint64.valueOf(BigInteger.ONE)), 100001,
Arrays.asList(Uint64.valueOf(BigInteger.ONE)), 100002,
- InterVpnLinkState.State.Error, Optional.absent());
+ InterVpnLinkState.State.Error, Optional.empty());
// InterVpnLink linking VPN_3 and VPN_4. Active. No automatic route leaking at all. Installed on DPN BigInteger.ONE
static InterVpnLinkDataComposite I_VPN_LINK_34 =
build("InterVpnLink VPN3-VPN4", L3VpnTestCatalog.VPN_3.vpnCfgData.getVpnInstanceName(), "3.3.3.3",
L3VpnTestCatalog.VPN_4.vpnCfgData.getVpnInstanceName(), "4.4.4.4", false, false, false,
Arrays.asList(Uint64.valueOf(2L)), 100003, Arrays.asList(Uint64.valueOf(2L)), 100004,
- InterVpnLinkState.State.Active, Optional.absent());
+ InterVpnLinkState.State.Active, Optional.empty());
// InterVpnLink linking VPN_5 and VPN_6. Active. No automatic route leaking at all. Installed on DPN 2
// Note that VPN5 has same iRTs than VPN1 and VPN6 has same iRTs thant VPN2. This means that this InterVpnLink
build("InterVpnLink VPN5-VPN6", L3VpnTestCatalog.VPN_5.vpnCfgData.getVpnInstanceName(), "5.5.5.5",
L3VpnTestCatalog.VPN_6.vpnCfgData.getVpnInstanceName(), "6.6.6.6", false, false, false,
Arrays.asList(Uint64.valueOf(2L)), 100005, Arrays.asList(Uint64.valueOf(2L)), 100006,
- InterVpnLinkState.State.Active, Optional.absent());
+ InterVpnLinkState.State.Active, Optional.empty());
static List<InterVpnLinkDataComposite> ALL_IVPN_LINKS =
Arrays.asList(I_VPN_LINK_12, I_VPN_LINK_12_ERR, I_VPN_LINK_34, I_VPN_LINK_56);
public static void populateIvpnLinks(DataBroker broker2, List<InterVpnLinkDataComposite> ivpnLinks)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
for (InterVpnLinkDataComposite ivpnLink : ivpnLinks) {
WriteTransaction writeTx1 = broker2.newWriteOnlyTransaction();
writeTx1.merge(LogicalDatastoreType.CONFIGURATION,
InterVpnLinkUtil.getInterVpnLinkPath(ivpnLink.getInterVpnLinkName()),
ivpnLink.getInterVpnLinkConfig());
- writeTx1.submit().checkedGet();
+ writeTx1.commit().get();
WriteTransaction writeTx2 = broker2.newWriteOnlyTransaction();
writeTx2.merge(LogicalDatastoreType.OPERATIONAL,
InterVpnLinkUtil.getInterVpnLinkStateIid(ivpnLink.getInterVpnLinkName()),
ivpnLink.getInterVpnLinkState());
- writeTx2.submit().checkedGet();
+ writeTx2.commit().get();
}
}
public static void cleanIvpnLinks(DataBroker broker2, InterVpnLinkDataComposite... ivpnLinks)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
for (InterVpnLinkDataComposite ivpnLink : ivpnLinks) {
WriteTransaction writeTx1 = broker2.newWriteOnlyTransaction();
writeTx1.delete(LogicalDatastoreType.OPERATIONAL,
InterVpnLinkUtil.getInterVpnLinkStateIid(ivpnLink.getInterVpnLinkName()));
- writeTx1.submit().checkedGet();
+ writeTx1.commit().get();
WriteTransaction writeTx2 = broker2.newWriteOnlyTransaction();
writeTx2.delete(LogicalDatastoreType.CONFIGURATION,
InterVpnLinkUtil.getInterVpnLinkPath(ivpnLink.getInterVpnLinkName()));
- writeTx2.submit().checkedGet();
+ writeTx2.commit().get();
}
}
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.SubnetOpDpnManager;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PortOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfacesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfacesKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
-
@RunWith(MockitoJUnitRunner.class)
public class SubnetOpDpnManagerTest {
@Mock
DataBroker dataBroker;
@Mock
- ReadOnlyTransaction mockReadTx;
+ ReadTransaction mockReadTx;
@Mock
WriteTransaction mockWriteTx;
optionalSubDpn = Optional.of(subnetToDpn);
optionalPortOp = Optional.of(portOp);
- doReturn(Futures.immediateCheckedFuture(optionalPortOp)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalPortOp)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, portOpIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalSubDpn)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalSubDpn)).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, dpnOpId);
}
@Test
public void testAddPortOpDataEntryPortOpAbsent() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, portOpIdentifier);
subOpDpnManager.addPortOpDataEntry(infName, subnetId, dpId);
@Test
public void testRemovePortOpDataEntryPortOpAbsent() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, portOpIdentifier);
subOpDpnManager.removePortOpDataEntry(infName, null);
@Test
public void testGetPortOpDataEntryPortOpAbsent() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, portOpIdentifier);
subOpDpnManager.getPortOpDataEntry(infName);
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Future;
import javax.inject.Inject;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.vpnmanager.SubnetOpDpnManager;
@Mock
DataBroker dataBroker;
@Mock
- ReadOnlyTransaction mockReadTx;
+ ReadTransaction mockReadTx;
@Mock
WriteTransaction mockWriteTx;
@Mock
.CONFIGURATION, instVpnInstance);
doReturn(Futures.immediateCheckedFuture(vpnInstanceOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, vpnInstanceIdentifier);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateCheckedFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION, netsIdentifier);
doReturn(idOutputOptional).when(idManager).allocateId(allocateIdInput);
networks = new NetworksBuilder().setId(portId).withKey(new NetworksKey(portId)).build();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).commit();
}
@Ignore
@Test
public void testOnSubnetAddedToVpn() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(Futures.immediateCheckedFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.OPERATIONAL, subOpIdentifier);
vpnSubnetRouteHandler.onSubnetAddedToVpn(subnetmap, true, elanTag);
*/
package org.opendaylight.netvirt.vpnmanager.shell;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInterfaceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
*/
package org.opendaylight.netvirt.vpnmanager.shell;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
- <reference id="dataBrokerRef" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ <reference id="dataBrokerRef" interface="org.opendaylight.mdsal.binding.api.DataBroker"
availability="optional"/>
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
Code Review / netvirt.git / commitdiff