package org.opendaylight.netvirt.qosservice;
-import java.math.BigInteger;
-import java.util.List;
+import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.PreDestroy;
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.apache.felix.service.command.CommandSession;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
-import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetNodeConnectorStatisticsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.OpendaylightDirectStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.qosalert.config.rev170301.QosalertConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final QosEosHandler qosEosHandler;
private final IInterfaceManager interfaceManager;
private final Set unprocessedInterfaceIds = ConcurrentHashMap.newKeySet();
- private final ConcurrentMap<BigInteger, ConcurrentMap<String, QosAlertPortData>> qosAlertDpnPortNumberMap =
+ private final ConcurrentMap<Uint64, ConcurrentMap<String, QosAlertPortData>> qosAlertDpnPortNumberMap =
new ConcurrentHashMap<>();
private final AlertThresholdSupplier alertThresholdSupplier = new AlertThresholdSupplier();
private void getDefaultConfig() {
alertEnabled = defaultConfig.isQosAlertEnabled();
- pollInterval = defaultConfig.getQosAlertPollInterval();
+ pollInterval = defaultConfig.getQosAlertPollInterval().toJava();
- alertThresholdSupplier.set(defaultConfig.getQosDropPacketThreshold());
+ alertThresholdSupplier.set(defaultConfig.getQosDropPacketThreshold().toJava());
}
public void setQosalertConfig(QosalertConfig config) {
config.getQosAlertPollInterval());
alertEnabled = config.isQosAlertEnabled().booleanValue();
- pollInterval = config.getQosAlertPollInterval();
+ pollInterval = config.getQosAlertPollInterval().toJava();
alertThresholdSupplier.set(config.getQosDropPacketThreshold().shortValue());
}
}
+ public void displayConfig(CommandSession session) {
+
+ session.getConsole().println("Qos Alert Configuration Details");
+ session.getConsole().println("Threshold: " + alertThresholdSupplier.get().shortValue());
+ session.getConsole().println("AlertEnabled: " + alertEnabled);
+ session.getConsole().println("Poll Interval: " + pollInterval);
+
+ Uint64 dpnId;
+ String portData;
+ Gson gson = new GsonBuilder().setPrettyPrinting().create();
+ if (qosAlertDpnPortNumberMap.isEmpty()) {
+ session.getConsole().println("\nQosAlert Cache not found\n");
+ return;
+ } else {
+ session.getConsole().println("\nDPN Map");
+ JsonObject jsonObject;
+ JsonArray jsonArray;
+ JsonArray jsonArrayOuter = new JsonArray();
+ for (Entry<Uint64, ConcurrentMap<String, QosAlertPortData>> dpnEntry
+ : qosAlertDpnPortNumberMap.entrySet()) {
+ dpnId = dpnEntry.getKey();
+ jsonObject = new JsonObject();
+ jsonObject.addProperty("DpnId", dpnId.toString());
+ ConcurrentMap<String, QosAlertPortData> portInnerMap = qosAlertDpnPortNumberMap.get(dpnId);
+ jsonArray = new JsonArray();
+ for (ConcurrentMap.Entry<String, QosAlertPortData> portEntry : portInnerMap.entrySet()) {
+ portData = "Port_number: " + portEntry.getKey() + ", " + portEntry.getValue();
+ jsonArray.add(portData);
+ }
+ jsonObject.add("QosAlertPortData Cache", jsonArray);
+ jsonArrayOuter.add(jsonObject);
+ }
+ session.getConsole().println(gson.toJson(jsonArrayOuter));
+ session.getConsole().println();
+ }
+ }
+
public void processInterfaceUpEvent(String ifaceId) {
LOG.trace("processInterfaceUpEvent {}", ifaceId);
if (unprocessedInterfaceIds.remove(ifaceId)) {
}
private void addToQosAlertCache(InterfaceInfo interfaceInfo) {
- BigInteger dpnId = interfaceInfo.getDpId();
- if (dpnId.equals(IfmConstants.INVALID_DPID)) {
+ Uint64 dpnId = interfaceInfo.getDpId();
+ if (dpnId.equals(Uint64.valueOf(0L))) {
LOG.warn("Interface {} could not be added to Qos Alert Cache because Dpn Id is not found",
interfaceInfo.getInterfaceName());
return;
if (interfaceInfo == null) {
return;
}
- BigInteger dpnId = interfaceInfo.getDpId();
+ Uint64 dpnId = interfaceInfo.getDpId();
String portNumber = String.valueOf(interfaceInfo.getPortNo());
removeFromQosAlertCache(dpnId, portNumber);
}
public void removeLowerLayerIfFromQosAlertCache(String lowerLayerIf) {
LOG.trace("If present, remove lowerLayerIf {} from cache", lowerLayerIf);
- BigInteger dpnId = qosNeutronUtils.getDpnIdFromLowerLayerIf(lowerLayerIf);
+ Uint64 dpnId = qosNeutronUtils.getDpnIdFromLowerLayerIf(lowerLayerIf);
String portNumber = qosNeutronUtils.getPortNumberFromLowerLayerIf(lowerLayerIf);
if (dpnId == null || portNumber == null) {
LOG.warn("Interface {} not in openflow:dpnid:portnum format, could not remove from cache", lowerLayerIf);
removeFromQosAlertCache(dpnId, portNumber);
}
- private void removeFromQosAlertCache(BigInteger dpnId, String portNumber) {
+ private void removeFromQosAlertCache(Uint64 dpnId, String portNumber) {
if (qosAlertDpnPortNumberMap.containsKey(dpnId)
&& qosAlertDpnPortNumberMap.get(dpnId).containsKey(portNumber)) {
qosAlertDpnPortNumberMap.get(dpnId).remove(portNumber);
.setQosAlertPollInterval(alertPollInterval)
.build();
- ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- tx -> tx.put(LogicalDatastoreType.CONFIGURATION, path, qosAlertConfig,
- WriteTransaction.CREATE_MISSING_PARENTS)), LOG, "Error writing to the config data store");
+ LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+ tx -> tx.mergeParentStructurePut(path,
+ qosAlertConfig)), LOG, "Error writing to the config data store");
}
private void pollDirectStatisticsForAllNodes() {
LOG.trace("Polling direct statistics from nodes");
- for (Entry<BigInteger, ConcurrentMap<String, QosAlertPortData>> entry : qosAlertDpnPortNumberMap.entrySet()) {
- BigInteger dpn = entry.getKey();
+ for (Entry<Uint64, ConcurrentMap<String, QosAlertPortData>> entry : qosAlertDpnPortNumberMap.entrySet()) {
+ Uint64 dpn = entry.getKey();
LOG.trace("Polling DPN ID {}", dpn);
GetNodeConnectorStatisticsInputBuilder input = new GetNodeConnectorStatisticsInputBuilder()
.setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
GetNodeConnectorStatisticsOutput nodeConnectorStatisticsOutput = rpcResult.getResult();
- List<NodeConnectorStatisticsAndPortNumberMap> nodeConnectorStatisticsAndPortNumberMapList =
- nodeConnectorStatisticsOutput.getNodeConnectorStatisticsAndPortNumberMap();
+ Map<NodeConnectorStatisticsAndPortNumberMapKey, NodeConnectorStatisticsAndPortNumberMap>
+ nodeConnectorStatisticsAndPortNumberMap =
+ nodeConnectorStatisticsOutput.nonnullNodeConnectorStatisticsAndPortNumberMap();
ConcurrentMap<String, QosAlertPortData> portDataMap = entry.getValue();
- for (NodeConnectorStatisticsAndPortNumberMap stats : nodeConnectorStatisticsAndPortNumberMapList) {
+ for (NodeConnectorStatisticsAndPortNumberMap stats
+ : nodeConnectorStatisticsAndPortNumberMap.values()) {
QosAlertPortData portData = portDataMap.get(stats.getNodeConnectorId().getValue());
if (portData != null) {
portData.updatePortStatistics(stats);
.forEach(QosAlertPortData::initPortData));
}
- private static class AlertThresholdSupplier implements Supplier<BigInteger> {
- private volatile BigInteger alertThreshold = BigInteger.valueOf(0);
+ private static class AlertThresholdSupplier implements Supplier<Uint64> {
+ private volatile Uint64 alertThreshold = Uint64.valueOf(0);
void set(short threshold) {
- alertThreshold = BigInteger.valueOf(threshold);
+ alertThreshold = Uint64.valueOf(threshold);
}
@Override
- public BigInteger get() {
+ public Uint64 get() {
return alertThreshold;
}
}
Code Review / netvirt.git / blobdiff