* 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.fibmanager.api;
import static java.util.Comparator.comparing;
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.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-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.eclipse.jdt.annotation.Nullable;
+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;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class FibHelper {
+ private FibHelper() {
- private FibHelper() { }
+ }
- public static RoutePaths buildRoutePath(String nextHop, Long label) {
+ public static RoutePaths buildRoutePath(String nextHop, Uint32 label) {
RoutePathsBuilder builder = new RoutePathsBuilder()
- .setKey(new RoutePathsKey(nextHop))
+ .withKey(new RoutePathsKey(nextHop))
.setNexthopAddress(nextHop);
if (label != null) {
builder.setLabel(label);
return builder.build();
}
- public static VrfEntryBuilder getVrfEntryBuilder(String prefix, RouteOrigin origin, String parentVpnRd) {
- return new VrfEntryBuilder().setKey(new VrfEntryKey(prefix)).setDestPrefix(prefix)
+ 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) {
- return new VrfEntryBuilder().setKey(new VrfEntryKey(prefix)).setDestPrefix(prefix)
+ 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) {
+ public static VrfEntryBuilder getVrfEntryBuilder(String prefix, Uint32 label, String nextHop, RouteOrigin origin,
+ @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) {
+ public static VrfEntryBuilder getVrfEntryBuilder(VrfEntry vrfEntry, Uint32 label,
+ List<String> nextHopList, RouteOrigin origin, @Nullable String parentvpnRd) {
List<RoutePaths> routePaths =
nextHopList.stream().map(nextHop -> buildRoutePath(nextHop, label))
.collect(toList());
return idBuilder.build();
}
- public static boolean isControllerManagedRoute(RouteOrigin routeOrigin) {
- return routeOrigin == RouteOrigin.STATIC
- || routeOrigin == RouteOrigin.CONNECTED
- || routeOrigin == RouteOrigin.LOCAL
- || routeOrigin == RouteOrigin.INTERVPN;
- }
-
public static boolean isControllerManagedNonInterVpnLinkRoute(RouteOrigin routeOrigin) {
return routeOrigin == RouteOrigin.STATIC
|| routeOrigin == RouteOrigin.CONNECTED
}
}
- public static InstanceIdentifier<RoutePaths> getRoutePathsIdentifier(String rd, String prefix, String nh) {
- return InstanceIdentifier.builder(FibEntries.class)
- .child(VrfTables.class,new VrfTablesKey(rd)).child(VrfEntry.class,new VrfEntryKey(prefix))
- .child(RoutePaths.class, new RoutePathsKey(nh)).build();
- }
-
public static List<String> getNextHopListFromRoutePaths(final VrfEntry vrfEntry) {
- List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
- if (routePaths == null || routePaths.isEmpty()) {
+ Map<RoutePathsKey, RoutePaths> keyRoutePathsMap = vrfEntry.getRoutePaths();
+ if (keyRoutePathsMap == null || keyRoutePathsMap.isEmpty()) {
return new ArrayList<>();
}
- return routePaths.stream()
+ return keyRoutePathsMap.values().stream()
.map(RoutePaths::getNexthopAddress)
.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);
* @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;
return val;
}
- /**This methode return the bytes representation from an IP.
- * @param ipBigInteger value integer of IP to convert
- * @param isIpv4 if is ipv4 setup to true if ipv6 setup to false
- * @return byte[] which contained the representation of bytes from th ip value
- */
- public static byte[] unpackBigInteger(BigInteger ipBigInteger, boolean isIpv4) {
- int sizeBloc = 4;
- if (!isIpv4) {
- sizeBloc = 128 / 8;// if ipv6 size of dataIP is 128 bits
- }
- byte[] res = new byte[sizeBloc];
- for (int i = 0 ; i < sizeBloc ; i++) {
- BigInteger bigInt = ipBigInteger.shiftRight(i * 8);
- bigInt = bigInt.and(BigInteger.valueOf(0xFF));
- res[sizeBloc - 1 - i] = bigInt.byteValue();
- }
- return res;
- }
-
/**get the bits cache mask of net for a ip version type.
* @param ipVersion version of ip must be 4 or 6
* @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) {
}
return bb;
}
+
+ public static String getJobKeyForDcGwLoadBalancingGroup(Uint64 dpnId) {
+ return new StringBuilder().append("NextHopManager").append(dpnId).toString();
+ }
}
Code Review / netvirt.git / blobdiff