public static synchronized void removeAclInterfaceFromCache(String interfaceId) {
AclInterface aclInterface = cachedMap.get(interfaceId);
if (aclInterface == null) {
- LOG.warn("AclInterface object not found in cache for interface {}", interfaceId);
+ LOG.debug("AclInterface object not found in cache for interface {}", interfaceId);
return;
}
if (aclInterface.isMarkedForDelete()) {
.getEgressActionsForInterface(getEgressActionInput);
RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = result.get();
if (!rpcResult.isSuccessful()) {
- LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}", ifName,
+ LOG.debug("RPC Call to Get egress actions for interface {} returned with Errors {}", ifName,
rpcResult.getErrors());
} else {
List<Action> actions = rpcResult.getResult().getAction();
String ipPrefix = prefixInfo.getIpAddress();
String ifName = prefixInfo.getVpnInterfaceName();
if (ifName == null) {
- LOG.warn("Failed to get VPN interface for prefix {}", ipPrefix);
+ LOG.debug("Failed to get VPN interface for prefix {}", ipPrefix);
return;
}
String macAddress = FibUtil.getMacAddressFromPrefix(dataBroker, ifName, ipPrefix);
public void updateHostIntf(Uuid portId, Boolean portIncludesV6Address) {
VirtualPort intf = vintfs.get(portId);
if (intf == null) {
- LOG.warn("Update Host interface failed. Could not get Host interface details {}", portId);
+ LOG.debug("Update Host interface failed. Could not get Host interface details {}", portId);
return;
}
}
if (NatUtil.isIPv6Subnet(subnetMap.getSubnetIp())) {
- LOG.error("installExtNetGroupEntries : Subnet id {} is not an IPv4 subnet, hence skipping.",
+ LOG.debug("installExtNetGroupEntries : Subnet id {} is not an IPv4 subnet, hence skipping.",
subnetMap.getId());
return;
}
}
if (NatUtil.isIPv6Subnet(subnetMap.getSubnetIp())) {
- LOG.warn("installExtNetGroupEntries : Subnet-id {} is not an IPv4 subnet, hence skipping.",
+ LOG.debug("installExtNetGroupEntries : Subnet-id {} is not an IPv4 subnet, hence skipping.",
subnetMap.getId());
return;
}
Collection<String> extInterfaces = elanService.getExternalElanInterfaces(networkId.getValue());
if (extInterfaces == null || extInterfaces.isEmpty()) {
- LOG.error("removeExtNetGroupEntries : No external ELAN interfaces attached to network {} subnet {}",
+ LOG.debug("removeExtNetGroupEntries : No external ELAN interfaces attached to network {} subnet {}",
networkId, subnetName);
return;
}
long groupId, String extInterface) {
BigInteger dpId = NatUtil.getDpnForInterface(interfaceManager, extInterface);
if (BigInteger.ZERO.equals(dpId)) {
- LOG.error("buildExtNetGroupEntity: No DPN for interface {}. NAT ext-net flow will not be installed "
- + "for subnet {}", extInterface, subnetName);
+ LOG.info("buildExtNetGroupEntity: No DPN for interface {}. NAT ext-net flow will not be installed "
+ + "for subnet {}", extInterface, subnetName);
return null;
}
}
}
}
- LOG.error("getVpnForRouter : VPN not found for routerID:{}", routerId);
+ LOG.debug("getVpnForRouter : VPN not found for routerID:{}", routerId);
return null;
}
WriteTransaction writeOperTxn) {
BigInteger dpId = getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
if (dpId.equals(BigInteger.ZERO)) {
- LOG.warn("removeFromNeutronRouterDpnsMap : Could not retrieve dp id for interface {} to handle router {}"
+ LOG.debug("removeFromNeutronRouterDpnsMap : Could not retrieve dp id for interface {} to handle router {}"
+ " dissociation model", vpnInterfaceName, routerName);
return;
}
OdlInterfaceRpcService ifaceMgrRpcService, WriteTransaction writeOperTxn) {
BigInteger dpId = getDpnForInterface(ifaceMgrRpcService, vpnInterfaceName);
if (dpId.equals(BigInteger.ZERO)) {
- LOG.warn("removeFromDpnRoutersMap : removeFromDpnRoutersMap() : Could not retrieve DPN ID for interface {} "
- + "to handle router {} dissociation model", vpnInterfaceName, routerName);
+ LOG.debug("removeFromDpnRoutersMap : removeFromDpnRoutersMap() : "
+ + "Could not retrieve DPN ID for interface {} to handle router {} dissociation model",
+ vpnInterfaceName, routerName);
return;
}
removeFromDpnRoutersMap(broker, routerName, vpnInterfaceName, dpId, ifaceMgrRpcService, writeOperTxn);
continue;
}
if (!vmInterfaceName.equalsIgnoreCase(vpnInterfaceName)) {
- LOG.error("removeFromDpnRoutersMap : Router {} is present in the DPN {} through the other interface {} "
+ LOG.info("removeFromDpnRoutersMap : Router {} is present in the DPN {} through the other interface {} "
+ "Hence DPN router model WOULD NOT be cleared", routerName, curDpnId, vmInterfaceName);
return;
}
if (dpIdResult.isSuccessful()) {
nodeId = dpIdResult.getResult().getDpid();
} else {
- LOG.error("removeFromDpnRoutersMap : Could not retrieve DPN Id for interface {}", ifName);
+ LOG.debug("removeFromDpnRoutersMap : Could not retrieve DPN Id for interface {}", ifName);
}
} catch (NullPointerException | InterruptedException | ExecutionException e) {
LOG.error("removeFromDpnRoutersMap : Exception when getting dpn for interface {}", ifName, e);
if (optionalRouters.isPresent()) {
builder = new RoutersBuilder(optionalRouters.get());
} else {
- LOG.error("No Routers element found for router {}", routerId.getValue());
+ LOG.debug("No Routers element found for router {}", routerId.getValue());
return;
}
List<Uuid> subList = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
}
}
}
- LOG.error("getVpnForNetwork: Failed for network {} as no VPN present in VPNMaps DS", network.getValue());
+ LOG.debug("getVpnForNetwork: Failed for network {} as no VPN present in VPNMaps DS", network.getValue());
return null;
}
}
}
}
- LOG.error("getVpnForRouter: Failed for router {} as no VPN present in VPNMaps DS", routerId.getValue());
+ LOG.debug("getVpnForRouter: Failed for router {} as no VPN present in VPNMaps DS", routerId.getValue());
return null;
}
subOpIdentifier.child(SubnetToDpn.class, new SubnetToDpnKey(dpnId));
Optional<SubnetToDpn> optionalSubDpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId);
if (!optionalSubDpn.isPresent()) {
- LOG.error("removeInterfaceFromDpn: Cannot delete, SubnetToDpn for intf {} subnet {} DPN {}"
+ LOG.debug("removeInterfaceFromDpn: Cannot delete, SubnetToDpn for intf {} subnet {} DPN {}"
+ " not available in datastore", intfName, subnetId.getValue(), dpnId);
return false;
}
if (intrf.getOperStatus().equals(Interface.OperStatus.Up)) {
subnetId = getSubnetId(intrf);
if (subnetId == null) {
- LOG.error("SubnetRouteInterfaceListener add: Port {} doesnt exist in configDS",
+ LOG.trace("SubnetRouteInterfaceListener add: Port {} doesnt exist in configDS",
intrf.getName());
return;
}
LOG.trace("SubnetRouteInterfaceListener remove: Received interface {} down event", intrf);
subnetId = getSubnetId(intrf);
if (subnetId == null) {
- LOG.error("SubnetRouteInterfaceListener add: Port {} doesnt exist in configDS",
+ LOG.trace("SubnetRouteInterfaceListener add: Port {} doesnt exist in configDS",
intrf.getName());
return;
}
original, update);
subnetId = getSubnetId(update);
if (subnetId == null) {
- LOG.error("SubnetRouteInterfaceListener update: Port {} doesnt exist in configDS",
+ LOG.trace("SubnetRouteInterfaceListener update: Port {} doesnt exist in configDS",
update.getName());
return;
}
}
List<IpAddresses> ipAddresses = dpnInVpn.getIpAddresses();
if (ipAddresses == null) {
- LOG.error("Could not find ipAddresses for DpnInVpn map for VPN=[name={} rd={} id={}] and dpnId={}",
+ LOG.info("Could not find ipAddresses for DpnInVpn map for VPN=[name={} rd={} id={}] and dpnId={}",
vpnName, rd, id, dpnId);
return;
}
Optional<SubnetOpDataEntry> optionalSubs = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
subOpIdentifier);
if (!optionalSubs.isPresent()) {
- LOG.error("{} onInterfaceUp: SubnetOpDataEntry for subnet {} is not available."
+ LOG.trace("{} onInterfaceUp: SubnetOpDataEntry for subnet {} is not available."
+ " Ignoring interfaceUp for port{}", LOGGING_PREFIX, subnetId.getValue(), intfName);
return;
}