import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
-import java.math.BigInteger;
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.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
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 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();
- BigInteger dpnId = dpnInfo.getDpnId();
+ Uint64 dpnId = dpnInfo.getDpnId();
//check router is associated to external network
InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerUuid);
Optional<Routers> routerData =
Uuid networkId = router.getNetworkId();
if (networkId != null) {
if (natMode == NatMode.Conntrack) {
- BigInteger naptSwitch = NatUtil.getPrimaryNaptfromRouterName(dataBroker, router.getRouterName());
- if (naptSwitch == null || naptSwitch.equals(BigInteger.ZERO)) {
+ Uint64 naptSwitch = NatUtil.getPrimaryNaptfromRouterName(dataBroker, router.getRouterName());
+ if (naptSwitch == null || naptSwitch.equals(Uint64.ZERO)) {
LOG.warn("add : NAPT switch is not selected.");
return;
}
}
}), LOG, "Error notifying NAT service manager");
} else {
- Long routerId = NatUtil.getVpnId(dataBroker, routerUuid);
+ Uint32 routerId = NatUtil.getVpnId(dataBroker, routerUuid);
if (routerId == NatConstants.INVALID_ID) {
LOG.error("add : Invalid routerId returned for routerName {}", routerUuid);
return;
Uuid vpnName = NatUtil.getVpnForRouter(dataBroker, routerUuid);
return Collections.singletonList(
txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, confTx -> {
- Long vpnId;
+ Uint32 vpnId;
if (vpnName == null) {
LOG.debug("add : Internal vpn associated to router {}", routerUuid);
vpnId = routerId;
LOG.error("add : External Network Provider Type missing");
return;
}
- NatUtil.handleSNATForDPN(dataBroker, mdsalManager, idManager, naptSwitchHA, dpnId,
- router, routerId, vpnId, confTx, extNwProvType, upgradeState);
+ NatUtil.handleSNATForDPN(dataBroker, mdsalManager, idManager, naptSwitchHA,
+ dpnId, router, routerId, vpnId, confTx, extNwProvType, upgradeState);
} else {
LOG.info("add : SNAT is not enabled for router {} to handle addDPN event {}",
routerUuid, dpnId);
}
@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();
- Long routerId = NatUtil.getVpnId(dataBroker, routerUuid);
+ Uint32 routerId = NatUtil.getVpnId(dataBroker, routerUuid);
if (routerId == NatConstants.INVALID_ID) {
LOG.error("REMOVE: Invalid routId returned for routerName {}",routerUuid);
return;
}
- BigInteger dpnId = dpnInfo.getDpnId();
+ Uint64 dpnId = dpnInfo.getDpnId();
//check router is associated to external network
InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerUuid);
Optional<Routers> routerData =
Uuid networkId = router.getNetworkId();
if (networkId != null) {
if (natMode == NatMode.Conntrack) {
- BigInteger naptSwitch = NatUtil.getPrimaryNaptfromRouterName(dataBroker, router.getRouterName());
- if (naptSwitch == null || naptSwitch.equals(BigInteger.ZERO)) {
+ Uint64 naptSwitch = NatUtil.getPrimaryNaptfromRouterName(dataBroker, router.getRouterName());
+ if (naptSwitch == null || naptSwitch.equals(Uint64.ZERO)) {
LOG.warn("remove : NAPT switch is not selected.");
return;
}
Uuid vpnName = NatUtil.getVpnForRouter(dataBroker, routerUuid);
return Collections.singletonList(
txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, confTx -> {
- Long vpnId;
+ Uint32 vpnId;
if (vpnName == null) {
LOG.debug("remove : Internal vpn associated to router {}", routerUuid);
vpnId = routerId;
return;
}
LOG.info("remove : SNAT enabled for router {}", routerUuid);
- NatUtil.removeSNATFromDPN(dataBroker, mdsalManager, idManager, naptSwitchHA,
- dpnId, routerUuid, routerId, vpnId, networkId, extNwProvType, confTx);
+ String externalVpnName = NatUtil.getAssociatedVPN(dataBroker,
+ routerData.get().getNetworkId());
+ NatUtil.removeSNATFromDPN(dataBroker, mdsalManager, idManager, naptSwitchHA, dpnId,
+ router, routerId, vpnId, externalVpnName, extNwProvType, confTx);
} else {
LOG.info("remove : SNAT is not enabled for router {} to handle removeDPN event {}",
routerUuid, dpnId);
}
@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);
}
- private void installDefaultNatRouteForRouterExternalSubnets(BigInteger dpnId, Collection<Uuid> externalSubnetIds) {
+ private void installDefaultNatRouteForRouterExternalSubnets(Uint64 dpnId, Collection<Uuid> externalSubnetIds) {
if (externalSubnetIds == null) {
LOG.error("installDefaultNatRouteForRouterExternalSubnets : No external subnets for router");
return;
}
for (Uuid subnetId : externalSubnetIds) {
- long vpnIdForSubnet = NatUtil.getExternalSubnetVpnId(dataBroker, subnetId);
+ Uint32 vpnIdForSubnet = NatUtil.getExternalSubnetVpnId(dataBroker, subnetId);
if (vpnIdForSubnet != NatConstants.INVALID_ID) {
LOG.info("installDefaultNatRouteForRouterExternalSubnets : Installing default routes in FIB on dpn {} "
+ "for subnetId {} with vpnId {}", dpnId, subnetId, vpnIdForSubnet);
Code Review / netvirt.git / blobdiff