use of org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6 in project bgpcep by opendaylight.
the class SrAttributeParserTest method testRangeTlvIpv6.
@Test
public void testRangeTlvIpv6() {
final byte[] tested = Bytes.concat(new byte[] { 0, 0, 0, 5, // binding sid
4, // binding sid
(byte) 0x88, // binding sid
0, // binding sid
0x34, // binding sid
5, // binding sid
0x48, // binding sid
0, // binding sid
0, // binding sub-tlvs
4, (byte) 0x8c, 0, 0x14, 0, 0, 0, // IPv6 ERO
0 }, // IPv6 ERO
IPV6_A_BYTES, // IPv6 ERO backup
new byte[] { 4, (byte) 0x8f, 0, 0x14, 0, 0, 0, 0 }, // IPv6 ERO backup
IPV6_B_BYTES);
final SrRange parsedRange = RangeTlvParser.parseSrRange(Unpooled.wrappedBuffer(tested), ProtocolId.IsisLevel1);
final List<SubTlvs> rangeSubTlvs = new ArrayList<>();
final List<BindingSubTlvs> bindingSubTlvs = new ArrayList<>();
bindingSubTlvs.add(new BindingSubTlvsBuilder().setBindingSubTlv(new Ipv6EroCaseBuilder().setLoose(Boolean.FALSE).setAddress(new Ipv6Address(IPV6_A)).build()).build());
bindingSubTlvs.add(new BindingSubTlvsBuilder().setBindingSubTlv(new Ipv6EroBackupCaseBuilder().setLoose(Boolean.FALSE).setAddress(new Ipv6Address(IPV6_B)).build()).build());
rangeSubTlvs.add(new SubTlvsBuilder().setRangeSubTlv(new BindingSidTlvCaseBuilder().setWeight(new Weight((short) 5)).setFlags(BINDING_FLAGS).setBindingSubTlvs(bindingSubTlvs).build()).build());
final SrRange expected = new SrRangeBuilder().setInterArea(Boolean.FALSE).setRangeSize(5).setSubTlvs(rangeSubTlvs).build();
assertEquals(expected, parsedRange);
final ByteBuf serializedRange = Unpooled.buffer();
RangeTlvParser.serializeSrRange(parsedRange, serializedRange);
assertArrayEquals(tested, ByteArray.getAllBytes(serializedRange));
}
use of org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6 in project bgpcep by opendaylight.
the class ReachTlvParser method serializeModel.
public static IpPrefix serializeModel(final ContainerNode prefixDesc) {
if (prefixDesc.getChild(IP_REACH_NID).isPresent()) {
final String prefix = (String) prefixDesc.getChild(IP_REACH_NID).get().getValue();
try {
final ByteBuf buffer = Unpooled.buffer(5);
ByteBufWriteUtil.writeMinimalPrefix(new Ipv4Prefix(prefix), buffer);
return new IpPrefix(new Ipv4Prefix(prefix));
} catch (final IllegalArgumentException e) {
LOG.debug("Creating Ipv6 prefix because", e);
return new IpPrefix(new Ipv6Prefix(prefix));
}
}
return null;
}
use of org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6 in project netvirt by opendaylight.
the class VpnInterfaceManager method processVpnInterfaceUp.
// "Unconditional wait" and "Wait not in loop" wrt the VpnNotifyTask below - suppressing the FB violation -
// see comments below.
@SuppressFBWarnings({ "UW_UNCOND_WAIT", "WA_NOT_IN_LOOP" })
protected void processVpnInterfaceUp(final BigInteger dpId, VpnInterface vpnInterface, final String primaryRd, final int lportTag, boolean isInterfaceUp, WriteTransaction writeConfigTxn, WriteTransaction writeOperTxn, WriteTransaction writeInvTxn, Interface interfaceState, final String vpnName) {
final String interfaceName = vpnInterface.getName();
Optional<VpnInterfaceOpDataEntry> optOpVpnInterface = VpnUtil.getVpnInterfaceOpDataEntry(dataBroker, interfaceName, vpnName);
VpnInterfaceOpDataEntry opVpnInterface = optOpVpnInterface.isPresent() ? optOpVpnInterface.get() : null;
boolean isBgpVpnInternetVpn = VpnUtil.isBgpVpnInternet(dataBroker, vpnName);
if (!isInterfaceUp) {
LOG.info("processVpnInterfaceUp: Binding vpn service to interface {} onto dpn {} for vpn {}", interfaceName, dpId, vpnName);
long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
if (vpnId == VpnConstants.INVALID_ID) {
LOG.warn("processVpnInterfaceUp: VpnInstance to VPNId mapping not available for VpnName {}" + " processing vpninterface {} on dpn {}, bailing out now.", vpnName, interfaceName, dpId);
return;
}
boolean waitForVpnInterfaceOpRemoval = false;
if (opVpnInterface != null && !opVpnInterface.isScheduledForRemove()) {
String opVpnName = opVpnInterface.getVpnInstanceName();
String primaryInterfaceIp = null;
if (opVpnName.equals(vpnName)) {
// Please check if the primary VRF Entry does not exist for VPNInterface
// If so, we have to process ADD, as this might be a DPN Restart with Remove and Add triggered
// back to back
// However, if the primary VRF Entry for this VPNInterface exists, please continue bailing out !
List<Adjacency> adjs = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(dataBroker, interfaceName);
if (adjs == null) {
LOG.error("processVpnInterfaceUp: VPN Interface {} on dpn {} for vpn {} failed as adjacencies" + " for this vpn interface could not be obtained", interfaceName, dpId, vpnName);
return;
}
for (Adjacency adj : adjs) {
if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
primaryInterfaceIp = adj.getIpAddress();
break;
}
}
if (primaryInterfaceIp == null) {
LOG.error("processVpnInterfaceUp: VPN Interface {} addition on dpn {} for vpn {} failed" + " as primary adjacency for this vpn interface could not be obtained", interfaceName, dpId, vpnName);
return;
}
// Get the rd of the vpn instance
VrfEntry vrf = VpnUtil.getVrfEntry(dataBroker, primaryRd, primaryInterfaceIp);
if (vrf != null) {
LOG.error("processVpnInterfaceUp: VPN Interface {} on dpn {} for vpn {} already provisioned ," + " bailing out from here.", interfaceName, dpId, vpnName);
return;
}
waitForVpnInterfaceOpRemoval = true;
} else {
LOG.error("processVpnInterfaceUp: vpn interface {} to go to configured vpn {} on dpn {}," + " but in operational vpn {}", interfaceName, vpnName, dpId, opVpnName);
}
}
if (!waitForVpnInterfaceOpRemoval) {
// Add the VPNInterface and quit
vpnFootprintService.updateVpnToDpnMapping(dpId, vpnName, primaryRd, interfaceName, null, /*ipAddressSourceValuePair*/
true);
processVpnInterfaceAdjacencies(dpId, lportTag, vpnName, primaryRd, interfaceName, vpnId, writeConfigTxn, writeOperTxn, writeInvTxn, interfaceState);
if (!isBgpVpnInternetVpn) {
VpnUtil.bindService(vpnName, interfaceName, dataBroker, false, /*isTunnelInterface*/
jobCoordinator);
}
LOG.info("processVpnInterfaceUp: Plumbed vpn interface {} onto dpn {} for vpn {}", interfaceName, dpId, vpnName);
if (interfaceManager.isExternalInterface(interfaceName)) {
processExternalVpnInterface(interfaceName, vpnName, vpnId, dpId, lportTag, writeInvTxn, NwConstants.ADD_FLOW);
}
return;
}
// FIB didn't get a chance yet to clean up this VPNInterface
// Let us give it a chance here !
LOG.info("processVpnInterfaceUp: Trying to add VPN Interface {} on dpn {} for vpn {}," + " but waiting for FIB to clean up! ", interfaceName, dpId, vpnName);
try {
Runnable notifyTask = new VpnNotifyTask();
synchronized (notifyTask) {
// Per FB's "Unconditional wait" violation, the code should really verify that the condition it
// intends to wait for is not already satisfied before calling wait. However the VpnNotifyTask is
// published here while holding the lock on it so this path will hit the wait before notify can be
// invoked.
vpnIntfMap.put(interfaceName, notifyTask);
try {
notifyTask.wait(VpnConstants.MAX_WAIT_TIME_IN_MILLISECONDS);
} catch (InterruptedException e) {
// Ignored
}
}
} finally {
vpnIntfMap.remove(interfaceName);
}
if (opVpnInterface != null) {
LOG.warn("processVpnInterfaceUp: VPN Interface {} removal on dpn {} for vpn {}" + " by FIB did not complete on time," + " bailing addition ...", interfaceName, dpId, vpnName);
VpnUtil.unsetScheduledToRemoveForVpnInterface(txRunner, interfaceName);
return;
}
// VPNInterface got removed, proceed with Add
LOG.info("processVpnInterfaceUp: Continuing to plumb vpn interface {} onto dpn {} for vpn {}", interfaceName, dpId, vpnName);
vpnFootprintService.updateVpnToDpnMapping(dpId, vpnName, primaryRd, interfaceName, null, /*ipAddressSourceValuePair*/
true);
processVpnInterfaceAdjacencies(dpId, lportTag, vpnName, primaryRd, interfaceName, vpnId, writeConfigTxn, writeOperTxn, writeInvTxn, interfaceState);
if (!isBgpVpnInternetVpn) {
VpnUtil.bindService(vpnName, interfaceName, dataBroker, false, /*isTunnelInterface*/
jobCoordinator);
}
LOG.info("processVpnInterfaceUp: Plumbed vpn interface {} onto dpn {} for vpn {} after waiting for" + " FIB to clean up", interfaceName, dpId, vpnName);
if (interfaceManager.isExternalInterface(interfaceName)) {
processExternalVpnInterface(interfaceName, vpnName, vpnId, dpId, lportTag, writeInvTxn, NwConstants.ADD_FLOW);
}
} else {
// Interface is retained in the DPN, but its Link Up.
// Advertise prefixes again for this interface to BGP
InstanceIdentifier<VpnInterface> identifier = VpnUtil.getVpnInterfaceIdentifier(vpnInterface.getName());
InstanceIdentifier<VpnInterfaceOpDataEntry> vpnInterfaceOpIdentifier = VpnUtil.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
advertiseAdjacenciesForVpnToBgp(primaryRd, dpId, vpnInterfaceOpIdentifier, vpnName, interfaceName);
// Perform similar operation as interface add event for extraroutes.
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
Optional<Adjacencies> optAdjacencies = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
if (!optAdjacencies.isPresent()) {
LOG.trace("No config adjacencies present for vpninterface {}", vpnInterface);
return;
}
List<Adjacency> adjacencies = optAdjacencies.get().getAdjacency();
for (Adjacency adjacency : adjacencies) {
if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
continue;
}
// if BGPVPN Internet, filter only IPv6 Adjacencies
if (isBgpVpnInternetVpn && !VpnUtil.isAdjacencyEligibleToVpnInternet(dataBroker, adjacency)) {
continue;
}
addNewAdjToVpnInterface(vpnInterfaceOpIdentifier, primaryRd, adjacency, dpId, writeOperTxn, writeConfigTxn);
}
}
}
use of org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6 in project netvirt by opendaylight.
the class VpnOpStatusListener method update.
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
protected void update(InstanceIdentifier<VpnInstanceOpDataEntry> identifier, VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
LOG.info("update: Processing update for vpn {} with rd {}", update.getVpnInstanceName(), update.getVrfId());
if (update.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete && vpnFootprintService.isVpnFootPrintCleared(update)) {
// Cleanup VPN data
final String vpnName = update.getVpnInstanceName();
final List<String> rds = update.getRd();
String primaryRd = update.getVrfId();
final long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
jobCoordinator.enqueueJob("VPN-" + update.getVpnInstanceName(), () -> {
WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
// Clean up VpnInstanceToVpnId from Config DS
VpnUtil.removeVpnIdToVpnInstance(dataBroker, vpnId, writeTxn);
VpnUtil.removeVpnInstanceToVpnId(dataBroker, vpnName, writeTxn);
LOG.trace("Removed vpnIdentifier for rd{} vpnname {}", primaryRd, vpnName);
// Clean up FIB Entries Config DS
fibManager.removeVrfTable(primaryRd, null);
// Clean up VPNExtraRoutes Operational DS
if (VpnUtil.isBgpVpn(vpnName, primaryRd)) {
if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.L2VPN));
}
if (update.isIpv4Configured()) {
rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.IPV4));
}
if (update.isIpv6Configured()) {
rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.IPV6));
}
}
InstanceIdentifier<Vpn> vpnToExtraroute = VpnExtraRouteHelper.getVpnToExtrarouteVpnIdentifier(vpnName);
Optional<Vpn> optVpnToExtraroute = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
if (optVpnToExtraroute.isPresent()) {
VpnUtil.removeVpnExtraRouteForVpn(dataBroker, vpnName, writeTxn);
}
if (VpnUtil.isL3VpnOverVxLan(update.getL3vni())) {
VpnUtil.removeExternalTunnelDemuxFlows(vpnName, dataBroker, mdsalManager);
}
// Clean up VPNInstanceOpDataEntry
VpnUtil.removeVpnOpInstance(dataBroker, primaryRd, writeTxn);
// Clean up PrefixToInterface Operational DS
VpnUtil.removePrefixToInterfaceForVpnId(dataBroker, vpnId, writeTxn);
// Clean up L3NextHop Operational DS
VpnUtil.removeL3nexthopForVpnId(dataBroker, vpnId, writeTxn);
// Release the ID used for this VPN back to IdManager
VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME, vpnName);
List<ListenableFuture<Void>> futures = new ArrayList<>();
futures.add(writeTxn.submit());
return futures;
}, SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
} else if (update.getVpnState() == VpnInstanceOpDataEntry.VpnState.Created) {
final String vpnName = update.getVpnInstanceName();
final List<String> rds = update.getRd();
String primaryRd = update.getVrfId();
if (!VpnUtil.isBgpVpn(vpnName, primaryRd)) {
return;
}
if (original == null) {
LOG.error("VpnOpStatusListener.update: vpn {} with RD {}. add() handler already called", vpnName, primaryRd);
return;
}
if (update.getVpnTargets() == null) {
LOG.error("VpnOpStatusListener.update: vpn {} with RD {} vpnTargets not ready", vpnName, primaryRd);
return;
}
List<VpnTarget> vpnTargetList = update.getVpnTargets().getVpnTarget();
List<String> ertList = new ArrayList<>();
List<String> irtList = new ArrayList<>();
if (vpnTargetList != null) {
for (VpnTarget vpnTarget : vpnTargetList) {
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
ertList.add(vpnTarget.getVrfRTValue());
}
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
irtList.add(vpnTarget.getVrfRTValue());
}
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
ertList.add(vpnTarget.getVrfRTValue());
irtList.add(vpnTarget.getVrfRTValue());
}
}
} else {
LOG.error("VpnOpStatusListener.update: vpn target list is empty, cannot add BGP" + " VPN {} RD {}", vpnName, primaryRd);
return;
}
jobCoordinator.enqueueJob("VPN-" + update.getVpnInstanceName(), () -> {
WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
long primaryRdAddFailed = rds.parallelStream().filter(rd -> {
try {
LOG.info("VpnOpStatusListener.update: updating BGPVPN for vpn {} with RD {}" + " Type is {}, IPv4 is {}, IPv6 is {}", vpnName, primaryRd, update.getType(), update.isIpv4Configured(), update.isIpv6Configured());
if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
bgpManager.addVrf(rd, irtList, ertList, AddressFamily.L2VPN);
} else {
bgpManager.deleteVrf(rd, false, AddressFamily.L2VPN);
}
if (!original.isIpv4Configured() && update.isIpv4Configured()) {
bgpManager.addVrf(rd, irtList, ertList, AddressFamily.IPV4);
} else if (original.isIpv4Configured() && !update.isIpv4Configured()) {
bgpManager.deleteVrf(rd, false, AddressFamily.IPV4);
}
if (!original.isIpv6Configured() && update.isIpv6Configured()) {
bgpManager.addVrf(rd, irtList, ertList, AddressFamily.IPV6);
} else if (original.isIpv6Configured() && !update.isIpv6Configured()) {
bgpManager.deleteVrf(rd, false, AddressFamily.IPV6);
}
} catch (Exception e) {
LOG.error("VpnOpStatusListener.update: Exception when updating VRF to BGP" + " for vpn {} rd {}", vpnName, rd);
return false;
}
return false;
}).count();
return Collections.emptyList();
});
}
}
use of org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6 in project netvirt by opendaylight.
the class Cache method doExecute.
@SuppressWarnings("resource")
@Override
protected Object doExecute() {
boolean listVrfs = false;
boolean listNets = false;
PrintStream ps = session.getConsole();
if (action != null) {
return usage();
}
PrintStream fileStream = null;
if (ofile != null) {
try {
fileStream = new PrintStream(ofile);
ps = fileStream;
} catch (FileNotFoundException e) {
session.getConsole().println("error: cannot create file " + ofile + "; exception: " + e);
return null;
}
}
if (list != null) {
for (String item : list) {
switch(item) {
case "vrfs":
listVrfs = true;
break;
case "networks":
listNets = true;
break;
default:
session.getConsole().println("error: unknown value for " + LST + ": " + item);
if (fileStream != null) {
fileStream.close();
}
return null;
}
}
}
// we'd normally read this directly from 'config' but
// legacy behaviour forces to check for a connection
// that's initiated by default at startup without
// writing to config.
String configHost = bgpManager.getConfigHost();
int configPort = bgpManager.getConfigPort();
ps.printf("%nConfiguration Server%n\t%s %s%n\t%s %d%n", HTSTR, configHost, PTSTR, configPort);
Bgp config = bgpManager.getConfig();
if (config == null) {
if (fileStream != null) {
fileStream.close();
}
return null;
}
AsId asId = config.getAsId();
if (asId != null) {
int asNum = asId.getLocalAs().intValue();
IpAddress routerId = asId.getRouterId();
Long spt = asId.getStalepathTime();
Boolean afb = asId.isAnnounceFbit();
String rid = routerId == null ? "<n/a>" : new String(routerId.getValue());
// F-bit is always set to ON (hardcoded), in SDN even though the controller is down
// forwarding state shall be retained.
String bit = "ON";
GracefulRestart gracefulRestart = config.getGracefulRestart();
if (gracefulRestart != null) {
spt = gracefulRestart.getStalepathTime();
}
ps.printf("%nBGP Router%n");
ps.printf("\t%-15s %d%n\t%-15s %s%n\t%-15s %s%n\t%-15s %s%n", ASSTR, asNum, RISTR, rid, SPSTR, spt == null || spt == 0 ? "default" : spt.toString(), FBSTR, bit);
}
Logging logging = config.getLogging();
if (logging != null) {
ps.printf("\t%-15s %s%n\t%-15s %s%n", LFSTR, logging.getFile(), LLSTR, logging.getLevel());
}
List<Neighbors> neighbors = config.getNeighbors();
if (neighbors != null) {
ps.printf("%nNeighbors%n");
for (Neighbors nbr : neighbors) {
ps.printf("\t%s%n\t\t%-16s %d%n", nbr.getAddress().getValue(), ASSTR, nbr.getRemoteAs().intValue());
EbgpMultihop en = nbr.getEbgpMultihop();
if (en != null) {
ps.printf("\t\t%-16s %d%n", EBSTR, en.getNhops().intValue());
}
UpdateSource us = nbr.getUpdateSource();
if (us != null) {
ps.printf("\t\t%-16s %s%n", USSTR, us.getSourceIp().getValue());
}
ps.printf("\t\t%-16s IPv4-Labeled-VPN", AFSTR);
List<AddressFamilies> afs = nbr.getAddressFamilies();
if (afs != null) {
for (AddressFamilies af : afs) {
// Should not print "unknown" in vpnv4 case
if (!(af.getSafi().intValue() == 5 && af.getAfi().intValue() == 1)) {
if (af.getSafi().intValue() == 4 && af.getAfi().intValue() == 1) {
ps.printf(" %s", "IPv4-Labeled-Unicast");
} else if (af.getSafi().intValue() == 5 && af.getAfi().intValue() == 2) {
ps.printf(" %s", "IPv6-Labeled-VPN");
} else if (af.getSafi().intValue() == 6) {
ps.printf(" %s", "Ethernet-VPN");
} else {
ps.printf(" %s", "Unknown");
}
}
}
}
ps.printf("%n");
}
}
if (listVrfs) {
List<Vrfs> vrfs = config.getVrfs();
if (vrfs != null) {
ps.printf("%nVRFs%n");
for (Vrfs vrf : vrfs) {
ps.printf("\t%s%n", vrf.getRd());
ps.printf("\t\t%s ", IRSTR);
for (String rt : vrf.getImportRts()) {
ps.printf("%s ", rt);
}
ps.printf("%n\t\t%s ", ERSTR);
for (String rt : vrf.getExportRts()) {
ps.printf("%s ", rt);
}
for (AddressFamiliesVrf adf : vrf.getAddressFamiliesVrf()) {
ps.printf("%n\t\tafi %d safi %d", adf.getAfi(), adf.getSafi());
}
ps.printf("%n");
}
}
}
if (listNets) {
List<Networks> ln = config.getNetworks();
if (ln != null) {
ps.printf("%nNetworks%n");
for (Networks net : ln) {
String rd = net.getRd();
String pfxlen = net.getPrefixLen();
String nh = net.getNexthop().getValue();
int label = net.getLabel().intValue();
ps.printf("\t%s%n\t\t%-7s %s%n\t\t%-7s %s%n\t\t%-7s %d%n", pfxlen, RDSTR, rd, NHSTR, nh, LBSTR, label);
}
}
}
List<Multipath> mp = config.getMultipath();
List<VrfMaxpath> vrfm = config.getVrfMaxpath();
if (mp != null) {
ps.printf("%nMultipath%n");
for (Multipath multipath : mp) {
int afi = multipath.getAfi().intValue();
int safi = multipath.getSafi().intValue();
Boolean enabled = multipath.isMultipathEnabled();
if (enabled) {
if (afi == 1 && safi == 5) {
ps.printf("\t%-16s %s%n%n", AFSTR, "vpnv4");
} else if (afi == 2 && safi == 5) {
ps.printf("\t%-16s %s%n%n", AFSTR, "vpnv6");
} else if (afi == 3 && safi == 6) {
ps.printf("\t%-16s %s%n%n", AFSTR, "evpn");
} else {
ps.printf("\t%-16s %s%n%n", AFSTR, "Unknown");
}
if (vrfm != null) {
ps.printf("\t%-16s %s%n", RDSTR, MPSTR);
for (VrfMaxpath vrfMaxpath : vrfm) {
String rd = vrfMaxpath.getRd();
int maxpath = vrfMaxpath.getMaxpaths();
ps.printf("\t%-16s %d%n", rd, maxpath);
}
}
}
}
}
if (fileStream != null) {
fileStream.close();
}
return null;
}
Aggregations