/*
* Copyright 2015-present Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ui.topo;
import org.onosproject.net.Link;
import org.onosproject.net.LinkKey;
import java.text.DecimalFormat;
import static com.google.common.base.Preconditions.checkArgument;
import static org.onosproject.net.LinkKey.linkKey;
/**
* Utility methods for helping out with formatting data for the Topology View
* in the web client.
*/
public final class TopoUtils {
// explicit decision made to not 'javadoc' these constants
public static final double N_KILO = 1024;
public static final double N_MEGA = 1024 * N_KILO;
public static final double N_GIGA = 1024 * N_MEGA;
public static final String BITS_UNIT = "b";
public static final String BYTES_UNIT = "B";
public static final String PACKETS_UNIT = "p";
private static final DecimalFormat DF2 = new DecimalFormat("#,###.##");
private static final String COMPACT = "%s/%s-%s/%s";
private static final String EMPTY = "";
private static final String SPACE = " ";
private static final String FLOW = "flow";
private static final String FLOWS = "flows";
// non-instantiable
private TopoUtils() { }
/**
* Returns a compact identity for the given link, in the form
* used to identify links in the Topology View on the client.
*
* @param link link
* @return compact link identity
*/
public static String compactLinkString(Link link) {
return String.format(COMPACT, link.src().elementId(), link.src().port(),
link.dst().elementId(), link.dst().port());
}
/**
* Produces a canonical link key, that is, one that will match both a link
* and its inverse.
*
* @param link the link
* @return canonical key
*/
public static LinkKey canonicalLinkKey(Link link) {
String sn = link.src().elementId().toString();
String dn = link.dst().elementId().toString();
return sn.compareTo(dn) < 0 ?
linkKey(link.src(), link.dst()) : linkKey(link.dst(), link.src());
}
/**
* Returns a value representing a count of bytes.
*
* @param bytes number of bytes
* @return value representing bytes
*/
public static ValueLabel formatBytes(long bytes) {
return new ValueLabel(bytes, BYTES_UNIT);
}
/**
* Returns a value representing a count of packets per second.
*
* @param packets number of packets (per second)
* @return value representing packets per second
*/
public static ValueLabel formatPacketRate(long packets) {
return new ValueLabel(packets, PACKETS_UNIT).perSec();
}
/**
* Returns a value representing a count of bits per second,
* (clipped to a maximum of 10 Gbps).
* Note that the input is bytes per second.
*
* @param bytes bytes per second
* @return value representing bits per second
*/
public static ValueLabel formatClippedBitRate(long bytes) {
return new ValueLabel(bytes * 8, BITS_UNIT).perSec().clipG(10.0);
}
/**
* Returns human readable flow count, to be displayed as a label.
*
* @param flows number of flows
* @return formatted flow count
*/
public static String formatFlows(long flows) {
if (flows < 1) {
return EMPTY;
}
return String.valueOf(flows) + SPACE + (flows > 1 ? FLOWS : FLOW);
}
/**
* Enumeration of magnitudes.
*/
public enum Magnitude {
ONE("", 1),
KILO("K", N_KILO),
MEGA("M", N_MEGA),
GIGA("G", N_GIGA);
private final String label;
private final double mult;
Magnitude(String label, double mult) {
this.label = label;
this.mult = mult;
}
@Override
public String toString() {
return label;
}
private double mult() {
return mult;
}
}
/**
* Encapsulates a value to be used as a label.
*/
public static class ValueLabel {
private final long value;
private final String unit;
private double divDown;
private Magnitude mag;
private boolean perSec = false;
private boolean clipped = false;
/**
* Creates a value label with the given base value and unit. For
* example:
* <pre>
* ValueLabel bits = new ValueLabel(2_050, "b");
* ValueLabel bytesPs = new ValueLabel(3_000_000, "B").perSec();
* </pre>
* Generating labels:
* <pre>
* bits.toString() ... "2.00 Kb"
* bytesPs.toString() ... "2.86 MBps"
* </pre>
*
* @param value the base value
* @param unit the value unit
*/
public ValueLabel(long value, String unit) {
this.value = value;
this.unit = unit;
computeAdjusted();
}
private void computeAdjusted() {
if (value >= N_GIGA) {
divDown = value / N_GIGA;
mag = Magnitude.GIGA;
} else if (value >= N_MEGA) {
divDown = value / N_MEGA;
mag = Magnitude.MEGA;
} else if (value >= N_KILO) {
divDown = value / N_KILO;
mag = Magnitude.KILO;
} else {
divDown = value;
mag = Magnitude.ONE;
}
}
/**
* Mark this value to be expressed as a rate. That is, "ps" (per sec)
* will be appended in the string representation.
*
* @return self, for chaining
*/
public ValueLabel perSec() {
perSec = true;
return this;
}
/**
* Clips the (adjusted) value to the given threshold expressed in
* Giga units. That is, if the adjusted value exceeds the threshold,
* it will be set to the threshold value and the clipped flag
* will be set. For example,
* <pre>
* ValueLabel tooMuch = new ValueLabel(12_000_000_000, "b")
* .perSec().clipG(10.0);
*
* tooMuch.toString() ... "10.00 Gbps"
* tooMuch.clipped() ... true
* </pre>
*
* @param threshold the clip threshold (Giga)
* @return self, for chaining
*/
public ValueLabel clipG(double threshold) {
return clip(threshold, Magnitude.GIGA);
}
private ValueLabel clip(double threshold, Magnitude m) {
checkArgument(threshold >= 1.0, "threshold must be 1.0 or more");
double clipAt = threshold * m.mult();
if (value > clipAt) {
divDown = threshold;
mag = m;
clipped = true;
}
return this;
}
/**
* Returns true if this value was clipped to a maximum threshold.
*
* @return true if value was clipped
*/
public boolean clipped() {
return clipped;
}
/**
* Returns the magnitude value.
*
* @return the magnitude
*/
public Magnitude magnitude() {
return mag;
}
@Override
public String toString() {
return DF2.format(divDown) + SPACE + mag + unit + (perSec ? "ps" : "");
}
}
}