import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.NwConstants;
-import org.opendaylight.genius.utils.batching.DefaultBatchHandler;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
private static final String DEL_WARN = "Config store updated; undo with Add if needed.";
private static final String UPD_WARN = "Update operation not supported; Config store updated;"
+ " restore with another Update if needed.";
- private static final int DEFAULT_BATCH_SIZE = 1000;
- private static final int DEFAULT_BATCH_INTERVAL = 500;
private static final Class<?>[] REACTORS = {
ConfigServerReactor.class, AsIdReactor.class,
private final FibDSWriter fibDSWriter;
private final IVpnLinkService vpnLinkService;
private final BundleContext bundleContext;
+ private final BgpUtil bgpUtil;
private volatile Bgp config;
private final BgpRouter bgpRouter;
private final BgpSyncHandle bgpSyncHandle = new BgpSyncHandle();
final EntityOwnershipService entityOwnershipService,
final FibDSWriter fibDSWriter,
final IVpnLinkService vpnLinkSrvce,
- final BundleContext bundleContext)
+ final BundleContext bundleContext,
+ final BgpUtil bgpUtil)
throws InterruptedException, ExecutionException, TimeoutException {
this.dataBroker = dataBroker;
this.fibDSWriter = fibDSWriter;
this.vpnLinkService = vpnLinkSrvce;
this.bundleContext = bundleContext;
+ this.bgpUtil = bgpUtil;
String updatePort = getProperty(UPDATE_PORT, DEF_UPORT);
hostStartup = getProperty(CONFIG_HOST, DEF_CHOST);
portStartup = getProperty(CONFIG_PORT, DEF_CPORT);
LOG.info("BGP Configuration manager initialized");
initer.countDown();
- Integer batchSize = Integer.getInteger("batch.size", DEFAULT_BATCH_SIZE);
-
- Integer batchInterval = Integer.getInteger("batch.wait.time", DEFAULT_BATCH_INTERVAL);
- BgpUtil.registerWithBatchManager(
- new DefaultBatchHandler(dataBroker, LogicalDatastoreType.CONFIGURATION, batchSize, batchInterval));
-
GlobalEventExecutor.INSTANCE.execute(() -> {
final WaitingServiceTracker<IBgpManager> tracker = WaitingServiceTracker.create(
IBgpManager.class, bundleContext);
boolean needUpdate = addToRt2TepMap(rd, tepIp, mac, l2vni);
if (needUpdate) {
LOG.info("Adding tepIp {} with RD {} to ELan DS", tepIp, rd);
- BgpUtil.addTepToElanInstance(dataBroker, rd, tepIp);
+ bgpUtil.addTepToElanInstance(rd, tepIp);
} else {
LOG.debug("Skipping the Elan update for RT2 from tep {} rd {}", tepIp, rd);
}
boolean needUpdate = deleteFromRt2TepMap(rd, tepIp, mac);
if (needUpdate) {
LOG.info("Deleting tepIp {} with RD {} to ELan DS", tepIp, rd);
- BgpUtil.deleteTepFromElanInstance(dataBroker, rd, tepIp);
+ bgpUtil.deleteTepFromElanInstance(rd, tepIp);
} else {
LOG.debug("Skipping the Elan update for RT2 withdraw from tep {} rd {}", tepIp, rd);
}
VrfEntry.EncapType encapType = VrfEntry.EncapType.Mplsgre;
if (protocolType.equals(protocol_type.PROTOCOL_EVPN)) {
encapType = VrfEntry.EncapType.Vxlan;
- VpnInstanceOpDataEntry vpnInstanceOpDataEntry = BgpUtil.getVpnInstanceOpData(dataBroker, rd);
+ VpnInstanceOpDataEntry vpnInstanceOpDataEntry = bgpUtil.getVpnInstanceOpData(rd);
if (vpnInstanceOpDataEntry != null) {
if (vpnInstanceOpDataEntry.getType() == VpnInstanceOpDataEntry.Type.L2) {
LOG.info("Got RT2 route for RD {} l3label {} l2label {} from tep {} with mac {} remote RD {}",
fibDSWriter.addFibEntryToDS(rd, macaddress, prefix + "/" + plen, nextHopList, encapType, label, l3vni,
routermac, RouteOrigin.BGP);
LOG.info("ADD: Added Fib entry rd {} prefix {} nexthop {} label {}", rd, prefix, nextHop, label);
- String vpnName = BgpUtil.getVpnNameFromRd(dataBroker, rd);
+ String vpnName = bgpUtil.getVpnNameFromRd(rd);
if (vpnName != null) {
vpnLinkService.leakRouteIfNeeded(vpnName, prefix, nextHopList, label, RouteOrigin.BGP,
NwConstants.ADD_FLOW);
long vni = 0L;
boolean macupdate = false;
if (protocolType.equals(protocol_type.PROTOCOL_EVPN)) {
- VpnInstanceOpDataEntry vpnInstanceOpDataEntry = BgpUtil.getVpnInstanceOpData(dataBroker, rd);
+ VpnInstanceOpDataEntry vpnInstanceOpDataEntry = bgpUtil.getVpnInstanceOpData(rd);
if (vpnInstanceOpDataEntry != null) {
vni = vpnInstanceOpDataEntry.getL3vni();
if (vpnInstanceOpDataEntry.getType() == VpnInstanceOpDataEntry.Type.L2) {
public void onUpdateWithdrawRoute(String rd, String prefix, int plen, String nexthop) {
LOG.debug("Route del ** {} ** {}/{} ", rd, prefix, plen);
fibDSWriter.removeOrUpdateFibEntryFromDS(rd, prefix + "/" + plen, nexthop);
- String vpnName = BgpUtil.getVpnNameFromRd(dataBroker, rd);
+ String vpnName = bgpUtil.getVpnNameFromRd(rd);
if (vpnName != null) {
vpnLinkService.leakRouteIfNeeded(vpnName, prefix, null /*nextHopList*/, 0 /*INVALID_LABEL*/,
RouteOrigin.BGP, NwConstants.DEL_FLOW);
}
private <T extends DataObject> void update(InstanceIdentifier<T> iid, T dto) {
- BgpUtil.update(dataBroker, LogicalDatastoreType.CONFIGURATION, iid, dto);
+ bgpUtil.update(LogicalDatastoreType.CONFIGURATION, iid, dto);
}
private <T extends DataObject> void delete(InstanceIdentifier<T> iid) {
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, iid);
+ bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, iid);
}
public void startConfig(String bgpHost, int thriftPort) {
// TODO: add LayerType as arg - supports command
public void addVrf(String rd, List<String> irts, List<String> erts, AddressFamily addressFamily) {
- Vrfs vrf = BgpUtil.getVrfFromRd(rd);
+ Vrfs vrf = bgpUtil.getVrfFromRd(rd);
List<AddressFamiliesVrf> adfList = new ArrayList<>(1);
if (vrf != null) {
adfList = vrf.getAddressFamiliesVrf();
adfBuilder.setAfi((long) af_afi.AFI_IP.getValue());
adfBuilder.setSafi((long) af_safi.SAFI_EVPN.getValue());
}
- Vrfs vrfOriginal = BgpUtil.getVrfFromRd(rd);
+ Vrfs vrfOriginal = bgpUtil.getVrfFromRd(rd);
if (vrfOriginal == null) {
LOG.error("delVrf: no vrf with existing rd {}. step aborted", rd);
return false;
try {
staledFibEntriesMap.clear();
InstanceIdentifier<FibEntries> id = InstanceIdentifier.create(FibEntries.class);
- DataBroker db = BgpUtil.getBroker();
- if (db == null) {
- LOG.error("Couldn't find BgpUtil dataBroker while creating createStaleFibMap");
- return;
- }
- Optional<FibEntries> fibEntries = SingleTransactionDataBroker.syncReadOptional(BgpUtil.getBroker(),
+ Optional<FibEntries> fibEntries = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (fibEntries.isPresent()) {
List<VrfTables> staleVrfTables = fibEntries.get().getVrfTables();
totalExternalMacRoutes = 0;
try {
InstanceIdentifier<FibEntries> id = InstanceIdentifier.create(FibEntries.class);
- DataBroker db = BgpUtil.getBroker();
- if (db == null) {
- LOG.error("Couldn't find BgpUtil dataBroker while deleting external routes");
- return;
- }
- Optional<FibEntries> fibEntries = SingleTransactionDataBroker.syncReadOptional(BgpUtil.getBroker(),
+ Optional<FibEntries> fibEntries = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (fibEntries.isPresent()) {
if (fibEntries.get().getVrfTables() == null) {
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.thrift.TException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.bgpmanager.oam.BgpAlarmErrorCodes;
import org.opendaylight.netvirt.bgpmanager.oam.BgpConstants;
@Singleton
public class BgpManager implements AutoCloseable, IBgpManager {
private static final Logger LOG = LoggerFactory.getLogger(BgpManager.class);
- private final DataBroker dataBroker;
private final BgpConfigurationManager bcm;
private final FibDSWriter fibDSWriter;
private volatile long qbgprestartTS = 0;
@Inject
- public BgpManager(final DataBroker dataBroker,
- final BgpConfigurationManager bcm,
- final FibDSWriter fibDSWriter) {
- this.dataBroker = dataBroker;
+ public BgpManager(final BgpConfigurationManager bcm, final FibDSWriter fibDSWriter) {
this.bcm = bcm;
this.fibDSWriter = fibDSWriter;
}
@PostConstruct
public void init() {
- BgpUtil.setBroker(dataBroker);
LOG.info("{} start", getClass().getSimpleName());
}
package org.opendaylight.netvirt.bgpmanager;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadFactory;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.batching.ActionableResource;
import org.opendaylight.genius.utils.batching.ActionableResourceImpl;
+import org.opendaylight.genius.utils.batching.DefaultBatchHandler;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
-import org.opendaylight.genius.utils.batching.ResourceHandler;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_afi;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_safi;
import org.opendaylight.netvirt.bgpmanager.thrift.gen.encap_type;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class BgpUtil {
-
+@Singleton
+public class BgpUtil implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(BgpUtil.class);
+ private static final String RESOURCE_TYPE = "BGP-RESOURCES";
+ private static final int DEFAULT_BATCH_SIZE = 1000;
+ private static final int DEFAULT_BATCH_INTERVAL = 500;
+
+ private final DataBroker dataBroker;
+
+ private final BlockingQueue<ActionableResource> bgpResourcesBufferQ = new LinkedBlockingQueue<>();
+
+ @Inject
+ public BgpUtil(DataBroker dataBroker) {
+ this.dataBroker = dataBroker;
+ }
- private static DataBroker dataBroker;
+ @PostConstruct
+ public void init() {
+ ResourceBatchingManager resBatchingManager = ResourceBatchingManager.getInstance();
+
+ Integer batchSize = Integer.getInteger("batch.size", DEFAULT_BATCH_SIZE);
+ Integer batchInterval = Integer.getInteger("batch.wait.time", DEFAULT_BATCH_INTERVAL);
- private static BlockingQueue<ActionableResource> bgpResourcesBufferQ = new LinkedBlockingQueue<>();
+ resBatchingManager.registerBatchableResource(RESOURCE_TYPE, bgpResourcesBufferQ,
+ new DefaultBatchHandler(dataBroker, LogicalDatastoreType.CONFIGURATION, batchSize, batchInterval));
+ }
+
+ @Override
+ @PreDestroy
+ public void close() {
+ ResourceBatchingManager.getInstance().deregisterBatchableResource(RESOURCE_TYPE);
+ }
/**
* get a translation from prefix ipv6 to afi<br>.
return retValue;
}
- static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
- .setNameFormat("bgp-util-mdsal-%d").build();
-
- static ExecutorService threadPool = Executors.newFixedThreadPool(1, namedThreadFactory);
-
- static void registerWithBatchManager(ResourceHandler resourceHandler) {
- ResourceBatchingManager resBatchingManager = ResourceBatchingManager.getInstance();
- resBatchingManager.registerBatchableResource("BGP-RESOURCES", bgpResourcesBufferQ, resourceHandler);
- }
-
- static <T extends DataObject> void update(DataBroker broker, final LogicalDatastoreType datastoreType,
- final InstanceIdentifier<T> path, final T data) {
+ public <T extends DataObject> void update(final LogicalDatastoreType datastoreType,
+ final InstanceIdentifier<T> path, final T data) {
ActionableResource actResource = new ActionableResourceImpl(path.toString());
actResource.setAction(ActionableResource.UPDATE);
actResource.setInstanceIdentifier(path);
bgpResourcesBufferQ.add(actResource);
}
- public static <T extends DataObject> void write(DataBroker broker, final LogicalDatastoreType datastoreType,
- final InstanceIdentifier<T> path, final T data) {
+ public <T extends DataObject> void write(final LogicalDatastoreType datastoreType, final InstanceIdentifier<T> path,
+ final T data) {
ActionableResource actResource = new ActionableResourceImpl(path.toString());
actResource.setAction(ActionableResource.CREATE);
actResource.setInstanceIdentifier(path);
bgpResourcesBufferQ.add(actResource);
}
- static <T extends DataObject> void delete(DataBroker broker, final LogicalDatastoreType datastoreType,
- final InstanceIdentifier<T> path) {
+ public <T extends DataObject> void delete(final LogicalDatastoreType datastoreType,
+ final InstanceIdentifier<T> path) {
ActionableResource actResource = new ActionableResourceImpl(path.toString());
actResource.setAction(ActionableResource.DELETE);
actResource.setInstanceIdentifier(path);
bgpResourcesBufferQ.add(actResource);
}
- public static void setBroker(final DataBroker broker) {
- BgpUtil.dataBroker = broker;
- }
-
- public static DataBroker getBroker() {
- return dataBroker;
- }
-
// Convert ProtocolType to thrift protocol_type
public static protocol_type convertToThriftProtocolType(BgpControlPlaneType protocolType) {
switch (protocolType) {
}
}
- static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
+ public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = MDSALUtil.read(broker,
+ Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = MDSALUtil.read(dataBroker,
LogicalDatastoreType.OPERATIONAL, id);
if (vpnInstanceOpData.isPresent()) {
return vpnInstanceOpData.get();
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
}
- private static String getElanNamefromRd(DataBroker broker, String rd) {
+ private String getElanNamefromRd(String rd) {
InstanceIdentifier<EvpnRdToNetwork> id = getEvpnRdToNetworkIdentifier(rd);
- Optional<EvpnRdToNetwork> evpnRdToNetworkOpData = MDSALUtil.read(broker,
+ Optional<EvpnRdToNetwork> evpnRdToNetworkOpData = MDSALUtil.read(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (evpnRdToNetworkOpData.isPresent()) {
return evpnRdToNetworkOpData.get().getNetworkId();
.child(EvpnRdToNetwork.class, new EvpnRdToNetworkKey(rd)).build();
}
- public static void addTepToElanInstance(DataBroker broker, String rd, String tepIp) {
+ public void addTepToElanInstance(String rd, String tepIp) {
if (rd == null || tepIp == null) {
LOG.error("addTepToElanInstance : Null parameters returning");
return;
}
- String elanName = getElanNamefromRd(broker, rd);
+ String elanName = getElanNamefromRd(rd);
if (elanName == null) {
LOG.error("Elan null while processing RT2 for RD {}", rd);
return;
ExternalTepsKey externalTepsKey = externalTepsId.firstKeyOf(ExternalTeps.class);
externalTepsBuilder.setKey(externalTepsKey);
externalTepsBuilder.setTepIp(externalTepsKey.getTepIp());
- BgpUtil.update(dataBroker, LogicalDatastoreType.CONFIGURATION, externalTepsId, externalTepsBuilder.build());
+ update(LogicalDatastoreType.CONFIGURATION, externalTepsId, externalTepsBuilder.build());
}
- public static void deleteTepFromElanInstance(DataBroker broker, String rd, String tepIp) {
+ public void deleteTepFromElanInstance(String rd, String tepIp) {
if (rd == null || tepIp == null) {
LOG.error("deleteTepFromElanInstance : Null parameters returning");
return;
}
- String elanName = getElanNamefromRd(broker, rd);
+ String elanName = getElanNamefromRd(rd);
if (elanName == null) {
LOG.error("Elan null while processing RT2 withdraw for RD {}", rd);
return;
}
LOG.debug("Deleting tepIp {} from elan {}", tepIp, elanName);
InstanceIdentifier<ExternalTeps> externalTepsId = getExternalTepsIdentifier(elanName, tepIp);
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, externalTepsId);
+ delete(LogicalDatastoreType.CONFIGURATION, externalTepsId);
}
private static InstanceIdentifier<ExternalTeps> getExternalTepsIdentifier(String elanInstanceName, String tepIp) {
new ExternalTepsKey(tepAdress)).build();
}
- public static String getVpnNameFromRd(DataBroker dataBroker2, String rd) {
- VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(dataBroker2, rd);
+ public String getVpnNameFromRd(String rd) {
+ VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
return vpnInstanceOpData != null ? vpnInstanceOpData.getVpnInstanceName() : null;
}
* @param rd is the RouteDistinguisher of vrf
* @return the vrf of rd or null if no exist
*/
- public static Vrfs getVrfFromRd(String rd) {
+ public Vrfs getVrfFromRd(String rd) {
Vrfs vrfs = null;
KeyedInstanceIdentifier<Vrfs, VrfsKey> id = InstanceIdentifier.create(Bgp.class)
.child(Vrfs.class, new VrfsKey(rd));
return layerTypeValue;
}
- public static void removeVrfEntry(String rd, VrfEntry vrfEntry) {
+ public void removeVrfEntry(String rd, VrfEntry vrfEntry) {
LOG.debug("removeVrfEntry : vrf {} prefix {}", rd, vrfEntry.getDestPrefix());
InstanceIdentifier<VrfEntry> vrfEntryId =
InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(vrfEntry.getDestPrefix())).build();
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
}
-
}
private final DataBroker broker;
private final BgpConfigurationManager bgpConfigManager;
+ private final BgpUtil bgpUtil;
- public EvpnRdNetworkListener(DataBroker dataBroker,
- BgpConfigurationManager bgpConfigManager) {
+ public EvpnRdNetworkListener(DataBroker dataBroker, BgpConfigurationManager bgpConfigManager, BgpUtil bgpUtil) {
super(EvpnRdToNetwork.class, EvpnRdNetworkListener.class);
this.broker = dataBroker;
this.bgpConfigManager = bgpConfigManager;
+ this.bgpUtil = bgpUtil;
}
@Override
private void addExternalTepstoElanInstance(String rd) {
for (String tepIp: bgpConfigManager.getTepIPs(rd)) {
LOG.debug("Adding tep {} to Elan Corresponding to RD {}", tepIp, rd);
- BgpUtil.addTepToElanInstance(broker, rd, tepIp);
+ bgpUtil.addTepToElanInstance(rd, tepIp);
}
}
private void deleteExternalTepsfromElanInstance(String rd) {
for (String tepIp: bgpConfigManager.getTepIPs(rd)) {
LOG.debug("Deleting tep {} to Elan Corresponding to RD {}", tepIp, rd);
- BgpUtil.deleteTepFromElanInstance(broker, rd, tepIp);
+ bgpUtil.deleteTepFromElanInstance(rd, tepIp);
}
}
}
private static final Logger LOG = LoggerFactory.getLogger(FibDSWriter.class);
private final DataBroker dataBroker;
private final SingleTransactionDataBroker singleTxDB;
+ private final BgpUtil bgpUtil;
@Inject
- public FibDSWriter(final DataBroker dataBroker) {
+ public FibDSWriter(final DataBroker dataBroker, final BgpUtil bgpUtil) {
this.dataBroker = dataBroker;
+ this.bgpUtil = bgpUtil;
this.singleTxDB = new SingleTransactionDataBroker(dataBroker);
}
VrfEntryBuilder vrfEntryBuilder = new VrfEntryBuilder().setDestPrefix(prefix).setOrigin(origin.getValue());
buildVpnEncapSpecificInfo(vrfEntryBuilder, encapType, label, l3vni, macAddress,
gatewayMacAddress, nextHopList);
- BgpUtil.update(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntryBuilder.build());
+ bgpUtil.update(LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntryBuilder.build());
}
public void addMacEntryToDS(String rd, String macAddress, String prefix,
InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(MacVrfEntry.class, new MacVrfEntryKey(macAddress)).build();
- BgpUtil.update(dataBroker, LogicalDatastoreType.CONFIGURATION, macEntryId, macEntryBuilder.build());
+ bgpUtil.update(LogicalDatastoreType.CONFIGURATION, macEntryId, macEntryBuilder.build());
}
private static void buildVpnEncapSpecificInfo(VrfEntryBuilder builder,
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
VrfEntry.class, new VrfEntryKey(prefix));
InstanceIdentifier<VrfEntry> vrfEntryId = idBuilder.build();
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
}
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
MacVrfEntry.class, new MacVrfEntryKey(macAddress));
InstanceIdentifier<MacVrfEntry> macEntryId = idBuilder.build();
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, macEntryId);
+ bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, macEntryId);
}
existingVrfEntry.toJavaUtil().map(VrfEntry::getRoutePaths).orElse(Collections.emptyList());
if (routePaths.size() == 1) {
if (routePaths.get(0).getNexthopAddress().equals(nextHop)) {
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
}
} else {
routePaths.stream()
.ifPresent(nh -> {
InstanceIdentifier<RoutePaths> routePathId =
FibHelper.buildRoutePathId(rd, prefix, nextHop);
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION,
- routePathId);
+ bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, routePathId);
});
}
} catch (ReadFailedException e) {
if (found == false) {
continue;
}
- BgpUtil.removeVrfEntry(rd, vrfEntry);
+ bgpUtil.removeVrfEntry(rd, vrfEntry);
}
}
} catch (ReadFailedException rfe) {
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
- BgpUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfTableId);
+ bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, vrfTableId);
}
}
@Before
public void setUp() throws Exception {
dataBroker = getDataBroker();
- bgpFibWriter = new FibDSWriter(dataBroker);
+ bgpFibWriter = new FibDSWriter(dataBroker, new BgpUtil(dataBroker));
fibManager = new MockFibManager(dataBroker);
- BgpUtil.setBroker(dataBroker);
}
@Test
Code Review / netvirt.git / commitdiff