import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
+import javax.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;
return builder.build();
}
- public static VrfEntryBuilder getVrfEntryBuilder(String prefix, RouteOrigin origin, String parentVpnRd) {
+ public static VrfEntryBuilder getVrfEntryBuilder(String prefix, RouteOrigin origin, @Nullable String parentVpnRd) {
return new VrfEntryBuilder().withKey(new VrfEntryKey(prefix)).setDestPrefix(prefix)
.setOrigin(origin.getValue()).setParentVpnRd(parentVpnRd);
}
public static VrfEntryBuilder getVrfEntryBuilder(String prefix, List<RoutePaths> routePaths,
- RouteOrigin origin, String parentVpnRd) {
+ RouteOrigin origin, @Nullable String parentVpnRd) {
return new VrfEntryBuilder().withKey(new VrfEntryKey(prefix)).setDestPrefix(prefix)
.setRoutePaths(routePaths).setOrigin(origin.getValue()).setParentVpnRd(parentVpnRd);
}
public static VrfEntryBuilder getVrfEntryBuilder(String prefix, long label, String nextHop, RouteOrigin origin,
- String parentVpnRd) {
+ @Nullable String parentVpnRd) {
if (nextHop != null) {
RoutePaths routePath = buildRoutePath(nextHop, label);
- return getVrfEntryBuilder(prefix, Arrays.asList(routePath), origin, parentVpnRd);
+ return getVrfEntryBuilder(prefix, Collections.singletonList(routePath), origin, parentVpnRd);
} else {
return getVrfEntryBuilder(prefix, origin, parentVpnRd);
}
}
public static VrfEntryBuilder getVrfEntryBuilder(VrfEntry vrfEntry, long label,
- List<String> nextHopList, RouteOrigin origin, String parentvpnRd) {
+ List<String> nextHopList, RouteOrigin origin, @Nullable String parentvpnRd) {
List<RoutePaths> routePaths =
nextHopList.stream().map(nextHop -> buildRoutePath(nextHop, label))
.collect(toList());
* @return true if it is an IPv4 or false if it is not.
*/
public static boolean isIpv4Prefix(String prefix) {
- boolean rep = false;
if (prefix == null || prefix.length() < 7) {
- return rep;
+ return false;
}
try {
String ip = getIpFromPrefix(prefix);
java.net.Inet4Address.getByName(ip);
- rep = true;
} catch (SecurityException | UnknownHostException | ClassCastException e) {
- rep = false;
- return rep;
+ return false;
}
- return rep;
+ return true;
}
/** get true if this prefix is an IPv6 version, false otherwise.
* @return true if it is an IPv4 or false if it is not.
*/
public static boolean isIpv6Prefix(String prefix) {
- boolean rep = false;
if (prefix == null || prefix.length() < 2) {
- return rep;
+ return false;
}
try {
String ip = getIpFromPrefix(prefix);
java.net.Inet6Address.getByName(ip);
- rep = true;
} catch (SecurityException | UnknownHostException | ClassCastException e) {
- rep = false;
- return rep;
+ return false;
}
- return rep;
+ return true;
}
/**get String format IP from prefix as x.x.....x/nn.
* @param prefix the prefix as IPv4 or IPv6 as x.....x/nn
* @return prefix if "/" is unfindable or the IP only as x.x...x from x.x......x/nn
*/
+ @Nullable
public static String getIpFromPrefix(String prefix) {
if (prefix == null || prefix.length() < 2) {
return null;
* @param mask the lengh of the mask of net as 24 from this representation 10.1.1.0/24 or 64 for 2001::1/64
* @return the bit mask of net ex: x.x.x.x/24 return a BigInteger == 0xFFFFFFotherwise null if any error
*/
+ @Nullable
public static BigInteger getMaskNetwork(int ipVersion, int mask) {
int lenghBitsIp = 0;
if (ipVersion == 6) {
import java.math.BigInteger;
import java.util.List;
+import javax.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
public interface IFibManager {
void populateFibOnNewDpn(BigInteger dpnId, long vpnId, String rd,
- FutureCallback<List<Void>> callback);
+ @Nullable FutureCallback<List<Void>> callback);
void cleanUpExternalRoutesOnDpn(BigInteger dpnId, long vpnId, String rd,
String localNextHopIp, String remoteNextHopIp);
String localNextHopIp, String remoteNextHopIp);
void cleanUpDpnForVpn(BigInteger dpnId, long vpnId, String rd,
- FutureCallback<List<Void>> callback);
+ @Nullable FutureCallback<List<Void>> callback);
void setConfTransType(String service, String transportType);
String destTepIp,
long label);
- void addOrUpdateFibEntry(String rd, String macAddress, String prefix, List<String> nextHopList,
- VrfEntry.EncapType encapType, long label, long l3vni, String gwMacAddress,
- String parentVpnRd, RouteOrigin origin,
- TypedWriteTransaction<Configuration> writeConfigTxn);
+ void addOrUpdateFibEntry(String rd, @Nullable String macAddress, String prefix, List<String> nextHopList,
+ VrfEntry.EncapType encapType, long label, long l3vni, @Nullable String gwMacAddress,
+ @Nullable String parentVpnRd, RouteOrigin origin,
+ @Nullable TypedWriteTransaction<Configuration> writeConfigTxn);
void addFibEntryForRouterInterface(String rd, String prefix,
RouterInterface routerInterface, long label,
void removeOrUpdateFibEntry(String rd, String prefix, String nextHopToRemove,
TypedWriteTransaction<Configuration> writeConfigTxn);
- void removeFibEntry(String rd, String prefix, TypedWriteTransaction<Configuration> writeConfigTxn);
+ void removeFibEntry(String rd, String prefix, @Nullable TypedWriteTransaction<Configuration> writeConfigTxn);
void updateRoutePathForFibEntry(String rd, String prefix, String nextHop,
long label, boolean nextHopAdd, WriteTransaction writeConfigTxn);
import static java.util.stream.Collectors.toList;
import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
+import static org.opendaylight.netvirt.fibmanager.FibUtil.nullToEmpty;
import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@Nonnull
protected List<AdjacencyResult> resolveAdjacency(final BigInteger remoteDpnId, final long vpnId,
final VrfEntry vrfEntry, String rd) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
+ List<RoutePaths> routePaths = nullToEmpty(vrfEntry.getRoutePaths());
FibHelper.sortIpAddress(routePaths);
List<AdjacencyResult> adjacencyList = new ArrayList<>();
List<String> prefixIpList;
prefixIpList = Collections.singletonList(vrfEntry.getDestPrefix());
} else {
List<String> prefixIpListLocal = new ArrayList<>();
- vpnExtraRoutes.forEach(route -> route.getNexthopIpList().forEach(extraRouteIp -> {
+ vpnExtraRoutes.forEach(route -> nullToEmpty(route.getNexthopIpList()).forEach(extraRouteIp -> {
String ipPrefix;
if (isIpv4Address(extraRouteIp)) {
ipPrefix = extraRouteIp + NwConstants.IPV4PREFIX;
}
protected void makeConnectedRoute(BigInteger dpId, long vpnId, VrfEntry vrfEntry, String rd,
- List<InstructionInfo> instructions, int addOrRemove, WriteTransaction tx,
- List<SubTransaction> subTxns) {
+ @Nullable List<InstructionInfo> instructions, int addOrRemove,
+ WriteTransaction tx, @Nullable List<SubTransaction> subTxns) {
if (tx == null) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
newTx -> makeConnectedRoute(dpId, vpnId, vrfEntry, rd, instructions, addOrRemove, newTx, subTxns)),
}
}
- protected void addRewriteDstMacAction(long vpnId, VrfEntry vrfEntry, Prefixes prefixInfo,
- List<ActionInfo> actionInfos) {
+ protected void addRewriteDstMacAction(long vpnId, VrfEntry vrfEntry, @Nullable Prefixes prefixInfo,
+
List<ActionInfo> actionInfos) {
if (vrfEntry.getMac() != null) {
actionInfos.add(new ActionSetFieldEthernetDestination(actionInfos.size(),
new MacAddress(vrfEntry.getMac())));
addRewriteDstMacAction(vpnId, vrfEntry, prefixInfo, actionInfos);
}
+ @Nullable
private InstanceIdentifier<Interface> getFirstAbsentInterfaceStateIid(List<AdjacencyResult> adjacencyResults) {
InstanceIdentifier<Interface> res = null;
for (AdjacencyResult adjacencyResult : adjacencyResults) {
}
public void programRemoteFib(final BigInteger remoteDpnId, final long vpnId,
- final VrfEntry vrfEntry, WriteTransaction tx, String rd,
-
List<AdjacencyResult> adjacencyResults,
- List<SubTransaction> subTxns) {
+ final VrfEntry vrfEntry, WriteTransaction tx, String rd,
+ List<AdjacencyResult> adjacencyResults,
+ @Nullable List<SubTransaction> subTxns) {
if (upgradeState.isUpgradeInProgress()) {
InstanceIdentifier<Interface> absentInterfaceStateIid = getFirstAbsentInterfaceStateIid(adjacencyResults);
if (absentInterfaceStateIid != null) {
absentInterfaceStateIid,
(before, after) -> {
LOG.info("programRemoteFib: waited for and got interface state {}", absentInterfaceStateIid);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit((wtx) -> {
- programRemoteFib(remoteDpnId, vpnId, vrfEntry, wtx, rd, adjacencyResults, null);
- });
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ (wtx) -> programRemoteFib(remoteDpnId, vpnId, vrfEntry, wtx, rd, adjacencyResults, null));
return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
},
Duration.of(15, ChronoUnit.MINUTES),
(iid) -> {
LOG.error("programRemoteFib: timed out waiting for {}", absentInterfaceStateIid);
- txRunner.callWithNewWriteOnlyTransactionAndSubmit((wtx) -> {
- programRemoteFib(remoteDpnId, vpnId, vrfEntry, wtx, rd, adjacencyResults, null);
- });
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ (wtx) -> programRemoteFib(remoteDpnId, vpnId, vrfEntry, wtx, rd, adjacencyResults, null));
});
return;
}
}
public boolean checkDpnDeleteFibEntry(VpnNexthop localNextHopInfo, BigInteger remoteDpnId, long vpnId,
- VrfEntry vrfEntry, String rd,
- WriteTransaction tx, List<SubTransaction> subTxns) {
+ VrfEntry vrfEntry, String rd,
+ WriteTransaction tx, @Nullable List<SubTransaction> subTxns) {
boolean isRemoteRoute = true;
if (localNextHopInfo != null) {
isRemoteRoute = !remoteDpnId.equals(localNextHopInfo.getDpnId());
}
}
- public void deleteRemoteRoute(final BigInteger localDpnId, final BigInteger remoteDpnId,
+ public void deleteRemoteRoute(@Nullable final BigInteger localDpnId, final BigInteger remoteDpnId,
final long vpnId, final VrfTablesKey vrfTableKey,
final VrfEntry vrfEntry, Optional<Routes> extraRouteOptional,
- WriteTransaction tx) {
+ @Nullable WriteTransaction tx) {
if (tx == null) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
newTx -> deleteRemoteRoute(localDpnId, remoteDpnId, vpnId, vrfTableKey, vrfEntry,
new ExtraRoutesKey(vrfId)).child(Routes.class, new RoutesKey(ipPrefix)).build();
}
+ @Nullable
public Routes getVpnToExtraroute(Long vpnId, String vpnRd, String destPrefix) {
String optVpnName = fibUtil.getVpnNameFromId(vpnId);
if (optVpnName != null) {
package org.opendaylight.netvirt.fibmanager;
import static java.util.stream.Collectors.toList;
+import static org.opendaylight.netvirt.fibmanager.FibUtil.nullToEmpty;
import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Consumer;
+import javax.annotation.Nullable;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
String rd,
List<NexthopManager.AdjacencyResult> adjacencyResults,
List<SubTransaction> subTxns) {
- if (vrfEntry.getRoutePaths().size() > 2) {
+ if (nullToEmpty(vrfEntry.getRoutePaths()).size() > 2) {
LOG.error("DC-GW can advertise only 2 bestPaths for prefix {}", vrfEntry.getDestPrefix());
return;
}
}
}
- public void deleteRemoteRoute(final BigInteger localDpnId, final BigInteger remoteDpnId,
+ public void deleteRemoteRoute(@Nullable final BigInteger localDpnId, final BigInteger remoteDpnId,
final long vpnId, final VrfTablesKey vrfTableKey,
final VrfEntry vrfEntry, Optional<Routes> extraRouteOptional,
- WriteTransaction tx, List<SubTransaction> subTxns) {
+ @Nullable WriteTransaction tx, List<SubTransaction> subTxns) {
if (tx == null) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
newTx -> deleteRemoteRoute(localDpnId, remoteDpnId, vpnId, vrfTableKey, vrfEntry,
final BigInteger dpnId, final long vpnId, final String rd,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
- return vrfEntry -> vrfEntry.getRoutePaths().stream()
+ return vrfEntry -> nullToEmpty(vrfEntry.getRoutePaths()).stream()
.filter(routes -> !routes.getNexthopAddress().isEmpty()
&& remoteNextHopIp.trim().equals(routes.getNexthopAddress().trim()))
.findFirst()
final BigInteger dpnId, final long vpnId,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
- return vrfEntry -> vrfEntry.getRoutePaths().stream()
+ return vrfEntry -> nullToEmpty(vrfEntry.getRoutePaths()).stream()
.filter(routes -> !routes.getNexthopAddress().isEmpty()
&& remoteNextHopIp.trim().equals(routes.getNexthopAddress().trim()))
.findFirst()
}
@Override
- protected void addRewriteDstMacAction(long vpnId, VrfEntry vrfEntry, Prefixes prefixInfo,
- List<ActionInfo> actionInfos) {
+ protected void addRewriteDstMacAction(long vpnId, VrfEntry vrfEntry, @Nullable Prefixes prefixInfo,
+
List<ActionInfo> actionInfos) {
if (vrfEntry.getGatewayMacAddress() != null) {
actionInfos.add(new ActionSetFieldEthernetDestination(actionInfos.size(),
new MacAddress(vrfEntry.getGatewayMacAddress())));
package org.opendaylight.netvirt.fibmanager;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.netvirt.fibmanager.FibUtil.nullToEmpty;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
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;
//Handle extra routes and imported routes
Routes extraRoute = getVpnToExtraroute(vpnId, rd, vrfEntry.getDestPrefix());
if (extraRoute != null) {
- for (String nextHopIp : extraRoute.getNexthopIpList()) {
+ for (String nextHopIp : nullToEmpty(extraRoute.getNexthopIpList())) {
LOG.info("NextHop IP for destination {} is {}", vrfEntry.getDestPrefix(), nextHopIp);
if (nextHopIp != null) {
localNextHopInfo = getFibUtil().getPrefixToInterface(vpnId, nextHopIp + "/32");
String prefix = adjacencyResult.getPrefix();
Prefixes prefixInfo = getFibUtil().getPrefixToInterface(vpnId, prefix);
String interfaceName = prefixInfo.getVpnInterfaceName();
- if (vrfEntry.getOrigin().equals(RouteOrigin.BGP.getValue()) || isNatPrefix) {
+ if (RouteOrigin.BGP.getValue().equals(vrfEntry.getOrigin()) || isNatPrefix) {
tunnelId = BigInteger.valueOf(vrfEntry.getL3vni());
} else if (FibUtil.isVxlanNetwork(prefixInfo.getNetworkType())) {
tunnelId = BigInteger.valueOf(prefixInfo.getSegmentationId());
} else {
for (BigInteger localDpnId : localDpnIdList) {
for (VpnToDpnList curDpn2 : vpnToDpnList) {
- if (!curDpn2.getDpnId().equals(localDpnId)) {
+ if (!Objects.equals(curDpn2.getDpnId(), localDpnId)) {
if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
if (curDpn2.getDpnState() == VpnToDpnList.DpnState.Active) {
bgpRouteVrfEntryHandler.deleteRemoteRoute(localDpnId, curDpn2.getDpnId(),
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
+import javax.annotation.Nullable;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.tuple.ImmutablePair;
}
//TODO: Below Util methods to be removed once VpnUtil methods are exposed in api bundle
+ @Nullable
public static String getVpnRd(DataBroker broker, String vpnName) {
InstanceIdentifier<VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
package org.opendaylight.netvirt.fibmanager;
+import static java.util.Collections.emptyList;
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.math.BigInteger;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Objects;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
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;
return operTx.read(getVpnInstanceOpDataIdentifier(rd)).get();
}
+ @Nullable
VpnInstanceOpDataEntry getVpnInstance(String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id =
InstanceIdentifier.create(VpnInstanceOpData.class)
return rd + FibConstants.SEPARATOR + prefix;
}
+ @Nullable
Prefixes getPrefixToInterface(Long vpnId, String ipPrefix) {
Optional<Prefixes> localNextHopInfoData = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
getPrefixToInterfaceIdentifier(vpnId, ipPrefix));
return localNextHopInfoData.isPresent() ? localNextHopInfoData.get() : null;
}
+ @Nullable
static Prefixes getPrefixToInterface(TypedReadTransaction<Operational> operTx, Long vpnId, String ipPrefix)
throws ExecutionException, InterruptedException {
return operTx.read(getPrefixToInterfaceIdentifier(vpnId, ipPrefix)).get().orNull();
}
+ @Nullable
String getMacAddressFromPrefix(String ifName, String vpnName, String ipPrefix) {
Optional<Adjacency> adjacencyData = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
getAdjacencyIdentifierOp(ifName, vpnName, ipPrefix));
getVpnInstanceOpData(rd).toJavaUtil().map(VpnInstanceOpDataEntry::getVpnInstanceName));
}
+ @Nullable
public String getVpnNameFromId(long vpnId) {
InstanceIdentifier<VpnIds> id = getVpnIdToVpnInstanceIdentifier(vpnId);
return MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
}
java.util.Optional<RoutePaths> optRoutePath =
routePaths.stream()
- .filter(routePath -> routePath.getNexthopAddress().equals(
- nextHopToRemove)).findFirst();
+ .filter(
+ routePath -> Objects.equals(routePath.getNexthopAddress(), nextHopToRemove)).findFirst();
if (!optRoutePath.isPresent()) {
LOG.error("Unable to find a routePath that contains the given nextHop to remove {}", nextHopToRemove);
return;
return java.util.Optional.empty();
}
return routePaths.stream()
- .filter(routePath -> routePath.getNexthopAddress().equals(nextHopIp))
+ .filter(routePath -> Objects.equals(routePath.getNexthopAddress(), nextHopIp))
.findFirst()
.map(RoutePaths::getLabel);
}
+ @Nullable
public StateTunnelList getTunnelState(String interfaceName) throws ReadFailedException {
Optional<StateTunnelList> tunnelStateOptional = iitmProvider.getTunnelState(interfaceName);
if (tunnelStateOptional.isPresent()) {
return id;
}
+ @Nullable
public org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
.state.Interface getInterfaceStateFromOperDS(String interfaceName) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
public static void removeOrUpdateNextHopInfo(BigInteger dpnId, String nextHopKey, String groupId,
Nexthops nexthops, TypedWriteTransaction<Operational> tx) {
InstanceIdentifier<Nexthops> nextHopsId = getNextHopsIdentifier(nextHopKey);
- List<String> targetDeviceIds = nexthops.getTargetDeviceId();
+ List<String> targetDeviceIds = new ArrayList<>(nullToEmpty(nexthops.getTargetDeviceId()));
targetDeviceIds.remove(dpnId.toString());
if (targetDeviceIds.isEmpty()) {
tx.delete(nextHopsId);
}
return false;
}
+
+ // TODO Replace this with mdsal's DataObjectUtils.nullToEmpty when upgrading to mdsal 3
+ @Nonnull
+ public static <T> List<T> nullToEmpty(final @Nullable List<T> input) {
+ return input != null ? input : emptyList();
+ }
}
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.netvirt.fibmanager.FibUtil.nullToEmpty;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
+import javax.annotation.Nullable;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
}
}
List<ActionInfo> listActionInfo = new ArrayList<>();
- for (Action action : actions) {
+ for (Action action : nullToEmpty(actions)) {
actionKey = action.key().getOrder() + actionKey;
org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action
actionClass = action.getAction();
return Collections.emptyList();
}
+ @Nullable
protected String getTunnelInterfaceName(BigInteger srcDpId, BigInteger dstDpId) {
Class<? extends TunnelTypeBase> tunType = getReqTunType(getReqTransType().toUpperCase(Locale.getDefault()));
Future<RpcResult<GetTunnelInterfaceNameOutput>> result;
return null;
}
+ @Nullable
protected String getTunnelInterfaceName(BigInteger srcDpId, org.opendaylight.yang.gen.v1.urn.ietf.params
.xml.ns.yang.ietf.inet.types.rev130715.IpAddress dstIp, Class<? extends TunnelTypeBase> tunnelType) {
Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> result;
return id;
}
+ @Nullable
protected VpnNexthop getVpnNexthop(long vpnId, String ipAddress) {
// check if vpn node is there
Optional<VpnNexthops> vpnNexthops = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if (vpnNexthops.isPresent()) {
// get nexthops list for vpn
- List<VpnNexthop> nexthops = vpnNexthops.get().getVpnNexthop();
+ List<VpnNexthop> nexthops = nullToEmpty(vpnNexthops.get().getVpnNexthop());
for (VpnNexthop nexthop : nexthops) {
- if (nexthop.getIpAddress().equals(ipAddress)) {
+ if (Objects.equals(nexthop.getIpAddress(), ipAddress)) {
// return nexthop
LOG.trace("VpnNextHop : {}", nexthop);
return nexthop;
return null;
}
+ @Nullable
public AdjacencyResult getRemoteNextHopPointer(BigInteger remoteDpnId, long vpnId, String prefixIp,
- String nextHopIp, Class<? extends TunnelTypeBase> tunnelType) {
+ @Nullable String nextHopIp, Class<? extends TunnelTypeBase> tunnelType) {
String egressIfName = null;
LOG.trace("getRemoteNextHopPointer: input [remoteDpnId {}, vpnId {}, prefixIp {}, nextHopIp {} ]", remoteDpnId,
vpnId, prefixIp, nextHopIp);
prefixIp) : null;
}
+ @Nullable
public BigInteger getDpnForPrefix(long vpnId, String prefixIp) {
VpnNexthop vpnNexthop = getVpnNexthop(vpnId, prefixIp);
- BigInteger localDpnId = vpnNexthop == null ? null : vpnNexthop.getDpnId();
- return localDpnId;
+ return vpnNexthop == null ? null : vpnNexthop.getDpnId();
}
private void removeVpnNexthopFromDS(long vpnId, String ipPrefix) {
if (FibUtil.lockCluster(lockManager, nextHopLockStr, WAIT_TIME_TO_ACQUIRE_LOCK)) {
VpnNexthop nh = getVpnNexthop(vpnId, primaryIpAddress);
if (nh != null) {
- List<IpAdjacencies> prefixesList = nh.getIpAdjacencies();
+ List<IpAdjacencies> prefixesList = new ArrayList<>(nullToEmpty(nh.getIpAdjacencies()));
IpAdjacencies prefix = new IpAdjacenciesBuilder().setIpAdjacency(currDestIpPrefix).build();
prefixesList.remove(prefix);
if (prefixesList.isEmpty()) { //remove the group only if there are no more flows using this group
MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, getConfTransportTypeIdentifier());
if (configuredTransTypeFromConfig.isPresent()) {
- if (configuredTransTypeFromConfig.get().getTransportType().equals(TunnelTypeGre.class)) {
+ if (TunnelTypeGre.class.equals(configuredTransTypeFromConfig.get().getTransportType())) {
configuredTransportTypeL3VPN = L3VPNTransportTypes.GRE;
} else {
configuredTransportTypeL3VPN = L3VPNTransportTypes.VxLAN;
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
+ @Nullable
private String getTunnelRemoteNextHopPointer(BigInteger remoteDpnId, String nextHopIp,
Class<? extends TunnelTypeBase> tunnelType) {
if (nextHopIp != null && !nextHopIp.isEmpty()) {
return false;
}
- boolean result = false;
if (getClass() != obj.getClass()) {
- return result;
+ return false;
} else {
AdjacencyResult other = (AdjacencyResult) obj;
- result = interfaceName.equals(other.interfaceName);
+ return interfaceName.equals(other.interfaceName);
}
- return result;
}
}
}
long createNextHopGroups(Long vpnId, String rd, BigInteger dpnId, VrfEntry vrfEntry,
- Routes routes, List<Routes> vpnExtraRoutes) {
+ @Nullable Routes routes, List<Routes> vpnExtraRoutes) {
List<BucketInfo> localBucketInfo = new ArrayList<>();
List<Routes> clonedVpnExtraRoutes = new ArrayList<>(vpnExtraRoutes);
if (clonedVpnExtraRoutes.contains(routes)) {
localBucketInfo.addAll(getBucketsForLocalNexthop(vpnId, dpnId, vrfEntry, routes));
clonedVpnExtraRoutes.remove(routes);
}
- List<BucketInfo> remoteBucketInfo = new ArrayList<>();
- remoteBucketInfo.addAll(getBucketsForRemoteNexthop(vpnId, dpnId, vrfEntry, rd, clonedVpnExtraRoutes));
+ List<BucketInfo> remoteBucketInfo =
+ new ArrayList<>(getBucketsForRemoteNexthop(vpnId, dpnId, vrfEntry, rd, clonedVpnExtraRoutes));
return setupLoadBalancingNextHop(vpnId, dpnId,
vrfEntry.getDestPrefix(), localBucketInfo, remoteBucketInfo);
}
routes.getNexthopIpList());
}
List<BucketInfo> listBucketInfo = new CopyOnWriteArrayList<>();
- routes.getNexthopIpList().parallelStream().forEach(nextHopIp -> {
+ nullToEmpty(routes.getNexthopIpList()).parallelStream().forEach(nextHopIp -> {
String localNextHopIP;
if (isIpv4Address(nextHopIp)) {
localNextHopIP = nextHopIp + NwConstants.IPV4PREFIX;
List<Routes> vpnExtraRoutes) {
List<BucketInfo> listBucketInfo = new ArrayList<>();
Map<String, List<ActionInfo>> egressActionMap = new HashMap<>();
- vpnExtraRoutes.forEach(vpnExtraRoute -> vpnExtraRoute.getNexthopIpList().forEach(nextHopIp -> {
+ vpnExtraRoutes.forEach(vpnExtraRoute -> nullToEmpty(vpnExtraRoute.getNexthopIpList()).forEach(nextHopIp -> {
String nextHopPrefixIp;
if (isIpv4Address(nextHopIp)) {
nextHopPrefixIp = nextHopIp + NwConstants.IPV4PREFIX;
LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}",
interfaceName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().getAction();
+ actions = nullToEmpty(rpcResult.getResult().getAction());
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Exception when egress actions for interface {}", interfaceName, e);
if (!dpnLbNextHops.isPresent()) {
return;
}
- List<String> nextHopKeys = dpnLbNextHops.get().getNexthopKey();
+ List<String> nextHopKeys = nullToEmpty(dpnLbNextHops.get().getNexthopKey());
for (String nextHopKey : nextHopKeys) {
Optional<Nexthops> optionalNextHops = fibUtil.getNexthops(nextHopKey);
if (!optionalNextHops.isPresent()) {
if (!dpnLbNextHops.isPresent()) {
return;
}
- List<String> nextHopKeys = dpnLbNextHops.get().getNexthopKey();
+ List<String> nextHopKeys = nullToEmpty(dpnLbNextHops.get().getNexthopKey());
for (String nextHopKey : nextHopKeys) {
Optional<Nexthops> optionalNextHops = fibUtil.getNexthops(nextHopKey);
if (!optionalNextHops.isPresent()) {
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.netvirt.fibmanager.FibUtil.nullToEmpty;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
+import javax.annotation.Nullable;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
LabelRouteInfoBuilder builder = new LabelRouteInfoBuilder(lri);
if (!isPresentInList) {
LOG.debug("vpnName {} is not present in LRI with label {}..", vpnInstanceName, lri.getLabel());
- List<String> vpnInstanceNames = lri.getVpnInstanceList();
+ List<String> vpnInstanceNames = new ArrayList<>(nullToEmpty(lri.getVpnInstanceList()));
vpnInstanceNames.add(vpnInstanceName);
builder.setVpnInstanceList(vpnInstanceNames);
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, lriId, builder.build());
fibUtil.getVpnInstanceOpData(rd);
if (vpnInstanceOpDataEntryOptional.isPresent()) {
String vpnInstanceName = vpnInstanceOpDataEntryOptional.get().getVpnInstanceName();
- if (lri.getVpnInstanceList().contains(vpnInstanceName)) {
+ if (nullToEmpty(lri.getVpnInstanceList()).contains(vpnInstanceName)) {
localNextHopInfo = updateVpnReferencesInLri(lri, vpnInstanceName, true);
localNextHopIP = lri.getPrefix();
} else {
private BigInteger checkCreateLocalFibEntry(Prefixes localNextHopInfo, String localNextHopIP,
final Long vpnId, final String rd,
final VrfEntry vrfEntry,
- Routes routes, List<Routes> vpnExtraRoutes,
+ @Nullable Routes routes, @Nullable List<Routes> vpnExtraRoutes,
int etherType) {
String vpnName = fibUtil.getVpnNameFromId(vpnId);
if (localNextHopInfo != null) {
private boolean isVpnPresentInDpn(String rd, BigInteger dpnId) {
InstanceIdentifier<VpnToDpnList> id = VpnHelper.getVpnToDpnListIdentifier(rd, dpnId);
Optional<VpnToDpnList> dpnInVpn = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
- if (dpnInVpn.isPresent()) {
- return true;
- }
- return false;
+ return dpnInVpn.isPresent();
}
+ @Nullable
private LabelRouteInfo getLabelRouteInfo(Long label) {
InstanceIdentifier<LabelRouteInfo> lriIid = InstanceIdentifier.builder(LabelRouteMap.class)
.child(LabelRouteInfo.class, new LabelRouteInfoKey(label)).build();
}
private boolean deleteLabelRouteInfo(LabelRouteInfo lri, String vpnInstanceName,
- TypedWriteTransaction<Operational> tx) {
+ @Nullable TypedWriteTransaction<Operational> tx) {
if (lri == null) {
return true;
}
String usedRd = usedRds.isEmpty() ? primaryRd : usedRds.get(0);
Routes extraRoute = baseVrfEntryHandler.getVpnToExtraroute(vpnId, usedRd, vrfEntry.getDestPrefix());
if (extraRoute != null) {
- for (String nextHopIp : extraRoute.getNexthopIpList()) {
+ for (String nextHopIp : nullToEmpty(extraRoute.getNexthopIpList())) {
LOG.debug("NextHop IP for destination {} is {}", vrfEntry.getDestPrefix(), nextHopIp);
if (nextHopIp != null) {
String ipPrefix;
}
private void checkCleanUpOpDataForFib(final Prefixes prefixInfo, final Long vpnId, final String rd,
- final VrfEntry vrfEntry, final Routes extraRoute) {
+ final VrfEntry vrfEntry, @Nullable final Routes extraRoute) {
if (prefixInfo == null) {
LOG.error("Cleanup VPN Data Failed as unable to find prefix Info for prefix {} VpnId {} rd {}",
List<String> nextHopAddressList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
synchronized (label.toString().intern()) {
LabelRouteInfo lri = getLabelRouteInfo(label);
- if (lri != null && lri.getPrefix().equals(vrfEntry.getDestPrefix())
+ if (lri != null && Objects.equals(lri.getPrefix(), vrfEntry.getDestPrefix())
&& nextHopAddressList.contains(lri.getNextHopIpList().get(0))) {
Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional =
fibUtil.getVpnInstanceOpData(rd);
return;
}
- if (optAdjacencies.get().getAdjacency().stream().count() <= 2
- && optAdjacencies.get().getAdjacency().stream().allMatch(adjacency ->
+ if (nullToEmpty(optAdjacencies.get().getAdjacency()).size() <= 2
+ && nullToEmpty(optAdjacencies.get().getAdjacency()).stream().allMatch(adjacency ->
adjacency.getAdjacencyType() == Adjacency.AdjacencyType.PrimaryAdjacency
&& adjacency.isMarkedForDeletion() != null
&& adjacency.isMarkedForDeletion()
} else {
for (BigInteger localDpnId : localDpnIdList) {
for (VpnToDpnList curDpn : vpnToDpnList) {
- if (!curDpn.getDpnId().equals(localDpnId)) {
+ if (!Objects.equals(curDpn.getDpnId(), localDpnId)) {
baseVrfEntryHandler.deleteRemoteRoute(localDpnId, curDpn.getDpnId(),
vpnInstance.getVpnId(), vrfTableKey, vrfEntry, extraRouteOptional,
TransactionAdapter.toWriteTransaction(tx));
}
- private void makeLFibTableEntry(BigInteger dpId, long label, List<InstructionInfo> instructions, int priority,
- int addOrRemove, TypedWriteTransaction<Configuration> tx) {
+ private void makeLFibTableEntry(BigInteger dpId, long label, @Nullable List<InstructionInfo> instructions,
+ int priority, int addOrRemove, TypedWriteTransaction<Configuration> tx) {
if (tx == null) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
newTx -> makeLFibTableEntry(dpId, label, instructions, priority, addOrRemove, newTx)), LOG,
}
synchronized (vpnInstance.getVpnInstanceName().intern()) {
futures.add(retryingTxRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
- for (final VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
+ for (final VrfEntry vrfEntry : nullToEmpty(vrfTable.get().getVrfEntry())) {
SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
if (subnetRoute != null) {
long elanTag = subnetRoute.getElantag();
List<String> nextHopList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
LabelRouteInfo lri = getLabelRouteInfo(optionalLabel.get());
if (isPrefixAndNextHopPresentInLri(vrfEntry.getDestPrefix(), nextHopList, lri)) {
- if (lri.getDpnId().equals(dpnId)) {
+ if (Objects.equals(lri.getDpnId(), dpnId)) {
try {
int etherType = NWUtil.getEtherTypeFromIpPrefix(
vrfEntry.getDestPrefix());
jobCoordinator.enqueueJob(FibUtil.getJobKeyForVpnIdDpnId(vpnId, dpnId),
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
synchronized (vpnInstance.getVpnInstanceName().intern()) {
- vrfTable.get().getVrfEntry().stream()
+ nullToEmpty(vrfTable.get().getVrfEntry()).stream()
.filter(vrfEntry -> RouteOrigin.BGP == RouteOrigin.value(vrfEntry.getOrigin()))
.forEach(bgpRouteVrfEntryHandler.getConsumerForCreatingRemoteFib(dpnId, vpnId,
rd, remoteNextHopIp, vrfTable, TransactionAdapter.toWriteTransaction(tx), txnObjects));
synchronized (vpnInstance.getVpnInstanceName().intern()) {
futures.add(retryingTxRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
String vpnName = fibUtil.getVpnNameFromId(vpnInstance.getVpnId());
- for (final VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
+ for (final VrfEntry vrfEntry : nullToEmpty(vrfTable.get().getVrfEntry())) {
/* parentRd is only filled for external PNF cases where the interface on the external
* network VPN are used to cleanup the flows. For all other cases, use "rd" for
* #fibUtil.isInterfacePresentInDpn().
List<String> nextHopList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
LabelRouteInfo lri = getLabelRouteInfo(optionalLabel.get());
if (isPrefixAndNextHopPresentInLri(vrfEntry.getDestPrefix(), nextHopList,
- lri) && lri.getDpnId().equals(dpnId)) {
+ lri) && Objects.equals(lri.getDpnId(), dpnId)) {
deleteLocalFibEntry(vpnId, rd, vrfEntry);
}
}
synchronized (vpnInstance.getVpnInstanceName().intern()) {
return Collections.singletonList(
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> vrfTable.get().getVrfEntry().stream()
+ tx -> nullToEmpty(vrfTable.get().getVrfEntry()).stream()
.filter(vrfEntry -> RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP)
.forEach(bgpRouteVrfEntryHandler.getConsumerForDeletingRemoteFib(dpnId, vpnId,
remoteNextHopIp, vrfTable, TransactionAdapter.toWriteTransaction(tx),
+ tableMiss + FLOWID_PREFIX;
}
+ @Nullable
private VrfEntry getVrfEntry(DataBroker broker, String rd, String ipPrefix) {
InstanceIdentifier<VrfEntry> vrfEntryId = InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
private boolean isPrefixAndNextHopPresentInLri(String prefix,
List<String> nextHopAddressList, LabelRouteInfo lri) {
- return lri != null && lri.getPrefix().equals(prefix)
+ return lri != null && Objects.equals(lri.getPrefix(), prefix)
&& nextHopAddressList.contains(lri.getNextHopIpList().get(0));
}
package org.opendaylight.netvirt.fibmanager.shell;
import java.util.Locale;
+import javax.annotation.Nullable;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
import org.apache.karaf.shell.console.OsgiCommandSupport;
}
@Override
+ @Nullable
protected Object doExecute() {
if (service == null || service.isEmpty() || !"L3VPN".equalsIgnoreCase(service)) {
import java.net.UnknownHostException;
import java.util.List;
import java.util.Locale;
+import javax.annotation.Nullable;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.commands.Option;
}
@Override
+ @Nullable
protected Object doExecute() {
PrintStream console = session.getConsole();
if (prefixOrSubnetOption != null && prefixOrSubnetOption.length() > 0) {
}
private void printVrfTable(VrfTables vrfTable, PrintStream console, boolean isIpv4, boolean isIpv6,
- boolean isL2vpn, String inputPrefixOrSubnet) {
+ boolean isL2vpn, @Nullable String inputPrefixOrSubnet) {
List<VrfEntry> vrfEntries = vrfTable.getVrfEntry();
if (vrfEntries == null) {
}
}
+ @Nullable
private Object usage(PrintStream console) {
String nl = System.getProperty("line.separator");
console.println("===================================================");
*/
package org.opendaylight.netvirt.fibmanager.shell;
+import javax.annotation.Nullable;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
}
@Override
+ @Nullable
protected Object doExecute() {
String displayFormat = "%-16s %-16s";
String cacheVal = fibManager.getReqTransType();
Code Review / netvirt.git / commitdiff