*/
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 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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.RouterIdName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCounters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.external.counters.ExternalIpCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets;
@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);
protected void subnetRegisterMapping(Routers routerEntry, Uint32 segmentId) {
LOG.debug("subnetRegisterMapping : Fetching values from extRouters model");
- List<String> externalIps = NatUtil.getIpsListFromExternalIps(routerEntry.getExternalIps());
+ List<String> externalIps = NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(routerEntry.getExternalIps().values()));
int counter = 0;
int extIpCounter = externalIps.size();
LOG.debug("subnetRegisterMapping : counter values before looping counter {} and extIpCounter {}",
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
bgpVpnId, bgpVpnName);
RouterIds rtrs = new RouterIdsBuilder().withKey(new RouterIdsKey(bgpVpnId))
.setRouterId(bgpVpnId).setRouterName(bgpVpnName).build();
- confTx.put(getRoutersIdentifier(bgpVpnId), rtrs, CREATE_MISSING_PARENTS);
+ confTx.mergeParentStructurePut(getRoutersIdentifier(bgpVpnId), rtrs);
}
if (create) {
addDefaultFibRouteForSnatWithBgpVpn(routerName, routerId, bgpVpnId, confTx);
LOG.error("handleSnatReverseTraffic : networkId is null for the router ID {}", routerId);
return;
}
- Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(router.getExternalIps());
+ Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(router.getExternalIps().values()));
// FLAT/VLAN case having external-subnet as VPN
String externalSubnetVpn = null;
if (externalSubnetList != null && !externalSubnetList.isEmpty()) {
+ Boolean isExternalIpsAdvertized = Boolean.FALSE;
for (Uuid externalSubnetId : externalSubnetList) {
Optional<Subnets> externalSubnet = NatUtil
.getOptionalExternalSubnets(dataBroker, externalSubnetId);
advToBgpAndInstallFibAndTsFlows(dpnId, NwConstants.INBOUND_NAPT_TABLE,
externalSubnetVpn, routerId, routerName,
externalIp, networkId, router, confTx);
+ isExternalIpsAdvertized = Boolean.TRUE;
}
}
- return;
+ if (isExternalIpsAdvertized) {
+ LOG.trace("External Ips {} advertized for Router {}", router.getExternalIps(), routerName);
+ return;
+ }
}
+
// VXVLAN/GRE case having Internet-VPN
final String vpnName = NatUtil.getAssociatedVPN(dataBroker, networkId);
if (vpnName == null) {
matches.add(MatchEthernetType.MPLS_UNICAST);
matches.add(new MatchMplsLabel(serviceId.longValue()));
- List<Instruction> instructions = new ArrayList<>();
+ Map<InstructionKey, Instruction> instructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
List<ActionInfo> actionsInfos = new ArrayList<>();
//NAT is required for IPv4 only. Hence always etherType will be IPv4
actionsInfos.add(new ActionPopMpls(NwConstants.ETHTYPE_IPV4));
Instruction writeInstruction = new InstructionApplyActions(actionsInfos).buildInstruction(0);
- instructions.add(writeInstruction);
- instructions.add(new InstructionGotoTable(tableId).buildInstruction(1));
+ instructionsMap.put(new InstructionKey(++instructionKey), writeInstruction);
+ instructionsMap.put(new InstructionKey(++instructionKey),
+ new InstructionGotoTable(tableId).buildInstruction(1));
// Install the flow entry in L3_LFIB_TABLE
String flowRef = getFlowRef(dpId, NwConstants.L3_LFIB_TABLE, serviceId, "");
Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_LFIB_TABLE, flowRef,
10, flowRef, 0, 0,
- COOKIE_VM_LFIB_TABLE, matches, instructions);
+ COOKIE_VM_LFIB_TABLE, matches, instructionsMap);
mdsalManager.addFlow(confTx, dpId, flowEntity);
} else {
mkMatches.add(new MatchTunnelId(Uint64.valueOf(serviceId)));
}
-
+ Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ int instructionKey = 0;
+ for (Instruction instructionObj : customInstructions) {
+ customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
+ }
Flow terminatingServiceTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
getFlowRef(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, serviceId, ""),
NatConstants.DEFAULT_VPN_INTERNAL_TUNNEL_TABLE_PRIORITY,
String.format("%s:%s", "TST Flow Entry ", serviceId), 0, 0,
Uint64.valueOf(COOKIE_TUNNEL.toJava().add(BigInteger.valueOf(serviceId.longValue()))),
- mkMatches, customInstructions);
+ mkMatches, customInstructionsMap);
mdsalManager.addFlow(confTx, dpnId, terminatingServiceTableFlowEntity);
}
}
@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);
}
//Check if the Update is on External IPs
LOG.debug("update : Checking if this is update on External IPs for router {}", routerName);
- List<String> originalExternalIps = NatUtil.getIpsListFromExternalIps(original.getExternalIps());
- List<String> updatedExternalIps = NatUtil.getIpsListFromExternalIps(update.getExternalIps());
+ List<String> originalExternalIps = NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(original.getExternalIps().values()));
+ List<String> updatedExternalIps = NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(update.getExternalIps().values()));
//Check if the External IPs are removed during the update.
Set<String> removedExternalIps = new HashSet<>(originalExternalIps);
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()) {
for (IntextIpProtocolType intextIpProtocolType :
- ipPortMapping.get().nonnullIntextIpProtocolType()) {
+ ipPortMapping.get().nonnullIntextIpProtocolType().values()) {
ProtocolTypes protoType = intextIpProtocolType.getProtocol();
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
IpPortExternal ipPortExternal = ipPortMap.getIpPortExternal();
if (ipPortExternal.getIpAddress().equals(externalIp)) {
List<String> removedInternalIpPorts =
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();
- for (ExternalCounters ext : externalIpsCounters.nonnullExternalCounters()) {
- for (ExternalIpCounter externalIpCount : ext.nonnullExternalIpCounter()) {
+ for (ExternalCounters ext : externalIpsCounters.nonnullExternalCounters().values()) {
+ for (ExternalIpCounter externalIpCount : ext.nonnullExternalIpCounter().values()) {
if (externalIpCount.getExternalIp().equals(externalIp)) {
if (externalIpCount.getCounter().toJava() != 0) {
return true;
}
@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
LOG.error("handleDisableSnat : External Network Provider Type missing");
return;
}
- Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(router.getExternalIps());
+ Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(router.getExternalIps().values()));
removeNaptFlowsFromActiveSwitch(routerId, routerName, naptSwitchDpnId, networkUuid, vpnName, externalIps,
externalSubnetList, removeFlowInvTx, extNwProvType);
removeFlowsFromNonActiveSwitches(routerId, routerName, naptSwitchDpnId, removeFlowInvTx);
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();
return;
}
- for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
String protocol = intextIpProtocolType.getProtocol().name();
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
LOG.error("removeNaptFlowsFromActiveSwitchInternetVpn : Unable to retrieve the IpPortMapping");
return;
}
- for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
String protocol = intextIpProtocolType.getProtocol().name();
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
.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;
}
routerId);
return;
}
- for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
- for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
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,
Code Review / netvirt.git / blobdiff