synchronized (BgpConfigurationManager.this) {
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for asNum {}; {}", YANG_OBJ, val.getLocalAs(),
+ LOG.debug("{} Unable to process add for asNum {}; {}", YANG_OBJ, val.getLocalAs(),
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
long asNum = val.getLocalAs();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for asNum {}; {}", YANG_OBJ, asNum,
+ LOG.debug("{} Unable to process remove for asNum {}; {}", YANG_OBJ, asNum,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
final String md5Secret = extractMd5Secret(val);
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for peer {} as {}; {}", YANG_OBJ, peerIp, as,
+ LOG.debug("{} Unable to process add for peer {} as {}; {}", YANG_OBJ, peerIp, as,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
String peerIp = val.getAddress().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
String peerIp = val.getPeerIp().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process add for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
String peerIp = val.getPeerIp().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
String peerIp = val.getPeerIp().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process add for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
String peerIp = val.getPeerIp().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
String peerIp = val.getPeerIp().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process add for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
String peerIp = val.getPeerIp().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
+ LOG.debug("{} Unable to process remove for peer {}; {}", YANG_OBJ, peerIp,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
String nh = val.getNexthop().getValue();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for rd {} prefix {} nexthop {}; {}", YANG_OBJ, rd, pfxlen, nh,
+ LOG.debug("{} Unable to process add for rd {} prefix {} nexthop {}; {}", YANG_OBJ, rd, pfxlen, nh,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
String pfxlen = val.getPrefixLen();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for rd {} prefix {}; {}", YANG_OBJ, rd, pfxlen,
+ LOG.debug("{} Unable to process remove for rd {} prefix {}; {}", YANG_OBJ, rd, pfxlen,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
String rd = vrfs.getRd();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for rd {}; {}", YANG_OBJ, rd,
+ LOG.debug("{} Unable to process add for rd {}; {}", YANG_OBJ, rd,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
String rd = val.getRd();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process remove for rd {}; {}", YANG_OBJ, rd,
+ LOG.debug("{} Unable to process remove for rd {}; {}", YANG_OBJ, rd,
BgpRouterException.BGP_ERR_NOT_INITED, DEL_WARN);
return;
}
String rd = newval.getRd();
BgpRouter br = getClient(YANG_OBJ);
if (br == null) {
- LOG.error("{} Unable to process add for rd {}; {}", YANG_OBJ, rd,
+ LOG.debug("{} Unable to process add for rd {}; {}", YANG_OBJ, rd,
BgpRouterException.BGP_ERR_NOT_INITED, ADD_WARN);
return;
}
@Override
protected synchronized void add(InstanceIdentifier<Bgp> iid, Bgp val) {
- LOG.error("received add Bgp config");
+ LOG.debug("received add Bgp config");
try {
initer.await();
return networkId.getValue();
}
}
- LOG.error("getAssociatedExternalNetwork : External Network missing for routerid : {}", routerId);
+ LOG.info("getAssociatedExternalNetwork : External Network missing for routerid : {}", routerId);
return null;
}
}
LOG.debug("Deletion from FloatingIpInfo DS successful for fixedIp {} ", fixedIpAddress);
} else {
- LOG.error("routerPorts for router {} - fixedIp {} not found", routerName, fixedIpAddress);
+ LOG.warn("routerPorts for router {} - fixedIp {} not found", routerName, fixedIpAddress);
}
} catch (Exception e) {
LOG.error("Failed to delete internal-to-external-port-map from FloatingIpInfo DS for fixed Ip {}",
return;
}
if (portupdateIps == null || portupdateIps.isEmpty()) {
- LOG.error("Ignoring portUpdate (fixed_ip removal) for port {} as this case is handled "
+ LOG.info("Ignoring portUpdate (fixed_ip removal) for port {} as this case is handled "
+ "during subnet deletion event.", portupdate.getUuid().getValue());
return;
}
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id,
subnetmap);
} else {
- LOG.error("Trying to remove port from non-existing subnetmap node {}", subnetId.getValue());
+ LOG.info("Trying to remove port from non-existing subnetmap node {}", subnetId.getValue());
}
}
} catch (ReadFailedException | TransactionCommitFailedException e) {
*/
@Override
public void onFailure(Throwable throwable) {
- log.error("onFailure: Failed to establish/clear footprint for vpn {} rd {} on dpn {} ", vpnName, rd, dpnId,
+ log.info("onFailure: Failed to establish/clear footprint for vpn {} rd {} on dpn {} ", vpnName, rd, dpnId,
throwable);
}
}
if (canHandleNewVpnInterface(identifier, vpnInterface)) {
addVpnInterface(identifier, vpnInterface, null, null);
} else {
- LOG.error("add: VpnInstance {} for vpnInterface {} not ready, holding on ",
+ LOG.warn("add: VpnInstance {} for vpnInterface {} not ready, holding on ",
vpnInterface.getVpnInstanceName(), vpnInterface.getName());
}
}
interfaceName, dpId, vpnName);
long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
if (vpnId == VpnConstants.INVALID_ID) {
- LOG.error("processVpnInterfaceUp: VpnInstance to VPNId mapping not available for VpnName {}"
+ LOG.warn("processVpnInterfaceUp: VpnInstance to VPNId mapping not available for VpnName {}"
+ " processing vpninterface {} on dpn {}, bailing out now.", vpnName, interfaceName,
dpId);
return;
// However, if the primary VRF Entry for this VPNInterface exists, please continue bailing out !
List<Adjacency> adjs = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(dataBroker, interfaceName);
if (adjs == null) {
- LOG.error("processVpnInterfaceUp: VPN Interface {} on dpn {} for vpn {} failed as adjacencies"
+ LOG.warn("processVpnInterfaceUp: VPN Interface {} on dpn {} for vpn {} failed as adjacencies"
+ " for this vpn interface could not be obtained", interfaceName, dpId,
vpnName);
return;
}
}
if (primaryInterfaceIp == null) {
- LOG.error("processVpnInterfaceUp: VPN Interface {} addition on dpn {} for vpn {} failed"
+ LOG.warn("processVpnInterfaceUp: VPN Interface {} addition on dpn {} for vpn {} failed"
+ " as primary adjacency for this vpn interface could not be obtained", interfaceName,
dpId, vpnName);
return;
// Get the rd of the vpn instance
VrfEntry vrf = VpnUtil.getVrfEntry(dataBroker, primaryRd, primaryInterfaceIp);
if (vrf != null) {
- LOG.error("processVpnInterfaceUp: VPN Interface {} on dpn {} for vpn {} already provisioned ,"
+ LOG.warn("processVpnInterfaceUp: VPN Interface {} on dpn {} for vpn {} already provisioned ,"
+ " bailing out from here.", interfaceName, dpId, vpnName);
return;
}
waitForVpnInterfaceOpRemoval = true;
} else {
- LOG.error("processVpnInterfaceUp: vpn interface {} to go to configured vpn {} on dpn {},"
+ LOG.warn("processVpnInterfaceUp: vpn interface {} to go to configured vpn {} on dpn {},"
+ " but in operational vpn {}", interfaceName, vpnName, dpId, opVpnName);
}
}
opVpnInterface = VpnUtil.getOperationalVpnInterface(dataBroker, interfaceName);
if (opVpnInterface != null) {
- LOG.error("processVpnInterfaceUp: VPN Interface {} removal on dpn {} for vpn {}"
+ LOG.warn("processVpnInterfaceUp: VPN Interface {} removal on dpn {} for vpn {}"
+ " by FIB did not complete on time," + " bailing addition ...", interfaceName,
dpId, vpnName);
return;
try {
nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
} catch (Exception e) {
- LOG.error("processVpnInterfaceAdjacencies: Unable to retrieve enpoint ip address for "
+ LOG.error("processVpnInterfaceAdjacencies: Unable to retrieve endpoint ip address for "
+ "dpnId {} for vpnInterface {} vpnName {}", dpnId, interfaceName, vpnName);
}
List<String> nhList = new ArrayList<>();
arpResponderHandler.addArpResponderFlow(dpnId, lportTag, vpnName, vpnId, interfaceName,
subnetId, gatewayIp.get(), gwMac.get());
} else {
- LOG.error("Gateway MAC for subnet ID {} could not be obtained, cannot create "
- + "ARP responder flow for interface name {}, vpnName {}, gwIp {}",
- interfaceName, vpnName, gatewayIp.get());
+ LOG.error("processVpnInterfaceAdjacencies: Gateway MAC for subnet ID {} could not be "
+ + "obtained, cannot create ARP responder flow for interface name {}, vpnName {}, "
+ + "gwIp {}",
+ interfaceName, vpnName, gatewayIp.get());
}
}
} else {
- LOG.warn("Gateway IP for subnet ID {} could not be obtained, cannot create ARP responder flow "
- + "for interface name {}, vpnName {}", subnetId, interfaceName, vpnName);
+ LOG.warn("processVpnInterfaceAdjacencies: Gateway IP for subnet ID {} could not be obtained, "
+ + "cannot create ARP responder flow for interface name {}, vpnName {}",
+ subnetId, interfaceName, vpnName);
}
LOG.info("processVpnInterfaceAdjacencies: Added prefix {} to interface {} with nextHops {} on dpn {}"
+ " for vpn {}", prefix, interfaceName, nhList, dpnId, vpnName);
prefix, vpnName, nextHop.getNextHopIpList().get(0), dpnId, writeOperTxn);
if (rdToAllocate.isPresent()) {
rd = rdToAllocate.get();
- LOG.info("The rd {} is allocated for the extraroute {}", rd, prefix);
+ LOG.info("processVpnInterfaceAdjacencies: The rd {} is allocated for the extraroute {}",
+ rd, prefix);
} else {
- LOG.error("No rds to allocate extraroute {}", prefix);
+ LOG.error("processVpnInterfaceAdjacencies: No rds to allocate extraroute {}", prefix);
continue;
}
}
try {
operationalAdjacency = registeredPopulator.createOperationalAdjacency(input);
} catch (NullPointerException e) {
- LOG.error(e.getMessage());
+ LOG.error("processVpnInterfaceAdjacencies: failed to create operational adjacency: input: {}, {}",
+ input, e.getMessage());
return;
}
if (nextHop.getAdjacencyType() != AdjacencyType.PrimaryAdjacency) {
try {
operFuture.get();
} catch (ExecutionException e) {
- LOG.error("Exception encountered while submitting operational future for update"
- + " VpnInterface {}: {}", vpnInterfaceName, e);
+ LOG.error("update: Exception encountered while submitting operational future for update"
+ + " VpnInterface {}", vpnInterfaceName, e);
return null;
}
List<ListenableFuture<Void>> futures = new ArrayList<>();
if (dpIdResult.isSuccessful()) {
nodeId = dpIdResult.getResult().getDpid();
} else {
- LOG.error("getDpnForInterface: Could not retrieve DPN Id for interface {}", ifName);
+ LOG.info("getDpnForInterface: Could not retrieve DPN Id for interface {}", ifName);
}
} catch (NullPointerException | InterruptedException | ExecutionException e) {
LOG.error("getDpnForInterface: Exception when getting dpn for interface {}", ifName, e);