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 com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
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.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.infra.TypedReadTransaction;
-import org.opendaylight.genius.infra.TypedReadWriteTransaction;
-import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.api.IITMProvider;
import org.opendaylight.genius.mdsalutil.BucketInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
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.binding.util.Datastore.Configuration;
+import org.opendaylight.mdsal.binding.util.Datastore.Operational;
+import org.opendaylight.mdsal.binding.util.TypedReadTransaction;
+import org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.util.TypedWriteTransaction;
+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;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePaths;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePathsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.L3vpnDcGws;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.L3vpnLbNexthops;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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) {
}
buildVpnEncapSpecificInfo(vrfEntryBuilder, encapType, label, l3vni, macAddress, gatewayMacAddress, nextHopList);
if (writeConfigTxn != null) {
- writeConfigTxn.merge(vrfEntryId, vrfEntryBuilder.build(), CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructureMerge(vrfEntryId, vrfEntryBuilder.build());
} else {
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntryBuilder.build());
}
.addAugmentation(RouterInterface.class, routerInterface).build();
if (writeConfigTxn != null) {
- writeConfigTxn.merge(vrfEntryId, vrfEntry, CREATE_MISSING_PARENTS);
+ writeConfigTxn.mergeParentStructureMerge(vrfEntryId, vrfEntry);
} else {
MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntry);
}
LOG.error("removeFibEntry: Removed Fib Entry rd {} prefix {} source {} ",
rd, prefix, eventSource);
} catch (RuntimeException e) {
- LOG.error("removeFibEntry: Unable to remove Fib Entry for rd {} prefix {} source {} ",
- rd, prefix, eventSource);
+ if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
+ LOG.warn("removeFibEntry: Fib Entry prefix {} rd {} source {} is already deleted from the "
+ + "vrf table.", prefix, rd, eventSource);
+ } else {
+ LOG.error("removeFibEntry: Unable to remove Fib Entry for rd {} prefix {} source {} ",
+ rd, prefix, eventSource);
+ }
}
}
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();
+ final List<RoutePaths> routePaths = new ArrayList<RoutePaths>(entry.get().nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
LOG.warn("routePaths is null/empty for given rd {}, prefix {}", rd, prefix);
return;
* 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.mergeParentStructurePut(routePathId, routePaths);
} 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);
}
}
public static java.util.Optional<Uint32> getLabelFromRoutePaths(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
- if (routePaths == null || routePaths.isEmpty() || vrfEntry.getRoutePaths().get(0).getLabel() == null) {
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
+ if (routePaths == null || routePaths.isEmpty()
+ || new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values()).get(0).getLabel() == null) {
return java.util.Optional.empty();
}
- return java.util.Optional.of(vrfEntry.getRoutePaths().get(0).getLabel());
+ return java.util.Optional.of(new ArrayList<RoutePaths>(vrfEntry
+ .nonnullRoutePaths().values()).get(0).getLabel());
+
}
public static java.util.Optional<String> getFirstNextHopAddress(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
return java.util.Optional.empty();
}
- return java.util.Optional.of(vrfEntry.getRoutePaths().get(0).getNexthopAddress());
+ return java.util.Optional.of(new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values())
+ .get(0).getNexthopAddress());
}
public static java.util.Optional<Uint32> getLabelForNextHop(final VrfEntry vrfEntry, String nextHopIp) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
+ List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
if (routePaths == null || routePaths.isEmpty()) {
return java.util.Optional.empty();
}
.@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();
}
- return dcGwsOpt.get().getDcGateway().stream().map(DcGateway::getIpAddress).collect(toList());
+ return dcGwsOpt.get().nonnullDcGateway().values().stream().map(DcGateway::getIpAddress).collect(toList());
}
static boolean isVxlanNetwork(NetworkType networkType) {
&& !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) {
+ Map<RoutePathsKey, RoutePaths> pathsMap = entry.get().nonnullRoutePaths();
+ for (RoutePaths path: pathsMap.values()) {
if (path.getNexthopAddress().equals(nextHopIp)) {
return true;
}
Code Review / netvirt.git / blobdiff