protected void programRemoteAclTableFlow(BigInteger dpId, Integer aclTag, AllowedAddressPairs aap,
int addOrRemove) {
List<MatchInfoBase> flowMatches = new ArrayList<>();
- flowMatches.addAll(AclServiceUtils.buildIpAndDstServiceMatch(aclTag, aap, dataBroker));
+ flowMatches.addAll(AclServiceUtils.buildIpAndDstServiceMatch(aclTag, aap));
List<InstructionInfo> instructions = AclServiceOFFlowBuilder.getGotoInstructionInfo(getAclCommitterTable());
String flowNameAdded = "Acl_Filter_Egress_" + String.valueOf(aap.getIpAddress().getValue()) + "_" + aclTag;
BigInteger dpid = port.getDpId();
int lportTag = port.getLPortTag();
if (action == Action.ADD || action == Action.REMOVE) {
- ingressAclDhcpAllowServerTraffic(dpid, lportTag, addOrRemove, AclConstants.PROTO_PREFIX_MATCH_PRIORITY);
- ingressAclDhcpv6AllowServerTraffic(dpid, lportTag, addOrRemove, AclConstants.PROTO_PREFIX_MATCH_PRIORITY);
+ ingressAclDhcpAllowServerTraffic(dpid, lportTag, addOrRemove);
+ ingressAclDhcpv6AllowServerTraffic(dpid, lportTag, addOrRemove);
ingressAclIcmpv6AllowedTraffic(dpid, lportTag, addOrRemove);
programArpRule(dpid, lportTag, addOrRemove);
protected void programRemoteAclTableFlow(BigInteger dpId, Integer aclTag, AllowedAddressPairs aap,
int addOrRemove) {
List<MatchInfoBase> flowMatches = new ArrayList<>();
- flowMatches.addAll(AclServiceUtils.buildIpAndSrcServiceMatch(aclTag, aap, dataBroker));
+ flowMatches.addAll(AclServiceUtils.buildIpAndSrcServiceMatch(aclTag, aap));
List<InstructionInfo> instructions = AclServiceOFFlowBuilder.getGotoInstructionInfo(getAclCommitterTable());
String flowNameAdded = "Acl_Filter_Ingress_" + String.valueOf(aap.getIpAddress().getValue()) + "_" + aclTag;
* @param dpId the dpid
* @param lportTag the lport tag
* @param addOrRemove is write or delete
- * @param protoPortMatchPriority the priority
*/
- protected void ingressAclDhcpAllowServerTraffic(BigInteger dpId, int lportTag, int addOrRemove,
- int protoPortMatchPriority) {
+ protected void ingressAclDhcpAllowServerTraffic(BigInteger dpId, int lportTag, int addOrRemove) {
final List<MatchInfoBase> matches = AclServiceUtils.buildDhcpMatches(AclConstants.DHCP_SERVER_PORT_IPV4,
AclConstants.DHCP_CLIENT_PORT_IPV4, lportTag, serviceMode);
List<InstructionInfo> instructions = getDispatcherTableResubmitInstructions();
* @param dpId the dpid
* @param lportTag the lport tag
* @param addOrRemove is write or delete
- * @param protoPortMatchPriority the priority
*/
- protected void ingressAclDhcpv6AllowServerTraffic(BigInteger dpId, int lportTag, int addOrRemove,
- Integer protoPortMatchPriority) {
+ protected void ingressAclDhcpv6AllowServerTraffic(BigInteger dpId, int lportTag, int addOrRemove) {
final List<MatchInfoBase> matches = AclServiceUtils.buildDhcpV6Matches(AclConstants.DHCP_SERVER_PORT_IPV6,
AclConstants.DHCP_CLIENT_PORT_IPV6, lportTag, serviceMode);
List<InstructionInfo> instructions = getDispatcherTableResubmitInstructions();
deleteIdPool(AclConstants.ACL_TAG_POOL_NAME);
}
- public static List<? extends MatchInfoBase> buildIpAndSrcServiceMatch(Integer aclTag, AllowedAddressPairs aap,
- DataBroker dataBroker) {
+ public static List<? extends MatchInfoBase> buildIpAndSrcServiceMatch(Integer aclTag, AllowedAddressPairs aap) {
List<MatchInfoBase> flowMatches = new ArrayList<>();
flowMatches.add(buildRemoteAclTagMetadataMatch(aclTag));
if (aap.getIpAddress().getIpAddress() != null) {
return flowMatches;
}
- public static List<? extends MatchInfoBase> buildIpAndDstServiceMatch(Integer aclTag, AllowedAddressPairs aap,
- DataBroker dataBroker) {
+ public static List<? extends MatchInfoBase> buildIpAndDstServiceMatch(Integer aclTag, AllowedAddressPairs aap) {
List<MatchInfoBase> flowMatches = new ArrayList<>();
flowMatches.add(buildRemoteAclTagMetadataMatch(aclTag));
String getDCGwIP();
- void sendNotificationEvent(String pfx, int code, int subcode);
+ void sendNotificationEvent(int code, int subcode);
void setQbgprestartTS(long qbgprestartTS);
List<AddressFamiliesVrf> vrfAddrFamilyList = vrfs.getAddressFamiliesVrf();
for (AddressFamiliesVrf vrfAddrFamily : vrfAddrFamilyList) {
/*add to br the new vrfs arguments*/
- br.addVrf(BgpUtil.getLayerType(vrfAddrFamily), rd, vrfs.getImportRts(), vrfs.getExportRts(),
- vrfAddrFamily.getAfi(), vrfAddrFamily.getSafi());
+ br.addVrf(BgpUtil.getLayerType(vrfAddrFamily), rd, vrfs.getImportRts(), vrfs.getExportRts()
+ );
}
/*add to br the vrfs contained in mapNewAdFamily*/
List<AddressFamiliesVrf> vrfAddrFamilyListFromMap = mapNewAdFamily.get(rd);
mapNewAdFamily.remove(rd);
} else if (adf != null) {
- br.addVrf(BgpUtil.getLayerType(adf), rd, vrfs.getImportRts(), vrfs.getExportRts(),
- adf.getAfi(), adf.getSafi());
+ br.addVrf(BgpUtil.getLayerType(adf), rd, vrfs.getImportRts(), vrfs.getExportRts()
+ );
// remove AddressFamiliesVrf which was already added to BGP
vrfAddrFamilyListFromMap.remove(adf);
if (vrfAddrFamilyListFromMap.isEmpty()) {
try {
LOG.debug("call addVRf rd {} afi {} safi {}", rd, adfvrf.getAfi(), adfvrf.getSafi());
br.addVrf(BgpUtil.getLayerType(adfvrf), rd, newval.getImportRts(),
- newval.getExportRts(), adfvrf.getAfi(), adfvrf.getSafi());
+ newval.getExportRts());
} catch (TException | BgpRouterException e) {
LOG.error("{} Add received exception; {}", YANG_OBJ, ADD_WARN, e);
}
prefix,
plen,
nexthop,
- update.getEthtag(),
- update.getEsi(),
update.getMacaddress(),
label,
l2label,
*/
public void onUpdatePushRoute(protocol_type protocolType, String rd, String prefix, int plen, String nextHop,
- int ethtag, String esi, String macaddress, int label, int l2label, String routermac, af_afi afi) {
+ String macaddress, int label, int l2label, String routermac, af_afi afi) {
boolean addroute = false;
boolean macupdate = false;
long l3vni = 0L;
rd, prefix, nextHop, label, afi);
// TODO: modify addFibEntryToDS signature
List<String> nextHopList = Collections.singletonList(nextHop);
- fibDSWriter.addFibEntryToDS(rd, macaddress, prefix + "/" + plen, nextHopList, encapType, label, l3vni,
+ fibDSWriter.addFibEntryToDS(rd, 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(rd);
for (AddressFamiliesVrf adf : vrf.getAddressFamiliesVrf()) {
try {
br.addVrf(BgpUtil.getLayerType(adf), vrf.getRd(), vrf.getImportRts(),
- vrf.getExportRts(), adf.getAfi(), adf.getSafi());
+ vrf.getExportRts());
} catch (TException | BgpRouterException e) {
LOG.error("Replay:addVrf() received exception", e);
}
}
private <T extends DataObject> void update(InstanceIdentifier<T> iid, T dto) {
- bgpUtil.update(LogicalDatastoreType.CONFIGURATION, iid, dto);
+ bgpUtil.update(iid, dto);
}
private <T extends DataObject> void delete(InstanceIdentifier<T> iid) {
- bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, iid);
+ bgpUtil.delete(iid);
}
public void startConfig(String bgpHost, int thriftPort) {
public void addPrefix(String rd, String macAddress, String prefix, List<String> nextHopList,
VrfEntry.EncapType encapType, int vpnLabel, long l3vni,
String gatewayMac, RouteOrigin origin) {
- fibDSWriter.addFibEntryToDS(rd, macAddress, prefix, nextHopList,
+ fibDSWriter.addFibEntryToDS(rd, prefix, nextHopList,
encapType, vpnLabel, l3vni, gatewayMac, origin);
bcm.addPrefix(rd, macAddress, prefix, nextHopList,
encapType, vpnLabel, l3vni, 0 /*l2vni*/, gatewayMac);
@Override
// This method doesn't actually do any real work currently but may at some point so suppress FindBugs violation.
@SuppressFBWarnings("UC_USELESS_VOID_METHOD")
- public synchronized void sendNotificationEvent(String pfx, int code, int subcode) {
+ public synchronized void sendNotificationEvent(int code, int subcode) {
if (code != BgpConstants.BGP_NOTIFY_CEASE_CODE) {
// CEASE Notifications alone have to be reported to the CBA.
// Silently return here. No need to log because tons
return retValue;
}
- public <T extends DataObject> void update(final LogicalDatastoreType datastoreType,
- final InstanceIdentifier<T> path, final T data) {
+ public <T extends DataObject> void update(final InstanceIdentifier<T> path, final T data) {
ActionableResource actResource = new ActionableResourceImpl(path.toString());
actResource.setAction(ActionableResource.UPDATE);
actResource.setInstanceIdentifier(path);
bgpResourcesBufferQ.add(actResource);
}
- public <T extends DataObject> void write(final LogicalDatastoreType datastoreType, final InstanceIdentifier<T> path,
- final T data) {
+ public <T extends DataObject> void write(final InstanceIdentifier<T> path, final T data) {
ActionableResource actResource = new ActionableResourceImpl(path.toString());
actResource.setAction(ActionableResource.CREATE);
actResource.setInstanceIdentifier(path);
bgpResourcesBufferQ.add(actResource);
}
- public <T extends DataObject> void delete(final LogicalDatastoreType datastoreType,
- final InstanceIdentifier<T> path) {
+ public <T extends DataObject> void delete(final InstanceIdentifier<T> path) {
ActionableResource actResource = new ActionableResourceImpl(path.toString());
actResource.setAction(ActionableResource.DELETE);
actResource.setInstanceIdentifier(path);
ExternalTepsKey externalTepsKey = externalTepsId.firstKeyOf(ExternalTeps.class);
externalTepsBuilder.setKey(externalTepsKey);
externalTepsBuilder.setTepIp(externalTepsKey.getTepIp());
- update(LogicalDatastoreType.CONFIGURATION, externalTepsId, externalTepsBuilder.build());
+ update(externalTepsId, externalTepsBuilder.build());
}
public void deleteTepFromElanInstance(String rd, String tepIp) {
}
LOG.debug("Deleting tepIp {} from elan {}", tepIp, elanName);
InstanceIdentifier<ExternalTeps> externalTepsId = getExternalTepsIdentifier(elanName, tepIp);
- delete(LogicalDatastoreType.CONFIGURATION, externalTepsId);
+ delete(externalTepsId);
}
private static InstanceIdentifier<ExternalTeps> getExternalTepsIdentifier(String elanInstanceName, String tepIp) {
InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(VrfEntry.class, new VrfEntryKey(vrfEntry.getDestPrefix())).build();
- delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ delete(vrfEntryId);
}
}
protected void addRoute() {
bgpConfigurationManager.onUpdatePushRoute(protocol_type.PROTOCOL_EVPN, rd, prefix,
- 0, nexthop, 0, null, mac, l3vni, l2vni, null, null);
+ 0, nexthop, mac, l3vni, l2vni, null, null);
}
protected void deleteRoute() {
@Singleton
public class FibDSWriter {
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, final BgpUtil bgpUtil) {
- this.dataBroker = dataBroker;
this.bgpUtil = bgpUtil;
this.singleTxDB = new SingleTransactionDataBroker(dataBroker);
}
- public synchronized void addFibEntryToDS(String rd, String macAddress, String prefix, List<String> nextHopList,
- VrfEntry.EncapType encapType, int label, long l3vni,
- String gatewayMacAddress, RouteOrigin origin) {
+ public synchronized void addFibEntryToDS(String rd, String prefix, List<String> nextHopList,
+ VrfEntry.EncapType encapType, int label, long l3vni,
+ String gatewayMacAddress, RouteOrigin origin) {
if (rd == null || rd.isEmpty()) {
LOG.error("Prefix {} not associated with vpn", prefix);
return;
.child(VrfEntry.class, new VrfEntryKey(prefix)).build();
VrfEntryBuilder vrfEntryBuilder = new VrfEntryBuilder().setDestPrefix(prefix).setOrigin(origin.getValue());
- buildVpnEncapSpecificInfo(vrfEntryBuilder, encapType, label, l3vni, macAddress,
+ buildVpnEncapSpecificInfo(vrfEntryBuilder, encapType, label, l3vni,
gatewayMacAddress, nextHopList);
- bgpUtil.update(LogicalDatastoreType.CONFIGURATION, vrfEntryId, vrfEntryBuilder.build());
+ bgpUtil.update(vrfEntryId, vrfEntryBuilder.build());
}
public void addMacEntryToDS(String rd, String macAddress, String prefix,
}
MacVrfEntryBuilder macEntryBuilder = new MacVrfEntryBuilder().setOrigin(origin.getValue());
- buildVpnEncapSpecificInfo(macEntryBuilder, encapType, l2vni, macAddress,
+ buildVpnEncapSpecificInfo(macEntryBuilder, encapType, l2vni,
gatewayMacAddress, nextHopList);
macEntryBuilder.setMac(macAddress);
macEntryBuilder.setDestPrefix(prefix);
InstanceIdentifier.builder(FibEntries.class)
.child(VrfTables.class, new VrfTablesKey(rd))
.child(MacVrfEntry.class, new MacVrfEntryKey(macAddress)).build();
- bgpUtil.update(LogicalDatastoreType.CONFIGURATION, macEntryId, macEntryBuilder.build());
+ bgpUtil.update(macEntryId, macEntryBuilder.build());
}
private static void buildVpnEncapSpecificInfo(VrfEntryBuilder builder,
- VrfEntry.EncapType encapType, long label, long l3vni, String macAddress,
+ VrfEntry.EncapType encapType, long label, long l3vni,
String gatewayMac, List<String> nextHopList) {
if (!encapType.equals(VrfEntry.EncapType.Mplsgre)) {
builder.setL3vni(l3vni);
}
private static void buildVpnEncapSpecificInfo(MacVrfEntryBuilder builder,
- VrfEntry.EncapType encapType, long l2vni, String macAddress,
+ VrfEntry.EncapType encapType, long l2vni,
String gatewayMac, List<String> nextHopList) {
builder.setEncapType(encapType);
builder.setGatewayMacAddress(gatewayMac);
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
VrfEntry.class, new VrfEntryKey(prefix));
InstanceIdentifier<VrfEntry> vrfEntryId = idBuilder.build();
- bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ bgpUtil.delete(vrfEntryId);
}
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
MacVrfEntry.class, new MacVrfEntryKey(macAddress));
InstanceIdentifier<MacVrfEntry> macEntryId = idBuilder.build();
- bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, macEntryId);
+ bgpUtil.delete(macEntryId);
}
existingVrfEntry.toJavaUtil().map(VrfEntry::getRoutePaths).orElse(Collections.emptyList());
if (routePaths.size() == 1) {
if (routePaths.get(0).getNexthopAddress().equals(nextHop)) {
- bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ bgpUtil.delete(vrfEntryId);
}
} else {
routePaths.stream()
.ifPresent(nh -> {
InstanceIdentifier<RoutePaths> routePathId =
FibHelper.buildRoutePathId(rd, prefix, nextHop);
- bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, routePathId);
+ bgpUtil.delete(routePathId);
});
}
} catch (ReadFailedException e) {
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
- bgpUtil.delete(LogicalDatastoreType.CONFIGURATION, vrfTableId);
+ bgpUtil.delete(vrfTableId);
}
}
switch (handlerModule) {
case BGPD:
try {
- handleCommand(firstArg, cmd);
+ handleCommand(cmd);
} catch (IOException ioe) {
session.getConsole().println("IOException thrown.");
}
return serverName;
}
- public void handleCommand(String arg, String command) throws IOException {
+ public void handleCommand(String command) throws IOException {
char[] cbuf = new char[10];
Socket socket;
PrintWriter outToSocket;
}
@Override
- public void sendBgpAlarmInfo(String pfx, int code, int subcode) {
+ public void sendBgpAlarmInfo(String pfx, int subcode) {
BgpAlarmErrorCodes userAlarm = BgpAlarmErrorCodes.checkErrorSubcode(subcode);
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add(userAlarm.getAlarmType());
*/
public interface BgpAlarmBroadcasterMBean {
- void sendBgpAlarmInfo(String pfx, int code , int subcode);
+ void sendBgpAlarmInfo(String pfx, int subcode);
}
dispatch(bop);
}
- public synchronized void addVrf(LayerType layerType, String rd, List<String> irts, List<String> erts,
- long afi, long safi) throws TException, BgpRouterException {
+ public synchronized void addVrf(LayerType layerType, String rd, List<String> irts, List<String> erts)
+ throws TException, BgpRouterException {
bop.thriftLayerType = layerType == LayerType.LAYER2 ? layer_type.LAYER_2 : layer_type.LAYER_3;
bop.type = Optype.VRF;
bop.add = true;
prefix,
plen,
nexthop,
- ethtag,
- esi,
macaddress,
l3label,
l2label,
@Override
public void onNotificationSendEvent(String prefix, byte errCode,
byte errSubcode) {
- bgpManager.sendNotificationEvent(prefix, errCode, errSubcode);
+ bgpManager.sendNotificationEvent((int) errCode, (int) errSubcode);
}
}
List<String> nexthop = Collections.singletonList("100.100.100.100");
int label = 1234;
- bgpFibWriter.addFibEntryToDS(rd, null /*macAddress*/, prefix, nexthop,
+ bgpFibWriter.addFibEntryToDS(rd, /*macAddress*/ prefix, nexthop,
VrfEntry.EncapType.Mplsgre, label, 0 /*l3vni*/, null /*gatewayMacAddress*/, RouteOrigin.LOCAL);
//assertEquals(1, fibManager.getDataChgCount());
assertEquals(1, 1);
String prefix = "10.10.10.10/32";
int label = 1234;
try {
- bgpFibWriter.addFibEntryToDS(rd, null /*macAddress*/, prefix, null,
+ bgpFibWriter.addFibEntryToDS(rd, /*macAddress*/ prefix, null,
VrfEntry.EncapType.Mplsgre, label, 0 /*l3vni*/, null /*gatewayMacAddress*/, RouteOrigin.CONNECTED);
assertEquals(1,0); //The code is not launching NullPointerException
} catch (NullPointerException e) {
* retrieve the VNI and the elanTag.
* @param scfTag ServiceChainForwarding Tag
* @param elanLportTag LPortTag of the Elan Pseudo Port
- * @param isLastServiceChain Only considered in removal operations. States
- * if there are no more ServiceChains using the ElanPseudoPort as
- * ingress port.
* @param addOrRemove States if the flows must be added or removed
*/
void programElanScfPipeline(String elanName, short tableId, long scfTag, int elanLportTag,
- boolean isLastServiceChain, int addOrRemove);
+ int addOrRemove);
// TODO: To be removed when sdnc is changed so that it calls the following API instead:
void programElanScfPipeline(String elanName, short tableId, int scfTag, int elanLportTag, int addOrRemove);
@Override
public void programElanScfPipeline(String elanName, short tableId, long scfTag, int elanLportTag,
- boolean isLastServiceChain, int addOrRemove) {
+ int addOrRemove) {
LOG.info("ELAN Service chaining :programElanScfPipeline [Started] {} {} {} {} {}",
elanName, tableId, scfTag, elanLportTag, addOrRemove);
elanServiceChainHandler.programElanScfPipeline(elanName, tableId, scfTag, elanLportTag, addOrRemove);
remove(podsBefore, podInterfaceBefore);
break;
case SUBTREE_MODIFIED:
- update(pods, podsBefore, podInterfaceBefore, podInterfaceAfter);
+ update(pods, podsBefore, podInterfaceAfter);
break;
case WRITE:
if (podInterfaceBefore == null) {
add(pods, podInterfaceAfter);
} else {
- update(pods, podsBefore, podInterfaceBefore, podInterfaceAfter);
+ update(pods, podsBefore, podInterfaceAfter);
}
break;
default:
jobCoordinator.enqueueJob(pods.getName(), new PodConfigAddWorker(txRunner, pods, podInterface));
}
- private void update(Pods podsAfter, Pods podsBefore, Interface podInterfaceBefore, Interface podInterfaceAfter) {
+ private void update(Pods podsAfter, Pods podsBefore, Interface podInterfaceAfter) {
LOG.trace("Pod updated before :{}, after :{}",podsBefore, podsAfter);
if (!Objects.equals(podsAfter.getNetworkNS(), podsBefore.getNetworkNS())
|| !Objects.equals(podsAfter.getHostIpAddress(), podsBefore.getHostIpAddress())) {
ElanInstance elanInstance = CoeUtils.createElanInstanceForTheFirstPodInTheNetwork(
pods.getNetworkNS(), nodeIp, podInterface, tx);
LOG.info("interface creation for pod {}", interfaceName);
- String portInterfaceName = CoeUtils.createOfPortInterface(interfaceName, podInterface, tx);
+ String portInterfaceName = CoeUtils.createOfPortInterface(interfaceName, tx);
LOG.debug("Creating ELAN Interface for pod {}", interfaceName);
- CoeUtils.createElanInterface(podInterface, portInterfaceName,
+ CoeUtils.createElanInterface(portInterfaceName,
elanInstance.getElanInstanceName(), tx);
}));
}
return elanInstanceBuilder.build();
}
- public static void createElanInterface(org.opendaylight.yang.gen.v1.urn.opendaylight.coe
- .northbound.pod.rev170611.pod_attributes.Interface podInterface,
- String elanInterfaceName, String elanInstanceName,
+ public static void createElanInterface(String elanInterfaceName, String elanInstanceName,
WriteTransaction wrtConfigTxn) {
InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
.class, new ElanInterfaceKey(elanInterfaceName)).build();
}
public static String createOfPortInterface(String interfaceName,
- org.opendaylight.yang.gen.v1.urn.opendaylight.coe
- .northbound.pod.rev170611.pod_attributes.Interface podInterface,
WriteTransaction wrtConfigTxn) {
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface inf =
buildInterface(interfaceName);
}
}
for (Pair<IpAddress, String> pair : setOfTunnelIpElanNamePairs) {
- updateCacheAndInstallNewFlows(dpnId, listOfDpns, pair, tx);
+ updateCacheAndInstallNewFlows(listOfDpns, pair, tx);
}
}), LOG, "Error writing to datastore");
}
}
- public void updateCacheAndInstallNewFlows(BigInteger dpnId,
- List<BigInteger> listOfDpns, Pair<IpAddress, String> pair, WriteTransaction tx) {
+ public void updateCacheAndInstallNewFlows(List<BigInteger> listOfDpns, Pair<IpAddress, String> pair,
+ WriteTransaction tx) {
BigInteger newDesignatedDpn = chooseDpn(pair.getLeft(), pair.getRight(), listOfDpns);
if (newDesignatedDpn.equals(DhcpMConstants.INVALID_DPID)) {
return;
elanDpnAvailableFlag = false;
}
int size = 0;
- L2GatewayDevice device = getDeviceFromTunnelIp(elanInstanceName, tunnelIp);
+ L2GatewayDevice device = getDeviceFromTunnelIp(tunnelIp);
if (device == null) {
LOG.trace("Could not find any device for elanInstanceName {} and tunnelIp {}",
elanInstanceName, tunnelIp);
public void configureDhcpArpRequestResponseFlow(BigInteger dpnId, String elanInstanceName, boolean addFlow,
IpAddress tunnelIp, String dhcpIpAddress, String dhcpMacAddress) {
- L2GatewayDevice device = getDeviceFromTunnelIp(elanInstanceName, tunnelIp);
+ L2GatewayDevice device = getDeviceFromTunnelIp(tunnelIp);
if (device == null) {
LOG.error("Unable to get L2Device for tunnelIp {} and elanInstanceName {}", tunnelIp,
elanInstanceName);
tunnelIpInDpn, subnetDhcpData.get().getPortFixedip(),
subnetDhcpData.get().getPortMacaddress());
}
- updateCacheAndInstallNewFlows(interfaceDpn, dpns, tunnelElanPair, tx);
+ updateCacheAndInstallNewFlows(dpns, tunnelElanPair, tx);
}
}
}));
}
LOG.info("Installing remote McastMac");
- L2GatewayDevice device = getDeviceFromTunnelIp(elanInstanceName, tunnelIp);
+ L2GatewayDevice device = getDeviceFromTunnelIp(tunnelIp);
if (device == null) {
LOG.error("Unable to get L2Device for tunnelIp {} and elanInstanceName {}", tunnelIp,
elanInstanceName);
});
}
- private L2GatewayDevice getDeviceFromTunnelIp(String elanInstanceName, IpAddress tunnelIp) {
+ private L2GatewayDevice getDeviceFromTunnelIp(IpAddress tunnelIp) {
Collection<L2GatewayDevice> devices = l2GatewayCache.getAll();
LOG.trace("In getDeviceFromTunnelIp devices {}", devices);
for (L2GatewayDevice device : devices) {
if (interfacePort != null) {
dhcpInfo = handleDhcpNeutronPacket(msgType, interfacePort, subnet, serverIp);
} else if (config.isDhcpDynamicAllocationPoolEnabled()) {
- dhcpInfo = handleDhcpAllocationPoolPacket(msgType, dhcpPkt, interfaceName, macAddress);
+ dhcpInfo = handleDhcpAllocationPoolPacket(msgType, interfaceName, macAddress);
}
DHCP reply = null;
if (dhcpInfo != null) {
}
- private DhcpInfo handleDhcpAllocationPoolPacket(byte msgType, DHCP dhcpPkt, String interfaceName,
- String macAddress) {
+ private DhcpInfo handleDhcpAllocationPoolPacket(byte msgType, String interfaceName, String macAddress) {
String networkId = dhcpAllocationPoolMgr.getNetworkByPort(interfaceName);
AllocationPool pool = networkId != null ? dhcpAllocationPoolMgr.getAllocationPoolByNetwork(networkId)
: null;
void updateElanInterface(String elanInstanceName, String interfaceName, List<String> updatedStaticMacAddresses,
String newDescription);
- void deleteElanInterface(String elanInstanceName, String interfaceName);
+ void deleteElanInterface(String interfaceName);
- void addStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress);
+ void addStaticMacAddress(String interfaceName, String macAddress);
- void deleteStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress)
- ;
+ void deleteStaticMacAddress(String interfaceName, String macAddress);
Collection<MacEntry> getElanMacTable(String elanInstanceName);
public interface IEtreeService {
- void deleteEtreeInterface(String elanInstanceName, String interfaceName);
+ void deleteEtreeInterface(String interfaceName);
boolean deleteEtreeInstance(String elanInstanceName);
import java.util.List;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
String l2GwDeviceName,
L2gateway l2Gateway);
- List<L2gatewayConnection> getAssociatedL2GwConnections(DataBroker broker, Set<Uuid> l2GatewayIds);
+ List<L2gatewayConnection> getAssociatedL2GwConnections(Set<Uuid> l2GatewayIds);
}
@Override
protected Object doExecute() {
LOG.debug("Deleting ElanInterface command" + "\t" + elanName + "\t" + interfaceName + "\t");
- elanProvider.deleteElanInterface(elanName, interfaceName);
+ elanProvider.deleteElanInterface(interfaceName);
return null;
}
}
protected Object doExecute() {
LOG.debug("Executing create ElanInterface command" + "\t" + elanName + "\t" + interfaceName + "\t"
+ staticMacAddress + "\t");
- elanProvider.addStaticMacAddress(elanName, interfaceName, staticMacAddress);
+ elanProvider.addStaticMacAddress(interfaceName, staticMacAddress);
return null;
}
}
protected Object doExecute() {
LOG.debug("Executing create ElanInterface command" + "\t" + elanName + "\t" + interfaceName + "\t"
+ staticMacAddress + "\t");
- elanProvider.deleteStaticMacAddress(elanName, interfaceName, staticMacAddress);
+ elanProvider.deleteStaticMacAddress(interfaceName, staticMacAddress);
return null;
}
}
session.getConsole()
.println("Etree interface doesn't exist or isn't configured as etree: " + interfaceName);
}
- elanProvider.deleteEtreeInterface(etreeName, interfaceName);
+ elanProvider.deleteEtreeInterface(interfaceName);
session.getConsole().println("Deleted the Etree interface succesfully");
return null;
}
isValid = verfiyLogicalSwitch(logicalSwitchName, nodeIid);
if (isValid) {
- isValid = verifyMcastMac(logicalSwitchName, l2GatewayDevice, nodeIid);
+ isValid = verifyMcastMac(logicalSwitchName, nodeIid);
verifyVlanBindings(nodeIid, logicalSwitchName, device, l2gatewayConnection.getSegmentId());
L2GatewayDevice elanL2gatewayDevice = ElanL2GwCacheUtils
.getL2GatewayDeviceFromCache(logicalSwitchName, nodeId.getValue());
}
private boolean verifyMcastMac(String logicalSwitchName,
- L2GatewayDevice l2GatewayDevice,
InstanceIdentifier<Node> nodeIid) {
NodeId nodeId = nodeIid.firstKeyOf(Node.class).getNodeId();
import org.opendaylight.infrautils.diagstatus.ServiceDescriptor;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.diagstatus.ServiceStatusProvider;
-import org.opendaylight.netvirt.elan.internal.ElanServiceProvider;
import org.opendaylight.netvirt.elan.utils.ElanConstants;
import org.ops4j.pax.cdi.api.OsgiServiceProvider;
import org.slf4j.Logger;
private volatile ServiceDescriptor serviceDescriptor;
@Inject
- public ElanDiagStatusProvider(final ElanServiceProvider elanServiceProvider,
- final DiagStatusService diagStatusService) {
+ public ElanDiagStatusProvider(final DiagStatusService diagStatusService) {
this.diagStatusService = diagStatusService;
diagStatusService.register(ElanConstants.ELAN_SERVICE_NAME);
serviceDescriptor = new ServiceDescriptor(ElanConstants.ELAN_SERVICE_NAME, ServiceState.OPERATIONAL,
import java.util.Random;
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.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
/**
* Construct a new ElanBridgeManager.
- * @param dataBroker DataBroker
* @param elanConfig the elan configuration
* @param interfaceManager InterfaceManager
* @param southboundUtils southboutUtils
* @param mdsalUtils mdsalUtils
*/
@Inject
- public ElanBridgeManager(DataBroker dataBroker, ElanConfig elanConfig, IInterfaceManager interfaceManager,
+ public ElanBridgeManager(ElanConfig elanConfig, IInterfaceManager interfaceManager,
SouthboundUtils southboundUtils, MdsalUtils mdsalUtils) {
//TODO: ClusterAware!!!??
this.mdsalUtils = mdsalUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
-import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.elan.utils.TransportZoneNotificationUtil;
private final ElanInstanceCache elanInstanceCache;
@Inject
- public ElanDpnToTransportZoneListener(final DataBroker dbx, final IInterfaceManager interfaceManager,
+ public ElanDpnToTransportZoneListener(final DataBroker dbx,
final ElanConfig elanConfig, final TransportZoneNotificationUtil tznu,
final ElanInstanceCache elanInstanceCache) {
useTransportZone = elanConfig.isAutoConfigTransportZones();
public ElanServiceProvider(IdManagerService idManager, IInterfaceManager interfaceManager,
ElanBridgeManager bridgeMgr,
DataBroker dataBroker,
- ElanInterfaceManager elanInterfaceManager,
ElanUtils elanUtils,
EntityOwnershipService entityOwnershipService,
SouthboundUtils southboundUtils, ElanInstanceCache elanInstanceCache,
}
@Override
- public void deleteEtreeInterface(String elanInstanceName, String interfaceName) {
- deleteElanInterface(elanInstanceName, interfaceName);
+ public void deleteEtreeInterface(String interfaceName) {
+ deleteElanInterface(interfaceName);
LOG.debug("deleting the Etree Interface {}", interfaceName);
}
@Override
- public void deleteElanInterface(String elanInstanceName, String interfaceName) {
+ public void deleteElanInterface(String interfaceName) {
Optional<ElanInterface> existingElanInterface = elanInterfaceCache.get(interfaceName);
if (existingElanInterface.isPresent()) {
ElanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
}
@Override
- public void addStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress) {
+ public void addStaticMacAddress(String interfaceName, String macAddress) {
Optional<ElanInterface> existingElanInterface = elanInterfaceCache.get(interfaceName);
if (existingElanInterface.isPresent()) {
StaticMacEntriesBuilder staticMacEntriesBuilder = new StaticMacEntriesBuilder();
}
@Override
- public void deleteStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress) {
+ public void deleteStaticMacAddress(String interfaceName, String macAddress) {
Optional<ElanInterface> existingElanInterface = elanInterfaceCache.get(interfaceName);
if (existingElanInterface.isPresent()) {
InstanceIdentifier<StaticMacEntries> staticMacEntriesIdentifier =
if (elanInterfaceMac.getMacEntry() != null && elanInterfaceMac.getMacEntry().size() > 0) {
List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
for (MacEntry macEntry : macEntries) {
- deleteStaticMacAddress(elanInstanceName, elanInterface, macEntry.getMacAddress().getValue());
+ deleteStaticMacAddress(elanInterface, macEntry.getMacAddress().getValue());
}
}
}
String intfName = providerIntfName + IfmConstants.OF_URI_SEPARATOR + elanInstance.getSegmentationId();
Interface memberIntf = interfaceManager.getInterfaceInfoFromConfigDataStore(intfName);
if (memberIntf != null) {
- deleteElanInterface(elanInstance.getElanInstanceName(), intfName);
+ deleteElanInterface(intfName);
deleteIetfInterface(intfName);
LOG.debug("delete vlan prv intf {} in elan {}, dpID {}", intfName,
elanInstance.getElanInstanceName(), dpnId);
if (shouldDeleteTrunk(trunkInterfaceName, elanInterface)) {
deleteIetfInterface(trunkInterfaceName);
}
- deleteElanInterface(elanInstanceName, elanInterface);
+ deleteElanInterface(elanInterface);
}
}
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
-import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.netvirt.elan.utils.TransportZoneNotificationUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
private final Boolean useTransportZone;
@Inject
- public VpnDpnToTransportZoneListener(final DataBroker dbx, final IInterfaceManager interfaceManager,
+ public VpnDpnToTransportZoneListener(final DataBroker dbx,
final ElanConfig elanConfig, final TransportZoneNotificationUtil tznu) {
useTransportZone = elanConfig.isAutoConfigTransportZones();
transportZoneNotificationUtil = tznu;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorRef;
return false;
}
- public static void mergeManagedByNode(Node psNode,
- PhysicalSwitchAugmentationBuilder builder,
- InstanceIdentifier<Node> haNodePath,
- InstanceIdentifier<Node> haPsPath, NodeId haPSNodeId) {
- PhysicalSwitchAugmentation psAugmentation = psNode.getAugmentation(PhysicalSwitchAugmentation.class);
- builder.setManagedBy(new HwvtepGlobalRef(haNodePath));
- builder.setHwvtepNodeName(psAugmentation.getHwvtepNodeName());
- builder.setHwvtepNodeDescription(psAugmentation.getHwvtepNodeDescription());
- builder.setTunnelIps(psAugmentation.getTunnelIps());
- builder.setPhysicalSwitchUuid(getUUid(psAugmentation.getHwvtepNodeName().getValue()));
- }
-
public static Node getOriginal(DataObjectModification<Node> mod) {
Node node = null;
switch (mod.getModificationType()) {
/**
* Copy updated data from HA node to child node of config data tree.
*
- * @param haUpdated HA node updated
- * @param haOriginal HA node original
* @param haChildNodeId HA child node which needs to be updated
* @param mod the data object modification
* @param tx Transaction
*/
- public void copyHAGlobalUpdateToChild(Node haUpdated,
- Node haOriginal,
- InstanceIdentifier<Node> haChildNodeId,
+ public void copyHAGlobalUpdateToChild(InstanceIdentifier<Node> haChildNodeId,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
globalAugmentationMerger.mergeConfigUpdate(haChildNodeId,
/**
* Copy HA ps node update to HA child ps node of config data tree.
*
- * @param haUpdated HA node updated
- * @param haOriginal HA node original
* @param haChildNodeId HA child node which needs to be updated
* @param mod the data object modification
* @param tx Transaction
*/
- public void copyHAPSUpdateToChild(Node haUpdated,
- Node haOriginal,
- InstanceIdentifier<Node> haChildNodeId,
+ public void copyHAPSUpdateToChild(InstanceIdentifier<Node> haChildNodeId,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
}
@Override
- public void copyChildGlobalOpUpdateToHAParent(Node updatedSrcNode,
- Node origSrcNode,
- InstanceIdentifier<Node> haPath,
+ public void copyChildGlobalOpUpdateToHAParent(InstanceIdentifier<Node> haPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
if (haPath == null) {
return;
}
- opNodeUpdatedHandler.copyChildGlobalOpUpdateToHAParent(updatedSrcNode, origSrcNode, haPath, mod, tx);
+ opNodeUpdatedHandler.copyChildGlobalOpUpdateToHAParent(haPath, mod, tx);
}
@Override
public void copyChildPsOpUpdateToHAParent(Node updatedSrcPSNode,
- Node origSrcPSNode,
InstanceIdentifier<Node> haPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
if (haPath == null) {
return;
}
- opNodeUpdatedHandler.copyChildPsOpUpdateToHAParent(updatedSrcPSNode, origSrcPSNode, haPath, mod, tx);
+ opNodeUpdatedHandler.copyChildPsOpUpdateToHAParent(updatedSrcPSNode, haPath, mod, tx);
}
@Override
- public void copyHAPSUpdateToChild(Node haUpdated,
- Node haOriginal,
- InstanceIdentifier<Node> haChildNodeId,
+ public void copyHAPSUpdateToChild(InstanceIdentifier<Node> haChildNodeId,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
if (haChildNodeId == null) {
return;
}
- configNodeUpdatedHandler.copyHAPSUpdateToChild(haUpdated, haOriginal, haChildNodeId, mod, tx);
+ configNodeUpdatedHandler.copyHAPSUpdateToChild(haChildNodeId, mod, tx);
}
@Override
- public void copyHAGlobalUpdateToChild(Node haUpdated,
- Node haOriginal,
- InstanceIdentifier<Node> haChildNodeId,
+ public void copyHAGlobalUpdateToChild(InstanceIdentifier<Node> haChildNodeId,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
if (haChildNodeId == null) {
return;
}
- configNodeUpdatedHandler.copyHAGlobalUpdateToChild(haUpdated, haOriginal, haChildNodeId, mod, tx);
+ configNodeUpdatedHandler.copyHAGlobalUpdateToChild(haChildNodeId, mod, tx);
}
}
throws ReadFailedException, ExecutionException, InterruptedException;
- void copyChildGlobalOpUpdateToHAParent(Node updatedSrcNode,
- Node origSrcNode,
- InstanceIdentifier<Node> haPath,
+ void copyChildGlobalOpUpdateToHAParent(InstanceIdentifier<Node> haPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx);
void copyChildPsOpUpdateToHAParent(Node updatedSrcPSNode,
- Node origSrcPSNode,
InstanceIdentifier<Node> haPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx);
- void copyHAPSUpdateToChild(Node haUpdated,
- Node haOriginal,
- InstanceIdentifier<Node> haChildPath,
+ void copyHAPSUpdateToChild(InstanceIdentifier<Node> haChildPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx)
;
- void copyHAGlobalUpdateToChild(Node haUpdated,
- Node haOriginal,
- InstanceIdentifier<Node> haChildPath,
+ void copyHAGlobalUpdateToChild(InstanceIdentifier<Node> haChildPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx)
;
* Copy HA ps node update to HA child ps node of operational data tree.
*
* @param updatedSrcPSNode Updated HA child ps node
- * @param origSrcPSNode Original HA ps node
* @param haPath HA node path
* @param mod the data object modification
* @param tx Transaction
*/
public void copyChildPsOpUpdateToHAParent(Node updatedSrcPSNode,
- Node origSrcPSNode,
InstanceIdentifier<Node> haPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
/**
* Copy updated data from HA node to child node of operational data tree.
*
- * @param updatedSrcNode Updated HA child node
- * @param origSrcNode Original HA node
* @param haPath HA node path
* @param mod the data object modification
* @param tx Transaction
*/
- public void copyChildGlobalOpUpdateToHAParent(Node updatedSrcNode,
- Node origSrcNode,
- InstanceIdentifier<Node> haPath,
+ public void copyChildGlobalOpUpdateToHAParent(InstanceIdentifier<Node> haPath,
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
}
@Override
- void onPsNodeUpdate(InstanceIdentifier<Node> key,
- Node haPSUpdated,
- Node haPSOriginal,
- DataObjectModification<Node> mod,
- ReadWriteTransaction tx) throws InterruptedException, ExecutionException, ReadFailedException {
+ void onPsNodeUpdate(Node haPSUpdated,
+ Node haPSOriginal,
+ DataObjectModification<Node> mod,
+ ReadWriteTransaction tx) throws InterruptedException, ExecutionException, ReadFailedException {
//copy the ps node data to children
String psId = haPSUpdated.getNodeId().getValue();
Set<InstanceIdentifier<Node>> childSwitchIds = HwvtepHAUtil.getPSChildrenIdsForHAPSNode(psId);
for (InstanceIdentifier<Node> childSwitchId : childSwitchIds) {
- haEventHandler.copyHAPSUpdateToChild(haPSUpdated, haPSOriginal, childSwitchId, mod, tx);
+ haEventHandler.copyHAPSUpdateToChild(childSwitchId, mod, tx);
}
}
throws InterruptedException, ExecutionException, ReadFailedException {
Set<InstanceIdentifier<Node>> childNodeIds = hwvtepHACache.getChildrenForHANode(key);
for (InstanceIdentifier<Node> haChildNodeId : childNodeIds) {
- haEventHandler.copyHAGlobalUpdateToChild(haUpdated, haOriginal, haChildNodeId, mod, tx);
+ haEventHandler.copyHAGlobalUpdateToChild(haChildNodeId, mod, tx);
}
}
DataObjectModification<Node> mod,
ReadWriteTransaction tx) {
boolean wasHAChild = hwvtepHACache.isHAEnabledDevice(childPath);
- addToHACacheIfBecameHAChild(childPath, updatedChildNode, beforeChildNode, tx);
+ addToHACacheIfBecameHAChild(childPath, updatedChildNode, beforeChildNode);
boolean isHAChild = hwvtepHACache.isHAEnabledDevice(childPath);
* @param childPath HA child path which got converted to HA node
* @param updatedChildNode updated Child node
* @param beforeChildNode non-ha node before updated to HA node
- * @param tx Transaction
*/
public static void addToHACacheIfBecameHAChild(InstanceIdentifier<Node> childPath,
Node updatedChildNode,
- Node beforeChildNode,
- ReadWriteTransaction tx) {
+ Node beforeChildNode) {
HwvtepGlobalAugmentation updatedAugmentaion = updatedChildNode.getAugmentation(HwvtepGlobalAugmentation.class);
HwvtepGlobalAugmentation beforeAugmentaion = null;
if (beforeChildNode != null) {
} catch (ReadFailedException e) {
LOG.error("Failed to read nodes {} , {} ", childGlobalPath, haNodePath);
}
- readAndCopyChildPsOpToParent(childGlobalPath, childNode, haNodePath, tx);
+ readAndCopyChildPsOpToParent(childNode, tx);
}
//Update on global node has been taken care by HAListeners as per perf improvement
if (!Strings.isNullOrEmpty(oldHAId)) { //was already ha child
InstanceIdentifier<Node> haPath = hwvtepHACache.getParent(childGlobalPath);
LOG.debug("Copy oper update from child {} to parent {}", childGlobalPath, haPath);
- haEventHandler.copyChildGlobalOpUpdateToHAParent(updatedChildNode, originalChildNode, haPath, mod, tx);
+ haEventHandler.copyChildGlobalOpUpdateToHAParent(haPath, mod, tx);
return;//TODO handle unha case
}
- HAOpClusteredListener.addToHACacheIfBecameHAChild(childGlobalPath, updatedChildNode, originalChildNode, tx);
+ HAOpClusteredListener.addToHACacheIfBecameHAChild(childGlobalPath, updatedChildNode, originalChildNode);
if (IS_NOT_HA_CHILD.test(childGlobalPath)) {
return;
}
}
@Override
- void onPsNodeUpdate(InstanceIdentifier<Node> childPsPath,
- Node updatedChildPSNode,
- Node originalChildPSNode,
- DataObjectModification<Node> mod,
- ReadWriteTransaction tx) throws ReadFailedException {
+ void onPsNodeUpdate(Node updatedChildPSNode,
+ Node originalChildPSNode,
+ DataObjectModification<Node> mod,
+ ReadWriteTransaction tx) throws ReadFailedException {
InstanceIdentifier<Node> childGlobalPath = HwvtepHAUtil.getGlobalNodePathFromPSNode(updatedChildPSNode);
if (IS_NOT_HA_CHILD.test(childGlobalPath)) {
return;
}
InstanceIdentifier<Node> haGlobalPath = hwvtepHACache.getParent(childGlobalPath);
- haEventHandler.copyChildPsOpUpdateToHAParent(updatedChildPSNode, originalChildPSNode, haGlobalPath, mod, tx);
+ haEventHandler.copyChildPsOpUpdateToHAParent(updatedChildPSNode, haGlobalPath, mod, tx);
}
@Override
}
}
- private void readAndCopyChildPsOpToParent(InstanceIdentifier<Node> childGlobalPath,
- Node childNode,
- InstanceIdentifier<Node> haNodePath,
- ReadWriteTransaction tx) {
+ private void readAndCopyChildPsOpToParent(Node childNode, ReadWriteTransaction tx) {
String childGlobalNodeId = childNode.getNodeId().getValue();
List<InstanceIdentifier> childPsIids = new ArrayList<>();
HwvtepGlobalAugmentation hwvtepGlobalAugmentation = childNode.getAugmentation(HwvtepGlobalAugmentation.class);
if (!nodeId.contains(HwvtepHAUtil.PHYSICALSWITCH)) {
onGlobalNodeUpdate(key, updated, original, mod, tx);
} else {
- onPsNodeUpdate(key, updated, original, mod, tx);
+ onPsNodeUpdate(updated, original, mod, tx);
}
}
}
}
- void onPsNodeUpdate(InstanceIdentifier<Node> key, Node updated, Node original,
+ void onPsNodeUpdate(Node updated, Node original,
DataObjectModification<Node> mod, ReadWriteTransaction tx)
throws ReadFailedException, InterruptedException, ExecutionException {
LOG.info("delete mcast mac for {} {}", elanName, strHwvtepNodeId);
futures.addAll(elanL2GatewayMulticastUtils.handleMcastForElanL2GwDeviceDelete(this.elanName,
- elanInstanceSupplier.get(), l2GatewayDevice));
+ l2GatewayDevice));
LOG.info("delete local ucast macs {} {}", elanName, strHwvtepNodeId);
elanL2GatewayUtils.deleteL2GwDeviceUcastLocalMacsFromElan(l2GatewayDevice, elanName);
new NodeId(elanL2GwDevice.getHwvtepNodeId()), logicalSwitchName, physicalDevice, defaultVlanId));
LOG.info("creating mast mac entries for {} {}", logicalSwitchName, elanL2GwDevice.getHwvtepNodeId());
futures.add(elanL2GatewayMulticastUtils.handleMcastForElanL2GwDeviceAdd(logicalSwitchName,
- elanInstanceSupplier.get(), elanL2GwDevice));
+ elanL2GwDevice));
futures.add(elanL2GatewayUtils.installElanMacsInL2GatewayDevice(
logicalSwitchName, elanL2GwDevice));
return futures;
/**
* Group of data for bulk child update cases.
- * @param childIid - Subtree Node iid
* @param child - Subtree Node data
* @return - Group value
*/
- protected abstract G getGroup(InstanceIdentifier<C> childIid, C child);
+ protected abstract G getGroup(C child);
/**
* Process the added/updated/Deleted subtree data.
switch (modificationType) {
case WRITE:
case SUBTREE_MODIFIED:
- group = getGroup(childIid, dataAfter);
+ group = getGroup(dataAfter);
updatedMacsGrouped.computeIfAbsent(group, (grp) -> new ConcurrentHashMap<>());
updatedMacsGrouped.get(group).put(childIid, dataAfter);
break;
case DELETE:
- group = getGroup(childIid, dataBefore);
+ group = getGroup(dataBefore);
deletedMacsGrouped.computeIfAbsent(group, (grp) -> new ConcurrentHashMap<>());
deletedMacsGrouped.get(group).put(childIid, dataBefore);
break;
@SuppressWarnings("checkstyle:IllegalCatch") // TODO remove when using AutoCloseables
void runTask() {
try {
- String jobKey = ElanL2GatewayUtils.getL2GatewayConnectionJobKey(nodeId.getValue(), nodeId.getValue());
+ String jobKey = ElanL2GatewayUtils.getL2GatewayConnectionJobKey(nodeId.getValue());
jobCoordinator.enqueueJob(jobKey, taskToRun,
SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
} finally {
if (portAugmentation != null) {
final NodeId nodeId = identifier.firstIdentifierOf(Node.class).firstKeyOf(Node.class).getNodeId();
elanClusterUtils.runOnlyInOwnerNode(HwvtepSouthboundConstants.ELAN_ENTITY_NAME,
- () -> handlePortAdded(portAugmentation, add, nodeId));
+ () -> handlePortAdded(add, nodeId));
return;
}
return this;
}
- private List<ListenableFuture<Void>> handlePortAdded(HwvtepPhysicalPortAugmentation portAugmentation,
- TerminationPoint portAdded, NodeId psNodeId) {
+ private List<ListenableFuture<Void>> handlePortAdded(TerminationPoint portAdded, NodeId psNodeId) {
Node psNode = HwvtepUtils.getHwVtepNode(broker, LogicalDatastoreType.OPERATIONAL, psNodeId);
if (psNode != null) {
String psName = psNode.getAugmentation(PhysicalSwitchAugmentation.class).getHwvtepNodeName().getValue();
}
@Override
- protected String getGroup(final InstanceIdentifier<LocalUcastMacs> childIid,
- final LocalUcastMacs localUcastMacs) {
+ protected String getGroup(final LocalUcastMacs localUcastMacs) {
return getElanName(localUcastMacs);
}
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;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
/**
* Handle mcast for elan l2 gw device add.
* @param elanName the elan name
- * @param elanInstance elanInstace
* @param device the device
* @return the listenable future
*/
- public ListenableFuture<Void> handleMcastForElanL2GwDeviceAdd(String elanName, ElanInstance elanInstance,
- L2GatewayDevice device) {
+ public ListenableFuture<Void> handleMcastForElanL2GwDeviceAdd(String elanName, L2GatewayDevice device) {
InstanceIdentifier<ExternalTeps> tepPath = buildExternalTepPath(elanName, device.getTunnelIp());
JdkFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
tx.put(LogicalDatastoreType.CONFIGURATION, tepPath, buildExternalTeps(device));
}), LOG, "Failed to write to config external tep {}", tepPath);
- return updateMcastMacsForAllElanDevices(elanName, elanInstance, device, true/* updateThisDevice */);
+ return updateMcastMacsForAllElanDevices(elanName, device, true/* updateThisDevice */);
}
public static InstanceIdentifier<ExternalTeps> buildExternalTepPath(String elan, IpAddress tepIp) {
public ListenableFuture<Void> updateRemoteMcastMacOnElanL2GwDevices(String elanName) {
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
for (L2GatewayDevice device : ElanL2GwCacheUtils.getInvolvedL2GwDevices(elanName).values()) {
- prepareRemoteMcastMacUpdateOnDevice(tx, elanName, device);
+ prepareRemoteMcastMacUpdateOnDevice(elanName, device);
}
});
}
*/
public ListenableFuture<Void> updateRemoteMcastMacOnElanL2GwDevice(String elanName, L2GatewayDevice device) {
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> prepareRemoteMcastMacUpdateOnDevice(tx, elanName, device));
+ tx -> prepareRemoteMcastMacUpdateOnDevice(elanName, device));
}
- public void prepareRemoteMcastMacUpdateOnDevice(WriteTransaction transaction,String elanName,
- L2GatewayDevice device) {
+ public void prepareRemoteMcastMacUpdateOnDevice(String elanName,
+ L2GatewayDevice device) {
ConcurrentMap<String, L2GatewayDevice> elanL2gwDevices = ElanL2GwCacheUtils
.getInvolvedL2GwDevices(elanName);
List<DpnInterfaces> dpns = elanUtils.getElanDPNByName(elanName);
List<IpAddress> dpnsTepIps = getAllTepIpsOfDpns(device, dpns);
List<IpAddress> l2GwDevicesTepIps = getAllTepIpsOfL2GwDevices(elanL2gwDevices);
- preapareRemoteMcastMacEntry(transaction, elanName, device, dpnsTepIps, l2GwDevicesTepIps);
+ preapareRemoteMcastMacEntry(elanName, device, dpnsTepIps, l2GwDevicesTepIps);
}
/**
*
* @param elanName
* the elan name
- * @param elanInstance
- * the ElanInstance
* @param device
* the device
* @param updateThisDevice
* the update this device
* @return the listenable future
*/
- private ListenableFuture<Void> updateMcastMacsForAllElanDevices(String elanName, ElanInstance elanInstance,
- L2GatewayDevice device, boolean updateThisDevice) {
+ private ListenableFuture<Void> updateMcastMacsForAllElanDevices(String elanName, L2GatewayDevice device,
+ boolean updateThisDevice) {
SettableFuture<Void> ft = SettableFuture.create();
ft.set(null);
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
if (updateThisDevice) {
- preapareRemoteMcastMacEntry(tx, elanName, device, dpnsTepIps, l2GwDevicesTepIps);
+ preapareRemoteMcastMacEntry(elanName, device, dpnsTepIps, l2GwDevicesTepIps);
}
// TODO: Need to revisit below logic as logical switches might not be
// present to configure RemoteMcastMac entry
for (L2GatewayDevice otherDevice : devices.values()) {
if (!otherDevice.getDeviceName().equals(device.getDeviceName())) {
- preapareRemoteMcastMacEntry(tx, elanName, otherDevice, dpnsTepIps, l2GwDevicesTepIps);
+ preapareRemoteMcastMacEntry(elanName, otherDevice, dpnsTepIps, l2GwDevicesTepIps);
}
}
});
/**
* Update remote mcast mac.
*
- * @param transaction
- * the transaction
* @param elanName
* the elan name
* @param device
* the l2 gw devices tep ips
* @return the write transaction
*/
- private void preapareRemoteMcastMacEntry(WriteTransaction transaction, String elanName,
- L2GatewayDevice device, List<IpAddress> dpnsTepIps,
- List<IpAddress> l2GwDevicesTepIps) {
+ private void preapareRemoteMcastMacEntry(String elanName,
+ L2GatewayDevice device, List<IpAddress> dpnsTepIps,
+ List<IpAddress> l2GwDevicesTepIps) {
NodeId nodeId = new NodeId(device.getHwvtepNodeId());
ArrayList<IpAddress> remoteTepIps = new ArrayList<>(l2GwDevicesTepIps);
remoteTepIps.add(dhcpDesignatedSwitchTepIp);
}
String logicalSwitchName = ElanL2GatewayUtils.getLogicalSwitchFromElan(elanName);
- putRemoteMcastMac(transaction, nodeId, logicalSwitchName, remoteTepIps);
+ putRemoteMcastMac(nodeId, logicalSwitchName, remoteTepIps);
LOG.info("Adding RemoteMcastMac for node: {} with physical locators: {}", device.getHwvtepNodeId(),
remoteTepIps);
}
/**
* Put remote mcast mac in config DS.
*
- * @param transaction
- * the transaction
* @param nodeId
* the node id
* @param logicalSwitchName
* @param tepIps
* the tep ips
*/
- private static void putRemoteMcastMac(WriteTransaction transaction, NodeId nodeId, String logicalSwitchName,
+ private static void putRemoteMcastMac(NodeId nodeId, String logicalSwitchName,
ArrayList<IpAddress> tepIps) {
List<LocatorSet> locators = new ArrayList<>();
for (IpAddress tepIp : tepIps) {
*
* @param elanName
* the elan instance name
- * @param elanInstance
- * the ElanInstance
* @param l2GatewayDevice
* the l2 gateway device
* @return the listenable future
*/
public List<ListenableFuture<Void>> handleMcastForElanL2GwDeviceDelete(String elanName,
- ElanInstance elanInstance, L2GatewayDevice l2GatewayDevice) {
+ L2GatewayDevice l2GatewayDevice) {
ListenableFuture<Void> deleteTepFuture = txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
tx.delete(LogicalDatastoreType.CONFIGURATION,
buildExternalTepPath(elanName, l2GatewayDevice.getTunnelIp()));
});
ListenableFuture<Void> updateMcastMacsFuture = updateMcastMacsForAllElanDevices(
- elanName, elanInstance, l2GatewayDevice, false/* updateThisDevice */);
+ elanName, l2GatewayDevice, false/* updateThisDevice */);
ListenableFuture<Void> deleteRemoteMcastMacFuture = deleteRemoteMcastMac(
new NodeId(l2GatewayDevice.getHwvtepNodeId()), elanName);
return Arrays.asList(updateMcastMacsFuture, deleteRemoteMcastMacFuture, deleteTepFuture);
List<RemoteUcastMacs> lstL2GatewayDevicesMacs = getOtherDevicesMacs(elanName, l2GatewayDevice, hwVtepNodeId,
logicalSwitchName);
- List<RemoteUcastMacs> lstElanMacTableEntries = getElanMacTableEntriesMacs(elanName, l2GatewayDevice,
+ List<RemoteUcastMacs> lstElanMacTableEntries = getElanMacTableEntriesMacs(elanName,
hwVtepNodeId, logicalSwitchName);
List<RemoteUcastMacs> lstRemoteUcastMacs = new ArrayList<>(lstL2GatewayDevicesMacs);
*
* @param elanName
* the elan name
- * @param l2GatewayDeviceToBeConfigured
- * the l2 gateway device to be configured
* @param hwVtepNodeId
* the hw vtep node id
* @param logicalSwitchName
* @return the elan mac table entries as remote ucast macs
*/
public List<RemoteUcastMacs> getElanMacTableEntriesMacs(String elanName,
- L2GatewayDevice l2GatewayDeviceToBeConfigured, NodeId hwVtepNodeId, String logicalSwitchName) {
+ NodeId hwVtepNodeId, String logicalSwitchName) {
List<RemoteUcastMacs> lstRemoteUcastMacs = new ArrayList<>();
MacTable macTable = ElanUtils.getElanMacTable(broker, elanName);
/**
* Gets the l2 gateway connection job key.
*
- * @param nodeId
- * the node id
* @param logicalSwitchName
* the logical switch name
* @return the l2 gateway connection job key
*/
- public static String getL2GatewayConnectionJobKey(String nodeId, String logicalSwitchName) {
+ public static String getL2GatewayConnectionJobKey(String logicalSwitchName) {
return logicalSwitchName;
}
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
-import org.opendaylight.netvirt.elan.internal.ElanInstanceManager;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAOpClusteredListener;
import org.opendaylight.netvirt.elan.l2gw.jobs.AssociateHwvtepToElanJob;
import org.opendaylight.netvirt.elan.l2gw.jobs.DisAssociateHwvtepFromElanJob;
private static final Logger LOG = LoggerFactory.getLogger(L2GatewayConnectionUtils.class);
private final DataBroker broker;
- private final ElanInstanceManager elanInstanceManager;
private final ElanL2GatewayUtils elanL2GatewayUtils;
private final ElanClusterUtils elanClusterUtils;
private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
private final HAOpClusteredListener haOpClusteredListener;
@Inject
- public L2GatewayConnectionUtils(DataBroker dataBroker, ElanInstanceManager elanInstanceManager,
+ public L2GatewayConnectionUtils(DataBroker dataBroker,
ElanClusterUtils elanClusterUtils, ElanL2GatewayUtils elanL2GatewayUtils,
JobCoordinator jobCoordinator, ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils,
L2GatewayCache l2GatewayCache, HAOpClusteredListener haOpClusteredListener,
ElanInstanceCache elanInstanceCache) {
this.broker = dataBroker;
- this.elanInstanceManager = elanInstanceManager;
this.elanL2GatewayUtils = elanL2GatewayUtils;
this.elanClusterUtils = elanClusterUtils;
this.elanL2GatewayMulticastUtils = elanL2GatewayMulticastUtils;
}
@Override
- public List<L2gatewayConnection> getAssociatedL2GwConnections(DataBroker broker, Set<Uuid> l2GatewayIds) {
+ public List<L2gatewayConnection> getAssociatedL2GwConnections(Set<Uuid> l2GatewayIds) {
return L2GatewayConnectionUtils.getAssociatedL2GwConnections(dataBroker, l2GatewayIds);
}
}
private ListenableFuture<Void> buildEtreeDmacFlowDropIfPacketComingFromTunnelwithBatch(
- BigInteger dpnId, String extDeviceNodeId, Long elanTag, String macAddress,EtreeLeafTagName etreeLeafTag) {
+ BigInteger dpnId, String extDeviceNodeId, String macAddress, EtreeLeafTagName etreeLeafTag) {
if (etreeLeafTag != null) {
Flow dropFlow = buildDmacFlowDropIfPacketComingFromTunnel(dpnId, extDeviceNodeId,
etreeLeafTag.getEtreeLeafTag().getValue(), macAddress);
if (etreeLeafTag != null) {
return Lists.newArrayList(
buildEtreeDmacFlowDropIfPacketComingFromTunnelwithBatch(
- dpnId, extDeviceNodeId, elanTag, macAddress, etreeLeafTag),
+ dpnId, extDeviceNodeId, macAddress, etreeLeafTag),
buildEtreeDmacFlowForExternalRemoteMacWithBatch(
dpnId, extDeviceNodeId, vni, macAddress, displayName, interfaceName, etreeLeafTag));
}
import java.math.BigInteger;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.RouterInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
String destTepIp,
long label);
- void addOrUpdateFibEntry(DataBroker broker, String rd, String macAddress, String prefix, List<String> nextHopList,
+ void addOrUpdateFibEntry(String rd, String macAddress, String prefix, List<String> nextHopList,
VrfEntry.EncapType encapType, long label, long l3vni, String gwMacAddress,
String parentVpnRd, RouteOrigin origin, WriteTransaction writeConfigTxn);
- void addFibEntryForRouterInterface(DataBroker broker, String rd, String prefix,
+ void addFibEntryForRouterInterface(String rd, String prefix,
RouterInterface routerInterface, long label, WriteTransaction writeConfigTxn);
- void removeOrUpdateFibEntry(DataBroker broker, String rd, String prefix, String nextHopToRemove,
+ void removeOrUpdateFibEntry(String rd, String prefix, String nextHopToRemove,
WriteTransaction writeConfigTxn);
- void removeFibEntry(DataBroker broker, String rd, String prefix, WriteTransaction writeConfigTxn);
+ void removeFibEntry(String rd, String prefix, WriteTransaction writeConfigTxn);
- void updateRoutePathForFibEntry(DataBroker broker, String rd, String prefix, String nextHop,
- long label, boolean nextHopAdd, WriteTransaction writeConfigTxn);
+ void updateRoutePathForFibEntry(String rd, String prefix, String nextHop,
+ long label, boolean nextHopAdd, WriteTransaction writeConfigTxn);
- void removeVrfTable(DataBroker broker, String rd, WriteTransaction writeConfigTxn);
+ void removeVrfTable(String rd, WriteTransaction writeConfigTxn);
void removeInterVPNLinkRouteFlows(String interVpnLinkName,
boolean isVpnFirstEndPoint,
}
public Consumer<? super VrfEntry> getConsumerForDeletingRemoteFib(
- final BigInteger dpnId, final long vpnId, final String rd,
+ final BigInteger dpnId, final long vpnId,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
return vrfEntry -> vrfEntry.getRoutePaths().stream()
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.config.api.osgi.WaitingServiceTracker;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
}
@Override
- public void addOrUpdateFibEntry(DataBroker broker, String rd, String macAddress, String prefix,
- List<String> nextHopList, VrfEntry.EncapType encapType, long label,
- long l3vni, String gwMacAddress, String parentVpnRd, RouteOrigin origin,
- WriteTransaction writeConfigTxn) {
+ public void addOrUpdateFibEntry(String rd, String macAddress, String prefix,
+ List<String> nextHopList, VrfEntry.EncapType encapType, long label,
+ long l3vni, String gwMacAddress, String parentVpnRd, RouteOrigin origin,
+ WriteTransaction writeConfigTxn) {
fibUtil.addOrUpdateFibEntry(rd, macAddress, prefix, nextHopList , encapType, label, l3vni, gwMacAddress,
parentVpnRd, origin, writeConfigTxn);
}
@Override
- public void addFibEntryForRouterInterface(DataBroker broker, String rd, String prefix,
- RouterInterface routerInterface, long label,
- WriteTransaction writeConfigTxn) {
+ public void addFibEntryForRouterInterface(String rd, String prefix,
+ RouterInterface routerInterface, long label,
+ WriteTransaction writeConfigTxn) {
fibUtil.addFibEntryForRouterInterface(rd, prefix, routerInterface, label, writeConfigTxn);
}
@Override
- public void removeOrUpdateFibEntry(DataBroker broker, String rd, String prefix,
- String nextHopToRemove, WriteTransaction writeConfigTxn) {
+ public void removeOrUpdateFibEntry(String rd, String prefix,
+ String nextHopToRemove, WriteTransaction writeConfigTxn) {
fibUtil.removeOrUpdateFibEntry(rd, prefix, nextHopToRemove, writeConfigTxn);
}
@Override
- public void removeFibEntry(DataBroker broker, String rd, String prefix, WriteTransaction writeConfigTxn) {
+ public void removeFibEntry(String rd, String prefix, WriteTransaction writeConfigTxn) {
fibUtil.removeFibEntry(rd, prefix, writeConfigTxn);
}
@Override
- public void updateRoutePathForFibEntry(DataBroker broker, String rd, String prefix, String nextHop,
- long label, boolean nextHopAdd, WriteTransaction writeConfigTxn) {
+ public void updateRoutePathForFibEntry(String rd, String prefix, String nextHop,
+ long label, boolean nextHopAdd, WriteTransaction writeConfigTxn) {
fibUtil.updateRoutePathForFibEntry(rd, prefix, nextHop, label, nextHopAdd, writeConfigTxn);
}
@Override
- public void removeVrfTable(DataBroker broker, String rd, WriteTransaction writeConfigTxn) {
+ public void removeVrfTable(String rd, WriteTransaction writeConfigTxn) {
fibUtil.removeVrfTable(rd, writeConfigTxn);
}
WriteTransaction writeCfgTxn = dataBroker.newWriteOnlyTransaction();
vrfTable.get().getVrfEntry().stream()
.filter(vrfEntry -> RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP)
- .forEach(bgpRouteVrfEntryHandler.getConsumerForDeletingRemoteFib(dpnId, vpnId, rd,
+ .forEach(bgpRouteVrfEntryHandler.getConsumerForDeletingRemoteFib(dpnId, vpnId,
remoteNextHopIp, vrfTable, writeCfgTxn, txnObjects));
futures.add(writeCfgTxn.submit());
}
if (addOrRemove == NwConstants.ADD_FLOW) {
extSubnetId = NatUtil.getExternalSubnetVpnId(dataBroker,externalSubnetId);
}
- installInboundFibEntry(dpnId, externalIp, routerName, routerId, extSubnetId, addOrRemove);
- installInboundTerminatingServiceTblEntry(dpnId, routerId, routerName, externalIp, extSubnetId, addOrRemove);
+ installInboundFibEntry(dpnId, externalIp, routerId, extSubnetId, addOrRemove);
+ installInboundTerminatingServiceTblEntry(dpnId, routerId, extSubnetId, addOrRemove);
}
protected void installSnatCommonEntriesForNonNaptSwitch(Routers routers, BigInteger primarySwitchId,
protected abstract void installSnatSpecificEntriesForNonNaptSwitch(Routers routers, BigInteger dpnId,
int addOrRemove);
- protected void installInboundFibEntry(BigInteger dpnId, String externalIp, String routerName, Long routerId,
+ protected void installInboundFibEntry(BigInteger dpnId, String externalIp, Long routerId,
long extSubnetId, int addOrRemove) {
List<MatchInfo> matches = new ArrayList<>();
matches.add(MatchEthernetType.IPV4);
NwConstants.COOKIE_SNAT_TABLE, matches, instructions, addOrRemove);
}
- protected void installInboundTerminatingServiceTblEntry(BigInteger dpnId, Long routerId, String routerName,
- String externalIp, long extSubnetId, int addOrRemove) {
+ protected void installInboundTerminatingServiceTblEntry(BigInteger dpnId, Long routerId,
+ long extSubnetId, int addOrRemove) {
//Install the tunnel table entry in NAPT switch for inbound traffic to SNAP IP from a non a NAPT switch.
LOG.info("installInboundTerminatingServiceTblEntry : creating entry for Terminating Service Table "
+ "for switch {}, routerId {}", dpnId, routerId);
extSubnetId = NatUtil.getExternalSubnetVpnId(getDataBroker(),externalSubnetId);
}
createOutboundTblEntry(dpnId, routerId, externalIp, elanId, extGwMacAddress, addOrRemove);
- installNaptPfibFlow(routers, dpnId, routerId, routerName, extSubnetId, addOrRemove);
+ installNaptPfibFlow(routers, dpnId, routerId, extSubnetId, addOrRemove);
//Install Inbound NAT entries
- Long extNetId = NatUtil.getVpnId(getDataBroker(), routers.getNetworkId().getValue());
- installInboundEntry(dpnId, routerId, routerName, extNetId, externalIp, elanId, extSubnetId, addOrRemove);
+ installInboundEntry(dpnId, routerId, externalIp, elanId, extSubnetId, addOrRemove);
installNaptPfibEntry(dpnId, routerId, addOrRemove);
}
}
protected void installNaptPfibFlow(Routers routers, BigInteger dpnId, long routerId,
- String routerName, long extSubnetId, int addOrRemove) {
+ long extSubnetId, int addOrRemove) {
Long extNetId = NatUtil.getVpnId(getDataBroker(), routers.getNetworkId().getValue());
LOG.info("installNaptPfibFlow : dpId {}, extNetId {}", dpnId, extNetId);
List<MatchInfoBase> matches = new ArrayList<>();
flowRef, NwConstants.COOKIE_SNAT_TABLE, matches, instructions, addOrRemove);
}
- protected void installInboundEntry(BigInteger dpnId, long routerId, String routerName, Long extNetId,
- String externalIp, int elanId, long extSubnetId, int addOrRemove) {
+ protected void installInboundEntry(BigInteger dpnId, long routerId, String externalIp, int elanId, long extSubnetId,
+ int addOrRemove) {
LOG.info("installInboundEntry : dpId {} and routerId {}", dpnId, routerId);
List<MatchInfoBase> matches = new ArrayList<>();
matches.add(MatchEthernetType.IPV4);
public void onRemoveFloatingIp(final BigInteger dpnId, final String vpnName, final String externalIp,
final String floatingIpInterface, final String floatingIpPortMacAddress,
- final String routerName, final long routerId, WriteTransaction removeFlowInvTx) {
+ final long routerId, WriteTransaction removeFlowInvTx) {
/*
* 1) Remove the flow INTERNAL_TUNNEL_TABLE (table=36)-> PDNAT_TABLE (table=25) (SNAT VM on DPN1 is
* responding back to FIP VM on DPN2) {SNAT to DNAT traffic on different Hypervisor}
String fibExternalIp = NatUtil.validateAndAddNetworkMask(externalIp);
//Remove Prefix from BGP
- NatUtil.removePrefixFromBGP(dataBroker, bgpManager, fibManager, rd, fibExternalIp, vpnName, LOG);
+ NatUtil.removePrefixFromBGP(bgpManager, fibManager, rd, fibExternalIp, vpnName, LOG);
//Remove custom FIB routes flow for L3_FIB_TABLE (table=21)-> PDNAT_TABLE (table=25)
RemoveFibEntryInput input = new RemoveFibEntryInputBuilder().setVpnName(vpnName)
Collection<String> externalIps = NatUtil.getExternalIpsForRouter(dataBroker,routerId);
if (natMode == NatMode.Controller) {
externalRouterListener.handleDisableSnatInternetVpn(routerUuid.getValue(), routerId, networkUuid,
- externalIps, false, original.getVpnid().getValue(), writeFlowInvTx);
+ externalIps, original.getVpnid().getValue(), writeFlowInvTx);
}
}
}
addOrDelDefFibRouteToSNAT(routerName, routerId, bgpVpnId, bgpVpnUuid, true, writeFlowInvTx);
List<ListenableFuture<Void>> futures = new ArrayList<>();
// Allocate Primary Napt Switch for this router
- BigInteger primarySwitchId = getPrimaryNaptSwitch(routerName, routerId);
+ BigInteger primarySwitchId = getPrimaryNaptSwitch(routerName);
if (primarySwitchId != null && !primarySwitchId.equals(BigInteger.ZERO)) {
if (!routers.isEnableSnat()) {
LOG.info("add : SNAT is disabled for external router {} ", routerName);
// Handle switches and NAPT switches separately
if (!dpnId.equals(primarySwitchId)) {
LOG.debug("handleEnableSnat : Handle Ordinary switch");
- handleSwitches(dpnId, routerName, routerId, primarySwitchId, writeFlowInvTx);
+ handleSwitches(dpnId, routerName, routerId, primarySwitchId);
} else {
LOG.debug("handleEnableSnat : Handle NAPT switch");
handlePrimaryNaptSwitch(dpnId, routerName, routerId, writeFlowInvTx);
LOG.debug("handleEnableSnat : Exit");
}
- private BigInteger getPrimaryNaptSwitch(String routerName, long segmentId) {
+ private BigInteger getPrimaryNaptSwitch(String routerName) {
// Allocate Primary Napt Switch for this router
BigInteger primarySwitchId = NatUtil.getPrimaryNaptfromRouterName(dataBroker, routerName);
if (primarySwitchId != null && !primarySwitchId.equals(BigInteger.ZERO)) {
}
}
- protected void handleSwitches(BigInteger dpnId, String routerName, long routerId, BigInteger primarySwitchId,
- WriteTransaction writeFlowInvTx) {
+ protected void handleSwitches(BigInteger dpnId, String routerName, long routerId, BigInteger primarySwitchId) {
LOG.debug("handleSwitches : Installing SNAT miss entry in switch {}", dpnId);
List<ActionInfo> listActionInfoPrimary = new ArrayList<>();
String ifNamePrimary = getTunnelInterfaceName(dpnId, primarySwitchId);
}
Routers extRouter = router != null ? router :
NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
- Uuid externalSubnetId = NatUtil.getExternalSubnetForRouterExternalIp(dataBroker, externalIp,
+ Uuid externalSubnetId = NatUtil.getExternalSubnetForRouterExternalIp(externalIp,
extRouter);
NatUtil.addPrefixToBGP(dataBroker, bgpManager, fibManager, vpnName, rd, externalSubnetId,
externalIp, nextHopIp, extRouter.getNetworkId().getValue(), null, label, l3vni,
if (bgpVpnUuid != null) {
bgpVpnId = NatUtil.getVpnId(dataBroker, bgpVpnUuid.getValue());
}
- BigInteger dpnId = getPrimaryNaptSwitch(routerName, routerId);
+ BigInteger dpnId = getPrimaryNaptSwitch(routerName);
if (dpnId == null || dpnId.equals(BigInteger.ZERO)) {
// Router has no interface attached
return;
LOG.debug("update : Start processing of the External IPs removal during the update operation");
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName,
removedExternalIps, original.getExtGwMacAddress(),
- dpnId, networkId, null);
+ dpnId, networkId);
for (String removedExternalIp : removedExternalIps) {
/*
Collection<Uuid> externalSubnetList = NatUtil.getExternalSubnetIdsFromExternalIps(router.getExternalIps());
removeNaptFlowsFromActiveSwitch(routerId, routerName, naptSwitchDpnId, networkUuid, vpnName, externalIps,
externalSubnetList, removeFlowInvTx, extNwProvType);
- removeFlowsFromNonActiveSwitches(routerId, routerName, naptSwitchDpnId, networkUuid, removeFlowInvTx);
+ removeFlowsFromNonActiveSwitches(routerId, routerName, naptSwitchDpnId, removeFlowInvTx);
try {
String externalSubnetVpn = null;
for (Uuid externalSubnetId : externalSubnetList) {
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public void handleDisableSnatInternetVpn(String routerName, long routerId, Uuid networkUuid,
- @Nonnull Collection<String> externalIps, boolean routerFlag,
+ @Nonnull Collection<String> externalIps,
String vpnId, WriteTransaction writeFlowInvTx) {
LOG.debug("handleDisableSnatInternetVpn: Started to process handle disable snat for router {} "
+ "with internet vpn {}", routerName, vpnId);
}
public void removeFlowsFromNonActiveSwitches(long routerId, String routerName,
- BigInteger naptSwitchDpnId, Uuid networkId, WriteTransaction removeFlowInvTx) {
+ BigInteger naptSwitchDpnId, WriteTransaction removeFlowInvTx) {
LOG.debug("removeFlowsFromNonActiveSwitches : Remove NAPT related flows from non active switches");
// Remove the flows from the other switches which points to the primary and secondary switches
//Inform BGP about the route removal
LOG.info("clearBgpRoutes : Informing BGP to remove route for externalIP {} of vpn {}", externalIp, vpnName);
String rd = NatUtil.getVpnRd(dataBroker, vpnName);
- NatUtil.removePrefixFromBGP(dataBroker, bgpManager, fibManager, rd, externalIp, vpnName, LOG);
+ NatUtil.removePrefixFromBGP(bgpManager, fibManager, rd, externalIp, vpnName, LOG);
}
private void removeTunnelTableEntry(BigInteger dpnId, long serviceId, WriteTransaction writeFlowInvTx) {
public void installFlowsWithUpdatedVpnId(BigInteger primarySwitchId, String routerName, long bgpVpnId,
long routerId, boolean isSnatCfgd, WriteTransaction writeFlowInvTx,
ProviderTypes extNwProvType) {
- installFlowsWithUpdatedVpnId(primarySwitchId, routerName, bgpVpnId, routerId, isSnatCfgd, null, writeFlowInvTx,
- extNwProvType);
- }
-
- public void installFlowsWithUpdatedVpnId(BigInteger primarySwitchId, String routerName, long bgpVpnId,
- long routerId, boolean isSnatCfgd, Routers router,
- WriteTransaction writeFlowInvTx, ProviderTypes extNwProvType) {
long changedVpnId = bgpVpnId;
String logMsg = "installFlowsWithUpdatedVpnId : Update the BGP VPN ID {}";
if (bgpVpnId == NatConstants.INVALID_ID) {
}
- private void createDNATTblEntry(BigInteger dpnId, InternalToExternalPortMap mapping, long routerId, long vpnId,
+ private void createDNATTblEntry(BigInteger dpnId, InternalToExternalPortMap mapping, long routerId,
long associatedVpnId, WriteTransaction writeFlowInvTx) {
FlowEntity preFlowEntity = buildPreDNATFlowEntity(dpnId, mapping, routerId, associatedVpnId);
if (preFlowEntity == null) {
addOrDelDefaultFibRouteForDnat(dpnId, routerName, routerId, writeFlowInvTx, true);
}
//Create the DNAT and SNAT table entries
- createDNATTblEntry(dpnId, mapping, routerId, vpnId, associatedVpnId, writeFlowInvTx);
+ createDNATTblEntry(dpnId, mapping, routerId, associatedVpnId, writeFlowInvTx);
createSNATTblEntry(dpnId, mapping, vpnId, routerId, associatedVpnId, extNwId, writeFlowInvTx);
floatingIPHandler.onAddFloatingIp(dpnId, routerName, routerId, extNwId, interfaceName, mapping, writeFlowInvTx);
}
addOrDelDefaultFibRouteForDnat(dpnId, routerName, routerId, writeFlowInvTx, true);
}
//Create the DNAT and SNAT table entries
- createDNATTblEntry(dpnId, mapping, routerId, vpnId, associatedVpnId, writeFlowInvTx);
+ createDNATTblEntry(dpnId, mapping, routerId, associatedVpnId, writeFlowInvTx);
createSNATTblEntry(dpnId, mapping, vpnId, routerId, associatedVpnId, externalNetworkId, writeFlowInvTx);
floatingIPHandler.onAddFloatingIp(dpnId, routerName, routerId, externalNetworkId, interfaceName, mapping,
writeFlowInvTx);
if (provType == ProviderTypes.VXLAN) {
floatingIPHandler.onRemoveFloatingIp(dpnId, routerName, routerId, extNwId, mapping,
NatConstants.DEFAULT_L3VNI_VALUE, removeFlowInvTx);
- removeOperationalDS(routerName, interfaceName, internalIp, externalIp);
+ removeOperationalDS(routerName, interfaceName, internalIp);
return;
}
long label = getOperationalIpMapping(routerName, interfaceName, internalIp);
}
floatingIPHandler.onRemoveFloatingIp(dpnId, routerName, routerId, extNwId, mapping, (int) label,
removeFlowInvTx);
- removeOperationalDS(routerName, interfaceName, internalIp, externalIp);
+ removeOperationalDS(routerName, interfaceName, internalIp);
}
void removeNATFlowEntries(BigInteger dpnId, String interfaceName, String vpnName, String routerName,
if (provType == ProviderTypes.VXLAN) {
floatingIPHandler.cleanupFibEntries(dpnId, vpnName, externalIp, NatConstants.DEFAULT_L3VNI_VALUE,
removeFlowInvTx, provType);
- removeOperationalDS(routerName, interfaceName, internalIp, externalIp);
+ removeOperationalDS(routerName, interfaceName, internalIp);
return;
}
long label = getOperationalIpMapping(routerName, interfaceName, internalIp);
return;
}
floatingIPHandler.cleanupFibEntries(dpnId, vpnName, externalIp, label, removeFlowInvTx, provType);
- removeOperationalDS(routerName, interfaceName, internalIp, externalIp);
+ removeOperationalDS(routerName, interfaceName, internalIp);
}
protected long getOperationalIpMapping(String routerId, String interfaceName, String internalIp) {
}
}
- void removeOperationalDS(String routerId, String interfaceName, String internalIp, String externalIp) {
+ void removeOperationalDS(String routerId, String interfaceName, String internalIp) {
LOG.info("removeOperationalDS : Remove operational DS for floating ip config: {}", internalIp);
InstanceIdentifier<InternalToExternalPortMap> intExtPortMapId = NatUtil.getIntExtPortMapIdentifier(routerId,
interfaceName, internalIp);
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
-import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.natservice.api.SnatServiceManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
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.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
final OdlInterfaceRpcService interfaceManager,
final IdManagerService idManager,
final NAPTSwitchSelector naptSwitchSelector,
- final IBgpManager bgpManager,
- final VpnRpcService vpnService,
- final FibRpcService fibService,
final IFibManager fibManager,
final EvpnNaptSwitchHA evpnNaptSwitchHA,
final IElanService elanManager,
String rd = NatUtil.getVpnRd(dataBroker, vpnName);
for (String externalIp : externalIpsCache) {
LOG.debug("isNaptSwitchDown : Removing Fib entry rd {} prefix {}", rd, externalIp);
- fibManager.removeFibEntry(dataBroker, rd, externalIp, null);
+ fibManager.removeFibEntry(rd, externalIp, null);
}
}
} else {
Optional<VrfEntry> ent = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
if (ent.isPresent()) {
LOG.debug("removeFibEntry : Removing Fib entry rd {} prefix {}", rd, prefix);
- fibManager.removeFibEntry(dataBroker, rd, prefix, null);
+ fibManager.removeFibEntry(rd, prefix, null);
}
}
NatUtil.addPrefixToInterface(broker, NatUtil.getVpnId(broker, vpnName), interfaceName, prefix, dpId,
null /* subnet-id */, Prefixes.PrefixCue.Nat);
- fibManager.addOrUpdateFibEntry(broker, rd, null /*macAddress*/, prefix,
+ fibManager.addOrUpdateFibEntry(rd, null /*macAddress*/, prefix,
Collections.singletonList(nextHopIp), VrfEntry.EncapType.Vxlan, NatConstants.DEFAULT_LABEL_VALUE,
l3Vni, gwMacAddress, null /* parent-vpn-rd */, origin, writeTx);
/* Publish to Bgp only if its an INTERNET VPN */
if (extNwProvType == null) {
return false;
}
- hndlTepDelForDnatInEachRtr(router, routerId, srcDpnId, extNwProvType, writeFlowInvTx);
+ hndlTepDelForDnatInEachRtr(router, routerId, srcDpnId, extNwProvType);
LOG.debug("handleTepDelForAllRtrs : TEP DEL : SNAT -> Withdrawing and Advertising routes for router {} ",
router.getRouter());
hndlTepDelForSnatInEachRtr(router, routerId, srcDpnId, tunnelType, srcTepIp, destTepIp,
LOG.debug("hndlTepAddOnNonNaptSwitch : SNAT -> Install the group which forward packet to the tunnel port "
+ "for the NAPT switch {} and the flow 26 which forwards to group", primaryDpnId);
- externalRouterListner.handleSwitches(srcDpnId, routerName, routerId, primaryDpnId, writeFlowInvTx);
+ externalRouterListner.handleSwitches(srcDpnId, routerName, routerId, primaryDpnId);
} else {
LOG.debug("hndlTepAddOnNonNaptSwitch : SNAT -> External BGP VPN (Private BGP) associated to router {}",
routerId);
for (String externalIp : externalIps) {
String rd = NatUtil.getVpnRd(dataBroker, externalVpnName);
LOG.debug("hndlTepAddOnNaptSwitch : Removing Fib entry rd {} prefix {}", rd, externalIp);
- fibManager.removeFibEntry(dataBroker, rd, externalIp, null);
+ fibManager.removeFibEntry(rd, externalIp, null);
}
/*
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, externalVpnName, l3vni).longValue();
}
- Uuid externalSubnetId = NatUtil.getExternalSubnetForRouterExternalIp(dataBroker, externalIp,
- router);
+ Uuid externalSubnetId = NatUtil.getExternalSubnetForRouterExternalIp(externalIp, router);
NatUtil.addPrefixToBGP(dataBroker, bgpManager, fibManager, externalVpnName, rd, externalSubnetId,
fibExternalIp, nextHopIp, networkId.getValue(), null /* mac-address */, label, l3vni,
RouteOrigin.STATIC, srcDpnId);
}
private void hndlTepDelForDnatInEachRtr(RoutersList router, long routerId, BigInteger tepDeletedDpnId,
- ProviderTypes extNwProvType, WriteTransaction writeFlowInvTx) {
+ ProviderTypes extNwProvType) {
//DNAT : Withdraw the routes from the BGP
String routerName = router.getRouter();
LOG.debug("hndlTepDelForDnatInEachRtr : DNAT -> Withdrawing the FIB route to the floating IP {} "
+ "configured for the port: {}",
externalIp, interfaceName);
- NatUtil.removePrefixFromBGP(dataBroker, bgpManager, fibManager, rd, externalIp, vpnName, LOG);
+ NatUtil.removePrefixFromBGP(bgpManager, fibManager, rd, externalIp, vpnName, LOG);
long serviceId = 0;
if (extNwProvType == ProviderTypes.VXLAN) {
serviceId = l3Vni;
String macAddress,
long label,
long l3vni,
- RouteOrigin origin, BigInteger dpId) {
+ RouteOrigin origin,
+ BigInteger dpId) {
try {
LOG.info("addPrefixToBGP : Adding Fib entry rd {} prefix {} nextHop {} label {}", rd,
prefix, nextHopIp, label);
addPrefixToInterface(broker, getVpnId(broker, vpnName), null /*interfaceName*/,prefix, dpId,
subnetId, Prefixes.PrefixCue.Nat);
- fibManager.addOrUpdateFibEntry(broker, rd, macAddress, prefix,
+ fibManager.addOrUpdateFibEntry(rd, macAddress, prefix,
Collections.singletonList(nextHopIp), VrfEntry.EncapType.Mplsgre, (int)label, l3vni /*l3vni*/,
null /*gatewayMacAddress*/, parentVpnRd, origin, null /*writeTxn*/);
if (rd != null && !rd.equalsIgnoreCase(vpnName)) {
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public static void removePrefixFromBGP(DataBroker broker, IBgpManager bgpManager, IFibManager fibManager,
+ public static void removePrefixFromBGP(IBgpManager bgpManager, IFibManager fibManager,
String rd, String prefix, String vpnName, Logger log) {
try {
LOG.debug("removePrefixFromBGP: Removing Fib entry rd {} prefix {}", rd, prefix);
- fibManager.removeFibEntry(broker, rd, prefix, null);
+ fibManager.removeFibEntry(rd, prefix, null);
if (rd != null && !rd.equalsIgnoreCase(vpnName)) {
bgpManager.withdrawPrefix(rd, prefix);
}
protected static long getExternalSubnetVpnIdForRouterExternalIp(DataBroker dataBroker, String externalIpAddress,
Routers router) {
- Uuid externalSubnetId = NatUtil.getExternalSubnetForRouterExternalIp(dataBroker, externalIpAddress, router);
+ Uuid externalSubnetId = NatUtil.getExternalSubnetForRouterExternalIp(externalIpAddress, router);
if (externalSubnetId != null) {
return NatUtil.getExternalSubnetVpnId(dataBroker,externalSubnetId);
}
return NatConstants.INVALID_ID;
}
- protected static Uuid getExternalSubnetForRouterExternalIp(DataBroker dataBroker, String externalIpAddress,
- Routers router) {
+ protected static Uuid getExternalSubnetForRouterExternalIp(String externalIpAddress, Routers router) {
externalIpAddress = validateAndAddNetworkMask(externalIpAddress);
List<ExternalIps> externalIps = router.getExternalIps();
for (ExternalIps extIp : externalIps) {
router.getNetworkId(), subnetVpnName.getValue(), writeTx);
vpnManager.removeArpResponderFlowsToExternalNetworkIps(router.getRouterName(), externalIpsSting,
router.getExtGwMacAddress(), primarySwitchId,
- router.getNetworkId(), writeTx);
+ router.getNetworkId());
}
writeTx.submit();
}
vpnManager.removeSubnetMacFromVpnInstance(networkVpnName, subnetId.getValue(), floatingIpPortMacAddress,
dpnId, tx);
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerUuid, Collections.singletonList(externalIp),
- floatingIpPortMacAddress, dpnId, networkId, tx);
+ floatingIpPortMacAddress, dpnId, networkId);
}), LOG, "onRemoveFloatingIp");
removeFromFloatingIpPortInfo(floatingIpId);
if (provType == ProviderTypes.VXLAN) {
Uuid floatingIpInterface = NatEvpnUtil.getFloatingIpInterfaceIdFromFloatingIpId(dataBroker, floatingIpId);
evpnDnatFlowProgrammer.onRemoveFloatingIp(dpnId, vpnName, externalIp, floatingIpInterface.getValue(),
- floatingIpPortMacAddress, routerUuid, routerId, removeFlowInvTx);
+ floatingIpPortMacAddress, routerId, removeFlowInvTx);
return;
}
cleanupFibEntries(dpnId, vpnName, externalIp, label, removeFlowInvTx, provType);
//Remove Prefix from BGP
String rd = NatUtil.getVpnRd(dataBroker, vpnName);
String fibExternalIp = NatUtil.validateAndAddNetworkMask(externalIp);
- NatUtil.removePrefixFromBGP(dataBroker, bgpManager, fibManager, rd, fibExternalIp, vpnName, LOG);
+ NatUtil.removePrefixFromBGP(bgpManager, fibManager, rd, fibExternalIp, vpnName, LOG);
//Remove custom FIB routes
interfaceIdentifier);
if (optionalInf.isPresent()) {
InterfaceBuilder interfaceBuilder = new InterfaceBuilder(optionalInf.get());
- InterfaceAcl infAcl = handlePortSecurityUpdated(dataBroker, original, update,
+ InterfaceAcl infAcl = handlePortSecurityUpdated(original, update,
origSecurityEnabled, updatedSecurityEnabled, interfaceBuilder).build();
interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
LOG.info("update: Of-port-interface updation for port {}", portName);
})));
}
- private static InterfaceAclBuilder handlePortSecurityUpdated(DataBroker dataBroker, Port portOriginal,
+ private static InterfaceAclBuilder handlePortSecurityUpdated(Port portOriginal,
Port portUpdated, boolean origSecurityEnabled, boolean updatedSecurityEnabled,
InterfaceBuilder interfaceBuilder) {
InterfaceAclBuilder interfaceAclBuilder = null;
Uuid routerId = update.getUuid();
// Remove the router to the ExtRouters list
- removeExternalRouter(origExtNetId, update);
+ removeExternalRouter(update);
//Remove router entry from floating-ip-info list
removeRouterFromFloatingIpInfo(update, dataBroker);
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- private void removeExternalRouter(Uuid extNetId, Router update) {
+ private void removeExternalRouter(Router update) {
Uuid routerId = update.getUuid();
InstanceIdentifier<Routers> routersIdentifier = NeutronvpnUtils.buildExtRoutersIdentifier(routerId);
protected void update(InstanceIdentifier<L2gateway> identifier, L2gateway original, L2gateway update) {
LOG.trace("Updating L2gateway : key: {}, original value={}, update value={}", identifier, original, update);
List<L2gatewayConnection> connections = l2gwService.getAssociatedL2GwConnections(
- dataBroker, Sets.newHashSet(update.getUuid()));
+ Sets.newHashSet(update.getUuid()));
if (connections == null) {
LOG.warn("There are no connections associated with l2 gateway uuid {} name {}",
update.getUuid(), update.getName());
addedTunnelInterfaces.removeAll(origTunnelInterfaces);
populatePolicyGroupBucketsToDpn(underlayNetwork, profiles, removedTunnelInterfaces, dpId, NwConstants.DEL_FLOW);
- populatePolicyGroupsToDpn(underlayNetwork, profiles, addedTunnelInterfaces, dpId, NwConstants.ADD_FLOW);
+ populatePolicyGroupsToDpn(profiles, addedTunnelInterfaces, dpId, NwConstants.ADD_FLOW);
populatePolicyGroupBucketsToDpn(underlayNetwork, profiles, addedTunnelInterfaces, dpId, NwConstants.ADD_FLOW);
}
return;
}
- populatePolicyGroupsToDpn(underlayNetwork, profiles, tunnelInterfaces, dpId, NwConstants.ADD_FLOW);
+ populatePolicyGroupsToDpn(profiles, tunnelInterfaces, dpId, NwConstants.ADD_FLOW);
populatePolicyGroupBucketsToDpn(underlayNetwork, profiles, tunnelInterfaces, dpId, NwConstants.ADD_FLOW);
- populatePolicyAclRulesToDpn(underlayNetwork, dpId, profiles, NwConstants.ADD_FLOW);
+ populatePolicyAclRulesToDpn(dpId, profiles, NwConstants.ADD_FLOW);
populatePolicyRoutesToDpn(profiles, tunnelInterfaces, dpId, NwConstants.ADD_FLOW);
}
- private void populatePolicyGroupsToDpn(
String underlayNetwork, List<PolicyProfile> profiles,
+ private void populatePolicyGroupsToDpn(List<PolicyProfile> profiles,
List<TunnelInterface> tunnelInterfaces, BigInteger dpId, int addOrRemove) {
profiles.forEach(profile -> {
String policyClassifier = profile.getPolicyClassifier();
});
}
- private void populatePolicyAclRulesToDpn(
String underlayNetwork, BigInteger dpId, List<PolicyProfile> profiles,
+ private void populatePolicyAclRulesToDpn(BigInteger dpId, List<PolicyProfile> profiles,
int addOrRemove) {
profiles.forEach(profile -> {
String policyClassifier = profile.getPolicyClassifier();
mod.getModificationType(), key);
switch (mod.getModificationType()) {
case DELETE:
- dataProcessor.remove(key, mod.getDataBefore());
+ dataProcessor.remove(mod.getDataBefore());
break;
case SUBTREE_MODIFIED:
- dataProcessor.update(key, mod.getDataBefore(), mod.getDataAfter());
+ dataProcessor.update(mod.getDataAfter());
break;
case WRITE:
if (mod.getDataBefore() == null) {
- dataProcessor.add(key, mod.getDataAfter());
+ dataProcessor.add(mod.getDataAfter());
} else {
- dataProcessor.update(key, mod.getDataBefore(), mod.getDataAfter());
+ dataProcessor.update(mod.getDataAfter());
}
break;
default:
package org.opendaylight.netvirt.sfc.translator;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Neutron SFC yang model processor.
/**
* Method removes DataObject which is identified by InstanceIdentifier.
*
- * @param identifier - the whole path to DataObject
* @param del - DataObject for removing
*/
- void remove(InstanceIdentifier<D> identifier, D del);
+ void remove(D del);
/**
* Method updates the original DataObject to the update DataObject.
* Both are identified by same InstanceIdentifier.
*
- * @param identifier - the whole path to DataObject
- * @param original - original DataObject (for update)
- * @param update - changed DataObject (contain updates)
- */
- void update(InstanceIdentifier<D> identifier, D original, D update);
+ * @param update - changed DataObject (contain updates)*/
+ void update(D update);
/**
* Method adds the DataObject which is identified by InstanceIdentifier
* to device.
*
- * @param identifier - the whole path to new DataObject
* @param add - new DataObject
*/
- void add(InstanceIdentifier<D> identifier, D add);
+ void add(D add);
}
/**
* Method removes Acl respective to SfcFlowClassifier which is identified by InstanceIdentifier.
*
- * @param path - the whole path to SfcFlowClassifier
* @param deletedSfcFlowClassifier - SfcFlowClassifier for removing
*/
@Override
- public void remove(InstanceIdentifier<SfcFlowClassifier> path, SfcFlowClassifier deletedSfcFlowClassifier) {
+ public void remove(SfcFlowClassifier deletedSfcFlowClassifier) {
Acl aclFlowClassifier = FlowClassifierTranslator.buildAcl(deletedSfcFlowClassifier);
sfcMdsalHelper.removeAclFlowClassifier(aclFlowClassifier);
}
* Method updates the original SfcFlowClassifier to the update SfcFlowClassifier.
* Both are identified by same InstanceIdentifier.
*
- * @param path - the whole path to SfcFlowClassifier
- * @param originalSfcFlowClassifier - original SfcFlowClassifier (for update)
* @param updatedSfcFlowClassifier - changed SfcFlowClassifier (contain updates)
*/
@Override
- public void update(InstanceIdentifier<SfcFlowClassifier> path,
- SfcFlowClassifier originalSfcFlowClassifier,
- SfcFlowClassifier updatedSfcFlowClassifier) {
+ public void update(SfcFlowClassifier updatedSfcFlowClassifier) {
Acl aclFlowClassifier = FlowClassifierTranslator.buildAcl(updatedSfcFlowClassifier);
sfcMdsalHelper.updateAclFlowClassifier(aclFlowClassifier);
* Method adds the SfcFlowClassifier which is identified by InstanceIdentifier
* to device.
*
- * @param path - the whole path to new SfcFlowClassifier
* @param sfcFlowClassifier - new SfcFlowClassifier
*/
@Override
- public void add(InstanceIdentifier<SfcFlowClassifier> path, SfcFlowClassifier sfcFlowClassifier) {
+ public void add(SfcFlowClassifier sfcFlowClassifier) {
// Respective ACL classifier will be written in data store, once the chain is created.
}
/**
* Method removes PortChain which is identified by InstanceIdentifier.
*
- * @param path - the whole path to PortChain
* @param deletedPortChain - PortChain for removing
*/
@Override
- public void remove(InstanceIdentifier<PortChain> path, PortChain deletedPortChain) {
+ public void remove(PortChain deletedPortChain) {
if (this.rspService != null) {
DeleteRenderedPathInput deleteRenderedPathInput =
PortChainTranslator.buildDeleteRenderedServicePathInput(PortChainTranslator
* Method updates the original PortChain to the update PortChain.
* Both are identified by same InstanceIdentifier.
*
- * @param path - the whole path to PortChain
- * @param originalPortChain - original PortChain (for update)
* @param updatePortChain - changed PortChain (contain updates)
*/
@Override
- public void update(InstanceIdentifier<PortChain> path, PortChain originalPortChain, PortChain updatePortChain) {
+ public void update(PortChain updatePortChain) {
//TODO: Add support for chain update
}
* Method adds the PortChain which is identified by InstanceIdentifier
* to device.
*
- * @param path - the whole path to new PortChain
* @param newPortChain - new PortChain
*/
@Override
- public void add(final InstanceIdentifier<PortChain> path, final PortChain newPortChain) {
+ public void add(final PortChain newPortChain) {
processPortChain(newPortChain);
}
/**
* Method removes PortPairGroup which is identified by InstanceIdentifier.
*
- * @param path - the whole path to PortPairGroup
* @param deletedPortPairGroup - PortPairGroup for removing
*/
@Override
- public void remove(InstanceIdentifier<PortPairGroup> path, PortPairGroup deletedPortPairGroup) {
+ public void remove(PortPairGroup deletedPortPairGroup) {
//NO-OP
}
* Method updates the original PortPairGroup to the update PortPairGroup.
* Both are identified by same InstanceIdentifier.
*
- * @param path - the whole path to PortPairGroup
- * @param originalPortPairGroup - original PortPairGroup (for update)
* @param updatePortPairGroup - changed PortPairGroup (contain updates)
*/
@Override
- public void update(InstanceIdentifier<PortPairGroup> path,
- PortPairGroup originalPortPairGroup,
- PortPairGroup updatePortPairGroup) {
+ public void update(PortPairGroup updatePortPairGroup) {
//NO-OP
}
* Method adds the PortPairGroup which is identified by InstanceIdentifier
* to device.
*
- * @param path - the whole path to new PortPairGroup
* @param newPortPairGroup - new PortPairGroup
*/
@Override
- public void add(InstanceIdentifier<PortPairGroup> path, PortPairGroup newPortPairGroup) {
+ public void add(PortPairGroup newPortPairGroup) {
//NO-OP
}
}
/**
* Method removes PortPair which is identified by InstanceIdentifier.
*
- * @param path - the whole path to PortPair
* @param deletedPortPair - PortPair for removing
*/
@Override
- public void remove(InstanceIdentifier<PortPair> path, PortPair deletedPortPair) {
+ public void remove(PortPair deletedPortPair) {
LOG.info("Received remove port pair event {}", deletedPortPair);
ServiceFunctionKey sfKey = PortPairTranslator.getSFKey(deletedPortPair);
* Method updates the original PortPair to the update PortPair.
* Both are identified by same InstanceIdentifier.
*
- * @param path - the whole path to PortPair
- * @param originalPortPair - original PortPair (for update)
* @param updatePortPair - changed PortPair (contain updates)
*/
@Override
- public void update(InstanceIdentifier<PortPair> path, PortPair originalPortPair, PortPair updatePortPair) {
+ public void update(PortPair updatePortPair) {
//NO-OP
}
* Method adds the PortPair which is identified by InstanceIdentifier
* to device.
*
- * @param path - the whole path to new PortPair
* @param newPortPair - new PortPair
*/
@Override
- public void add(InstanceIdentifier<PortPair> path, PortPair newPortPair) {
+ public void add(PortPair newPortPair) {
//NO-OP
// Port Pair data written in neutron data store will be used
// When user will create port chain.
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.infrautils.counters.api.OccurenceCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetFlowStatisticsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetFlowStatisticsOutput;
private final Counters counters = new Counters();
@Inject
- public CounterRetriever(final RpcProviderRegistry rpcProviderRegistry,
- final StatisticsConfig statisticsConfig, final OpendaylightDirectStatisticsService odlDirectStatsService) {
+ public CounterRetriever(final StatisticsConfig statisticsConfig,
+ final OpendaylightDirectStatisticsService odlDirectStatsService) {
this.odlDirectStatsService = odlDirectStatsService;
- this.nodeResultTimeout = statisticsConfig.getNodeCounterResultTimeout();
+ nodeResultTimeout = statisticsConfig.getNodeCounterResultTimeout();
}
@PreDestroy
return crds;
}
- public CounterResultDataStructure getSwitchFlowCountersDirect(BigInteger dpId, Match match, short tableId) {
+ public CounterResultDataStructure getSwitchFlowCountersDirect(BigInteger dpId, Match match) {
NodeRef nodeRef = new NodeRef(InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(new NodeId(CountersUtils.getNodeId(dpId)))).toInstance());
GetFlowStatisticsInputBuilder gfsib = new GetFlowStatisticsInputBuilder();
}
public static Flow createFlowOnTable(Match match, int priority, short tableId) {
- return createFlowOnTable(match, priority, tableId, null, false, null);
+ return createFlowOnTable(match, priority, tableId, null, null);
}
public static Flow createFlowOnTable(Match match, int priority, short tableId, BigInteger cookie,
- boolean isCreateFlowIdFromMatch, Integer timeout) {
+ Integer timeout) {
FlowBuilder fb = new FlowBuilder();
if (match != null) {
fb.setMatch(match);
List<MatchInfoBase> matches = CountersServiceUtils.getCounterFlowMatch(ecr, lportTag,
ElementCountersDirection.valueOf(counterRequest.getTrafficDirection()));
Match match = MDSALUtil.buildMatches(matches);
- CounterResultDataStructure counterResultDS = counterRetriever.getSwitchFlowCountersDirect(dpId, match,
- CountersServiceUtils.getTableId(ecr.getDirection()));
- return counterResultDS;
+ return counterRetriever.getSwitchFlowCountersDirect(dpId, match);
}
private void initializeCountrsConfigDataSrore() {
String rd, String routerID, int label, RouteOrigin origin);
void addExtraRoute(String vpnName, String destination, String nextHop, String rd, String routerID,
- int label, Long l3vni, RouteOrigin origin, String intfName, Adjacency operationalAdj,
+ Long l3vni, RouteOrigin origin, String intfName, Adjacency operationalAdj,
VrfEntry.EncapType encapType, WriteTransaction writeConfigTxn);
void delExtraRoute(String vpnName, String destination, String nextHop, String rd, String routerID);
BigInteger dpnId, Uuid extNetworkId, WriteTransaction writeTx);
void addArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps, String routerGwMac,
- BigInteger dpnId, long vpnId, String extInterfaceName, int lportTag, WriteTransaction writeTx);
+ BigInteger dpnId, String extInterfaceName, int lportTag, WriteTransaction writeTx);
void removeArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps, String macAddress,
- BigInteger dpnId, Uuid extNetworkId, WriteTransaction writeTx);
+ BigInteger dpnId, Uuid extNetworkId);
void removeArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps,
- BigInteger dpnId, String extInterfaceName, int lportTag, WriteTransaction writeTx);
+ BigInteger dpnId, String extInterfaceName, int lportTag);
void onSubnetAddedToVpn(Subnetmap subnetmap, boolean isBgpVpn, Long elanTag);
* @param label Label of the route in the original VPN
* @param forcedOrigin By default, origin for leaked routes is INTERVPN, however it is possible to
* provide a different origin if desired.
- * @param addOrRemove states if the routes must be leaked or withdrawn
*/
void leakRoute(InterVpnLinkDataComposite interVpnLink, String srcVpnUuid, String dstVpnUuid,
- String prefix, Long label, RouteOrigin forcedOrigin, int addOrRemove);
+ String prefix, Long label, RouteOrigin forcedOrigin);
/**
* Similar to leakRouteIfNeeded but the only requisite to be met is that
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.Profile;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.ProfileBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.start.input.ConfigBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
+
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private AlivenessMonitorUtils() { }
public static void startArpMonitoring(MacEntry macEntry, Long arpMonitorProfileId,
- AlivenessMonitorService alivenessMonitorService, DataBroker dataBroker,
- OdlInterfaceRpcService interfaceRpc, INeutronVpnManager neutronVpnService,
- IInterfaceManager interfaceManager) {
+ AlivenessMonitorService alivenessMonitorService, DataBroker dataBroker,
+ INeutronVpnManager neutronVpnService,
+ IInterfaceManager interfaceManager) {
if (interfaceManager.isExternalInterface(macEntry.getInterfaceName())) {
LOG.debug("ARP monitoring is currently not supported through external interfaces,"
+ "skipping ARP monitoring from interface {} for IP {} (last known MAC {})",
return;
}
Optional<IpAddress> gatewayIpOptional =
- VpnUtil.getGatewayIpAddressFromInterface(macEntry.getInterfaceName(), neutronVpnService, dataBroker);
+ VpnUtil.getGatewayIpAddressFromInterface(macEntry.getInterfaceName(), neutronVpnService);
if (!gatewayIpOptional.isPresent()) {
LOG.error("Error while retrieving GatewayIp for interface{}", macEntry.getInterfaceName());
return;
}
final IpAddress gatewayIp = gatewayIpOptional.get();
Optional<String> gatewayMacOptional = VpnUtil.getGWMacAddressFromInterface(macEntry,
- gatewayIp, dataBroker, interfaceRpc);
+ gatewayIp, dataBroker);
if (!gatewayMacOptional.isPresent()) {
LOG.error("Error while retrieving GatewayMac for interface{}", macEntry.getInterfaceName());
return;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
public class ArpMonitorStartTask implements Callable<List<ListenableFuture<Void>>> {
private MacEntry macEntry;
private Long arpMonitorProfileId;
private DataBroker databroker;
private AlivenessMonitorService alivenessManager;
- private OdlInterfaceRpcService interfaceRpc;
private INeutronVpnManager neutronVpnService;
private IInterfaceManager interfaceManager;
public ArpMonitorStartTask(MacEntry macEntry, Long profileId, DataBroker databroker,
- AlivenessMonitorService alivenessManager, OdlInterfaceRpcService interfaceRpc,
- INeutronVpnManager neutronVpnService, IInterfaceManager interfaceManager) {
+ AlivenessMonitorService alivenessManager,
+ INeutronVpnManager neutronVpnService, IInterfaceManager interfaceManager) {
this.macEntry = macEntry;
this.arpMonitorProfileId = profileId;
this.databroker = databroker;
this.alivenessManager = alivenessManager;
- this.interfaceRpc = interfaceRpc;
this.neutronVpnService = neutronVpnService;
this.interfaceManager = interfaceManager;
}
@Override
public List<ListenableFuture<Void>> call() {
AlivenessMonitorUtils.startArpMonitoring(macEntry, arpMonitorProfileId,
- alivenessManager, databroker, interfaceRpc, neutronVpnService,
+ alivenessManager, databroker, neutronVpnService,
interfaceManager);
return null;
}
value.getCreationTime());
jobCoordinator.enqueueJob(buildJobKey(srcInetAddr.toString(), vpnName),
new ArpMonitorStartTask(macEntry, arpMonitorProfileId, dataBroker, alivenessManager,
- interfaceRpc, neutronVpnService, interfaceManager));
+ neutronVpnService, interfaceManager));
} catch (UnknownHostException e) {
LOG.error("Error in deserializing packet {} with exception", value, e);
}
subnetVpnName.getValue(), writeTx);
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName,
VpnUtil.getIpsListFromExternalIps(router.getExternalIps()),
- extGwMacAddress, primarySwitchId, extNetworkId, writeTx);
+ extGwMacAddress, primarySwitchId, extNetworkId);
}
}
}
throws InterruptedException, ExecutionException, UnknownHostException {
String vmVpnInterfaceName = VpnUtil.getVpnInterfaceName(odlInterfaceRpcService, metadata);
if (isTunnel(vmVpnInterfaceName)) {
- handlePacketFromTunnelToExternalNetwork(vpnIdVpnInstanceName, vmVpnInterfaceName,
+ handlePacketFromTunnelToExternalNetwork(vpnIdVpnInstanceName,
srcIpStr, dstIp, elanTag);
}
VpnInterface vmVpnInterface = VpnUtil.getVpnInterface(dataBroker, vmVpnInterfaceName);
transmitArpPacket(targetSubnetForPacketOut.getNhDpnId(), sourceIp, sourceMac, dstIp, elanTag);
}
- private void handlePacketFromTunnelToExternalNetwork(String vpnIdVpnInstanceName, String tunnelInterfaceName,
+ private void handlePacketFromTunnelToExternalNetwork(String vpnIdVpnInstanceName,
String srcIpStr, byte[] dstIp, long elanTag)
throws UnknownHostException {
String routerId = VpnUtil.getAssociatedExternalRouter(dataBroker, srcIpStr);
}
public static <T extends DataObject> void syncWrite(DataBroker dataBroker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
+ InstanceIdentifier<T> path, T data) {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(datastoreType, path, data, WriteTransaction.CREATE_MISSING_PARENTS);
try {
if (isGreTunnel(del)) {
programDcGwLoadBalancingGroup(del, NwConstants.DEL_FLOW);
}
- handleTunnelEventForDPN(del, UpdateRouteAction.WITHDRAW_ROUTE, TunnelAction.TUNNEL_EP_DELETE);
+ handleTunnelEventForDPN(del, TunnelAction.TUNNEL_EP_DELETE);
}
@Override
}
WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
if (tunOpStatus == TunnelOperStatus.Up) {
- handleTunnelEventForDPN(update, UpdateRouteAction.ADVERTISE_ROUTE, TunnelAction.TUNNEL_EP_ADD);
+ handleTunnelEventForDPN(update, TunnelAction.TUNNEL_EP_ADD);
} else {
vpnInstanceOpData.stream().filter(opData -> {
if (opData.getVpnToDpnList() == null) {
List<RoutePaths> routePaths = vrfEntry.getRoutePaths();
routePaths.forEach(routePath -> {
if (routePath.getNexthopAddress().equals(srcTepIp)) {
- fibManager.updateRoutePathForFibEntry(dataBroker, opData.getVrfId(),
+ fibManager.updateRoutePathForFibEntry(opData.getVrfId(),
destPrefix.getDestPrefix(), srcTepIp, routePath.getLabel(),
false, writeConfigTxn);
}
LOG.info("add: ITM Tunnel ,type {} ,added between src: {} and dest: {}",
fibManager.getTransportTypeStr(add.getTransportType().toString()),
add.getSrcInfo().getTepDeviceId(), add.getDstInfo().getTepDeviceId());
- handleTunnelEventForDPN(add, UpdateRouteAction.ADVERTISE_ROUTE, TunnelAction.TUNNEL_EP_ADD);
+ handleTunnelEventForDPN(add, TunnelAction.TUNNEL_EP_ADD);
}
public enum TunnelEventProcessingMethod {
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- private void handleTunnelEventForDPN(StateTunnelList stateTunnelList, UpdateRouteAction action,
- TunnelAction tunnelAction) {
+ private void handleTunnelEventForDPN(StateTunnelList stateTunnelList,
+ TunnelAction tunnelAction) {
final BigInteger srcDpnId = new BigInteger(stateTunnelList.getSrcInfo().getTepDeviceId());
final String srcTepIp = String.valueOf(stateTunnelList.getSrcInfo().getTepIp().getValue());
String destTepIp = String.valueOf(stateTunnelList.getDstInfo().getTepIp().getValue());
if (vpnInterface != null && !vpnInterface.isScheduledForRemove()) {
listVpnName.addAll(VpnHelper
.getVpnInterfaceVpnInstanceNamesString(vpnInterface.getVpnInstanceNames()));
- handleTunnelEventForDPNVpn(stateTunnelList, action, vpnIdRdMap,
+ handleTunnelEventForDPNVpn(stateTunnelList, vpnIdRdMap,
tunnelAction, isTepDeletedOnDpn,
subnetList, TunnelEventProcessingMethod.POPULATESUBNETS,
vpnInterface);
VpnInterface vpnInterface =
VpnUtil.getConfiguredVpnInterface(dataBroker, intfName);
if (vpnInterface != null) {
- handleTunnelEventForDPNVpn(stateTunnelList, action, vpnIdRdMap,
+ handleTunnelEventForDPNVpn(stateTunnelList, vpnIdRdMap,
tunnelAction, isTepDeletedOnDpn,
subnetList, TunnelEventProcessingMethod.MANAGEREMOTEROUTES,
vpnInterface);
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- private void handleTunnelEventForDPNVpn(StateTunnelList stateTunnelList, UpdateRouteAction action,
+ private void handleTunnelEventForDPNVpn(StateTunnelList stateTunnelList,
Map<Long, String> vpnIdRdMap, TunnelAction tunnelAction,
boolean isTepDeletedOnDpn, List<Uuid> subnetList,
TunnelEventProcessingMethod method,
protected void add(final InstanceIdentifier<VpnInstance> identifier, final VpnInstance value) {
LOG.trace("{} add: Add VPN event key: {}, value: {}", LOGGING_PREFIX_ADD, identifier, value);
final String vpnName = value.getVpnInstanceName();
- jobCoordinator.enqueueJob("VPN-" + vpnName, new AddVpnInstanceWorker(idManager, dataBroker, value),
+ jobCoordinator.enqueueJob("VPN-" + vpnName, new AddVpnInstanceWorker(dataBroker, value),
SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
private class AddVpnInstanceWorker implements Callable<List<ListenableFuture<Void>>> {
private final Logger log = LoggerFactory.getLogger(AddVpnInstanceWorker.class);
- IdManagerService idManager;
VpnInstance vpnInstance;
DataBroker broker;
- AddVpnInstanceWorker(IdManagerService idManager,
- DataBroker broker,
- VpnInstance value) {
- this.idManager = idManager;
+ AddVpnInstanceWorker(DataBroker broker,
+ VpnInstance value) {
this.broker = broker;
this.vpnInstance = value;
}
} else {
TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnInstanceName),
- vpnInstanceToVpnId, TransactionUtil.DEFAULT_CALLBACK);
+ vpnInstanceToVpnId);
}
VpnIds vpnIdToVpnInstance = VpnUtil.getVpnIdToVpnInstance(vpnId, value.getVpnInstanceName(),
} else {
TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId),
- vpnIdToVpnInstance, TransactionUtil.DEFAULT_CALLBACK);
+ vpnIdToVpnInstance);
}
try {
} else {
TransactionUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
VpnUtil.getVpnInstanceOpDataIdentifier(primaryRd),
- builder.build(), TransactionUtil.DEFAULT_CALLBACK);
+ builder.build());
}
LOG.info("{} addVpnInstance: VpnInstanceOpData populated successfully for vpn {} rd {}", LOGGING_PREFIX_ADD,
vpnInstanceName, primaryRd);
*/
VpnAfConfig config = vpnInstance.getIpv4Family();
List<String> rd = config.getRouteDistinguisher();
- if (rd == null || addBgpVrf(voids)) {
+ if (rd == null || addBgpVrf()) {
notifyTask();
vpnInterfaceManager.vpnInstanceIsReady(vpnName);
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- private boolean addBgpVrf(List<Void> voids) {
+ private boolean addBgpVrf() {
VpnAfConfig config = vpnInstance.getIpv4Family();
String primaryRd = VpnUtil.getPrimaryRd(dataBroker, vpnName);
List<VpnTarget> vpnTargetList = config.getVpnTargets().getVpnTarget();
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addArpResponderFlowsToExternalNetworkIps(routerName,
VpnUtil.getIpsListFromExternalIps(router.getExternalIps()), router.getExtGwMacAddress(),
- dpId, vpnId, interfaceName, lportTag, writeInvTxn);
+ dpId, interfaceName, lportTag, writeInvTxn);
} else {
vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName,
VpnUtil.getIpsListFromExternalIps(router.getExternalIps()),
- dpId, interfaceName, lportTag, writeInvTxn);
+ dpId, interfaceName, lportTag);
}
} else {
LOG.error("processExternalVpnInterface: No external-router found for router-id {}. Bailing out of"
// Use this for programming ARP_RESPONDER table here. And save this
// info into vpnInterface operational, so it can used in VrfEntryProcessor
// to populate L3_GW_MAC_TABLE there.
- arpResponderHandler.addArpResponderFlow(dpnId, lportTag, vpnName, vpnId, interfaceName,
- subnetId, gatewayIp.get(), gwMac.get());
+ arpResponderHandler.addArpResponderFlow(dpnId, lportTag, interfaceName,
+ gatewayIp.get(), gwMac.get());
vpnInterfaceSubnetGwMacAddress = gwMac.get();
} else {
// A valid mac-address is not available for this subnet-gateway-ip
if (gwMac.isPresent()) {
VpnUtil.setupGwMacIfExternalVpn(dataBroker, mdsalManager, dpnId, interfaceName,
vpnId, writeInvTxn, NwConstants.ADD_FLOW, gwMac.get());
- arpResponderHandler.addArpResponderFlow(dpnId, lportTag, vpnName, vpnId, interfaceName,
- subnetId, gatewayIp.get(), gwMac.get());
+ arpResponderHandler.addArpResponderFlow(dpnId, lportTag, interfaceName,
+ gatewayIp.get(), gwMac.get());
} else {
LOG.error("processVpnInterfaceAdjacencies: Gateway MAC for subnet ID {} could not be "
+ "obtained, cannot create ARP responder flow for interface name {}, vpnName {}, "
synchronized (vpnPrefixKey.intern()) {
java.util.Optional<String> rdToAllocate = VpnUtil
.allocateRdForExtraRouteAndUpdateUsedRdsMap(dataBroker, vpnId, null,
- prefix, vpnName, nextHop.getNextHopIpList().get(0), dpnId, writeOperTxn);
+ prefix, vpnName, nextHop.getNextHopIpList().get(0), dpnId);
if (rdToAllocate.isPresent()) {
rd = rdToAllocate.get();
LOG.info("processVpnInterfaceAdjacencies: The rd {} is allocated for the extraroute {}",
}
if (nextHop.getAdjacencyType() != AdjacencyType.PrimaryAdjacency) {
vpnManager.addExtraRoute(vpnName, nextHop.getIpAddress(), nextHop.getNextHopIpList().get(0), rd,
- vpnName, operationalAdjacency.getLabel().intValue(), l3vni, origin,
+ vpnName, l3vni, origin,
interfaceName, operationalAdjacency, encapType, writeConfigTxn);
}
value.add(operationalAdjacency);
gwMac.isPresent() ? gwMac.get() : null, writeOperTxn);
L3vpnInput input = new L3vpnInput().setNextHopIp(nextHopIp).setL3vni(l3vni).setPrimaryRd(primaryRd)
- .setGatewayMac(gwMac.isPresent() ? gwMac.get() : null).setInterfaceName(interfaceName)
+ .setGatewayMac(gwMac.orNull()).setInterfaceName(interfaceName)
.setVpnName(vpnName).setDpnId(dpnId).setEncapType(encapType);
for (Adjacency nextHop : aug.getAdjacency()) {
RouteOrigin origin = nextHop.getAdjacencyType() == AdjacencyType.PrimaryAdjacency ? RouteOrigin.LOCAL
: RouteOrigin.STATIC;
input.setNextHop(nextHop).setRd(nextHop.getVrfId()).setRouteOrigin(origin);
- registeredPopulator.populateFib(input, writeConfigTxn, writeOperTxn);
+ registeredPopulator.populateFib(input, writeConfigTxn);
}
}
}
+ " vpn {} vpnid {} rd {} interface {}", label, srcDpnId , prefix, nhList,
vpnInterface.getVpnInstanceName(), vpnId, rd, vpnInterface.getName());
// Update the VRF entry with nextHop
- fibManager.updateRoutePathForFibEntry(dataBroker, primaryRd, prefix, srcTepIp,
+ fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp,
label, true, writeConfigTxn);
//Get the list of VPN's importing this route(prefix) .
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
- fibManager.updateRoutePathForFibEntry(dataBroker, vpnRd, prefix,
+ fibManager.updateRoutePathForFibEntry(vpnRd, prefix,
srcTepIp, label, true, writeConfigTxn);
LOG.info("updateVpnInterfaceOnTepAdd: Exported route with rd {} prefix {} nhList {} label {}"
+ " interface {} dpn {} from vpn {} to VPN {} vpnRd {}", rd, prefix, nhList, label,
prefix, nhList, vpnName,
vpnId, rd, vpnInterface.getName());
// Update the VRF entry with removed nextHop
- fibManager.updateRoutePathForFibEntry(dataBroker, primaryRd, prefix, srcTepIp,
+ fibManager.updateRoutePathForFibEntry(primaryRd, prefix, srcTepIp,
label, false, writeConfigTxn);
//Get the list of VPN's importing this route(prefix) .
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
- fibManager.updateRoutePathForFibEntry(dataBroker, vpnRd, prefix,
+ fibManager.updateRoutePathForFibEntry(vpnRd, prefix,
srcTepIp, label, false, writeConfigTxn);
LOG.info("updateVpnInterfaceOnTepDelete: Exported route with rd {} prefix {} nhList {}"
+ " label {} interface {} dpn {} from vpn {} to VPN {} vpnRd {}", rd, prefix,
LOG.info("handleVpnsExportingRoutesImporting: Importing fib entry rd {} prefix {}"
+ " nexthop {} label {} to vpn {} vpnRd {}", vpn.getVrfId(), prefix, nh, label,
vpnName, vpnRd);
- fibManager.addOrUpdateFibEntry(dataBroker, vpnRd, null /*macAddress*/, prefix,
+ fibManager.addOrUpdateFibEntry(vpnRd, null /*macAddress*/, prefix,
Collections.singletonList(nh), VrfEntry.EncapType.Mplsgre, label,
0 /*l3vni*/, gwMac, null /*parentVpnRd*/, RouteOrigin.SELF_IMPORTED,
writeConfigTxn);
if (nextHop.isPhysNetworkFunc()) {
LOG.info("removeAdjacenciesFromVpn: Removing PNF FIB entry rd {} prefix {}",
nextHop.getSubnetId().getValue(), nextHop.getIpAddress());
- fibManager.removeFibEntry(dataBroker, nextHop.getSubnetId().getValue(), nextHop.getIpAddress(),
+ fibManager.removeFibEntry(nextHop.getSubnetId().getValue(), nextHop.getIpAddress(),
null/*writeCfgTxn*/);
} else {
String rd = nextHop.getVrfId();
// This is a primary adjacency
nhList = nextHop.getNextHopIpList() != null ? nextHop.getNextHopIpList()
: Collections.emptyList();
- removeGwMacAndArpResponderFlows(nextHop, vpnId, vpnName, dpnId, lportTag, gwMac,
+ removeGwMacAndArpResponderFlows(nextHop, vpnId, dpnId, lportTag, gwMac,
interfaceName, writeInvTxn);
}
if (!nhList.isEmpty()) {
+ " interface {}", nextHop.getIpAddress(), rd,
nextHop.getAdjacencyType().toString(), interfaceName);
bgpManager.withdrawPrefix(rd, nextHop.getIpAddress());
- fibManager.removeFibEntry(dataBroker, primaryRd, nextHop.getIpAddress(), writeConfigTxn);
+ fibManager.removeFibEntry(primaryRd, nextHop.getIpAddress(), writeConfigTxn);
}
}
String ip = nextHop.getIpAddress().split("/")[0];
String interfaceName, BigInteger dpnId,
WriteTransaction writeConfigTxn) {
return (nh) -> {
- fibManager.removeOrUpdateFibEntry(dataBroker, vpnName, nextHop.getIpAddress(), nh,
+ fibManager.removeOrUpdateFibEntry(vpnName, nextHop.getIpAddress(), nh,
writeConfigTxn);
LOG.info("removeAdjacenciesFromVpn: removed/updated FIB with rd {} prefix {}"
+ " nexthop {} for interface {} on dpn {} for internal vpn {}",
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
- fibManager.removeOrUpdateFibEntry(dataBroker, vpnRd,
+ fibManager.removeOrUpdateFibEntry(vpnRd,
nextHop.getIpAddress(), nh, writeConfigTxn);
LOG.info("removeAdjacenciesFromVpn: Removed Exported route with rd {}"
+ " prefix {} nextHop {} from VPN {} parentVpn {}"
});
}
- private void removeGwMacAndArpResponderFlows(Adjacency nextHop, long vpnId, String vpnName, BigInteger dpnId,
+ private void removeGwMacAndArpResponderFlows(Adjacency nextHop, long vpnId, BigInteger dpnId,
int lportTag, String gwMac, String interfaceName,
WriteTransaction writeInvTxn) {
final Uuid subnetId = nextHop.getSubnetId();
VpnUtil.setupGwMacIfExternalVpn(dataBroker, mdsalManager, dpnId, interfaceName,
vpnId, writeInvTxn, NwConstants.DEL_FLOW, gwMac);
}
- arpResponderHandler.removeArpResponderFlow(dpnId, lportTag, interfaceName, vpnName, vpnId,
- subnetId);
+ arpResponderHandler.removeArpResponderFlow(dpnId, lportTag, interfaceName, subnetId);
}
private List<String> getNextHopForNonPrimaryAdjacency(Adjacency nextHop, String vpnName, BigInteger dpnId,
String vpnPrefixKey = VpnUtil.getVpnNamePrefixKey(vpnName, prefix);
synchronized (vpnPrefixKey.intern()) {
java.util.Optional<String> rdToAllocate = VpnUtil.allocateRdForExtraRouteAndUpdateUsedRdsMap(
- dataBroker, vpnId, null, prefix, vpnName, nh, dpnId, writeOperTxn);
+ dataBroker, vpnId, null, prefix, vpnName, nh, dpnId);
if (rdToAllocate.isPresent()) {
input.setRd(rdToAllocate.get());
operationalAdjacency = populator.createOperationalAdjacency(input);
int label = operationalAdjacency.getLabel().intValue();
vpnManager.addExtraRoute(vpnName, adj.getIpAddress(), nh, rdToAllocate.get(),
- currVpnIntf.getVpnInstanceName(), label, l3vni, origin,
+ currVpnIntf.getVpnInstanceName(), l3vni, origin,
currVpnIntf.getName(), operationalAdjacency, encapType, writeConfigTxn);
LOG.info("addNewAdjToVpnInterface: Added extra route ip {} nh {} rd {} vpnname {} label {}"
+ " Interface {} on dpn {}", adj.getIpAddress(), nh, rdToAllocate.get(),
if (vpn.getVrfId() != null) {
VpnUtil.allocateRdForExtraRouteAndUpdateUsedRdsMap(
dataBroker, vpn.getVpnId(), vpnId, prefix,
- VpnUtil.getVpnName(dataBroker, vpn.getVpnId()), nh, dpnId,
- writeOperTxn)
+ VpnUtil.getVpnName(dataBroker, vpn.getVpnId()), nh, dpnId)
.ifPresent(
rds -> vpnManager.addExtraRoute(
VpnUtil.getVpnName(dataBroker, vpn.getVpnId()),
adj.getIpAddress(), nh, rds,
currVpnIntf.getVpnInstanceName(),
- opAdjacency.getLabel().intValue(),
l3vni, RouteOrigin.SELF_IMPORTED,
currVpnIntf.getName(), opAdjacency, encapType, writeConfigTxn));
}
VpnUtil.getPrefixToInterface(BigInteger.ZERO, currVpnIntf.getName(), prefix,
adj.getSubnetId(), Prefixes.PrefixCue.PhysNetFunc), true);
- fibManager.addOrUpdateFibEntry(dataBroker, adj.getSubnetId().getValue(), adj.getMacAddress(),
+ fibManager.addOrUpdateFibEntry(adj.getSubnetId().getValue(), adj.getMacAddress(),
adj.getIpAddress(), Collections.emptyList(), null /* EncapType */, 0 /* label */, 0 /*l3vni*/,
null /* gw-mac */, parentVpnRd, RouteOrigin.LOCAL, writeConfigTxn);
} else if (adj.isPhysNetworkFunc()) {
LOG.info("delAdjFromVpnInterface: deleting PNF adjacency prefix {} subnet [}",
adj.getIpAddress(), adj.getSubnetId());
- fibManager.removeFibEntry(dataBroker, adj.getSubnetId().getValue(), adj.getIpAddress(),
+ fibManager.removeFibEntry(adj.getSubnetId().getValue(), adj.getIpAddress(),
writeConfigTxn);
}
break;
RouterInterface routerInt = new RouterInterfaceBuilder().setUuid(vpnName)
.setIpAddress(primaryInterfaceIp).setMacAddress(macAddress).build();
- fibManager.addFibEntryForRouterInterface(dataBroker, primaryRd, prefix,
+ fibManager.addFibEntryForRouterInterface(primaryRd, prefix,
routerInt, label, writeConfigTxn);
LOG.info("createFibEntryForRouterInterface: Router interface {} for vpn {} rd {} prefix {} label {}"
+ " macAddress {} processed successfully;", interfaceName, vpnName, primaryRd, prefix, label,
if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
String primaryInterfaceIp = adj.getIpAddress();
String prefix = VpnUtil.getIpPrefix(primaryInterfaceIp);
- fibManager.removeFibEntry(dataBroker, rd, prefix, writeConfigTxn);
+ fibManager.removeFibEntry(rd, prefix, writeConfigTxn);
LOG.info("deleteFibEntryForRouterInterface: FIB for router interface {} deleted for vpn {} rd {}"
+ " prefix {}", vpnInterface.getName(), vpnName, rd, prefix);
return;
() -> {
WriteTransaction writeConfigTxn = dataBroker.newWriteOnlyTransaction();
WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
- if (VpnUtil.isAdjacencyEligibleToVpn(
- dataBroker, adjacency, vpnName, vpnInterface.getInterfaceName())) {
+ if (VpnUtil.isAdjacencyEligibleToVpn(dataBroker, adjacency, vpnName)) {
addNewAdjToVpnInterface(existingVpnInterfaceId, primaryRd, adjacency,
vpnInterfaceOptional.get().getDpnId(), writeConfigTxn, writeOperTxn);
ListenableFuture<Void> operFuture = writeOperTxn.submit();
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MatchInfoBase;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
-import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.UpgradeState;
import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
public VpnManagerImpl(final DataBroker dataBroker,
final IdManagerService idManagerService,
final IMdsalApiManager mdsalManager,
- final VpnFootprintService vpnFootprintService,
final IElanService elanService,
final IInterfaceManager interfaceManager,
final VpnSubnetRouteHandler vpnSubnetRouteHandler,
VpnInstanceOpDataEntry vpnOpEntry = VpnUtil.getVpnInstanceOpData(dataBroker, rd);
Boolean isVxlan = VpnUtil.isL3VpnOverVxLan(vpnOpEntry.getL3vni());
VrfEntry.EncapType encapType = VpnUtil.getEncapType(isVxlan);
- addExtraRoute(vpnName, destination, nextHop, rd, routerID, label, vpnOpEntry.getL3vni(),
+ addExtraRoute(vpnName, destination, nextHop, rd, routerID, vpnOpEntry.getL3vni(),
origin,/*intfName*/ null, null /*Adjacency*/, encapType, null);
}
@Override
public void addExtraRoute(String vpnName, String destination, String nextHop, String rd, String routerID,
- int label, Long l3vni, RouteOrigin origin, String intfName, Adjacency operationalAdj,
+ Long l3vni, RouteOrigin origin, String intfName, Adjacency operationalAdj,
VrfEntry.EncapType encapType, WriteTransaction writeConfigTxn) {
Boolean writeConfigTxnPresent = true;
+ " route for destination {}", destination);
return;
}
- ivpnLinkService.leakRoute(interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel, RouteOrigin.STATIC,
- NwConstants.ADD_FLOW);
+ ivpnLinkService.leakRoute(interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel, RouteOrigin.STATIC);
} else {
Optional<Routes> optVpnExtraRoutes = VpnExtraRouteHelper
.getVpnExtraroutes(dataBroker, vpnName, rd != null ? rd : routerID, destination);
L3vpnInput input = new L3vpnInput().setNextHop(operationalAdj).setNextHopIp(nextHop).setL3vni(l3vni)
.setPrimaryRd(primaryRd).setVpnName(vpnName).setDpnId(dpnId)
.setEncapType(encapType).setRd(rd).setRouteOrigin(origin);
- L3vpnRegistry.getRegisteredPopulator(encapType).populateFib(input, writeConfigTxn, null);
+ L3vpnRegistry.getRegisteredPopulator(encapType).populateFib(input, writeConfigTxn);
}
}
}
LOG.info("delExtraRoute: Removed extra route {} from interface {} for rd {}", destination, intfName, rd);
} else {
// add FIB route directly
- fibManager.removeOrUpdateFibEntry(dataBroker, routerID, destination, tunnelIp, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(routerID, destination, tunnelIp, writeConfigTxn);
LOG.info("delExtraRoute: Removed extra route {} from interface {} for rd {}", destination, intfName,
routerID);
}
return;
}
}
- fibManager.removeOrUpdateFibEntry(dataBroker, primaryRd, prefix, tunnelIp, writeConfigTxn);
+ fibManager.removeOrUpdateFibEntry(primaryRd, prefix, tunnelIp, writeConfigTxn);
if (VpnUtil.isEligibleForBgp(rd, vpnName, dpnId, null /*networkName*/)) {
// TODO: Might be needed to include nextHop here
bgpManager.withdrawPrefix(rd, prefix);
@Override
public void addArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps, String macAddress,
- BigInteger dpnId, long vpnId, String extInterfaceName, int lportTag, WriteTransaction writeTx) {
+ BigInteger dpnId, String extInterfaceName, int lportTag, WriteTransaction writeTx) {
if (fixedIps == null || fixedIps.isEmpty()) {
LOG.debug("No external IPs defined for {}", id);
return;
tx -> {
for (String fixedIp : fixedIps) {
installArpResponderFlowsToExternalNetworkIp(macAddress, dpnId, extInterfaceName, lportTag,
- vpnId,fixedIp, tx);
+ fixedIp);
}
});
ListenableFutures.addErrorLogging(future, LOG, "Commit transaction");
} else {
for (String fixedIp : fixedIps) {
- installArpResponderFlowsToExternalNetworkIp(macAddress, dpnId, extInterfaceName, lportTag, vpnId,
- fixedIp, writeTx);
+ installArpResponderFlowsToExternalNetworkIp(macAddress, dpnId, extInterfaceName, lportTag,
+ fixedIp);
}
}
}
return;
}
- long vpnId = getVpnIdFromExtNetworkId(extNetworkId);
- addArpResponderFlowsToExternalNetworkIps(id, fixedIps, macAddress, dpnId, vpnId, extInterfaceName, lportTag,
+ addArpResponderFlowsToExternalNetworkIps(id, fixedIps, macAddress, dpnId, extInterfaceName, lportTag,
writeTx);
}
@Override
public void removeArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps, String macAddress,
- BigInteger dpnId, Uuid extNetworkId, WriteTransaction writeTx) {
+ BigInteger dpnId, Uuid extNetworkId) {
if (dpnId == null || BigInteger.ZERO.equals(dpnId)) {
LOG.warn("Failed to remove arp responder flows for router {}. DPN id is missing.", id);
}
removeArpResponderFlowsToExternalNetworkIps(id, fixedIps, dpnId,
- extInterfaceName, lportTag, writeTx);
+ extInterfaceName, lportTag);
}
@Override
public void removeArpResponderFlowsToExternalNetworkIps(String id, Collection<String> fixedIps,
- BigInteger dpnId, String extInterfaceName, int lportTag, WriteTransaction writeTx) {
+ BigInteger dpnId, String extInterfaceName, int lportTag) {
if (fixedIps == null || fixedIps.isEmpty()) {
LOG.debug("No external IPs defined for {}", id);
return;
}
private void installArpResponderFlowsToExternalNetworkIp(String macAddress, BigInteger dpnId,
- String extInterfaceName, int lportTag, long vpnId, String fixedIp, WriteTransaction writeTx) {
+ String extInterfaceName, int lportTag, String fixedIp) {
// reset the split-horizon bit to allow traffic to be sent back to the
// provider port
List<Instruction> instructions = new ArrayList<>();
elanService.removeArpResponderFlow(arpInput);
}
- private long getVpnIdFromExtNetworkId(Uuid extNetworkId) {
- Uuid vpnInstanceId = VpnUtil.getExternalNetworkVpnId(dataBroker, extNetworkId);
- if (vpnInstanceId == null) {
- LOG.debug("Network {} is not associated with VPN", extNetworkId.getValue());
- return VpnConstants.INVALID_ID;
- }
-
- return VpnUtil.getVpnId(dataBroker, vpnInstanceId.getValue());
- }
-
@Override
public void onSubnetAddedToVpn(Subnetmap subnetmap, boolean isBgpVpn, Long elanTag) {
vpnSubnetRouteHandler.onSubnetAddedToVpn(subnetmap, isBgpVpn, elanTag);
VpnUtil.removeVpnInstanceToVpnId(dataBroker, vpnName, writeTxn);
LOG.trace("Removed vpnIdentifier for rd{} vpnname {}", primaryRd, vpnName);
// Clean up FIB Entries Config DS
- fibManager.removeVrfTable(dataBroker, primaryRd, null);
+ fibManager.removeVrfTable(primaryRd, null);
// Clean up VPNExtraRoutes Operational DS
if (VpnUtil.isBgpVpn(vpnName, primaryRd)) {
if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
}
} else {
vpnManager.addExtraRoute(vpnInstanceName, destination, nexthop, vpnRd, null /* routerId */,
- label.intValue(), vpnOpEntry.getL3vni(), RouteOrigin.STATIC, null /* intfName */,
+ vpnOpEntry.getL3vni(), RouteOrigin.STATIC, null /* intfName */,
null /*Adjacency*/, encapType, null);
}
Optional<InterVpnLinkDataComposite> optVpnLink = interVpnLinkCache.getInterVpnLinkByEndpoint(nexthop);
if (optVpnLink.isPresent()) {
- fibManager.removeOrUpdateFibEntry(dataBroker, vpnRd, destination, nexthop, /*writeTx*/ null);
+ fibManager.removeOrUpdateFibEntry(vpnRd, destination, nexthop, /*writeTx*/ null);
bgpManager.withdrawPrefix(vpnRd, destination);
} else {
vpnManager.delExtraRoute(vpnInstanceName, destination,
.setSubnetIp(subnetIp).setNextHopIp(nextHopIp).setL3vni(l3vni).setLabel(label).setElanTag(elanTag)
.setDpnId(nhDpnId).setEncapType(encapType).setNetworkName(networkName).setPrimaryRd(rd);
if (!isBgpVpn) {
- vpnPopulator.populateFib(input, null /*writeCfgTxn*/, null /*writeOperTxn*/);
+ vpnPopulator.populateFib(input, null /*writeCfgTxn*/);
return true;
}
Preconditions.checkNotNull(nextHopIp, LOGGING_PREFIX + "NextHopIp cannot be null or empty!");
.getPrefixToInterfaceIdentifier(VpnUtil.getVpnId(dataBroker, vpnName), subnetIp), VpnUtil
.getPrefixToInterface(nhDpnId, subnetId.getValue(), subnetIp, subnetId,
Prefixes.PrefixCue.SubnetRoute));
- vpnPopulator.populateFib(input, null /*writeCfgTxn*/, null /*writeOperTxn*/);
+ vpnPopulator.populateFib(input, null /*writeCfgTxn*/);
try {
// BGP manager will handle withdraw and advertise internally if prefix
// already exist
}
public void deleteSubnetRouteFibEntryFromDS(String rd, String prefix, String vpnName) {
- fibManager.removeFibEntry(dataBroker, rd, prefix, null);
+ fibManager.removeFibEntry(rd, prefix, null);
List<VpnInstanceOpDataEntry> vpnsToImportRoute = VpnUtil.getVpnsImportingMyRoute(dataBroker, vpnName);
for (VpnInstanceOpDataEntry vpnInstance : vpnsToImportRoute) {
String importingRd = vpnInstance.getVrfId();
- fibManager.removeFibEntry(dataBroker, importingRd, prefix, null);
+ fibManager.removeFibEntry(importingRd, prefix, null);
LOG.info("SUBNETROUTE: deleteSubnetRouteFibEntryFromDS: Deleted imported subnet route rd {} prefix {}"
+ " from vpn {} importingRd {}", rd, prefix, vpnInstance.getVpnInstanceName(), importingRd);
}
}
static Optional<IpAddress> getGatewayIpAddressFromInterface(String srcInterface,
- INeutronVpnManager neutronVpnService, DataBroker dataBroker) {
+ INeutronVpnManager neutronVpnService) {
Optional<IpAddress> gatewayIp = Optional.absent();
if (neutronVpnService != null) {
//TODO(Gobinath): Need to fix this as assuming port will belong to only one Subnet would be incorrect"
}
static Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp,
- DataBroker dataBroker, OdlInterfaceRpcService interfaceRpc) {
+ DataBroker dataBroker) {
Optional<String> gatewayMac = Optional.absent();
long vpnId = getVpnId(dataBroker, macEntry.getVpnName());
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
}
public static Optional<VpnPortipToPort> getRouterInterfaceForVpnInterface(DataBroker dataBroker,
- String interfaceName,
String vpnName,
Uuid subnetUuid) {
Optional<VpnPortipToPort> gwPortOptional = Optional.absent();
static java.util.Optional<String> allocateRdForExtraRouteAndUpdateUsedRdsMap(
DataBroker dataBroker, long vpnId, @Nullable Long parentVpnId, String prefix, String vpnName,
- String nextHop, BigInteger dpnId, WriteTransaction writeOperTxn) {
+ String nextHop, BigInteger dpnId) {
//Check if rd is already allocated for this extraroute behind the same VM. If yes, reuse it.
//This is particularly useful during reboot scenarios.
java.util.Optional<String> allocatedRd = VpnExtraRouteHelper
}
public static boolean isAdjacencyEligibleToVpn(DataBroker dataBroker, Adjacency adjacency,
- String vpnName, String interfaceName) {
+ String vpnName) {
// returns true if BGPVPN Internet and adjacency is IPv6, false otherwise
boolean adjacencyEligible = true;
// if BGPVPN internet, return false if subnetmap has not internetVpnId() filled in
* dpn Id on which ARP responder flow to be added
* @param lportTag
* lport tag of the interface
- * @param vpnName
- * vpnname of the interface
- * @param vpnId
- * vpn id that interface belongs to
* @param interfaceName
* interface to which ARP responder flow to be added
- * @param subnetId
- * subnet Id of the interface
* @param gatewayIp
* gateway ip of the interface
* @param mac
* mac address
*/
- public void addArpResponderFlow(BigInteger dpnId, int lportTag, String vpnName, long vpnId, String interfaceName,
- Uuid subnetId, String gatewayIp, String mac) {
+ public void addArpResponderFlow(BigInteger dpnId, int lportTag, String interfaceName,
+ String gatewayIp, String mac) {
LOG.trace("Creating the ARP Responder flow for VPN Interface {}", interfaceName);
ArpReponderInputBuilder builder = new ArpReponderInputBuilder();
* lport tag of the interface
* @param ifName
* interface to which ARP responder flow to be removed
- * @param vpnName
- * vpnname of the interface
- * @param vpnId
- * vpn id that interface belongs to
- *
* @param subnetUuid
* subnet Id of the interface
*/
- public void removeArpResponderFlow(BigInteger dpId, int lportTag, String ifName, String vpnName, long vpnId,
+ public void removeArpResponderFlow(BigInteger dpId, int lportTag, String ifName,
Uuid subnetUuid) {
Optional<String> gwIp = VpnUtil.getVpnSubnetGatewayIp(dataBroker, subnetUuid);
if (gwIp.isPresent()) {
String key = dstVpnRd + VpnConstants.SEPARATOR + prefix;
long leakedLabel = VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME, key);
String leakedNexthop = interVpnLink.getEndpointIpAddr(vpnName);
- fibManager.addOrUpdateFibEntry(dataBroker, dstVpnRd, null /*macAddress*/, prefix,
+ fibManager.addOrUpdateFibEntry(dstVpnRd, null /*macAddress*/, prefix,
Collections.singletonList(leakedNexthop), VrfEntry.EncapType.Mplsgre,
(int) leakedLabel, 0 /*l3vni*/, null /*gatewayMacAddress*/,
null /*parentVpnRd*/, RouteOrigin.INTERVPN, null /*writeConfigTxn*/);
}
} else {
LOG.debug("Removing leaked route to {} from VPN {}", prefix, dstVpnName);
- fibManager.removeFibEntry(dataBroker, dstVpnRd, prefix, null /*writeConfigTxn*/);
+ fibManager.removeFibEntry(dstVpnRd, prefix, null /*writeConfigTxn*/);
bgpManager.withdrawPrefix(dstVpnRd, prefix);
}
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
public void leakRoute(InterVpnLinkDataComposite interVpnLink, String srcVpnUuid, String dstVpnUuid,
- String prefix, Long label, RouteOrigin forcedOrigin, int addOrRemove) {
+ String prefix, Long label, RouteOrigin forcedOrigin) {
String ivpnLinkName = interVpnLink.getInterVpnLinkName();
// The source VPN must participate in the InterVpnLink
Preconditions.checkArgument(interVpnLink.isVpnLinked(srcVpnUuid),
if (! originsToConsider.isEmpty()) {
// 1st Endpoint ==> 2nd endpoint
- leakRoutes(ivpnLink, vpn1Uuid, vpn2Uuid, originsToConsider, NwConstants.ADD_FLOW);
+ leakRoutes(ivpnLink, vpn1Uuid, vpn2Uuid, originsToConsider);
// 2nd Endpoint ==> 1st endpoint
- leakRoutes(ivpnLink, vpn2Uuid, vpn1Uuid, originsToConsider, NwConstants.ADD_FLOW);
+ leakRoutes(ivpnLink, vpn2Uuid, vpn1Uuid, originsToConsider);
}
// Static routes in Vpn1 pointing to Vpn2's endpoint
vpnLink.getInterVpnLinkName(), vpn1Rd, vrfEntry.getDestPrefix());
} else {
leakRoute(vpnLink, vpn2Uuid, vpn1Uuid, vrfEntry.getDestPrefix(), label,
- RouteOrigin.value(vrfEntry.getOrigin()), NwConstants.ADD_FLOW);
+ RouteOrigin.value(vrfEntry.getOrigin()));
}
});
}
private void leakRoutes(InterVpnLinkDataComposite vpnLink, String srcVpnUuid, String dstVpnUuid,
- List<RouteOrigin> originsToConsider, int addOrRemove) {
+ List<RouteOrigin> originsToConsider) {
String srcVpnRd = VpnUtil.getVpnRd(dataBroker, srcVpnUuid);
String dstVpnRd = VpnUtil.getVpnRd(dataBroker, dstVpnUuid);
List<VrfEntry> srcVpnRemoteVrfEntries = VpnUtil.getVrfEntriesByOrigin(dataBroker, srcVpnRd, originsToConsider);
vpnLink.getInterVpnLinkName(), dstVpnRd, vrfEntry.getDestPrefix());
continue;
}
- leakRoute(vpnLink, srcVpnUuid, dstVpnUuid, vrfEntry.getDestPrefix(), label, null /*NotForcedOrigin*/,
- addOrRemove);
+ leakRoute(vpnLink, srcVpnUuid, dstVpnUuid, vrfEntry.getDestPrefix(), label, null /*NotForcedOrigin*/);
}
}
&& shouldConfigureLinkIntoDpn(i.getInterVpnLinkState(), numberOfDpns))
.forEach(i -> {
installLPortDispatcherTable(i.getInterVpnLinkState(), firstDpnList, secondDpnList);
- result.add(updateInterVpnLinkState(i.getInterVpnLinkState(), firstDpnList, secondDpnList,
- numberOfDpns));
+ result.add(updateInterVpnLinkState(i.getInterVpnLinkState(), firstDpnList, secondDpnList));
});
return result;
private ListenableFuture<Void>
updateInterVpnLinkState(InterVpnLinkState interVpnLinkState, List<BigInteger> firstDpnList,
- List<BigInteger> secondDpnList, int numberOfDpns) {
+ List<BigInteger> secondDpnList) {
FirstEndpointState firstEndPointState =
new FirstEndpointStateBuilder(interVpnLinkState.getFirstEndpointState()).setDpId(firstDpnList).build();
* @param prefix Prefix of the route
* @param label Label of the route in the original VPN
*/
- public static void leakRoute(DataBroker broker, IBgpManager bgpManager, InterVpnLink interVpnLink,
- String srcVpnUuid, String dstVpnUuid, String prefix, Long label) {
- leakRoute(broker, bgpManager, interVpnLink, srcVpnUuid, dstVpnUuid, prefix, label, RouteOrigin.INTERVPN);
- }
-
- /**
- * Leaks a route from one VPN to another.
- *
- * @param broker dataBroker service reference
- * @param bgpManager Used to advertise routes to the BGP Router
- * @param interVpnLink Reference to the object that holds the info about the link between the 2 VPNs
- * @param srcVpnUuid UUID of the VPN that has the route that is going to be leaked to the other VPN
- * @param dstVpnUuid UUID of the VPN that is going to receive the route
- * @param prefix Prefix of the route
- * @param label Label of the route in the original VPN
- * @param forcedOrigin By default, origin for leaked routes should be INTERVPN, however it is possible to provide
- * a different origin if desired.
- */
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public static void leakRoute(DataBroker broker, IBgpManager bgpManager, InterVpnLink interVpnLink,
- String srcVpnUuid, String dstVpnUuid, String prefix, Long label,
- RouteOrigin forcedOrigin) {
+ String srcVpnUuid, String dstVpnUuid, String prefix, Long label) {
Preconditions.checkNotNull(interVpnLink);
// The source VPN must participate in the InterVpnLink
}
LOG.debug("Writing FibEntry to DS: vpnRd={}, prefix={}, label={}, nexthop={} (interVpnLink)",
vpnRd, destination, label, nexthop);
- fibManager.addOrUpdateFibEntry(dataBroker, vpnRd, null /*macAddress*/, destination,
+ fibManager.addOrUpdateFibEntry(vpnRd, null /*macAddress*/, destination,
Collections.singletonList(nexthop), VrfEntry.EncapType.Mplsgre, label,
0 /*l3vni*/, null /*gatewayMacAddress*/, null /*parentVpnRd*/, RouteOrigin.STATIC, null /*writeTxn*/);
}
@Override
- public void populateFib(L3vpnInput input, WriteTransaction writeConfigTxn, WriteTransaction writeOperTxn) {
+ public void populateFib(L3vpnInput input, WriteTransaction writeConfigTxn) {
if (input.getRouteOrigin() == RouteOrigin.CONNECTED) {
LOG.info("populateFib : Found SubnetRoute for subnet {} rd {}", input.getSubnetIp(), input.getPrimaryRd());
addSubnetRouteFibEntry(input);
for (VpnInstanceOpDataEntry vpn : vpnsToImportRoute) {
String vpnRd = vpn.getVrfId();
if (vpnRd != null) {
- fibManager.addOrUpdateFibEntry(broker, vpnRd, null /*macAddress*/,
+ fibManager.addOrUpdateFibEntry(vpnRd, null /*macAddress*/,
nextHopIpAddress, Arrays.asList(nextHopIp), encapType, (int) label,
0 /*l3vni*/, input.getGatewayMac(), null /*parentVpnRd*/, RouteOrigin.SELF_IMPORTED,
writeConfigTxn);
}
} else {
// ### add FIB route directly
- fibManager.addOrUpdateFibEntry(broker, vpnName, null /*macAddress*/,
+ fibManager.addOrUpdateFibEntry(vpnName, null /*macAddress*/,
nextHopIpAddress, Arrays.asList(nextHopIp), encapType, (int) label,
0 /*l3vni*/, input.getGatewayMac(), null /*parentVpnRd*/, input.getRouteOrigin(), writeConfigTxn);
LOG.info("populateFib: Added internal FIB entry for prefix {} nexthop {} label {}"
}
@Override
- public void populateFib(L3vpnInput input, WriteTransaction writeConfigTxn,
- WriteTransaction writeOperTxn) {
+ public void populateFib(L3vpnInput input, WriteTransaction writeConfigTxn) {
if (input.getRouteOrigin() == RouteOrigin.CONNECTED) {
LOG.info("populateFib : Found SubnetRoute for subnet {} rd {}", input.getSubnetIp(), input.getPrimaryRd());
addSubnetRouteFibEntry(input);
}
@Override
- public void populateFib(L3vpnInput input, WriteTransaction writeCfgTxn,
- WriteTransaction writeOperTxn) {}
+ public void populateFib(L3vpnInput input, WriteTransaction writeCfgTxn) {}
public void addSubnetRouteFibEntry(L3vpnInput input) {
String rd = input.getRd();
List<String> nextHopList = Collections.singletonList(nextHopIp);
LOG.info("ADD: addPrefixToBGP: Adding Fib entry rd {} prefix {} nextHop {} label {} gwMac {}", rd, prefix,
nextHopList, label, gatewayMac);
- fibManager.addOrUpdateFibEntry(broker, primaryRd, macAddress, prefix, nextHopList,
+ fibManager.addOrUpdateFibEntry(primaryRd, macAddress, prefix, nextHopList,
encapType, (int)label, l3vni, gatewayMac, null /*parentVpnRd*/, origin, writeConfigTxn);
LOG.info("ADD: addPrefixToBGP: Added Fib entry rd {} prefix {} nextHop {} label {} gwMac {}", rd, prefix,
nextHopList, label, gatewayMac);
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
public interface VpnPopulator {
- void populateFib(L3vpnInput input, WriteTransaction writeCfgTxn, WriteTransaction writeOperTxn);
+ void populateFib(L3vpnInput input, WriteTransaction writeCfgTxn);
Adjacency createOperationalAdjacency(L3vpnInput input);
}
Code Review / netvirt.git / commitdiff