private String getUniqueProfileKey(Long failureThreshold, Long monitorInterval, Long monitorWindow,
EtherTypes ethType) {
- return new StringBuilder().append(failureThreshold).append(AlivenessMonitorConstants.SEPERATOR)
- .append(monitorInterval).append(AlivenessMonitorConstants.SEPERATOR)
- .append(monitorWindow).append(AlivenessMonitorConstants.SEPERATOR)
- .append(ethType).append(AlivenessMonitorConstants.SEPERATOR).toString();
+ return String.valueOf(failureThreshold) + AlivenessMonitorConstants.SEPERATOR +
+ monitorInterval + AlivenessMonitorConstants.SEPERATOR +
+ monitorWindow + AlivenessMonitorConstants.SEPERATOR +
+ ethType + AlivenessMonitorConstants.SEPERATOR;
}
@Override
}
private String getMonitoringKey(String interfaceName, String sourceIp, String targetIp) {
- return new StringBuilder().append(interfaceName).append(SEPERATOR).append(sourceIp)
- .append(SEPERATOR).append(targetIp).append(SEPERATOR).append(EtherTypes.Arp).toString();
+ return interfaceName + SEPERATOR + sourceIp +
+ SEPERATOR + targetIp + SEPERATOR + EtherTypes.Arp;
}
private String getIpAddress(EndpointType source) {
}
if(!Strings.isNullOrEmpty(interfaceName)) {
- String monitorKey = new StringBuilder().append(interfaceName).append(EtherTypes.LLDP).toString();
+ String monitorKey = interfaceName + EtherTypes.LLDP;
return monitorKey;
} else {
LOG.debug("No associated interface found to handle received LLDP Packet");
@Override
public String getUniqueMonitoringKey(MonitoringInfo monitorInfo) {
String interfaceName = getInterfaceName(monitorInfo.getSource().getEndpointType());
- return new StringBuilder().append(interfaceName).append(EtherTypes.LLDP).toString();
+ return interfaceName + EtherTypes.LLDP;
}
private String getInterfaceName(EndpointType endpoint) {
}
private String getBfdMonitorKey(String interfaceName) {
- return new StringBuilder().append(interfaceName).append("bfd").toString();
+ return interfaceName + "bfd";
}
private String getInterfaceName(EndpointType endpoint) {
}
private String getLocalPoolName(String poolName) {
- return new StringBuilder(poolName).append(".").append(BLADE_ID).toString();
+ return poolName + "." + BLADE_ID;
}
private void setupMocks(List<IdPool> idPools) {
}
public static String getTunnelInterfaceFlowRef(BigInteger dpnId, short tableId, String ifName) {
- return new StringBuilder().append(dpnId).append(tableId).append(ifName).toString();
+ return String.valueOf(dpnId) + tableId + ifName;
}
public static void setOpStateForInterface(DataBroker broker, String interfaceName,
private static ParentRefs updateParentInterface(boolean isTunnelInterface, ParentRefs parentRefs) {
if (!isTunnelInterface && parentRefs.getDatapathNodeIdentifier() != null) {
- StringBuilder parentInterface = new StringBuilder(parentRefs.getDatapathNodeIdentifier().toString());
- parentInterface.append(IfmConstants.OF_URI_SEPARATOR);
- parentInterface.append(parentRefs.getParentInterface());
- parentRefs = new ParentRefsBuilder(parentRefs).setParentInterface(parentInterface.toString()).build();
+ String parentInterface = parentRefs.getDatapathNodeIdentifier().toString() + IfmConstants.OF_URI_SEPARATOR +
+ parentRefs.getParentInterface();
+ parentRefs = new ParentRefsBuilder(parentRefs).setParentInterface(parentInterface).build();
}
return parentRefs;
}
}
private String getDpnPrefixedPortName(NodeConnectorId nodeConnectorId, String portName) {
- portName = new StringBuilder(
- (IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId)).toString())
- .append(IfmConstants.OF_URI_SEPARATOR)
- .append(portName).toString();
+ portName = (IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId)).toString() +
+ IfmConstants.OF_URI_SEPARATOR +
+ portName;
return portName;
}
private class InterfaceStateAddWorker implements Callable {
public static String getTerminationPointKeyString(String ipAddress) {
String tpKeyStr = null;
if(ipAddress != null) {
- tpKeyStr = new StringBuilder(TEP_PREFIX).
- append(ipAddress).toString();
+ tpKeyStr = TEP_PREFIX +
+ ipAddress;
}
return tpKeyStr;
}
}
private String getFlowRef(BigInteger dpnId, short tableId, BigInteger tunnelKey) {
- return new StringBuffer().append(IfmConstants.TUNNEL_TABLE_FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
- .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(tunnelKey).toString();
+ return IfmConstants.TUNNEL_TABLE_FLOWID_PREFIX + dpnId + NwConstants.FLOWID_SEPARATOR +
+ tableId + NwConstants.FLOWID_SEPARATOR + tunnelKey;
}
}
}
private static String getFlowRef(BigInteger dpnId, short tableId, String iface, BoundServices service, short currentServiceIndex) {
- return new StringBuffer().append(dpnId).append(tableId).append(NwConstants.FLOWID_SEPARATOR)
- .append(iface).append(NwConstants.FLOWID_SEPARATOR).append(currentServiceIndex).toString();
+ return String.valueOf(dpnId) + tableId + NwConstants.FLOWID_SEPARATOR +
+ iface + NwConstants.FLOWID_SEPARATOR + currentServiceIndex;
}
private static String getSplitHorizonFlowRef(BigInteger dpnId, short tableId, String iface, short currentServiceIndex, BigInteger shFlag) {
}
public static String buildFlowRef(BigInteger dpnId, short tableId, String iface, short currentServiceIndex) {
- return new StringBuffer().append(dpnId).append(tableId).append(NwConstants.FLOWID_SEPARATOR)
- .append(iface).append(NwConstants.FLOWID_SEPARATOR).append(currentServiceIndex).toString();
+ return String.valueOf(dpnId) + tableId + NwConstants.FLOWID_SEPARATOR +
+ iface + NwConstants.FLOWID_SEPARATOR + currentServiceIndex;
}
public static NodeConnector buildNodeConnector(NodeConnectorId ncId) {
}
public static String buildNodeConnectorString(BigInteger dpn, long portNo){
- return new StringBuffer().append(IfmConstants.OF_URI_PREFIX).
- append(dpn).append(IfmConstants.OF_URI_SEPARATOR).
- append(portNo).toString();
+ return IfmConstants.OF_URI_PREFIX +
+ dpn + IfmConstants.OF_URI_SEPARATOR +
+ portNo;
}
public static InstanceIdentifier<BridgeInterfaceEntry> buildBridgeEntryId(BigInteger dpn, String interfaceName){
if (isConfiguredTepGreType && isGreType) {
for (Vteps vtep : vtepList) {
if (vtep.getDpnId().equals(dpnId)) {
- String errMsg = new StringBuilder("DPN [").append(dpnId)
- .append("] already configured with GRE TEP. Mutiple GRE TEP's on a single DPN are not allowed.")
- .toString();
+ String errMsg = "DPN [" + dpnId +
+ "] already configured with GRE TEP. Mutiple GRE TEP's on a single DPN are not allowed.";
Preconditions.checkArgument(false, errMsg);
}
}
// if (tZone != null) {
if (tZoneFromConfigDS != null) {
if( (!tZoneFromConfigDS.getTunnelType().equals(tunType)) && ItmUtils.isNotEmpty(tZoneFromConfigDS.getSubnets())) {
- String errorMsg = new StringBuilder("Changing the tunnel type from ").append(tZoneFromConfigDS.getTunnelType())
- .append(" to ").append(strTunnelType)
- .append(" is not allowed for already configured transport zone [").append(tZoneName)
- .append("].").toString();
+ String errorMsg = "Changing the tunnel type from " + tZoneFromConfigDS.getTunnelType() +
+ " to " + strTunnelType +
+ " is not allowed for already configured transport zone [" + tZoneName +
+ "].";
Preconditions.checkArgument(false, errorMsg);
}
}
* @return the vtep config schema header output
*/
private String getHeaderOutput() {
- StringBuilder headerBuilder = new StringBuilder();
- headerBuilder.append(String.format(VTEP_CONFIG_SCHEMA_CLI_FORMAT, "SchemaName", "PortName", "VlanID", "Subnet",
- "GatewayIP", "TransportZone", "TunnelType", "DPN-IDS", "ExcludeIpFilter"));
- headerBuilder.append('\n');
- headerBuilder.append(HEADER_UNDERLINE);
- return headerBuilder.toString();
+ String headerBuilder =
+ String.format(VTEP_CONFIG_SCHEMA_CLI_FORMAT, "SchemaName", "PortName", "VlanID", "Subnet",
+ "GatewayIP", "TransportZone", "TunnelType", "DPN-IDS", "ExcludeIpFilter") +
+ '\n' +
+ HEADER_UNDERLINE;
+ return headerBuilder;
}
}
}
private static String getFlowRef(long termSvcTable, int svcId) {
- return new StringBuffer().append(termSvcTable).append(svcId).toString();
+ return String.valueOf(termSvcTable) + svcId;
}
public static InstanceIdentifier<VtepConfigSchema> getVtepConfigSchemaIdentifier(String schemaName) {
return InstanceIdentifier.builder(VtepConfigSchemas.class)
if (!StringUtils.equalsIgnoreCase(schema.getSchemaName(), existingSchema.getSchemaName())
&& schema.getSubnet().equals(existingSchema.getSubnet())) {
String subnetCidr = getSubnetCidrAsString(schema.getSubnet());
- Preconditions.checkArgument(false, new StringBuilder("VTEP schema with subnet [").append(subnetCidr)
- .append("] already exists. Multiple VTEP schemas with same subnet is not allowed.").toString());
+ Preconditions.checkArgument(false, "VTEP schema with subnet [" + subnetCidr +
+ "] already exists. Multiple VTEP schemas with same subnet is not allowed.");
}
}
if (isNotEmpty(getDpnIdList(validSchema.getDpnIds()))) {
getDpnIdList(validSchema.getDpnIds()), existingSchemas);
if (!lstDpns.isEmpty()) {
Preconditions.checkArgument(false,
- new StringBuilder("DPN's ").append(lstDpns).append(" already configured for transport zone ")
- .append(tzone).append(". Only one end point per transport Zone per Dpn is allowed.")
- .toString());
+ "DPN's " + lstDpns + " already configured for transport zone " +
+ tzone + ". Only one end point per transport Zone per Dpn is allowed.");
}
if (schema.getTunnelType().equals(TunnelTypeGre.class)){
validateForSingleGreTep(validSchema.getSchemaName(), getDpnIdList(validSchema.getDpnIds()), existingSchemas);
List<BigInteger> lstConflictingDpns = new ArrayList<>(getDpnIdList(existingSchema.getDpnIds()));
lstConflictingDpns.retainAll(emptyIfNull(lstDpnsForAdd));
if (!lstConflictingDpns.isEmpty()) {
- String errMsg = new StringBuilder("DPN's ").append(lstConflictingDpns)
- .append(" already configured with GRE TEP. Mutiple GRE TEP's on a single DPN are not allowed.")
- .toString();
+ String errMsg = "DPN's " + lstConflictingDpns +
+ " already configured with GRE TEP. Mutiple GRE TEP's on a single DPN are not allowed.";
Preconditions.checkArgument(false, errMsg);
}
}
if (gatewayIp != null) {
String strGatewayIp = String.valueOf(gatewayIp.getValue());
if (!strGatewayIp.equals(ITMConstants.DUMMY_IP_ADDRESS) && !subnetUtils.getInfo().isInRange(strGatewayIp)) {
- Preconditions.checkArgument(false, new StringBuilder("Gateway IP address ").append(strGatewayIp)
- .append(" is not in subnet range ").append(subnetCidr).toString());
+ Preconditions.checkArgument(false, "Gateway IP address " + strGatewayIp +
+ " is not in subnet range " + subnetCidr);
}
}
ItmUtils.getExcludeIpAddresses(schema.getExcludeIpFilter(), subnetUtils.getInfo());
tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
} else {
tunnelType = StringUtils.upperCase(tunnelType);
- String error = new StringBuilder("Invalid tunnel type. Valid values: ")
- .append(ITMConstants.TUNNEL_TYPE_VXLAN).append(" | ").append(ITMConstants.TUNNEL_TYPE_GRE)
- .toString();
+ String error = "Invalid tunnel type. Valid values: " +
+ ITMConstants.TUNNEL_TYPE_VXLAN + " | " + ITMConstants.TUNNEL_TYPE_GRE;
Preconditions.checkArgument(ITMConstants.TUNNEL_TYPE_VXLAN.equals(tunnelType)
|| ITMConstants.TUNNEL_TYPE_GRE.equals(tunnelType), error);
}
String strStartIp = StringUtils.trim(arrIpRange[0]);
String strEndIp = StringUtils.trim(arrIpRange[1]);
Preconditions.checkArgument(InetAddresses.isInetAddress(strStartIp),
- new StringBuilder("Invalid exclude IP filter: invalid IP address value ").append(strStartIp)
- .toString());
+ "Invalid exclude IP filter: invalid IP address value " + strStartIp);
Preconditions.checkArgument(InetAddresses.isInetAddress(strEndIp),
- new StringBuilder("Invalid exclude IP filter: invalid IP address value ").append(strEndIp)
- .toString());
+ "Invalid exclude IP filter: invalid IP address value " + strEndIp);
Preconditions.checkArgument(subnetInfo.isInRange(strStartIp),
- new StringBuilder("Invalid exclude IP filter: IP address [").append(strStartIp)
- .append("] not in subnet range ").append(subnetInfo.getCidrSignature()).toString());
+ "Invalid exclude IP filter: IP address [" + strStartIp +
+ "] not in subnet range " + subnetInfo.getCidrSignature());
Preconditions.checkArgument(subnetInfo.isInRange(strEndIp),
- new StringBuilder("Invalid exclude IP filter: IP address [").append(strEndIp)
- .append("] not in subnet range ").append(subnetInfo.getCidrSignature()).toString());
+ "Invalid exclude IP filter: IP address [" + strEndIp +
+ "] not in subnet range " + subnetInfo.getCidrSignature());
int startIp = subnetInfo.asInteger(strStartIp);
int endIp = subnetInfo.asInteger(strEndIp);
Preconditions.checkArgument(startIp < endIp,
- new StringBuilder("Invalid exclude IP filter: Invalid range [").append(ip).append("] ")
- .toString());
+ "Invalid exclude IP filter: Invalid range [" + ip + "] ");
for (int i = startIp; i <= endIp; i++) {
String ipAddress = ipFormat(toIpArray(i));
validateAndAddIpAddressToList(subnetInfo, lstIpAddress, ipAddress);
String ipAddress) {
String ip = StringUtils.trim(ipAddress);
Preconditions.checkArgument(InetAddresses.isInetAddress(ip),
- new StringBuilder("Invalid exclude IP filter: invalid IP address value ").append(ip).toString());
+ "Invalid exclude IP filter: invalid IP address value " + ip);
Preconditions.checkArgument(subnetInfo.isInRange(ip),
- new StringBuilder("Invalid exclude IP filter: IP address [").append(ip).append("] not in subnet range ")
- .append(subnetInfo.getCidrSignature()).toString());
+ "Invalid exclude IP filter: IP address [" + ip + "] not in subnet range " +
+ subnetInfo.getCidrSignature());
lstIpAddress.add(new IpAddress(ip.toCharArray()));
}
private static int[] toIpArray(int val) {
if ((lstDpnsForAdd == null || lstDpnsForAdd.isEmpty())
&& (lstDpnsForDelete == null || lstDpnsForDelete.isEmpty())) {
Preconditions.checkArgument(false,
- new StringBuilder("DPN ID list for add | delete is null or empty in schema ").append(schemaName)
- .toString());
+ "DPN ID list for add | delete is null or empty in schema " + schemaName);
}
VtepConfigSchema schema = itmProvider.getVtepConfigSchema(schemaName);
if (schema == null) {
- Preconditions.checkArgument(false, new StringBuilder("Specified VTEP Schema [").append(schemaName)
- .append("] doesn't exists!").toString());
+ Preconditions.checkArgument(false, "Specified VTEP Schema [" + schemaName +
+ "] doesn't exists!");
}
List<BigInteger> existingDpnIds = getDpnIdList(schema.getDpnIds());
if (isNotEmpty(lstDpnsForAdd)) {
List<BigInteger> lstAlreadyExistingDpns = new ArrayList<>(existingDpnIds);
lstAlreadyExistingDpns.retainAll(lstDpnsForAdd);
Preconditions.checkArgument(lstAlreadyExistingDpns.isEmpty(),
- new StringBuilder("DPN ID's ").append(lstAlreadyExistingDpns)
- .append(" already exists in VTEP schema [").append(schemaName).append("]").toString());
+ "DPN ID's " + lstAlreadyExistingDpns +
+ " already exists in VTEP schema [" + schemaName + "]");
// }
if (schema.getTunnelType().equals(TunnelTypeGre.class)) {
validateForSingleGreTep(schema.getSchemaName(), lstDpnsForAdd, itmProvider.getAllVtepConfigSchemas());
}
if (isNotEmpty(lstDpnsForDelete)) {
if (existingDpnIds == null || existingDpnIds.isEmpty()) {
- StringBuilder builder = new StringBuilder("DPN ID's ").append(lstDpnsForDelete)
- .append(" specified for delete from VTEP schema [").append(schemaName)
- .append("] are not configured in the schema.");
- Preconditions.checkArgument(false, builder.toString());
+ String builder = "DPN ID's " + lstDpnsForDelete +
+ " specified for delete from VTEP schema [" + schemaName +
+ "] are not configured in the schema.";
+ Preconditions.checkArgument(false, builder);
} else if (!existingDpnIds.containsAll(lstDpnsForDelete)) {
List<BigInteger> lstConflictingDpns = new ArrayList<>(lstDpnsForDelete);
lstConflictingDpns.removeAll(existingDpnIds);
- StringBuilder builder = new StringBuilder("DPN ID's ").append(lstConflictingDpns)
- .append(" specified for delete from VTEP schema [").append(schemaName)
- .append("] are not configured in the schema.");
- Preconditions.checkArgument(false, builder.toString());
+ String builder = "DPN ID's " + lstConflictingDpns +
+ " specified for delete from VTEP schema [" + schemaName +
+ "] are not configured in the schema.";
+ Preconditions.checkArgument(false, builder);
}
}
return schema;
String subnetCidr = ItmUtils.getSubnetCidrAsString(schema.getSubnet());
deleteVtepIpPool(subnetCidr);
} catch (Exception e) {
- String error = new StringBuilder("Failed to handle DCN for delete VtepConfigSchema: ").append(schema)
- .toString();
+ String error = "Failed to handle DCN for delete VtepConfigSchema: " + schema;
LOG.error(error, e);
}
}
handleUpdateOfDpnIds(orignalSchema, updatedSchema);
} catch (Exception e) {
- String error = new StringBuilder("Failed to handle DCN for update VtepConfigSchema original:")
- .append(original).append(", updated: ").append(updated).toString();
+ String error = "Failed to handle DCN for update VtepConfigSchema original:" +
+ original + ", updated: " + updated;
LOG.error(error, e);
}
}
clearInternalDataPathAlarm(srcDpId.toString(),dstDpId.toString(),tunnelType);
}else {
logger.trace("ITM Tunnel State is DOWN b/w srcDpn: {} and dstDpn: {}", srcDpId, dstDpId);
- StringBuilder alarmText = new StringBuilder();
- alarmText.append("Data Path Connectivity is lost b/w ").append("openflow:").append(srcDpId).append(" and openflow:")
- .append(dstDpId).append(" for tunnelType:").append(tunnelType);
- raiseInternalDataPathAlarm(srcDpId.toString(), dstDpId.toString(), tunnelType,alarmText.toString());
+ String alarmText =
+ "Data Path Connectivity is lost b/w " + "openflow:" + srcDpId + " and openflow:" +
+ dstDpId + " for tunnelType:" + tunnelType;
+ raiseInternalDataPathAlarm(srcDpId.toString(), dstDpId.toString(), tunnelType, alarmText);
}
}else{
ExternalTunnel externalTunnel = ItmUtils.getExternalTunnel(ifName,broker);
String srcNode = externalTunnel.getSourceDevice();
String dstNode = externalTunnel.getDestinationDevice();
if(!srcNode.contains("hwvtep")){
- srcNode = new StringBuilder().append("openflow:").append(externalTunnel.getSourceDevice()).toString() ;
+ srcNode = "openflow:" + externalTunnel.getSourceDevice();
}
if(!dstNode.contains("hwvtep")){
- dstNode = new StringBuilder().append("openflow:").append(externalTunnel.getDestinationDevice()).toString() ;
+ dstNode = "openflow:" + externalTunnel.getDestinationDevice();
}
String tunnelType = ItmUtils.convertTunnelTypetoString(externalTunnel.getTransportType());
logger.trace("ITM Tunnel state event changed from :{} to :{} for Tunnel Interface - {}", isTunnelInterfaceUp(original), isTunnelInterfaceUp(update), ifName);
clearExternalDataPathAlarm(srcNode, dstNode,tunnelType);
}else {
logger.trace("ITM Tunnel State is DOWN b/w srcNode: {} and dstNode: {}", srcNode, dstNode);
- StringBuilder alarmText = new StringBuilder();
- alarmText.append("DataPath lost b/w").append(srcNode).append(" and ").append(dstNode);
//alarmText.append("Data Path Connectivity is lost between ").append(srcNode).append(" and ").append(
// dstNode).append(" for tunnelType:").append(tunnelType);
- raiseExternalDataPathAlarm(srcNode, dstNode, tunnelType,alarmText.toString());
+ raiseExternalDataPathAlarm(srcNode, dstNode, tunnelType,
+ "DataPath lost b/w" + srcNode + " and " + dstNode);
}
}
}
String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
if(!isTunnelInterfaceUp(add)) {
logger.trace("ITM Tunnel State during tep add is DOWN b/w srcDpn: {} and dstDpn: {} for tunnelType: {}", srcDpId, dstDpId, tunnelType);
- StringBuilder alarmText = new StringBuilder();
- alarmText.append("DataPath is down between ").append("openflow:").append(srcDpId).append(" and openflow:")
- .append(dstDpId).append(" for ").append(tunnelType).append("tunnel initially");
- raiseInternalDataPathAlarm(srcDpId.toString(), dstDpId.toString(), tunnelType, alarmText.toString());
+
+ String alarmText = "DataPath is down between " + "openflow:" + srcDpId + " and openflow:" +
+ dstDpId + " for " + tunnelType + "tunnel initially";
+ raiseInternalDataPathAlarm(srcDpId.toString(), dstDpId.toString(), tunnelType, alarmText);
}
}else {
ExternalTunnel externalTunnel = ItmUtils.getExternalTunnel(ifName,broker);
String srcNode = externalTunnel.getSourceDevice();
String dstNode = externalTunnel.getDestinationDevice();
if(!srcNode.contains("hwvtep")){
- srcNode = new StringBuilder().append("openflow:").append(externalTunnel.getSourceDevice()).toString() ;
+ srcNode = "openflow:" + externalTunnel.getSourceDevice();
}
if(!dstNode.contains("hwvtep")){
- dstNode = new StringBuilder().append("openflow:").append(externalTunnel.getDestinationDevice()).toString() ;
+ dstNode = "openflow:" + externalTunnel.getDestinationDevice();
}
String tunnelType = ItmUtils.convertTunnelTypetoString(externalTunnel.getTransportType());
if(!isTunnelInterfaceUp(add)) {
logger.trace("ITM Tunnel State during tep add is DOWN b/w srcNode: {} and dstNode: {} for tunnelType: {}", srcNode, dstNode, tunnelType);
- StringBuilder alarmText = new StringBuilder();
+
//alarmText.append("DataPath is down between ").append(srcNode).append(" and ").append(dstNode).append(" for ").append(tunnelType).append("tunnel initially");
- alarmText.append("Path down").append(srcNode).append(" and ").append(dstNode).append(" initially");
- raiseExternalDataPathAlarm(srcNode, dstNode, tunnelType,alarmText.toString());
+ raiseExternalDataPathAlarm(srcNode, dstNode, tunnelType,
+ "Path down" + srcNode + " and " + dstNode + " initially");
}
}
}
public void clearExternalDataPathAlarm(String srcDevice,String dstDevice,String tunnelType) {
- StringBuilder source = new StringBuilder();
-
- source.append("srcDevice=").append(srcDevice).append("-dstDevice=").append(dstDevice).append("-tunnelType").append(tunnelType);
-
//logger.trace("Clearing DataPathConnectionFailure alarm of source {} ", source);
//Invokes JMX clearAlarm method
- alarmAgent.invokeFMclearmethod("DataPathConnectionFailure", "Clearing ITM Tunnel down alarm", source.toString());
+ alarmAgent.invokeFMclearmethod("DataPathConnectionFailure", "Clearing ITM Tunnel down alarm",
+ "srcDevice=" + srcDevice + "-dstDevice=" + dstDevice + "-tunnelType" + tunnelType);
}
}
private String getFlowRef(long termSvcTable, int svcId) {
- return new StringBuffer().append(termSvcTable).append(svcId).toString();
+ return String.valueOf(termSvcTable) + svcId;
}
@Override
@Override
public void setMatch(MatchBuilder matchBuilderInOut, MatchInfo matchInfo, Map<Class<?>, Object> mapMatchBuilder) {
- StringBuffer nodeConnectorId = new StringBuffer().append("openflow:").append(matchInfo.getBigMatchValues()[0])
- .append(':').append(matchInfo.getBigMatchValues()[1]);
- matchBuilderInOut.setInPort(new NodeConnectorId(nodeConnectorId.toString()));
+
+ String nodeConnectorId = "openflow:" + matchInfo.getBigMatchValues()[0] +
+ ':' + matchInfo.getBigMatchValues()[1];
+ matchBuilderInOut.setInPort(new NodeConnectorId(nodeConnectorId));
}
},
public static String getTerminationPointKeyString(String ipAddress) {
String tpKeyStr = null;
if(ipAddress != null) {
- tpKeyStr = new StringBuilder(HwvtepSouthboundConstants.TEP_PREFIX).
- append(ipAddress).toString();
+ tpKeyStr = HwvtepSouthboundConstants.TEP_PREFIX +
+ ipAddress;
}
return tpKeyStr;
}
}
private String getFlowRef(short termSvcTable, int svcId) {
- return new StringBuffer().append(termSvcTable).append(svcId).toString();
+ return String.valueOf(termSvcTable) + svcId;
}
public GroupEntity createGroupEntity(String Nodeid, String inport, int vlanid) {
Code Review / genius.git / commitdiff